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