#![cfg_attr(any(not(feature = "guard"), target_os = "ios"), allow(dead_code))]
#[cfg(target_os = "macos")]
use core::ffi::c_short;
use core::ffi::{c_char, c_int, c_long, c_uint, c_void};
pub(crate) type MachPort = u32;
pub(crate) type KernReturn = c_int;
pub(crate) type Uid = u32;
pub(crate) type Mode = u16;
pub(crate) type Time = i64;
pub(crate) type CfRef = *const c_void;
pub(crate) type CfIndex = isize;
pub(crate) type CfTypeId = usize;
#[cfg(target_os = "macos")]
pub(crate) type IoObject = MachPort;
pub(crate) const KERN_SUCCESS: KernReturn = 0;
pub(crate) const O_NOFOLLOW: c_int = 0x0100;
pub(crate) const ERANGE: c_int = 34;
pub(crate) const EPERM: c_int = 1;
pub(crate) const ENOENT: c_int = 2;
pub(crate) const ENOMEM: c_int = 12;
pub(crate) const EACCES: c_int = 13;
#[repr(C)]
pub(crate) struct Statfs {
pub(crate) bsize: u32,
pub(crate) iosize: i32,
pub(crate) blocks: u64,
pub(crate) bfree: u64,
pub(crate) bavail: u64,
pub(crate) files: u64,
pub(crate) ffree: u64,
pub(crate) fsid: [i32; 2],
pub(crate) owner: Uid,
pub(crate) ftype: u32,
pub(crate) flags: u32,
pub(crate) fssubtype: u32,
pub(crate) fstypename: [c_char; 16],
pub(crate) mntonname: [c_char; 1024],
pub(crate) mntfromname: [c_char; 1024],
pub(crate) flags_ext: u32,
pub(crate) reserved: [u32; 7],
}
layout!(Statfs, size = 2168, align = 8);
pub(crate) const MNT_RDONLY: u32 = 0x0000_0001;
pub(crate) const MNT_REMOVABLE: u32 = 0x0000_0200;
pub(crate) const MNT_LOCAL: u32 = 0x0000_1000;
pub(crate) const MNT_DONTBROWSE: u32 = 0x0010_0000;
pub(crate) const MNT_NOWAIT: c_int = 2;
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct Timeval {
pub(crate) sec: Time,
pub(crate) usec: i32,
}
layout!(Timeval, size = 16, align = 8);
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct Timespec {
pub(crate) sec: Time,
pub(crate) nsec: c_long,
}
layout!(Timespec, size = 16, align = 8);
#[derive(Default)]
#[repr(C)]
pub(crate) struct Rusage {
pub(crate) utime: Timeval,
pub(crate) stime: Timeval,
pub(crate) maxrss: c_long,
pub(crate) ixrss: c_long,
pub(crate) idrss: c_long,
pub(crate) isrss: c_long,
pub(crate) minflt: c_long,
pub(crate) majflt: c_long,
pub(crate) nswap: c_long,
pub(crate) inblock: c_long,
pub(crate) oublock: c_long,
pub(crate) msgsnd: c_long,
pub(crate) msgrcv: c_long,
pub(crate) nsignals: c_long,
pub(crate) nvcsw: c_long,
pub(crate) nivcsw: c_long,
}
layout!(Rusage, size = 144, align = 8);
pub(crate) const RUSAGE_SELF: c_int = 0;
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct Rlimit {
pub(crate) cur: u64,
pub(crate) max: u64,
}
layout!(Rlimit, size = 16, align = 8);
pub(crate) const RLIM_INFINITY: u64 = (1 << 63) - 1;
pub(crate) const RLIMIT_STACK: c_int = 3;
pub(crate) const RLIMIT_CORE: c_int = 4;
pub(crate) const RLIMIT_AS: c_int = 5;
pub(crate) const RLIMIT_NPROC: c_int = 7;
pub(crate) const RLIMIT_NOFILE: c_int = 8;
#[repr(C)]
pub(crate) struct Passwd {
pub(crate) name: *mut c_char,
pub(crate) passwd: *mut c_char,
pub(crate) uid: Uid,
pub(crate) gid: u32,
pub(crate) change: Time,
pub(crate) class: *mut c_char,
pub(crate) gecos: *mut c_char,
pub(crate) dir: *mut c_char,
pub(crate) shell: *mut c_char,
pub(crate) expire: Time,
}
layout!(Passwd, size = 72, align = 8);
#[repr(C)]
pub(crate) struct Tm {
pub(crate) sec: c_int,
pub(crate) min: c_int,
pub(crate) hour: c_int,
pub(crate) mday: c_int,
pub(crate) mon: c_int,
pub(crate) year: c_int,
pub(crate) wday: c_int,
pub(crate) yday: c_int,
pub(crate) isdst: c_int,
pub(crate) gmtoff: c_long,
pub(crate) zone: *mut c_char,
}
layout!(Tm, size = 56, align = 8);
#[repr(C)]
pub(crate) struct Sockaddr {
pub(crate) len: u8,
pub(crate) family: u8,
pub(crate) data: [c_char; 14],
}
layout!(Sockaddr, size = 16, align = 1);
#[repr(C)]
pub(crate) struct SockaddrIn {
pub(crate) len: u8,
pub(crate) family: u8,
pub(crate) port: u16,
pub(crate) addr: u32,
pub(crate) zero: [c_char; 8],
}
layout!(SockaddrIn, size = 16, align = 4);
#[repr(C)]
pub(crate) struct SockaddrIn6 {
pub(crate) len: u8,
pub(crate) family: u8,
pub(crate) port: u16,
pub(crate) flowinfo: u32,
pub(crate) addr: [u8; 16],
pub(crate) scope_id: u32,
}
layout!(SockaddrIn6, size = 28, align = 4);
#[repr(C)]
pub(crate) struct SockaddrDl {
pub(crate) len: u8,
pub(crate) family: u8,
pub(crate) index: u16,
pub(crate) ftype: u8,
pub(crate) nlen: u8,
pub(crate) alen: u8,
pub(crate) slen: u8,
pub(crate) data: [c_char; 12],
}
layout!(SockaddrDl, size = 20, align = 2);
#[repr(C)]
pub(crate) struct Ifaddrs {
pub(crate) next: *mut Ifaddrs,
pub(crate) name: *mut c_char,
pub(crate) flags: c_uint,
pub(crate) addr: *mut Sockaddr,
pub(crate) netmask: *mut Sockaddr,
pub(crate) dstaddr: *mut Sockaddr,
pub(crate) data: *mut c_void,
}
layout!(Ifaddrs, size = 56, align = 8);
pub(crate) const AF_INET: u8 = 2;
pub(crate) const AF_LINK: u8 = 18;
pub(crate) const AF_INET6: u8 = 30;
pub(crate) const IFF_UP: c_uint = 0x1;
pub(crate) const IFF_LOOPBACK: c_uint = 0x8;
pub(crate) const IFF_RUNNING: c_uint = 0x40;
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct Timeval32 {
pub(crate) sec: i32,
pub(crate) usec: i32,
}
layout!(Timeval32, size = 8, align = 4);
#[repr(C, packed(4))]
pub(crate) struct IfData64 {
pub(crate) ftype: u8,
pub(crate) typelen: u8,
pub(crate) physical: u8,
pub(crate) addrlen: u8,
pub(crate) hdrlen: u8,
pub(crate) recvquota: u8,
pub(crate) xmitquota: u8,
pub(crate) unused1: u8,
pub(crate) mtu: u32,
pub(crate) metric: u32,
pub(crate) baudrate: u64,
pub(crate) ipackets: u64,
pub(crate) ierrors: u64,
pub(crate) opackets: u64,
pub(crate) oerrors: u64,
pub(crate) collisions: u64,
pub(crate) ibytes: u64,
pub(crate) obytes: u64,
pub(crate) imcasts: u64,
pub(crate) omcasts: u64,
pub(crate) iqdrops: u64,
pub(crate) noproto: u64,
pub(crate) recvtiming: u32,
pub(crate) xmittiming: u32,
pub(crate) lastchange: Timeval32,
}
layout!(IfData64, size = 128, align = 4);
#[repr(C, packed(4))]
pub(crate) struct IfMsghdr2 {
pub(crate) msglen: u16,
pub(crate) version: u8,
pub(crate) mtype: u8,
pub(crate) addrs: c_int,
pub(crate) flags: c_int,
pub(crate) index: u16,
pub(crate) snd_len: c_int,
pub(crate) snd_maxlen: c_int,
pub(crate) snd_drops: c_int,
pub(crate) timer: c_int,
pub(crate) data: IfData64,
}
layout!(IfMsghdr2, size = 160, align = 4);
#[repr(C)]
pub(crate) struct RtMetrics {
pub(crate) locks: u32,
pub(crate) mtu: u32,
pub(crate) hopcount: u32,
pub(crate) expire: i32,
pub(crate) recvpipe: u32,
pub(crate) sendpipe: u32,
pub(crate) ssthresh: u32,
pub(crate) rtt: u32,
pub(crate) rttvar: u32,
pub(crate) pksent: u32,
pub(crate) state: u32,
pub(crate) filler: [u32; 3],
}
layout!(RtMetrics, size = 56, align = 4);
#[repr(C)]
pub(crate) struct RtMsghdr {
pub(crate) msglen: u16,
pub(crate) version: u8,
pub(crate) mtype: u8,
pub(crate) index: u16,
pub(crate) flags: c_int,
pub(crate) addrs: c_int,
pub(crate) pid: c_int,
pub(crate) seq: c_int,
pub(crate) errno: c_int,
pub(crate) used: c_int,
pub(crate) inits: u32,
pub(crate) rmx: RtMetrics,
}
layout!(RtMsghdr, size = 92, align = 4);
pub(crate) const CTL_NET: c_int = 4;
pub(crate) const PF_ROUTE: c_int = 17;
pub(crate) const NET_RT_DUMP: c_int = 1;
pub(crate) const NET_RT_IFLIST2: c_int = 6;
pub(crate) const RTM_GET: u8 = 0x4;
pub(crate) const RTM_IFINFO2: u8 = 0x12;
pub(crate) const RTM_VERSION: u8 = 5;
pub(crate) const RTA_DST: c_int = 0x1;
pub(crate) const RTA_GATEWAY: c_int = 0x2;
pub(crate) const RTA_NETMASK: c_int = 0x4;
pub(crate) const RTA_IFP: c_int = 0x10;
pub(crate) const RTF_UP: c_int = 0x1;
pub(crate) const RTF_HOST: c_int = 0x4;
pub(crate) const RTF_IFSCOPE: c_int = 0x0100_0000;
pub(crate) const IFT_ETHER: u8 = 0x06;
pub(crate) const IFT_PPP: u8 = 0x17;
pub(crate) const IFT_LOOP: u8 = 0x18;
pub(crate) const IFT_GIF: u8 = 0x37;
pub(crate) const IFT_STF: u8 = 0x39;
pub(crate) const IFT_IEEE80211: u8 = 0x47;
pub(crate) const IFT_TUNNEL: u8 = 0x83;
pub(crate) const IFT_L2VLAN: u8 = 0x87;
pub(crate) const IFT_IEEE8023ADLAG: u8 = 0x88;
pub(crate) const IFT_BRIDGE: u8 = 0xd1;
pub(crate) const IFT_CELLULAR: u8 = 0xff;
#[cfg(target_os = "macos")]
#[derive(Default)]
#[repr(C)]
pub(crate) struct Timex {
pub(crate) modes: c_uint,
pub(crate) offset: c_long,
pub(crate) freq: c_long,
pub(crate) maxerror: c_long,
pub(crate) esterror: c_long,
pub(crate) status: c_int,
pub(crate) constant: c_long,
pub(crate) precision: c_long,
pub(crate) tolerance: c_long,
pub(crate) ppsfreq: c_long,
pub(crate) jitter: c_long,
pub(crate) shift: c_int,
pub(crate) stabil: c_long,
pub(crate) jitcnt: c_long,
pub(crate) calcnt: c_long,
pub(crate) errcnt: c_long,
pub(crate) stbcnt: c_long,
}
#[cfg(target_os = "macos")]
layout!(Timex, size = 136, align = 8);
pub(crate) const STA_UNSYNC: c_int = 0x0040;
pub(crate) const TIME_ERROR: c_int = 5;
#[cfg(target_os = "macos")]
#[repr(C)]
pub(crate) struct Utmpx {
pub(crate) user: [c_char; 256],
pub(crate) id: [c_char; 4],
pub(crate) line: [c_char; 32],
pub(crate) pid: c_int,
pub(crate) utype: c_short,
pub(crate) tv: Timeval,
pub(crate) host: [c_char; 256],
pub(crate) pad: [u32; 16],
}
#[cfg(target_os = "macos")]
layout!(Utmpx, size = 640, align = 8);
#[cfg(target_os = "macos")]
pub(crate) const USER_PROCESS: c_short = 7;
#[cfg(target_os = "macos")]
#[derive(Default)]
#[repr(C)]
pub(crate) struct Attrlist {
pub(crate) bitmapcount: u16,
pub(crate) reserved: u16,
pub(crate) commonattr: u32,
pub(crate) volattr: u32,
pub(crate) dirattr: u32,
pub(crate) fileattr: u32,
pub(crate) forkattr: u32,
}
#[cfg(target_os = "macos")]
layout!(Attrlist, size = 24, align = 4);
#[cfg(target_os = "macos")]
pub(crate) const ATTR_BIT_MAP_COUNT: u16 = 5;
#[cfg(target_os = "macos")]
pub(crate) const ATTR_VOL_NAME: u32 = 0x0000_2000;
#[cfg(target_os = "macos")]
pub(crate) const ATTR_VOL_INFO: u32 = 0x8000_0000;
#[cfg(target_os = "macos")]
pub(crate) const FSOPT_NOFOLLOW: u32 = 0x1;
#[cfg(target_os = "ios")]
#[repr(C)]
pub(crate) struct Utsname {
pub(crate) sysname: [c_char; 256],
pub(crate) nodename: [c_char; 256],
pub(crate) release: [c_char; 256],
pub(crate) version: [c_char; 256],
pub(crate) machine: [c_char; 256],
}
#[cfg(target_os = "ios")]
layout!(Utsname, size = 1280, align = 1);
#[derive(Default)]
#[repr(C)]
pub(crate) struct XswUsage {
pub(crate) total: u64,
pub(crate) avail: u64,
pub(crate) used: u64,
pub(crate) pagesize: u32,
pub(crate) encrypted: i32,
}
layout!(XswUsage, size = 32, align = 8);
#[derive(Default)]
#[repr(C)]
pub(crate) struct VmStatistics64 {
pub(crate) free_count: u32,
pub(crate) active_count: u32,
pub(crate) inactive_count: u32,
pub(crate) wire_count: u32,
pub(crate) zero_fill_count: u64,
pub(crate) reactivations: u64,
pub(crate) pageins: u64,
pub(crate) pageouts: u64,
pub(crate) faults: u64,
pub(crate) cow_faults: u64,
pub(crate) lookups: u64,
pub(crate) hits: u64,
pub(crate) purges: u64,
pub(crate) purgeable_count: u32,
pub(crate) speculative_count: u32,
pub(crate) decompressions: u64,
pub(crate) compressions: u64,
pub(crate) swapins: u64,
pub(crate) swapouts: u64,
pub(crate) compressor_page_count: u32,
pub(crate) throttled_count: u32,
pub(crate) external_page_count: u32,
pub(crate) internal_page_count: u32,
pub(crate) total_uncompressed_pages_in_compressor: u64,
}
layout!(VmStatistics64, size = 152, align = 8);
pub(crate) const VM_STATISTICS64_COUNT: u32 =
(core::mem::size_of::<VmStatistics64>() / core::mem::size_of::<u32>()) as u32;
#[cfg(test)]
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct CpuLoadInfo {
pub(crate) ticks: [u32; CPU_STATE_MAX],
}
#[cfg(test)]
layout!(CpuLoadInfo, size = 16, align = 4);
pub(crate) const CPU_STATE_USER: usize = 0;
pub(crate) const CPU_STATE_SYSTEM: usize = 1;
pub(crate) const CPU_STATE_IDLE: usize = 2;
pub(crate) const CPU_STATE_NICE: usize = 3;
pub(crate) const CPU_STATE_MAX: usize = 4;
pub(crate) const HOST_VM_INFO64: c_int = 4;
pub(crate) const PROCESSOR_CPU_LOAD_INFO: c_int = 2;
pub(crate) const PROCESSOR_SET_LOAD_INFO: c_int = 4;
pub(crate) const MACH_TASK_BASIC_INFO: u32 = 20;
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct ProcessorSetLoadInfo {
pub(crate) task_count: c_int,
pub(crate) thread_count: c_int,
pub(crate) load_average: c_int,
pub(crate) mach_factor: c_int,
}
layout!(ProcessorSetLoadInfo, size = 16, align = 4);
pub(crate) const PROCESSOR_SET_LOAD_INFO_COUNT: u32 =
(core::mem::size_of::<ProcessorSetLoadInfo>() / core::mem::size_of::<u32>()) as u32;
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct MachTimebaseInfo {
pub(crate) numer: u32,
pub(crate) denom: u32,
}
layout!(MachTimebaseInfo, size = 8, align = 4);
#[derive(Clone, Copy, Default)]
#[repr(C)]
pub(crate) struct TimeValue {
pub(crate) seconds: i32,
pub(crate) microseconds: i32,
}
layout!(TimeValue, size = 8, align = 4);
#[derive(Default)]
#[repr(C, packed(4))]
pub(crate) struct MachTaskBasicInfo {
pub(crate) virtual_size: u64,
pub(crate) resident_size: u64,
pub(crate) resident_size_max: u64,
pub(crate) user_time: TimeValue,
pub(crate) system_time: TimeValue,
pub(crate) policy: c_int,
pub(crate) suspend_count: c_int,
}
layout!(MachTaskBasicInfo, size = 48, align = 4);
pub(crate) const MACH_TASK_BASIC_INFO_COUNT: u32 =
(core::mem::size_of::<MachTaskBasicInfo>() / core::mem::size_of::<u32>()) as u32;
#[cfg(target_os = "macos")]
#[derive(Default)]
#[repr(C)]
pub(crate) struct ProcTaskinfo {
pub(crate) virtual_size: u64,
pub(crate) resident_size: u64,
pub(crate) total_user: u64,
pub(crate) total_system: u64,
pub(crate) threads_user: u64,
pub(crate) threads_system: u64,
pub(crate) policy: i32,
pub(crate) faults: i32,
pub(crate) pageins: i32,
pub(crate) cow_faults: i32,
pub(crate) messages_sent: i32,
pub(crate) messages_received: i32,
pub(crate) syscalls_mach: i32,
pub(crate) syscalls_unix: i32,
pub(crate) csw: i32,
pub(crate) threadnum: i32,
pub(crate) numrunning: i32,
pub(crate) priority: i32,
}
#[cfg(target_os = "macos")]
layout!(ProcTaskinfo, size = 96, align = 8);
#[cfg(target_os = "macos")]
#[derive(Default)]
#[repr(C)]
pub(crate) struct ProcBsdinfo {
pub(crate) flags: u32,
pub(crate) status: u32,
pub(crate) xstatus: u32,
pub(crate) pid: u32,
pub(crate) ppid: u32,
pub(crate) uid: Uid,
pub(crate) gid: u32,
pub(crate) ruid: Uid,
pub(crate) rgid: u32,
pub(crate) svuid: Uid,
pub(crate) svgid: u32,
pub(crate) rfu_1: u32,
pub(crate) comm: [c_char; 16],
pub(crate) name: [c_char; 32],
pub(crate) nfiles: u32,
pub(crate) pgid: u32,
pub(crate) pjobc: u32,
pub(crate) e_tdev: u32,
pub(crate) e_tpgid: u32,
pub(crate) nice: i32,
pub(crate) start_tvsec: u64,
pub(crate) start_tvusec: u64,
}
#[cfg(target_os = "macos")]
layout!(ProcBsdinfo, size = 136, align = 8);
#[cfg(target_os = "macos")]
#[repr(C)]
pub(crate) struct ProcFdinfo {
pub(crate) fd: i32,
pub(crate) fdtype: u32,
}
#[cfg(target_os = "macos")]
layout!(ProcFdinfo, size = 8, align = 4);
#[cfg(target_os = "macos")]
#[derive(Default)]
#[repr(C)]
pub(crate) struct RusageInfoV2 {
pub(crate) uuid: [u8; 16],
pub(crate) user_time: u64,
pub(crate) system_time: u64,
pub(crate) pkg_idle_wkups: u64,
pub(crate) interrupt_wkups: u64,
pub(crate) pageins: u64,
pub(crate) wired_size: u64,
pub(crate) resident_size: u64,
pub(crate) phys_footprint: u64,
pub(crate) proc_start_abstime: u64,
pub(crate) proc_exit_abstime: u64,
pub(crate) child_user_time: u64,
pub(crate) child_system_time: u64,
pub(crate) child_pkg_idle_wkups: u64,
pub(crate) child_interrupt_wkups: u64,
pub(crate) child_pageins: u64,
pub(crate) child_elapsed_abstime: u64,
pub(crate) diskio_bytesread: u64,
pub(crate) diskio_byteswritten: u64,
}
#[cfg(target_os = "macos")]
layout!(RusageInfoV2, size = 160, align = 8);
#[cfg(target_os = "macos")]
pub(crate) const PROC_PIDLISTFDS: c_int = 1;
#[cfg(target_os = "macos")]
pub(crate) const PROC_PIDTBSDINFO: c_int = 3;
#[cfg(target_os = "macos")]
pub(crate) const PROC_PIDTASKINFO: c_int = 4;
#[cfg(target_os = "macos")]
pub(crate) const RUSAGE_INFO_V2: c_int = 2;
pub(crate) const CF_STRING_ENCODING_UTF8: u32 = 0x0800_0100;
pub(crate) const CF_NUMBER_SINT64_TYPE: CfIndex = 4;
#[cfg(target_os = "macos")]
pub(crate) const IO_MAIN_PORT_DEFAULT: MachPort = 0;
unsafe extern "C" {
pub(crate) fn sysctlbyname(
name: *const c_char,
oldp: *mut c_void,
oldlenp: *mut usize,
newp: *mut c_void,
newlen: usize,
) -> c_int;
pub(crate) fn sysctl(
name: *mut c_int,
namelen: c_uint,
oldp: *mut c_void,
oldlenp: *mut usize,
newp: *mut c_void,
newlen: usize,
) -> c_int;
pub(crate) safe static mach_task_self_: MachPort;
pub(crate) safe fn mach_host_self() -> MachPort;
pub(crate) fn mach_port_deallocate(task: MachPort, name: MachPort) -> KernReturn;
pub(crate) fn host_statistics64(
host: MachPort,
flavor: c_int,
info: *mut c_int,
count: *mut u32,
) -> KernReturn;
pub(crate) fn host_processor_info(
host: MachPort,
flavor: c_int,
processor_count: *mut u32,
info: *mut *mut c_int,
info_count: *mut u32,
) -> KernReturn;
pub(crate) fn task_info(
task: MachPort,
flavor: u32,
info: *mut c_int,
count: *mut u32,
) -> KernReturn;
pub(crate) fn vm_deallocate(task: MachPort, address: usize, size: usize) -> KernReturn;
pub(crate) fn host_page_size(host: MachPort, size: *mut usize) -> KernReturn;
pub(crate) fn processor_set_default(host: MachPort, set: *mut MachPort) -> KernReturn;
pub(crate) fn processor_set_statistics(
set: MachPort,
flavor: c_int,
info: *mut c_int,
count: *mut u32,
) -> KernReturn;
pub(crate) safe fn mach_continuous_time() -> u64;
pub(crate) fn mach_timebase_info(info: *mut MachTimebaseInfo) -> KernReturn;
pub(crate) safe fn geteuid() -> Uid;
pub(crate) safe fn getppid() -> c_int;
pub(crate) safe fn umask(mask: Mode) -> Mode;
pub(crate) fn getrlimit(resource: c_int, rlim: *mut Rlimit) -> c_int;
pub(crate) fn setrlimit(resource: c_int, rlim: *const Rlimit) -> c_int;
pub(crate) fn getrusage(who: c_int, usage: *mut Rusage) -> c_int;
pub(crate) fn getpwuid_r(
uid: Uid,
pwd: *mut Passwd,
buf: *mut c_char,
buflen: usize,
result: *mut *mut Passwd,
) -> c_int;
pub(crate) fn localtime_r(time: *const Time, result: *mut Tm) -> *mut Tm;
pub(crate) fn getloadavg(loadavg: *mut f64, nelem: c_int) -> c_int;
pub(crate) fn gethostname(name: *mut c_char, len: usize) -> c_int;
pub(crate) fn getifaddrs(ifap: *mut *mut Ifaddrs) -> c_int;
pub(crate) fn freeifaddrs(ifa: *mut Ifaddrs);
#[cfg_attr(
all(target_os = "macos", target_arch = "x86_64"),
link_name = "statfs$INODE64"
)]
pub(crate) fn statfs(path: *const c_char, buf: *mut Statfs) -> c_int;
}
#[cfg(target_os = "macos")]
unsafe extern "C" {
#[cfg_attr(target_arch = "x86_64", link_name = "getfsstat$INODE64")]
pub(crate) fn getfsstat(buf: *mut Statfs, bufsize: c_int, mode: c_int) -> c_int;
pub(crate) fn getattrlist(
path: *const c_char,
list: *mut c_void,
buf: *mut c_void,
size: usize,
options: u32,
) -> c_int;
pub(crate) fn ntp_adjtime(timex: *mut Timex) -> c_int;
pub(crate) fn setutxent();
pub(crate) fn getutxent() -> *mut Utmpx;
pub(crate) fn endutxent();
pub(crate) fn proc_pidinfo(
pid: c_int,
flavor: c_int,
arg: u64,
buffer: *mut c_void,
size: c_int,
) -> c_int;
pub(crate) fn proc_pid_rusage(pid: c_int, flavor: c_int, buffer: *mut *mut c_void) -> c_int;
pub(crate) fn proc_listallpids(buffer: *mut c_void, buffersize: c_int) -> c_int;
}
#[cfg(target_os = "ios")]
unsafe extern "C" {
pub(crate) fn uname(name: *mut Utsname) -> c_int;
}
#[link(name = "CoreFoundation", kind = "framework")]
unsafe extern "C" {
pub(crate) fn CFRelease(cf: CfRef);
pub(crate) fn CFGetTypeID(cf: CfRef) -> CfTypeId;
pub(crate) safe fn CFStringGetTypeID() -> CfTypeId;
pub(crate) safe fn CFNumberGetTypeID() -> CfTypeId;
pub(crate) safe fn CFBooleanGetTypeID() -> CfTypeId;
pub(crate) safe fn CFDictionaryGetTypeID() -> CfTypeId;
pub(crate) safe fn CFArrayGetTypeID() -> CfTypeId;
pub(crate) safe fn CFDataGetTypeID() -> CfTypeId;
pub(crate) fn CFStringCreateWithBytes(
allocator: CfRef,
bytes: *const u8,
length: CfIndex,
encoding: u32,
external_representation: u8,
) -> CfRef;
pub(crate) fn CFStringGetCString(
string: CfRef,
buffer: *mut c_char,
size: CfIndex,
encoding: u32,
) -> u8;
pub(crate) fn CFDictionaryGetValue(dictionary: CfRef, key: *const c_void) -> *const c_void;
pub(crate) fn CFArrayGetCount(array: CfRef) -> CfIndex;
pub(crate) fn CFArrayGetValueAtIndex(array: CfRef, index: CfIndex) -> *const c_void;
pub(crate) fn CFNumberGetValue(number: CfRef, kind: CfIndex, value: *mut c_void) -> u8;
pub(crate) fn CFBooleanGetValue(boolean: CfRef) -> u8;
pub(crate) fn CFDataGetLength(data: CfRef) -> CfIndex;
pub(crate) fn CFDataGetBytePtr(data: CfRef) -> *const u8;
pub(crate) fn CFLocaleCopyCurrent() -> CfRef;
pub(crate) fn CFLocaleGetIdentifier(locale: CfRef) -> CfRef;
}
#[cfg(target_os = "macos")]
#[link(name = "IOKit", kind = "framework")]
unsafe extern "C" {
pub(crate) fn IOServiceMatching(name: *const c_char) -> CfRef;
pub(crate) fn IOBSDNameMatching(
main_port: MachPort,
options: u32,
bsd_name: *const c_char,
) -> CfRef;
pub(crate) fn IOServiceGetMatchingService(main_port: MachPort, matching: CfRef) -> IoObject;
pub(crate) fn IOServiceGetMatchingServices(
main_port: MachPort,
matching: CfRef,
iterator: *mut IoObject,
) -> KernReturn;
pub(crate) fn IOIteratorNext(iterator: IoObject) -> IoObject;
pub(crate) fn IORegistryEntryFromPath(main_port: MachPort, path: *const c_char) -> IoObject;
pub(crate) fn IORegistryEntryCreateCFProperty(
entry: IoObject,
key: CfRef,
allocator: CfRef,
options: u32,
) -> CfRef;
pub(crate) fn IORegistryEntryGetParentEntry(
entry: IoObject,
plane: *const c_char,
parent: *mut IoObject,
) -> KernReturn;
pub(crate) fn IORegistryEntryGetChildEntry(
entry: IoObject,
plane: *const c_char,
child: *mut IoObject,
) -> KernReturn;
pub(crate) fn IOObjectRelease(object: IoObject) -> KernReturn;
pub(crate) fn IOPSCopyPowerSourcesInfo() -> CfRef;
pub(crate) fn IOPSCopyPowerSourcesList(blob: CfRef) -> CfRef;
pub(crate) fn IOPSGetPowerSourceDescription(blob: CfRef, source: CfRef) -> CfRef;
pub(crate) fn IOPSGetProvidingPowerSourceType(snapshot: CfRef) -> CfRef;
}
#[cfg(target_os = "macos")]
#[link(name = "SystemConfiguration", kind = "framework")]
unsafe extern "C" {
pub(crate) fn SCDynamicStoreCreate(
allocator: CfRef,
name: CfRef,
callout: *const c_void,
context: *mut c_void,
) -> CfRef;
pub(crate) fn SCDynamicStoreCopyValue(store: CfRef, key: CfRef) -> CfRef;
}
#[cfg(test)]
mod tests {
use super::*;
same_layout!(Statfs, libc::statfs,
bsize => f_bsize, iosize => f_iosize, blocks => f_blocks, bfree => f_bfree,
bavail => f_bavail, files => f_files, ffree => f_ffree, fsid => f_fsid,
owner => f_owner, ftype => f_type, flags => f_flags, fssubtype => f_fssubtype,
fstypename => f_fstypename, mntonname => f_mntonname,
mntfromname => f_mntfromname, flags_ext => f_flags_ext, reserved => f_reserved);
same_layout!(Timeval, libc::timeval, sec => tv_sec, usec => tv_usec);
same_layout!(Timespec, libc::timespec, sec => tv_sec, nsec => tv_nsec);
same_layout!(Rusage, libc::rusage,
utime => ru_utime, stime => ru_stime, maxrss => ru_maxrss, minflt => ru_minflt,
majflt => ru_majflt, nvcsw => ru_nvcsw, nivcsw => ru_nivcsw);
same_layout!(Rlimit, libc::rlimit, cur => rlim_cur, max => rlim_max);
same_layout!(Passwd, libc::passwd,
name => pw_name, passwd => pw_passwd, uid => pw_uid, gid => pw_gid,
change => pw_change, class => pw_class, gecos => pw_gecos, dir => pw_dir,
shell => pw_shell, expire => pw_expire);
same_layout!(Tm, libc::tm,
sec => tm_sec, isdst => tm_isdst, gmtoff => tm_gmtoff, zone => tm_zone);
same_layout!(Sockaddr, libc::sockaddr, len => sa_len, family => sa_family, data => sa_data);
same_layout!(SockaddrIn, libc::sockaddr_in,
len => sin_len, family => sin_family, port => sin_port, addr => sin_addr, zero => sin_zero);
same_layout!(SockaddrIn6, libc::sockaddr_in6,
len => sin6_len, family => sin6_family, port => sin6_port,
flowinfo => sin6_flowinfo, addr => sin6_addr, scope_id => sin6_scope_id);
same_layout!(SockaddrDl, libc::sockaddr_dl,
len => sdl_len, family => sdl_family, index => sdl_index, ftype => sdl_type,
nlen => sdl_nlen, alen => sdl_alen, slen => sdl_slen, data => sdl_data);
same_layout!(Ifaddrs, libc::ifaddrs,
next => ifa_next, name => ifa_name, flags => ifa_flags, addr => ifa_addr,
netmask => ifa_netmask, dstaddr => ifa_dstaddr, data => ifa_data);
same_layout!(IfData64, libc::if_data64,
ftype => ifi_type, mtu => ifi_mtu, baudrate => ifi_baudrate,
ipackets => ifi_ipackets, ierrors => ifi_ierrors, opackets => ifi_opackets,
oerrors => ifi_oerrors, ibytes => ifi_ibytes, obytes => ifi_obytes,
iqdrops => ifi_iqdrops, lastchange => ifi_lastchange);
same_layout!(IfMsghdr2, libc::if_msghdr2,
msglen => ifm_msglen, mtype => ifm_type, addrs => ifm_addrs, flags => ifm_flags,
index => ifm_index, snd_len => ifm_snd_len, timer => ifm_timer, data => ifm_data);
#[cfg(target_os = "macos")]
same_layout!(RtMetrics, libc::rt_metrics,
locks => rmx_locks, mtu => rmx_mtu, hopcount => rmx_hopcount, expire => rmx_expire,
recvpipe => rmx_recvpipe, sendpipe => rmx_sendpipe, ssthresh => rmx_ssthresh,
rtt => rmx_rtt, rttvar => rmx_rttvar, pksent => rmx_pksent, filler => rmx_filler);
#[cfg(target_os = "macos")]
same_layout!(RtMsghdr, libc::rt_msghdr,
msglen => rtm_msglen, version => rtm_version, mtype => rtm_type, index => rtm_index,
flags => rtm_flags, addrs => rtm_addrs, pid => rtm_pid, seq => rtm_seq,
errno => rtm_errno, used => rtm_use, inits => rtm_inits, rmx => rtm_rmx);
#[cfg(target_os = "macos")]
same_layout!(Timex, libc::timex,
modes => modes, offset => offset, freq => freq, maxerror => maxerror,
esterror => esterror, status => status, constant => constant, precision => precision,
tolerance => tolerance, ppsfreq => ppsfreq, jitter => jitter, shift => shift,
stabil => stabil, jitcnt => jitcnt, calcnt => calcnt, errcnt => errcnt, stbcnt => stbcnt);
#[cfg(target_os = "macos")]
same_layout!(Utmpx, libc::utmpx,
user => ut_user, id => ut_id, line => ut_line, pid => ut_pid, utype => ut_type,
tv => ut_tv, host => ut_host);
#[cfg(target_os = "macos")]
same_layout!(Attrlist, libc::attrlist,
bitmapcount => bitmapcount, reserved => reserved, commonattr => commonattr,
volattr => volattr, dirattr => dirattr, fileattr => fileattr, forkattr => forkattr);
#[cfg(target_os = "ios")]
same_layout!(Utsname, libc::utsname,
sysname => sysname, nodename => nodename, release => release, version => version,
machine => machine);
same_layout!(XswUsage, libc::xsw_usage,
total => xsu_total, avail => xsu_avail, used => xsu_used,
pagesize => xsu_pagesize, encrypted => xsu_encrypted);
same_layout!(prefix VmStatistics64, libc::vm_statistics64,
free_count => free_count, active_count => active_count,
inactive_count => inactive_count, wire_count => wire_count,
zero_fill_count => zero_fill_count, pageins => pageins, pageouts => pageouts,
purgeable_count => purgeable_count, speculative_count => speculative_count,
compressions => compressions, swapins => swapins, swapouts => swapouts,
compressor_page_count => compressor_page_count, throttled_count => throttled_count,
external_page_count => external_page_count, internal_page_count => internal_page_count,
total_uncompressed_pages_in_compressor => total_uncompressed_pages_in_compressor);
same_layout!(CpuLoadInfo, libc::processor_cpu_load_info, ticks => cpu_ticks);
same_layout!(TimeValue, libc::time_value_t, seconds => seconds, microseconds => microseconds);
same_layout!(MachTaskBasicInfo, libc::mach_task_basic_info,
virtual_size => virtual_size, resident_size => resident_size,
resident_size_max => resident_size_max, user_time => user_time,
system_time => system_time, policy => policy, suspend_count => suspend_count);
same_layout!(ProcessorSetLoadInfo, libc::processor_set_load_info,
task_count => task_count, thread_count => thread_count,
load_average => load_average, mach_factor => mach_factor);
#[allow(deprecated)]
mod deprecated_in_libc {
use super::*;
same_layout!(MachTimebaseInfo, libc::mach_timebase_info,
numer => numer, denom => denom);
}
#[cfg(target_os = "macos")]
same_layout!(ProcTaskinfo, libc::proc_taskinfo,
virtual_size => pti_virtual_size, resident_size => pti_resident_size,
total_user => pti_total_user, total_system => pti_total_system,
threadnum => pti_threadnum, priority => pti_priority);
#[cfg(target_os = "macos")]
same_layout!(ProcBsdinfo, libc::proc_bsdinfo,
pid => pbi_pid, ppid => pbi_ppid, uid => pbi_uid, comm => pbi_comm, name => pbi_name,
nfiles => pbi_nfiles, nice => pbi_nice, start_tvsec => pbi_start_tvsec,
start_tvusec => pbi_start_tvusec);
#[cfg(target_os = "macos")]
same_layout!(ProcFdinfo, libc::proc_fdinfo, fd => proc_fd, fdtype => proc_fdtype);
#[cfg(target_os = "macos")]
same_layout!(RusageInfoV2, libc::rusage_info_v2,
uuid => ri_uuid, user_time => ri_user_time, system_time => ri_system_time,
resident_size => ri_resident_size, phys_footprint => ri_phys_footprint,
diskio_byteswritten => ri_diskio_byteswritten);
#[allow(
clippy::unnecessary_cast,
reason = "libc's constant types differ between macOS and iOS"
)]
const _: () = {
assert!(KERN_SUCCESS == libc::KERN_SUCCESS);
assert!(O_NOFOLLOW == libc::O_NOFOLLOW);
assert!(ERANGE == libc::ERANGE);
assert!(EPERM == libc::EPERM);
assert!(ENOENT == libc::ENOENT);
assert!(ENOMEM == libc::ENOMEM);
assert!(EACCES == libc::EACCES);
assert!(PROCESSOR_SET_LOAD_INFO == libc::PROCESSOR_SET_LOAD_INFO);
assert!(MNT_RDONLY as i64 == libc::MNT_RDONLY as i64);
assert!(MNT_LOCAL as i64 == libc::MNT_LOCAL as i64);
assert!(MNT_NOWAIT == libc::MNT_NOWAIT);
assert!(RUSAGE_SELF == libc::RUSAGE_SELF);
assert!(RLIM_INFINITY == libc::RLIM_INFINITY as u64);
assert!(RLIMIT_STACK == libc::RLIMIT_STACK);
assert!(RLIMIT_CORE == libc::RLIMIT_CORE);
assert!(RLIMIT_AS == libc::RLIMIT_AS);
assert!(RLIMIT_NPROC == libc::RLIMIT_NPROC);
assert!(RLIMIT_NOFILE == libc::RLIMIT_NOFILE);
assert!(AF_INET as c_int == libc::AF_INET);
assert!(AF_INET6 as c_int == libc::AF_INET6);
assert!(AF_LINK as c_int == libc::AF_LINK);
assert!(IFF_UP as c_int == libc::IFF_UP);
assert!(IFF_LOOPBACK as c_int == libc::IFF_LOOPBACK);
assert!(IFF_RUNNING as c_int == libc::IFF_RUNNING);
assert!(CTL_NET == libc::CTL_NET);
assert!(PF_ROUTE == libc::PF_ROUTE);
assert!(NET_RT_IFLIST2 == libc::NET_RT_IFLIST2);
assert!(HOST_VM_INFO64 == libc::HOST_VM_INFO64);
assert!(PROCESSOR_CPU_LOAD_INFO == libc::PROCESSOR_CPU_LOAD_INFO);
assert!(MACH_TASK_BASIC_INFO == libc::MACH_TASK_BASIC_INFO);
assert!(MACH_TASK_BASIC_INFO_COUNT == libc::MACH_TASK_BASIC_INFO_COUNT);
assert!(CPU_STATE_USER as c_int == libc::CPU_STATE_USER);
assert!(CPU_STATE_SYSTEM as c_int == libc::CPU_STATE_SYSTEM);
assert!(CPU_STATE_IDLE as c_int == libc::CPU_STATE_IDLE);
assert!(CPU_STATE_NICE as c_int == libc::CPU_STATE_NICE);
assert!(CPU_STATE_MAX as c_int == libc::CPU_STATE_MAX);
};
#[cfg(target_os = "macos")]
const _: () = {
assert!(PROC_PIDLISTFDS == libc::PROC_PIDLISTFDS);
assert!(PROC_PIDTBSDINFO == libc::PROC_PIDTBSDINFO);
assert!(PROC_PIDTASKINFO == libc::PROC_PIDTASKINFO);
assert!(RUSAGE_INFO_V2 == libc::RUSAGE_INFO_V2);
assert!(RTM_IFINFO2 as c_int == libc::RTM_IFINFO2);
assert!(RTM_VERSION as c_int == libc::RTM_VERSION);
assert!(RTA_IFP == libc::RTA_IFP);
assert!(RTA_DST == libc::RTA_DST);
assert!(RTA_GATEWAY == libc::RTA_GATEWAY);
assert!(RTA_NETMASK == libc::RTA_NETMASK);
assert!(RTF_UP == libc::RTF_UP);
assert!(RTF_HOST == libc::RTF_HOST);
assert!(RTF_IFSCOPE == libc::RTF_IFSCOPE);
assert!(RTM_GET as c_int == libc::RTM_GET);
assert!(NET_RT_DUMP == libc::NET_RT_DUMP);
assert!(STA_UNSYNC == libc::STA_UNSYNC);
assert!(TIME_ERROR == libc::TIME_ERROR);
assert!(USER_PROCESS == libc::USER_PROCESS);
assert!(ATTR_BIT_MAP_COUNT == libc::ATTR_BIT_MAP_COUNT);
assert!(ATTR_VOL_NAME == libc::ATTR_VOL_NAME);
assert!(ATTR_VOL_INFO == libc::ATTR_VOL_INFO);
assert!(FSOPT_NOFOLLOW == libc::FSOPT_NOFOLLOW);
assert!(MNT_REMOVABLE as i64 == 2 * libc::MNT_EXPORTED as i64);
assert!(MNT_REMOVABLE as i64 * 2 == libc::MNT_QUARANTINE as i64);
assert!(MNT_DONTBROWSE as i64 == libc::MNT_DONTBROWSE as i64);
};
#[test]
fn test_ffi_apple_layouts_match_libc() {
let host = mach_host_self();
assert_ne!(host, 0);
let released = unsafe { mach_port_deallocate(mach_task_self_, host) };
assert_eq!(released, KERN_SUCCESS);
}
}