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 #[repr(C)]
 266 #[cfg(not(target_pointer_width = "64"))]
 267 pub struct WSADATA {
 268     pub wVersion: WORD,
 269     pub wHighVersion: WORD,
 270     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
 271     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
 272     pub iMaxSockets: u16,
 273     pub iMaxUdpDg: u16,
 274     pub lpVendorInfo: *mut u8,
 275 }
 276 #[repr(C)]
 277 #[cfg(target_pointer_width = "64")]
 278 pub struct WSADATA {
 279     pub wVersion: WORD,
 280     pub wHighVersion: WORD,
 281     pub iMaxSockets: u16,
 282     pub iMaxUdpDg: u16,
 283     pub lpVendorInfo: *mut u8,
 284     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
 285     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
 286 }
 287
 288 #[derive(Copy, Clone)]
 289 #[repr(C)]
 290 pub struct WSABUF {
 291     pub len: ULONG,
 292     pub buf: *mut CHAR,
 293 }
 294
 295 #[repr(C)]
 296 pub struct WSAPROTOCOL_INFO {
 297     pub dwServiceFlags1: DWORD,
 298     pub dwServiceFlags2: DWORD,
 299     pub dwServiceFlags3: DWORD,
 300     pub dwServiceFlags4: DWORD,
 301     pub dwProviderFlags: DWORD,
 302     pub ProviderId: GUID,
 303     pub dwCatalogEntryId: DWORD,
 304     pub ProtocolChain: WSAPROTOCOLCHAIN,
 305     pub iVersion: c_int,
 306     pub iAddressFamily: c_int,
 307     pub iMaxSockAddr: c_int,
 308     pub iMinSockAddr: c_int,
 309     pub iSocketType: c_int,
 310     pub iProtocol: c_int,
 311     pub iProtocolMaxOffset: c_int,
 312     pub iNetworkByteOrder: c_int,
 313     pub iSecurityScheme: c_int,
 314     pub dwMessageSize: DWORD,
 315     pub dwProviderReserved: DWORD,
 316     pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1],
 317 }
 318
 319 #[repr(C)]
 320 #[derive(Copy, Clone)]
 321 pub struct WIN32_FILE_ATTRIBUTE_DATA {
 322     pub dwFileAttributes: DWORD,
 323     pub ftCreationTime: FILETIME,
 324     pub ftLastAccessTime: FILETIME,
 325     pub ftLastWriteTime: FILETIME,
 326     pub nFileSizeHigh: DWORD,
 327     pub nFileSizeLow: DWORD,
 328 }
 329
 330 #[repr(C)]
 331 #[allow(dead_code)] // we only use some variants
 332 pub enum FILE_INFO_BY_HANDLE_CLASS {
 333     FileBasicInfo = 0,
 334     FileStandardInfo = 1,
 335     FileNameInfo = 2,
 336     FileRenameInfo = 3,
 337     FileDispositionInfo = 4,
 338     FileAllocationInfo = 5,
 339     FileEndOfFileInfo = 6,
 340     FileStreamInfo = 7,
 341     FileCompressionInfo = 8,
 342     FileAttributeTagInfo = 9,
 343     FileIdBothDirectoryInfo = 10,        // 0xA
 344     FileIdBothDirectoryRestartInfo = 11, // 0xB
 345     FileIoPriorityHintInfo = 12,         // 0xC
 346     FileRemoteProtocolInfo = 13,         // 0xD
 347     FileFullDirectoryInfo = 14,          // 0xE
 348     FileFullDirectoryRestartInfo = 15,   // 0xF
 349     FileStorageInfo = 16,                // 0x10
 350     FileAlignmentInfo = 17,              // 0x11
 351     FileIdInfo = 18,                     // 0x12
 352     FileIdExtdDirectoryInfo = 19,        // 0x13
 353     FileIdExtdDirectoryRestartInfo = 20, // 0x14
 354     MaximumFileInfoByHandlesClass,
 355 }
 356
 357 #[repr(C)]
 358 pub struct FILE_BASIC_INFO {
 359     pub CreationTime: LARGE_INTEGER,
 360     pub LastAccessTime: LARGE_INTEGER,
 361     pub LastWriteTime: LARGE_INTEGER,
 362     pub ChangeTime: LARGE_INTEGER,
 363     pub FileAttributes: DWORD,
 364 }
 365
 366 #[repr(C)]
 367 pub struct FILE_END_OF_FILE_INFO {
 368     pub EndOfFile: LARGE_INTEGER,
 369 }
 370
 371 #[repr(C)]
 372 pub struct REPARSE_DATA_BUFFER {
 373     pub ReparseTag: c_uint,
 374     pub ReparseDataLength: c_ushort,
 375     pub Reserved: c_ushort,
 376     pub rest: (),
 377 }
 378
 379 #[repr(C)]
 380 pub struct SYMBOLIC_LINK_REPARSE_BUFFER {
 381     pub SubstituteNameOffset: c_ushort,
 382     pub SubstituteNameLength: c_ushort,
 383     pub PrintNameOffset: c_ushort,
 384     pub PrintNameLength: c_ushort,
 385     pub Flags: c_ulong,
 386     pub PathBuffer: WCHAR,
 387 }
 388
 389 #[repr(C)]
 390 pub struct MOUNT_POINT_REPARSE_BUFFER {
 391     pub SubstituteNameOffset: c_ushort,
 392     pub SubstituteNameLength: c_ushort,
 393     pub PrintNameOffset: c_ushort,
 394     pub PrintNameLength: c_ushort,
 395     pub PathBuffer: WCHAR,
 396 }
 397
 398 pub type LPPROGRESS_ROUTINE = crate::option::Option<
 399     unsafe extern "system" fn(
 400         TotalFileSize: LARGE_INTEGER,
 401         TotalBytesTransferred: LARGE_INTEGER,
 402         StreamSize: LARGE_INTEGER,
 403         StreamBytesTransferred: LARGE_INTEGER,
 404         dwStreamNumber: DWORD,
 405         dwCallbackReason: DWORD,
 406         hSourceFile: HANDLE,
 407         hDestinationFile: HANDLE,
 408         lpData: LPVOID,
 409     ) -> DWORD,
 410 >;
 411
 412 #[repr(C)]
 413 pub struct CONDITION_VARIABLE {
 414     pub ptr: LPVOID,
 415 }
 416 #[repr(C)]
 417 pub struct SRWLOCK {
 418     pub ptr: LPVOID,
 419 }
 420 #[repr(C)]
 421 pub struct CRITICAL_SECTION {
 422     CriticalSectionDebug: LPVOID,
 423     LockCount: LONG,
 424     RecursionCount: LONG,
 425     OwningThread: HANDLE,
 426     LockSemaphore: HANDLE,
 427     SpinCount: ULONG_PTR,
 428 }
 429
 430 #[repr(C)]
 431 pub struct REPARSE_MOUNTPOINT_DATA_BUFFER {
 432     pub ReparseTag: DWORD,
 433     pub ReparseDataLength: DWORD,
 434     pub Reserved: WORD,
 435     pub ReparseTargetLength: WORD,
 436     pub ReparseTargetMaximumLength: WORD,
 437     pub Reserved1: WORD,
 438     pub ReparseTarget: WCHAR,
 439 }
 440
 441 #[repr(C)]
 442 pub struct GUID {
 443     pub Data1: DWORD,
 444     pub Data2: WORD,
 445     pub Data3: WORD,
 446     pub Data4: [BYTE; 8],
 447 }
 448
 449 #[repr(C)]
 450 pub struct WSAPROTOCOLCHAIN {
 451     pub ChainLen: c_int,
 452     pub ChainEntries: [DWORD; MAX_PROTOCOL_CHAIN as usize],
 453 }
 454
 455 #[repr(C)]
 456 pub struct SECURITY_ATTRIBUTES {
 457     pub nLength: DWORD,
 458     pub lpSecurityDescriptor: LPVOID,
 459     pub bInheritHandle: BOOL,
 460 }
 461
 462 #[repr(C)]
 463 pub struct PROCESS_INFORMATION {
 464     pub hProcess: HANDLE,
 465     pub hThread: HANDLE,
 466     pub dwProcessId: DWORD,
 467     pub dwThreadId: DWORD,
 468 }
 469
 470 #[repr(C)]
 471 pub struct STARTUPINFO {
 472     pub cb: DWORD,
 473     pub lpReserved: LPWSTR,
 474     pub lpDesktop: LPWSTR,
 475     pub lpTitle: LPWSTR,
 476     pub dwX: DWORD,
 477     pub dwY: DWORD,
 478     pub dwXSize: DWORD,
 479     pub dwYSize: DWORD,
 480     pub dwXCountChars: DWORD,
 481     pub dwYCountCharts: DWORD,
 482     pub dwFillAttribute: DWORD,
 483     pub dwFlags: DWORD,
 484     pub wShowWindow: WORD,
 485     pub cbReserved2: WORD,
 486     pub lpReserved2: LPBYTE,
 487     pub hStdInput: HANDLE,
 488     pub hStdOutput: HANDLE,
 489     pub hStdError: HANDLE,
 490 }
 491
 492 #[repr(C)]
 493 pub struct SOCKADDR {
 494     pub sa_family: ADDRESS_FAMILY,
 495     pub sa_data: [CHAR; 14],
 496 }
 497
 498 #[repr(C)]
 499 #[derive(Copy, Clone)]
 500 pub struct FILETIME {
 501     pub dwLowDateTime: DWORD,
 502     pub dwHighDateTime: DWORD,
 503 }
 504
 505 #[repr(C)]
 506 pub struct SYSTEM_INFO {
 507     pub wProcessorArchitecture: WORD,
 508     pub wReserved: WORD,
 509     pub dwPageSize: DWORD,
 510     pub lpMinimumApplicationAddress: LPVOID,
 511     pub lpMaximumApplicationAddress: LPVOID,
 512     pub dwActiveProcessorMask: DWORD_PTR,
 513     pub dwNumberOfProcessors: DWORD,
 514     pub dwProcessorType: DWORD,
 515     pub dwAllocationGranularity: DWORD,
 516     pub wProcessorLevel: WORD,
 517     pub wProcessorRevision: WORD,
 518 }
 519
 520 #[repr(C)]
 521 pub struct OVERLAPPED {
 522     pub Internal: *mut c_ulong,
 523     pub InternalHigh: *mut c_ulong,
 524     pub Offset: DWORD,
 525     pub OffsetHigh: DWORD,
 526     pub hEvent: HANDLE,
 527 }
 528
 529 #[repr(C)]
 530 #[allow(dead_code)] // we only use some variants
 531 pub enum ADDRESS_MODE {
 532     AddrMode1616,
 533     AddrMode1632,
 534     AddrModeReal,
 535     AddrModeFlat,
 536 }
 537
 538 #[repr(C)]
 539 pub struct SOCKADDR_STORAGE_LH {
 540     pub ss_family: ADDRESS_FAMILY,
 541     pub __ss_pad1: [CHAR; 6],
 542     pub __ss_align: i64,
 543     pub __ss_pad2: [CHAR; 112],
 544 }
 545
 546 #[repr(C)]
 547 pub struct ADDRINFOA {
 548     pub ai_flags: c_int,
 549     pub ai_family: c_int,
 550     pub ai_socktype: c_int,
 551     pub ai_protocol: c_int,
 552     pub ai_addrlen: size_t,
 553     pub ai_canonname: *mut c_char,
 554     pub ai_addr: *mut SOCKADDR,
 555     pub ai_next: *mut ADDRINFOA,
 556 }
 557
 558 #[repr(C)]
 559 #[derive(Copy, Clone)]
 560 pub struct sockaddr_in {
 561     pub sin_family: ADDRESS_FAMILY,
 562     pub sin_port: USHORT,
 563     pub sin_addr: in_addr,
 564     pub sin_zero: [CHAR; 8],
 565 }
 566
 567 #[repr(C)]
 568 #[derive(Copy, Clone)]
 569 pub struct sockaddr_in6 {
 570     pub sin6_family: ADDRESS_FAMILY,
 571     pub sin6_port: USHORT,
 572     pub sin6_flowinfo: c_ulong,
 573     pub sin6_addr: in6_addr,
 574     pub sin6_scope_id: c_ulong,
 575 }
 576
 577 #[repr(C)]
 578 #[derive(Copy, Clone)]
 579 pub struct in_addr {
 580     pub s_addr: u32,
 581 }
 582
 583 #[repr(C)]
 584 #[derive(Copy, Clone)]
 585 pub struct in6_addr {
 586     pub s6_addr: [u8; 16],
 587 }
 588
 589 #[repr(C)]
 590 #[derive(Copy, Clone)]
 591 #[allow(dead_code)] // we only use some variants
 592 pub enum EXCEPTION_DISPOSITION {
 593     ExceptionContinueExecution,
 594     ExceptionContinueSearch,
 595     ExceptionNestedException,
 596     ExceptionCollidedUnwind,
 597 }
 598
 599 #[repr(C)]
 600 #[derive(Copy)]
 601 pub struct fd_set {
 602     pub fd_count: c_uint,
 603     pub fd_array: [SOCKET; FD_SETSIZE],
 604 }
 605
 606 impl Clone for fd_set {
 607     fn clone(&self) -> fd_set {
 608         *self
 609     }
 610 }
 611
 612 #[repr(C)]
 613 #[derive(Copy, Clone)]
 614 pub struct timeval {
 615     pub tv_sec: c_long,
 616     pub tv_usec: c_long,
 617 }
 618
 619 // Desktop specific functions & types
 620 cfg_if::cfg_if! {
 621 if #[cfg(not(target_vendor = "uwp"))] {
 622     pub const EXCEPTION_CONTINUE_SEARCH: LONG = 0;
 623     pub const EXCEPTION_STACK_OVERFLOW: DWORD = 0xc00000fd;
 624     pub const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15;
 625
 626     #[repr(C)]
 627     pub struct EXCEPTION_RECORD {
 628         pub ExceptionCode: DWORD,
 629         pub ExceptionFlags: DWORD,
 630         pub ExceptionRecord: *mut EXCEPTION_RECORD,
 631         pub ExceptionAddress: LPVOID,
 632         pub NumberParameters: DWORD,
 633         pub ExceptionInformation: [LPVOID; EXCEPTION_MAXIMUM_PARAMETERS],
 634     }
 635
 636     pub enum CONTEXT {}
 637
 638     #[repr(C)]
 639     pub struct EXCEPTION_POINTERS {
 640         pub ExceptionRecord: *mut EXCEPTION_RECORD,
 641         pub ContextRecord: *mut CONTEXT,
 642     }
 643
 644     pub type PVECTORED_EXCEPTION_HANDLER =
 645         extern "system" fn(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG;
 646
 647     #[repr(C)]
 648     #[derive(Copy, Clone)]
 649     pub struct CONSOLE_READCONSOLE_CONTROL {
 650         pub nLength: ULONG,
 651         pub nInitialChars: ULONG,
 652         pub dwCtrlWakeupMask: ULONG,
 653         pub dwControlKeyState: ULONG,
 654     }
 655
 656     pub type PCONSOLE_READCONSOLE_CONTROL = *mut CONSOLE_READCONSOLE_CONTROL;
 657
 658     #[repr(C)]
 659     pub struct BY_HANDLE_FILE_INFORMATION {
 660         pub dwFileAttributes: DWORD,
 661         pub ftCreationTime: FILETIME,
 662         pub ftLastAccessTime: FILETIME,
 663         pub ftLastWriteTime: FILETIME,
 664         pub dwVolumeSerialNumber: DWORD,
 665         pub nFileSizeHigh: DWORD,
 666         pub nFileSizeLow: DWORD,
 667         pub nNumberOfLinks: DWORD,
 668         pub nFileIndexHigh: DWORD,
 669         pub nFileIndexLow: DWORD,
 670     }
 671
 672     pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION;
 673     pub type LPCVOID = *const c_void;
 674
 675     pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001;
 676
 677     pub const TOKEN_READ: DWORD = 0x20008;
 678
 679     #[link(name = "advapi32")]
 680     extern "system" {
 681         // Forbidden when targeting UWP
 682         #[link_name = "SystemFunction036"]
 683         pub fn RtlGenRandom(RandomBuffer: *mut u8, RandomBufferLength: ULONG) -> BOOLEAN;
 684
 685         // Allowed but unused by UWP
 686         pub fn OpenProcessToken(
 687             ProcessHandle: HANDLE,
 688             DesiredAccess: DWORD,
 689             TokenHandle: *mut HANDLE,
 690         ) -> BOOL;
 691     }
 692
 693     #[link(name = "userenv")]
 694     extern "system" {
 695         // Allowed but unused by UWP
 696         pub fn GetUserProfileDirectoryW(
 697             hToken: HANDLE,
 698             lpProfileDir: LPWSTR,
 699             lpcchSize: *mut DWORD,
 700         ) -> BOOL;
 701     }
 702
 703     #[link(name = "kernel32")]
 704     extern "system" {
 705         // Functions forbidden when targeting UWP
 706         pub fn ReadConsoleW(
 707             hConsoleInput: HANDLE,
 708             lpBuffer: LPVOID,
 709             nNumberOfCharsToRead: DWORD,
 710             lpNumberOfCharsRead: LPDWORD,
 711             pInputControl: PCONSOLE_READCONSOLE_CONTROL,
 712         ) -> BOOL;
 713
 714         pub fn WriteConsoleW(
 715             hConsoleOutput: HANDLE,
 716             lpBuffer: LPCVOID,
 717             nNumberOfCharsToWrite: DWORD,
 718             lpNumberOfCharsWritten: LPDWORD,
 719             lpReserved: LPVOID,
 720         ) -> BOOL;
 721
 722         pub fn GetConsoleMode(hConsoleHandle: HANDLE, lpMode: LPDWORD) -> BOOL;
 723         // Allowed but unused by UWP
 724         pub fn GetFileInformationByHandle(
 725             hFile: HANDLE,
 726             lpFileInformation: LPBY_HANDLE_FILE_INFORMATION,
 727         ) -> BOOL;
 728         pub fn SetHandleInformation(hObject: HANDLE, dwMask: DWORD, dwFlags: DWORD) -> BOOL;
 729         pub fn AddVectoredExceptionHandler(
 730             FirstHandler: ULONG,
 731             VectoredHandler: PVECTORED_EXCEPTION_HANDLER,
 732         ) -> LPVOID;
 733         pub fn CreateHardLinkW(
 734             lpSymlinkFileName: LPCWSTR,
 735             lpTargetFileName: LPCWSTR,
 736             lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 737         ) -> BOOL;
 738         pub fn SetThreadStackGuarantee(_size: *mut c_ulong) -> BOOL;
 739     }
 740 }
 741 }
 742
 743 // UWP specific functions & types
 744 cfg_if::cfg_if! {
 745 if #[cfg(target_vendor = "uwp")] {
 746     pub const BCRYPT_USE_SYSTEM_PREFERRED_RNG: DWORD = 0x00000002;
 747
 748     #[repr(C)]
 749     pub struct FILE_STANDARD_INFO {
 750         pub AllocationSize: LARGE_INTEGER,
 751         pub EndOfFile: LARGE_INTEGER,
 752         pub NumberOfLinks: DWORD,
 753         pub DeletePending: BOOLEAN,
 754         pub Directory: BOOLEAN,
 755     }
 756
 757     #[link(name = "bcrypt")]
 758     extern "system" {
 759         pub fn BCryptGenRandom(
 760             hAlgorithm: LPVOID,
 761             pBuffer: *mut u8,
 762             cbBuffer: ULONG,
 763             dwFlags: ULONG,
 764         ) -> LONG;
 765     }
 766     #[link(name = "kernel32")]
 767     extern "system" {
 768         pub fn GetFileInformationByHandleEx(
 769             hFile: HANDLE,
 770             fileInfoClass: FILE_INFO_BY_HANDLE_CLASS,
 771             lpFileInformation: LPVOID,
 772             dwBufferSize: DWORD,
 773         ) -> BOOL;
 774     }
 775 }
 776 }
 777
 778 // Shared between Desktop & UWP
 779
 780 #[link(name = "kernel32")]
 781 extern "system" {
 782     pub fn GetCurrentProcessId() -> DWORD;
 783     pub fn InitializeCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 784     pub fn EnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 785     pub fn TryEnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION) -> BOOL;
 786     pub fn LeaveCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 787     pub fn DeleteCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 788
 789     pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL;
 790     pub fn SetFileAttributesW(lpFileName: LPCWSTR, dwFileAttributes: DWORD) -> BOOL;
 791     pub fn SetLastError(dwErrCode: DWORD);
 792     pub fn GetCommandLineW() -> LPWSTR;
 793     pub fn GetTempPathW(nBufferLength: DWORD, lpBuffer: LPCWSTR) -> DWORD;
 794     pub fn GetCurrentProcess() -> HANDLE;
 795     pub fn GetCurrentThread() -> HANDLE;
 796     pub fn GetStdHandle(which: DWORD) -> HANDLE;
 797     pub fn ExitProcess(uExitCode: c_uint) -> !;
 798     pub fn DeviceIoControl(
 799         hDevice: HANDLE,
 800         dwIoControlCode: DWORD,
 801         lpInBuffer: LPVOID,
 802         nInBufferSize: DWORD,
 803         lpOutBuffer: LPVOID,
 804         nOutBufferSize: DWORD,
 805         lpBytesReturned: LPDWORD,
 806         lpOverlapped: LPOVERLAPPED,
 807     ) -> BOOL;
 808     pub fn CreateThread(
 809         lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 810         dwStackSize: SIZE_T,
 811         lpStartAddress: extern "system" fn(*mut c_void) -> DWORD,
 812         lpParameter: LPVOID,
 813         dwCreationFlags: DWORD,
 814         lpThreadId: LPDWORD,
 815     ) -> HANDLE;
 816     pub fn WaitForSingleObject(hHandle: HANDLE, dwMilliseconds: DWORD) -> DWORD;
 817     pub fn SwitchToThread() -> BOOL;
 818     pub fn Sleep(dwMilliseconds: DWORD);
 819     pub fn GetProcessId(handle: HANDLE) -> DWORD;
 820     pub fn CopyFileExW(
 821         lpExistingFileName: LPCWSTR,
 822         lpNewFileName: LPCWSTR,
 823         lpProgressRoutine: LPPROGRESS_ROUTINE,
 824         lpData: LPVOID,
 825         pbCancel: LPBOOL,
 826         dwCopyFlags: DWORD,
 827     ) -> BOOL;
 828     pub fn FormatMessageW(
 829         flags: DWORD,
 830         lpSrc: LPVOID,
 831         msgId: DWORD,
 832         langId: DWORD,
 833         buf: LPWSTR,
 834         nsize: DWORD,
 835         args: *const c_void,
 836     ) -> DWORD;
 837     pub fn TlsAlloc() -> DWORD;
 838     pub fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID;
 839     pub fn TlsSetValue(dwTlsIndex: DWORD, lpTlsvalue: LPVOID) -> BOOL;
 840     pub fn GetLastError() -> DWORD;
 841     pub fn QueryPerformanceFrequency(lpFrequency: *mut LARGE_INTEGER) -> BOOL;
 842     pub fn QueryPerformanceCounter(lpPerformanceCount: *mut LARGE_INTEGER) -> BOOL;
 843     pub fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL;
 844     pub fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL;
 845     pub fn CreateProcessW(
 846         lpApplicationName: LPCWSTR,
 847         lpCommandLine: LPWSTR,
 848         lpProcessAttributes: LPSECURITY_ATTRIBUTES,
 849         lpThreadAttributes: LPSECURITY_ATTRIBUTES,
 850         bInheritHandles: BOOL,
 851         dwCreationFlags: DWORD,
 852         lpEnvironment: LPVOID,
 853         lpCurrentDirectory: LPCWSTR,
 854         lpStartupInfo: LPSTARTUPINFO,
 855         lpProcessInformation: LPPROCESS_INFORMATION,
 856     ) -> BOOL;
 857     pub fn GetEnvironmentVariableW(n: LPCWSTR, v: LPWSTR, nsize: DWORD) -> DWORD;
 858     pub fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR) -> BOOL;
 859     pub fn GetEnvironmentStringsW() -> LPWCH;
 860     pub fn FreeEnvironmentStringsW(env_ptr: LPWCH) -> BOOL;
 861     pub fn GetModuleFileNameW(hModule: HMODULE, lpFilename: LPWSTR, nSize: DWORD) -> DWORD;
 862     pub fn CreateDirectoryW(
 863         lpPathName: LPCWSTR,
 864         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 865     ) -> BOOL;
 866     pub fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL;
 867     pub fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD;
 868     pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL;
 869     pub fn DuplicateHandle(
 870         hSourceProcessHandle: HANDLE,
 871         hSourceHandle: HANDLE,
 872         hTargetProcessHandle: HANDLE,
 873         lpTargetHandle: LPHANDLE,
 874         dwDesiredAccess: DWORD,
 875         bInheritHandle: BOOL,
 876         dwOptions: DWORD,
 877     ) -> BOOL;
 878     pub fn ReadFile(
 879         hFile: HANDLE,
 880         lpBuffer: LPVOID,
 881         nNumberOfBytesToRead: DWORD,
 882         lpNumberOfBytesRead: LPDWORD,
 883         lpOverlapped: LPOVERLAPPED,
 884     ) -> BOOL;
 885     pub fn WriteFile(
 886         hFile: HANDLE,
 887         lpBuffer: LPVOID,
 888         nNumberOfBytesToWrite: DWORD,
 889         lpNumberOfBytesWritten: LPDWORD,
 890         lpOverlapped: LPOVERLAPPED,
 891     ) -> BOOL;
 892     pub fn CloseHandle(hObject: HANDLE) -> BOOL;
 893     pub fn MoveFileExW(lpExistingFileName: LPCWSTR, lpNewFileName: LPCWSTR, dwFlags: DWORD)
 894     -> BOOL;
 895     pub fn SetFilePointerEx(
 896         hFile: HANDLE,
 897         liDistanceToMove: LARGE_INTEGER,
 898         lpNewFilePointer: PLARGE_INTEGER,
 899         dwMoveMethod: DWORD,
 900     ) -> BOOL;
 901     pub fn FlushFileBuffers(hFile: HANDLE) -> BOOL;
 902     pub fn CreateFileW(
 903         lpFileName: LPCWSTR,
 904         dwDesiredAccess: DWORD,
 905         dwShareMode: DWORD,
 906         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 907         dwCreationDisposition: DWORD,
 908         dwFlagsAndAttributes: DWORD,
 909         hTemplateFile: HANDLE,
 910     ) -> HANDLE;
 911
 912     pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW) -> HANDLE;
 913     pub fn FindNextFileW(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW) -> BOOL;
 914     pub fn FindClose(findFile: HANDLE) -> BOOL;
 915
 916     pub fn GetProcAddress(handle: HMODULE, name: LPCSTR) -> *mut c_void;
 917     pub fn GetModuleHandleA(lpModuleName: LPCSTR) -> HMODULE;
 918     pub fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE;
 919
 920     pub fn GetSystemTimeAsFileTime(lpSystemTimeAsFileTime: LPFILETIME);
 921     pub fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO);
 922
 923     pub fn CreateEventW(
 924         lpEventAttributes: LPSECURITY_ATTRIBUTES,
 925         bManualReset: BOOL,
 926         bInitialState: BOOL,
 927         lpName: LPCWSTR,
 928     ) -> HANDLE;
 929     pub fn WaitForMultipleObjects(
 930         nCount: DWORD,
 931         lpHandles: *const HANDLE,
 932         bWaitAll: BOOL,
 933         dwMilliseconds: DWORD,
 934     ) -> DWORD;
 935     pub fn CreateNamedPipeW(
 936         lpName: LPCWSTR,
 937         dwOpenMode: DWORD,
 938         dwPipeMode: DWORD,
 939         nMaxInstances: DWORD,
 940         nOutBufferSize: DWORD,
 941         nInBufferSize: DWORD,
 942         nDefaultTimeOut: DWORD,
 943         lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
 944     ) -> HANDLE;
 945     pub fn CancelIo(handle: HANDLE) -> BOOL;
 946     pub fn GetOverlappedResult(
 947         hFile: HANDLE,
 948         lpOverlapped: LPOVERLAPPED,
 949         lpNumberOfBytesTransferred: LPDWORD,
 950         bWait: BOOL,
 951     ) -> BOOL;
 952     pub fn CreateSymbolicLinkW(
 953         lpSymlinkFileName: LPCWSTR,
 954         lpTargetFileName: LPCWSTR,
 955         dwFlags: DWORD,
 956     ) -> BOOLEAN;
 957     pub fn GetFinalPathNameByHandleW(
 958         hFile: HANDLE,
 959         lpszFilePath: LPCWSTR,
 960         cchFilePath: DWORD,
 961         dwFlags: DWORD,
 962     ) -> DWORD;
 963     pub fn SetFileInformationByHandle(
 964         hFile: HANDLE,
 965         FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
 966         lpFileInformation: LPVOID,
 967         dwBufferSize: DWORD,
 968     ) -> BOOL;
 969     pub fn SleepConditionVariableSRW(
 970         ConditionVariable: PCONDITION_VARIABLE,
 971         SRWLock: PSRWLOCK,
 972         dwMilliseconds: DWORD,
 973         Flags: ULONG,
 974     ) -> BOOL;
 975
 976     pub fn WakeConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
 977     pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE);
 978
 979     pub fn AcquireSRWLockExclusive(SRWLock: PSRWLOCK);
 980     pub fn AcquireSRWLockShared(SRWLock: PSRWLOCK);
 981     pub fn ReleaseSRWLockExclusive(SRWLock: PSRWLOCK);
 982     pub fn ReleaseSRWLockShared(SRWLock: PSRWLOCK);
 983     pub fn TryAcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> BOOLEAN;
 984     pub fn TryAcquireSRWLockShared(SRWLock: PSRWLOCK) -> BOOLEAN;
 985
 986     pub fn CompareStringOrdinal(
 987         lpString1: LPCWSTR,
 988         cchCount1: c_int,
 989         lpString2: LPCWSTR,
 990         cchCount2: c_int,
 991         bIgnoreCase: BOOL,
 992     ) -> c_int;
 993 }
 994
 995 #[link(name = "ws2_32")]
 996 extern "system" {
 997     pub fn WSAStartup(wVersionRequested: WORD, lpWSAData: LPWSADATA) -> c_int;
 998     pub fn WSACleanup() -> c_int;
 999     pub fn WSAGetLastError() -> c_int;
1000     pub fn WSADuplicateSocketW(
1001         s: SOCKET,
1002         dwProcessId: DWORD,
1003         lpProtocolInfo: LPWSAPROTOCOL_INFO,
1004     ) -> c_int;
1005     pub fn WSASend(
1006         s: SOCKET,
1007         lpBuffers: LPWSABUF,
1008         dwBufferCount: DWORD,
1009         lpNumberOfBytesSent: LPDWORD,
1010         dwFlags: DWORD,
1011         lpOverlapped: LPWSAOVERLAPPED,
1012         lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
1013     ) -> c_int;
1014     pub fn WSARecv(
1015         s: SOCKET,
1016         lpBuffers: LPWSABUF,
1017         dwBufferCount: DWORD,
1018         lpNumberOfBytesRecvd: LPDWORD,
1019         lpFlags: LPDWORD,
1020         lpOverlapped: LPWSAOVERLAPPED,
1021         lpCompletionRoutine: LPWSAOVERLAPPED_COMPLETION_ROUTINE,
1022     ) -> c_int;
1023     pub fn WSASocketW(
1024         af: c_int,
1025         kind: c_int,
1026         protocol: c_int,
1027         lpProtocolInfo: LPWSAPROTOCOL_INFO,
1028         g: GROUP,
1029         dwFlags: DWORD,
1030     ) -> SOCKET;
1031     pub fn ioctlsocket(s: SOCKET, cmd: c_long, argp: *mut c_ulong) -> c_int;
1032     pub fn closesocket(socket: SOCKET) -> c_int;
1033     pub fn recv(socket: SOCKET, buf: *mut c_void, len: c_int, flags: c_int) -> c_int;
1034     pub fn send(socket: SOCKET, buf: *const c_void, len: c_int, flags: c_int) -> c_int;
1035     pub fn recvfrom(
1036         socket: SOCKET,
1037         buf: *mut c_void,
1038         len: c_int,
1039         flags: c_int,
1040         addr: *mut SOCKADDR,
1041         addrlen: *mut c_int,
1042     ) -> c_int;
1043     pub fn sendto(
1044         socket: SOCKET,
1045         buf: *const c_void,
1046         len: c_int,
1047         flags: c_int,
1048         addr: *const SOCKADDR,
1049         addrlen: c_int,
1050     ) -> c_int;
1051     pub fn shutdown(socket: SOCKET, how: c_int) -> c_int;
1052     pub fn accept(socket: SOCKET, address: *mut SOCKADDR, address_len: *mut c_int) -> SOCKET;
1053     pub fn getsockopt(
1054         s: SOCKET,
1055         level: c_int,
1056         optname: c_int,
1057         optval: *mut c_char,
1058         optlen: *mut c_int,
1059     ) -> c_int;
1060     pub fn setsockopt(
1061         s: SOCKET,
1062         level: c_int,
1063         optname: c_int,
1064         optval: *const c_void,
1065         optlen: c_int,
1066     ) -> c_int;
1067     pub fn getsockname(socket: SOCKET, address: *mut SOCKADDR, address_len: *mut c_int) -> c_int;
1068     pub fn getpeername(socket: SOCKET, address: *mut SOCKADDR, address_len: *mut c_int) -> c_int;
1069     pub fn bind(socket: SOCKET, address: *const SOCKADDR, address_len: socklen_t) -> c_int;
1070     pub fn listen(socket: SOCKET, backlog: c_int) -> c_int;
1071     pub fn connect(socket: SOCKET, address: *const SOCKADDR, len: c_int) -> c_int;
1072     pub fn getaddrinfo(
1073         node: *const c_char,
1074         service: *const c_char,
1075         hints: *const ADDRINFOA,
1076         res: *mut *mut ADDRINFOA,
1077     ) -> c_int;
1078     pub fn freeaddrinfo(res: *mut ADDRINFOA);
1079     pub fn select(
1080         nfds: c_int,
1081         readfds: *mut fd_set,
1082         writefds: *mut fd_set,
1083         exceptfds: *mut fd_set,
1084         timeout: *const timeval,
1085     ) -> c_int;
1086 }
1087
1088 // Functions that aren't available on every version of Windows that we support,
1089 // but we still use them and just provide some form of a fallback implementation.
1090 compat_fn! {
1091     "kernel32":
1092
1093     // >= Win10 1607
1094     // https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setthreaddescription
1095     pub fn SetThreadDescription(hThread: HANDLE,
1096                                 lpThreadDescription: LPCWSTR) -> HRESULT {
1097         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); E_NOTIMPL
1098     }
1099
1100     // >= Win8 / Server 2012
1101     // https://docs.microsoft.com/en-us/windows/win32/api/sysinfoapi/nf-sysinfoapi-getsystemtimepreciseasfiletime
1102     pub fn GetSystemTimePreciseAsFileTime(lpSystemTimeAsFileTime: LPFILETIME)
1103                                           -> () {
1104         GetSystemTimeAsFileTime(lpSystemTimeAsFileTime)
1105     }
1106 }
1107
1108 compat_fn! {
1109     "api-ms-win-core-synch-l1-2-0":
1110
1111     // >= Windows 8 / Server 2012
1112     // https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-waitonaddress
1113     pub fn WaitOnAddress(
1114         Address: LPVOID,
1115         CompareAddress: LPVOID,
1116         AddressSize: SIZE_T,
1117         dwMilliseconds: DWORD
1118     ) -> BOOL {
1119         panic!("WaitOnAddress not available")
1120     }
1121     pub fn WakeByAddressSingle(Address: LPVOID) -> () {
1122         // If this api is unavailable, there cannot be anything waiting, because
1123         // WaitOnAddress would've panicked. So it's fine to do nothing here.
1124     }
1125 }
1126
1127 compat_fn! {
1128     "ntdll":
1129     pub fn NtCreateKeyedEvent(
1130         KeyedEventHandle: LPHANDLE,
1131         DesiredAccess: ACCESS_MASK,
1132         ObjectAttributes: LPVOID,
1133         Flags: ULONG
1134     ) -> NTSTATUS {
1135         panic!("keyed events not available")
1136     }
1137     pub fn NtReleaseKeyedEvent(
1138         EventHandle: HANDLE,
1139         Key: LPVOID,
1140         Alertable: BOOLEAN,
1141         Timeout: PLARGE_INTEGER
1142     ) -> NTSTATUS {
1143         panic!("keyed events not available")
1144     }
1145     pub fn NtWaitForKeyedEvent(
1146         EventHandle: HANDLE,
1147         Key: LPVOID,
1148         Alertable: BOOLEAN,
1149         Timeout: PLARGE_INTEGER
1150     ) -> NTSTATUS {
1151         panic!("keyed events not available")
1152     }
1153 }