src/libstd/sys/windows/c.rs

   1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! C definitions used by libnative that don't belong in liblibc
  12
  13 #![allow(bad_style, dead_code, overflowing_literals)]
  14
  15 use libc;
  16 use libc::{c_uint, c_ulong};
  17 use libc::{DWORD, BOOL, BOOLEAN, ERROR_CALL_NOT_IMPLEMENTED, LPVOID, HANDLE};
  18 use libc::{LPCWSTR, LONG};
  19 use ptr;
  20
  21 pub use self::GET_FILEEX_INFO_LEVELS::*;
  22 pub use self::FILE_INFO_BY_HANDLE_CLASS::*;
  23 pub use libc::consts::os::extra::{
  24     FILE_ATTRIBUTE_READONLY,
  25     FILE_ATTRIBUTE_DIRECTORY,
  26     WSAPROTOCOL_LEN,
  27 };
  28 pub use libc::types::os::arch::extra::{GROUP, GUID, WSAPROTOCOLCHAIN};
  29
  30 pub const WSADESCRIPTION_LEN: usize = 256;
  31 pub const WSASYS_STATUS_LEN: usize = 128;
  32 pub const FIONBIO: libc::c_long = 0x8004667e;
  33 pub const FD_SETSIZE: usize = 64;
  34 pub const MSG_DONTWAIT: libc::c_int = 0;
  35 pub const ERROR_ILLEGAL_CHARACTER: libc::c_int = 582;
  36 pub const ENABLE_ECHO_INPUT: libc::DWORD = 0x4;
  37 pub const ENABLE_EXTENDED_FLAGS: libc::DWORD = 0x80;
  38 pub const ENABLE_INSERT_MODE: libc::DWORD = 0x20;
  39 pub const ENABLE_LINE_INPUT: libc::DWORD = 0x2;
  40 pub const ENABLE_PROCESSED_INPUT: libc::DWORD = 0x1;
  41 pub const ENABLE_QUICK_EDIT_MODE: libc::DWORD = 0x40;
  42 pub const WSA_INVALID_EVENT: WSAEVENT = 0 as WSAEVENT;
  43
  44 pub const FD_ACCEPT: libc::c_long = 0x08;
  45 pub const FD_MAX_EVENTS: usize = 10;
  46 pub const WSA_INFINITE: libc::DWORD = libc::INFINITE;
  47 pub const WSA_WAIT_TIMEOUT: libc::DWORD = libc::consts::os::extra::WAIT_TIMEOUT;
  48 pub const WSA_WAIT_EVENT_0: libc::DWORD = libc::consts::os::extra::WAIT_OBJECT_0;
  49 pub const WSA_WAIT_FAILED: libc::DWORD = libc::consts::os::extra::WAIT_FAILED;
  50 pub const WSAESHUTDOWN: libc::c_int = 10058;
  51 pub const WSA_FLAG_OVERLAPPED: libc::DWORD = 0x01;
  52 pub const WSA_FLAG_NO_HANDLE_INHERIT: libc::DWORD = 0x80;
  53
  54 pub const ERROR_NO_MORE_FILES: libc::DWORD = 18;
  55 pub const TOKEN_READ: libc::DWORD = 0x20008;
  56 pub const FILE_FLAG_OPEN_REPARSE_POINT: libc::DWORD = 0x00200000;
  57 pub const FILE_FLAG_BACKUP_SEMANTICS: libc::DWORD = 0x02000000;
  58 pub const MAXIMUM_REPARSE_DATA_BUFFER_SIZE: usize = 16 * 1024;
  59 pub const FSCTL_GET_REPARSE_POINT: libc::DWORD = 0x900a8;
  60 pub const IO_REPARSE_TAG_SYMLINK: libc::DWORD = 0xa000000c;
  61 pub const IO_REPARSE_TAG_MOUNT_POINT: libc::DWORD = 0xa0000003;
  62 pub const FSCTL_SET_REPARSE_POINT: libc::DWORD = 0x900a4;
  63 pub const FSCTL_DELETE_REPARSE_POINT: libc::DWORD = 0x900ac;
  64
  65 pub const SYMBOLIC_LINK_FLAG_DIRECTORY: libc::DWORD = 0x1;
  66
  67 // Note that these are not actually HANDLEs, just values to pass to GetStdHandle
  68 pub const STD_INPUT_HANDLE: libc::DWORD = -10i32 as libc::DWORD;
  69 pub const STD_OUTPUT_HANDLE: libc::DWORD = -11i32 as libc::DWORD;
  70 pub const STD_ERROR_HANDLE: libc::DWORD = -12i32 as libc::DWORD;
  71
  72 pub const HANDLE_FLAG_INHERIT: libc::DWORD = 0x00000001;
  73
  74 pub const PROGRESS_CONTINUE: libc::DWORD = 0;
  75 pub const PROGRESS_CANCEL: libc::DWORD = 1;
  76 pub const PROGRESS_STOP: libc::DWORD = 2;
  77 pub const PROGRESS_QUIET: libc::DWORD = 3;
  78
  79 pub const TOKEN_ADJUST_PRIVILEGES: libc::DWORD = 0x0020;
  80 pub const SE_PRIVILEGE_ENABLED: libc::DWORD = 2;
  81
  82 pub const EXCEPTION_CONTINUE_SEARCH: LONG = 0;
  83 pub const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15;
  84 pub const EXCEPTION_STACK_OVERFLOW: DWORD = 0xc00000fd;
  85
  86 #[repr(C)]
  87 #[cfg(target_arch = "x86")]
  88 pub struct WSADATA {
  89     pub wVersion: libc::WORD,
  90     pub wHighVersion: libc::WORD,
  91     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
  92     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
  93     pub iMaxSockets: u16,
  94     pub iMaxUdpDg: u16,
  95     pub lpVendorInfo: *mut u8,
  96 }
  97 #[repr(C)]
  98 #[cfg(target_arch = "x86_64")]
  99 pub struct WSADATA {
 100     pub wVersion: libc::WORD,
 101     pub wHighVersion: libc::WORD,
 102     pub iMaxSockets: u16,
 103     pub iMaxUdpDg: u16,
 104     pub lpVendorInfo: *mut u8,
 105     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
 106     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
 107 }
 108
 109 pub type LPWSADATA = *mut WSADATA;
 110
 111 #[repr(C)]
 112 pub struct WSANETWORKEVENTS {
 113     pub lNetworkEvents: libc::c_long,
 114     pub iErrorCode: [libc::c_int; FD_MAX_EVENTS],
 115 }
 116
 117 pub type LPWSANETWORKEVENTS = *mut WSANETWORKEVENTS;
 118
 119 pub type WSAEVENT = libc::HANDLE;
 120
 121 #[repr(C)]
 122 pub struct WSAPROTOCOL_INFO {
 123     pub dwServiceFlags1: libc::DWORD,
 124     pub dwServiceFlags2: libc::DWORD,
 125     pub dwServiceFlags3: libc::DWORD,
 126     pub dwServiceFlags4: libc::DWORD,
 127     pub dwProviderFlags: libc::DWORD,
 128     pub ProviderId: GUID,
 129     pub dwCatalogEntryId: libc::DWORD,
 130     pub ProtocolChain: WSAPROTOCOLCHAIN,
 131     pub iVersion: libc::c_int,
 132     pub iAddressFamily: libc::c_int,
 133     pub iMaxSockAddr: libc::c_int,
 134     pub iMinSockAddr: libc::c_int,
 135     pub iSocketType: libc::c_int,
 136     pub iProtocol: libc::c_int,
 137     pub iProtocolMaxOffset: libc::c_int,
 138     pub iNetworkByteOrder: libc::c_int,
 139     pub iSecurityScheme: libc::c_int,
 140     pub dwMessageSize: libc::DWORD,
 141     pub dwProviderReserved: libc::DWORD,
 142     pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1],
 143 }
 144
 145 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;
 146
 147 #[repr(C)]
 148 pub struct fd_set {
 149     fd_count: libc::c_uint,
 150     fd_array: [libc::SOCKET; FD_SETSIZE],
 151 }
 152
 153 pub fn fd_set(set: &mut fd_set, s: libc::SOCKET) {
 154     set.fd_array[set.fd_count as usize] = s;
 155     set.fd_count += 1;
 156 }
 157
 158 pub type SHORT = libc::c_short;
 159
 160 #[repr(C)]
 161 pub struct COORD {
 162     pub X: SHORT,
 163     pub Y: SHORT,
 164 }
 165
 166 #[repr(C)]
 167 pub struct SMALL_RECT {
 168     pub Left: SHORT,
 169     pub Top: SHORT,
 170     pub Right: SHORT,
 171     pub Bottom: SHORT,
 172 }
 173
 174 #[repr(C)]
 175 pub struct CONSOLE_SCREEN_BUFFER_INFO {
 176     pub dwSize: COORD,
 177     pub dwCursorPosition: COORD,
 178     pub wAttributes: libc::WORD,
 179     pub srWindow: SMALL_RECT,
 180     pub dwMaximumWindowSize: COORD,
 181 }
 182 pub type PCONSOLE_SCREEN_BUFFER_INFO = *mut CONSOLE_SCREEN_BUFFER_INFO;
 183
 184 #[repr(C)]
 185 #[derive(Clone)]
 186 pub struct WIN32_FILE_ATTRIBUTE_DATA {
 187     pub dwFileAttributes: libc::DWORD,
 188     pub ftCreationTime: libc::FILETIME,
 189     pub ftLastAccessTime: libc::FILETIME,
 190     pub ftLastWriteTime: libc::FILETIME,
 191     pub nFileSizeHigh: libc::DWORD,
 192     pub nFileSizeLow: libc::DWORD,
 193 }
 194
 195 #[repr(C)]
 196 pub struct BY_HANDLE_FILE_INFORMATION {
 197     pub dwFileAttributes: libc::DWORD,
 198     pub ftCreationTime: libc::FILETIME,
 199     pub ftLastAccessTime: libc::FILETIME,
 200     pub ftLastWriteTime: libc::FILETIME,
 201     pub dwVolumeSerialNumber: libc::DWORD,
 202     pub nFileSizeHigh: libc::DWORD,
 203     pub nFileSizeLow: libc::DWORD,
 204     pub nNumberOfLinks: libc::DWORD,
 205     pub nFileIndexHigh: libc::DWORD,
 206     pub nFileIndexLow: libc::DWORD,
 207 }
 208
 209 pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION;
 210
 211 #[repr(C)]
 212 pub enum GET_FILEEX_INFO_LEVELS {
 213     GetFileExInfoStandard,
 214     GetFileExMaxInfoLevel
 215 }
 216
 217 #[repr(C)]
 218 pub enum FILE_INFO_BY_HANDLE_CLASS {
 219     FileBasicInfo                   = 0,
 220     FileStandardInfo                = 1,
 221     FileNameInfo                    = 2,
 222     FileRenameInfo                  = 3,
 223     FileDispositionInfo             = 4,
 224     FileAllocationInfo              = 5,
 225     FileEndOfFileInfo               = 6,
 226     FileStreamInfo                  = 7,
 227     FileCompressionInfo             = 8,
 228     FileAttributeTagInfo            = 9,
 229     FileIdBothDirectoryInfo         = 10, // 0xA
 230     FileIdBothDirectoryRestartInfo  = 11, // 0xB
 231     FileIoPriorityHintInfo          = 12, // 0xC
 232     FileRemoteProtocolInfo          = 13, // 0xD
 233     FileFullDirectoryInfo           = 14, // 0xE
 234     FileFullDirectoryRestartInfo    = 15, // 0xF
 235     FileStorageInfo                 = 16, // 0x10
 236     FileAlignmentInfo               = 17, // 0x11
 237     FileIdInfo                      = 18, // 0x12
 238     FileIdExtdDirectoryInfo         = 19, // 0x13
 239     FileIdExtdDirectoryRestartInfo  = 20, // 0x14
 240     MaximumFileInfoByHandlesClass
 241 }
 242
 243 #[repr(C)]
 244 pub struct FILE_END_OF_FILE_INFO {
 245     pub EndOfFile: libc::LARGE_INTEGER,
 246 }
 247
 248 #[repr(C)]
 249 pub struct REPARSE_DATA_BUFFER {
 250     pub ReparseTag: libc::c_uint,
 251     pub ReparseDataLength: libc::c_ushort,
 252     pub Reserved: libc::c_ushort,
 253     pub rest: (),
 254 }
 255
 256 #[repr(C)]
 257 pub struct SYMBOLIC_LINK_REPARSE_BUFFER {
 258     pub SubstituteNameOffset: libc::c_ushort,
 259     pub SubstituteNameLength: libc::c_ushort,
 260     pub PrintNameOffset: libc::c_ushort,
 261     pub PrintNameLength: libc::c_ushort,
 262     pub Flags: libc::c_ulong,
 263     pub PathBuffer: libc::WCHAR,
 264 }
 265
 266 pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE;
 267 pub type PSRWLOCK = *mut SRWLOCK;
 268 pub type ULONG = c_ulong;
 269 pub type ULONG_PTR = c_ulong;
 270 pub type LPBOOL = *mut BOOL;
 271
 272 pub type LPPROGRESS_ROUTINE = ::option::Option<unsafe extern "system" fn(
 273     TotalFileSize: libc::LARGE_INTEGER,
 274     TotalBytesTransferred: libc::LARGE_INTEGER,
 275     StreamSize: libc::LARGE_INTEGER,
 276     StreamBytesTransferred: libc::LARGE_INTEGER,
 277     dwStreamNumber: DWORD,
 278     dwCallbackReason: DWORD,
 279     hSourceFile: HANDLE,
 280     hDestinationFile: HANDLE,
 281     lpData: LPVOID,
 282 ) -> DWORD>;
 283
 284 #[repr(C)]
 285 pub struct CONDITION_VARIABLE { pub ptr: LPVOID }
 286 #[repr(C)]
 287 pub struct SRWLOCK { pub ptr: LPVOID }
 288 #[repr(C)]
 289 pub struct CRITICAL_SECTION {
 290     CriticalSectionDebug: LPVOID,
 291     LockCount: LONG,
 292     RecursionCount: LONG,
 293     OwningThread: HANDLE,
 294     LockSemaphore: HANDLE,
 295     SpinCount: ULONG_PTR
 296 }
 297
 298 pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = CONDITION_VARIABLE {
 299     ptr: ptr::null_mut(),
 300 };
 301 pub const SRWLOCK_INIT: SRWLOCK = SRWLOCK { ptr: ptr::null_mut() };
 302
 303 #[repr(C)]
 304 pub struct LUID {
 305     pub LowPart: libc::DWORD,
 306     pub HighPart: libc::c_long,
 307 }
 308
 309 pub type PLUID = *mut LUID;
 310
 311 #[repr(C)]
 312 pub struct TOKEN_PRIVILEGES {
 313     pub PrivilegeCount: libc::DWORD,
 314     pub Privileges: [LUID_AND_ATTRIBUTES; 1],
 315 }
 316
 317 pub type PTOKEN_PRIVILEGES = *mut TOKEN_PRIVILEGES;
 318
 319 #[repr(C)]
 320 pub struct LUID_AND_ATTRIBUTES {
 321     pub Luid: LUID,
 322     pub Attributes: libc::DWORD,
 323 }
 324
 325 #[repr(C)]
 326 pub struct REPARSE_MOUNTPOINT_DATA_BUFFER {
 327     pub ReparseTag: libc::DWORD,
 328     pub ReparseDataLength: libc::DWORD,
 329     pub Reserved: libc::WORD,
 330     pub ReparseTargetLength: libc::WORD,
 331     pub ReparseTargetMaximumLength: libc::WORD,
 332     pub Reserved1: libc::WORD,
 333     pub ReparseTarget: libc::WCHAR,
 334 }
 335
 336 #[repr(C)]
 337 pub struct EXCEPTION_RECORD {
 338     pub ExceptionCode: DWORD,
 339     pub ExceptionFlags: DWORD,
 340     pub ExceptionRecord: *mut EXCEPTION_RECORD,
 341     pub ExceptionAddress: LPVOID,
 342     pub NumberParameters: DWORD,
 343     pub ExceptionInformation: [LPVOID; EXCEPTION_MAXIMUM_PARAMETERS]
 344 }
 345
 346 #[repr(C)]
 347 pub struct EXCEPTION_POINTERS {
 348     pub ExceptionRecord: *mut EXCEPTION_RECORD,
 349     pub ContextRecord: LPVOID
 350 }
 351
 352 pub type PVECTORED_EXCEPTION_HANDLER = extern "system"
 353         fn(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG;
 354
 355 #[link(name = "ws2_32")]
 356 #[link(name = "userenv")]
 357 extern "system" {
 358     pub fn WSAStartup(wVersionRequested: libc::WORD,
 359                       lpWSAData: LPWSADATA) -> libc::c_int;
 360     pub fn WSACleanup() -> libc::c_int;
 361     pub fn WSAGetLastError() -> libc::c_int;
 362     pub fn WSACloseEvent(hEvent: WSAEVENT) -> libc::BOOL;
 363     pub fn WSACreateEvent() -> WSAEVENT;
 364     pub fn WSAEventSelect(s: libc::SOCKET,
 365                           hEventObject: WSAEVENT,
 366                           lNetworkEvents: libc::c_long) -> libc::c_int;
 367     pub fn WSASetEvent(hEvent: WSAEVENT) -> libc::BOOL;
 368     pub fn WSAWaitForMultipleEvents(cEvents: libc::DWORD,
 369                                     lphEvents: *const WSAEVENT,
 370                                     fWaitAll: libc::BOOL,
 371                                     dwTimeout: libc::DWORD,
 372                                     fAltertable: libc::BOOL) -> libc::DWORD;
 373     pub fn WSAEnumNetworkEvents(s: libc::SOCKET,
 374                                 hEventObject: WSAEVENT,
 375                                 lpNetworkEvents: LPWSANETWORKEVENTS)
 376                                 -> libc::c_int;
 377     pub fn WSADuplicateSocketW(s: libc::SOCKET,
 378                                dwProcessId: libc::DWORD,
 379                                lpProtocolInfo: LPWSAPROTOCOL_INFO)
 380                                -> libc::c_int;
 381     pub fn GetCurrentProcessId() -> libc::DWORD;
 382     pub fn WSASocketW(af: libc::c_int,
 383                       kind: libc::c_int,
 384                       protocol: libc::c_int,
 385                       lpProtocolInfo: LPWSAPROTOCOL_INFO,
 386                       g: GROUP,
 387                       dwFlags: libc::DWORD) -> libc::SOCKET;
 388
 389     pub fn ioctlsocket(s: libc::SOCKET, cmd: libc::c_long,
 390                        argp: *mut libc::c_ulong) -> libc::c_int;
 391     pub fn select(nfds: libc::c_int,
 392                   readfds: *mut fd_set,
 393                   writefds: *mut fd_set,
 394                   exceptfds: *mut fd_set,
 395                   timeout: *mut libc::timeval) -> libc::c_int;
 396     pub fn getsockopt(sockfd: libc::SOCKET,
 397                       level: libc::c_int,
 398                       optname: libc::c_int,
 399                       optval: *mut libc::c_char,
 400                       optlen: *mut libc::c_int) -> libc::c_int;
 401
 402     pub fn SetEvent(hEvent: libc::HANDLE) -> libc::BOOL;
 403     pub fn WaitForMultipleObjects(nCount: libc::DWORD,
 404                                   lpHandles: *const libc::HANDLE,
 405                                   bWaitAll: libc::BOOL,
 406                                   dwMilliseconds: libc::DWORD) -> libc::DWORD;
 407
 408     pub fn CancelIo(hFile: libc::HANDLE) -> libc::BOOL;
 409     pub fn CancelIoEx(hFile: libc::HANDLE,
 410                       lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
 411
 412     pub fn InitializeCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 413     pub fn EnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 414     pub fn TryEnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION) -> BOOLEAN;
 415     pub fn LeaveCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 416     pub fn DeleteCriticalSection(CriticalSection: *mut CRITICAL_SECTION);
 417
 418     // FIXME - pInputControl should be PCONSOLE_READCONSOLE_CONTROL
 419     pub fn ReadConsoleW(hConsoleInput: libc::HANDLE,
 420                         lpBuffer: libc::LPVOID,
 421                         nNumberOfCharsToRead: libc::DWORD,
 422                         lpNumberOfCharsRead: libc::LPDWORD,
 423                         pInputControl: libc::LPVOID) -> libc::BOOL;
 424
 425     pub fn WriteConsoleW(hConsoleOutput: libc::HANDLE,
 426                          lpBuffer: libc::types::os::arch::extra::LPCVOID,
 427                          nNumberOfCharsToWrite: libc::DWORD,
 428                          lpNumberOfCharsWritten: libc::LPDWORD,
 429                          lpReserved: libc::LPVOID) -> libc::BOOL;
 430
 431     pub fn GetConsoleMode(hConsoleHandle: libc::HANDLE,
 432                           lpMode: libc::LPDWORD) -> libc::BOOL;
 433
 434     pub fn SetConsoleMode(hConsoleHandle: libc::HANDLE,
 435                           lpMode: libc::DWORD) -> libc::BOOL;
 436     pub fn GetConsoleScreenBufferInfo(
 437         hConsoleOutput: libc::HANDLE,
 438         lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO,
 439     ) -> libc::BOOL;
 440
 441     pub fn GetFileAttributesExW(lpFileName: libc::LPCWSTR,
 442                                 fInfoLevelId: GET_FILEEX_INFO_LEVELS,
 443                                 lpFileInformation: libc::LPVOID) -> libc::BOOL;
 444     pub fn RemoveDirectoryW(lpPathName: libc::LPCWSTR) -> libc::BOOL;
 445     pub fn SetFileAttributesW(lpFileName: libc::LPCWSTR,
 446                               dwFileAttributes: libc::DWORD) -> libc::BOOL;
 447     pub fn GetFileAttributesW(lpFileName: libc::LPCWSTR) -> libc::DWORD;
 448     pub fn GetFileInformationByHandle(hFile: libc::HANDLE,
 449                             lpFileInformation: LPBY_HANDLE_FILE_INFORMATION)
 450                             -> libc::BOOL;
 451
 452     pub fn SetLastError(dwErrCode: libc::DWORD);
 453     pub fn GetCommandLineW() -> *mut libc::LPCWSTR;
 454     pub fn LocalFree(ptr: *mut libc::c_void);
 455     pub fn CommandLineToArgvW(lpCmdLine: *mut libc::LPCWSTR,
 456                               pNumArgs: *mut libc::c_int) -> *mut *mut u16;
 457     pub fn SetFileTime(hFile: libc::HANDLE,
 458                        lpCreationTime: *const libc::FILETIME,
 459                        lpLastAccessTime: *const libc::FILETIME,
 460                        lpLastWriteTime: *const libc::FILETIME) -> libc::BOOL;
 461     pub fn GetTempPathW(nBufferLength: libc::DWORD,
 462                         lpBuffer: libc::LPCWSTR) -> libc::DWORD;
 463     pub fn OpenProcessToken(ProcessHandle: libc::HANDLE,
 464                             DesiredAccess: libc::DWORD,
 465                             TokenHandle: *mut libc::HANDLE) -> libc::BOOL;
 466     pub fn GetCurrentProcess() -> libc::HANDLE;
 467     pub fn GetStdHandle(which: libc::DWORD) -> libc::HANDLE;
 468     pub fn ExitProcess(uExitCode: libc::c_uint) -> !;
 469     pub fn DeviceIoControl(hDevice: libc::HANDLE,
 470                            dwIoControlCode: libc::DWORD,
 471                            lpInBuffer: libc::LPVOID,
 472                            nInBufferSize: libc::DWORD,
 473                            lpOutBuffer: libc::LPVOID,
 474                            nOutBufferSize: libc::DWORD,
 475                            lpBytesReturned: libc::LPDWORD,
 476                            lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
 477     pub fn CreatePipe(hReadPipe: libc::LPHANDLE,
 478                       hWritePipe: libc::LPHANDLE,
 479                       lpPipeAttributes: libc::LPSECURITY_ATTRIBUTES,
 480                       nSize: libc::DWORD) -> libc::BOOL;
 481     pub fn CreateThread(lpThreadAttributes: libc::LPSECURITY_ATTRIBUTES,
 482                         dwStackSize: libc::SIZE_T,
 483                         lpStartAddress: extern "system" fn(*mut libc::c_void)
 484                                                            -> libc::DWORD,
 485                         lpParameter: libc::LPVOID,
 486                         dwCreationFlags: libc::DWORD,
 487                         lpThreadId: libc::LPDWORD) -> libc::HANDLE;
 488     pub fn WaitForSingleObject(hHandle: libc::HANDLE,
 489                                dwMilliseconds: libc::DWORD) -> libc::DWORD;
 490     pub fn SwitchToThread() -> libc::BOOL;
 491     pub fn Sleep(dwMilliseconds: libc::DWORD);
 492     pub fn GetProcessId(handle: libc::HANDLE) -> libc::DWORD;
 493     pub fn GetUserProfileDirectoryW(hToken: libc::HANDLE,
 494                                     lpProfileDir: libc::LPCWSTR,
 495                                     lpcchSize: *mut libc::DWORD) -> libc::BOOL;
 496     pub fn SetHandleInformation(hObject: libc::HANDLE,
 497                                 dwMask: libc::DWORD,
 498                                 dwFlags: libc::DWORD) -> libc::BOOL;
 499     pub fn CopyFileExW(lpExistingFileName: libc::LPCWSTR,
 500                        lpNewFileName: libc::LPCWSTR,
 501                        lpProgressRoutine: LPPROGRESS_ROUTINE,
 502                        lpData: libc::LPVOID,
 503                        pbCancel: LPBOOL,
 504                        dwCopyFlags: libc::DWORD) -> libc::BOOL;
 505     pub fn LookupPrivilegeValueW(lpSystemName: libc::LPCWSTR,
 506                                  lpName: libc::LPCWSTR,
 507                                  lpLuid: PLUID) -> libc::BOOL;
 508     pub fn AdjustTokenPrivileges(TokenHandle: libc::HANDLE,
 509                                  DisableAllPrivileges: libc::BOOL,
 510                                  NewState: PTOKEN_PRIVILEGES,
 511                                  BufferLength: libc::DWORD,
 512                                  PreviousState: PTOKEN_PRIVILEGES,
 513                                  ReturnLength: *mut libc::DWORD) -> libc::BOOL;
 514     pub fn AddVectoredExceptionHandler(FirstHandler: ULONG,
 515                                        VectoredHandler: PVECTORED_EXCEPTION_HANDLER)
 516                                        -> LPVOID;
 517 }
 518
 519 // Functions that aren't available on Windows XP, but we still use them and just
 520 // provide some form of a fallback implementation.
 521 compat_fn! {
 522     kernel32:
 523
 524     pub fn CreateSymbolicLinkW(_lpSymlinkFileName: LPCWSTR,
 525                                _lpTargetFileName: LPCWSTR,
 526                                _dwFlags: DWORD) -> BOOLEAN {
 527         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0
 528     }
 529     pub fn GetFinalPathNameByHandleW(_hFile: HANDLE,
 530                                      _lpszFilePath: LPCWSTR,
 531                                      _cchFilePath: DWORD,
 532                                      _dwFlags: DWORD) -> DWORD {
 533         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0
 534     }
 535     pub fn SetThreadErrorMode(_dwNewMode: DWORD,
 536                               _lpOldMode: *mut DWORD) -> c_uint {
 537         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0
 538     }
 539     pub fn SetThreadStackGuarantee(_size: *mut c_ulong) -> BOOL {
 540         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0
 541     }
 542     pub fn SetFileInformationByHandle(_hFile: HANDLE,
 543                     _FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
 544                     _lpFileInformation: LPVOID,
 545                     _dwBufferSize: DWORD) -> BOOL {
 546         SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0
 547     }
 548     pub fn SleepConditionVariableSRW(ConditionVariable: PCONDITION_VARIABLE,
 549                                      SRWLock: PSRWLOCK,
 550                                      dwMilliseconds: DWORD,
 551                                      Flags: ULONG) -> BOOL {
 552         panic!("condition variables not available")
 553     }
 554     pub fn WakeConditionVariable(ConditionVariable: PCONDITION_VARIABLE)
 555                                  -> () {
 556         panic!("condition variables not available")
 557     }
 558     pub fn WakeAllConditionVariable(ConditionVariable: PCONDITION_VARIABLE)
 559                                     -> () {
 560         panic!("condition variables not available")
 561     }
 562     pub fn AcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> () {
 563         panic!("rwlocks not available")
 564     }
 565     pub fn AcquireSRWLockShared(SRWLock: PSRWLOCK) -> () {
 566         panic!("rwlocks not available")
 567     }
 568     pub fn ReleaseSRWLockExclusive(SRWLock: PSRWLOCK) -> () {
 569         panic!("rwlocks not available")
 570     }
 571     pub fn ReleaseSRWLockShared(SRWLock: PSRWLOCK) -> () {
 572         panic!("rwlocks not available")
 573     }
 574     pub fn TryAcquireSRWLockExclusive(SRWLock: PSRWLOCK) -> BOOLEAN {
 575         panic!("rwlocks not available")
 576     }
 577     pub fn TryAcquireSRWLockShared(SRWLock: PSRWLOCK) -> BOOLEAN {
 578         panic!("rwlocks not available")
 579     }
 580 }