https://github.com/mahkoh/uapi

Unix API
https://github.com/mahkoh/uapi

ffi freebsd linux macos openbsd rust unix

Last synced: about 1 month ago
JSON representation

Unix API

• Host: GitHub
• URL: https://github.com/mahkoh/uapi
• Owner: mahkoh
• License: apache-2.0
• Created: 2020-05-27T17:53:48.000Z (over 4 years ago)
• Default Branch: master
• Last Pushed: 2024-03-12T11:38:04.000Z (8 months ago)
• Last Synced: 2024-09-26T20:56:48.329Z (about 2 months ago)
• Topics: ffi, freebsd, linux, macos, openbsd, rust, unix
• Language: Rust
• Homepage:
• Size: 221 KB
• Stars: 26
• Watchers: 2
• Forks: 1
• Open Issues: 3
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • License: LICENSE-APACHE

Awesome Lists containing this project

README

        
# Unix API

[![crates.io](https://img.shields.io/crates/v/uapi.svg)](http://crates.io/crates/uapi)

[![docs.rs](https://docs.rs/uapi/badge.svg)](http://docs.rs/uapi)

This crate contains safe wrappers around Unix APIs.

## Supported Targets

A target is supported if and only if the crate is tested against it via CI.

The following targets are supported:

- x86_64-unknown-linux-gnu (glibc >= 2.23)

- x86_64-unknown-linux-musl (musl >= 1.1.19)

- x86_64-unknown-freebsd (12)

- x86_64-unknown-openbsd (6.7)

- x86_64-apple-darwin (10.15)

This crate contains little architecture-specific code. Therefore, other

architectures (arm, aarch64, etc.) will probably also work.

## Future changes

This crate fully supports reading into uninitialized buffers but the API will

most likely change when the same functionality becomes stable in libstd.

## Comparison with other crates

### libc

This crate builds on the libc crate and uses its declarations of the raw OS APIs

if possible. This crate considers itself to be the next step up from libc: It

safely wraps the raw OS functions but does little beyond that. Integer

parameters are still integer parameters, functions operating on sockets accept

the socket file descriptor as a raw integer, there is no socket wrapper type,

etc.

At the same time, this crate provides the necessary tools to make it as easy to

use from Rust as the raw APIs are to use from C. For example, all of the

following just work:

```rust

open("./file", c::O_RDWR, 0);

open(b"./file", c::O_RDWR, 0);

open(CStr::from_ptr(p), c::O_RDWR, 0);

open(Path::new("./file"), c::O_RDWR, 0);

```

See the crate documentation for more details.

### nix

- **nix** uses a nested module structure. **uapi** exports all APIs in the crate

  root.

- **nix** I/O works on `[u8]`. **uapi** I/O works on `[MaybeUninit]`.

- **nix** uses enums and bitflags for integer/flag parameters. **uapi** uses

  plain integers.

- **nix** uses methods declared on wrapper types to expose APIs. **uapi** uses

  free functions unless doing so would be unsafe.

- **nix** uses enums for the values produced and consumed by certain generic OS

  APIs (e.g. control messages.) **uapi** uses generic functions that do not

  restrict the types that can be used.

## License

This project is licensed under either of

- Apache License, Version 2.0

- MIT License

at your option.