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