Initial GPUI Wayland terminal with Alacritty core

This commit is contained in:
2026-11-17 00:12:24 -08:00
commit de1d5776b6
26 changed files with 10792 additions and 0 deletions
+28
View File
@@ -0,0 +1,28 @@
use std::error::Error;
use std::fmt;
/// The error type returned on unsupported platforms.
///
/// On unsupported platforms, all operations will fail with an `io::Error` with
/// a kind `io::ErrorKind::Other` and an `UnsupportedPlatformError` error as the inner error.
/// While you *could* check the inner error, it's probably simpler just to check
/// `xattr::SUPPORTED_PLATFORM`.
///
/// This error mostly exists for pretty error messages.
#[derive(Copy, Clone, Debug)]
pub struct UnsupportedPlatformError;
impl Error for UnsupportedPlatformError {
fn description(&self) -> &str {
"unsupported platform"
}
}
impl fmt::Display for UnsupportedPlatformError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"unsupported platform, please file a bug at `https://github.com/Stebalien/xattr'"
)
}
}
+116
View File
@@ -0,0 +1,116 @@
//! A pure-Rust library to manage extended attributes.
//!
//! It provides support for manipulating extended attributes
//! (`xattrs`) on modern Unix filesystems. See the `attr(5)`
//! manpage for more details.
//!
//! An extension trait [`FileExt`](::FileExt) is provided to directly work with
//! standard `File` objects and file descriptors.
//!
//! NOTE: In case of a symlink as path argument, all methods
//! in this library work on the symlink itself **without**
//! de-referencing it.
//!
//! ```rust
//! let mut xattrs = xattr::list("/").unwrap().peekable();
//!
//! if xattrs.peek().is_none() {
//! println!("no xattr set on root");
//! return;
//! }
//!
//! println!("Extended attributes:");
//! for attr in xattrs {
//! println!(" - {:?}", attr);
//! }
//! ```
extern crate libc;
mod error;
mod sys;
mod util;
use std::ffi::OsStr;
use std::fs::File;
use std::io;
use std::os::unix::io::AsRawFd;
use std::path::Path;
pub use error::UnsupportedPlatformError;
pub use sys::{XAttrs, SUPPORTED_PLATFORM};
/// Get an extended attribute for the specified file.
pub fn get<N, P>(path: P, name: N) -> io::Result<Option<Vec<u8>>>
where
P: AsRef<Path>,
N: AsRef<OsStr>,
{
util::extract_noattr(sys::get_path(path.as_ref(), name.as_ref()))
}
/// Set an extended attribute on the specified file.
pub fn set<N, P>(path: P, name: N, value: &[u8]) -> io::Result<()>
where
P: AsRef<Path>,
N: AsRef<OsStr>,
{
sys::set_path(path.as_ref(), name.as_ref(), value)
}
/// Remove an extended attribute from the specified file.
pub fn remove<N, P>(path: P, name: N) -> io::Result<()>
where
P: AsRef<Path>,
N: AsRef<OsStr>,
{
sys::remove_path(path.as_ref(), name.as_ref())
}
/// List extended attributes attached to the specified file.
///
/// Note: this may not list *all* attributes. Speficially, it definitely won't list any trusted
/// attributes unless you are root and it may not list system attributes.
pub fn list<P>(path: P) -> io::Result<XAttrs>
where
P: AsRef<Path>,
{
sys::list_path(path.as_ref())
}
/// Extension trait to manipulate extended attributes on `File`-like objects.
pub trait FileExt: AsRawFd {
/// Get an extended attribute for the specified file.
fn get_xattr<N>(&self, name: N) -> io::Result<Option<Vec<u8>>>
where
N: AsRef<OsStr>,
{
util::extract_noattr(sys::get_fd(self.as_raw_fd(), name.as_ref()))
}
/// Set an extended attribute on the specified file.
fn set_xattr<N>(&self, name: N, value: &[u8]) -> io::Result<()>
where
N: AsRef<OsStr>,
{
sys::set_fd(self.as_raw_fd(), name.as_ref(), value)
}
/// Remove an extended attribute from the specified file.
fn remove_xattr<N>(&self, name: N) -> io::Result<()>
where
N: AsRef<OsStr>,
{
sys::remove_fd(self.as_raw_fd(), name.as_ref())
}
/// List extended attributes attached to the specified file.
///
/// Note: this may not list *all* attributes. Speficially, it definitely won't list any trusted
/// attributes unless you are root and it may not list system attributes.
fn list_xattr(&self) -> io::Result<XAttrs> {
sys::list_fd(self.as_raw_fd())
}
}
impl FileExt for File {}
+367
View File
@@ -0,0 +1,367 @@
//! FreeBSD and NetBSD xattr support.
use std::ffi::{CString, OsStr, OsString};
use std::io;
use std::mem;
use std::os::unix::ffi::{OsStrExt, OsStringExt};
use std::os::unix::io::RawFd;
use std::path::Path;
use libc::{c_char, c_int, c_void, size_t, ssize_t, EPERM};
use util::{allocate_loop, path_to_c};
const EXTATTR_NAMESPACE_USER_STRING: &'static str = "user";
const EXTATTR_NAMESPACE_SYSTEM_STRING: &'static str = "system";
const EXTATTR_NAMESPACE_NAMES: [&'static str; 3] = [
"empty",
EXTATTR_NAMESPACE_USER_STRING,
EXTATTR_NAMESPACE_SYSTEM_STRING,
];
const EXTATTR_NAMESPACE_USER: c_int = 1;
const EXTATTR_NAMESPACE_SYSTEM: c_int = 2;
extern "C" {
pub fn extattr_list_fd(
fd: c_int,
attrnamespace: c_int,
data: *mut c_void,
nbytes: size_t,
) -> ssize_t;
pub fn extattr_get_fd(
fd: c_int,
attrnamespace: c_int,
attrname: *const c_char,
data: *mut c_void,
nbytes: size_t,
) -> ssize_t;
pub fn extattr_delete_fd(fd: c_int, attrname: c_int, attrname: *const c_char) -> c_int;
pub fn extattr_set_fd(
fd: c_int,
attrname: c_int,
attrname: *const c_char,
data: *const c_void,
nbytes: size_t,
) -> ssize_t;
pub fn extattr_list_link(
path: *const c_char,
attrnamespace: c_int,
data: *mut c_void,
nbytes: size_t,
) -> ssize_t;
pub fn extattr_get_link(
path: *const c_char,
attrnamespace: c_int,
attrname: *const c_char,
data: *mut c_void,
nbytes: size_t,
) -> ssize_t;
pub fn extattr_delete_link(
path: *const c_char,
attrname: c_int,
attrname: *const c_char,
) -> c_int;
pub fn extattr_set_link(
path: *const c_char,
attrname: c_int,
attrname: *const c_char,
data: *const c_void,
nbytes: size_t,
) -> ssize_t;
}
/// An iterator over a set of extended attributes names.
pub struct XAttrs {
user_attrs: Box<[u8]>,
system_attrs: Box<[u8]>,
offset: usize,
}
impl Clone for XAttrs {
fn clone(&self) -> Self {
XAttrs {
user_attrs: Vec::from(&*self.user_attrs).into_boxed_slice(),
system_attrs: Vec::from(&*self.system_attrs).into_boxed_slice(),
offset: self.offset,
}
}
fn clone_from(&mut self, other: &XAttrs) {
self.offset = other.offset;
let mut data = mem::replace(&mut self.user_attrs, Box::new([])).into_vec();
data.extend(other.user_attrs.iter().cloned());
self.user_attrs = data.into_boxed_slice();
data = mem::replace(&mut self.system_attrs, Box::new([])).into_vec();
data.extend(other.system_attrs.iter().cloned());
self.system_attrs = data.into_boxed_slice();
}
}
impl Iterator for XAttrs {
type Item = OsString;
fn next(&mut self) -> Option<OsString> {
if self.user_attrs.is_empty() && self.system_attrs.is_empty() {
return None;
}
if self.offset == self.user_attrs.len() + self.system_attrs.len() {
return None;
}
let data = if self.offset < self.system_attrs.len() {
&self.system_attrs[self.offset..]
} else {
&self.user_attrs[self.offset - self.system_attrs.len()..]
};
let siz = data[0] as usize;
self.offset += siz + 1;
if self.offset < self.system_attrs.len() {
Some(prefix_namespace(
OsStr::from_bytes(&data[1..siz + 1]),
EXTATTR_NAMESPACE_SYSTEM,
))
} else {
Some(prefix_namespace(
OsStr::from_bytes(&data[1..siz + 1]),
EXTATTR_NAMESPACE_USER,
))
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
if self.user_attrs.len() + self.system_attrs.len() == self.offset {
(0, Some(0))
} else {
(1, None)
}
}
}
fn name_to_ns(name: &OsStr) -> io::Result<(c_int, CString)> {
let mut groups = name.as_bytes().splitn(2, |&b| b == b'.').take(2);
let nsname = match groups.next() {
Some(s) => s,
None => {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"couldn't find namespace",
))
}
};
let propname = match groups.next() {
Some(s) => s,
None => {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"couldn't find attribute",
))
}
};
let ns_int = match EXTATTR_NAMESPACE_NAMES
.iter()
.position(|&s| s.as_bytes() == nsname)
{
Some(i) => i,
None => {
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"no matching namespace",
))
}
};
Ok((ns_int as c_int, CString::new(propname)?))
}
fn prefix_namespace(attr: &OsStr, ns: c_int) -> OsString {
let nsname = EXTATTR_NAMESPACE_NAMES[ns as usize];
let mut v = Vec::with_capacity(nsname.as_bytes().len() + attr.as_bytes().len() + 1);
v.extend(nsname.as_bytes());
v.extend(".".as_bytes());
v.extend(attr.as_bytes());
OsString::from_vec(v)
}
pub fn get_fd(fd: RawFd, name: &OsStr) -> io::Result<Vec<u8>> {
let (ns, name) = name_to_ns(name)?;
unsafe {
allocate_loop(|buf, len| {
extattr_get_fd(fd, ns, name.as_ptr(), buf as *mut c_void, len as size_t)
})
}
}
pub fn set_fd(fd: RawFd, name: &OsStr, value: &[u8]) -> io::Result<()> {
let (ns, name) = name_to_ns(name)?;
let ret = unsafe {
extattr_set_fd(
fd,
ns,
name.as_ptr(),
value.as_ptr() as *const c_void,
value.len() as size_t,
)
};
if ret == -1 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn remove_fd(fd: RawFd, name: &OsStr) -> io::Result<()> {
let (ns, name) = name_to_ns(name)?;
let ret = unsafe { extattr_delete_fd(fd, ns, name.as_ptr()) };
if ret != 0 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn list_fd(fd: RawFd) -> io::Result<XAttrs> {
let sysvec = unsafe {
let res = allocate_loop(|buf, len| {
extattr_list_fd(
fd,
EXTATTR_NAMESPACE_SYSTEM,
buf as *mut c_void,
len as size_t,
)
});
// On FreeBSD, system attributes require root privileges to view. However,
// to mimic the behavior of listxattr in linux and osx, we need to query
// them anyway and return empty results if we get EPERM
match res {
Ok(v) => v,
Err(err) => {
if err.raw_os_error() == Some(EPERM) {
Vec::new()
} else {
return Err(err);
}
}
}
};
let uservec = unsafe {
let res = allocate_loop(|buf, len| {
extattr_list_fd(
fd,
EXTATTR_NAMESPACE_USER,
buf as *mut c_void,
len as size_t,
)
});
match res {
Ok(v) => v,
Err(err) => return Err(err),
}
};
Ok(XAttrs {
system_attrs: sysvec.into_boxed_slice(),
user_attrs: uservec.into_boxed_slice(),
offset: 0,
})
}
pub fn get_path(path: &Path, name: &OsStr) -> io::Result<Vec<u8>> {
let (ns, name) = name_to_ns(name)?;
let path = path_to_c(path)?;
unsafe {
allocate_loop(|buf, len| {
extattr_get_link(
path.as_ptr(),
ns,
name.as_ptr(),
buf as *mut c_void,
len as size_t,
)
})
}
}
pub fn set_path(path: &Path, name: &OsStr, value: &[u8]) -> io::Result<()> {
let (ns, name) = name_to_ns(name)?;
let path = path_to_c(path)?;
let ret = unsafe {
extattr_set_link(
path.as_ptr(),
ns,
name.as_ptr(),
value.as_ptr() as *const c_void,
value.len() as size_t,
)
};
if ret == -1 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn remove_path(path: &Path, name: &OsStr) -> io::Result<()> {
let (ns, name) = name_to_ns(name)?;
let path = path_to_c(path)?;
let ret = unsafe { extattr_delete_link(path.as_ptr(), ns, name.as_ptr()) };
if ret != 0 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn list_path(path: &Path) -> io::Result<XAttrs> {
let path = path_to_c(path)?;
let sysvec = unsafe {
let res = allocate_loop(|buf, len| {
extattr_list_link(
path.as_ptr(),
EXTATTR_NAMESPACE_SYSTEM,
buf as *mut c_void,
len as size_t,
)
});
// On FreeBSD, system attributes require root privileges to view. However,
// to mimic the behavior of listxattr in linux and osx, we need to query
// them anyway and return empty results if we get EPERM
match res {
Ok(v) => v,
Err(err) => {
if err.raw_os_error() == Some(EPERM) {
Vec::new()
} else {
return Err(err);
}
}
}
};
let uservec = unsafe {
let res = allocate_loop(|buf, len| {
extattr_list_link(
path.as_ptr(),
EXTATTR_NAMESPACE_USER,
buf as *mut c_void,
len as size_t,
)
});
match res {
Ok(v) => v,
Err(err) => return Err(err),
}
};
Ok(XAttrs {
system_attrs: sysvec.into_boxed_slice(),
user_attrs: uservec.into_boxed_slice(),
offset: 0,
})
}
+52
View File
@@ -0,0 +1,52 @@
use libc::{c_char, c_int, c_void, size_t, ssize_t};
extern "C" {
pub fn flistxattr(fd: c_int, buf: *mut c_char, size: size_t) -> ssize_t;
pub fn fgetxattr(fd: c_int, name: *const c_char, value: *mut c_void, size: size_t) -> ssize_t;
pub fn fremovexattr(fd: c_int, name: *const c_char) -> c_int;
pub fn llistxattr(path: *const c_char, buf: *mut c_char, size: size_t) -> ssize_t;
pub fn lgetxattr(
path: *const c_char,
name: *const c_char,
value: *mut c_void,
size: size_t,
) -> ssize_t;
pub fn lremovexattr(path: *const c_char, name: *const c_char) -> c_int;
}
pub unsafe fn fsetxattr(
fd: c_int,
name: *const c_char,
value: *const c_void,
size: size_t,
) -> ssize_t {
extern "C" {
fn fsetxattr(
fd: c_int,
name: *const c_char,
value: *const c_void,
size: size_t,
flags: c_int,
) -> ssize_t;
}
fsetxattr(fd, name, value, size, 0)
}
pub unsafe fn lsetxattr(
path: *const c_char,
name: *const c_char,
value: *const c_void,
size: size_t,
) -> ssize_t {
extern "C" {
fn lsetxattr(
path: *const c_char,
name: *const c_char,
value: *const c_void,
size: size_t,
flags: c_int,
) -> ssize_t;
}
lsetxattr(path, name, value, size, 0)
}
+120
View File
@@ -0,0 +1,120 @@
use libc::{c_char, c_int, c_void, size_t, ssize_t, uint32_t};
const XATTR_NOFOLLOW: c_int = 0x0001;
#[inline(always)]
pub unsafe fn fremovexattr(fd: c_int, name: *const c_char) -> c_int {
extern "C" {
fn fremovexattr(fd: c_int, name: *const c_char, options: c_int) -> c_int;
}
fremovexattr(fd, name, 0)
}
#[inline(always)]
pub unsafe fn fsetxattr(
fd: c_int,
name: *const c_char,
value: *const c_void,
size: size_t,
) -> ssize_t {
extern "C" {
fn fsetxattr(
fd: c_int,
name: *const c_char,
value: *const c_void,
size: size_t,
position: uint32_t,
options: c_int,
) -> ssize_t;
}
fsetxattr(fd, name, value, size, 0, 0)
}
#[inline(always)]
pub unsafe fn fgetxattr(
fd: c_int,
name: *const c_char,
value: *mut c_void,
size: size_t,
) -> ssize_t {
extern "C" {
fn fgetxattr(
fd: c_int,
name: *const c_char,
value: *mut c_void,
size: size_t,
position: uint32_t,
options: c_int,
) -> ssize_t;
}
fgetxattr(fd, name, value, size, 0, 0)
}
#[inline(always)]
pub unsafe fn flistxattr(fd: c_int, buf: *mut c_char, size: size_t) -> ssize_t {
extern "C" {
fn flistxattr(fd: c_int, buf: *mut c_char, size: size_t, options: c_int) -> ssize_t;
}
flistxattr(fd, buf, size, 0)
}
#[inline(always)]
pub unsafe fn lremovexattr(path: *const c_char, name: *const c_char) -> c_int {
extern "C" {
fn removexattr(path: *const c_char, name: *const c_char, options: c_int) -> c_int;
}
removexattr(path, name, XATTR_NOFOLLOW)
}
#[inline(always)]
pub unsafe fn lsetxattr(
path: *const c_char,
name: *const c_char,
value: *const c_void,
size: size_t,
) -> ssize_t {
extern "C" {
fn setxattr(
path: *const c_char,
name: *const c_char,
value: *const c_void,
size: size_t,
position: uint32_t,
options: c_int,
) -> ssize_t;
}
setxattr(path, name, value, size, 0, XATTR_NOFOLLOW)
}
#[inline(always)]
pub unsafe fn lgetxattr(
path: *const c_char,
name: *const c_char,
value: *mut c_void,
size: size_t,
) -> ssize_t {
extern "C" {
fn getxattr(
path: *const c_char,
name: *const c_char,
value: *mut c_void,
size: size_t,
position: uint32_t,
options: c_int,
) -> ssize_t;
}
getxattr(path, name, value, size, 0, XATTR_NOFOLLOW)
}
#[inline(always)]
pub unsafe fn llistxattr(path: *const c_char, buf: *mut c_char, size: size_t) -> ssize_t {
extern "C" {
fn listxattr(
path: *const c_char,
buf: *mut c_char,
size: size_t,
options: c_int,
) -> ssize_t;
}
listxattr(path, buf, size, XATTR_NOFOLLOW)
}
+168
View File
@@ -0,0 +1,168 @@
#[cfg(any(target_os = "linux", target_os = "android"))]
mod linux;
#[cfg(any(target_os = "linux", target_os = "android"))]
use self::linux::*;
#[cfg(target_os = "macos")]
mod macos;
#[cfg(target_os = "macos")]
use self::macos::*;
use std::ffi::{OsStr, OsString};
use std::io;
use std::mem;
use std::os::unix::ffi::OsStrExt;
use std::os::unix::io::RawFd;
use std::path::Path;
use libc::{c_char, c_void, size_t};
use util::{allocate_loop, name_to_c, path_to_c};
/// An iterator over a set of extended attributes names.
pub struct XAttrs {
data: Box<[u8]>,
offset: usize,
}
impl Clone for XAttrs {
fn clone(&self) -> Self {
XAttrs {
data: Vec::from(&*self.data).into_boxed_slice(),
offset: self.offset,
}
}
fn clone_from(&mut self, other: &XAttrs) {
self.offset = other.offset;
let mut data = mem::replace(&mut self.data, Box::new([])).into_vec();
data.extend(other.data.iter().cloned());
self.data = data.into_boxed_slice();
}
}
// Yes, I could avoid these allocations on linux/macos. However, if we ever want to be freebsd
// compatible, we need to be able to prepend the namespace to the extended attribute names.
// Furthermore, borrowing makes the API messy.
impl Iterator for XAttrs {
type Item = OsString;
fn next(&mut self) -> Option<OsString> {
let data = &self.data[self.offset..];
if data.is_empty() {
None
} else {
// always null terminated (unless empty).
let end = data.iter().position(|&b| b == 0u8).unwrap();
self.offset += end + 1;
Some(OsStr::from_bytes(&data[..end]).to_owned())
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
if self.data.len() == self.offset {
(0, Some(0))
} else {
(1, None)
}
}
}
pub fn get_fd(fd: RawFd, name: &OsStr) -> io::Result<Vec<u8>> {
let name = name_to_c(name)?;
unsafe {
allocate_loop(|buf, len| fgetxattr(fd, name.as_ptr(), buf as *mut c_void, len as size_t))
}
}
pub fn set_fd(fd: RawFd, name: &OsStr, value: &[u8]) -> io::Result<()> {
let name = name_to_c(name)?;
let ret = unsafe {
fsetxattr(
fd,
name.as_ptr(),
value.as_ptr() as *const c_void,
value.len() as size_t,
)
};
if ret != 0 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn remove_fd(fd: RawFd, name: &OsStr) -> io::Result<()> {
let name = name_to_c(name)?;
let ret = unsafe { fremovexattr(fd, name.as_ptr()) };
if ret != 0 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn list_fd(fd: RawFd) -> io::Result<XAttrs> {
let vec =
unsafe { allocate_loop(|buf, len| flistxattr(fd, buf as *mut c_char, len as size_t))? };
Ok(XAttrs {
data: vec.into_boxed_slice(),
offset: 0,
})
}
pub fn get_path(path: &Path, name: &OsStr) -> io::Result<Vec<u8>> {
let name = name_to_c(name)?;
let path = path_to_c(path)?;
unsafe {
allocate_loop(|buf, len| {
lgetxattr(
path.as_ptr(),
name.as_ptr(),
buf as *mut c_void,
len as size_t,
)
})
}
}
pub fn set_path(path: &Path, name: &OsStr, value: &[u8]) -> io::Result<()> {
let name = name_to_c(name)?;
let path = path_to_c(path)?;
let ret = unsafe {
lsetxattr(
path.as_ptr(),
name.as_ptr(),
value.as_ptr() as *const c_void,
value.len() as size_t,
)
};
if ret != 0 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn remove_path(path: &Path, name: &OsStr) -> io::Result<()> {
let name = name_to_c(name)?;
let path = path_to_c(path)?;
let ret = unsafe { lremovexattr(path.as_ptr(), name.as_ptr()) };
if ret != 0 {
Err(io::Error::last_os_error())
} else {
Ok(())
}
}
pub fn list_path(path: &Path) -> io::Result<XAttrs> {
let path = path_to_c(path)?;
let vec = unsafe {
allocate_loop(|buf, len| llistxattr(path.as_ptr(), buf as *mut c_char, len as size_t))?
};
Ok(XAttrs {
data: vec.into_boxed_slice(),
offset: 0,
})
}
+45
View File
@@ -0,0 +1,45 @@
macro_rules! platforms {
($($($platform:expr);* => $module:ident),*) => {
$(
#[cfg(any($(target_os = $platform),*))]
#[cfg_attr(not(any($(target_os = $platform),*)), allow(dead_code))]
mod $module;
#[cfg(any($(target_os = $platform),*))]
pub use self::$module::*;
#[cfg(all(any($(target_os = $platform),*), not(any(target_os = "linux", target_os = "android"))))]
pub const ENOATTR: ::libc::c_int = ::libc::ENOATTR;
)*
#[cfg(all(feature = "unsupported", not(any($($(target_os = $platform),*),*))))]
#[cfg_attr(any($($(target_os = $platform),*),*), allow(dead_code))]
mod unsupported;
#[cfg(all(feature = "unsupported", not(any($($(target_os = $platform),*),*))))]
pub use self::unsupported::*;
#[cfg(all(feature = "unsupported", not(any($($(target_os = $platform),*),*))))]
pub const ENOATTR: ::libc::c_int = 0;
/// A constant indicating whether or not the target platform is supported.
///
/// To make programmer's lives easier, this library builds on all platforms.
/// However, all function calls on unsupported platforms will return
/// `io::Error`s.
///
/// Note: If you would like compilation to simply fail on unsupported platforms,
/// turn of the `unsupported` feature.
pub const SUPPORTED_PLATFORM: bool = cfg!(any($($(target_os = $platform),*),*));
}
}
// Linux calls this error ENODATA. Recent libc versions no longer expose the
// deprecated ENOATTR alias; Darwin and BSD still use their native ENOATTR.
#[cfg(any(target_os = "linux", target_os = "android"))]
pub const ENOATTR: ::libc::c_int = ::libc::ENODATA;
platforms! {
"android"; "linux"; "macos" => linux_macos,
"freebsd"; "netbsd" => bsd
}
+77
View File
@@ -0,0 +1,77 @@
use std::ffi::{OsStr, OsString};
use std::io;
use std::os::unix::io::RawFd;
use std::path::Path;
use UnsupportedPlatformError;
/// An iterator over a set of extended attributes names.
#[derive(Clone, Debug)]
pub struct XAttrs;
impl Iterator for XAttrs {
type Item = OsString;
fn next(&mut self) -> Option<OsString> {
unreachable!("this should never exist")
}
fn size_hint(&self) -> (usize, Option<usize>) {
unreachable!("this should never exist")
}
}
pub fn get_fd(_: RawFd, _: &OsStr) -> io::Result<Vec<u8>> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn set_fd(_: RawFd, _: &OsStr, _: &[u8]) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn remove_fd(_: RawFd, _: &OsStr) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn list_fd(_: RawFd) -> io::Result<XAttrs> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn get_path(_: &Path, _: &OsStr) -> io::Result<Vec<u8>> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn set_path(_: &Path, _: &OsStr, _: &[u8]) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn remove_path(_: &Path, _: &OsStr) -> io::Result<()> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
pub fn list_path(_: &Path) -> io::Result<XAttrs> {
Err(io::Error::new(
io::ErrorKind::Other,
UnsupportedPlatformError,
))
}
+65
View File
@@ -0,0 +1,65 @@
use std::ffi::CString;
use std::ffi::OsStr;
use std::io;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;
use std::ptr;
use libc::{ssize_t, ERANGE};
// Need to use this one as libc only defines this on supported platforms. Given
// that we want to at least compile on unsupported platforms, we define this in
// our platform-specific modules.
use sys::ENOATTR;
#[allow(dead_code)]
pub fn name_to_c(name: &OsStr) -> io::Result<CString> {
match CString::new(name.as_bytes()) {
Ok(name) => Ok(name),
Err(_) => Err(io::Error::new(
io::ErrorKind::InvalidInput,
"name must not contain null bytes",
)),
}
}
pub fn path_to_c(path: &Path) -> io::Result<CString> {
match CString::new(path.as_os_str().as_bytes()) {
Ok(name) => Ok(name),
Err(_) => Err(io::Error::new(io::ErrorKind::NotFound, "file not found")),
}
}
pub fn extract_noattr(result: io::Result<Vec<u8>>) -> io::Result<Option<Vec<u8>>> {
result.map(Some).or_else(|e| match e.raw_os_error() {
Some(ENOATTR) => Ok(None),
_ => Err(e),
})
}
pub unsafe fn allocate_loop<F: FnMut(*mut u8, usize) -> ssize_t>(mut f: F) -> io::Result<Vec<u8>> {
let mut vec: Vec<u8> = Vec::new();
loop {
let ret = (f)(ptr::null_mut(), 0);
if ret < 0 {
return Err(io::Error::last_os_error());
} else if ret == 0 {
break;
}
vec.reserve_exact(ret as usize);
let ret = (f)(vec.as_mut_ptr(), vec.capacity());
if ret >= 0 {
vec.set_len(ret as usize);
break;
} else {
let error = io::Error::last_os_error();
if error.raw_os_error() == Some(ERANGE) {
continue;
}
return Err(error);
}
}
vec.shrink_to_fit();
Ok(vec)
}