aboutsummaryrefslogtreecommitdiff
path: root/libc/src/unix/bsd/apple/mod.rs
diff options
context:
space:
mode:
Diffstat (limited to 'libc/src/unix/bsd/apple/mod.rs')
-rw-r--r--libc/src/unix/bsd/apple/mod.rs806
1 files changed, 693 insertions, 113 deletions
diff --git a/libc/src/unix/bsd/apple/mod.rs b/libc/src/unix/bsd/apple/mod.rs
index 837efff..9483e90 100644
--- a/libc/src/unix/bsd/apple/mod.rs
+++ b/libc/src/unix/bsd/apple/mod.rs
@@ -1,8 +1,6 @@
//! Apple (ios/darwin)-specific definitions
//!
//! This covers *-apple-* triples currently
-use dox::mem;
-
pub type c_char = i8;
pub type clock_t = c_ulong;
pub type time_t = c_long;
@@ -33,10 +31,21 @@ pub type posix_spawnattr_t = *mut ::c_void;
pub type posix_spawn_file_actions_t = *mut ::c_void;
pub type key_t = ::c_int;
pub type shmatt_t = ::c_ushort;
+pub type vm_size_t = ::uintptr_t;
+#[cfg_attr(feature = "extra_traits", derive(Debug))]
pub enum timezone {}
+impl ::Copy for timezone {}
+impl ::Clone for timezone {
+ fn clone(&self) -> timezone { *self }
+}
s! {
+ pub struct ip_mreq {
+ pub imr_multiaddr: in_addr,
+ pub imr_interface: in_addr,
+ }
+
pub struct aiocb {
pub aio_fildes: ::c_int,
pub aio_offset: ::off_t,
@@ -47,17 +56,6 @@ s! {
pub aio_lio_opcode: ::c_int
}
- pub struct utmpx {
- pub ut_user: [::c_char; _UTX_USERSIZE],
- pub ut_id: [::c_char; _UTX_IDSIZE],
- pub ut_line: [::c_char; _UTX_LINESIZE],
- pub ut_pid: ::pid_t,
- pub ut_type: ::c_short,
- pub ut_tv: ::timeval,
- pub ut_host: [::c_char; _UTX_HOSTSIZE],
- ut_pad: [::uint32_t; 16],
- }
-
pub struct glob_t {
pub gl_pathc: ::size_t,
__unused1: ::c_int,
@@ -74,14 +72,6 @@ s! {
__unused8: *mut ::c_void,
}
- pub struct sockaddr_storage {
- pub ss_len: u8,
- pub ss_family: ::sa_family_t,
- __ss_pad1: [u8; 6],
- __ss_align: i64,
- __ss_pad2: [u8; 112],
- }
-
pub struct addrinfo {
pub ai_flags: ::c_int,
pub ai_family: ::c_int,
@@ -123,40 +113,16 @@ s! {
pub st_qspare: [::int64_t; 2],
}
- pub struct dirent {
- pub d_ino: u64,
- pub d_seekoff: u64,
- pub d_reclen: u16,
- pub d_namlen: u16,
- pub d_type: u8,
- pub d_name: [::c_char; 1024],
- }
-
- pub struct pthread_mutex_t {
- __sig: ::c_long,
- __opaque: [u8; __PTHREAD_MUTEX_SIZE__],
- }
-
pub struct pthread_mutexattr_t {
__sig: ::c_long,
__opaque: [u8; 8],
}
- pub struct pthread_cond_t {
- __sig: ::c_long,
- __opaque: [u8; __PTHREAD_COND_SIZE__],
- }
-
pub struct pthread_condattr_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_CONDATTR_SIZE__],
}
- pub struct pthread_rwlock_t {
- __sig: ::c_long,
- __opaque: [u8; __PTHREAD_RWLOCK_SIZE__],
- }
-
pub struct pthread_rwlockattr_t {
__sig: ::c_long,
__opaque: [u8; __PTHREAD_RWLOCKATTR_SIZE__],
@@ -174,6 +140,7 @@ s! {
}
pub struct sigaction {
+ // FIXME: this field is actually a union
pub sa_sigaction: ::sighandler_t,
pub sa_mask: sigset_t,
pub sa_flags: ::c_int,
@@ -227,35 +194,6 @@ s! {
pub sin_zero: [::c_char; 8],
}
- pub struct statfs {
- pub f_bsize: ::uint32_t,
- pub f_iosize: ::int32_t,
- pub f_blocks: ::uint64_t,
- pub f_bfree: ::uint64_t,
- pub f_bavail: ::uint64_t,
- pub f_files: ::uint64_t,
- pub f_ffree: ::uint64_t,
- pub f_fsid: ::fsid_t,
- pub f_owner: ::uid_t,
- pub f_type: ::uint32_t,
- pub f_flags: ::uint32_t,
- pub f_fssubtype: ::uint32_t,
- pub f_fstypename: [::c_char; 16],
- pub f_mntonname: [::c_char; 1024],
- pub f_mntfromname: [::c_char; 1024],
- pub f_reserved: [::uint32_t; 8],
- }
-
- #[cfg_attr(feature = "rustc-dep-of-std", repr(packed(4)))]
- pub struct kevent {
- pub ident: ::uintptr_t,
- pub filter: ::int16_t,
- pub flags: ::uint16_t,
- pub fflags: ::uint32_t,
- pub data: ::intptr_t,
- pub udata: *mut ::c_void,
- }
-
pub struct kevent64_s {
pub ident: ::uint64_t,
pub filter: ::int16_t,
@@ -400,20 +338,6 @@ s! {
pub ptinfo: proc_taskinfo,
}
- pub struct proc_threadinfo {
- pub pth_user_time: u64,
- pub pth_system_time: u64,
- pub pth_cpu_usage: i32,
- pub pth_policy: i32,
- pub pth_run_state: i32,
- pub pth_flags: i32,
- pub pth_sleep_time: i32,
- pub pth_curpri: i32,
- pub pth_priority: i32,
- pub pth_maxpriority: i32,
- pub pth_name: [::c_char; MAXTHREADNAMESIZE],
- }
-
pub struct xsw_usage {
pub xsu_total: u64,
pub xsu_avail: u64,
@@ -544,7 +468,33 @@ s! {
pub sem_flg: ::c_short,
}
- #[cfg_attr(feature = "rustc-dep-of-std", repr(packed(4)))]
+ // sys/shm.h
+
+ pub struct arphdr {
+ pub ar_hrd: u16,
+ pub ar_pro: u16,
+ pub ar_hln: u8,
+ pub ar_pln: u8,
+ pub ar_op: u16,
+ }
+
+ pub struct in_addr {
+ pub s_addr: ::in_addr_t,
+ }
+}
+
+s_no_extra_traits!{
+ #[cfg_attr(libc_packedN, repr(packed(4)))]
+ pub struct kevent {
+ pub ident: ::uintptr_t,
+ pub filter: ::int16_t,
+ pub flags: ::uint16_t,
+ pub fflags: ::uint32_t,
+ pub data: ::intptr_t,
+ pub udata: *mut ::c_void,
+ }
+
+ #[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct semid_ds {
// Note the manpage shows different types than the system header.
pub sem_perm: ipc_perm,
@@ -557,15 +507,7 @@ s! {
pub sem_pad3: [::int32_t; 4],
}
- pub union semun {
- pub val: ::c_int,
- pub buf: *mut semid_ds,
- pub array: *mut ::c_ushort,
- }
-
- // sys/shm.h
-
- #[cfg_attr(feature = "rustc-dep-of-std", repr(packed(4)))]
+ #[cfg_attr(libc_packedN, repr(packed(4)))]
pub struct shmid_ds {
pub shm_perm: ipc_perm,
pub shm_segsz: ::size_t,
@@ -577,15 +519,630 @@ s! {
pub shm_ctime: ::time_t, // FIXME: 64-bit wrong align => wrong offset
// FIXME: 64-bit wrong align => wrong offset:
pub shm_internal: *mut ::c_void,
+ }
+ pub struct proc_threadinfo {
+ pub pth_user_time: u64,
+ pub pth_system_time: u64,
+ pub pth_cpu_usage: i32,
+ pub pth_policy: i32,
+ pub pth_run_state: i32,
+ pub pth_flags: i32,
+ pub pth_sleep_time: i32,
+ pub pth_curpri: i32,
+ pub pth_priority: i32,
+ pub pth_maxpriority: i32,
+ pub pth_name: [::c_char; MAXTHREADNAMESIZE],
}
- pub struct arphdr {
- pub ar_hrd: u16,
- pub ar_pro: u16,
- pub ar_hln: u8,
- pub ar_pln: u8,
- pub ar_op: u16,
+ pub struct statfs {
+ pub f_bsize: ::uint32_t,
+ pub f_iosize: ::int32_t,
+ pub f_blocks: ::uint64_t,
+ pub f_bfree: ::uint64_t,
+ pub f_bavail: ::uint64_t,
+ pub f_files: ::uint64_t,
+ pub f_ffree: ::uint64_t,
+ pub f_fsid: ::fsid_t,
+ pub f_owner: ::uid_t,
+ pub f_type: ::uint32_t,
+ pub f_flags: ::uint32_t,
+ pub f_fssubtype: ::uint32_t,
+ pub f_fstypename: [::c_char; 16],
+ pub f_mntonname: [::c_char; 1024],
+ pub f_mntfromname: [::c_char; 1024],
+ pub f_reserved: [::uint32_t; 8],
+ }
+
+ pub struct dirent {
+ pub d_ino: u64,
+ pub d_seekoff: u64,
+ pub d_reclen: u16,
+ pub d_namlen: u16,
+ pub d_type: u8,
+ pub d_name: [::c_char; 1024],
+ }
+
+ pub struct pthread_rwlock_t {
+ __sig: ::c_long,
+ __opaque: [u8; __PTHREAD_RWLOCK_SIZE__],
+ }
+
+ pub struct pthread_mutex_t {
+ __sig: ::c_long,
+ __opaque: [u8; __PTHREAD_MUTEX_SIZE__],
+ }
+
+ pub struct pthread_cond_t {
+ __sig: ::c_long,
+ __opaque: [u8; __PTHREAD_COND_SIZE__],
+ }
+
+ pub struct sockaddr_storage {
+ pub ss_len: u8,
+ pub ss_family: ::sa_family_t,
+ __ss_pad1: [u8; 6],
+ __ss_align: i64,
+ __ss_pad2: [u8; 112],
+ }
+
+ pub struct utmpx {
+ pub ut_user: [::c_char; _UTX_USERSIZE],
+ pub ut_id: [::c_char; _UTX_IDSIZE],
+ pub ut_line: [::c_char; _UTX_LINESIZE],
+ pub ut_pid: ::pid_t,
+ pub ut_type: ::c_short,
+ pub ut_tv: ::timeval,
+ pub ut_host: [::c_char; _UTX_HOSTSIZE],
+ ut_pad: [::uint32_t; 16],
+ }
+}
+
+cfg_if! {
+ if #[cfg(libc_union)] {
+ s_no_extra_traits! {
+ pub union semun {
+ pub val: ::c_int,
+ pub buf: *mut semid_ds,
+ pub array: *mut ::c_ushort,
+ }
+ }
+
+ cfg_if! {
+ if #[cfg(feature = "extra_traits")] {
+ impl PartialEq for semun {
+ fn eq(&self, other: &semun) -> bool {
+ unsafe { self.val == other.val }
+ }
+ }
+ impl Eq for semun {}
+ impl ::fmt::Debug for semun {
+ fn fmt(&self, f: &mut ::fmt::Formatter)
+ -> ::fmt::Result {
+ f.debug_struct("semun")
+ .field("val", unsafe { &self.val })
+ .finish()
+ }
+ }
+ impl ::hash::Hash for semun {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ unsafe { self.val.hash(state) };
+ }
+ }
+ }
+ }
+ }
+}
+
+cfg_if! {
+ if #[cfg(feature = "extra_traits")] {
+ impl PartialEq for kevent {
+ fn eq(&self, other: &kevent) -> bool {
+ self.ident == other.ident
+ && self.filter == other.filter
+ && self.flags == other.flags
+ && self.fflags == other.fflags
+ && self.data == other.data
+ && self.udata == other.udata
+ }
+ }
+ impl Eq for kevent {}
+ impl ::fmt::Debug for kevent {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ let ident = self.ident;
+ let filter = self.filter;
+ let flags = self.flags;
+ let fflags = self.fflags;
+ let data = self.data;
+ let udata = self.udata;
+ f.debug_struct("kevent")
+ .field("ident", &ident)
+ .field("filter", &filter)
+ .field("flags", &flags)
+ .field("fflags", &fflags)
+ .field("data", &data)
+ .field("udata", &udata)
+ .finish()
+ }
+ }
+ impl ::hash::Hash for kevent {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ let ident = self.ident;
+ let filter = self.filter;
+ let flags = self.flags;
+ let fflags = self.fflags;
+ let data = self.data;
+ let udata = self.udata;
+ ident.hash(state);
+ filter.hash(state);
+ flags.hash(state);
+ fflags.hash(state);
+ data.hash(state);
+ udata.hash(state);
+ }
+ }
+
+ impl PartialEq for semid_ds {
+ fn eq(&self, other: &semid_ds) -> bool {
+ let sem_perm = self.sem_perm;
+ let sem_pad3 = self.sem_pad3;
+ let other_sem_perm = other.sem_perm;
+ let other_sem_pad3 = other.sem_pad3;
+ sem_perm == other_sem_perm
+ && self.sem_base == other.sem_base
+ && self.sem_nsems == other.sem_nsems
+ && self.sem_otime == other.sem_otime
+ && self.sem_pad1 == other.sem_pad1
+ && self.sem_ctime == other.sem_ctime
+ && self.sem_pad2 == other.sem_pad2
+ && sem_pad3 == other_sem_pad3
+ }
+ }
+ impl Eq for semid_ds {}
+ impl ::fmt::Debug for semid_ds {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ let sem_perm = self.sem_perm;
+ let sem_base = self.sem_base;
+ let sem_nsems = self.sem_nsems;
+ let sem_otime = self.sem_otime;
+ let sem_pad1 = self.sem_pad1;
+ let sem_ctime = self.sem_ctime;
+ let sem_pad2 = self.sem_pad2;
+ let sem_pad3 = self.sem_pad3;
+ f.debug_struct("semid_ds")
+ .field("sem_perm", &sem_perm)
+ .field("sem_base", &sem_base)
+ .field("sem_nsems", &sem_nsems)
+ .field("sem_otime", &sem_otime)
+ .field("sem_pad1", &sem_pad1)
+ .field("sem_ctime", &sem_ctime)
+ .field("sem_pad2", &sem_pad2)
+ .field("sem_pad3", &sem_pad3)
+ .finish()
+ }
+ }
+ impl ::hash::Hash for semid_ds {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ let sem_perm = self.sem_perm;
+ let sem_base = self.sem_base;
+ let sem_nsems = self.sem_nsems;
+ let sem_otime = self.sem_otime;
+ let sem_pad1 = self.sem_pad1;
+ let sem_ctime = self.sem_ctime;
+ let sem_pad2 = self.sem_pad2;
+ let sem_pad3 = self.sem_pad3;
+ sem_perm.hash(state);
+ sem_base.hash(state);
+ sem_nsems.hash(state);
+ sem_otime.hash(state);
+ sem_pad1.hash(state);
+ sem_ctime.hash(state);
+ sem_pad2.hash(state);
+ sem_pad3.hash(state);
+ }
+ }
+
+ impl PartialEq for shmid_ds {
+ fn eq(&self, other: &shmid_ds) -> bool {
+ let shm_perm = self.shm_perm;
+ let other_shm_perm = other.shm_perm;
+ shm_perm == other_shm_perm
+ && self.shm_segsz == other.shm_segsz
+ && self.shm_lpid == other.shm_lpid
+ && self.shm_cpid == other.shm_cpid
+ && self.shm_nattch == other.shm_nattch
+ && self.shm_atime == other.shm_atime
+ && self.shm_dtime == other.shm_dtime
+ && self.shm_ctime == other.shm_ctime
+ && self.shm_internal == other.shm_internal
+ }
+ }
+ impl Eq for shmid_ds {}
+ impl ::fmt::Debug for shmid_ds {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ let shm_perm = self.shm_perm;
+ let shm_segsz = self.shm_segsz;
+ let shm_lpid = self.shm_lpid;
+ let shm_cpid = self.shm_cpid;
+ let shm_nattch = self.shm_nattch;
+ let shm_atime = self.shm_atime;
+ let shm_dtime = self.shm_dtime;
+ let shm_ctime = self.shm_ctime;
+ let shm_internal = self.shm_internal;
+ f.debug_struct("shmid_ds")
+ .field("shm_perm", &shm_perm)
+ .field("shm_segsz", &shm_segsz)
+ .field("shm_lpid", &shm_lpid)
+ .field("shm_cpid", &shm_cpid)
+ .field("shm_nattch", &shm_nattch)
+ .field("shm_atime", &shm_atime)
+ .field("shm_dtime", &shm_dtime)
+ .field("shm_ctime", &shm_ctime)
+ .field("shm_internal", &shm_internal)
+ .finish()
+ }
+ }
+ impl ::hash::Hash for shmid_ds {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ let shm_perm = self.shm_perm;
+ let shm_segsz = self.shm_segsz;
+ let shm_lpid = self.shm_lpid;
+ let shm_cpid = self.shm_cpid;
+ let shm_nattch = self.shm_nattch;
+ let shm_atime = self.shm_atime;
+ let shm_dtime = self.shm_dtime;
+ let shm_ctime = self.shm_ctime;
+ let shm_internal = self.shm_internal;
+ shm_perm.hash(state);
+ shm_segsz.hash(state);
+ shm_lpid.hash(state);
+ shm_cpid.hash(state);
+ shm_nattch.hash(state);
+ shm_atime.hash(state);
+ shm_dtime.hash(state);
+ shm_ctime.hash(state);
+ shm_internal.hash(state);
+ }
+ }
+
+ impl PartialEq for proc_threadinfo {
+ fn eq(&self, other: &proc_threadinfo) -> bool {
+ self.pth_user_time == other.pth_user_time
+ && self.pth_system_time == other.pth_system_time
+ && self.pth_cpu_usage == other.pth_cpu_usage
+ && self.pth_policy == other.pth_policy
+ && self.pth_run_state == other.pth_run_state
+ && self.pth_flags == other.pth_flags
+ && self.pth_sleep_time == other.pth_sleep_time
+ && self.pth_curpri == other.pth_curpri
+ && self.pth_priority == other.pth_priority
+ && self.pth_maxpriority == other.pth_maxpriority
+ && self.pth_name
+ .iter()
+ .zip(other.pth_name.iter())
+ .all(|(a,b)| a == b)
+ }
+ }
+ impl Eq for proc_threadinfo {}
+ impl ::fmt::Debug for proc_threadinfo {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("proc_threadinfo")
+ .field("pth_user_time", &self.pth_user_time)
+ .field("pth_system_time", &self.pth_system_time)
+ .field("pth_cpu_usage", &self.pth_cpu_usage)
+ .field("pth_policy", &self.pth_policy)
+ .field("pth_run_state", &self.pth_run_state)
+ .field("pth_flags", &self.pth_flags)
+ .field("pth_sleep_time", &self.pth_sleep_time)
+ .field("pth_curpri", &self.pth_curpri)
+ .field("pth_priority", &self.pth_priority)
+ .field("pth_maxpriority", &self.pth_maxpriority)
+ // FIXME: .field("pth_name", &self.pth_name)
+ .finish()
+ }
+ }
+ impl ::hash::Hash for proc_threadinfo {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.pth_user_time.hash(state);
+ self.pth_system_time.hash(state);
+ self.pth_cpu_usage.hash(state);
+ self.pth_policy.hash(state);
+ self.pth_run_state.hash(state);
+ self.pth_flags.hash(state);
+ self.pth_sleep_time.hash(state);
+ self.pth_curpri.hash(state);
+ self.pth_priority.hash(state);
+ self.pth_maxpriority.hash(state);
+ self.pth_name.hash(state);
+ }
+ }
+
+ impl PartialEq for statfs {
+ fn eq(&self, other: &statfs) -> bool {
+ self.f_bsize == other.f_bsize
+ && self.f_iosize == other.f_iosize
+ && self.f_blocks == other.f_blocks
+ && self.f_bfree == other.f_bfree
+ && self.f_bavail == other.f_bavail
+ && self.f_files == other.f_files
+ && self.f_ffree == other.f_ffree
+ && self.f_fsid == other.f_fsid
+ && self.f_owner == other.f_owner
+ && self.f_flags == other.f_flags
+ && self.f_fssubtype == other.f_fssubtype
+ && self.f_fstypename == other.f_fstypename
+ && self.f_type == other.f_type
+ && self
+ .f_mntonname
+ .iter()
+ .zip(other.f_mntonname.iter())
+ .all(|(a,b)| a == b)
+ && self
+ .f_mntfromname
+ .iter()
+ .zip(other.f_mntfromname.iter())
+ .all(|(a,b)| a == b)
+ && self.f_reserved == other.f_reserved
+ }
+ }
+
+ impl Eq for statfs {}
+ impl ::fmt::Debug for statfs {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("statfs")
+ .field("f_bsize", &self.f_bsize)
+ .field("f_iosize", &self.f_iosize)
+ .field("f_blocks", &self.f_blocks)
+ .field("f_bfree", &self.f_bfree)
+ .field("f_bavail", &self.f_bavail)
+ .field("f_files", &self.f_files)
+ .field("f_ffree", &self.f_ffree)
+ .field("f_fsid", &self.f_fsid)
+ .field("f_owner", &self.f_owner)
+ .field("f_flags", &self.f_flags)
+ .field("f_fssubtype", &self.f_fssubtype)
+ .field("f_fstypename", &self.f_fstypename)
+ .field("f_type", &self.f_type)
+ // FIXME: .field("f_mntonname", &self.f_mntonname)
+ // FIXME: .field("f_mntfromname", &self.f_mntfromname)
+ .field("f_reserved", &self.f_reserved)
+ .finish()
+ }
+ }
+
+ impl ::hash::Hash for statfs {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.f_bsize.hash(state);
+ self.f_iosize.hash(state);
+ self.f_blocks.hash(state);
+ self.f_bfree.hash(state);
+ self.f_bavail.hash(state);
+ self.f_files.hash(state);
+ self.f_ffree.hash(state);
+ self.f_fsid.hash(state);
+ self.f_owner.hash(state);
+ self.f_flags.hash(state);
+ self.f_fssubtype.hash(state);
+ self.f_fstypename.hash(state);
+ self.f_type.hash(state);
+ self.f_mntonname.hash(state);
+ self.f_mntfromname.hash(state);
+ self.f_reserved.hash(state);
+ }
+ }
+
+ impl PartialEq for dirent {
+ fn eq(&self, other: &dirent) -> bool {
+ self.d_ino == other.d_ino
+ && self.d_seekoff == other.d_seekoff
+ && self.d_reclen == other.d_reclen
+ && self.d_namlen == other.d_namlen
+ && self.d_type == other.d_type
+ && self
+ .d_name
+ .iter()
+ .zip(other.d_name.iter())
+ .all(|(a,b)| a == b)
+ }
+ }
+ impl Eq for dirent {}
+ impl ::fmt::Debug for dirent {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("dirent")
+ .field("d_ino", &self.d_ino)
+ .field("d_seekoff", &self.d_seekoff)
+ .field("d_reclen", &self.d_reclen)
+ .field("d_namlen", &self.d_namlen)
+ .field("d_type", &self.d_type)
+ // FIXME: .field("d_name", &self.d_name)
+ .finish()
+ }
+ }
+ impl ::hash::Hash for dirent {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.d_ino.hash(state);
+ self.d_seekoff.hash(state);
+ self.d_reclen.hash(state);
+ self.d_namlen.hash(state);
+ self.d_type.hash(state);
+ self.d_name.hash(state);
+ }
+ }
+ impl PartialEq for pthread_rwlock_t {
+ fn eq(&self, other: &pthread_rwlock_t) -> bool {
+ self.__sig == other.__sig
+ && self.
+ __opaque
+ .iter()
+ .zip(other.__opaque.iter())
+ .all(|(a,b)| a == b)
+ }
+ }
+ impl Eq for pthread_rwlock_t {}
+ impl ::fmt::Debug for pthread_rwlock_t {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("pthread_rwlock_t")
+ .field("__sig", &self.__sig)
+ // FIXME: .field("__opaque", &self.__opaque)
+ .finish()
+ }
+ }
+ impl ::hash::Hash for pthread_rwlock_t {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.__sig.hash(state);
+ self.__opaque.hash(state);
+ }
+ }
+
+ impl PartialEq for pthread_mutex_t {
+ fn eq(&self, other: &pthread_mutex_t) -> bool {
+ self.__sig == other.__sig
+ && self.
+ __opaque
+ .iter()
+ .zip(other.__opaque.iter())
+ .all(|(a,b)| a == b)
+ }
+ }
+
+ impl Eq for pthread_mutex_t {}
+
+ impl ::fmt::Debug for pthread_mutex_t {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("pthread_mutex_t")
+ .field("__sig", &self.__sig)
+ // FIXME: .field("__opaque", &self.__opaque)
+ .finish()
+ }
+ }
+
+ impl ::hash::Hash for pthread_mutex_t {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.__sig.hash(state);
+ self.__opaque.hash(state);
+ }
+ }
+
+ impl PartialEq for pthread_cond_t {
+ fn eq(&self, other: &pthread_cond_t) -> bool {
+ self.__sig == other.__sig
+ && self.
+ __opaque
+ .iter()
+ .zip(other.__opaque.iter())
+ .all(|(a,b)| a == b)
+ }
+ }
+
+ impl Eq for pthread_cond_t {}
+
+ impl ::fmt::Debug for pthread_cond_t {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("pthread_cond_t")
+ .field("__sig", &self.__sig)
+ // FIXME: .field("__opaque", &self.__opaque)
+ .finish()
+ }
+ }
+
+ impl ::hash::Hash for pthread_cond_t {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.__sig.hash(state);
+ self.__opaque.hash(state);
+ }
+ }
+
+ impl PartialEq for sockaddr_storage {
+ fn eq(&self, other: &sockaddr_storage) -> bool {
+ self.ss_len == other.ss_len
+ && self.ss_family == other.ss_family
+ && self
+ .__ss_pad1
+ .iter()
+ .zip(other.__ss_pad1.iter())
+ .all(|(a, b)| a == b)
+ && self.__ss_align == other.__ss_align
+ && self
+ .__ss_pad2
+ .iter()
+ .zip(other.__ss_pad2.iter())
+ .all(|(a, b)| a == b)
+ }
+ }
+
+ impl Eq for sockaddr_storage {}
+
+ impl ::fmt::Debug for sockaddr_storage {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("sockaddr_storage")
+ .field("ss_len", &self.ss_len)
+ .field("ss_family", &self.ss_family)
+ .field("__ss_pad1", &self.__ss_pad1)
+ .field("__ss_align", &self.__ss_align)
+ // FIXME: .field("__ss_pad2", &self.__ss_pad2)
+ .finish()
+ }
+ }
+
+ impl ::hash::Hash for sockaddr_storage {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.ss_len.hash(state);
+ self.ss_family.hash(state);
+ self.__ss_pad1.hash(state);
+ self.__ss_align.hash(state);
+ self.__ss_pad2.hash(state);
+ }
+ }
+
+ impl PartialEq for utmpx {
+ fn eq(&self, other: &utmpx) -> bool {
+ self.ut_user
+ .iter()
+ .zip(other.ut_user.iter())
+ .all(|(a,b)| a == b)
+ && self.ut_id == other.ut_id
+ && self.ut_line == other.ut_line
+ && self.ut_pid == other.ut_pid
+ && self.ut_type == other.ut_type
+ && self.ut_tv == other.ut_tv
+ && self
+ .ut_host
+ .iter()
+ .zip(other.ut_host.iter())
+ .all(|(a,b)| a == b)
+ && self.ut_pad == other.ut_pad
+ }
+ }
+
+ impl Eq for utmpx {}
+
+ impl ::fmt::Debug for utmpx {
+ fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+ f.debug_struct("utmpx")
+ // FIXME: .field("ut_user", &self.ut_user)
+ .field("ut_id", &self.ut_id)
+ .field("ut_line", &self.ut_line)
+ .field("ut_pid", &self.ut_pid)
+ .field("ut_type", &self.ut_type)
+ .field("ut_tv", &self.ut_tv)
+ // FIXME: .field("ut_host", &self.ut_host)
+ .field("ut_pad", &self.ut_pad)
+ .finish()
+ }
+ }
+
+ impl ::hash::Hash for utmpx {
+ fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+ self.ut_user.hash(state);
+ self.ut_id.hash(state);
+ self.ut_line.hash(state);
+ self.ut_pid.hash(state);
+ self.ut_type.hash(state);
+ self.ut_tv.hash(state);
+ self.ut_host.hash(state);
+ self.ut_pad.hash(state);
+ }
+ }
}
}
@@ -1862,12 +2419,14 @@ pub const NOTE_NONE: ::uint32_t = 0x00000080;
pub const NOTE_EXIT: ::uint32_t = 0x80000000;
pub const NOTE_FORK: ::uint32_t = 0x40000000;
pub const NOTE_EXEC: ::uint32_t = 0x20000000;
+#[deprecated(since="0.2.49", note="Deprecated since MacOSX 10.9")]
pub const NOTE_REAP: ::uint32_t = 0x10000000;
pub const NOTE_SIGNAL: ::uint32_t = 0x08000000;
pub const NOTE_EXITSTATUS: ::uint32_t = 0x04000000;
pub const NOTE_EXIT_DETAIL: ::uint32_t = 0x02000000;
pub const NOTE_PDATAMASK: ::uint32_t = 0x000fffff;
pub const NOTE_PCTRLMASK: ::uint32_t = 0xfff00000;
+#[deprecated(since="0.2.49", note="Deprecated since MacOSX 10.9")]
pub const NOTE_EXIT_REPARENTED: ::uint32_t = 0x00080000;
pub const NOTE_EXIT_DETAIL_MASK: ::uint32_t = 0x00070000;
pub const NOTE_EXIT_DECRYPTFAIL: ::uint32_t = 0x00010000;
@@ -2073,7 +2632,9 @@ pub const KERN_KDSETRTCDEC: ::c_int = 15;
pub const KERN_KDGETENTROPY: ::c_int = 16;
pub const KERN_KDWRITETR: ::c_int = 17;
pub const KERN_KDWRITEMAP: ::c_int = 18;
+#[deprecated(since = "0.2.49", note ="Removed in MacOSX 10.12")]
pub const KERN_KDENABLE_BG_TRACE: ::c_int = 19;
+#[deprecated(since = "0.2.49", note ="Removed in MacOSX 10.12")]
pub const KERN_KDDISABLE_BG_TRACE: ::c_int = 20;
pub const KERN_KDREADCURTHRMAP: ::c_int = 21;
pub const KERN_KDSET_TYPEFILTER: ::c_int = 22;
@@ -2384,9 +2945,18 @@ pub const SF_IMMUTABLE: ::c_uint = 0x00020000;
pub const SF_APPEND: ::c_uint = 0x00040000;
pub const UF_HIDDEN: ::c_uint = 0x00008000;
-fn __DARWIN_ALIGN32(p: usize) -> usize {
- const __DARWIN_ALIGNBYTES32: usize = mem::size_of::<u32>() - 1;
- p + __DARWIN_ALIGNBYTES32 & !__DARWIN_ALIGNBYTES32
+cfg_if! {
+ if #[cfg(libc_const_size_of)] {
+ fn __DARWIN_ALIGN32(p: usize) -> usize {
+ const __DARWIN_ALIGNBYTES32: usize = ::mem::size_of::<u32>() - 1;
+ p + __DARWIN_ALIGNBYTES32 & !__DARWIN_ALIGNBYTES32
+ }
+ } else {
+ fn __DARWIN_ALIGN32(p: usize) -> usize {
+ let __DARWIN_ALIGNBYTES32: usize = ::mem::size_of::<u32>() - 1;
+ p + __DARWIN_ALIGNBYTES32 & !__DARWIN_ALIGNBYTES32
+ }
+ }
}
f! {
@@ -2396,11 +2966,10 @@ f! {
return ::CMSG_FIRSTHDR(mhdr);
};
let cmsg_len = (*cmsg).cmsg_len as usize;
- let next = cmsg as usize + __DARWIN_ALIGN32(cmsg_len as usize)
- + __DARWIN_ALIGN32(mem::size_of::<::cmsghdr>());
+ let next = cmsg as usize + __DARWIN_ALIGN32(cmsg_len as usize);
let max = (*mhdr).msg_control as usize
+ (*mhdr).msg_controllen as usize;
- if next > max {
+ if next + __DARWIN_ALIGN32(::mem::size_of::<::cmsghdr>()) > max {
0 as *mut ::cmsghdr
} else {
next as *mut ::cmsghdr
@@ -2409,17 +2978,17 @@ f! {
pub fn CMSG_DATA(cmsg: *const ::cmsghdr) -> *mut ::c_uchar {
(cmsg as *mut ::c_uchar)
- .offset(__DARWIN_ALIGN32(mem::size_of::<::cmsghdr>()) as isize)
+ .offset(__DARWIN_ALIGN32(::mem::size_of::<::cmsghdr>()) as isize)
}
pub fn CMSG_SPACE(length: ::c_uint) -> ::c_uint {
- (__DARWIN_ALIGN32(mem::size_of::<::cmsghdr>())
+ (__DARWIN_ALIGN32(::mem::size_of::<::cmsghdr>())
+ __DARWIN_ALIGN32(length as usize))
as ::c_uint
}
pub fn CMSG_LEN(length: ::c_uint) -> ::c_uint {
- __DARWIN_ALIGN32(mem::size_of::<::cmsghdr>() + length as usize)
+ (__DARWIN_ALIGN32(::mem::size_of::<::cmsghdr>()) + length as usize)
as ::c_uint
}
@@ -2445,6 +3014,16 @@ f! {
}
extern {
+ #[deprecated(since="0.2.49", note="Deprecated in MacOSX 10.5")]
+ #[link_name = "daemon$1050"]
+ pub fn daemon(nochdir: ::c_int, noclose: ::c_int) -> ::c_int;
+ #[deprecated(since="0.2.49", note="Deprecated in MacOSX 10.10")]
+ pub fn sem_destroy(sem: *mut sem_t) -> ::c_int;
+ #[deprecated(since="0.2.49", note="Deprecated in MacOSX 10.10")]
+ pub fn sem_init(sem: *mut sem_t,
+ pshared: ::c_int,
+ value: ::c_uint)
+ -> ::c_int;
pub fn aio_read(aiocbp: *mut aiocb) -> ::c_int;
pub fn aio_write(aiocbp: *mut aiocb) -> ::c_int;
pub fn aio_fsync(op: ::c_int, aiocbp: *mut aiocb) -> ::c_int;
@@ -2589,6 +3168,7 @@ extern {
name: *mut ::c_char,
termp: *mut termios,
winp: *mut ::winsize) -> ::pid_t;
+ pub fn login_tty(fd: ::c_int) -> ::c_int;
pub fn duplocale(base: ::locale_t) -> ::locale_t;
pub fn freelocale(loc: ::locale_t) -> ::c_int;
pub fn localeconv_l(loc: ::locale_t) -> *mut lconv;
generated by cgit v1.2.3 (git 2.46.0) at 2024-11-26 11:01:06 +0000