Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 


Quelle  mod.rs   Sprache: unbekannt

 
pub type clock_t = u32;

pub type sa_family_t = u8;
pub type speed_t = ::c_uint;
pub type tcflag_t = ::c_uint;
pub type clockid_t = ::c_int;
pub type timer_t = ::c_int;
pub type key_t = ::c_uint;
pub type id_t = ::c_int;

pub type useconds_t = u32;
pub type dev_t = u32;
pub type socklen_t = u32;
pub type mode_t = u32;
pub type rlim64_t = u64;
pub type mqd_t = ::c_int;
pub type nfds_t = ::c_uint;
pub type idtype_t = ::c_uint;
pub type errno_t = ::c_int;
pub type rsize_t = c_ulong;

pub type Elf32_Half = u16;
pub type Elf32_Word = u32;
pub type Elf32_Off = u32;
pub type Elf32_Addr = u32;
pub type Elf32_Lword = u64;
pub type Elf32_Sword = i32;

pub type Elf64_Half = u16;
pub type Elf64_Word = u32;
pub type Elf64_Off = u64;
pub type Elf64_Addr = u64;
pub type Elf64_Xword = u64;
pub type Elf64_Sxword = i64;
pub type Elf64_Lword = u64;
pub type Elf64_Sword = i32;

pub type Elf32_Section = u16;
pub type Elf64_Section = u16;

pub type _Time32t = u32;

pub type pthread_t = ::c_int;
pub type regoff_t = ::ssize_t;

pub type nlink_t = u32;
pub type blksize_t = u32;
pub type suseconds_t = i32;

pub type ino_t = u64;
pub type off_t = i64;
pub type blkcnt_t = u64;
pub type msgqnum_t = u64;
pub type msglen_t = u64;
pub type fsblkcnt_t = u64;
pub type fsfilcnt_t = u64;
pub type rlim_t = u64;
pub type posix_spawn_file_actions_t = *mut ::c_void;
pub type posix_spawnattr_t = ::uintptr_t;

pub type pthread_mutex_t = ::sync_t;
pub type pthread_mutexattr_t = ::_sync_attr;
pub type pthread_cond_t = ::sync_t;
pub type pthread_condattr_t = ::_sync_attr;
pub type pthread_rwlockattr_t = ::_sync_attr;
pub type pthread_key_t = ::c_int;
pub type pthread_spinlock_t = sync_t;
pub type pthread_barrierattr_t = _sync_attr;
pub type sem_t = sync_t;

pub type nl_item = ::c_int;

#[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 dirent_extra {
        pub d_datalen: u16,
        pub d_type: u16,
        pub d_reserved: u32,
    }

    pub struct stat {
        pub st_ino: ::ino_t,
        pub st_size: ::off_t,
        pub st_dev: ::dev_t,
        pub st_rdev: ::dev_t,
        pub st_uid: ::uid_t,
        pub st_gid: ::gid_t,
        pub __old_st_mtime: ::_Time32t,
        pub __old_st_atime: ::_Time32t,
        pub __old_st_ctime: ::_Time32t,
        pub st_mode: ::mode_t,
        pub st_nlink: ::nlink_t,
        pub st_blocksize: ::blksize_t,
        pub st_nblocks: i32,
        pub st_blksize: ::blksize_t,
        pub st_blocks: ::blkcnt_t,
        pub st_mtim:    ::timespec,
        pub st_atim:    ::timespec,
        pub st_ctim:    ::timespec,
    }

    pub struct ip_mreq {
        pub imr_multiaddr: in_addr,
        pub imr_interface: in_addr,
    }

    #[repr(packed)]
    pub struct in_addr {
        pub s_addr: ::in_addr_t,
    }

    pub struct sockaddr {
        pub sa_len: u8,
        pub sa_family: sa_family_t,
        pub sa_data: [::c_char; 14],
    }

    pub struct sockaddr_in {
        pub sin_len: u8,
        pub sin_family: sa_family_t,
        pub sin_port: ::in_port_t,
        pub sin_addr: ::in_addr,
        pub sin_zero: [i8; 8],
    }

    pub struct sockaddr_in6 {
        pub sin6_len: u8,
        pub sin6_family: sa_family_t,
        pub sin6_port: ::in_port_t,
        pub sin6_flowinfo: u32,
        pub sin6_addr: ::in6_addr,
        pub sin6_scope_id: u32,
    }

    // The order of the `ai_addr` field in this struct is crucial
    // for converting between the Rust and C types.
    pub struct addrinfo {
        pub ai_flags: ::c_int,
        pub ai_family: ::c_int,
        pub ai_socktype: ::c_int,
        pub ai_protocol: ::c_int,
        pub ai_addrlen: socklen_t,
        pub ai_canonname: *mut c_char,
        pub ai_addr: *mut ::sockaddr,
        pub ai_next: *mut addrinfo,
    }

    pub struct fd_set {
        fds_bits: [::c_uint; 2 * FD_SETSIZE / ULONG_SIZE],
    }

    pub struct tm {
        pub tm_sec: ::c_int,
        pub tm_min: ::c_int,
        pub tm_hour: ::c_int,
        pub tm_mday: ::c_int,
        pub tm_mon: ::c_int,
        pub tm_year: ::c_int,
        pub tm_wday: ::c_int,
        pub tm_yday: ::c_int,
        pub tm_isdst: ::c_int,
        pub tm_gmtoff: ::c_long,
        pub tm_zone: *const ::c_char,
    }

    #[repr(align(8))]
    pub struct sched_param {
        pub sched_priority: ::c_int,
        pub sched_curpriority: ::c_int,
        pub reserved: [::c_int; 10],
    }

    #[repr(align(8))]
    pub struct __sched_param {
        pub __sched_priority: ::c_int,
        pub __sched_curpriority: ::c_int,
        pub reserved: [::c_int; 10],
    }

    pub struct Dl_info {
        pub dli_fname: *const ::c_char,
        pub dli_fbase: *mut ::c_void,
        pub dli_sname: *const ::c_char,
        pub dli_saddr: *mut ::c_void,
    }

    pub struct lconv {
        pub currency_symbol: *mut ::c_char,
        pub int_curr_symbol: *mut ::c_char,
        pub mon_decimal_point: *mut ::c_char,
        pub mon_grouping: *mut ::c_char,
        pub mon_thousands_sep: *mut ::c_char,
        pub negative_sign: *mut ::c_char,
        pub positive_sign: *mut ::c_char,
        pub frac_digits: ::c_char,
        pub int_frac_digits: ::c_char,
        pub n_cs_precedes: ::c_char,
        pub n_sep_by_space: ::c_char,
        pub n_sign_posn: ::c_char,
        pub p_cs_precedes: ::c_char,
        pub p_sep_by_space: ::c_char,
        pub p_sign_posn: ::c_char,

        pub int_n_cs_precedes: ::c_char,
        pub int_n_sep_by_space: ::c_char,
        pub int_n_sign_posn: ::c_char,
        pub int_p_cs_precedes: ::c_char,
        pub int_p_sep_by_space: ::c_char,
        pub int_p_sign_posn: ::c_char,

        pub decimal_point: *mut ::c_char,
        pub grouping: *mut ::c_char,
        pub thousands_sep: *mut ::c_char,

        pub _Frac_grouping: *mut ::c_char,
        pub _Frac_sep: *mut ::c_char,
        pub _False: *mut ::c_char,
        pub _True: *mut ::c_char,

        pub _No: *mut ::c_char,
        pub _Yes: *mut ::c_char,
        pub _Nostr: *mut ::c_char,
        pub _Yesstr: *mut ::c_char,
        pub _Reserved: [*mut ::c_char; 8],
        }

    pub struct in_pktinfo {
        pub ipi_addr: ::in_addr,
        pub ipi_ifindex: ::c_uint,
    }

    pub struct ifaddrs {
        pub ifa_next: *mut ifaddrs,
        pub ifa_name: *mut c_char,
        pub ifa_flags: ::c_uint,
        pub ifa_addr: *mut ::sockaddr,
        pub ifa_netmask: *mut ::sockaddr,
        pub ifa_dstaddr: *mut ::sockaddr,
        pub ifa_data: *mut ::c_void
    }

    pub struct arpreq {
        pub arp_pa: ::sockaddr,
        pub arp_ha: ::sockaddr,
        pub arp_flags: ::c_int,
    }

    #[repr(packed)]
    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 mmsghdr {
        pub msg_hdr: ::msghdr,
        pub msg_len: ::c_uint,
    }

    #[repr(align(8))]
    pub struct siginfo_t {
        pub si_signo: ::c_int,
        pub si_code: ::c_int,
        pub si_errno: ::c_int,
        __data: [u8; 36], // union
    }

    pub struct sigaction {
        pub sa_sigaction: ::sighandler_t,
        pub sa_flags: ::c_int,
        pub sa_mask: ::sigset_t,
    }

    pub struct _sync {
        _union: ::c_uint,
        __owner: ::c_uint,
    }
    pub struct rlimit64 {
        pub rlim_cur: rlim64_t,
        pub rlim_max: rlim64_t,
    }

    pub struct glob_t {
        pub gl_pathc: ::size_t,
        pub gl_matchc: ::c_int,
        pub gl_pathv: *mut *mut c_char,
        pub gl_offs: ::size_t,
        pub gl_flags: ::c_int,
        pub gl_errfunc: extern "C" fn(*const ::c_char, ::c_int) -> ::c_int,

        __unused1: *mut ::c_void,
        __unused2: *mut ::c_void,
        __unused3: *mut ::c_void,
        __unused4: *mut ::c_void,
        __unused5: *mut ::c_void,
    }

    pub struct passwd {
        pub pw_name: *mut ::c_char,
        pub pw_passwd: *mut ::c_char,
        pub pw_uid: ::uid_t,
        pub pw_gid: ::gid_t,
        pub pw_age: *mut ::c_char,
        pub pw_comment: *mut ::c_char,
        pub pw_gecos: *mut ::c_char,
        pub pw_dir: *mut ::c_char,
        pub pw_shell: *mut ::c_char,
    }

    pub struct if_nameindex {
        pub if_index: ::c_uint,
        pub if_name: *mut ::c_char,
    }

    pub struct sembuf {
        pub sem_num: ::c_ushort,
        pub sem_op: ::c_short,
        pub sem_flg: ::c_short,
    }

    pub struct Elf32_Ehdr {
        pub e_ident: [::c_uchar; 16],
        pub e_type: Elf32_Half,
        pub e_machine: Elf32_Half,
        pub e_version: Elf32_Word,
        pub e_entry: Elf32_Addr,
        pub e_phoff: Elf32_Off,
        pub e_shoff: Elf32_Off,
        pub e_flags: Elf32_Word,
        pub e_ehsize: Elf32_Half,
        pub e_phentsize: Elf32_Half,
        pub e_phnum: Elf32_Half,
        pub e_shentsize: Elf32_Half,
        pub e_shnum: Elf32_Half,
        pub e_shstrndx: Elf32_Half,
    }

    pub struct Elf64_Ehdr {
        pub e_ident: [::c_uchar; 16],
        pub e_type: Elf64_Half,
        pub e_machine: Elf64_Half,
        pub e_version: Elf64_Word,
        pub e_entry: Elf64_Addr,
        pub e_phoff: Elf64_Off,
        pub e_shoff: Elf64_Off,
        pub e_flags: Elf64_Word,
        pub e_ehsize: Elf64_Half,
        pub e_phentsize: Elf64_Half,
        pub e_phnum: Elf64_Half,
        pub e_shentsize: Elf64_Half,
        pub e_shnum: Elf64_Half,
        pub e_shstrndx: Elf64_Half,
    }

    pub struct Elf32_Sym {
        pub st_name: Elf32_Word,
        pub st_value: Elf32_Addr,
        pub st_size: Elf32_Word,
        pub st_info: ::c_uchar,
        pub st_other: ::c_uchar,
        pub st_shndx: Elf32_Section,
    }

    pub struct Elf64_Sym {
        pub st_name: Elf64_Word,
        pub st_info: ::c_uchar,
        pub st_other: ::c_uchar,
        pub st_shndx: Elf64_Section,
        pub st_value: Elf64_Addr,
        pub st_size: Elf64_Xword,
    }

    pub struct Elf32_Phdr {
        pub p_type: Elf32_Word,
        pub p_offset: Elf32_Off,
        pub p_vaddr: Elf32_Addr,
        pub p_paddr: Elf32_Addr,
        pub p_filesz: Elf32_Word,
        pub p_memsz: Elf32_Word,
        pub p_flags: Elf32_Word,
        pub p_align: Elf32_Word,
    }

    pub struct Elf64_Phdr {
        pub p_type: Elf64_Word,
        pub p_flags: Elf64_Word,
        pub p_offset: Elf64_Off,
        pub p_vaddr: Elf64_Addr,
        pub p_paddr: Elf64_Addr,
        pub p_filesz: Elf64_Xword,
        pub p_memsz: Elf64_Xword,
        pub p_align: Elf64_Xword,
    }

    pub struct Elf32_Shdr {
        pub sh_name: Elf32_Word,
        pub sh_type: Elf32_Word,
        pub sh_flags: Elf32_Word,
        pub sh_addr: Elf32_Addr,
        pub sh_offset: Elf32_Off,
        pub sh_size: Elf32_Word,
        pub sh_link: Elf32_Word,
        pub sh_info: Elf32_Word,
        pub sh_addralign: Elf32_Word,
        pub sh_entsize: Elf32_Word,
    }

    pub struct Elf64_Shdr {
        pub sh_name: Elf64_Word,
        pub sh_type: Elf64_Word,
        pub sh_flags: Elf64_Xword,
        pub sh_addr: Elf64_Addr,
        pub sh_offset: Elf64_Off,
        pub sh_size: Elf64_Xword,
        pub sh_link: Elf64_Word,
        pub sh_info: Elf64_Word,
        pub sh_addralign: Elf64_Xword,
        pub sh_entsize: Elf64_Xword,
    }

    pub struct in6_pktinfo {
        pub ipi6_addr: ::in6_addr,
        pub ipi6_ifindex: ::c_uint,
    }

    pub struct inotify_event {
        pub wd: ::c_int,
        pub mask: u32,
        pub cookie: u32,
        pub len: u32
    }

    pub struct regmatch_t {
        pub rm_so: regoff_t,
        pub rm_eo: regoff_t,
    }

    pub struct msghdr {
        pub msg_name: *mut ::c_void,
        pub msg_namelen: ::socklen_t,
        pub msg_iov: *mut ::iovec,
        pub msg_iovlen: ::c_int,
        pub msg_control: *mut ::c_void,
        pub msg_controllen: ::socklen_t,
        pub msg_flags: ::c_int,
    }

    pub struct cmsghdr {
        pub cmsg_len: ::socklen_t,
        pub cmsg_level: ::c_int,
        pub cmsg_type: ::c_int,
    }

    pub struct termios {
        pub c_iflag: ::tcflag_t,
        pub c_oflag: ::tcflag_t,
        pub c_cflag: ::tcflag_t,
        pub c_lflag: ::tcflag_t,
        pub c_cc: [::cc_t; ::NCCS],
        __reserved: [::c_uint; 3],
        pub c_ispeed: ::speed_t,
        pub c_ospeed: ::speed_t,
    }

    pub struct mallinfo {
        pub arena: ::c_int,
        pub ordblks: ::c_int,
        pub smblks: ::c_int,
        pub hblks: ::c_int,
        pub hblkhd: ::c_int,
        pub usmblks: ::c_int,
        pub fsmblks: ::c_int,
        pub uordblks: ::c_int,
        pub fordblks: ::c_int,
        pub keepcost: ::c_int,
    }

    pub struct flock {
        pub l_type: i16,
        pub l_whence: i16,
        pub l_zero1: i32,
        pub l_start: ::off_t,
        pub l_len: ::off_t,
        pub l_pid: ::pid_t,
        pub l_sysid: u32,
    }

    pub struct statvfs {
        pub f_bsize: ::c_ulong,
        pub f_frsize: ::c_ulong,
        pub f_blocks: ::fsblkcnt_t,
        pub f_bfree: ::fsblkcnt_t,
        pub f_bavail: ::fsblkcnt_t,
        pub f_files: ::fsfilcnt_t,
        pub f_ffree: ::fsfilcnt_t,
        pub f_favail: ::fsfilcnt_t,
        pub f_fsid: ::c_ulong,
        pub f_basetype: [::c_char; 16],
        pub f_flag: ::c_ulong,
        pub f_namemax: ::c_ulong,
        f_filler: [::c_uint; 21],
    }

    pub struct aiocb {
        pub aio_fildes: ::c_int,
        pub aio_reqprio: ::c_int,
        pub aio_offset: off_t,
        pub aio_buf: *mut ::c_void,
        pub aio_nbytes: ::size_t,
        pub aio_sigevent: ::sigevent,
        pub aio_lio_opcode: ::c_int,
        pub _aio_lio_state: *mut ::c_void,
        _aio_pad: [::c_int; 3],
        pub _aio_next: *mut ::aiocb,
        pub _aio_flag: ::c_uint,
        pub _aio_iotype: ::c_uint,
        pub _aio_result: ::ssize_t,
        pub _aio_error: ::c_uint,
        pub _aio_suspend: *mut ::c_void,
        pub _aio_plist: *mut ::c_void,
        pub _aio_policy: ::c_int,
        pub _aio_param: ::__sched_param,
    }

    pub struct pthread_attr_t {
        __data1: ::c_long,
        __data2: [u8; 96]
    }

    pub struct ipc_perm {
        pub uid: ::uid_t,
        pub gid: ::gid_t,
        pub cuid: ::uid_t,
        pub cgid: ::gid_t,
        pub mode: ::mode_t,
        pub seq: ::c_uint,
        pub key: ::key_t,
        _reserved: [::c_int; 4],
    }

    pub struct regex_t {
        re_magic: ::c_int,
        re_nsub: ::size_t,
        re_endp: *const ::c_char,
        re_g: *mut ::c_void,
    }

    pub struct _thread_attr {
        pub __flags: ::c_int,
        pub __stacksize: ::size_t,
        pub __stackaddr: *mut ::c_void,
        pub __exitfunc: ::Option<unsafe extern "C" fn(_fake: *mut ::c_void)>,
        pub __policy: ::c_int,
        pub __param: ::__sched_param,
        pub __guardsize: ::c_uint,
        pub __prealloc: ::c_uint,
        __spare: [::c_int; 2],
    }

    pub struct _sync_attr {
        pub __protocol: ::c_int,
        pub __flags: ::c_int,
        pub __prioceiling: ::c_int,
        pub __clockid: ::c_int,
        pub __count: ::c_int,
        __reserved: [::c_int; 3],
    }

    pub struct sockcred {
        pub sc_uid: ::uid_t,
        pub sc_euid: ::uid_t,
        pub sc_gid: ::gid_t,
        pub sc_egid: ::gid_t,
        pub sc_ngroups: ::c_int,
        pub sc_groups: [::gid_t; 1],
    }

    pub struct bpf_program {
        pub bf_len: ::c_uint,
        pub bf_insns: *mut ::bpf_insn,
    }

    pub struct bpf_stat {
        pub bs_recv: u64,
        pub bs_drop: u64,
        pub bs_capt: u64,
        bs_padding: [u64; 13],
    }

    pub struct bpf_version {
        pub bv_major: ::c_ushort,
        pub bv_minor: ::c_ushort,
    }

    pub struct bpf_hdr {
        pub bh_tstamp: ::timeval,
        pub bh_caplen: u32,
        pub bh_datalen: u32,
        pub bh_hdrlen: u16,
    }

    pub struct bpf_insn {
        pub code: u16,
        pub jt: ::c_uchar,
        pub jf: ::c_uchar,
        pub k: u32,
    }

    pub struct bpf_dltlist {
        pub bfl_len: ::c_uint,
        pub bfl_list: *mut ::c_uint,
    }

    pub struct unpcbid {
        pub unp_pid: ::pid_t,
        pub unp_euid: ::uid_t,
        pub unp_egid: ::gid_t,
    }

    pub struct dl_phdr_info {
        pub dlpi_addr: ::Elf64_Addr,
        pub dlpi_name: *const ::c_char,
        pub dlpi_phdr: *const ::Elf64_Phdr,
        pub dlpi_phnum: ::Elf64_Half,
    }

    #[repr(align(8))]
    pub struct ucontext_t {
        pub uc_link: *mut ucontext_t,
        pub uc_sigmask: ::sigset_t,
        pub uc_stack: stack_t,
        pub uc_mcontext: mcontext_t,
    }
}

s_no_extra_traits! {
    pub struct sockaddr_un {
        pub sun_len: u8,
        pub sun_family: sa_family_t,
        pub sun_path: [::c_char; 104]
    }

    pub struct sockaddr_storage {
        pub ss_len: u8,
        pub ss_family: sa_family_t,
        __ss_pad1: [::c_char; 6],
        __ss_align: i64,
        __ss_pad2: [::c_char; 112],
    }

    pub struct utsname {
        pub sysname: [::c_char; _SYSNAME_SIZE],
        pub nodename: [::c_char; _SYSNAME_SIZE],
        pub release: [::c_char; _SYSNAME_SIZE],
        pub version: [::c_char; _SYSNAME_SIZE],
        pub machine: [::c_char; _SYSNAME_SIZE],
    }

    pub struct sigevent {
        pub sigev_notify: ::c_int,
        pub __padding1: ::c_int,
        pub sigev_signo: ::c_int, // union
        pub __padding2: ::c_int,
        pub sigev_value: ::sigval,
        __sigev_un2: usize, // union

    }
    pub struct dirent {
        pub d_ino: ::ino_t,
        pub d_offset: ::off_t,
        pub d_reclen: ::c_short,
        pub d_namelen: ::c_short,
        pub d_name: [::c_char; 1], // flex array
    }

    pub struct sigset_t {
        __val: [u32; 2],
    }

    pub struct mq_attr {
        pub mq_maxmsg: ::c_long,
        pub mq_msgsize: ::c_long,
        pub mq_flags: ::c_long,
        pub mq_curmsgs: ::c_long,
        pub mq_sendwait: ::c_long,
        pub mq_recvwait: ::c_long,
    }

    pub struct msg {
        pub msg_next: *mut ::msg,
        pub msg_type: ::c_long,
        pub msg_ts: ::c_ushort,
        pub msg_spot: ::c_short,
        _pad: [u8; 4],
    }

    pub struct msqid_ds {
        pub msg_perm: ::ipc_perm,
        pub msg_first: *mut ::msg,
        pub msg_last: *mut ::msg,
        pub msg_cbytes: ::msglen_t,
        pub msg_qnum: ::msgqnum_t,
        pub msg_qbytes: ::msglen_t,
        pub msg_lspid: ::pid_t,
        pub msg_lrpid: ::pid_t,
        pub msg_stime: ::time_t,
        msg_pad1: ::c_long,
        pub msg_rtime: ::time_t,
        msg_pad2: ::c_long,
        pub msg_ctime: ::time_t,
        msg_pad3: ::c_long,
        msg_pad4: [::c_long; 4],
    }

    pub struct sockaddr_dl {
        pub sdl_len: ::c_uchar,
        pub sdl_family: ::sa_family_t,
        pub sdl_index: u16,
        pub sdl_type: ::c_uchar,
        pub sdl_nlen: ::c_uchar,
        pub sdl_alen: ::c_uchar,
        pub sdl_slen: ::c_uchar,
        pub sdl_data: [::c_char; 12],
    }

    pub struct sync_t {
        __u: ::c_uint,                     // union
        pub __owner: ::c_uint,
    }

    #[repr(align(4))]
    pub struct pthread_barrier_t {         // union
        __pad: [u8; 28],                   // union
    }

    pub struct pthread_rwlock_t {
        pub __active: ::c_int,
        pub __blockedwriters: ::c_int,
        pub __blockedreaders: ::c_int,
        pub __heavy: ::c_int,
        pub __lock: ::pthread_mutex_t,     // union
        pub __rcond: ::pthread_cond_t,     // union
        pub __wcond: ::pthread_cond_t,     // union
        pub __owner: ::c_uint,
        pub __spare: ::c_uint,
    }
}

cfg_if! {
    if #[cfg(feature = "extra_traits")] {
        // sigevent
        impl PartialEq for sigevent {
            fn eq(&self, other: &sigevent) -> bool {
                self.sigev_notify == other.sigev_notify
                    && self.sigev_signo == other.sigev_signo
                    && self.sigev_value == other.sigev_value
                    && self.__sigev_un2
                        == other.__sigev_un2
            }
        }
        impl Eq for sigevent {}
        impl ::fmt::Debug for sigevent {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sigevent")
                    .field("sigev_notify", &self.sigev_notify)
                    .field("sigev_signo", &self.sigev_signo)
                    .field("sigev_value", &self.sigev_value)
                    .field("__sigev_un2",
                        &self.__sigev_un2)
                    .finish()
            }
        }
        impl ::hash::Hash for sigevent {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sigev_notify.hash(state);
                self.sigev_signo.hash(state);
                self.sigev_value.hash(state);
                self.__sigev_un2.hash(state);
            }
        }

        impl PartialEq for sockaddr_un {
            fn eq(&self, other: &sockaddr_un) -> bool {
                self.sun_len == other.sun_len
                    && self.sun_family == other.sun_family
                    && self
                    .sun_path
                    .iter()
                    .zip(other.sun_path.iter())
                    .all(|(a,b)| a == b)
            }
        }
        impl Eq for sockaddr_un {}
        impl ::fmt::Debug for sockaddr_un {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sockaddr_un")
                    .field("sun_len", &self.sun_len)
                    .field("sun_family", &self.sun_family)
                    // FIXME: .field("sun_path", &self.sun_path)
                    .finish()
            }
        }

        impl ::hash::Hash for sockaddr_un {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sun_len.hash(state);
                self.sun_family.hash(state);
                self.sun_path.hash(state);
            }
        }

        // sigset_t
        impl PartialEq for sigset_t {
            fn eq(&self, other: &sigset_t) -> bool {
                self.__val == other.__val
            }
        }
        impl Eq for sigset_t {}
        impl ::fmt::Debug for sigset_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sigset_t")
                    .field("__val", &self.__val)
                    .finish()
            }
        }
        impl ::hash::Hash for sigset_t {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.__val.hash(state);
            }
        }

        // msg
        impl ::fmt::Debug for msg {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("msg")
                    .field("msg_next", &self.msg_next)
                    .field("msg_type", &self.msg_type)
                    .field("msg_ts", &self.msg_ts)
                    .field("msg_spot", &self.msg_spot)
                .finish()
            }
        }

        // msqid_ds
        impl ::fmt::Debug for msqid_ds {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("msqid_ds")
                    .field("msg_perm", &self.msg_perm)
                    .field("msg_first", &self.msg_first)
                    .field("msg_cbytes", &self.msg_cbytes)
                    .field("msg_qnum", &self.msg_qnum)
                    .field("msg_qbytes", &self.msg_qbytes)
                    .field("msg_lspid", &self.msg_lspid)
                    .field("msg_lrpid", &self.msg_lrpid)
                    .field("msg_stime", &self.msg_stime)
                    .field("msg_rtime", &self.msg_rtime)
                    .field("msg_ctime", &self.msg_ctime)
                    .finish()
            }
        }

        // sockaddr_dl
        impl ::fmt::Debug for sockaddr_dl {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sockaddr_dl")
                    .field("sdl_len", &self.sdl_len)
                    .field("sdl_family", &self.sdl_family)
                    .field("sdl_index", &self.sdl_index)
                    .field("sdl_type", &self.sdl_type)
                    .field("sdl_nlen", &self.sdl_nlen)
                    .field("sdl_alen", &self.sdl_alen)
                    .field("sdl_slen", &self.sdl_slen)
                    .field("sdl_data", &self.sdl_data)
                    .finish()
            }
        }
        impl PartialEq for sockaddr_dl {
            fn eq(&self, other: &sockaddr_dl) -> bool {
                self.sdl_len == other.sdl_len
                    && self.sdl_family == other.sdl_family
                    && self.sdl_index == other.sdl_index
                    && self.sdl_type == other.sdl_type
                    && self.sdl_nlen == other.sdl_nlen
                    && self.sdl_alen == other.sdl_alen
                    && self.sdl_slen == other.sdl_slen
                    && self
                    .sdl_data
                    .iter()
                    .zip(other.sdl_data.iter())
                    .all(|(a,b)| a == b)
            }
        }
        impl Eq for sockaddr_dl {}
        impl ::hash::Hash for sockaddr_dl {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sdl_len.hash(state);
                self.sdl_family.hash(state);
                self.sdl_index.hash(state);
                self.sdl_type.hash(state);
                self.sdl_nlen.hash(state);
                self.sdl_alen.hash(state);
                self.sdl_slen.hash(state);
                self.sdl_data.hash(state);
            }
        }

        // sync_t
        impl ::fmt::Debug for sync_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("sync_t")
                    .field("__owner", &self.__owner)
                    .field("__u", &self.__u)
                    .finish()
            }
        }

        // pthread_barrier_t
        impl ::fmt::Debug for pthread_barrier_t {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("pthread_barrier_t")
                    .field("__pad", &self.__pad)
                    .finish()
            }
        }

        // 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("__active", &self.__active)
                    .field("__blockedwriters", &self.__blockedwriters)
                    .field("__blockedreaders", &self.__blockedreaders)
                    .field("__heavy", &self.__heavy)
                    .field("__lock", &self.__lock)
                    .field("__rcond", &self.__rcond)
                    .field("__wcond", &self.__wcond)
                    .field("__owner", &self.__owner)
                    .field("__spare", &self.__spare)
                .finish()
            }
        }

        // syspage_entry
        impl ::fmt::Debug for syspage_entry {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("syspage_entry")
                    .field("size", &self.size)
                    .field("total_size", &self.total_size)
                    .field("type_", &self.type_)
                    .field("num_cpu", &self.num_cpu)
                    .field("system_private", &self.system_private)
                    .field("old_asinfo", &self.old_asinfo)
                    .field("hwinfo", &self.hwinfo)
                    .field("old_cpuinfo", &self.old_cpuinfo)
                    .field("old_cacheattr", &self.old_cacheattr)
                    .field("qtime", &self.qtime)
                    .field("callout", &self.callout)
                    .field("callin", &self.callin)
                    .field("typed_strings", &self.typed_strings)
                    .field("strings", &self.strings)
                    .field("old_intrinfo", &self.old_intrinfo)
                    .field("smp", &self.smp)
                    .field("pminfo", &self.pminfo)
                    .field("old_mdriver", &self.old_mdriver)
                    .field("new_asinfo", &self.new_asinfo)
                    .field("new_cpuinfo", &self.new_cpuinfo)
                    .field("new_cacheattr", &self.new_cacheattr)
                    .field("new_intrinfo", &self.new_intrinfo)
                    .field("new_mdriver", &self.new_mdriver)
                    .finish()
            }
        }

        impl PartialEq for utsname {
            fn eq(&self, other: &utsname) -> bool {
                self.sysname
                    .iter()
                    .zip(other.sysname.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .nodename
                    .iter()
                    .zip(other.nodename.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .release
                    .iter()
                    .zip(other.release.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .version
                    .iter()
                    .zip(other.version.iter())
                    .all(|(a,b)| a == b)
                    && self
                    .machine
                    .iter()
                    .zip(other.machine.iter())
                    .all(|(a,b)| a == b)
            }
        }

        impl Eq for utsname {}

        impl ::fmt::Debug for utsname {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("utsname")
                // FIXME: .field("sysname", &self.sysname)
                // FIXME: .field("nodename", &self.nodename)
                // FIXME: .field("release", &self.release)
                // FIXME: .field("version", &self.version)
                // FIXME: .field("machine", &self.machine)
                    .finish()
            }
        }

        impl ::hash::Hash for utsname {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.sysname.hash(state);
                self.nodename.hash(state);
                self.release.hash(state);
                self.version.hash(state);
                self.machine.hash(state);
            }
        }

        impl PartialEq for mq_attr {
            fn eq(&self, other: &mq_attr) -> bool {
                self.mq_maxmsg == other.mq_maxmsg &&
                self.mq_msgsize == other.mq_msgsize &&
                self.mq_flags == other.mq_flags &&
                self.mq_curmsgs == other.mq_curmsgs &&
                self.mq_msgsize == other.mq_msgsize &&
                self.mq_sendwait == other.mq_sendwait &&
                self.mq_recvwait == other.mq_recvwait
            }
        }

        impl Eq for mq_attr {}

        impl ::fmt::Debug for mq_attr {
            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                f.debug_struct("mq_attr")
                    .field("mq_maxmsg", &self.mq_maxmsg)
                    .field("mq_msgsize", &self.mq_msgsize)
                    .field("mq_flags", &self.mq_flags)
                    .field("mq_curmsgs", &self.mq_curmsgs)
                    .field("mq_msgsize", &self.mq_msgsize)
                    .field("mq_sendwait", &self.mq_sendwait)
                    .field("mq_recvwait", &self.mq_recvwait)
                    .finish()
            }
        }
        impl ::hash::Hash for mq_attr {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.mq_maxmsg.hash(state);
                self.mq_msgsize.hash(state);
                self.mq_flags.hash(state);
                self.mq_curmsgs.hash(state);
                self.mq_sendwait.hash(state);
                self.mq_recvwait.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 == other.__ss_pad1
                    && 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 dirent {
            fn eq(&self, other: &dirent) -> bool {
                self.d_ino == other.d_ino
                    && self.d_offset == other.d_offset
                    && self.d_reclen == other.d_reclen
                    && self.d_namelen == other.d_namelen
                    && self
                    .d_name[..self.d_namelen as _]
                    .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_offset", &self.d_offset)
                    .field("d_reclen", &self.d_reclen)
                    .field("d_namelen", &self.d_namelen)
                    .field("d_name", &&self.d_name[..self.d_namelen as _])
                    .finish()
            }
        }

        impl ::hash::Hash for dirent {
            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                self.d_ino.hash(state);
                self.d_offset.hash(state);
                self.d_reclen.hash(state);
                self.d_namelen.hash(state);
                self.d_name[..self.d_namelen as _].hash(state);
            }
        }
    }
}

pub const _SYSNAME_SIZE: usize = 256 + 1;
pub const RLIM_INFINITY: ::rlim_t = 0xfffffffffffffffd;
pub const O_LARGEFILE: ::c_int = 0o0100000;

// intentionally not public, only used for fd_set
cfg_if! {
    if #[cfg(target_pointer_width = "32")] {
        const ULONG_SIZE: usize = 32;
    } else if #[cfg(target_pointer_width = "64")] {
        const ULONG_SIZE: usize = 64;
    } else {
        // Unknown target_pointer_width
    }
}

pub const EXIT_FAILURE: ::c_int = 1;
pub const EXIT_SUCCESS: ::c_int = 0;
pub const RAND_MAX: ::c_int = 32767;
pub const EOF: ::c_int = -1;
pub const SEEK_SET: ::c_int = 0;
pub const SEEK_CUR: ::c_int = 1;
pub const SEEK_END: ::c_int = 2;
pub const _IOFBF: ::c_int = 0;
pub const _IONBF: ::c_int = 2;
pub const _IOLBF: ::c_int = 1;

pub const F_DUPFD: ::c_int = 0;
pub const F_GETFD: ::c_int = 1;
pub const F_SETFD: ::c_int = 2;
pub const F_GETFL: ::c_int = 3;
pub const F_SETFL: ::c_int = 4;

pub const F_DUPFD_CLOEXEC: ::c_int = 5;

pub const SIGTRAP: ::c_int = 5;

pub const CLOCK_REALTIME: ::clockid_t = 0;
pub const CLOCK_MONOTONIC: ::clockid_t = 2;
pub const CLOCK_PROCESS_CPUTIME_ID: ::clockid_t = 3;
pub const CLOCK_THREAD_CPUTIME_ID: ::clockid_t = 4;
pub const TIMER_ABSTIME: ::c_uint = 0x80000000;

pub const RUSAGE_SELF: ::c_int = 0;

pub const F_OK: ::c_int = 0;
pub const X_OK: ::c_int = 1;
pub const W_OK: ::c_int = 2;
pub const R_OK: ::c_int = 4;

pub const STDIN_FILENO: ::c_int = 0;
pub const STDOUT_FILENO: ::c_int = 1;
pub const STDERR_FILENO: ::c_int = 2;

pub const SIGHUP: ::c_int = 1;
pub const SIGINT: ::c_int = 2;
pub const SIGQUIT: ::c_int = 3;
pub const SIGILL: ::c_int = 4;
pub const SIGABRT: ::c_int = 6;
pub const SIGFPE: ::c_int = 8;
pub const SIGKILL: ::c_int = 9;
pub const SIGSEGV: ::c_int = 11;
pub const SIGPIPE: ::c_int = 13;
pub const SIGALRM: ::c_int = 14;
pub const SIGTERM: ::c_int = 15;

pub const PROT_NONE: ::c_int = 0x00000000;
pub const PROT_READ: ::c_int = 0x00000100;
pub const PROT_WRITE: ::c_int = 0x00000200;
pub const PROT_EXEC: ::c_int = 0x00000400;

pub const MAP_FILE: ::c_int = 0;
pub const MAP_SHARED: ::c_int = 1;
pub const MAP_PRIVATE: ::c_int = 2;
pub const MAP_FIXED: ::c_int = 0x10;

pub const MAP_FAILED: *mut ::c_void = !0 as *mut ::c_void;

pub const MS_ASYNC: ::c_int = 1;
pub const MS_INVALIDATE: ::c_int = 4;
pub const MS_SYNC: ::c_int = 2;

pub const SCM_RIGHTS: ::c_int = 0x01;
pub const SCM_TIMESTAMP: ::c_int = 0x02;
pub const SCM_CREDS: ::c_int = 0x04;

pub const MAP_TYPE: ::c_int = 0x3;

pub const IFF_UP: ::c_int = 0x00000001;
pub const IFF_BROADCAST: ::c_int = 0x00000002;
pub const IFF_DEBUG: ::c_int = 0x00000004;
pub const IFF_LOOPBACK: ::c_int = 0x00000008;
pub const IFF_POINTOPOINT: ::c_int = 0x00000010;
pub const IFF_NOTRAILERS: ::c_int = 0x00000020;
pub const IFF_RUNNING: ::c_int = 0x00000040;
pub const IFF_NOARP: ::c_int = 0x00000080;
pub const IFF_PROMISC: ::c_int = 0x00000100;
pub const IFF_ALLMULTI: ::c_int = 0x00000200;
pub const IFF_MULTICAST: ::c_int = 0x00008000;

pub const AF_UNSPEC: ::c_int = 0;
pub const AF_UNIX: ::c_int = AF_LOCAL;
pub const AF_LOCAL: ::c_int = 1;
pub const AF_INET: ::c_int = 2;
pub const AF_IPX: ::c_int = 23;
pub const AF_APPLETALK: ::c_int = 16;
pub const AF_INET6: ::c_int = 24;
pub const AF_ROUTE: ::c_int = 17;
pub const AF_SNA: ::c_int = 11;
pub const AF_BLUETOOTH: ::c_int = 31;
pub const AF_ISDN: ::c_int = 26;

pub const PF_UNSPEC: ::c_int = AF_UNSPEC;
pub const PF_UNIX: ::c_int = PF_LOCAL;
pub const PF_LOCAL: ::c_int = AF_LOCAL;
pub const PF_INET: ::c_int = AF_INET;
pub const PF_IPX: ::c_int = AF_IPX;
pub const PF_APPLETALK: ::c_int = AF_APPLETALK;
pub const PF_INET6: ::c_int = AF_INET6;
pub const pseudo_AF_KEY: ::c_int = 29;
pub const PF_KEY: ::c_int = pseudo_AF_KEY;
pub const PF_ROUTE: ::c_int = AF_ROUTE;
pub const PF_SNA: ::c_int = AF_SNA;

pub const PF_BLUETOOTH: ::c_int = AF_BLUETOOTH;
pub const PF_ISDN: ::c_int = AF_ISDN;

pub const SOMAXCONN: ::c_int = 128;

pub const MSG_OOB: ::c_int = 0x0001;
pub const MSG_PEEK: ::c_int = 0x0002;
pub const MSG_DONTROUTE: ::c_int = 0x0004;
pub const MSG_CTRUNC: ::c_int = 0x0020;
pub const MSG_TRUNC: ::c_int = 0x0010;
pub const MSG_DONTWAIT: ::c_int = 0x0080;
pub const MSG_EOR: ::c_int = 0x0008;
pub const MSG_WAITALL: ::c_int = 0x0040;
pub const MSG_NOSIGNAL: ::c_int = 0x0800;
pub const MSG_WAITFORONE: ::c_int = 0x2000;

pub const IP_TOS: ::c_int = 3;
pub const IP_TTL: ::c_int = 4;
pub const IP_HDRINCL: ::c_int = 2;
pub const IP_OPTIONS: ::c_int = 1;
pub const IP_RECVOPTS: ::c_int = 5;
pub const IP_RETOPTS: ::c_int = 8;
pub const IP_PKTINFO: ::c_int = 25;
pub const IP_IPSEC_POLICY_COMPAT: ::c_int = 22;
pub const IP_MULTICAST_IF: ::c_int = 9;
pub const IP_MULTICAST_TTL: ::c_int = 10;
pub const IP_MULTICAST_LOOP: ::c_int = 11;
pub const IP_ADD_MEMBERSHIP: ::c_int = 12;
pub const IP_DROP_MEMBERSHIP: ::c_int = 13;
pub const IP_DEFAULT_MULTICAST_TTL: ::c_int = 1;
pub const IP_DEFAULT_MULTICAST_LOOP: ::c_int = 1;

pub const IPPROTO_HOPOPTS: ::c_int = 0;
pub const IPPROTO_IGMP: ::c_int = 2;
pub const IPPROTO_IPIP: ::c_int = 4;
pub const IPPROTO_EGP: ::c_int = 8;
pub const IPPROTO_PUP: ::c_int = 12;
pub const IPPROTO_IDP: ::c_int = 22;
pub const IPPROTO_TP: ::c_int = 29;
pub const IPPROTO_ROUTING: ::c_int = 43;
pub const IPPROTO_FRAGMENT: ::c_int = 44;
pub const IPPROTO_RSVP: ::c_int = 46;
pub const IPPROTO_GRE: ::c_int = 47;
pub const IPPROTO_ESP: ::c_int = 50;
pub const IPPROTO_AH: ::c_int = 51;
pub const IPPROTO_NONE: ::c_int = 59;
pub const IPPROTO_DSTOPTS: ::c_int = 60;
pub const IPPROTO_ENCAP: ::c_int = 98;
pub const IPPROTO_PIM: ::c_int = 103;
pub const IPPROTO_SCTP: ::c_int = 132;
pub const IPPROTO_RAW: ::c_int = 255;
pub const IPPROTO_MAX: ::c_int = 256;
pub const IPPROTO_CARP: ::c_int = 112;
pub const IPPROTO_DIVERT: ::c_int = 259;
pub const IPPROTO_DONE: ::c_int = 257;
pub const IPPROTO_EON: ::c_int = 80;
pub const IPPROTO_ETHERIP: ::c_int = 97;
pub const IPPROTO_GGP: ::c_int = 3;
pub const IPPROTO_IPCOMP: ::c_int = 108;
pub const IPPROTO_MOBILE: ::c_int = 55;

pub const IPV6_RTHDR_LOOSE: ::c_int = 0;
pub const IPV6_RTHDR_STRICT: ::c_int = 1;
pub const IPV6_UNICAST_HOPS: ::c_int = 4;
pub const IPV6_MULTICAST_IF: ::c_int = 9;
pub const IPV6_MULTICAST_HOPS: ::c_int = 10;
pub const IPV6_MULTICAST_LOOP: ::c_int = 11;
pub const IPV6_JOIN_GROUP: ::c_int = 12;
pub const IPV6_LEAVE_GROUP: ::c_int = 13;
pub const IPV6_CHECKSUM: ::c_int = 26;
pub const IPV6_V6ONLY: ::c_int = 27;
pub const IPV6_IPSEC_POLICY_COMPAT: ::c_int = 28;
pub const IPV6_RTHDRDSTOPTS: ::c_int = 35;
pub const IPV6_RECVPKTINFO: ::c_int = 36;
pub const IPV6_RECVHOPLIMIT: ::c_int = 37;
pub const IPV6_RECVRTHDR: ::c_int = 38;
pub const IPV6_RECVHOPOPTS: ::c_int = 39;
pub const IPV6_RECVDSTOPTS: ::c_int = 40;
pub const IPV6_RECVPATHMTU: ::c_int = 43;
pub const IPV6_PATHMTU: ::c_int = 44;
pub const IPV6_PKTINFO: ::c_int = 46;
pub const IPV6_HOPLIMIT: ::c_int = 47;
pub const IPV6_NEXTHOP: ::c_int = 48;
pub const IPV6_HOPOPTS: ::c_int = 49;
pub const IPV6_DSTOPTS: ::c_int = 50;
pub const IPV6_RECVTCLASS: ::c_int = 57;
pub const IPV6_TCLASS: ::c_int = 61;
pub const IPV6_DONTFRAG: ::c_int = 62;

pub const TCP_NODELAY: ::c_int = 0x01;
pub const TCP_MAXSEG: ::c_int = 0x02;
pub const TCP_MD5SIG: ::c_int = 0x10;
pub const TCP_KEEPALIVE: ::c_int = 0x04;

pub const SHUT_RD: ::c_int = 0;
pub const SHUT_WR: ::c_int = 1;
pub const SHUT_RDWR: ::c_int = 2;

pub const LOCK_SH: ::c_int = 0x1;
pub const LOCK_EX: ::c_int = 0x2;
pub const LOCK_NB: ::c_int = 0x4;
pub const LOCK_UN: ::c_int = 0x8;

pub const SS_ONSTACK: ::c_int = 1;
pub const SS_DISABLE: ::c_int = 2;

pub const PATH_MAX: ::c_int = 1024;

pub const UIO_MAXIOV: ::c_int = 1024;

pub const FD_SETSIZE: usize = 256;

pub const TCIOFF: ::c_int = 0x0002;
pub const TCION: ::c_int = 0x0003;
pub const TCOOFF: ::c_int = 0x0000;
pub const TCOON: ::c_int = 0x0001;
pub const TCIFLUSH: ::c_int = 0;
pub const TCOFLUSH: ::c_int = 1;
pub const TCIOFLUSH: ::c_int = 2;
pub const NL0: ::tcflag_t = 0x000;
pub const NL1: ::tcflag_t = 0x100;
pub const TAB0: ::tcflag_t = 0x0000;
pub const CR0: ::tcflag_t = 0x000;
pub const FF0: ::tcflag_t = 0x0000;
pub const BS0: ::tcflag_t = 0x0000;
pub const VT0: ::tcflag_t = 0x0000;
pub const VERASE: usize = 2;
pub const VKILL: usize = 3;
pub const VINTR: usize = 0;
pub const VQUIT: usize = 1;
pub const VLNEXT: usize = 15;
pub const IGNBRK: ::tcflag_t = 0x00000001;
pub const BRKINT: ::tcflag_t = 0x00000002;
pub const IGNPAR: ::tcflag_t = 0x00000004;
pub const PARMRK: ::tcflag_t = 0x00000008;
pub const INPCK: ::tcflag_t = 0x00000010;
pub const ISTRIP: ::tcflag_t = 0x00000020;
pub const INLCR: ::tcflag_t = 0x00000040;
pub const IGNCR: ::tcflag_t = 0x00000080;
pub const ICRNL: ::tcflag_t = 0x00000100;
pub const IXANY: ::tcflag_t = 0x00000800;
pub const IMAXBEL: ::tcflag_t = 0x00002000;
pub const OPOST: ::tcflag_t = 0x00000001;
pub const CS5: ::tcflag_t = 0x00;
pub const ECHO: ::tcflag_t = 0x00000008;
pub const OCRNL: ::tcflag_t = 0x00000008;
pub const ONOCR: ::tcflag_t = 0x00000010;
pub const ONLRET: ::tcflag_t = 0x00000020;
pub const OFILL: ::tcflag_t = 0x00000040;
pub const OFDEL: ::tcflag_t = 0x00000080;

pub const WNOHANG: ::c_int = 0x0040;
pub const WUNTRACED: ::c_int = 0x0004;
pub const WSTOPPED: ::c_int = WUNTRACED;
pub const WEXITED: ::c_int = 0x0001;
pub const WCONTINUED: ::c_int = 0x0008;
pub const WNOWAIT: ::c_int = 0x0080;
pub const WTRAPPED: ::c_int = 0x0002;

pub const RTLD_LOCAL: ::c_int = 0x0200;
pub const RTLD_LAZY: ::c_int = 0x0001;

pub const POSIX_FADV_NORMAL: ::c_int = 0;
pub const POSIX_FADV_RANDOM: ::c_int = 2;
pub const POSIX_FADV_SEQUENTIAL: ::c_int = 1;
pub const POSIX_FADV_WILLNEED: ::c_int = 3;

pub const AT_FDCWD: ::c_int = -100;
pub const AT_EACCESS: ::c_int = 0x0001;
pub const AT_SYMLINK_NOFOLLOW: ::c_int = 0x0002;
pub const AT_SYMLINK_FOLLOW: ::c_int = 0x0004;
pub const AT_REMOVEDIR: ::c_int = 0x0008;

pub const LOG_CRON: ::c_int = 9 << 3;
pub const LOG_AUTHPRIV: ::c_int = 10 << 3;
pub const LOG_FTP: ::c_int = 11 << 3;
pub const LOG_PERROR: ::c_int = 0x20;

pub const PIPE_BUF: usize = 5120;

pub const CLD_EXITED: ::c_int = 1;
pub const CLD_KILLED: ::c_int = 2;
pub const CLD_DUMPED: ::c_int = 3;
pub const CLD_TRAPPED: ::c_int = 4;
pub const CLD_STOPPED: ::c_int = 5;
pub const CLD_CONTINUED: ::c_int = 6;

pub const UTIME_OMIT: c_long = 0x40000002;
pub const UTIME_NOW: c_long = 0x40000001;

pub const POLLIN: ::c_short = POLLRDNORM | POLLRDBAND;
pub const POLLPRI: ::c_short = 0x0008;
pub const POLLOUT: ::c_short = 0x0002;
pub const POLLERR: ::c_short = 0x0020;
pub const POLLHUP: ::c_short = 0x0040;
pub const POLLNVAL: ::c_short = 0x1000;
pub const POLLRDNORM: ::c_short = 0x0001;
pub const POLLRDBAND: ::c_short = 0x0004;

pub const IPTOS_LOWDELAY: u8 = 0x10;
pub const IPTOS_THROUGHPUT: u8 = 0x08;
pub const IPTOS_RELIABILITY: u8 = 0x04;
pub const IPTOS_MINCOST: u8 = 0x02;

pub const IPTOS_PREC_NETCONTROL: u8 = 0xe0;
pub const IPTOS_PREC_INTERNETCONTROL: u8 = 0xc0;
pub const IPTOS_PREC_CRITIC_ECP: u8 = 0xa0;
pub const IPTOS_PREC_FLASHOVERRIDE: u8 = 0x80;
pub const IPTOS_PREC_FLASH: u8 = 0x60;
pub const IPTOS_PREC_IMMEDIATE: u8 = 0x40;
pub const IPTOS_PREC_PRIORITY: u8 = 0x20;
pub const IPTOS_PREC_ROUTINE: u8 = 0x00;

pub const IPTOS_ECN_MASK: u8 = 0x03;
pub const IPTOS_ECN_ECT1: u8 = 0x01;
pub const IPTOS_ECN_ECT0: u8 = 0x02;
pub const IPTOS_ECN_CE: u8 = 0x03;

pub const IPOPT_CONTROL: u8 = 0x00;
pub const IPOPT_RESERVED1: u8 = 0x20;
pub const IPOPT_RESERVED2: u8 = 0x60;
pub const IPOPT_LSRR: u8 = 131;
pub const IPOPT_RR: u8 = 7;
pub const IPOPT_SSRR: u8 = 137;
pub const IPDEFTTL: u8 = 64;
pub const IPOPT_OPTVAL: u8 = 0;
pub const IPOPT_OLEN: u8 = 1;
pub const IPOPT_OFFSET: u8 = 2;
pub const IPOPT_MINOFF: u8 = 4;
pub const IPOPT_NOP: u8 = 1;
pub const IPOPT_EOL: u8 = 0;
pub const IPOPT_TS: u8 = 68;
pub const IPOPT_TS_TSONLY: u8 = 0;
pub const IPOPT_TS_TSANDADDR: u8 = 1;
pub const IPOPT_TS_PRESPEC: u8 = 3;

pub const MAX_IPOPTLEN: u8 = 40;
pub const IPVERSION: u8 = 4;
pub const MAXTTL: u8 = 255;

pub const ARPHRD_ETHER: u16 = 1;
pub const ARPHRD_IEEE802: u16 = 6;
pub const ARPHRD_ARCNET: u16 = 7;
pub const ARPHRD_IEEE1394: u16 = 24;

pub const SOL_SOCKET: ::c_int = 0xffff;

pub const SO_DEBUG: ::c_int = 0x0001;
pub const SO_REUSEADDR: ::c_int = 0x0004;
pub const SO_TYPE: ::c_int = 0x1008;
pub const SO_ERROR: ::c_int = 0x1007;
pub const SO_DONTROUTE: ::c_int = 0x0010;
pub const SO_BROADCAST: ::c_int = 0x0020;
pub const SO_SNDBUF: ::c_int = 0x1001;
pub const SO_RCVBUF: ::c_int = 0x1002;
pub const SO_KEEPALIVE: ::c_int = 0x0008;
pub const SO_OOBINLINE: ::c_int = 0x0100;
pub const SO_LINGER: ::c_int = 0x0080;
pub const SO_REUSEPORT: ::c_int = 0x0200;
pub const SO_RCVLOWAT: ::c_int = 0x1004;
pub const SO_SNDLOWAT: ::c_int = 0x1003;
pub const SO_RCVTIMEO: ::c_int = 0x1006;
pub const SO_SNDTIMEO: ::c_int = 0x1005;
pub const SO_BINDTODEVICE: ::c_int = 0x0800;
pub const SO_TIMESTAMP: ::c_int = 0x0400;
pub const SO_ACCEPTCONN: ::c_int = 0x0002;

pub const TIOCM_LE: ::c_int = 0x0100;
pub const TIOCM_DTR: ::c_int = 0x0001;
pub const TIOCM_RTS: ::c_int = 0x0002;
pub const TIOCM_ST: ::c_int = 0x0200;
pub const TIOCM_SR: ::c_int = 0x0400;
pub const TIOCM_CTS: ::c_int = 0x1000;
pub const TIOCM_CAR: ::c_int = TIOCM_CD;
pub const TIOCM_CD: ::c_int = 0x8000;
pub const TIOCM_RNG: ::c_int = TIOCM_RI;
pub const TIOCM_RI: ::c_int = 0x4000;
pub const TIOCM_DSR: ::c_int = 0x2000;

pub const SCHED_OTHER: ::c_int = 3;
pub const SCHED_FIFO: ::c_int = 1;
pub const SCHED_RR: ::c_int = 2;

pub const IPC_PRIVATE: ::key_t = 0;

pub const IPC_CREAT: ::c_int = 0o001000;
pub const IPC_EXCL: ::c_int = 0o002000;
pub const IPC_NOWAIT: ::c_int = 0o004000;

pub const IPC_RMID: ::c_int = 0;
pub const IPC_SET: ::c_int = 1;
pub const IPC_STAT: ::c_int = 2;

pub const MSG_NOERROR: ::c_int = 0o010000;

pub const LOG_NFACILITIES: ::c_int = 24;

pub const SEM_FAILED: *mut ::sem_t = 0xFFFFFFFFFFFFFFFF as *mut sem_t;

pub const AI_PASSIVE: ::c_int = 0x00000001;
pub const AI_CANONNAME: ::c_int = 0x00000002;
pub const AI_NUMERICHOST: ::c_int = 0x00000004;

pub const AI_NUMERICSERV: ::c_int = 0x00000008;

pub const EAI_BADFLAGS: ::c_int = 3;
pub const EAI_NONAME: ::c_int = 8;
pub const EAI_AGAIN: ::c_int = 2;
pub const EAI_FAIL: ::c_int = 4;
pub const EAI_NODATA: ::c_int = 7;
pub const EAI_FAMILY: ::c_int = 5;
pub const EAI_SOCKTYPE: ::c_int = 10;
pub const EAI_SERVICE: ::c_int = 9;
pub const EAI_MEMORY: ::c_int = 6;
pub const EAI_SYSTEM: ::c_int = 11;
pub const EAI_OVERFLOW: ::c_int = 14;

pub const NI_NUMERICHOST: ::c_int = 0x00000002;
pub const NI_NUMERICSERV: ::c_int = 0x00000008;
pub const NI_NOFQDN: ::c_int = 0x00000001;
pub const NI_NAMEREQD: ::c_int = 0x00000004;
pub const NI_DGRAM: ::c_int = 0x00000010;

pub const AIO_CANCELED: ::c_int = 0;
pub const AIO_NOTCANCELED: ::c_int = 2;
pub const AIO_ALLDONE: ::c_int = 1;
pub const LIO_READ: ::c_int = 1;
pub const LIO_WRITE: ::c_int = 2;
pub const LIO_NOP: ::c_int = 0;
pub const LIO_WAIT: ::c_int = 1;
pub const LIO_NOWAIT: ::c_int = 0;

pub const ITIMER_REAL: ::c_int = 0;
pub const ITIMER_VIRTUAL: ::c_int = 1;
pub const ITIMER_PROF: ::c_int = 2;

pub const POSIX_SPAWN_RESETIDS: ::c_int = 0x00000010;
pub const POSIX_SPAWN_SETPGROUP: ::c_int = 0x00000001;
pub const POSIX_SPAWN_SETSIGDEF: ::c_int = 0x00000004;
pub const POSIX_SPAWN_SETSIGMASK: ::c_int = 0x00000002;
pub const POSIX_SPAWN_SETSCHEDPARAM: ::c_int = 0x00000400;
pub const POSIX_SPAWN_SETSCHEDULER: ::c_int = 0x00000040;

pub const IPTOS_ECN_NOT_ECT: u8 = 0x00;

pub const RTF_UP: ::c_ushort = 0x0001;
pub const RTF_GATEWAY: ::c_ushort = 0x0002;

pub const RTF_HOST: ::c_ushort = 0x0004;
pub const RTF_DYNAMIC: ::c_ushort = 0x0010;
pub const RTF_MODIFIED: ::c_ushort = 0x0020;
pub const RTF_REJECT: ::c_ushort = 0x0008;
pub const RTF_STATIC: ::c_ushort = 0x0800;
pub const RTF_XRESOLVE: ::c_ushort = 0x0200;
pub const RTF_BROADCAST: u32 = 0x80000;
pub const RTM_NEWADDR: u16 = 0xc;
pub const RTM_DELADDR: u16 = 0xd;
pub const RTA_DST: ::c_ushort = 0x1;
pub const RTA_GATEWAY: ::c_ushort = 0x2;

pub const UDP_ENCAP: ::c_int = 100;

pub const IN_ACCESS: u32 = 0x00000001;
pub const IN_MODIFY: u32 = 0x00000002;
pub const IN_ATTRIB: u32 = 0x00000004;
pub const IN_CLOSE_WRITE: u32 = 0x00000008;
pub const IN_CLOSE_NOWRITE: u32 = 0x00000010;
pub const IN_CLOSE: u32 = IN_CLOSE_WRITE | IN_CLOSE_NOWRITE;
pub const IN_OPEN: u32 = 0x00000020;
pub const IN_MOVED_FROM: u32 = 0x00000040;
pub const IN_MOVED_TO: u32 = 0x00000080;
pub const IN_MOVE: u32 = IN_MOVED_FROM | IN_MOVED_TO;
pub const IN_CREATE: u32 = 0x00000100;
pub const IN_DELETE: u32 = 0x00000200;
pub const IN_DELETE_SELF: u32 = 0x00000400;
pub const IN_MOVE_SELF: u32 = 0x00000800;
pub const IN_UNMOUNT: u32 = 0x00002000;
pub const IN_Q_OVERFLOW: u32 = 0x00004000;
pub const IN_IGNORED: u32 = 0x00008000;
pub const IN_ONLYDIR: u32 = 0x01000000;
pub const IN_DONT_FOLLOW: u32 = 0x02000000;

pub const IN_ISDIR: u32 = 0x40000000;
pub const IN_ONESHOT: u32 = 0x80000000;

pub const REG_EXTENDED: ::c_int = 0o0001;
pub const REG_ICASE: ::c_int = 0o0002;
pub const REG_NEWLINE: ::c_int = 0o0010;
pub const REG_NOSUB: ::c_int = 0o0004;

pub const REG_NOTBOL: ::c_int = 0o00001;
pub const REG_NOTEOL: ::c_int = 0o00002;

pub const REG_ENOSYS: ::c_int = 17;
pub const REG_NOMATCH: ::c_int = 1;
pub const REG_BADPAT: ::c_int = 2;
pub const REG_ECOLLATE: ::c_int = 3;
pub const REG_ECTYPE: ::c_int = 4;
pub const REG_EESCAPE: ::c_int = 5;
pub const REG_ESUBREG: ::c_int = 6;
pub const REG_EBRACK: ::c_int = 7;
pub const REG_EPAREN: ::c_int = 8;
pub const REG_EBRACE: ::c_int = 9;
pub const REG_BADBR: ::c_int = 10;
pub const REG_ERANGE: ::c_int = 11;
pub const REG_ESPACE: ::c_int = 12;
pub const REG_BADRPT: ::c_int = 13;

// errno.h
pub const EOK: ::c_int = 0;
pub const EWOULDBLOCK: ::c_int = EAGAIN;
pub const EPERM: ::c_int = 1;
pub const ENOENT: ::c_int = 2;
pub const ESRCH: ::c_int = 3;
pub const EINTR: ::c_int = 4;
pub const EIO: ::c_int = 5;
pub const ENXIO: ::c_int = 6;
pub const E2BIG: ::c_int = 7;
pub const ENOEXEC: ::c_int = 8;
pub const EBADF: ::c_int = 9;
pub const ECHILD: ::c_int = 10;
pub const EAGAIN: ::c_int = 11;
pub const ENOMEM: ::c_int = 12;
pub const EACCES: ::c_int = 13;
pub const EFAULT: ::c_int = 14;
pub const ENOTBLK: ::c_int = 15;
pub const EBUSY: ::c_int = 16;
pub const EEXIST: ::c_int = 17;
pub const EXDEV: ::c_int = 18;
pub const ENODEV: ::c_int = 19;
pub const ENOTDIR: ::c_int = 20;
pub const EISDIR: ::c_int = 21;
pub const EINVAL: ::c_int = 22;
pub const ENFILE: ::c_int = 23;
pub const EMFILE: ::c_int = 24;
pub const ENOTTY: ::c_int = 25;
pub const ETXTBSY: ::c_int = 26;
pub const EFBIG: ::c_int = 27;
pub const ENOSPC: ::c_int = 28;
pub const ESPIPE: ::c_int = 29;
pub const EROFS: ::c_int = 30;
pub const EMLINK: ::c_int = 31;
pub const EPIPE: ::c_int = 32;
pub const EDOM: ::c_int = 33;
pub const ERANGE: ::c_int = 34;
pub const ENOMSG: ::c_int = 35;
pub const EIDRM: ::c_int = 36;
pub const ECHRNG: ::c_int = 37;
pub const EL2NSYNC: ::c_int = 38;
pub const EL3HLT: ::c_int = 39;
pub const EL3RST: ::c_int = 40;
pub const ELNRNG: ::c_int = 41;
pub const EUNATCH: ::c_int = 42;
pub const ENOCSI: ::c_int = 43;
pub const EL2HLT: ::c_int = 44;
pub const EDEADLK: ::c_int = 45;
pub const ENOLCK: ::c_int = 46;
pub const ECANCELED: ::c_int = 47;
pub const EDQUOT: ::c_int = 49;
pub const EBADE: ::c_int = 50;
pub const EBADR: ::c_int = 51;
pub const EXFULL: ::c_int = 52;
pub const ENOANO: ::c_int = 53;
pub const EBADRQC: ::c_int = 54;
pub const EBADSLT: ::c_int = 55;
pub const EDEADLOCK: ::c_int = 56;
pub const EBFONT: ::c_int = 57;
pub const EOWNERDEAD: ::c_int = 58;
pub const ENOSTR: ::c_int = 60;
pub const ENODATA: ::c_int = 61;
pub const ETIME: ::c_int = 62;
pub const ENOSR: ::c_int = 63;
pub const ENONET: ::c_int = 64;
pub const ENOPKG: ::c_int = 65;
pub const EREMOTE: ::c_int = 66;
pub const ENOLINK: ::c_int = 67;
pub const EADV: ::c_int = 68;
pub const ESRMNT: ::c_int = 69;
pub const ECOMM: ::c_int = 70;
pub const EPROTO: ::c_int = 71;
pub const EMULTIHOP: ::c_int = 74;
pub const EBADMSG: ::c_int = 77;
pub const ENAMETOOLONG: ::c_int = 78;
pub const EOVERFLOW: ::c_int = 79;
pub const ENOTUNIQ: ::c_int = 80;
pub const EBADFD: ::c_int = 81;
pub const EREMCHG: ::c_int = 82;
pub const ELIBACC: ::c_int = 83;
pub const ELIBBAD: ::c_int = 84;
pub const ELIBSCN: ::c_int = 85;
pub const ELIBMAX: ::c_int = 86;
pub const ELIBEXEC: ::c_int = 87;
pub const EILSEQ: ::c_int = 88;
pub const ENOSYS: ::c_int = 89;
pub const ELOOP: ::c_int = 90;
pub const ERESTART: ::c_int = 91;
pub const ESTRPIPE: ::c_int = 92;
pub const ENOTEMPTY: ::c_int = 93;
pub const EUSERS: ::c_int = 94;
pub const ENOTRECOVERABLE: ::c_int = 95;
pub const EOPNOTSUPP: ::c_int = 103;
pub const EFPOS: ::c_int = 110;
pub const ESTALE: ::c_int = 122;
pub const EINPROGRESS: ::c_int = 236;
pub const EALREADY: ::c_int = 237;
pub const ENOTSOCK: ::c_int = 238;
pub const EDESTADDRREQ: ::c_int = 239;
pub const EMSGSIZE: ::c_int = 240;
pub const EPROTOTYPE: ::c_int = 241;
pub const ENOPROTOOPT: ::c_int = 242;
pub const EPROTONOSUPPORT: ::c_int = 243;
pub const ESOCKTNOSUPPORT: ::c_int = 244;
pub const EPFNOSUPPORT: ::c_int = 246;
pub const EAFNOSUPPORT: ::c_int = 247;
pub const EADDRINUSE: ::c_int = 248;
pub const EADDRNOTAVAIL: ::c_int = 249;
pub const ENETDOWN: ::c_int = 250;
pub const ENETUNREACH: ::c_int = 251;
pub const ENETRESET: ::c_int = 252;
pub const ECONNABORTED: ::c_int = 253;
pub const ECONNRESET: ::c_int = 254;
pub const ENOBUFS: ::c_int = 255;
pub const EISCONN: ::c_int = 256;
pub const ENOTCONN: ::c_int = 257;
pub const ESHUTDOWN: ::c_int = 258;
pub const ETOOMANYREFS: ::c_int = 259;
pub const ETIMEDOUT: ::c_int = 260;
pub const ECONNREFUSED: ::c_int = 261;
pub const EHOSTDOWN: ::c_int = 264;
pub const EHOSTUNREACH: ::c_int = 265;
pub const EBADRPC: ::c_int = 272;
pub const ERPCMISMATCH: ::c_int = 273;
pub const EPROGUNAVAIL: ::c_int = 274;
pub const EPROGMISMATCH: ::c_int = 275;
pub const EPROCUNAVAIL: ::c_int = 276;
pub const ENOREMOTE: ::c_int = 300;
pub const ENONDP: ::c_int = 301;
pub const EBADFSYS: ::c_int = 302;
pub const EMORE: ::c_int = 309;
pub const ECTRLTERM: ::c_int = 310;
pub const ENOLIC: ::c_int = 311;
pub const ESRVRFAULT: ::c_int = 312;
pub const EENDIAN: ::c_int = 313;
pub const ESECTYPEINVAL: ::c_int = 314;

pub const RUSAGE_CHILDREN: ::c_int = -1;
pub const L_tmpnam: ::c_uint = 255;

pub const _PC_LINK_MAX: ::c_int = 1;
pub const _PC_MAX_CANON: ::c_int = 2;
pub const _PC_MAX_INPUT: ::c_int = 3;
pub const _PC_NAME_MAX: ::c_int = 4;
pub const _PC_PATH_MAX: ::c_int = 5;
pub const _PC_PIPE_BUF: ::c_int = 6;
pub const _PC_CHOWN_RESTRICTED: ::c_int = 9;
pub const _PC_NO_TRUNC: ::c_int = 7;
pub const _PC_VDISABLE: ::c_int = 8;
pub const _PC_SYNC_IO: ::c_int = 14;
pub const _PC_ASYNC_IO: ::c_int = 12;
pub const _PC_PRIO_IO: ::c_int = 13;
pub const _PC_SOCK_MAXBUF: ::c_int = 15;
pub const _PC_FILESIZEBITS: ::c_int = 16;
pub const _PC_REC_INCR_XFER_SIZE: ::c_int = 22;
pub const _PC_REC_MAX_XFER_SIZE: ::c_int = 23;
pub const _PC_REC_MIN_XFER_SIZE: ::c_int = 24;
pub const _PC_REC_XFER_ALIGN: ::c_int = 25;
pub const _PC_ALLOC_SIZE_MIN: ::c_int = 21;
pub const _PC_SYMLINK_MAX: ::c_int = 17;
pub const _PC_2_SYMLINKS: ::c_int = 20;

pub const _SC_PAGE_SIZE: ::c_int = _SC_PAGESIZE;
pub const _SC_ARG_MAX: ::c_int = 1;
pub const _SC_CHILD_MAX: ::c_int = 2;
pub const _SC_CLK_TCK: ::c_int = 3;
pub const _SC_NGROUPS_MAX: ::c_int = 4;
pub const _SC_OPEN_MAX: ::c_int = 5;
pub const _SC_JOB_CONTROL: ::c_int = 6;
pub const _SC_SAVED_IDS: ::c_int = 7;
pub const _SC_VERSION: ::c_int = 8;
pub const _SC_PASS_MAX: ::c_int = 9;
pub const _SC_PAGESIZE: ::c_int = 11;
pub const _SC_XOPEN_VERSION: ::c_int = 12;
pub const _SC_STREAM_MAX: ::c_int = 13;
pub const _SC_TZNAME_MAX: ::c_int = 14;
pub const _SC_AIO_LISTIO_MAX: ::c_int = 15;
pub const _SC_AIO_MAX: ::c_int = 16;
pub const _SC_AIO_PRIO_DELTA_MAX: ::c_int = 17;
pub const _SC_DELAYTIMER_MAX: ::c_int = 18;
pub const _SC_MQ_OPEN_MAX: ::c_int = 19;
pub const _SC_MQ_PRIO_MAX: ::c_int = 20;
pub const _SC_RTSIG_MAX: ::c_int = 21;
pub const _SC_SEM_NSEMS_MAX: ::c_int = 22;
pub const _SC_SEM_VALUE_MAX: ::c_int = 23;
pub const _SC_SIGQUEUE_MAX: ::c_int = 24;
pub const _SC_TIMER_MAX: ::c_int = 25;
pub const _SC_ASYNCHRONOUS_IO: ::c_int = 26;
pub const _SC_FSYNC: ::c_int = 27;
pub const _SC_MAPPED_FILES: ::c_int = 28;
pub const _SC_MEMLOCK: ::c_int = 29;
pub const _SC_MEMLOCK_RANGE: ::c_int = 30;
pub const _SC_MEMORY_PROTECTION: ::c_int = 31;
pub const _SC_MESSAGE_PASSING: ::c_int = 32;
pub const _SC_PRIORITIZED_IO: ::c_int = 33;
pub const _SC_PRIORITY_SCHEDULING: ::c_int = 34;
pub const _SC_REALTIME_SIGNALS: ::c_int = 35;
pub const _SC_SEMAPHORES: ::c_int = 36;
pub const _SC_SHARED_MEMORY_OBJECTS: ::c_int = 37;
pub const _SC_SYNCHRONIZED_IO: ::c_int = 38;
pub const _SC_TIMERS: ::c_int = 39;
pub const _SC_GETGR_R_SIZE_MAX: ::c_int = 40;
pub const _SC_GETPW_R_SIZE_MAX: ::c_int = 41;
pub const _SC_LOGIN_NAME_MAX: ::c_int = 42;
pub const _SC_THREAD_DESTRUCTOR_ITERATIONS: ::c_int = 43;
pub const _SC_THREAD_KEYS_MAX: ::c_int = 44;
pub const _SC_THREAD_STACK_MIN: ::c_int = 45;
pub const _SC_THREAD_THREADS_MAX: ::c_int = 46;
pub const _SC_TTY_NAME_MAX: ::c_int = 47;
pub const _SC_THREADS: ::c_int = 48;
pub const _SC_THREAD_ATTR_STACKADDR: ::c_int = 49;
pub const _SC_THREAD_ATTR_STACKSIZE: ::c_int = 50;
pub const _SC_THREAD_PRIORITY_SCHEDULING: ::c_int = 51;
pub const _SC_THREAD_PRIO_INHERIT: ::c_int = 52;
pub const _SC_THREAD_PRIO_PROTECT: ::c_int = 53;
pub const _SC_THREAD_PROCESS_SHARED: ::c_int = 54;
pub const _SC_THREAD_SAFE_FUNCTIONS: ::c_int = 55;
pub const _SC_2_CHAR_TERM: ::c_int = 56;
pub const _SC_2_C_BIND: ::c_int = 57;
pub const _SC_2_C_DEV: ::c_int = 58;
pub const _SC_2_C_VERSION: ::c_int = 59;
pub const _SC_2_FORT_DEV: ::c_int = 60;
pub const _SC_2_FORT_RUN: ::c_int = 61;
pub const _SC_2_LOCALEDEF: ::c_int = 62;
pub const _SC_2_SW_DEV: ::c_int = 63;
pub const _SC_2_UPE: ::c_int = 64;
pub const _SC_2_VERSION: ::c_int = 65;
pub const _SC_ATEXIT_MAX: ::c_int = 66;
pub const _SC_AVPHYS_PAGES: ::c_int = 67;
pub const _SC_BC_BASE_MAX: ::c_int = 68;
pub const _SC_BC_DIM_MAX: ::c_int = 69;
pub const _SC_BC_SCALE_MAX: ::c_int = 70;
pub const _SC_BC_STRING_MAX: ::c_int = 71;
pub const _SC_CHARCLASS_NAME_MAX: ::c_int = 72;
pub const _SC_CHAR_BIT: ::c_int = 73;
pub const _SC_CHAR_MAX: ::c_int = 74;
pub const _SC_CHAR_MIN: ::c_int = 75;
pub const _SC_COLL_WEIGHTS_MAX: ::c_int = 76;
pub const _SC_EQUIV_CLASS_MAX: ::c_int = 77;
pub const _SC_EXPR_NEST_MAX: ::c_int = 78;
pub const _SC_INT_MAX: ::c_int = 79;
pub const _SC_INT_MIN: ::c_int = 80;
pub const _SC_LINE_MAX: ::c_int = 81;
pub const _SC_LONG_BIT: ::c_int = 82;
pub const _SC_MB_LEN_MAX: ::c_int = 83;
pub const _SC_NL_ARGMAX: ::c_int = 84;
pub const _SC_NL_LANGMAX: ::c_int = 85;
pub const _SC_NL_MSGMAX: ::c_int = 86;
pub const _SC_NL_NMAX: ::c_int = 87;
pub const _SC_NL_SETMAX: ::c_int = 88;
pub const _SC_NL_TEXTMAX: ::c_int = 89;
pub const _SC_NPROCESSORS_CONF: ::c_int = 90;
pub const _SC_NPROCESSORS_ONLN: ::c_int = 91;
pub const _SC_NZERO: ::c_int = 92;
pub const _SC_PHYS_PAGES: ::c_int = 93;
pub const _SC_PII: ::c_int = 94;
pub const _SC_PII_INTERNET: ::c_int = 95;
pub const _SC_PII_INTERNET_DGRAM: ::c_int = 96;
pub const _SC_PII_INTERNET_STREAM: ::c_int = 97;
pub const _SC_PII_OSI: ::c_int = 98;
pub const _SC_PII_OSI_CLTS: ::c_int = 99;
pub const _SC_PII_OSI_COTS: ::c_int = 100;
pub const _SC_PII_OSI_M: ::c_int = 101;
pub const _SC_PII_SOCKET: ::c_int = 102;
pub const _SC_PII_XTI: ::c_int = 103;
pub const _SC_POLL: ::c_int = 104;
pub const _SC_RE_DUP_MAX: ::c_int = 105;
pub const _SC_SCHAR_MAX: ::c_int = 106;
pub const _SC_SCHAR_MIN: ::c_int = 107;
pub const _SC_SELECT: ::c_int = 108;
pub const _SC_SHRT_MAX: ::c_int = 109;
pub const _SC_SHRT_MIN: ::c_int = 110;
pub const _SC_SSIZE_MAX: ::c_int = 111;
pub const _SC_T_IOV_MAX: ::c_int = 112;
pub const _SC_UCHAR_MAX: ::c_int = 113;
pub const _SC_UINT_MAX: ::c_int = 114;
pub const _SC_UIO_MAXIOV: ::c_int = 115;
pub const _SC_ULONG_MAX: ::c_int = 116;
pub const _SC_USHRT_MAX: ::c_int = 117;
pub const _SC_WORD_BIT: ::c_int = 118;
pub const _SC_XOPEN_CRYPT: ::c_int = 119;
pub const _SC_XOPEN_ENH_I18N: ::c_int = 120;
pub const _SC_XOPEN_SHM: ::c_int = 121;
pub const _SC_XOPEN_UNIX: ::c_int = 122;
pub const _SC_XOPEN_XCU_VERSION: ::c_int = 123;
pub const _SC_XOPEN_XPG2: ::c_int = 124;
pub const _SC_XOPEN_XPG3: ::c_int = 125;
pub const _SC_XOPEN_XPG4: ::c_int = 126;
pub const _SC_XBS5_ILP32_OFF32: ::c_int = 127;
pub const _SC_XBS5_ILP32_OFFBIG: ::c_int = 128;
pub const _SC_XBS5_LP64_OFF64: ::c_int = 129;
pub const _SC_XBS5_LPBIG_OFFBIG: ::c_int = 130;
pub const _SC_ADVISORY_INFO: ::c_int = 131;
pub const _SC_CPUTIME: ::c_int = 132;
pub const _SC_SPAWN: ::c_int = 133;
pub const _SC_SPORADIC_SERVER: ::c_int = 134;
pub const _SC_THREAD_CPUTIME: ::c_int = 135;
pub const _SC_THREAD_SPORADIC_SERVER: ::c_int = 136;
pub const _SC_TIMEOUTS: ::c_int = 137;
pub const _SC_BARRIERS: ::c_int = 138;
pub const _SC_CLOCK_SELECTION: ::c_int = 139;
pub const _SC_MONOTONIC_CLOCK: ::c_int = 140;
pub const _SC_READER_WRITER_LOCKS: ::c_int = 141;
pub const _SC_SPIN_LOCKS: ::c_int = 142;
pub const _SC_TYPED_MEMORY_OBJECTS: ::c_int = 143;
pub const _SC_TRACE_EVENT_FILTER: ::c_int = 144;
pub const _SC_TRACE: ::c_int = 145;
pub const _SC_TRACE_INHERIT: ::c_int = 146;
pub const _SC_TRACE_LOG: ::c_int = 147;
pub const _SC_2_PBS: ::c_int = 148;
pub const _SC_2_PBS_ACCOUNTING: ::c_int = 149;
pub const _SC_2_PBS_CHECKPOINT: ::c_int = 150;
pub const _SC_2_PBS_LOCATE: ::c_int = 151;
pub const _SC_2_PBS_MESSAGE: ::c_int = 152;
pub const _SC_2_PBS_TRACK: ::c_int = 153;
pub const _SC_HOST_NAME_MAX: ::c_int = 154;
pub const _SC_IOV_MAX: ::c_int = 155;
pub const _SC_IPV6: ::c_int = 156;
pub const _SC_RAW_SOCKETS: ::c_int = 157;
pub const _SC_REGEXP: ::c_int = 158;
pub const _SC_SHELL: ::c_int = 159;
pub const _SC_SS_REPL_MAX: ::c_int = 160;
pub const _SC_SYMLOOP_MAX: ::c_int = 161;
pub const _SC_TRACE_EVENT_NAME_MAX: ::c_int = 162;
pub const _SC_TRACE_NAME_MAX: ::c_int = 163;
pub const _SC_TRACE_SYS_MAX: ::c_int = 164;
pub const _SC_TRACE_USER_EVENT_MAX: ::c_int = 165;
pub const _SC_V6_ILP32_OFF32: ::c_int = 166;
pub const _SC_V6_ILP32_OFFBIG: ::c_int = 167;
pub const _SC_V6_LP64_OFF64: ::c_int = 168;
pub const _SC_V6_LPBIG_OFFBIG: ::c_int = 169;
pub const _SC_XOPEN_REALTIME: ::c_int = 170;
pub const _SC_XOPEN_REALTIME_THREADS: ::c_int = 171;
--> --------------------

--> maximum size reached

--> --------------------

[ Dauer der Verarbeitung: 0.36 Sekunden  (vorverarbeitet)  ]

                                                                                                                                                                                                                                                                                                                                                                                                     


Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Produkte
     Quellcodebibliothek

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder

Jenseits des Üblichen ....

Besucherstatistik

Besucherstatistik

Monitoring

Montastic status badge