OpenE2K/libc-rs
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
2,589 Commits 2 Branches 0 Tags 10 MiB
Rust 98%
Shell 1%
Dockerfile 0.7%
CSS 0.3%
a2bf9f1d92
Go to file
bors a2bf9f1d92 Auto merge of #1246 - gnzlbg:rustfmt_style, r=gnzlbg 
Check style using rustfmt and reformat

A couple of recent PRs attempt to reformat the library using rustfmt and run into issues against libc's style checker because rustfmt default settings differ.

This PR uses the rustfmt-preview from nightly to check that the library is appropriately formatted, adding a style as similar to libc's style as possible, so that both style checkers work properly simultaneously.
2019-02-07 12:08:51 +00:00
ci Add an integration test for the cmsg(3) functions. 2019-02-05 08:26:17 -07:00
libc-test Check style using rustfmt and reformat 2019-02-07 11:13:38 +01:00
src Check style using rustfmt and reformat 2019-02-07 11:13:38 +01:00
.cirrus.yml Move FreeBSD testing from Travis/QEMU to Cirrus-CI 2018-12-07 13:11:09 -07:00
.gitignore Ignore the style executable used for testing 2019-02-02 16:32:00 -08:00
.travis.yml Check style using rustfmt and reformat 2019-02-07 11:13:38 +01:00
appveyor.yml
build.rs core::ffi::c_void is available since rustc 1.30 2018-11-21 16:43:24 +09:00
Cargo.toml Implement PartialEq,Eq for all types 2019-02-02 13:06:58 -08:00
LICENSE-APACHE
LICENSE-MIT
README.md Implement Hash for all types 2019-02-02 16:32:00 -08:00
rustfmt.toml Check style using rustfmt and reformat 2019-02-07 11:13:38 +01:00

README.md

libc

Raw FFI bindings to platform libraries like libc.

Build Status Build status Build Status Latest version Documentation License

Usage

First, add the following to your Cargo.toml:

[dependencies]
libc = "0.2"

Next, add this to your crate root:

extern crate libc;

Currently libc by default links to the standard library, but if you would instead like to use libc in a #![no_std] situation or crate you can request this via:

[dependencies]
libc = { version = "0.2", default-features = false }

By default libc uses private fields in structs in order to enforce a certain memory alignment on them. These structs can be hard to instantiate outside of libc. To make libc use #[repr(align(x))], instead of the private fields, activate the align feature. This requires Rust 1.25 or newer:

[dependencies]
libc = { version = "0.2", features = ["align"] }

All structs implemented by the libc crate have the Copy and Clone traits implemented for them. The additional traits of Debug, Eq, Hash, and PartialEq` can be enabled with the extra_traits feature (requires Rust 1.25 or newer):

[dependencies]
libc = { version = "0.2", features = ["extra_traits"] }

What is libc?

The primary purpose of this crate is to provide all of the definitions necessary to easily interoperate with C code (or "C-like" code) on each of the platforms that Rust supports. This includes type definitions (e.g. c_int), constants (e.g. EINVAL) as well as function headers (e.g. malloc).

This crate does not strive to have any form of compatibility across platforms, but rather it is simply a straight binding to the system libraries on the platform in question.

Public API

This crate exports all underlying platform types, functions, and constants under the crate root, so all items are accessible as libc::foo. The types and values of all the exported APIs match the platform that libc is compiled for.

More detailed information about the design of this library can be found in its associated RFC.

Adding an API

Want to use an API which currently isn't bound in libc? It's quite easy to add one!

The internal structure of this crate is designed to minimize the number of #[cfg] attributes in order to easily be able to add new items which apply to all platforms in the future. As a result, the crate is organized hierarchically based on platform. Each module has a number of #[cfg]'d children, but only one is ever actually compiled. Each module then reexports all the contents of its children.

This means that for each platform that libc supports, the path from a leaf module to the root will contain all bindings for the platform in question. Consequently, this indicates where an API should be added! Adding an API at a particular level in the hierarchy means that it is supported on all the child platforms of that level. For example, when adding a Unix API it should be added to src/unix/mod.rs, but when adding a Linux-only API it should be added to src/unix/notbsd/linux/mod.rs.

If you're not 100% sure at what level of the hierarchy an API should be added at, fear not! This crate has CI support which tests any binding against all platforms supported, so you'll see failures if an API is added at the wrong level or has different signatures across platforms.

With that in mind, the steps for adding a new API are:

  1. Determine where in the module hierarchy your API should be added.
  2. Add the API.
  3. Send a PR to this repo.
  4. Wait for CI to pass, fixing errors.
  5. Wait for a merge!

Test before you commit

We have two automated tests running on Travis:

  1. libc-test
  • cd libc-test && cargo test
  • Use the skip_*() functions in build.rs if you really need a workaround.
  1. Style checker
  • rustc ci/style.rs && ./style src

Releasing your change to crates.io

Now that you've done the amazing job of landing your new API or your new platform in this crate, the next step is to get that sweet, sweet usage from crates.io! The only next step is to bump the version of libc and then publish it. If you'd like to get a release out ASAP you can follow these steps:

  1. Update the version number in Cargo.toml, you'll just be bumping the patch version number.
  2. Run cargo update to regenerate the lockfile to encode your version bump in the lock file. You may pull in some other updated dependencies, that's ok.
  3. Send a PR to this repository. It should look like this, but it'd also be nice to fill out the description with a small rationale for the release (any rationale is ok though!)
  4. Once merged the release will be tagged and published by one of the libc crate maintainers.

Platforms and Documentation

The following platforms are currently tested and have documentation available:

Tested:

The following may be supported, but are not guaranteed to always work: