library/std/src/sys/windows/c.rs

   1 //! C definitions used by libnative that don't belong in liblibc
   2
   3 #![allow(nonstandard_style)]
   4 #![cfg_attr(test, allow(dead_code))]
   5 #![unstable(issue = "none", feature = "windows_c")]
   6
   7 use crate::os::raw::NonZero_c_ulong;
   8 use crate::os::raw::{c_char, c_int, c_long, c_longlong, c_uint, c_ulong, c_ushort};
   9 use crate::ptr;
  10
  11 use libc::{c_void, size_t, wchar_t};
  12
  13 #[path = "c/errors.rs"] // c.rs is included from two places so we need to specify this
  14 mod errors;
  15 pub use errors::*;
  16
  17 pub use self::EXCEPTION_DISPOSITION::*;
  18 pub use self::FILE_INFO_BY_HANDLE_CLASS::*;
  19
  20 pub type DWORD_PTR = ULONG_PTR;
  21 pub type DWORD = c_ulong;
  22 pub type NonZeroDWORD = NonZero_c_ulong;
  23 pub type HANDLE = LPVOID;
  24 pub type HINSTANCE = HANDLE;
  25 pub type HMODULE = HINSTANCE;
  26 pub type HRESULT = LONG;
  27 pub type BOOL = c_int;
  28 pub type BYTE = u8;
  29 pub type BOOLEAN = BYTE;
  30 pub type GROUP = c_uint;
  31 pub type LARGE_INTEGER = c_longlong;
  32 pub type LONG = c_long;
  33 pub type UINT = c_uint;
  34 pub type WCHAR = u16;
  35 pub type USHORT = c_ushort;
  36 pub type SIZE_T = usize;
  37 pub type WORD = u16;
  38 pub type CHAR = c_char;
  39 pub type ULONG_PTR = usize;
  40 pub type ULONG = c_ulong;
  41 pub type NTSTATUS = LONG;
  42 pub type ACCESS_MASK = DWORD;
  43
  44 pub type LPBOOL = *mut BOOL;
  45 pub type LPBYTE = *mut BYTE;
  46 pub type LPCSTR = *const CHAR;
  47 pub type LPCWSTR = *const WCHAR;
  48 pub type LPDWORD = *mut DWORD;
  49 pub type LPHANDLE = *mut HANDLE;
  50 pub type LPOVERLAPPED = *mut OVERLAPPED;
  51 pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
  52 pub type LPSECURITY_ATTRIBUTES = *mut SECURITY_ATTRIBUTES;
  53 pub type LPSTARTUPINFO = *mut STARTUPINFO;
  54 pub type LPVOID = *mut c_void;
  55 pub type LPWCH = *mut WCHAR;
  56 pub type LPWIN32_FIND_DATAW = *mut WIN32_FIND_DATAW;
  57 pub type LPWSADATA = *mut WSADATA;
  58 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;
  59 pub type LPWSTR = *mut WCHAR;
  60 pub type LPFILETIME = *mut FILETIME;
  61 pub type LPSYSTEM_INFO = *mut SYSTEM_INFO;
  62 pub type LPWSABUF = *mut WSABUF;
  63 pub type LPWSAOVERLAPPED = *mut c_void;
  64 pub type LPWSAOVERLAPPED_COMPLETION_ROUTINE = *mut c_void;
  65
  66 pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE;
  67 pub type PLARGE_INTEGER = *mut c_longlong;
  68 pub type PSRWLOCK = *mut SRWLOCK;
  69
  70 pub type SOCKET = crate::os::windows::raw::SOCKET;
  71 pub type socklen_t = c_int;
  72 pub type ADDRESS_FAMILY = USHORT;
  73
  74 pub const TRUE: BOOL = 1;
  75 pub const FALSE: BOOL = 0;
  76
  77 pub const CSTR_LESS_THAN: c_int = 1;
  78 pub const CSTR_EQUAL: c_int = 2;
  79 pub const CSTR_GREATER_THAN: c_int = 3;
  80
  81 pub const FILE_ATTRIBUTE_READONLY: DWORD = 0x1;
  82 pub const FILE_ATTRIBUTE_DIRECTORY: DWORD = 0x10;
  83 pub const FILE_ATTRIBUTE_REPARSE_POINT: DWORD = 0x400;
  84
  85 pub const FILE_SHARE_DELETE: DWORD = 0x4;
  86 pub const FILE_SHARE_READ: DWORD = 0x1;
  87 pub const FILE_SHARE_WRITE: DWORD = 0x2;
  88
  89 pub const CREATE_ALWAYS: DWORD = 2;
  90 pub const CREATE_NEW: DWORD = 1;
  91 pub const OPEN_ALWAYS: DWORD = 4;
  92 pub const OPEN_EXISTING: DWORD = 3;
  93 pub const TRUNCATE_EXISTING: DWORD = 5;
  94
  95 pub const FILE_WRITE_DATA: DWORD = 0x00000002;
  96 pub const FILE_APPEND_DATA: DWORD = 0x00000004;
  97 pub const FILE_WRITE_EA: DWORD = 0x00000010;
  98 pub const FILE_WRITE_ATTRIBUTES: DWORD = 0x00000100;
  99 pub const READ_CONTROL: DWORD = 0x00020000;
 100 pub const SYNCHRONIZE: DWORD = 0x00100000;
 101 pub const GENERIC_READ: DWORD = 0x80000000;
 102 pub const GENERIC_WRITE: DWORD = 0x40000000;
 103 pub const STANDARD_RIGHTS_WRITE: DWORD = READ_CONTROL;
 104 pub const FILE_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE
 105     | FILE_WRITE_DATA
 106     | FILE_WRITE_ATTRIBUTES
 107     | FILE_WRITE_EA
 108     | FILE_APPEND_DATA
 109     | SYNCHRONIZE;
 110
 111 pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000;
 112 pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000;
 113 pub const SECURITY_SQOS_PRESENT: DWORD = 0x00100000;
 114
 115 pub const FIONBIO: c_ulong = 0x8004667e;
 116
 117 #[repr(C)]
 118 #[derive(Copy)]
 119 pub struct WIN32_FIND_DATAW {
 120     pub dwFileAttributes: DWORD,
 121     pub ftCreationTime: FILETIME,
 122     pub ftLastAccessTime: FILETIME,
 123     pub ftLastWriteTime: FILETIME,
 124     pub nFileSizeHigh: DWORD,
 125     pub nFileSizeLow: DWORD,
 126     pub dwReserved0: DWORD,
 127     pub dwReserved1: DWORD,
 128     pub cFileName: [wchar_t; 260], // #define MAX_PATH 260
 129     pub cAlternateFileName: [wchar_t; 14],
 130 }
 131 impl Clone for WIN32_FIND_DATAW {
 132     fn clone(&self) -> Self {
 133         *self
 134     }
 135 }
 136
 137 pub const WSA_FLAG_OVERLAPPED: DWORD = 0x01;
 138 pub const WSA_FLAG_NO_HANDLE_INHERIT: DWORD = 0x80;
 139
 140 pub const WSADESCRIPTION_LEN: usize = 256;
 141 pub const WSASYS_STATUS_LEN: usize = 128;
 142 pub const WSAPROTOCOL_LEN: DWORD = 255;
 143 pub const INVALID_SOCKET: SOCKET = !0;
 144
 145 pub const MAX_PROTOCOL_CHAIN: DWORD = 7;
 146
 147 pub const MAXIMUM_REPARSE_DATA_BUFFER_SIZE: usize = 16 * 1024;
 148 pub const FSCTL_GET_REPARSE_POINT: DWORD = 0x900a8;
 149 pub const IO_REPARSE_TAG_SYMLINK: DWORD = 0xa000000c;
 150 pub const IO_REPARSE_TAG_MOUNT_POINT: DWORD = 0xa0000003;
 151 pub const SYMLINK_FLAG_RELATIVE: DWORD = 0x00000001;
 152 pub const FSCTL_SET_REPARSE_POINT: DWORD = 0x900a4;
 153
 154 pub const SYMBOLIC_LINK_FLAG_DIRECTORY: DWORD = 0x1;
 155 pub const SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE: DWORD = 0x2;
 156
 157 // Note that these are not actually HANDLEs, just values to pass to GetStdHandle
 158 pub const STD_INPUT_HANDLE: DWORD = -10i32 as DWORD;
 159 pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as DWORD;
 160 pub const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
 161
 162 pub const PROGRESS_CONTINUE: DWORD = 0;
 163
 164 pub const E_NOTIMPL: HRESULT = 0x80004001u32 as HRESULT;
 165
 166 pub const INVALID_HANDLE_VALUE: HANDLE = !0 as HANDLE;
 167
 168 pub const FACILITY_NT_BIT: DWORD = 0x1000_0000;
 169
 170 pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000;
 171 pub const FORMAT_MESSAGE_FROM_HMODULE: DWORD = 0x00000800;
 172 pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200;
 173
 174 pub const TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF;
 175
 176 pub const DLL_THREAD_DETACH: DWORD = 3;
 177 pub const DLL_PROCESS_DETACH: DWORD = 0;
 178
 179 pub const INFINITE: DWORD = !0;
 180
 181 pub const DUPLICATE_SAME_ACCESS: DWORD = 0x00000002;
 182
 183 pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = CONDITION_VARIABLE { ptr: ptr::null_mut() };
 184 pub const SRWLOCK_INIT: SRWLOCK = SRWLOCK { ptr: ptr::null_mut() };
 185
 186 pub const DETACHED_PROCESS: DWORD = 0x00000008;
 187 pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200;
 188 pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400;
 189 pub const STARTF_USESTDHANDLES: DWORD = 0x00000100;
 190
 191 pub const AF_INET: c_int = 2;
 192 pub const AF_INET6: c_int = 23;
 193 pub const SD_BOTH: c_int = 2;
 194 pub const SD_RECEIVE: c_int = 0;
 195 pub const SD_SEND: c_int = 1;
 196 pub const SOCK_DGRAM: c_int = 2;
 197 pub const SOCK_STREAM: c_int = 1;
 198 pub const SOCKET_ERROR: c_int = -1;
 199 pub const SOL_SOCKET: c_int = 0xffff;
 200 pub const SO_LINGER: c_int = 0x0080;
 201 pub const SO_RCVTIMEO: c_int = 0x1006;
 202 pub const SO_SNDTIMEO: c_int = 0x1005;
 203 pub const IPPROTO_IP: c_int = 0;
 204 pub const IPPROTO_TCP: c_int = 6;
 205 pub const IPPROTO_IPV6: c_int = 41;
 206 pub const TCP_NODELAY: c_int = 0x0001;
 207 pub const IP_TTL: c_int = 4;
 208 pub const IPV6_V6ONLY: c_int = 27;
 209 pub const SO_ERROR: c_int = 0x1007;
 210 pub const SO_BROADCAST: c_int = 0x0020;
 211 pub const IP_MULTICAST_LOOP: c_int = 11;
 212 pub const IPV6_MULTICAST_LOOP: c_int = 11;
 213 pub const IP_MULTICAST_TTL: c_int = 10;
 214 pub const IP_ADD_MEMBERSHIP: c_int = 12;
 215 pub const IP_DROP_MEMBERSHIP: c_int = 13;
 216 pub const IPV6_ADD_MEMBERSHIP: c_int = 12;
 217 pub const IPV6_DROP_MEMBERSHIP: c_int = 13;
 218 pub const MSG_PEEK: c_int = 0x2;
 219
 220 #[repr(C)]
 221 #[derive(Copy, Clone)]
 222 pub struct linger {
 223     pub l_onoff: c_ushort,
 224     pub l_linger: c_ushort,
 225 }
 226
 227 #[repr(C)]
 228 pub struct ip_mreq {
 229     pub imr_multiaddr: in_addr,
 230     pub imr_interface: in_addr,
 231 }
 232
 233 #[repr(C)]
 234 pub struct ipv6_mreq {
 235     pub ipv6mr_multiaddr: in6_addr,
 236     pub ipv6mr_interface: c_uint,
 237 }
 238
 239 pub const VOLUME_NAME_DOS: DWORD = 0x0;
 240 pub const MOVEFILE_REPLACE_EXISTING: DWORD = 1;
 241
 242 pub const FILE_BEGIN: DWORD = 0;
 243 pub const FILE_CURRENT: DWORD = 1;
 244 pub const FILE_END: DWORD = 2;
 245
 246 pub const WAIT_OBJECT_0: DWORD = 0x00000000;
 247 pub const WAIT_TIMEOUT: DWORD = 258;
 248 pub const WAIT_FAILED: DWORD = 0xFFFFFFFF;
 249
 250 pub const PIPE_ACCESS_INBOUND: DWORD = 0x00000001;
 251 pub const PIPE_ACCESS_OUTBOUND: DWORD = 0x00000002;
 252 pub const FILE_FLAG_FIRST_PIPE_INSTANCE: DWORD = 0x00080000;
 253 pub const FILE_FLAG_OVERLAPPED: DWORD = 0x40000000;
 254 pub const PIPE_WAIT: DWORD = 0x00000000;
 255 pub const PIPE_TYPE_BYTE: DWORD = 0x00000000;
 256 pub const PIPE_REJECT_REMOTE_CLIENTS: DWORD = 0x00000008;
 257 pub const PIPE_READMODE_BYTE: DWORD = 0x00000000;
 258
 259 pub const FD_SETSIZE: usize = 64;
 260
 261 pub const STACK_SIZE_PARAM_IS_A_RESERVATION: DWORD = 0x00010000;
 262
 263 pub const STATUS_SUCCESS: NTSTATUS = 0x00000000;
 264
 265 pub const BCRYPT_USE_SYSTEM_PREFERRED_RNG: DWORD = 0x00000002;
 266
 267 #[repr(C)]
 268 #[cfg(not(target_pointer_width = "64"))]
 269 pub struct WSADATA {
 270     pub wVersion: WORD,
 271     pub wHighVersion: WORD,
 272     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
 273     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
 274     pub iMaxSockets: u16,
 275     pub iMaxUdpDg: u16,
 276     pub lpVendorInfo: *mut u8,
 277 }
 278 #[repr(C)]
 279 #[cfg(target_pointer_width = "64")]
 280 pub struct WSADATA {
 281     pub wVersion: WORD,
 282     pub wHighVersion: WORD,
 283     pub iMaxSockets: u16,
 284     pub iMaxUdpDg: u16,
 285     pub lpVendorInfo: *mut u8,
 286     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
 287     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
 288 }
 289
 290 #[derive(Copy, Clone)]
 291 #[repr(C)]
 292 pub struct WSABUF {
 293     pub len: ULONG,
 294     pub buf: *mut CHAR,
 295 }
 296
 297 #[repr(C)]
 298 pub struct WSAPROTOCOL_INFO {
 299     pub dwServiceFlags1: DWORD,
 300     pub dwServiceFlags2: DWORD,
 301     pub dwServiceFlags3: DWORD,
 302     pub dwServiceFlags4: DWORD,
 303     pub dwProviderFlags: DWORD,
 304     pub ProviderId: GUID,
 305     pub dwCatalogEntryId: DWORD,
 306     pub ProtocolChain: WSAPROTOCOLCHAIN,
 307     pub iVersion: c_int,
 308     pub iAddressFamily: c_int,
 309     pub iMaxSockAddr: c_int,
 310     pub iMinSockAddr: c_int,
 311     pub iSocketType: c_int,
 312     pub iProtocol: c_int,
 313     pub iProtocolMaxOffset: c_int,
 314     pub iNetworkByteOrder: c_int,
 315     pub iSecurityScheme: c_int,
 316     pub dwMessageSize: DWORD,
 317     pub dwProviderReserved: DWORD,
 318     pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1],
 319 }
 320
 321 #[repr(C)]
 322 #[derive(Copy, Clone)]
 323 pub struct WIN32_FILE_ATTRIBUTE_DATA {
 324     pub dwFileAttributes: DWORD,
 325     pub ftCreationTime: FILETIME,
 326     pub ftLastAccessTime: FILETIME,
 327     pub ftLastWriteTime: FILETIME,
 328     pub nFileSizeHigh: DWORD,
 329     pub nFileSizeLow: DWORD,
 330 }
 331
 332 #[repr(C)]
 333 #[allow(dead_code)] // we only use some variants
 334 pub enum FILE_INFO_BY_HANDLE_CLASS {
 335     FileBasicInfo = 0,
 336     FileStandardInfo = 1,
 337     FileNameInfo = 2,
 338     FileRenameInfo = 3,
 339     FileDispositionInfo = 4,
 340     FileAllocationInfo = 5,
 341     FileEndOfFileInfo = 6,
 342     FileStreamInfo = 7,
 343     FileCompressionInfo = 8,
 344     FileAttributeTagInfo = 9,
 345     FileIdBothDirectoryInfo = 10,        // 0xA
 346     FileIdBothDirectoryRestartInfo = 11, // 0xB
 347     FileIoPriorityHintInfo = 12,         // 0xC
 348     FileRemoteProtocolInfo = 13,         // 0xD
 349     FileFullDirectoryInfo = 14,          // 0xE
 350     FileFullDirectoryRestartInfo = 15,   // 0xF
 351     FileStorageInfo = 16,                // 0x10
 352     FileAlignmentInfo = 17,              // 0x11
 353     FileIdInfo = 18,                     // 0x12
 354     FileIdExtdDirectoryInfo = 19,        // 0x13
 355     FileIdExtdDirectoryRestartInfo = 20, // 0x14
 356     MaximumFileInfoByHandlesClass,
 357 }
 358
 359 #[repr(C)]
 360 pub struct FILE_BASIC_INFO {
 361     pub CreationTime: LARGE_INTEGER,
 362     pub LastAccessTime: LARGE_INTEGER,
 363     pub LastWriteTime: LARGE_INTEGER,
 364     pub ChangeTime: LARGE_INTEGER,
 365     pub FileAttributes: DWORD,
 366 }
 367
 368 #[repr(C)]
 369 pub struct FILE_END_OF_FILE_INFO {
 370     pub EndOfFile: LARGE_INTEGER,
 371 }
 372
 373 #[repr(C)]
 374 pub struct REPARSE_DATA_BUFFER {
 375     pub ReparseTag: c_uint,
 376     pub ReparseDataLength: c_ushort,
 377     pub Reserved: c_ushort,
 378     pub rest: (),
 379 }
 380
 381 #[repr(C)]
 382 pub struct SYMBOLIC_LINK_REPARSE_BUFFER {
 383     pub SubstituteNameOffset: c_ushort,
 384     pub SubstituteNameLength: c_ushort,
 385     pub PrintNameOffset: c_ushort,
 386     pub PrintNameLength: c_ushort,
 387     pub Flags: c_ulong,
 388     pub PathBuffer: WCHAR,
 389 }
 390
 391 #[repr(C)]
 392 pub struct MOUNT_POINT_REPARSE_BUFFER {
 393     pub SubstituteNameOffset: c_ushort,
 394     pub SubstituteNameLength: c_ushort,
 395     pub PrintNameOffset: c_ushort,
 396     pub PrintNameLength: c_ushort,
 397     pub PathBuffer: WCHAR,
 398 }
 399
 400 pub type LPPROGRESS_ROUTINE = crate::option::Option<
 401     unsafe extern "system" fn(
 402         TotalFileSize: LARGE_INTEGER,
 403         TotalBytesTransferred: LARGE_INTEGER,
 404         StreamSize: LARGE_INTEGER,
 405         StreamBytesTransferred: LARGE_INTEGER,
 406         dwStreamNumber: DWORD,
 407         dwCallbackReason: DWORD,
 408         hSourceFile: HANDLE,
 409         hDestinationFile: HANDLE,
 410         lpData: LPVOID,
 411     ) -> DWORD,
 412 >;
 413
 414 #[repr(C)]
 415 pub struct CONDITION_VARIABLE {
 416     pub ptr: LPVOID,
 417 }
 418 #[repr(C)]
 419 pub struct SRWLOCK {
 420     pub ptr: LPVOID,
 421 }
 422 #[repr(C)]
 423 pub struct CRITICAL_SECTION {
 424     CriticalSectionDebug: LPVOID,
 425     LockCount: LONG,
 426     RecursionCount: LONG,
 427     OwningThread: HANDLE,
 428     LockSemaphore: HANDLE,
 429     SpinCount: ULONG_PTR,
 430 }
 431
 432 #[repr(C)]
 433 pub struct REPARSE_MOUNTPOINT_DATA_BUFFER {
 434     pub ReparseTag: DWORD,
 435     pub ReparseDataLength: DWORD,
 436     pub Reserved: WORD,
 437     pub ReparseTargetLength: WORD,
 438     pub ReparseTargetMaximumLength: WORD,
 439     pub Reserved1: WORD,
 440     pub ReparseTarget: WCHAR,
 441 }
 442
 443 #[repr(C)]
 444 pub struct GUID {
 445     pub Data1: DWORD,
 446     pub Data2: WORD,
 447     pub Data3: WORD,
 448     pub Data4: [BYTE; 8],
 449 }
 450
 451 #[repr(C)]
 452 pub struct WSAPROTOCOLCHAIN {
 453     pub ChainLen: c_int,
 454     pub ChainEntries: [DWORD; MAX_PROTOCOL_CHAIN as usize],
 455 }
 456
 457 #[repr(C)]
 458 pub struct SECURITY_ATTRIBUTES {
 459     pub nLength: DWORD,
 460     pub lpSecurityDescriptor: LPVOID,
 461     pub bInheritHandle: BOOL,
 462 }
 463
 464 #[repr(C)]
 465 pub struct PROCESS_INFORMATION {
 466     pub hProcess: HANDLE,
 467     pub hThread: HANDLE,
 468     pub dwProcessId: DWORD,
 469     pub dwThreadId: DWORD,
 470 }
 471
 472 #[repr(C)]
 473 pub struct STARTUPINFO {
 474     pub cb: DWORD,
 475     pub lpReserved: LPWSTR,
 476     pub lpDesktop: LPWSTR,
 477     pub lpTitle: LPWSTR,
 478     pub dwX: DWORD,
 479     pub dwY: DWORD,
 480     pub dwXSize: DWORD,
 481     pub dwYSize: DWORD,
 482     pub dwXCountChars: DWORD,
 483     pub dwYCountCharts: DWORD,
 484     pub dwFillAttribute: DWORD,
 485     pub dwFlags: DWORD,
 486     pub wShowWindow: WORD,
 487     pub cbReserved2: WORD,
 488     pub lpReserved2: LPBYTE,
 489     pub hStdInput: HANDLE,
 490     pub hStdOutput: HANDLE,
 491     pub hStdError: HANDLE,
 492 }
 493
 494 #[repr(C)]
 495 pub struct SOCKADDR {
 496     pub sa_family: ADDRESS_FAMILY,
 497     pub sa_data: [CHAR; 14],
 498 }
 499
 500 #[repr(C)]
 501 #[derive(Copy, Clone)]
 502 pub struct FILETIME {
 503     pub dwLowDateTime: DWORD,
 504     pub dwHighDateTime: DWORD,
 505 }
 506
 507 #[repr(C)]
 508 pub struct SYSTEM_INFO {
 509     pub wProcessorArchitecture: WORD,
 510     pub wReserved: WORD,
 511     pub dwPageSize: DWORD,
 512     pub lpMinimumApplicationAddress: LPVOID,
 513     pub lpMaximumApplicationAddress: LPVOID,
 514     pub dwActiveProcessorMask: DWORD_PTR,
 515     pub dwNumberOfProcessors: DWORD,
 516     pub dwProcessorType: DWORD,
 517     pub dwAllocationGranularity: DWORD,
 518     pub wProcessorLevel: WORD,
 519     pub wProcessorRevision: WORD,
 520 }
 521
 522 #[repr(C)]
 523 pub struct OVERLAPPED {
 524     pub Internal: *mut c_ulong,
 525     pub InternalHigh: *mut c_ulong,
 526     pub Offset: DWORD,
 527     pub OffsetHigh: DWORD,
 528     pub hEvent: HANDLE,
 529 }
 530
 531 #[repr(C)]
 532 #[allow(dead_code)] // we only use some variants
 533 pub enum ADDRESS_MODE {
 534     AddrMode1616,
 535     AddrMode1632,
 536     AddrModeReal,
 537     AddrModeFlat,
 538 }
 539
 540 #[repr(C)]
 541 pub struct SOCKADDR_STORAGE_LH {
 542     pub ss_family: ADDRESS_FAMILY,
 543     pub __ss_pad1: [CHAR; 6],
 544     pub __ss_align: i64,
 545     pub __ss_pad2: [CHAR; 112],
 546 }
 547
 548 #[repr(C)]
 549 pub struct ADDRINFOA {
 550     pub ai_flags: c_int,
 551     pub ai_family: c_int,
 552     pub ai_socktype: c_int,
 553     pub ai_protocol: c_int,
 554     pub ai_addrlen: size_t,
 555     pub ai_canonname: *mut c_char,
 556     pub ai_addr: *mut SOCKADDR,
 557     pub ai_next: *mut ADDRINFOA,
 558 }
 559
 560 #[repr(C)]
 561 #[derive(Copy, Clone)]
 562 pub struct sockaddr_in {
 563     pub sin_family: ADDRESS_FAMILY,
 564     pub sin_port: USHORT,
 565     pub sin_addr: in_addr,
 566     pub sin_zero: [CHAR; 8],
 567 }
 568
 569 #[repr(C)]
 570 #[derive(Copy, Clone)]
 571 pub struct sockaddr_in6 {
 572     pub sin6_family: ADDRESS_FAMILY,
 573     pub sin6_port: USHORT,
 574     pub sin6_flowinfo: c_ulong,
 575     pub sin6_addr: in6_addr,
 576     pub sin6_scope_id: c_ulong,
 577 }
 578
 579 #[repr(C)]
 580 #[derive(Copy, Clone)]
 581 pub struct in_addr {
 582     pub s_addr: u32,
 583 }
 584
 585 #[repr(C)]
 586 #[derive(Copy, Clone)]
 587 pub struct in6_addr {
 588     pub s6_addr: [u8; 16],
 589 }
 590
 591 #[repr(C)]
 592 #[derive(Copy, Clone)]
 593 #[allow(dead_code)] // we only use some variants
 594 pub enum EXCEPTION_DISPOSITION {
 595     ExceptionContinueExecution,
 596     ExceptionContinueSearch,
 597     ExceptionNestedException,
 598     ExceptionCollidedUnwind,
 599 }
 600
 601 #[repr(C)]
 602 #[derive(Copy)]
 603 pub struct fd_set {
 604     pub fd_count: c_uint,
 605     pub fd_array: [SOCKET; FD_SETSIZE],
 606 }
 607
 608 impl Clone for fd_set {
 609     fn clone(&self) -> fd_set {
 610         *self
 611     }
 612 }
 613
 614 #[repr(C)]
 615 #[derive(Copy, Clone)]
 616 pub struct timeval {
 617     pub tv_sec: c_long,
 618     pub tv_usec: c_long,
 619 }
 620
 621 // Desktop specific functions & types
 622 cfg_if::cfg_if! {
 623 if #[cfg(not(target_vendor = "uwp"))] {
 624     pub const EXCEPTION_CONTINUE_SEARCH: LONG = 0;
 625     pub const EXCEPTION_STACK_OVERFLOW: DWORD = 0xc00000fd;
 626     pub const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15;
 627
 628     #[repr(C)]
 629     pub struct EXCEPTION_RECORD {
 630         pub ExceptionCode: DWORD,
 631         pub ExceptionFlags: DWORD,
 632         pub ExceptionRecord: *mut EXCEPTION_RECORD,
 633         pub ExceptionAddress: LPVOID,
 634         pub NumberParameters: DWORD,
 635         pub ExceptionInformation: [LPVOID; EXCEPTION_MAXIMUM_PARAMETERS],
 636     }
 637
 638     pub enum CONTEXT {}
 639
 640     #[repr(C)]
 641     pub struct EXCEPTION_POINTERS {
 642         pub ExceptionRecord: *mut EXCEPTION_RECORD,
 643         pub ContextRecord: *mut CONTEXT,
 644     }
 645
 646     pub type PVECTORED_EXCEPTION_HANDLER =
 647         extern "system" fn(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG;
 648
 649     #[repr(C)]
 650     #[derive(Copy, Clone)]
 651     pub struct CONSOLE_READCONSOLE_CONTROL {
 652         pub nLength: ULONG,
 653         pub nInitialChars: ULONG,
 654         pub dwCtrlWakeupMask: ULONG,
 655         pub dwControlKeyState: ULONG,
 656     }
 657
 658     pub type PCONSOLE_READCONSOLE_CONTROL = *mut CONSOLE_READCONSOLE_CONTROL;
 659
 660     #[repr(C)]
 661     pub struct BY_HANDLE_FILE_INFORMATION {
 662         pub dwFileAttributes: DWORD,
 663         pub ftCreationTime: FILETIME,
 664         pub ftLastAccessTime: FILETIME,
 665         pub ftLastWriteTime: FILETIME,
 666         pub dwVolumeSerialNumber: DWORD,
 667         pub nFileSizeHigh: DWORD,
 668         pub nFileSizeLow: DWORD,
 669         pub nNumberOfLinks: DWORD,
 670         pub nFileIndexHigh: DWORD,
 671         pub nFileIndexLow: DWORD,
 672     }
 673
 674     pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION;
 675     pub type LPCVOID = *const c_void;
 676
 677     pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
 678
 679     pub const TOKEN_READ: DWORD = 0x20008;
 680
 681     #[link(name = "advapi32")]
 682     extern "system" {
 683         // Allowed but unused by UWP
 684         pub fn OpenProcessToken(
 685             ProcessHandle: HANDLE,
 686             DesiredAccess: DWORD,
 687             TokenHandle: *mut HANDLE,
 688         ) -> BOOL;
 689     }
 690
 691     #[link(name = "userenv")]
 692     extern "system" {
 693         // Allowed but unused by UWP
 694         pub fn GetUserProfileDirectoryW(
 695             hToken: HANDLE,
 696             lpProfileDir: LPWSTR,
 697             lpcchSize: *mut DWORD,
 698         ) -> BOOL;
 699     }
 700
 701     #[link(name = "kernel32")]
 702     extern "system" {
 703         // Functions forbidden when targeting UWP
 704         pub fn ReadConsoleW(
 705             hConsoleInput: HANDLE,
 706             lpBuffer: LPVOID,
 707             nNumberOfCharsToRead: DWORD,
 708             lpNumberOfCharsRead: LPDWORD,
 709             pInputControl: PCONSOLE_READCONSOLE_CONTROL,
 710         ) -> BOOL;
 711
 712         pub fn WriteConsoleW(
 713             hConsoleOutput: HANDLE,
 714             lpBuffer: LPCVOID,
 715             nNumberOfCharsToWrite: DWORD,
 716             lpNumberOfCharsWritten: LPDWORD,
 717             lpReserved: LPVOID,
 718         ) -> BOOL;
 719
 720         pub fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL;
 721         // Allowed but unused by UWP
 722         pub fn GetFileInformationByHandle(
 723             hFile: HANDLE,
 724             lpFileInformation: LPBY_HANDLE_FILE_INFORMATION,
 725         ) -> BOOL;
 726         pub fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) -> BOOL;
 727         pub fn AddVectoredExceptionHandler(
 728             FirstHandler: ULONG,
 729             VectoredHandler: PVECTORED_EXCEPTION_HANDLER,
 730         ) -> LPVOID;
 731         pub fn CreateHardLinkW(
 732             lpSymlinkFileName: LPCWSTR,
 733             lpTargetFileName: LPCWSTR,
 734             lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 735         ) -> BOOL;
 736         pub fn SetThreadStackGuarantee(_size: *mut c_ulong) -> BOOL;
 737     }
 738 }
 739 }
 740
 741 // UWP specific functions & types
 742 cfg_if::cfg_if! {
 743 if #[cfg(target_vendor = "uwp")] {
 744     #[repr(C)]
 745     pub struct FILE_STANDARD_INFO {
 746         pub AllocationSize: LARGE_INTEGER,
 747         pub EndOfFile: LARGE_INTEGER,
 748         pub NumberOfLinks: DWORD,
 749         pub DeletePending: BOOLEAN,
 750         pub Directory: BOOLEAN,
 751     }
 752
 753     #[link(name = "kernel32")]
 754     extern "system" {
 755         pub fn GetFileInformationByHandleEx(
 756             hFile: HANDLE,
 757             fileInfoClass: FILE_INFO_BY_HANDLE_CLASS,
 758             lpFileInformation: LPVOID,
 759             dwBufferSize: DWORD,
 760         ) -> BOOL;
 761     }
 762 }
 763 }
 764
 765 // Shared between Desktop & UWP
 766
 767 #[link(name = "kernel32")]
 768 extern "system" {
 769     pub fn GetCurrentProcessId() -> DWORD;
 770     pub fn InitializeCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 771     pub fn EnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 772     pub fn TryEnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION) -> BOOL;
 773     pub fn LeaveCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 774     pub fn DeleteCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 775
 776     pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
 777     pub fn SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: DWORD) -> BOOL;
 778     pub fn SetLastError(dwErrCode: DWORD);
 779     pub fn GetCommandLineW() -> LPWSTR;
 780     pub fn GetTempPathW(nBufferLength: DWORD, lpBuffer: LPCWSTR) -> DWORD;
 781     pub fn GetCurrentProcess() -> HANDLE;
 782     pub fn GetCurrentThread() -> HANDLE;
 783     pub fn GetStdHandle(which: DWORD) -> HANDLE;
 784     pub fn ExitProcess(uExitCode: c_uint) -> !;
 785     pub fn DeviceIoControl(
 786         hDevice: HANDLE,
 787         dwIoControlCode: DWORD,
 788         lpInBuffer: LPVOID,
 789         nInBufferSize: DWORD,
 790         lpOutBuffer: LPVOID,
 791         nOutBufferSize: DWORD,
 792         lpBytesReturned: LPDWORD,
 793         lpOverlapped: LPOVERLAPPED,
 794     ) -> BOOL;
 795     pub fn CreateThread(
 796         lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 797         dwStackSize: SIZE_T,
 798         lpStartAddress: extern "system" fn(*mut c_void) -> DWORD,
 799         lpParameter: LPVOID,
 800         dwCreationFlags: DWORD,
 801         lpThreadId: LPDWORD,
 802     ) -> HANDLE;
 803     pub fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
 804     pub fn SwitchToThread() -> BOOL;
 805     pub fn Sleep(dwMilliseconds: DWORD);
 806     pub fn GetProcessId(handle: HANDLE) -> DWORD;
 807     pub fn CopyFileExW(
 808         lpExistingFileName: LPCWSTR,
 809         lpNewFileName: LPCWSTR,
 810         lpProgressRoutine: LPPROGRESS_ROUTINE,
 811         lpData: LPVOID,
 812         pbCancel: LPBOOL,
 813         dwCopyFlags: DWORD,
 814     ) -> BOOL;
 815     pub fn FormatMessageW(
 816         flags: DWORD,
 817         lpSrc: LPVOID,
 818         msgId: DWORD,
 819         langId: DWORD,
 820         buf: LPWSTR,
 821         nsize: DWORD,
 822         args: *const c_void,
 823     ) -> DWORD;
 824     pub fn TlsAlloc() -> DWORD;
 825     pub fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID;
 826     pub fn TlsSetValue(dwTlsIndex: DWORD, lpTlsvalue: LPVOID) -> BOOL;
 827     pub fn GetLastError() -> DWORD;
 828     pub fn QueryPerformanceFrequency(lpFrequency: *mut LARGE_INTEGER) -> BOOL;
 829     pub fn QueryPerformanceCounter(lpPerformanceCount: *mut LARGE_INTEGER) -> BOOL;
 830     pub fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL;
 831     pub fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL;
 832     pub fn CreateProcessW(
 833         lpApplicationName: LPCWSTR,
 834         lpCommandLine: LPWSTR,
 835         lpProcessAttributes: LPSECURITY_ATTRIBUTES,
 836         lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 837         bInheritHandles: BOOL,
 838         dwCreationFlags: DWORD,
 839         lpEnvironment: LPVOID,
 840         lpCurrentDirectory: LPCWSTR,
 841         lpStartupInfo: LPSTARTUPINFO,
 842         lpProcessInformation: LPPROCESS_INFORMATION,
 843     ) -> BOOL;
 844     pub fn GetEnvironmentVariableW(n: LPCWSTR, v: LPWSTR, nsize: DWORD) -> DWORD;
 845     pub fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR) -> BOOL;
 846     pub fn GetEnvironmentStringsW() -> LPWCH;
 847     pub fn FreeEnvironmentStringsW(env_ptr: LPWCH) -> BOOL;
 848     pub fn GetModuleFileNameW(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD) -> DWORD;
 849     pub fn CreateDirectoryW(
 850         lpPathName: LPCWSTR,
 851         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 852     ) -> BOOL;
 853     pub fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
 854     pub fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
 855     pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
 856     pub fn DuplicateHandle(
 857         hSourceProcessHandle: HANDLE,
 858         hSourceHandle: HANDLE,
 859         hTargetProcessHandle: HANDLE,
 860         lpTargetHandle: LPHANDLE,
 861         dwDesiredAccess: DWORD,
 862         bInheritHandle: BOOL,
 863         dwOptions: DWORD,
 864     ) -> BOOL;
 865     pub fn ReadFile(
 866         hFile: HANDLE,
 867         lpBuffer: LPVOID,
 868         nNumberOfBytesToRead: DWORD,
 869         lpNumberOfBytesRead: LPDWORD,
 870         lpOverlapped: LPOVERLAPPED,
 871     ) -> BOOL;
 872     pub fn WriteFile(
 873         hFile: HANDLE,
 874         lpBuffer: LPVOID,
 875         nNumberOfBytesToWrite: DWORD,
 876         lpNumberOfBytesWritten: LPDWORD,
 877         lpOverlapped: LPOVERLAPPED,
 878     ) -> BOOL;
 879     pub fn CloseHandle(hObject: HANDLE) -> BOOL;
 880     pub fn MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD)
 881     -> BOOL;
 882     pub fn SetFilePointerEx(
 883         hFile: HANDLE,
 884         liDistanceToMove: LARGE_INTEGER,
 885         lpNewFilePointer: PLARGE_INTEGER,
 886         dwMoveMethod: DWORD,
 887     ) -> BOOL;
 888     pub fn FlushFileBuffers(hFile: HANDLE) -> BOOL;
 889     pub fn CreateFileW(
 890         lpFileName: LPCWSTR,
 891         dwDesiredAccess: DWORD,
 892         dwShareMode: DWORD,
 893         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 894         dwCreationDisposition: DWORD,
 895         dwFlagsAndAttributes: DWORD,
 896         hTemplateFile: HANDLE,
 897     ) -> HANDLE;
 898
 899     pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW) -> HANDLE;
 900     pub fn FindNextFileW(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW) -> BOOL;
 901     pub fn FindClose(findFile: HANDLE) -> BOOL;
 902
 903     pub fn GetProcAddress(handle: HMODULE, name: LPCSTR) -> *mut c_void;
 904     pub fn GetModuleHandleA(lpModuleName: LPCSTR) -> HMODULE;
 905     pub fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE;
 906
 907     pub fn GetSystemTimeAsFileTime(lpSystemTimeAsFileTime: LPFILETIME);
 908     pub fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
 909
 910     pub fn CreateEventW(
 911         lpEventAttributes: LPSECURITY_ATTRIBUTES,
 912         bManualReset: BOOL,
 913         bInitialState: BOOL,
 914         lpName: LPCWSTR,
 915     ) -> HANDLE;
 916     pub fn WaitForMultipleObjects(
 917         nCount: DWORD,
 918         lpHandles: *const HANDLE,
 919         bWaitAll: BOOL,
 920         dwMilliseconds: DWORD,
 921     ) -> DWORD;
 922     pub fn CreateNamedPipeW(
 923         lpName: LPCWSTR,
 924         dwOpenMode: DWORD,
 925         dwPipeMode: DWORD,
 926         nMaxInstances: DWORD,
 927         nOutBufferSize: DWORD,
 928         nInBufferSize: DWORD,
 929         nDefaultTimeOut: DWORD,
 930         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 931     ) -> HANDLE;
 932     pub fn CancelIo(handle: HANDLE) -> BOOL;
 933     pub fn GetOverlappedResult(
 934         hFile: HANDLE,
 935         lpOverlapped: LPOVERLAPPED,
 936         lpNumberOfBytesTransferred: LPDWORD,
 937         bWait: BOOL,
 938     ) -> BOOL;
 939     pub fn CreateSymbolicLinkW(
 940         lpSymlinkFileName: LPCWSTR,
 941         lpTargetFileName: LPCWSTR,
 942         dwFlags: DWORD,
 943     ) -> BOOLEAN;
 944     pub fn GetFinalPathNameByHandleW(
 945         hFile: HANDLE,
 946         lpszFilePath: LPCWSTR,
 947         cchFilePath: DWORD,
 948         dwFlags: DWORD,
 949     ) -> DWORD;
 950     pub fn SetFileInformationByHandle(
 951         hFile: HANDLE,
 952         FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
 953         lpFileInformation: LPVOID,
 954         dwBufferSize: DWORD,
 955     ) -> BOOL;
 956     pub fn SleepConditionVariableSRW(
 957         ConditionVariable: PCONDITION_VARIABLE,
 958         SRWLock: PSRWLOCK,
 959         dwMilliseconds: DWORD,
 960         Flags: ULONG,
 961     ) -> BOOL;
 962
 963     pub fn WakeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
 964     pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
 965
 966     pub fn AcquireSRWLockExclusive(SRWLock: PSRWLOCK);
 967     pub fn AcquireSRWLockShared(SRWLock: PSRWLOCK);
 968     pub fn ReleaseSRWLockExclusive(SRWLock: PSRWLOCK);
 969     pub fn ReleaseSRWLockShared(SRWLock: PSRWLOCK);
 970     pub fn TryAcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> BOOLEAN;
 971     pub fn TryAcquireSRWLockShared(SRWLock: PSRWLOCK) -> BOOLEAN;
 972
 973     pub fn CompareStringOrdinal(
 974         lpString1: LPCWSTR,
 975         cchCount1: c_int,
 976         lpString2: LPCWSTR,
 977         cchCount2: c_int,
 978         bIgnoreCase: BOOL,
 979     ) -> c_int;
 980 }
 981
 982 #[link(name = "ws2_32")]
 983 extern "system" {
 984     pub fn WSAStartup(wVersionRequested: WORD, lpWSAData: LPWSADATA) -> c_int;
 985     pub fn WSACleanup() -> c_int;
 986     pub fn WSAGetLastError() -> c_int;
 987     pub fn WSADuplicateSocketW(
 988         s: SOCKET,
 989         dwProcessId: DWORD,
 990         lpProtocolInfo: LPWSAPROTOCOL_INFO,
 991     ) -> c_int;
 992     pub fn WSASend(
 993         s: SOCKET,
 994         lpBuffers: LPWSABUF,
 995         dwBufferCount: DWORD,
 996         lpNumberOfBytesSent: LPDWORD,
 997         dwFlags: DWORD,
 998         lpOverlapped: LPWSAOVERLAPPED,
 999         lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
1000     ) -> c_int;
1001     pub fn WSARecv(
1002         s: SOCKET,
1003         lpBuffers: LPWSABUF,
1004         dwBufferCount: DWORD,
1005         lpNumberOfBytesRecvd: LPDWORD,
1006         lpFlags: LPDWORD,
1007         lpOverlapped: LPWSAOVERLAPPED,
1008         lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
1009     ) -> c_int;
1010     pub fn WSASocketW(
1011         af: c_int,
1012         kind: c_int,
1013         protocol: c_int,
1014         lpProtocolInfo: LPWSAPROTOCOL_INFO,
1015         g: GROUP,
1016         dwFlags: DWORD,
1017     ) -> SOCKET;
1018     pub fn ioctlsocket(s: SOCKET, cmd: c_long, argp: *mut c_ulong) -> c_int;
1019     pub fn closesocket(socket: SOCKET) -> c_int;
1020     pub fn recv(socket: SOCKET, buf: *mut c_void, len: c_int, flags: c_int) -> c_int;
1021     pub fn send(socket: SOCKET, buf: *const c_void, len: c_int, flags: c_int) -> c_int;
1022     pub fn recvfrom(
1023         socket: SOCKET,
1024         buf: *mut c_void,
1025         len: c_int,
1026         flags: c_int,
1027         addr: *mut SOCKADDR,
1028         addrlen: *mut c_int,
1029     ) -> c_int;
1030     pub fn sendto(
1031         socket: SOCKET,
1032         buf: *const c_void,
1033         len: c_int,
1034         flags: c_int,
1035         addr: *const SOCKADDR,
1036         addrlen: c_int,
1037     ) -> c_int;
1038     pub fn shutdown(socket: SOCKET, how: c_int) -> c_int;
1039     pub fn accept(socket: SOCKET, address: *mut SOCKADDR, address_len: *mut c_int) -> SOCKET;
1040     pub fn getsockopt(
1041         s: SOCKET,
1042         level: c_int,
1043         optname: c_int,
1044         optval: *mut c_char,
1045         optlen: *mut c_int,
1046     ) -> c_int;
1047     pub fn setsockopt(
1048         s: SOCKET,
1049         level: c_int,
1050         optname: c_int,
1051         optval: *const c_void,
1052         optlen: c_int,
1053     ) -> c_int;
1054     pub fn getsockname(socket: SOCKET, address: *mut SOCKADDR, address_len: *mut c_int) -> c_int;
1055     pub fn getpeername(socket: SOCKET, address: *mut SOCKADDR, address_len: *mut c_int) -> c_int;
1056     pub fn bind(socket: SOCKET, address: *const SOCKADDR, address_len: socklen_t) -> c_int;
1057     pub fn listen(socket: SOCKET, backlog: c_int) -> c_int;
1058     pub fn connect(socket: SOCKET, address: *const SOCKADDR, len: c_int) -> c_int;
1059     pub fn getaddrinfo(
1060         node: *const c_char,
1061         service: *const c_char,
1062         hints: *const ADDRINFOA,
1063         res: *mut *mut ADDRINFOA,
1064     ) -> c_int;
1065     pub fn freeaddrinfo(res: *mut ADDRINFOA);
1066     pub fn select(
1067         nfds: c_int,
1068         readfds: *mut fd_set,
1069         writefds: *mut fd_set,
1070         exceptfds: *mut fd_set,
1071         timeout: *const timeval,
1072     ) -> c_int;
1073 }
1074
1075 #[link(name = "bcrypt")]
1076 extern "system" {
1077     // >= Vista / Server 2008
1078     // https://docs.microsoft.com/en-us/windows/win32/api/bcrypt/nf-bcrypt-bcryptgenrandom
1079     pub fn BCryptGenRandom(
1080         hAlgorithm: LPVOID,
1081         pBuffer: *mut u8,
1082         cbBuffer: ULONG,
1083         dwFlags: ULONG,
1084     ) -> NTSTATUS;
1085 }
1086
1087 // Functions that aren't available on every version of Windows that we support,
1088 // but we still use them and just provide some form of a fallback implementation.
1089 compat_fn! {
1090     "kernel32":
1091
1092     // >= Win10 1607
1093     // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setthreaddescription
1094     pub fn SetThreadDescription(hThread: HANDLE,
1095                                 lpThreadDescription: LPCWSTR) -> HRESULT {
1096         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); E_NOTIMPL
1097     }
1098
1099     // >= Win8 / Server 2012
1100     // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimepreciseasfiletime
1101     pub fn GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime: LPFILETIME)
1102                                           -> () {
1103         GetSystemTimeAsFileTime(lpSystemTimeAsFileTime)
1104     }
1105 }
1106
1107 compat_fn! {
1108     "api-ms-win-core-synch-l1-2-0":
1109
1110     // >= Windows 8 / Server 2012
1111     // https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-waitonaddress
1112     pub fn WaitOnAddress(
1113         Address: LPVOID,
1114         CompareAddress: LPVOID,
1115         AddressSize: SIZE_T,
1116         dwMilliseconds: DWORD
1117     ) -> BOOL {
1118         panic!("WaitOnAddress not available")
1119     }
1120     pub fn WakeByAddressSingle(Address: LPVOID) -> () {
1121         // If this api is unavailable, there cannot be anything waiting, because
1122         // WaitOnAddress would've panicked. So it's fine to do nothing here.
1123     }
1124 }
1125
1126 compat_fn! {
1127     "ntdll":
1128     pub fn NtCreateKeyedEvent(
1129         KeyedEventHandle: LPHANDLE,
1130         DesiredAccess: ACCESS_MASK,
1131         ObjectAttributes: LPVOID,
1132         Flags: ULONG
1133     ) -> NTSTATUS {
1134         panic!("keyed events not available")
1135     }
1136     pub fn NtReleaseKeyedEvent(
1137         EventHandle: HANDLE,
1138         Key: LPVOID,
1139         Alertable: BOOLEAN,
1140         Timeout: PLARGE_INTEGER
1141     ) -> NTSTATUS {
1142         panic!("keyed events not available")
1143     }
1144     pub fn NtWaitForKeyedEvent(
1145         EventHandle: HANDLE,
1146         Key: LPVOID,
1147         Alertable: BOOLEAN,
1148         Timeout: PLARGE_INTEGER
1149     ) -> NTSTATUS {
1150         panic!("keyed events not available")
1151     }
1152 }