1 //! Definitions found commonly among almost all Unix derivatives 2 //! 3 //! More functions and definitions can be found in the more specific modules 4 //! according to the platform in question. 5 6 use crate::prelude::*; 7 8 pub type intmax_t = i64; 9 pub type uintmax_t = u64; 10 11 pub type size_t = usize; 12 pub type ptrdiff_t = isize; 13 pub type intptr_t = isize; 14 pub type uintptr_t = usize; 15 pub type ssize_t = isize; 16 17 pub type pid_t = i32; 18 pub type in_addr_t = u32; 19 pub type in_port_t = u16; 20 pub type sighandler_t = size_t; 21 pub type cc_t = c_uchar; 22 23 cfg_if! { 24 if #[cfg(any( 25 target_os = "espidf", 26 target_os = "horizon", 27 target_os = "vita" 28 ))] { 29 pub type uid_t = c_ushort; 30 pub type gid_t = c_ushort; 31 } else if #[cfg(target_os = "nto")] { 32 pub type uid_t = i32; 33 pub type gid_t = i32; 34 } else { 35 pub type uid_t = u32; 36 pub type gid_t = u32; 37 } 38 } 39 40 missing! { 41 #[cfg_attr(feature = "extra_traits", derive(Debug))] 42 pub enum DIR {} 43 } 44 pub type locale_t = *mut c_void; 45 46 s! { 47 pub struct group { 48 pub gr_name: *mut c_char, 49 pub gr_passwd: *mut c_char, 50 pub gr_gid: crate::gid_t, 51 pub gr_mem: *mut *mut c_char, 52 } 53 54 pub struct utimbuf { 55 pub actime: time_t, 56 pub modtime: time_t, 57 } 58 59 pub struct timeval { 60 pub tv_sec: time_t, 61 #[cfg(not(gnu_time_bits64))] 62 pub tv_usec: suseconds_t, 63 // For 64 bit time on 32 bit linux glibc, suseconds_t is still 64 // a 32 bit type. Use __suseconds64_t instead 65 #[cfg(gnu_time_bits64)] 66 pub tv_usec: __suseconds64_t, 67 } 68 69 // linux x32 compatibility 70 // See https://sourceware.org/bugzilla/show_bug.cgi?id=16437 71 #[cfg(not(target_env = "gnu"))] 72 pub struct timespec { 73 pub tv_sec: time_t, 74 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 75 pub tv_nsec: i64, 76 #[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))] 77 pub tv_nsec: c_long, 78 } 79 80 pub struct rlimit { 81 pub rlim_cur: rlim_t, 82 pub rlim_max: rlim_t, 83 } 84 85 pub struct rusage { 86 pub ru_utime: timeval, 87 pub ru_stime: timeval, 88 pub ru_maxrss: c_long, 89 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 90 __pad1: u32, 91 pub ru_ixrss: c_long, 92 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 93 __pad2: u32, 94 pub ru_idrss: c_long, 95 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 96 __pad3: u32, 97 pub ru_isrss: c_long, 98 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 99 __pad4: u32, 100 pub ru_minflt: c_long, 101 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 102 __pad5: u32, 103 pub ru_majflt: c_long, 104 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 105 __pad6: u32, 106 pub ru_nswap: c_long, 107 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 108 __pad7: u32, 109 pub ru_inblock: c_long, 110 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 111 __pad8: u32, 112 pub ru_oublock: c_long, 113 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 114 __pad9: u32, 115 pub ru_msgsnd: c_long, 116 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 117 __pad10: u32, 118 pub ru_msgrcv: c_long, 119 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 120 __pad11: u32, 121 pub ru_nsignals: c_long, 122 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 123 __pad12: u32, 124 pub ru_nvcsw: c_long, 125 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 126 __pad13: u32, 127 pub ru_nivcsw: c_long, 128 #[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))] 129 __pad14: u32, 130 131 #[cfg(any(target_env = "musl", target_env = "ohos", target_os = "emscripten"))] 132 __reserved: [c_long; 16], 133 } 134 135 pub struct ipv6_mreq { 136 pub ipv6mr_multiaddr: in6_addr, 137 #[cfg(target_os = "android")] 138 pub ipv6mr_interface: c_int, 139 #[cfg(not(target_os = "android"))] 140 pub ipv6mr_interface: c_uint, 141 } 142 143 #[cfg(not(target_os = "cygwin"))] 144 pub struct hostent { 145 pub h_name: *mut c_char, 146 pub h_aliases: *mut *mut c_char, 147 pub h_addrtype: c_int, 148 pub h_length: c_int, 149 pub h_addr_list: *mut *mut c_char, 150 } 151 152 pub struct iovec { 153 pub iov_base: *mut c_void, 154 pub iov_len: size_t, 155 } 156 157 pub struct pollfd { 158 pub fd: c_int, 159 pub events: c_short, 160 pub revents: c_short, 161 } 162 163 #[cfg(not(target_os = "aix"))] 164 pub struct winsize { 165 pub ws_row: c_ushort, 166 pub ws_col: c_ushort, 167 pub ws_xpixel: c_ushort, 168 pub ws_ypixel: c_ushort, 169 } 170 171 #[cfg(not(target_os = "cygwin"))] 172 pub struct linger { 173 pub l_onoff: c_int, 174 pub l_linger: c_int, 175 } 176 177 pub struct sigval { 178 // Actually a union of an int and a void* 179 pub sival_ptr: *mut c_void, 180 } 181 182 // <sys/time.h> 183 pub struct itimerval { 184 pub it_interval: crate::timeval, 185 pub it_value: crate::timeval, 186 } 187 188 // <sys/times.h> 189 pub struct tms { 190 pub tms_utime: crate::clock_t, 191 pub tms_stime: crate::clock_t, 192 pub tms_cutime: crate::clock_t, 193 pub tms_cstime: crate::clock_t, 194 } 195 196 pub struct servent { 197 pub s_name: *mut c_char, 198 pub s_aliases: *mut *mut c_char, 199 #[cfg(target_os = "cygwin")] 200 pub s_port: c_short, 201 #[cfg(not(target_os = "cygwin"))] 202 pub s_port: c_int, 203 pub s_proto: *mut c_char, 204 } 205 206 pub struct protoent { 207 pub p_name: *mut c_char, 208 pub p_aliases: *mut *mut c_char, 209 #[cfg(not(target_os = "cygwin"))] 210 pub p_proto: c_int, 211 #[cfg(target_os = "cygwin")] 212 pub p_proto: c_short, 213 } 214 215 #[repr(align(4))] 216 pub struct in6_addr { 217 pub s6_addr: [u8; 16], 218 } 219 } 220 221 pub const INT_MIN: c_int = -2147483648; 222 pub const INT_MAX: c_int = 2147483647; 223 224 pub const SIG_DFL: sighandler_t = 0 as sighandler_t; 225 pub const SIG_IGN: sighandler_t = 1 as sighandler_t; 226 pub const SIG_ERR: sighandler_t = !0 as sighandler_t; 227 228 cfg_if! { 229 if #[cfg(all(not(target_os = "nto"), not(target_os = "aix")))] { 230 pub const DT_UNKNOWN: u8 = 0; 231 pub const DT_FIFO: u8 = 1; 232 pub const DT_CHR: u8 = 2; 233 pub const DT_DIR: u8 = 4; 234 pub const DT_BLK: u8 = 6; 235 pub const DT_REG: u8 = 8; 236 pub const DT_LNK: u8 = 10; 237 pub const DT_SOCK: u8 = 12; 238 } 239 } 240 cfg_if! { 241 if #[cfg(not(target_os = "redox"))] { 242 pub const FD_CLOEXEC: c_int = 0x1; 243 } 244 } 245 246 cfg_if! { 247 if #[cfg(not(target_os = "nto"))] { 248 pub const USRQUOTA: c_int = 0; 249 pub const GRPQUOTA: c_int = 1; 250 } 251 } 252 pub const SIGIOT: c_int = 6; 253 254 pub const S_ISUID: mode_t = 0o4000; 255 pub const S_ISGID: mode_t = 0o2000; 256 pub const S_ISVTX: mode_t = 0o1000; 257 258 cfg_if! { 259 if #[cfg(not(any( 260 target_os = "haiku", 261 target_os = "illumos", 262 target_os = "solaris", 263 target_os = "cygwin" 264 )))] { 265 pub const IF_NAMESIZE: size_t = 16; 266 pub const IFNAMSIZ: size_t = IF_NAMESIZE; 267 } 268 } 269 270 pub const LOG_EMERG: c_int = 0; 271 pub const LOG_ALERT: c_int = 1; 272 pub const LOG_CRIT: c_int = 2; 273 pub const LOG_ERR: c_int = 3; 274 pub const LOG_WARNING: c_int = 4; 275 pub const LOG_NOTICE: c_int = 5; 276 pub const LOG_INFO: c_int = 6; 277 pub const LOG_DEBUG: c_int = 7; 278 279 pub const LOG_KERN: c_int = 0; 280 pub const LOG_USER: c_int = 1 << 3; 281 pub const LOG_MAIL: c_int = 2 << 3; 282 pub const LOG_DAEMON: c_int = 3 << 3; 283 pub const LOG_AUTH: c_int = 4 << 3; 284 pub const LOG_SYSLOG: c_int = 5 << 3; 285 pub const LOG_LPR: c_int = 6 << 3; 286 pub const LOG_NEWS: c_int = 7 << 3; 287 pub const LOG_UUCP: c_int = 8 << 3; 288 pub const LOG_LOCAL0: c_int = 16 << 3; 289 pub const LOG_LOCAL1: c_int = 17 << 3; 290 pub const LOG_LOCAL2: c_int = 18 << 3; 291 pub const LOG_LOCAL3: c_int = 19 << 3; 292 pub const LOG_LOCAL4: c_int = 20 << 3; 293 pub const LOG_LOCAL5: c_int = 21 << 3; 294 pub const LOG_LOCAL6: c_int = 22 << 3; 295 pub const LOG_LOCAL7: c_int = 23 << 3; 296 297 cfg_if! { 298 if #[cfg(not(target_os = "haiku"))] { 299 pub const LOG_PID: c_int = 0x01; 300 pub const LOG_CONS: c_int = 0x02; 301 pub const LOG_ODELAY: c_int = 0x04; 302 pub const LOG_NDELAY: c_int = 0x08; 303 pub const LOG_NOWAIT: c_int = 0x10; 304 } 305 } 306 pub const LOG_PRIMASK: c_int = 7; 307 pub const LOG_FACMASK: c_int = 0x3f8; 308 309 cfg_if! { 310 if #[cfg(not(target_os = "nto"))] { 311 pub const PRIO_MIN: c_int = -20; 312 pub const PRIO_MAX: c_int = 20; 313 } 314 } 315 pub const IPPROTO_ICMP: c_int = 1; 316 pub const IPPROTO_ICMPV6: c_int = 58; 317 pub const IPPROTO_TCP: c_int = 6; 318 pub const IPPROTO_UDP: c_int = 17; 319 pub const IPPROTO_IP: c_int = 0; 320 pub const IPPROTO_IPV6: c_int = 41; 321 322 pub const INADDR_LOOPBACK: in_addr_t = 2130706433; 323 pub const INADDR_ANY: in_addr_t = 0; 324 pub const INADDR_BROADCAST: in_addr_t = 4294967295; 325 pub const INADDR_NONE: in_addr_t = 4294967295; 326 327 pub const IN6ADDR_LOOPBACK_INIT: in6_addr = in6_addr { 328 s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], 329 }; 330 331 pub const IN6ADDR_ANY_INIT: in6_addr = in6_addr { 332 s6_addr: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 333 }; 334 335 pub const ARPOP_REQUEST: u16 = 1; 336 pub const ARPOP_REPLY: u16 = 2; 337 338 pub const ATF_COM: c_int = 0x02; 339 pub const ATF_PERM: c_int = 0x04; 340 pub const ATF_PUBL: c_int = 0x08; 341 pub const ATF_USETRAILERS: c_int = 0x10; 342 343 cfg_if! { 344 if #[cfg(any(target_os = "nto", target_os = "aix"))] { 345 pub const FNM_PERIOD: c_int = 1 << 1; 346 } else { 347 pub const FNM_PERIOD: c_int = 1 << 2; 348 } 349 } 350 pub const FNM_NOMATCH: c_int = 1; 351 352 cfg_if! { 353 if #[cfg(any(target_os = "illumos", target_os = "solaris",))] { 354 pub const FNM_CASEFOLD: c_int = 1 << 3; 355 } else if #[cfg(not(target_os = "aix"))] { 356 pub const FNM_CASEFOLD: c_int = 1 << 4; 357 } 358 } 359 360 cfg_if! { 361 if #[cfg(any( 362 target_os = "macos", 363 target_os = "freebsd", 364 target_os = "android", 365 target_os = "openbsd", 366 target_os = "cygwin", 367 ))] { 368 pub const FNM_PATHNAME: c_int = 1 << 1; 369 } else { 370 pub const FNM_PATHNAME: c_int = 1 << 0; 371 } 372 } 373 374 cfg_if! { 375 if #[cfg(any( 376 target_os = "macos", 377 target_os = "freebsd", 378 target_os = "android", 379 target_os = "openbsd", 380 ))] { 381 pub const FNM_NOESCAPE: c_int = 1 << 0; 382 } else if #[cfg(target_os = "nto")] { 383 pub const FNM_NOESCAPE: c_int = 1 << 2; 384 } else if #[cfg(target_os = "aix")] { 385 pub const FNM_NOESCAPE: c_int = 1 << 3; 386 } else { 387 pub const FNM_NOESCAPE: c_int = 1 << 1; 388 } 389 } 390 391 extern "C" { 392 pub static in6addr_loopback: in6_addr; 393 pub static in6addr_any: in6_addr; 394 } 395 396 cfg_if! { 397 if #[cfg(any( 398 target_os = "l4re", 399 target_os = "espidf", 400 target_os = "nuttx" 401 ))] { 402 // required libraries are linked externally for these platforms: 403 // * L4Re 404 // * ESP-IDF 405 // * NuttX 406 } else if #[cfg(feature = "std")] { 407 // cargo build, don't pull in anything extra as the std dep 408 // already pulls in all libs. 409 } else if #[cfg(all( 410 any( 411 all( 412 target_os = "linux", 413 any(target_env = "gnu", target_env = "uclibc") 414 ), 415 target_os = "cygwin" 416 ), 417 feature = "rustc-dep-of-std" 418 ))] { 419 #[link( 420 name = "util", 421 kind = "static", 422 modifiers = "-bundle", 423 cfg(target_feature = "crt-static") 424 )] 425 #[link( 426 name = "rt", 427 kind = "static", 428 modifiers = "-bundle", 429 cfg(target_feature = "crt-static") 430 )] 431 #[link( 432 name = "pthread", 433 kind = "static", 434 modifiers = "-bundle", 435 cfg(target_feature = "crt-static") 436 )] 437 #[link( 438 name = "m", 439 kind = "static", 440 modifiers = "-bundle", 441 cfg(target_feature = "crt-static") 442 )] 443 #[link( 444 name = "dl", 445 kind = "static", 446 modifiers = "-bundle", 447 cfg(target_feature = "crt-static") 448 )] 449 #[link( 450 name = "c", 451 kind = "static", 452 modifiers = "-bundle", 453 cfg(target_feature = "crt-static") 454 )] 455 #[link( 456 name = "gcc_eh", 457 kind = "static", 458 modifiers = "-bundle", 459 cfg(target_feature = "crt-static") 460 )] 461 #[link( 462 name = "gcc", 463 kind = "static", 464 modifiers = "-bundle", 465 cfg(target_feature = "crt-static") 466 )] 467 #[link( 468 name = "c", 469 kind = "static", 470 modifiers = "-bundle", 471 cfg(target_feature = "crt-static") 472 )] 473 #[link(name = "util", cfg(not(target_feature = "crt-static")))] 474 #[link(name = "rt", cfg(not(target_feature = "crt-static")))] 475 #[link(name = "pthread", cfg(not(target_feature = "crt-static")))] 476 #[link(name = "m", cfg(not(target_feature = "crt-static")))] 477 #[link(name = "dl", cfg(not(target_feature = "crt-static")))] 478 #[link(name = "c", cfg(not(target_feature = "crt-static")))] 479 extern "C" {} 480 } else if #[cfg(any(target_env = "musl", target_env = "ohos"))] { 481 #[cfg_attr( 482 feature = "rustc-dep-of-std", 483 link( 484 name = "c", 485 kind = "static", 486 modifiers = "-bundle", 487 cfg(target_feature = "crt-static") 488 ) 489 )] 490 #[cfg_attr( 491 feature = "rustc-dep-of-std", 492 link(name = "c", cfg(not(target_feature = "crt-static"))) 493 )] 494 extern "C" {} 495 } else if #[cfg(target_os = "emscripten")] { 496 // Don't pass -lc to Emscripten, it breaks. See: 497 // https://github.com/emscripten-core/emscripten/issues/22758 498 } else if #[cfg(all(target_os = "android", feature = "rustc-dep-of-std"))] { 499 #[link( 500 name = "c", 501 kind = "static", 502 modifiers = "-bundle", 503 cfg(target_feature = "crt-static") 504 )] 505 #[link( 506 name = "m", 507 kind = "static", 508 modifiers = "-bundle", 509 cfg(target_feature = "crt-static") 510 )] 511 #[link(name = "m", cfg(not(target_feature = "crt-static")))] 512 #[link(name = "c", cfg(not(target_feature = "crt-static")))] 513 extern "C" {} 514 } else if #[cfg(any( 515 target_os = "macos", 516 target_os = "ios", 517 target_os = "tvos", 518 target_os = "watchos", 519 target_os = "visionos", 520 target_os = "android", 521 target_os = "openbsd", 522 target_os = "nto", 523 ))] { 524 #[link(name = "c")] 525 #[link(name = "m")] 526 extern "C" {} 527 } else if #[cfg(target_os = "haiku")] { 528 #[link(name = "root")] 529 #[link(name = "network")] 530 extern "C" {} 531 } else if #[cfg(target_env = "newlib")] { 532 #[link(name = "c")] 533 #[link(name = "m")] 534 extern "C" {} 535 } else if #[cfg(target_env = "illumos")] { 536 #[link(name = "c")] 537 #[link(name = "m")] 538 extern "C" {} 539 } else if #[cfg(target_os = "redox")] { 540 #[cfg_attr( 541 feature = "rustc-dep-of-std", 542 link( 543 name = "c", 544 kind = "static", 545 modifiers = "-bundle", 546 cfg(target_feature = "crt-static") 547 ) 548 )] 549 #[cfg_attr( 550 feature = "rustc-dep-of-std", 551 link(name = "c", cfg(not(target_feature = "crt-static"))) 552 )] 553 extern "C" {} 554 } else if #[cfg(target_os = "aix")] { 555 #[link(name = "c")] 556 #[link(name = "m")] 557 #[link(name = "bsd")] 558 #[link(name = "pthread")] 559 extern "C" {} 560 } else { 561 #[link(name = "c")] 562 #[link(name = "m")] 563 #[link(name = "rt")] 564 #[link(name = "pthread")] 565 extern "C" {} 566 } 567 } 568 569 cfg_if! { 570 if #[cfg(not(all(target_os = "linux", target_env = "gnu")))] { 571 missing! { 572 #[cfg_attr(feature = "extra_traits", derive(Debug))] 573 pub enum fpos_t {} // FIXME(unix): fill this out with a struct 574 } 575 } 576 } 577 578 missing! { 579 #[cfg_attr(feature = "extra_traits", derive(Debug))] 580 pub enum FILE {} 581 } 582 583 extern "C" { isalnum(c: c_int) -> c_int584 pub fn isalnum(c: c_int) -> c_int; isalpha(c: c_int) -> c_int585 pub fn isalpha(c: c_int) -> c_int; iscntrl(c: c_int) -> c_int586 pub fn iscntrl(c: c_int) -> c_int; isdigit(c: c_int) -> c_int587 pub fn isdigit(c: c_int) -> c_int; isgraph(c: c_int) -> c_int588 pub fn isgraph(c: c_int) -> c_int; islower(c: c_int) -> c_int589 pub fn islower(c: c_int) -> c_int; isprint(c: c_int) -> c_int590 pub fn isprint(c: c_int) -> c_int; ispunct(c: c_int) -> c_int591 pub fn ispunct(c: c_int) -> c_int; isspace(c: c_int) -> c_int592 pub fn isspace(c: c_int) -> c_int; isupper(c: c_int) -> c_int593 pub fn isupper(c: c_int) -> c_int; isxdigit(c: c_int) -> c_int594 pub fn isxdigit(c: c_int) -> c_int; isblank(c: c_int) -> c_int595 pub fn isblank(c: c_int) -> c_int; tolower(c: c_int) -> c_int596 pub fn tolower(c: c_int) -> c_int; toupper(c: c_int) -> c_int597 pub fn toupper(c: c_int) -> c_int; qsort( base: *mut c_void, num: size_t, size: size_t, compar: Option<unsafe extern "C" fn(*const c_void, *const c_void) -> c_int>, )598 pub fn qsort( 599 base: *mut c_void, 600 num: size_t, 601 size: size_t, 602 compar: Option<unsafe extern "C" fn(*const c_void, *const c_void) -> c_int>, 603 ); bsearch( key: *const c_void, base: *const c_void, num: size_t, size: size_t, compar: Option<unsafe extern "C" fn(*const c_void, *const c_void) -> c_int>, ) -> *mut c_void604 pub fn bsearch( 605 key: *const c_void, 606 base: *const c_void, 607 num: size_t, 608 size: size_t, 609 compar: Option<unsafe extern "C" fn(*const c_void, *const c_void) -> c_int>, 610 ) -> *mut c_void; 611 #[cfg_attr( 612 all(target_os = "macos", target_arch = "x86"), 613 link_name = "fopen$UNIX2003" 614 )] 615 #[cfg_attr(gnu_file_offset_bits64, link_name = "fopen64")] fopen(filename: *const c_char, mode: *const c_char) -> *mut FILE616 pub fn fopen(filename: *const c_char, mode: *const c_char) -> *mut FILE; 617 #[cfg_attr( 618 all(target_os = "macos", target_arch = "x86"), 619 link_name = "freopen$UNIX2003" 620 )] 621 #[cfg_attr(gnu_file_offset_bits64, link_name = "freopen64")] freopen(filename: *const c_char, mode: *const c_char, file: *mut FILE) -> *mut FILE622 pub fn freopen(filename: *const c_char, mode: *const c_char, file: *mut FILE) -> *mut FILE; 623 fflush(file: *mut FILE) -> c_int624 pub fn fflush(file: *mut FILE) -> c_int; fclose(file: *mut FILE) -> c_int625 pub fn fclose(file: *mut FILE) -> c_int; remove(filename: *const c_char) -> c_int626 pub fn remove(filename: *const c_char) -> c_int; rename(oldname: *const c_char, newname: *const c_char) -> c_int627 pub fn rename(oldname: *const c_char, newname: *const c_char) -> c_int; 628 #[cfg_attr(gnu_file_offset_bits64, link_name = "tmpfile64")] tmpfile() -> *mut FILE629 pub fn tmpfile() -> *mut FILE; setvbuf(stream: *mut FILE, buffer: *mut c_char, mode: c_int, size: size_t) -> c_int630 pub fn setvbuf(stream: *mut FILE, buffer: *mut c_char, mode: c_int, size: size_t) -> c_int; setbuf(stream: *mut FILE, buf: *mut c_char)631 pub fn setbuf(stream: *mut FILE, buf: *mut c_char); getchar() -> c_int632 pub fn getchar() -> c_int; putchar(c: c_int) -> c_int633 pub fn putchar(c: c_int) -> c_int; fgetc(stream: *mut FILE) -> c_int634 pub fn fgetc(stream: *mut FILE) -> c_int; fgets(buf: *mut c_char, n: c_int, stream: *mut FILE) -> *mut c_char635 pub fn fgets(buf: *mut c_char, n: c_int, stream: *mut FILE) -> *mut c_char; fputc(c: c_int, stream: *mut FILE) -> c_int636 pub fn fputc(c: c_int, stream: *mut FILE) -> c_int; 637 #[cfg_attr( 638 all(target_os = "macos", target_arch = "x86"), 639 link_name = "fputs$UNIX2003" 640 )] fputs(s: *const c_char, stream: *mut FILE) -> c_int641 pub fn fputs(s: *const c_char, stream: *mut FILE) -> c_int; puts(s: *const c_char) -> c_int642 pub fn puts(s: *const c_char) -> c_int; ungetc(c: c_int, stream: *mut FILE) -> c_int643 pub fn ungetc(c: c_int, stream: *mut FILE) -> c_int; fread(ptr: *mut c_void, size: size_t, nobj: size_t, stream: *mut FILE) -> size_t644 pub fn fread(ptr: *mut c_void, size: size_t, nobj: size_t, stream: *mut FILE) -> size_t; 645 #[cfg_attr( 646 all(target_os = "macos", target_arch = "x86"), 647 link_name = "fwrite$UNIX2003" 648 )] fwrite(ptr: *const c_void, size: size_t, nobj: size_t, stream: *mut FILE) -> size_t649 pub fn fwrite(ptr: *const c_void, size: size_t, nobj: size_t, stream: *mut FILE) -> size_t; fseek(stream: *mut FILE, offset: c_long, whence: c_int) -> c_int650 pub fn fseek(stream: *mut FILE, offset: c_long, whence: c_int) -> c_int; ftell(stream: *mut FILE) -> c_long651 pub fn ftell(stream: *mut FILE) -> c_long; rewind(stream: *mut FILE)652 pub fn rewind(stream: *mut FILE); 653 #[cfg_attr(target_os = "netbsd", link_name = "__fgetpos50")] 654 #[cfg_attr(gnu_file_offset_bits64, link_name = "fgetpos64")] fgetpos(stream: *mut FILE, ptr: *mut fpos_t) -> c_int655 pub fn fgetpos(stream: *mut FILE, ptr: *mut fpos_t) -> c_int; 656 #[cfg_attr(target_os = "netbsd", link_name = "__fsetpos50")] 657 #[cfg_attr(gnu_file_offset_bits64, link_name = "fsetpos64")] fsetpos(stream: *mut FILE, ptr: *const fpos_t) -> c_int658 pub fn fsetpos(stream: *mut FILE, ptr: *const fpos_t) -> c_int; feof(stream: *mut FILE) -> c_int659 pub fn feof(stream: *mut FILE) -> c_int; ferror(stream: *mut FILE) -> c_int660 pub fn ferror(stream: *mut FILE) -> c_int; clearerr(stream: *mut FILE)661 pub fn clearerr(stream: *mut FILE); perror(s: *const c_char)662 pub fn perror(s: *const c_char); atof(s: *const c_char) -> c_double663 pub fn atof(s: *const c_char) -> c_double; atoi(s: *const c_char) -> c_int664 pub fn atoi(s: *const c_char) -> c_int; atol(s: *const c_char) -> c_long665 pub fn atol(s: *const c_char) -> c_long; atoll(s: *const c_char) -> c_longlong666 pub fn atoll(s: *const c_char) -> c_longlong; 667 #[cfg_attr( 668 all(target_os = "macos", target_arch = "x86"), 669 link_name = "strtod$UNIX2003" 670 )] strtod(s: *const c_char, endp: *mut *mut c_char) -> c_double671 pub fn strtod(s: *const c_char, endp: *mut *mut c_char) -> c_double; strtof(s: *const c_char, endp: *mut *mut c_char) -> c_float672 pub fn strtof(s: *const c_char, endp: *mut *mut c_char) -> c_float; strtol(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_long673 pub fn strtol(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_long; strtoll(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_longlong674 pub fn strtoll(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_longlong; strtoul(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_ulong675 pub fn strtoul(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_ulong; strtoull(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_ulonglong676 pub fn strtoull(s: *const c_char, endp: *mut *mut c_char, base: c_int) -> c_ulonglong; 677 #[cfg_attr(target_os = "aix", link_name = "vec_calloc")] calloc(nobj: size_t, size: size_t) -> *mut c_void678 pub fn calloc(nobj: size_t, size: size_t) -> *mut c_void; 679 #[cfg_attr(target_os = "aix", link_name = "vec_malloc")] malloc(size: size_t) -> *mut c_void680 pub fn malloc(size: size_t) -> *mut c_void; realloc(p: *mut c_void, size: size_t) -> *mut c_void681 pub fn realloc(p: *mut c_void, size: size_t) -> *mut c_void; free(p: *mut c_void)682 pub fn free(p: *mut c_void); abort() -> !683 pub fn abort() -> !; exit(status: c_int) -> !684 pub fn exit(status: c_int) -> !; _exit(status: c_int) -> !685 pub fn _exit(status: c_int) -> !; 686 #[cfg_attr( 687 all(target_os = "macos", target_arch = "x86"), 688 link_name = "system$UNIX2003" 689 )] system(s: *const c_char) -> c_int690 pub fn system(s: *const c_char) -> c_int; getenv(s: *const c_char) -> *mut c_char691 pub fn getenv(s: *const c_char) -> *mut c_char; 692 strcpy(dst: *mut c_char, src: *const c_char) -> *mut c_char693 pub fn strcpy(dst: *mut c_char, src: *const c_char) -> *mut c_char; strncpy(dst: *mut c_char, src: *const c_char, n: size_t) -> *mut c_char694 pub fn strncpy(dst: *mut c_char, src: *const c_char, n: size_t) -> *mut c_char; stpcpy(dst: *mut c_char, src: *const c_char) -> *mut c_char695 pub fn stpcpy(dst: *mut c_char, src: *const c_char) -> *mut c_char; strcat(s: *mut c_char, ct: *const c_char) -> *mut c_char696 pub fn strcat(s: *mut c_char, ct: *const c_char) -> *mut c_char; strncat(s: *mut c_char, ct: *const c_char, n: size_t) -> *mut c_char697 pub fn strncat(s: *mut c_char, ct: *const c_char, n: size_t) -> *mut c_char; strcmp(cs: *const c_char, ct: *const c_char) -> c_int698 pub fn strcmp(cs: *const c_char, ct: *const c_char) -> c_int; strncmp(cs: *const c_char, ct: *const c_char, n: size_t) -> c_int699 pub fn strncmp(cs: *const c_char, ct: *const c_char, n: size_t) -> c_int; strcoll(cs: *const c_char, ct: *const c_char) -> c_int700 pub fn strcoll(cs: *const c_char, ct: *const c_char) -> c_int; strchr(cs: *const c_char, c: c_int) -> *mut c_char701 pub fn strchr(cs: *const c_char, c: c_int) -> *mut c_char; strrchr(cs: *const c_char, c: c_int) -> *mut c_char702 pub fn strrchr(cs: *const c_char, c: c_int) -> *mut c_char; strspn(cs: *const c_char, ct: *const c_char) -> size_t703 pub fn strspn(cs: *const c_char, ct: *const c_char) -> size_t; strcspn(cs: *const c_char, ct: *const c_char) -> size_t704 pub fn strcspn(cs: *const c_char, ct: *const c_char) -> size_t; strdup(cs: *const c_char) -> *mut c_char705 pub fn strdup(cs: *const c_char) -> *mut c_char; strndup(cs: *const c_char, n: size_t) -> *mut c_char706 pub fn strndup(cs: *const c_char, n: size_t) -> *mut c_char; strpbrk(cs: *const c_char, ct: *const c_char) -> *mut c_char707 pub fn strpbrk(cs: *const c_char, ct: *const c_char) -> *mut c_char; strstr(cs: *const c_char, ct: *const c_char) -> *mut c_char708 pub fn strstr(cs: *const c_char, ct: *const c_char) -> *mut c_char; strcasecmp(s1: *const c_char, s2: *const c_char) -> c_int709 pub fn strcasecmp(s1: *const c_char, s2: *const c_char) -> c_int; strncasecmp(s1: *const c_char, s2: *const c_char, n: size_t) -> c_int710 pub fn strncasecmp(s1: *const c_char, s2: *const c_char, n: size_t) -> c_int; strlen(cs: *const c_char) -> size_t711 pub fn strlen(cs: *const c_char) -> size_t; strnlen(cs: *const c_char, maxlen: size_t) -> size_t712 pub fn strnlen(cs: *const c_char, maxlen: size_t) -> size_t; 713 #[cfg_attr( 714 all(target_os = "macos", target_arch = "x86"), 715 link_name = "strerror$UNIX2003" 716 )] strerror(n: c_int) -> *mut c_char717 pub fn strerror(n: c_int) -> *mut c_char; strtok(s: *mut c_char, t: *const c_char) -> *mut c_char718 pub fn strtok(s: *mut c_char, t: *const c_char) -> *mut c_char; strtok_r(s: *mut c_char, t: *const c_char, p: *mut *mut c_char) -> *mut c_char719 pub fn strtok_r(s: *mut c_char, t: *const c_char, p: *mut *mut c_char) -> *mut c_char; strxfrm(s: *mut c_char, ct: *const c_char, n: size_t) -> size_t720 pub fn strxfrm(s: *mut c_char, ct: *const c_char, n: size_t) -> size_t; strsignal(sig: c_int) -> *mut c_char721 pub fn strsignal(sig: c_int) -> *mut c_char; wcslen(buf: *const wchar_t) -> size_t722 pub fn wcslen(buf: *const wchar_t) -> size_t; wcstombs(dest: *mut c_char, src: *const wchar_t, n: size_t) -> size_t723 pub fn wcstombs(dest: *mut c_char, src: *const wchar_t, n: size_t) -> size_t; 724 memchr(cx: *const c_void, c: c_int, n: size_t) -> *mut c_void725 pub fn memchr(cx: *const c_void, c: c_int, n: size_t) -> *mut c_void; wmemchr(cx: *const wchar_t, c: wchar_t, n: size_t) -> *mut wchar_t726 pub fn wmemchr(cx: *const wchar_t, c: wchar_t, n: size_t) -> *mut wchar_t; memcmp(cx: *const c_void, ct: *const c_void, n: size_t) -> c_int727 pub fn memcmp(cx: *const c_void, ct: *const c_void, n: size_t) -> c_int; memcpy(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void728 pub fn memcpy(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void; memmove(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void729 pub fn memmove(dest: *mut c_void, src: *const c_void, n: size_t) -> *mut c_void; memset(dest: *mut c_void, c: c_int, n: size_t) -> *mut c_void730 pub fn memset(dest: *mut c_void, c: c_int, n: size_t) -> *mut c_void; memccpy(dest: *mut c_void, src: *const c_void, c: c_int, n: size_t) -> *mut c_void731 pub fn memccpy(dest: *mut c_void, src: *const c_void, c: c_int, n: size_t) -> *mut c_void; 732 } 733 734 extern "C" { 735 #[cfg_attr(target_os = "netbsd", link_name = "__getpwnam50")] getpwnam(name: *const c_char) -> *mut passwd736 pub fn getpwnam(name: *const c_char) -> *mut passwd; 737 #[cfg_attr(target_os = "netbsd", link_name = "__getpwuid50")] getpwuid(uid: crate::uid_t) -> *mut passwd738 pub fn getpwuid(uid: crate::uid_t) -> *mut passwd; 739 fprintf(stream: *mut crate::FILE, format: *const c_char, ...) -> c_int740 pub fn fprintf(stream: *mut crate::FILE, format: *const c_char, ...) -> c_int; printf(format: *const c_char, ...) -> c_int741 pub fn printf(format: *const c_char, ...) -> c_int; snprintf(s: *mut c_char, n: size_t, format: *const c_char, ...) -> c_int742 pub fn snprintf(s: *mut c_char, n: size_t, format: *const c_char, ...) -> c_int; sprintf(s: *mut c_char, format: *const c_char, ...) -> c_int743 pub fn sprintf(s: *mut c_char, format: *const c_char, ...) -> c_int; 744 #[cfg_attr( 745 all(target_os = "linux", not(target_env = "uclibc")), 746 link_name = "__isoc99_fscanf" 747 )] fscanf(stream: *mut crate::FILE, format: *const c_char, ...) -> c_int748 pub fn fscanf(stream: *mut crate::FILE, format: *const c_char, ...) -> c_int; 749 #[cfg_attr( 750 all(target_os = "linux", not(target_env = "uclibc")), 751 link_name = "__isoc99_scanf" 752 )] scanf(format: *const c_char, ...) -> c_int753 pub fn scanf(format: *const c_char, ...) -> c_int; 754 #[cfg_attr( 755 all(target_os = "linux", not(target_env = "uclibc")), 756 link_name = "__isoc99_sscanf" 757 )] sscanf(s: *const c_char, format: *const c_char, ...) -> c_int758 pub fn sscanf(s: *const c_char, format: *const c_char, ...) -> c_int; getchar_unlocked() -> c_int759 pub fn getchar_unlocked() -> c_int; putchar_unlocked(c: c_int) -> c_int760 pub fn putchar_unlocked(c: c_int) -> c_int; 761 762 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 763 #[cfg_attr(target_os = "netbsd", link_name = "__socket30")] 764 #[cfg_attr(target_os = "illumos", link_name = "__xnet_socket")] 765 #[cfg_attr(target_os = "solaris", link_name = "__xnet7_socket")] 766 #[cfg_attr(target_os = "espidf", link_name = "lwip_socket")] socket(domain: c_int, ty: c_int, protocol: c_int) -> c_int767 pub fn socket(domain: c_int, ty: c_int, protocol: c_int) -> c_int; 768 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 769 #[cfg_attr( 770 all(target_os = "macos", target_arch = "x86"), 771 link_name = "connect$UNIX2003" 772 )] 773 #[cfg_attr( 774 any(target_os = "illumos", target_os = "solaris"), 775 link_name = "__xnet_connect" 776 )] 777 #[cfg_attr(target_os = "espidf", link_name = "lwip_connect")] connect(socket: c_int, address: *const sockaddr, len: socklen_t) -> c_int778 pub fn connect(socket: c_int, address: *const sockaddr, len: socklen_t) -> c_int; 779 #[cfg_attr( 780 all(target_os = "macos", target_arch = "x86"), 781 link_name = "listen$UNIX2003" 782 )] 783 #[cfg_attr(target_os = "espidf", link_name = "lwip_listen")] listen(socket: c_int, backlog: c_int) -> c_int784 pub fn listen(socket: c_int, backlog: c_int) -> c_int; 785 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 786 #[cfg_attr( 787 all(target_os = "macos", target_arch = "x86"), 788 link_name = "accept$UNIX2003" 789 )] 790 #[cfg_attr(target_os = "espidf", link_name = "lwip_accept")] 791 #[cfg_attr(target_os = "aix", link_name = "naccept")] accept(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int792 pub fn accept(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int; 793 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 794 #[cfg_attr( 795 all(target_os = "macos", target_arch = "x86"), 796 link_name = "getpeername$UNIX2003" 797 )] 798 #[cfg_attr(target_os = "espidf", link_name = "lwip_getpeername")] 799 #[cfg_attr(target_os = "aix", link_name = "ngetpeername")] getpeername(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int800 pub fn getpeername(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) 801 -> c_int; 802 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 803 #[cfg_attr( 804 all(target_os = "macos", target_arch = "x86"), 805 link_name = "getsockname$UNIX2003" 806 )] 807 #[cfg_attr(target_os = "espidf", link_name = "lwip_getsockname")] 808 #[cfg_attr(target_os = "aix", link_name = "ngetsockname")] getsockname(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) -> c_int809 pub fn getsockname(socket: c_int, address: *mut sockaddr, address_len: *mut socklen_t) 810 -> c_int; 811 #[cfg_attr(target_os = "espidf", link_name = "lwip_setsockopt")] 812 #[cfg_attr(gnu_time_bits64, link_name = "__setsockopt64")] setsockopt( socket: c_int, level: c_int, name: c_int, value: *const c_void, option_len: socklen_t, ) -> c_int813 pub fn setsockopt( 814 socket: c_int, 815 level: c_int, 816 name: c_int, 817 value: *const c_void, 818 option_len: socklen_t, 819 ) -> c_int; 820 #[cfg_attr( 821 all(target_os = "macos", target_arch = "x86"), 822 link_name = "socketpair$UNIX2003" 823 )] 824 #[cfg_attr( 825 any(target_os = "illumos", target_os = "solaris"), 826 link_name = "__xnet_socketpair" 827 )] socketpair( domain: c_int, type_: c_int, protocol: c_int, socket_vector: *mut c_int, ) -> c_int828 pub fn socketpair( 829 domain: c_int, 830 type_: c_int, 831 protocol: c_int, 832 socket_vector: *mut c_int, 833 ) -> c_int; 834 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 835 #[cfg_attr( 836 all(target_os = "macos", target_arch = "x86"), 837 link_name = "sendto$UNIX2003" 838 )] 839 #[cfg_attr( 840 any(target_os = "illumos", target_os = "solaris"), 841 link_name = "__xnet_sendto" 842 )] 843 #[cfg_attr(target_os = "espidf", link_name = "lwip_sendto")] sendto( socket: c_int, buf: *const c_void, len: size_t, flags: c_int, addr: *const sockaddr, addrlen: socklen_t, ) -> ssize_t844 pub fn sendto( 845 socket: c_int, 846 buf: *const c_void, 847 len: size_t, 848 flags: c_int, 849 addr: *const sockaddr, 850 addrlen: socklen_t, 851 ) -> ssize_t; 852 #[cfg_attr(target_os = "espidf", link_name = "lwip_shutdown")] shutdown(socket: c_int, how: c_int) -> c_int853 pub fn shutdown(socket: c_int, how: c_int) -> c_int; 854 855 #[cfg_attr( 856 all(target_os = "macos", target_arch = "x86"), 857 link_name = "chmod$UNIX2003" 858 )] chmod(path: *const c_char, mode: mode_t) -> c_int859 pub fn chmod(path: *const c_char, mode: mode_t) -> c_int; 860 #[cfg_attr( 861 all(target_os = "macos", target_arch = "x86"), 862 link_name = "fchmod$UNIX2003" 863 )] fchmod(fd: c_int, mode: mode_t) -> c_int864 pub fn fchmod(fd: c_int, mode: mode_t) -> c_int; 865 866 #[cfg_attr( 867 all(target_os = "macos", not(target_arch = "aarch64")), 868 link_name = "fstat$INODE64" 869 )] 870 #[cfg_attr(target_os = "netbsd", link_name = "__fstat50")] 871 #[cfg_attr( 872 all(target_os = "freebsd", any(freebsd11, freebsd10)), 873 link_name = "fstat@FBSD_1.0" 874 )] 875 #[cfg_attr(gnu_time_bits64, link_name = "__fstat64_time64")] 876 #[cfg_attr( 877 all(not(gnu_time_bits64), gnu_file_offset_bits64), 878 link_name = "fstat64" 879 )] fstat(fildes: c_int, buf: *mut stat) -> c_int880 pub fn fstat(fildes: c_int, buf: *mut stat) -> c_int; 881 mkdir(path: *const c_char, mode: mode_t) -> c_int882 pub fn mkdir(path: *const c_char, mode: mode_t) -> c_int; 883 884 #[cfg_attr( 885 all(target_os = "macos", not(target_arch = "aarch64")), 886 link_name = "stat$INODE64" 887 )] 888 #[cfg_attr(target_os = "netbsd", link_name = "__stat50")] 889 #[cfg_attr( 890 all(target_os = "freebsd", any(freebsd11, freebsd10)), 891 link_name = "stat@FBSD_1.0" 892 )] 893 #[cfg_attr(gnu_time_bits64, link_name = "__stat64_time64")] 894 #[cfg_attr( 895 all(not(gnu_time_bits64), gnu_file_offset_bits64), 896 link_name = "stat64" 897 )] stat(path: *const c_char, buf: *mut stat) -> c_int898 pub fn stat(path: *const c_char, buf: *mut stat) -> c_int; 899 pclose(stream: *mut crate::FILE) -> c_int900 pub fn pclose(stream: *mut crate::FILE) -> c_int; 901 #[cfg_attr( 902 all(target_os = "macos", target_arch = "x86"), 903 link_name = "fdopen$UNIX2003" 904 )] fdopen(fd: c_int, mode: *const c_char) -> *mut crate::FILE905 pub fn fdopen(fd: c_int, mode: *const c_char) -> *mut crate::FILE; fileno(stream: *mut crate::FILE) -> c_int906 pub fn fileno(stream: *mut crate::FILE) -> c_int; 907 908 #[cfg_attr( 909 all(target_os = "macos", target_arch = "x86"), 910 link_name = "open$UNIX2003" 911 )] 912 #[cfg_attr(gnu_file_offset_bits64, link_name = "open64")] open(path: *const c_char, oflag: c_int, ...) -> c_int913 pub fn open(path: *const c_char, oflag: c_int, ...) -> c_int; 914 #[cfg_attr( 915 all(target_os = "macos", target_arch = "x86"), 916 link_name = "creat$UNIX2003" 917 )] 918 #[cfg_attr(gnu_file_offset_bits64, link_name = "creat64")] creat(path: *const c_char, mode: mode_t) -> c_int919 pub fn creat(path: *const c_char, mode: mode_t) -> c_int; 920 #[cfg_attr( 921 all(target_os = "macos", target_arch = "x86"), 922 link_name = "fcntl$UNIX2003" 923 )] 924 #[cfg_attr(gnu_time_bits64, link_name = "__fcntl_time64")] 925 #[cfg_attr( 926 all(not(gnu_time_bits64), gnu_file_offset_bits64), 927 link_name = "__fcntl_time64" 928 )] fcntl(fd: c_int, cmd: c_int, ...) -> c_int929 pub fn fcntl(fd: c_int, cmd: c_int, ...) -> c_int; 930 931 #[cfg_attr( 932 all(target_os = "macos", target_arch = "x86_64"), 933 link_name = "opendir$INODE64" 934 )] 935 #[cfg_attr( 936 all(target_os = "macos", target_arch = "x86"), 937 link_name = "opendir$INODE64$UNIX2003" 938 )] 939 #[cfg_attr(target_os = "netbsd", link_name = "__opendir30")] opendir(dirname: *const c_char) -> *mut crate::DIR940 pub fn opendir(dirname: *const c_char) -> *mut crate::DIR; 941 942 #[cfg_attr( 943 all(target_os = "macos", not(target_arch = "aarch64")), 944 link_name = "readdir$INODE64" 945 )] 946 #[cfg_attr(target_os = "netbsd", link_name = "__readdir30")] 947 #[cfg_attr( 948 all(target_os = "freebsd", any(freebsd11, freebsd10)), 949 link_name = "readdir@FBSD_1.0" 950 )] 951 #[cfg_attr(gnu_file_offset_bits64, link_name = "readdir64")] readdir(dirp: *mut crate::DIR) -> *mut crate::dirent952 pub fn readdir(dirp: *mut crate::DIR) -> *mut crate::dirent; 953 #[cfg_attr( 954 all(target_os = "macos", target_arch = "x86"), 955 link_name = "closedir$UNIX2003" 956 )] closedir(dirp: *mut crate::DIR) -> c_int957 pub fn closedir(dirp: *mut crate::DIR) -> c_int; 958 #[cfg_attr( 959 all(target_os = "macos", target_arch = "x86_64"), 960 link_name = "rewinddir$INODE64" 961 )] 962 #[cfg_attr( 963 all(target_os = "macos", target_arch = "x86"), 964 link_name = "rewinddir$INODE64$UNIX2003" 965 )] rewinddir(dirp: *mut crate::DIR)966 pub fn rewinddir(dirp: *mut crate::DIR); 967 fchmodat(dirfd: c_int, pathname: *const c_char, mode: mode_t, flags: c_int) -> c_int968 pub fn fchmodat(dirfd: c_int, pathname: *const c_char, mode: mode_t, flags: c_int) -> c_int; fchown(fd: c_int, owner: crate::uid_t, group: crate::gid_t) -> c_int969 pub fn fchown(fd: c_int, owner: crate::uid_t, group: crate::gid_t) -> c_int; fchownat( dirfd: c_int, pathname: *const c_char, owner: crate::uid_t, group: crate::gid_t, flags: c_int, ) -> c_int970 pub fn fchownat( 971 dirfd: c_int, 972 pathname: *const c_char, 973 owner: crate::uid_t, 974 group: crate::gid_t, 975 flags: c_int, 976 ) -> c_int; 977 #[cfg_attr( 978 all(target_os = "macos", not(target_arch = "aarch64")), 979 link_name = "fstatat$INODE64" 980 )] 981 #[cfg_attr( 982 all(target_os = "freebsd", any(freebsd11, freebsd10)), 983 link_name = "fstatat@FBSD_1.1" 984 )] 985 #[cfg_attr(gnu_time_bits64, link_name = "__fstatat64_time64")] 986 #[cfg_attr( 987 all(not(gnu_time_bits64), gnu_file_offset_bits64), 988 link_name = "fstatat64" 989 )] fstatat(dirfd: c_int, pathname: *const c_char, buf: *mut stat, flags: c_int) -> c_int990 pub fn fstatat(dirfd: c_int, pathname: *const c_char, buf: *mut stat, flags: c_int) -> c_int; linkat( olddirfd: c_int, oldpath: *const c_char, newdirfd: c_int, newpath: *const c_char, flags: c_int, ) -> c_int991 pub fn linkat( 992 olddirfd: c_int, 993 oldpath: *const c_char, 994 newdirfd: c_int, 995 newpath: *const c_char, 996 flags: c_int, 997 ) -> c_int; renameat( olddirfd: c_int, oldpath: *const c_char, newdirfd: c_int, newpath: *const c_char, ) -> c_int998 pub fn renameat( 999 olddirfd: c_int, 1000 oldpath: *const c_char, 1001 newdirfd: c_int, 1002 newpath: *const c_char, 1003 ) -> c_int; symlinkat(target: *const c_char, newdirfd: c_int, linkpath: *const c_char) -> c_int1004 pub fn symlinkat(target: *const c_char, newdirfd: c_int, linkpath: *const c_char) -> c_int; unlinkat(dirfd: c_int, pathname: *const c_char, flags: c_int) -> c_int1005 pub fn unlinkat(dirfd: c_int, pathname: *const c_char, flags: c_int) -> c_int; 1006 access(path: *const c_char, amode: c_int) -> c_int1007 pub fn access(path: *const c_char, amode: c_int) -> c_int; alarm(seconds: c_uint) -> c_uint1008 pub fn alarm(seconds: c_uint) -> c_uint; chdir(dir: *const c_char) -> c_int1009 pub fn chdir(dir: *const c_char) -> c_int; fchdir(dirfd: c_int) -> c_int1010 pub fn fchdir(dirfd: c_int) -> c_int; chown(path: *const c_char, uid: uid_t, gid: gid_t) -> c_int1011 pub fn chown(path: *const c_char, uid: uid_t, gid: gid_t) -> c_int; 1012 #[cfg_attr( 1013 all(target_os = "macos", target_arch = "x86"), 1014 link_name = "lchown$UNIX2003" 1015 )] lchown(path: *const c_char, uid: uid_t, gid: gid_t) -> c_int1016 pub fn lchown(path: *const c_char, uid: uid_t, gid: gid_t) -> c_int; 1017 #[cfg_attr( 1018 all(target_os = "macos", target_arch = "x86"), 1019 link_name = "close$NOCANCEL$UNIX2003" 1020 )] 1021 #[cfg_attr( 1022 all(target_os = "macos", target_arch = "x86_64"), 1023 link_name = "close$NOCANCEL" 1024 )] close(fd: c_int) -> c_int1025 pub fn close(fd: c_int) -> c_int; dup(fd: c_int) -> c_int1026 pub fn dup(fd: c_int) -> c_int; dup2(src: c_int, dst: c_int) -> c_int1027 pub fn dup2(src: c_int, dst: c_int) -> c_int; 1028 execl(path: *const c_char, arg0: *const c_char, ...) -> c_int1029 pub fn execl(path: *const c_char, arg0: *const c_char, ...) -> c_int; execle(path: *const c_char, arg0: *const c_char, ...) -> c_int1030 pub fn execle(path: *const c_char, arg0: *const c_char, ...) -> c_int; execlp(file: *const c_char, arg0: *const c_char, ...) -> c_int1031 pub fn execlp(file: *const c_char, arg0: *const c_char, ...) -> c_int; 1032 1033 // DIFF(main): changed to `*const *mut` in e77f551de9 execv(prog: *const c_char, argv: *const *const c_char) -> c_int1034 pub fn execv(prog: *const c_char, argv: *const *const c_char) -> c_int; execve( prog: *const c_char, argv: *const *const c_char, envp: *const *const c_char, ) -> c_int1035 pub fn execve( 1036 prog: *const c_char, 1037 argv: *const *const c_char, 1038 envp: *const *const c_char, 1039 ) -> c_int; execvp(c: *const c_char, argv: *const *const c_char) -> c_int1040 pub fn execvp(c: *const c_char, argv: *const *const c_char) -> c_int; 1041 fork() -> pid_t1042 pub fn fork() -> pid_t; fpathconf(filedes: c_int, name: c_int) -> c_long1043 pub fn fpathconf(filedes: c_int, name: c_int) -> c_long; getcwd(buf: *mut c_char, size: size_t) -> *mut c_char1044 pub fn getcwd(buf: *mut c_char, size: size_t) -> *mut c_char; getegid() -> gid_t1045 pub fn getegid() -> gid_t; geteuid() -> uid_t1046 pub fn geteuid() -> uid_t; getgid() -> gid_t1047 pub fn getgid() -> gid_t; getgroups(ngroups_max: c_int, groups: *mut gid_t) -> c_int1048 pub fn getgroups(ngroups_max: c_int, groups: *mut gid_t) -> c_int; 1049 #[cfg_attr(target_os = "illumos", link_name = "getloginx")] getlogin() -> *mut c_char1050 pub fn getlogin() -> *mut c_char; 1051 #[cfg_attr( 1052 all(target_os = "macos", target_arch = "x86"), 1053 link_name = "getopt$UNIX2003" 1054 )] getopt(argc: c_int, argv: *const *mut c_char, optstr: *const c_char) -> c_int1055 pub fn getopt(argc: c_int, argv: *const *mut c_char, optstr: *const c_char) -> c_int; getpgid(pid: pid_t) -> pid_t1056 pub fn getpgid(pid: pid_t) -> pid_t; getpgrp() -> pid_t1057 pub fn getpgrp() -> pid_t; getpid() -> pid_t1058 pub fn getpid() -> pid_t; getppid() -> pid_t1059 pub fn getppid() -> pid_t; getuid() -> uid_t1060 pub fn getuid() -> uid_t; isatty(fd: c_int) -> c_int1061 pub fn isatty(fd: c_int) -> c_int; 1062 #[cfg_attr(target_os = "solaris", link_name = "__link_xpg4")] link(src: *const c_char, dst: *const c_char) -> c_int1063 pub fn link(src: *const c_char, dst: *const c_char) -> c_int; 1064 #[cfg_attr(gnu_file_offset_bits64, link_name = "lseek64")] lseek(fd: c_int, offset: off_t, whence: c_int) -> off_t1065 pub fn lseek(fd: c_int, offset: off_t, whence: c_int) -> off_t; pathconf(path: *const c_char, name: c_int) -> c_long1066 pub fn pathconf(path: *const c_char, name: c_int) -> c_long; pipe(fds: *mut c_int) -> c_int1067 pub fn pipe(fds: *mut c_int) -> c_int; posix_memalign(memptr: *mut *mut c_void, align: size_t, size: size_t) -> c_int1068 pub fn posix_memalign(memptr: *mut *mut c_void, align: size_t, size: size_t) -> c_int; aligned_alloc(alignment: size_t, size: size_t) -> *mut c_void1069 pub fn aligned_alloc(alignment: size_t, size: size_t) -> *mut c_void; 1070 #[cfg_attr( 1071 all(target_os = "macos", target_arch = "x86"), 1072 link_name = "read$UNIX2003" 1073 )] read(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t1074 pub fn read(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t; rmdir(path: *const c_char) -> c_int1075 pub fn rmdir(path: *const c_char) -> c_int; seteuid(uid: uid_t) -> c_int1076 pub fn seteuid(uid: uid_t) -> c_int; setegid(gid: gid_t) -> c_int1077 pub fn setegid(gid: gid_t) -> c_int; setgid(gid: gid_t) -> c_int1078 pub fn setgid(gid: gid_t) -> c_int; setpgid(pid: pid_t, pgid: pid_t) -> c_int1079 pub fn setpgid(pid: pid_t, pgid: pid_t) -> c_int; setsid() -> pid_t1080 pub fn setsid() -> pid_t; setuid(uid: uid_t) -> c_int1081 pub fn setuid(uid: uid_t) -> c_int; setreuid(ruid: uid_t, euid: uid_t) -> c_int1082 pub fn setreuid(ruid: uid_t, euid: uid_t) -> c_int; setregid(rgid: gid_t, egid: gid_t) -> c_int1083 pub fn setregid(rgid: gid_t, egid: gid_t) -> c_int; 1084 #[cfg_attr( 1085 all(target_os = "macos", target_arch = "x86"), 1086 link_name = "sleep$UNIX2003" 1087 )] sleep(secs: c_uint) -> c_uint1088 pub fn sleep(secs: c_uint) -> c_uint; 1089 #[cfg_attr( 1090 all(target_os = "macos", target_arch = "x86"), 1091 link_name = "nanosleep$UNIX2003" 1092 )] 1093 #[cfg_attr(target_os = "netbsd", link_name = "__nanosleep50")] 1094 #[cfg_attr(gnu_time_bits64, link_name = "__nanosleep64")] nanosleep(rqtp: *const timespec, rmtp: *mut timespec) -> c_int1095 pub fn nanosleep(rqtp: *const timespec, rmtp: *mut timespec) -> c_int; tcgetpgrp(fd: c_int) -> pid_t1096 pub fn tcgetpgrp(fd: c_int) -> pid_t; tcsetpgrp(fd: c_int, pgrp: crate::pid_t) -> c_int1097 pub fn tcsetpgrp(fd: c_int, pgrp: crate::pid_t) -> c_int; ttyname(fd: c_int) -> *mut c_char1098 pub fn ttyname(fd: c_int) -> *mut c_char; 1099 #[cfg_attr( 1100 all(target_os = "macos", target_arch = "x86"), 1101 link_name = "ttyname_r$UNIX2003" 1102 )] 1103 #[cfg_attr( 1104 any(target_os = "illumos", target_os = "solaris"), 1105 link_name = "__posix_ttyname_r" 1106 )] ttyname_r(fd: c_int, buf: *mut c_char, buflen: size_t) -> c_int1107 pub fn ttyname_r(fd: c_int, buf: *mut c_char, buflen: size_t) -> c_int; unlink(c: *const c_char) -> c_int1108 pub fn unlink(c: *const c_char) -> c_int; 1109 #[cfg_attr( 1110 all(target_os = "macos", target_arch = "x86"), 1111 link_name = "wait$UNIX2003" 1112 )] wait(status: *mut c_int) -> pid_t1113 pub fn wait(status: *mut c_int) -> pid_t; 1114 #[cfg_attr( 1115 all(target_os = "macos", target_arch = "x86"), 1116 link_name = "waitpid$UNIX2003" 1117 )] waitpid(pid: pid_t, status: *mut c_int, options: c_int) -> pid_t1118 pub fn waitpid(pid: pid_t, status: *mut c_int, options: c_int) -> pid_t; 1119 #[cfg_attr( 1120 all(target_os = "macos", target_arch = "x86"), 1121 link_name = "write$UNIX2003" 1122 )] write(fd: c_int, buf: *const c_void, count: size_t) -> ssize_t1123 pub fn write(fd: c_int, buf: *const c_void, count: size_t) -> ssize_t; 1124 #[cfg_attr( 1125 all(target_os = "macos", target_arch = "x86"), 1126 link_name = "pread$UNIX2003" 1127 )] 1128 #[cfg_attr(gnu_file_offset_bits64, link_name = "pread64")] pread(fd: c_int, buf: *mut c_void, count: size_t, offset: off_t) -> ssize_t1129 pub fn pread(fd: c_int, buf: *mut c_void, count: size_t, offset: off_t) -> ssize_t; 1130 #[cfg_attr( 1131 all(target_os = "macos", target_arch = "x86"), 1132 link_name = "pwrite$UNIX2003" 1133 )] 1134 #[cfg_attr(gnu_file_offset_bits64, link_name = "pwrite64")] pwrite(fd: c_int, buf: *const c_void, count: size_t, offset: off_t) -> ssize_t1135 pub fn pwrite(fd: c_int, buf: *const c_void, count: size_t, offset: off_t) -> ssize_t; umask(mask: mode_t) -> mode_t1136 pub fn umask(mask: mode_t) -> mode_t; 1137 1138 #[cfg_attr(target_os = "netbsd", link_name = "__utime50")] 1139 #[cfg_attr(gnu_time_bits64, link_name = "__utime64")] utime(file: *const c_char, buf: *const utimbuf) -> c_int1140 pub fn utime(file: *const c_char, buf: *const utimbuf) -> c_int; 1141 1142 #[cfg_attr( 1143 all(target_os = "macos", target_arch = "x86"), 1144 link_name = "kill$UNIX2003" 1145 )] kill(pid: pid_t, sig: c_int) -> c_int1146 pub fn kill(pid: pid_t, sig: c_int) -> c_int; 1147 #[cfg_attr( 1148 all(target_os = "macos", target_arch = "x86"), 1149 link_name = "killpg$UNIX2003" 1150 )] killpg(pgrp: pid_t, sig: c_int) -> c_int1151 pub fn killpg(pgrp: pid_t, sig: c_int) -> c_int; 1152 mlock(addr: *const c_void, len: size_t) -> c_int1153 pub fn mlock(addr: *const c_void, len: size_t) -> c_int; munlock(addr: *const c_void, len: size_t) -> c_int1154 pub fn munlock(addr: *const c_void, len: size_t) -> c_int; mlockall(flags: c_int) -> c_int1155 pub fn mlockall(flags: c_int) -> c_int; munlockall() -> c_int1156 pub fn munlockall() -> c_int; 1157 1158 #[cfg_attr( 1159 all(target_os = "macos", target_arch = "x86"), 1160 link_name = "mmap$UNIX2003" 1161 )] 1162 #[cfg_attr(gnu_file_offset_bits64, link_name = "mmap64")] mmap( addr: *mut c_void, len: size_t, prot: c_int, flags: c_int, fd: c_int, offset: off_t, ) -> *mut c_void1163 pub fn mmap( 1164 addr: *mut c_void, 1165 len: size_t, 1166 prot: c_int, 1167 flags: c_int, 1168 fd: c_int, 1169 offset: off_t, 1170 ) -> *mut c_void; 1171 #[cfg_attr( 1172 all(target_os = "macos", target_arch = "x86"), 1173 link_name = "munmap$UNIX2003" 1174 )] munmap(addr: *mut c_void, len: size_t) -> c_int1175 pub fn munmap(addr: *mut c_void, len: size_t) -> c_int; 1176 if_nametoindex(ifname: *const c_char) -> c_uint1177 pub fn if_nametoindex(ifname: *const c_char) -> c_uint; if_indextoname(ifindex: c_uint, ifname: *mut c_char) -> *mut c_char1178 pub fn if_indextoname(ifindex: c_uint, ifname: *mut c_char) -> *mut c_char; 1179 1180 #[cfg_attr( 1181 all(target_os = "macos", not(target_arch = "aarch64")), 1182 link_name = "lstat$INODE64" 1183 )] 1184 #[cfg_attr(target_os = "netbsd", link_name = "__lstat50")] 1185 #[cfg_attr( 1186 all(target_os = "freebsd", any(freebsd11, freebsd10)), 1187 link_name = "lstat@FBSD_1.0" 1188 )] 1189 #[cfg_attr(gnu_time_bits64, link_name = "__lstat64_time64")] 1190 #[cfg_attr( 1191 all(not(gnu_time_bits64), gnu_file_offset_bits64), 1192 link_name = "lstat64" 1193 )] lstat(path: *const c_char, buf: *mut stat) -> c_int1194 pub fn lstat(path: *const c_char, buf: *mut stat) -> c_int; 1195 1196 #[cfg_attr( 1197 all(target_os = "macos", target_arch = "x86"), 1198 link_name = "fsync$UNIX2003" 1199 )] fsync(fd: c_int) -> c_int1200 pub fn fsync(fd: c_int) -> c_int; 1201 1202 #[cfg_attr( 1203 all(target_os = "macos", target_arch = "x86"), 1204 link_name = "setenv$UNIX2003" 1205 )] setenv(name: *const c_char, val: *const c_char, overwrite: c_int) -> c_int1206 pub fn setenv(name: *const c_char, val: *const c_char, overwrite: c_int) -> c_int; 1207 #[cfg_attr( 1208 all(target_os = "macos", target_arch = "x86"), 1209 link_name = "unsetenv$UNIX2003" 1210 )] 1211 #[cfg_attr(target_os = "netbsd", link_name = "__unsetenv13")] unsetenv(name: *const c_char) -> c_int1212 pub fn unsetenv(name: *const c_char) -> c_int; 1213 symlink(path1: *const c_char, path2: *const c_char) -> c_int1214 pub fn symlink(path1: *const c_char, path2: *const c_char) -> c_int; 1215 1216 #[cfg_attr(gnu_file_offset_bits64, link_name = "truncate64")] truncate(path: *const c_char, length: off_t) -> c_int1217 pub fn truncate(path: *const c_char, length: off_t) -> c_int; 1218 #[cfg_attr(gnu_file_offset_bits64, link_name = "ftruncate64")] ftruncate(fd: c_int, length: off_t) -> c_int1219 pub fn ftruncate(fd: c_int, length: off_t) -> c_int; 1220 signal(signum: c_int, handler: sighandler_t) -> sighandler_t1221 pub fn signal(signum: c_int, handler: sighandler_t) -> sighandler_t; 1222 1223 #[cfg_attr(target_os = "netbsd", link_name = "__getrusage50")] 1224 #[cfg_attr(gnu_time_bits64, link_name = "__getrusage64")] getrusage(resource: c_int, usage: *mut rusage) -> c_int1225 pub fn getrusage(resource: c_int, usage: *mut rusage) -> c_int; 1226 1227 #[cfg_attr( 1228 any( 1229 target_os = "macos", 1230 target_os = "ios", 1231 target_os = "tvos", 1232 target_os = "watchos", 1233 target_os = "visionos" 1234 ), 1235 link_name = "realpath$DARWIN_EXTSN" 1236 )] realpath(pathname: *const c_char, resolved: *mut c_char) -> *mut c_char1237 pub fn realpath(pathname: *const c_char, resolved: *mut c_char) -> *mut c_char; 1238 1239 #[cfg_attr(target_os = "netbsd", link_name = "__times13")] times(buf: *mut crate::tms) -> crate::clock_t1240 pub fn times(buf: *mut crate::tms) -> crate::clock_t; 1241 pthread_self() -> crate::pthread_t1242 pub fn pthread_self() -> crate::pthread_t; pthread_equal(t1: crate::pthread_t, t2: crate::pthread_t) -> c_int1243 pub fn pthread_equal(t1: crate::pthread_t, t2: crate::pthread_t) -> c_int; 1244 #[cfg_attr( 1245 all(target_os = "macos", target_arch = "x86"), 1246 link_name = "pthread_join$UNIX2003" 1247 )] pthread_join(native: crate::pthread_t, value: *mut *mut c_void) -> c_int1248 pub fn pthread_join(native: crate::pthread_t, value: *mut *mut c_void) -> c_int; pthread_exit(value: *mut c_void) -> !1249 pub fn pthread_exit(value: *mut c_void) -> !; pthread_attr_init(attr: *mut crate::pthread_attr_t) -> c_int1250 pub fn pthread_attr_init(attr: *mut crate::pthread_attr_t) -> c_int; pthread_attr_destroy(attr: *mut crate::pthread_attr_t) -> c_int1251 pub fn pthread_attr_destroy(attr: *mut crate::pthread_attr_t) -> c_int; pthread_attr_getstacksize( attr: *const crate::pthread_attr_t, stacksize: *mut size_t, ) -> c_int1252 pub fn pthread_attr_getstacksize( 1253 attr: *const crate::pthread_attr_t, 1254 stacksize: *mut size_t, 1255 ) -> c_int; pthread_attr_setstacksize(attr: *mut crate::pthread_attr_t, stack_size: size_t) -> c_int1256 pub fn pthread_attr_setstacksize(attr: *mut crate::pthread_attr_t, stack_size: size_t) 1257 -> c_int; pthread_attr_setdetachstate(attr: *mut crate::pthread_attr_t, state: c_int) -> c_int1258 pub fn pthread_attr_setdetachstate(attr: *mut crate::pthread_attr_t, state: c_int) -> c_int; pthread_detach(thread: crate::pthread_t) -> c_int1259 pub fn pthread_detach(thread: crate::pthread_t) -> c_int; 1260 #[cfg_attr(target_os = "netbsd", link_name = "__libc_thr_yield")] sched_yield() -> c_int1261 pub fn sched_yield() -> c_int; pthread_key_create( key: *mut pthread_key_t, dtor: Option<unsafe extern "C" fn(*mut c_void)>, ) -> c_int1262 pub fn pthread_key_create( 1263 key: *mut pthread_key_t, 1264 dtor: Option<unsafe extern "C" fn(*mut c_void)>, 1265 ) -> c_int; pthread_key_delete(key: pthread_key_t) -> c_int1266 pub fn pthread_key_delete(key: pthread_key_t) -> c_int; pthread_getspecific(key: pthread_key_t) -> *mut c_void1267 pub fn pthread_getspecific(key: pthread_key_t) -> *mut c_void; pthread_setspecific(key: pthread_key_t, value: *const c_void) -> c_int1268 pub fn pthread_setspecific(key: pthread_key_t, value: *const c_void) -> c_int; pthread_mutex_init( lock: *mut pthread_mutex_t, attr: *const pthread_mutexattr_t, ) -> c_int1269 pub fn pthread_mutex_init( 1270 lock: *mut pthread_mutex_t, 1271 attr: *const pthread_mutexattr_t, 1272 ) -> c_int; pthread_mutex_destroy(lock: *mut pthread_mutex_t) -> c_int1273 pub fn pthread_mutex_destroy(lock: *mut pthread_mutex_t) -> c_int; pthread_mutex_lock(lock: *mut pthread_mutex_t) -> c_int1274 pub fn pthread_mutex_lock(lock: *mut pthread_mutex_t) -> c_int; pthread_mutex_trylock(lock: *mut pthread_mutex_t) -> c_int1275 pub fn pthread_mutex_trylock(lock: *mut pthread_mutex_t) -> c_int; pthread_mutex_unlock(lock: *mut pthread_mutex_t) -> c_int1276 pub fn pthread_mutex_unlock(lock: *mut pthread_mutex_t) -> c_int; 1277 pthread_mutexattr_init(attr: *mut pthread_mutexattr_t) -> c_int1278 pub fn pthread_mutexattr_init(attr: *mut pthread_mutexattr_t) -> c_int; 1279 #[cfg_attr( 1280 all(target_os = "macos", target_arch = "x86"), 1281 link_name = "pthread_mutexattr_destroy$UNIX2003" 1282 )] pthread_mutexattr_destroy(attr: *mut pthread_mutexattr_t) -> c_int1283 pub fn pthread_mutexattr_destroy(attr: *mut pthread_mutexattr_t) -> c_int; pthread_mutexattr_settype(attr: *mut pthread_mutexattr_t, _type: c_int) -> c_int1284 pub fn pthread_mutexattr_settype(attr: *mut pthread_mutexattr_t, _type: c_int) -> c_int; 1285 1286 #[cfg_attr( 1287 all(target_os = "macos", target_arch = "x86"), 1288 link_name = "pthread_cond_init$UNIX2003" 1289 )] pthread_cond_init(cond: *mut pthread_cond_t, attr: *const pthread_condattr_t) -> c_int1290 pub fn pthread_cond_init(cond: *mut pthread_cond_t, attr: *const pthread_condattr_t) -> c_int; 1291 #[cfg_attr( 1292 all(target_os = "macos", target_arch = "x86"), 1293 link_name = "pthread_cond_wait$UNIX2003" 1294 )] pthread_cond_wait(cond: *mut pthread_cond_t, lock: *mut pthread_mutex_t) -> c_int1295 pub fn pthread_cond_wait(cond: *mut pthread_cond_t, lock: *mut pthread_mutex_t) -> c_int; 1296 #[cfg_attr( 1297 all(target_os = "macos", target_arch = "x86"), 1298 link_name = "pthread_cond_timedwait$UNIX2003" 1299 )] 1300 #[cfg_attr(gnu_time_bits64, link_name = "__pthread_cond_timedwait64")] pthread_cond_timedwait( cond: *mut pthread_cond_t, lock: *mut pthread_mutex_t, abstime: *const crate::timespec, ) -> c_int1301 pub fn pthread_cond_timedwait( 1302 cond: *mut pthread_cond_t, 1303 lock: *mut pthread_mutex_t, 1304 abstime: *const crate::timespec, 1305 ) -> c_int; pthread_cond_signal(cond: *mut pthread_cond_t) -> c_int1306 pub fn pthread_cond_signal(cond: *mut pthread_cond_t) -> c_int; pthread_cond_broadcast(cond: *mut pthread_cond_t) -> c_int1307 pub fn pthread_cond_broadcast(cond: *mut pthread_cond_t) -> c_int; pthread_cond_destroy(cond: *mut pthread_cond_t) -> c_int1308 pub fn pthread_cond_destroy(cond: *mut pthread_cond_t) -> c_int; pthread_condattr_init(attr: *mut pthread_condattr_t) -> c_int1309 pub fn pthread_condattr_init(attr: *mut pthread_condattr_t) -> c_int; pthread_condattr_destroy(attr: *mut pthread_condattr_t) -> c_int1310 pub fn pthread_condattr_destroy(attr: *mut pthread_condattr_t) -> c_int; 1311 #[cfg_attr( 1312 all(target_os = "macos", target_arch = "x86"), 1313 link_name = "pthread_rwlock_init$UNIX2003" 1314 )] pthread_rwlock_init( lock: *mut pthread_rwlock_t, attr: *const pthread_rwlockattr_t, ) -> c_int1315 pub fn pthread_rwlock_init( 1316 lock: *mut pthread_rwlock_t, 1317 attr: *const pthread_rwlockattr_t, 1318 ) -> c_int; 1319 #[cfg_attr( 1320 all(target_os = "macos", target_arch = "x86"), 1321 link_name = "pthread_rwlock_destroy$UNIX2003" 1322 )] pthread_rwlock_destroy(lock: *mut pthread_rwlock_t) -> c_int1323 pub fn pthread_rwlock_destroy(lock: *mut pthread_rwlock_t) -> c_int; 1324 #[cfg_attr( 1325 all(target_os = "macos", target_arch = "x86"), 1326 link_name = "pthread_rwlock_rdlock$UNIX2003" 1327 )] pthread_rwlock_rdlock(lock: *mut pthread_rwlock_t) -> c_int1328 pub fn pthread_rwlock_rdlock(lock: *mut pthread_rwlock_t) -> c_int; 1329 #[cfg_attr( 1330 all(target_os = "macos", target_arch = "x86"), 1331 link_name = "pthread_rwlock_tryrdlock$UNIX2003" 1332 )] pthread_rwlock_tryrdlock(lock: *mut pthread_rwlock_t) -> c_int1333 pub fn pthread_rwlock_tryrdlock(lock: *mut pthread_rwlock_t) -> c_int; 1334 #[cfg_attr( 1335 all(target_os = "macos", target_arch = "x86"), 1336 link_name = "pthread_rwlock_wrlock$UNIX2003" 1337 )] pthread_rwlock_wrlock(lock: *mut pthread_rwlock_t) -> c_int1338 pub fn pthread_rwlock_wrlock(lock: *mut pthread_rwlock_t) -> c_int; 1339 #[cfg_attr( 1340 all(target_os = "macos", target_arch = "x86"), 1341 link_name = "pthread_rwlock_trywrlock$UNIX2003" 1342 )] pthread_rwlock_trywrlock(lock: *mut pthread_rwlock_t) -> c_int1343 pub fn pthread_rwlock_trywrlock(lock: *mut pthread_rwlock_t) -> c_int; 1344 #[cfg_attr( 1345 all(target_os = "macos", target_arch = "x86"), 1346 link_name = "pthread_rwlock_unlock$UNIX2003" 1347 )] pthread_rwlock_unlock(lock: *mut pthread_rwlock_t) -> c_int1348 pub fn pthread_rwlock_unlock(lock: *mut pthread_rwlock_t) -> c_int; pthread_rwlockattr_init(attr: *mut pthread_rwlockattr_t) -> c_int1349 pub fn pthread_rwlockattr_init(attr: *mut pthread_rwlockattr_t) -> c_int; pthread_rwlockattr_destroy(attr: *mut pthread_rwlockattr_t) -> c_int1350 pub fn pthread_rwlockattr_destroy(attr: *mut pthread_rwlockattr_t) -> c_int; 1351 1352 #[cfg_attr( 1353 any(target_os = "illumos", target_os = "solaris"), 1354 link_name = "__xnet_getsockopt" 1355 )] 1356 #[cfg_attr(target_os = "espidf", link_name = "lwip_getsockopt")] 1357 #[cfg_attr(gnu_time_bits64, link_name = "__getsockopt64")] getsockopt( sockfd: c_int, level: c_int, optname: c_int, optval: *mut c_void, optlen: *mut crate::socklen_t, ) -> c_int1358 pub fn getsockopt( 1359 sockfd: c_int, 1360 level: c_int, 1361 optname: c_int, 1362 optval: *mut c_void, 1363 optlen: *mut crate::socklen_t, 1364 ) -> c_int; raise(signum: c_int) -> c_int1365 pub fn raise(signum: c_int) -> c_int; 1366 1367 #[cfg_attr(target_os = "netbsd", link_name = "__utimes50")] 1368 #[cfg_attr(gnu_time_bits64, link_name = "__utimes64")] utimes(filename: *const c_char, times: *const crate::timeval) -> c_int1369 pub fn utimes(filename: *const c_char, times: *const crate::timeval) -> c_int; dlopen(filename: *const c_char, flag: c_int) -> *mut c_void1370 pub fn dlopen(filename: *const c_char, flag: c_int) -> *mut c_void; dlerror() -> *mut c_char1371 pub fn dlerror() -> *mut c_char; dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void1372 pub fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void; dlclose(handle: *mut c_void) -> c_int1373 pub fn dlclose(handle: *mut c_void) -> c_int; 1374 1375 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 1376 #[cfg_attr( 1377 any(target_os = "illumos", target_os = "solaris"), 1378 link_name = "__xnet_getaddrinfo" 1379 )] 1380 #[cfg_attr(target_os = "espidf", link_name = "lwip_getaddrinfo")] getaddrinfo( node: *const c_char, service: *const c_char, hints: *const addrinfo, res: *mut *mut addrinfo, ) -> c_int1381 pub fn getaddrinfo( 1382 node: *const c_char, 1383 service: *const c_char, 1384 hints: *const addrinfo, 1385 res: *mut *mut addrinfo, 1386 ) -> c_int; 1387 #[cfg(not(all(target_arch = "powerpc", target_vendor = "nintendo")))] 1388 #[cfg_attr(target_os = "espidf", link_name = "lwip_freeaddrinfo")] freeaddrinfo(res: *mut addrinfo)1389 pub fn freeaddrinfo(res: *mut addrinfo); hstrerror(errcode: c_int) -> *const c_char1390 pub fn hstrerror(errcode: c_int) -> *const c_char; gai_strerror(errcode: c_int) -> *const c_char1391 pub fn gai_strerror(errcode: c_int) -> *const c_char; 1392 #[cfg_attr( 1393 any( 1394 all( 1395 target_os = "linux", 1396 not(any(target_env = "musl", target_env = "ohos")) 1397 ), 1398 target_os = "freebsd", 1399 target_os = "cygwin", 1400 target_os = "dragonfly", 1401 target_os = "haiku" 1402 ), 1403 link_name = "__res_init" 1404 )] 1405 #[cfg_attr( 1406 any( 1407 target_os = "macos", 1408 target_os = "ios", 1409 target_os = "tvos", 1410 target_os = "watchos", 1411 target_os = "visionos" 1412 ), 1413 link_name = "res_9_init" 1414 )] 1415 #[cfg_attr(target_os = "aix", link_name = "_res_init")] res_init() -> c_int1416 pub fn res_init() -> c_int; 1417 1418 #[cfg_attr(target_os = "netbsd", link_name = "__gmtime_r50")] 1419 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1420 // FIXME(time): for `time_t` 1421 #[cfg_attr(gnu_time_bits64, link_name = "__gmtime64_r")] gmtime_r(time_p: *const time_t, result: *mut tm) -> *mut tm1422 pub fn gmtime_r(time_p: *const time_t, result: *mut tm) -> *mut tm; 1423 #[cfg_attr(target_os = "netbsd", link_name = "__localtime_r50")] 1424 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1425 // FIXME(time): for `time_t` 1426 #[cfg_attr(gnu_time_bits64, link_name = "__localtime64_r")] localtime_r(time_p: *const time_t, result: *mut tm) -> *mut tm1427 pub fn localtime_r(time_p: *const time_t, result: *mut tm) -> *mut tm; 1428 #[cfg_attr( 1429 all(target_os = "macos", target_arch = "x86"), 1430 link_name = "mktime$UNIX2003" 1431 )] 1432 #[cfg_attr(target_os = "netbsd", link_name = "__mktime50")] 1433 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1434 // FIXME: for `time_t` 1435 #[cfg_attr(gnu_time_bits64, link_name = "__mktime64")] mktime(tm: *mut tm) -> time_t1436 pub fn mktime(tm: *mut tm) -> time_t; 1437 #[cfg_attr(target_os = "netbsd", link_name = "__time50")] 1438 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1439 // FIXME: for `time_t` 1440 #[cfg_attr(gnu_time_bits64, link_name = "__time64")] time(time: *mut time_t) -> time_t1441 pub fn time(time: *mut time_t) -> time_t; 1442 #[cfg_attr(target_os = "netbsd", link_name = "__gmtime50")] 1443 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1444 // FIXME(time): for `time_t` 1445 #[cfg_attr(gnu_time_bits64, link_name = "__gmtime64")] gmtime(time_p: *const time_t) -> *mut tm1446 pub fn gmtime(time_p: *const time_t) -> *mut tm; 1447 #[cfg_attr(target_os = "netbsd", link_name = "__locatime50")] 1448 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1449 // FIXME(time): for `time_t` 1450 #[cfg_attr(gnu_time_bits64, link_name = "__localtime64")] localtime(time_p: *const time_t) -> *mut tm1451 pub fn localtime(time_p: *const time_t) -> *mut tm; 1452 #[cfg_attr(target_os = "netbsd", link_name = "__difftime50")] 1453 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1454 // FIXME(time): for `time_t` 1455 #[cfg_attr(gnu_time_bits64, link_name = "__difftime64")] difftime(time1: time_t, time0: time_t) -> c_double1456 pub fn difftime(time1: time_t, time0: time_t) -> c_double; 1457 #[cfg(not(target_os = "aix"))] 1458 #[cfg_attr(target_os = "netbsd", link_name = "__timegm50")] 1459 #[cfg_attr(any(target_env = "musl", target_env = "ohos"), allow(deprecated))] 1460 // FIXME(time): for `time_t` 1461 #[cfg_attr(gnu_time_bits64, link_name = "__timegm64")] timegm(tm: *mut crate::tm) -> time_t1462 pub fn timegm(tm: *mut crate::tm) -> time_t; 1463 1464 #[cfg_attr(target_os = "netbsd", link_name = "__mknod50")] 1465 #[cfg_attr( 1466 all(target_os = "freebsd", any(freebsd11, freebsd10)), 1467 link_name = "mknod@FBSD_1.0" 1468 )] mknod(pathname: *const c_char, mode: mode_t, dev: crate::dev_t) -> c_int1469 pub fn mknod(pathname: *const c_char, mode: mode_t, dev: crate::dev_t) -> c_int; gethostname(name: *mut c_char, len: size_t) -> c_int1470 pub fn gethostname(name: *mut c_char, len: size_t) -> c_int; endservent()1471 pub fn endservent(); getservbyname(name: *const c_char, proto: *const c_char) -> *mut servent1472 pub fn getservbyname(name: *const c_char, proto: *const c_char) -> *mut servent; getservbyport(port: c_int, proto: *const c_char) -> *mut servent1473 pub fn getservbyport(port: c_int, proto: *const c_char) -> *mut servent; getservent() -> *mut servent1474 pub fn getservent() -> *mut servent; setservent(stayopen: c_int)1475 pub fn setservent(stayopen: c_int); getprotobyname(name: *const c_char) -> *mut protoent1476 pub fn getprotobyname(name: *const c_char) -> *mut protoent; getprotobynumber(proto: c_int) -> *mut protoent1477 pub fn getprotobynumber(proto: c_int) -> *mut protoent; chroot(name: *const c_char) -> c_int1478 pub fn chroot(name: *const c_char) -> c_int; 1479 #[cfg(target_os = "cygwin")] usleep(secs: useconds_t) -> c_int1480 pub fn usleep(secs: useconds_t) -> c_int; 1481 #[cfg_attr( 1482 all(target_os = "macos", target_arch = "x86"), 1483 link_name = "usleep$UNIX2003" 1484 )] 1485 #[cfg(not(target_os = "cygwin"))] usleep(secs: c_uint) -> c_int1486 pub fn usleep(secs: c_uint) -> c_int; 1487 #[cfg_attr( 1488 all(target_os = "macos", target_arch = "x86"), 1489 link_name = "send$UNIX2003" 1490 )] 1491 #[cfg_attr(target_os = "espidf", link_name = "lwip_send")] send(socket: c_int, buf: *const c_void, len: size_t, flags: c_int) -> ssize_t1492 pub fn send(socket: c_int, buf: *const c_void, len: size_t, flags: c_int) -> ssize_t; 1493 #[cfg_attr( 1494 all(target_os = "macos", target_arch = "x86"), 1495 link_name = "recv$UNIX2003" 1496 )] 1497 #[cfg_attr(target_os = "espidf", link_name = "lwip_recv")] recv(socket: c_int, buf: *mut c_void, len: size_t, flags: c_int) -> ssize_t1498 pub fn recv(socket: c_int, buf: *mut c_void, len: size_t, flags: c_int) -> ssize_t; 1499 #[cfg_attr( 1500 all(target_os = "macos", target_arch = "x86"), 1501 link_name = "putenv$UNIX2003" 1502 )] 1503 #[cfg_attr(target_os = "netbsd", link_name = "__putenv50")] putenv(string: *mut c_char) -> c_int1504 pub fn putenv(string: *mut c_char) -> c_int; 1505 #[cfg_attr( 1506 all(target_os = "macos", target_arch = "x86"), 1507 link_name = "poll$UNIX2003" 1508 )] poll(fds: *mut pollfd, nfds: nfds_t, timeout: c_int) -> c_int1509 pub fn poll(fds: *mut pollfd, nfds: nfds_t, timeout: c_int) -> c_int; 1510 #[cfg_attr( 1511 all(target_os = "macos", target_arch = "x86_64"), 1512 link_name = "select$1050" 1513 )] 1514 #[cfg_attr( 1515 all(target_os = "macos", target_arch = "x86"), 1516 link_name = "select$UNIX2003" 1517 )] 1518 #[cfg_attr(target_os = "netbsd", link_name = "__select50")] 1519 #[cfg_attr(target_os = "aix", link_name = "__fd_select")] 1520 #[cfg_attr(gnu_time_bits64, link_name = "__select64")] select( nfds: c_int, readfds: *mut fd_set, writefds: *mut fd_set, errorfds: *mut fd_set, timeout: *mut timeval, ) -> c_int1521 pub fn select( 1522 nfds: c_int, 1523 readfds: *mut fd_set, 1524 writefds: *mut fd_set, 1525 errorfds: *mut fd_set, 1526 timeout: *mut timeval, 1527 ) -> c_int; 1528 #[cfg_attr(target_os = "netbsd", link_name = "__setlocale50")] setlocale(category: c_int, locale: *const c_char) -> *mut c_char1529 pub fn setlocale(category: c_int, locale: *const c_char) -> *mut c_char; localeconv() -> *mut lconv1530 pub fn localeconv() -> *mut lconv; 1531 1532 #[cfg_attr( 1533 all(target_os = "macos", target_arch = "x86"), 1534 link_name = "sem_wait$UNIX2003" 1535 )] sem_wait(sem: *mut sem_t) -> c_int1536 pub fn sem_wait(sem: *mut sem_t) -> c_int; sem_trywait(sem: *mut sem_t) -> c_int1537 pub fn sem_trywait(sem: *mut sem_t) -> c_int; sem_post(sem: *mut sem_t) -> c_int1538 pub fn sem_post(sem: *mut sem_t) -> c_int; 1539 #[cfg_attr(gnu_file_offset_bits64, link_name = "statvfs64")] statvfs(path: *const c_char, buf: *mut statvfs) -> c_int1540 pub fn statvfs(path: *const c_char, buf: *mut statvfs) -> c_int; 1541 #[cfg_attr(gnu_file_offset_bits64, link_name = "fstatvfs64")] fstatvfs(fd: c_int, buf: *mut statvfs) -> c_int1542 pub fn fstatvfs(fd: c_int, buf: *mut statvfs) -> c_int; 1543 1544 #[cfg_attr(target_os = "netbsd", link_name = "__sigemptyset14")] sigemptyset(set: *mut sigset_t) -> c_int1545 pub fn sigemptyset(set: *mut sigset_t) -> c_int; 1546 #[cfg_attr(target_os = "netbsd", link_name = "__sigaddset14")] sigaddset(set: *mut sigset_t, signum: c_int) -> c_int1547 pub fn sigaddset(set: *mut sigset_t, signum: c_int) -> c_int; 1548 #[cfg_attr(target_os = "netbsd", link_name = "__sigfillset14")] sigfillset(set: *mut sigset_t) -> c_int1549 pub fn sigfillset(set: *mut sigset_t) -> c_int; 1550 #[cfg_attr(target_os = "netbsd", link_name = "__sigdelset14")] sigdelset(set: *mut sigset_t, signum: c_int) -> c_int1551 pub fn sigdelset(set: *mut sigset_t, signum: c_int) -> c_int; 1552 #[cfg_attr(target_os = "netbsd", link_name = "__sigismember14")] sigismember(set: *const sigset_t, signum: c_int) -> c_int1553 pub fn sigismember(set: *const sigset_t, signum: c_int) -> c_int; 1554 1555 #[cfg_attr(target_os = "netbsd", link_name = "__sigprocmask14")] sigprocmask(how: c_int, set: *const sigset_t, oldset: *mut sigset_t) -> c_int1556 pub fn sigprocmask(how: c_int, set: *const sigset_t, oldset: *mut sigset_t) -> c_int; 1557 #[cfg_attr(target_os = "netbsd", link_name = "__sigpending14")] sigpending(set: *mut sigset_t) -> c_int1558 pub fn sigpending(set: *mut sigset_t) -> c_int; 1559 1560 #[cfg_attr(target_os = "solaris", link_name = "__sysconf_xpg7")] sysconf(name: c_int) -> c_long1561 pub fn sysconf(name: c_int) -> c_long; 1562 mkfifo(path: *const c_char, mode: mode_t) -> c_int1563 pub fn mkfifo(path: *const c_char, mode: mode_t) -> c_int; 1564 1565 #[cfg_attr(gnu_file_offset_bits64, link_name = "fseeko64")] fseeko(stream: *mut crate::FILE, offset: off_t, whence: c_int) -> c_int1566 pub fn fseeko(stream: *mut crate::FILE, offset: off_t, whence: c_int) -> c_int; 1567 #[cfg_attr(gnu_file_offset_bits64, link_name = "ftello64")] ftello(stream: *mut crate::FILE) -> off_t1568 pub fn ftello(stream: *mut crate::FILE) -> off_t; 1569 #[cfg_attr( 1570 all(target_os = "macos", target_arch = "x86"), 1571 link_name = "tcdrain$UNIX2003" 1572 )] tcdrain(fd: c_int) -> c_int1573 pub fn tcdrain(fd: c_int) -> c_int; cfgetispeed(termios: *const crate::termios) -> crate::speed_t1574 pub fn cfgetispeed(termios: *const crate::termios) -> crate::speed_t; cfgetospeed(termios: *const crate::termios) -> crate::speed_t1575 pub fn cfgetospeed(termios: *const crate::termios) -> crate::speed_t; cfsetispeed(termios: *mut crate::termios, speed: crate::speed_t) -> c_int1576 pub fn cfsetispeed(termios: *mut crate::termios, speed: crate::speed_t) -> c_int; cfsetospeed(termios: *mut crate::termios, speed: crate::speed_t) -> c_int1577 pub fn cfsetospeed(termios: *mut crate::termios, speed: crate::speed_t) -> c_int; tcgetattr(fd: c_int, termios: *mut crate::termios) -> c_int1578 pub fn tcgetattr(fd: c_int, termios: *mut crate::termios) -> c_int; tcsetattr(fd: c_int, optional_actions: c_int, termios: *const crate::termios) -> c_int1579 pub fn tcsetattr(fd: c_int, optional_actions: c_int, termios: *const crate::termios) -> c_int; tcflow(fd: c_int, action: c_int) -> c_int1580 pub fn tcflow(fd: c_int, action: c_int) -> c_int; tcflush(fd: c_int, action: c_int) -> c_int1581 pub fn tcflush(fd: c_int, action: c_int) -> c_int; tcgetsid(fd: c_int) -> crate::pid_t1582 pub fn tcgetsid(fd: c_int) -> crate::pid_t; tcsendbreak(fd: c_int, duration: c_int) -> c_int1583 pub fn tcsendbreak(fd: c_int, duration: c_int) -> c_int; 1584 #[cfg_attr(gnu_file_offset_bits64, link_name = "mkstemp64")] mkstemp(template: *mut c_char) -> c_int1585 pub fn mkstemp(template: *mut c_char) -> c_int; mkdtemp(template: *mut c_char) -> *mut c_char1586 pub fn mkdtemp(template: *mut c_char) -> *mut c_char; 1587 tmpnam(ptr: *mut c_char) -> *mut c_char1588 pub fn tmpnam(ptr: *mut c_char) -> *mut c_char; 1589 openlog(ident: *const c_char, logopt: c_int, facility: c_int)1590 pub fn openlog(ident: *const c_char, logopt: c_int, facility: c_int); closelog()1591 pub fn closelog(); setlogmask(maskpri: c_int) -> c_int1592 pub fn setlogmask(maskpri: c_int) -> c_int; 1593 #[cfg_attr(target_os = "macos", link_name = "syslog$DARWIN_EXTSN")] syslog(priority: c_int, message: *const c_char, ...)1594 pub fn syslog(priority: c_int, message: *const c_char, ...); 1595 #[cfg_attr( 1596 all(target_os = "macos", target_arch = "x86"), 1597 link_name = "nice$UNIX2003" 1598 )] nice(incr: c_int) -> c_int1599 pub fn nice(incr: c_int) -> c_int; 1600 grantpt(fd: c_int) -> c_int1601 pub fn grantpt(fd: c_int) -> c_int; posix_openpt(flags: c_int) -> c_int1602 pub fn posix_openpt(flags: c_int) -> c_int; ptsname(fd: c_int) -> *mut c_char1603 pub fn ptsname(fd: c_int) -> *mut c_char; unlockpt(fd: c_int) -> c_int1604 pub fn unlockpt(fd: c_int) -> c_int; 1605 1606 #[cfg(not(target_os = "aix"))] strcasestr(cs: *const c_char, ct: *const c_char) -> *mut c_char1607 pub fn strcasestr(cs: *const c_char, ct: *const c_char) -> *mut c_char; getline(lineptr: *mut *mut c_char, n: *mut size_t, stream: *mut FILE) -> ssize_t1608 pub fn getline(lineptr: *mut *mut c_char, n: *mut size_t, stream: *mut FILE) -> ssize_t; 1609 1610 #[cfg_attr(gnu_file_offset_bits64, link_name = "lockf64")] lockf(fd: c_int, cmd: c_int, len: off_t) -> c_int1611 pub fn lockf(fd: c_int, cmd: c_int, len: off_t) -> c_int; 1612 1613 } 1614 1615 safe_f! { 1616 // It seems htonl, etc are macros on macOS. So we have to reimplement them. So let's 1617 // reimplement them for all UNIX platforms 1618 pub {const} fn htonl(hostlong: u32) -> u32 { 1619 u32::to_be(hostlong) 1620 } 1621 pub {const} fn htons(hostshort: u16) -> u16 { 1622 u16::to_be(hostshort) 1623 } 1624 pub {const} fn ntohl(netlong: u32) -> u32 { 1625 u32::from_be(netlong) 1626 } 1627 pub {const} fn ntohs(netshort: u16) -> u16 { 1628 u16::from_be(netshort) 1629 } 1630 } 1631 1632 cfg_if! { 1633 if #[cfg(not(any( 1634 target_os = "emscripten", 1635 target_os = "android", 1636 target_os = "haiku", 1637 target_os = "nto", 1638 target_os = "solaris", 1639 target_os = "cygwin", 1640 target_os = "aix", 1641 )))] { 1642 extern "C" { 1643 #[cfg_attr(gnu_time_bits64, link_name = "__adjtime64")] 1644 pub fn adjtime(delta: *const timeval, olddelta: *mut timeval) -> c_int; 1645 } 1646 } else if #[cfg(target_os = "solaris")] { 1647 extern "C" { 1648 pub fn adjtime(delta: *mut timeval, olddelta: *mut timeval) -> c_int; 1649 } 1650 } 1651 } 1652 1653 cfg_if! { 1654 if #[cfg(not(any( 1655 target_os = "emscripten", 1656 target_os = "android", 1657 target_os = "nto" 1658 )))] { 1659 extern "C" { 1660 pub fn stpncpy(dst: *mut c_char, src: *const c_char, n: size_t) -> *mut c_char; 1661 } 1662 } 1663 } 1664 1665 cfg_if! { 1666 if #[cfg(not(target_os = "android"))] { 1667 extern "C" { 1668 #[cfg_attr( 1669 all(target_os = "macos", target_arch = "x86"), 1670 link_name = "confstr$UNIX2003" 1671 )] 1672 #[cfg_attr(target_os = "solaris", link_name = "__confstr_xpg7")] 1673 pub fn confstr(name: c_int, buf: *mut c_char, len: size_t) -> size_t; 1674 } 1675 } 1676 } 1677 1678 cfg_if! { 1679 if #[cfg(not(target_os = "aix"))] { 1680 extern "C" { 1681 pub fn dladdr(addr: *const c_void, info: *mut Dl_info) -> c_int; 1682 } 1683 } 1684 } 1685 1686 cfg_if! { 1687 if #[cfg(not(target_os = "solaris"))] { 1688 extern "C" { 1689 pub fn flock(fd: c_int, operation: c_int) -> c_int; 1690 } 1691 } 1692 } 1693 1694 cfg_if! { 1695 if #[cfg(not(any(target_env = "uclibc", target_os = "nto")))] { 1696 extern "C" { 1697 pub fn open_wmemstream(ptr: *mut *mut wchar_t, sizeloc: *mut size_t) -> *mut FILE; 1698 } 1699 } 1700 } 1701 1702 cfg_if! { 1703 if #[cfg(not(target_os = "redox"))] { 1704 extern "C" { 1705 pub fn getsid(pid: pid_t) -> pid_t; 1706 #[cfg_attr( 1707 all(target_os = "macos", target_arch = "x86"), 1708 link_name = "pause$UNIX2003" 1709 )] 1710 pub fn pause() -> c_int; 1711 1712 pub fn mkdirat(dirfd: c_int, pathname: *const c_char, mode: mode_t) -> c_int; 1713 #[cfg_attr(gnu_file_offset_bits64, link_name = "openat64")] 1714 pub fn openat(dirfd: c_int, pathname: *const c_char, flags: c_int, ...) -> c_int; 1715 1716 #[cfg_attr( 1717 all(target_os = "macos", target_arch = "x86_64"), 1718 link_name = "fdopendir$INODE64" 1719 )] 1720 #[cfg_attr( 1721 all(target_os = "macos", target_arch = "x86"), 1722 link_name = "fdopendir$INODE64$UNIX2003" 1723 )] 1724 pub fn fdopendir(fd: c_int) -> *mut crate::DIR; 1725 1726 #[cfg_attr( 1727 all(target_os = "macos", not(target_arch = "aarch64")), 1728 link_name = "readdir_r$INODE64" 1729 )] 1730 #[cfg_attr(target_os = "netbsd", link_name = "__readdir_r30")] 1731 #[cfg_attr( 1732 all(target_os = "freebsd", any(freebsd11, freebsd10)), 1733 link_name = "readdir_r@FBSD_1.0" 1734 )] 1735 #[allow(non_autolinks)] // FIXME(docs): `<>` breaks line length limit. 1736 /// The 64-bit libc on Solaris and illumos only has readdir_r. If a 1737 /// 32-bit Solaris or illumos target is ever created, it should use 1738 /// __posix_readdir_r. See libc(3LIB) on Solaris or illumos: 1739 /// https://illumos.org/man/3lib/libc 1740 /// https://docs.oracle.com/cd/E36784_01/html/E36873/libc-3lib.html 1741 /// https://www.unix.com/man-page/opensolaris/3LIB/libc/ 1742 #[cfg_attr(gnu_file_offset_bits64, link_name = "readdir64_r")] 1743 pub fn readdir_r( 1744 dirp: *mut crate::DIR, 1745 entry: *mut crate::dirent, 1746 result: *mut *mut crate::dirent, 1747 ) -> c_int; 1748 } 1749 } 1750 } 1751 1752 cfg_if! { 1753 if #[cfg(target_os = "nto")] { 1754 extern "C" { 1755 pub fn readlinkat( 1756 dirfd: c_int, 1757 pathname: *const c_char, 1758 buf: *mut c_char, 1759 bufsiz: size_t, 1760 ) -> c_int; 1761 pub fn readlink(path: *const c_char, buf: *mut c_char, bufsz: size_t) -> c_int; 1762 pub fn pselect( 1763 nfds: c_int, 1764 readfds: *mut fd_set, 1765 writefds: *mut fd_set, 1766 errorfds: *mut fd_set, 1767 timeout: *mut timespec, 1768 sigmask: *const sigset_t, 1769 ) -> c_int; 1770 pub fn sigaction(signum: c_int, act: *const sigaction, oldact: *mut sigaction) 1771 -> c_int; 1772 } 1773 } else { 1774 extern "C" { 1775 pub fn readlinkat( 1776 dirfd: c_int, 1777 pathname: *const c_char, 1778 buf: *mut c_char, 1779 bufsiz: size_t, 1780 ) -> ssize_t; 1781 pub fn fmemopen(buf: *mut c_void, size: size_t, mode: *const c_char) -> *mut FILE; 1782 pub fn open_memstream(ptr: *mut *mut c_char, sizeloc: *mut size_t) -> *mut FILE; 1783 pub fn atexit(cb: extern "C" fn()) -> c_int; 1784 #[cfg_attr(target_os = "netbsd", link_name = "__sigaction14")] 1785 pub fn sigaction(signum: c_int, act: *const sigaction, oldact: *mut sigaction) 1786 -> c_int; 1787 pub fn readlink(path: *const c_char, buf: *mut c_char, bufsz: size_t) -> ssize_t; 1788 #[cfg_attr( 1789 all(target_os = "macos", target_arch = "x86_64"), 1790 link_name = "pselect$1050" 1791 )] 1792 #[cfg_attr( 1793 all(target_os = "macos", target_arch = "x86"), 1794 link_name = "pselect$UNIX2003" 1795 )] 1796 #[cfg_attr(target_os = "netbsd", link_name = "__pselect50")] 1797 #[cfg_attr(gnu_time_bits64, link_name = "__pselect64")] 1798 pub fn pselect( 1799 nfds: c_int, 1800 readfds: *mut fd_set, 1801 writefds: *mut fd_set, 1802 errorfds: *mut fd_set, 1803 timeout: *const timespec, 1804 sigmask: *const sigset_t, 1805 ) -> c_int; 1806 } 1807 } 1808 } 1809 1810 cfg_if! { 1811 if #[cfg(target_os = "aix")] { 1812 extern "C" { 1813 pub fn cfmakeraw(termios: *mut crate::termios) -> c_int; 1814 pub fn cfsetspeed(termios: *mut crate::termios, speed: crate::speed_t) -> c_int; 1815 } 1816 } else if #[cfg(not(any( 1817 target_os = "solaris", 1818 target_os = "illumos", 1819 target_os = "nto", 1820 )))] { 1821 extern "C" { 1822 pub fn cfmakeraw(termios: *mut crate::termios); 1823 pub fn cfsetspeed(termios: *mut crate::termios, speed: crate::speed_t) -> c_int; 1824 } 1825 } 1826 } 1827 1828 extern "C" { fnmatch(pattern: *const c_char, name: *const c_char, flags: c_int) -> c_int1829 pub fn fnmatch(pattern: *const c_char, name: *const c_char, flags: c_int) -> c_int; 1830 } 1831 1832 cfg_if! { 1833 if #[cfg(target_env = "newlib")] { 1834 mod newlib; 1835 pub use self::newlib::*; 1836 } else if #[cfg(any( 1837 target_os = "linux", 1838 target_os = "l4re", 1839 target_os = "android", 1840 target_os = "emscripten" 1841 ))] { 1842 mod linux_like; 1843 pub use self::linux_like::*; 1844 } else if #[cfg(any( 1845 target_os = "macos", 1846 target_os = "ios", 1847 target_os = "tvos", 1848 target_os = "watchos", 1849 target_os = "visionos", 1850 target_os = "freebsd", 1851 target_os = "dragonfly", 1852 target_os = "openbsd", 1853 target_os = "netbsd" 1854 ))] { 1855 mod bsd; 1856 pub use self::bsd::*; 1857 } else if #[cfg(any(target_os = "solaris", target_os = "illumos"))] { 1858 mod solarish; 1859 pub use self::solarish::*; 1860 } else if #[cfg(target_os = "haiku")] { 1861 mod haiku; 1862 pub use self::haiku::*; 1863 } else if #[cfg(target_os = "redox")] { 1864 mod redox; 1865 pub use self::redox::*; 1866 } else if #[cfg(target_os = "cygwin")] { 1867 mod cygwin; 1868 pub use self::cygwin::*; 1869 } else if #[cfg(target_os = "nto")] { 1870 mod nto; 1871 pub use self::nto::*; 1872 } else if #[cfg(target_os = "aix")] { 1873 mod aix; 1874 pub use self::aix::*; 1875 } else if #[cfg(target_os = "hurd")] { 1876 mod hurd; 1877 pub use self::hurd::*; 1878 } else if #[cfg(target_os = "nuttx")] { 1879 mod nuttx; 1880 pub use self::nuttx::*; 1881 } else { 1882 // Unknown target_os 1883 } 1884 } 1885