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
  17 pub use self::GET_FILEEX_INFO_LEVELS::*;
  18 pub use self::FILE_INFO_BY_HANDLE_CLASS::*;
  19 pub use libc::consts::os::extra::{
  20     FILE_ATTRIBUTE_READONLY,
  21     FILE_ATTRIBUTE_DIRECTORY,
  22     WSAPROTOCOL_LEN,
  23 };
  24 pub use libc::types::os::arch::extra::{GROUP, GUID, WSAPROTOCOLCHAIN};
  25
  26 pub const WSADESCRIPTION_LEN: usize = 256;
  27 pub const WSASYS_STATUS_LEN: usize = 128;
  28 pub const FIONBIO: libc::c_long = 0x8004667e;
  29 pub const FD_SETSIZE: usize = 64;
  30 pub const MSG_DONTWAIT: libc::c_int = 0;
  31 pub const ERROR_ILLEGAL_CHARACTER: libc::c_int = 582;
  32 pub const ENABLE_ECHO_INPUT: libc::DWORD = 0x4;
  33 pub const ENABLE_EXTENDED_FLAGS: libc::DWORD = 0x80;
  34 pub const ENABLE_INSERT_MODE: libc::DWORD = 0x20;
  35 pub const ENABLE_LINE_INPUT: libc::DWORD = 0x2;
  36 pub const ENABLE_PROCESSED_INPUT: libc::DWORD = 0x1;
  37 pub const ENABLE_QUICK_EDIT_MODE: libc::DWORD = 0x40;
  38 pub const WSA_INVALID_EVENT: WSAEVENT = 0 as WSAEVENT;
  39
  40 pub const FD_ACCEPT: libc::c_long = 0x08;
  41 pub const FD_MAX_EVENTS: usize = 10;
  42 pub const WSA_INFINITE: libc::DWORD = libc::INFINITE;
  43 pub const WSA_WAIT_TIMEOUT: libc::DWORD = libc::consts::os::extra::WAIT_TIMEOUT;
  44 pub const WSA_WAIT_EVENT_0: libc::DWORD = libc::consts::os::extra::WAIT_OBJECT_0;
  45 pub const WSA_WAIT_FAILED: libc::DWORD = libc::consts::os::extra::WAIT_FAILED;
  46 pub const WSAESHUTDOWN: libc::c_int = 10058;
  47
  48 pub const ERROR_NO_MORE_FILES: libc::DWORD = 18;
  49 pub const TOKEN_READ: libc::DWORD = 0x20008;
  50
  51 // Note that these are not actually HANDLEs, just values to pass to GetStdHandle
  52 pub const STD_INPUT_HANDLE: libc::DWORD = -10i32 as libc::DWORD;
  53 pub const STD_OUTPUT_HANDLE: libc::DWORD = -11i32 as libc::DWORD;
  54 pub const STD_ERROR_HANDLE: libc::DWORD = -12i32 as libc::DWORD;
  55
  56 #[repr(C)]
  57 #[cfg(target_arch = "x86")]
  58 pub struct WSADATA {
  59     pub wVersion: libc::WORD,
  60     pub wHighVersion: libc::WORD,
  61     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
  62     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
  63     pub iMaxSockets: u16,
  64     pub iMaxUdpDg: u16,
  65     pub lpVendorInfo: *mut u8,
  66 }
  67 #[repr(C)]
  68 #[cfg(target_arch = "x86_64")]
  69 pub struct WSADATA {
  70     pub wVersion: libc::WORD,
  71     pub wHighVersion: libc::WORD,
  72     pub iMaxSockets: u16,
  73     pub iMaxUdpDg: u16,
  74     pub lpVendorInfo: *mut u8,
  75     pub szDescription: [u8; WSADESCRIPTION_LEN + 1],
  76     pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1],
  77 }
  78
  79 pub type LPWSADATA = *mut WSADATA;
  80
  81 #[repr(C)]
  82 pub struct WSANETWORKEVENTS {
  83     pub lNetworkEvents: libc::c_long,
  84     pub iErrorCode: [libc::c_int; FD_MAX_EVENTS],
  85 }
  86
  87 pub type LPWSANETWORKEVENTS = *mut WSANETWORKEVENTS;
  88
  89 pub type WSAEVENT = libc::HANDLE;
  90
  91 #[repr(C)]
  92 pub struct WSAPROTOCOL_INFO {
  93     pub dwServiceFlags1: libc::DWORD,
  94     pub dwServiceFlags2: libc::DWORD,
  95     pub dwServiceFlags3: libc::DWORD,
  96     pub dwServiceFlags4: libc::DWORD,
  97     pub dwProviderFlags: libc::DWORD,
  98     pub ProviderId: GUID,
  99     pub dwCatalogEntryId: libc::DWORD,
 100     pub ProtocolChain: WSAPROTOCOLCHAIN,
 101     pub iVersion: libc::c_int,
 102     pub iAddressFamily: libc::c_int,
 103     pub iMaxSockAddr: libc::c_int,
 104     pub iMinSockAddr: libc::c_int,
 105     pub iSocketType: libc::c_int,
 106     pub iProtocol: libc::c_int,
 107     pub iProtocolMaxOffset: libc::c_int,
 108     pub iNetworkByteOrder: libc::c_int,
 109     pub iSecurityScheme: libc::c_int,
 110     pub dwMessageSize: libc::DWORD,
 111     pub dwProviderReserved: libc::DWORD,
 112     pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1],
 113 }
 114
 115 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;
 116
 117 #[repr(C)]
 118 pub struct fd_set {
 119     fd_count: libc::c_uint,
 120     fd_array: [libc::SOCKET; FD_SETSIZE],
 121 }
 122
 123 pub fn fd_set(set: &mut fd_set, s: libc::SOCKET) {
 124     set.fd_array[set.fd_count as usize] = s;
 125     set.fd_count += 1;
 126 }
 127
 128 pub type SHORT = libc::c_short;
 129
 130 #[repr(C)]
 131 pub struct COORD {
 132     pub X: SHORT,
 133     pub Y: SHORT,
 134 }
 135
 136 #[repr(C)]
 137 pub struct SMALL_RECT {
 138     pub Left: SHORT,
 139     pub Top: SHORT,
 140     pub Right: SHORT,
 141     pub Bottom: SHORT,
 142 }
 143
 144 #[repr(C)]
 145 pub struct CONSOLE_SCREEN_BUFFER_INFO {
 146     pub dwSize: COORD,
 147     pub dwCursorPosition: COORD,
 148     pub wAttributes: libc::WORD,
 149     pub srWindow: SMALL_RECT,
 150     pub dwMaximumWindowSize: COORD,
 151 }
 152 pub type PCONSOLE_SCREEN_BUFFER_INFO = *mut CONSOLE_SCREEN_BUFFER_INFO;
 153
 154 #[repr(C)]
 155 pub struct WIN32_FILE_ATTRIBUTE_DATA {
 156     pub dwFileAttributes: libc::DWORD,
 157     pub ftCreationTime: libc::FILETIME,
 158     pub ftLastAccessTime: libc::FILETIME,
 159     pub ftLastWriteTime: libc::FILETIME,
 160     pub nFileSizeHigh: libc::DWORD,
 161     pub nFileSizeLow: libc::DWORD,
 162 }
 163
 164 #[repr(C)]
 165 pub struct BY_HANDLE_FILE_INFORMATION {
 166     pub dwFileAttributes: libc::DWORD,
 167     pub ftCreationTime: libc::FILETIME,
 168     pub ftLastAccessTime: libc::FILETIME,
 169     pub ftLastWriteTime: libc::FILETIME,
 170     pub dwVolumeSerialNumber: libc::DWORD,
 171     pub nFileSizeHigh: libc::DWORD,
 172     pub nFileSizeLow: libc::DWORD,
 173     pub nNumberOfLinks: libc::DWORD,
 174     pub nFileIndexHigh: libc::DWORD,
 175     pub nFileIndexLow: libc::DWORD,
 176 }
 177
 178 pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION;
 179
 180 #[repr(C)]
 181 pub enum GET_FILEEX_INFO_LEVELS {
 182     GetFileExInfoStandard,
 183     GetFileExMaxInfoLevel
 184 }
 185
 186 #[repr(C)]
 187 pub enum FILE_INFO_BY_HANDLE_CLASS {
 188     FileBasicInfo                   = 0,
 189     FileStandardInfo                = 1,
 190     FileNameInfo                    = 2,
 191     FileRenameInfo                  = 3,
 192     FileDispositionInfo             = 4,
 193     FileAllocationInfo              = 5,
 194     FileEndOfFileInfo               = 6,
 195     FileStreamInfo                  = 7,
 196     FileCompressionInfo             = 8,
 197     FileAttributeTagInfo            = 9,
 198     FileIdBothDirectoryInfo         = 10, // 0xA
 199     FileIdBothDirectoryRestartInfo  = 11, // 0xB
 200     FileIoPriorityHintInfo          = 12, // 0xC
 201     FileRemoteProtocolInfo          = 13, // 0xD
 202     FileFullDirectoryInfo           = 14, // 0xE
 203     FileFullDirectoryRestartInfo    = 15, // 0xF
 204     FileStorageInfo                 = 16, // 0x10
 205     FileAlignmentInfo               = 17, // 0x11
 206     FileIdInfo                      = 18, // 0x12
 207     FileIdExtdDirectoryInfo         = 19, // 0x13
 208     FileIdExtdDirectoryRestartInfo  = 20, // 0x14
 209     MaximumFileInfoByHandlesClass
 210 }
 211
 212 #[repr(C)]
 213 pub struct FILE_END_OF_FILE_INFO {
 214     pub EndOfFile: libc::LARGE_INTEGER,
 215 }
 216
 217 #[link(name = "ws2_32")]
 218 extern "system" {
 219     pub fn WSAStartup(wVersionRequested: libc::WORD,
 220                       lpWSAData: LPWSADATA) -> libc::c_int;
 221     pub fn WSACleanup() -> libc::c_int;
 222     pub fn WSAGetLastError() -> libc::c_int;
 223     pub fn WSACloseEvent(hEvent: WSAEVENT) -> libc::BOOL;
 224     pub fn WSACreateEvent() -> WSAEVENT;
 225     pub fn WSAEventSelect(s: libc::SOCKET,
 226                           hEventObject: WSAEVENT,
 227                           lNetworkEvents: libc::c_long) -> libc::c_int;
 228     pub fn WSASetEvent(hEvent: WSAEVENT) -> libc::BOOL;
 229     pub fn WSAWaitForMultipleEvents(cEvents: libc::DWORD,
 230                                     lphEvents: *const WSAEVENT,
 231                                     fWaitAll: libc::BOOL,
 232                                     dwTimeout: libc::DWORD,
 233                                     fAltertable: libc::BOOL) -> libc::DWORD;
 234     pub fn WSAEnumNetworkEvents(s: libc::SOCKET,
 235                                 hEventObject: WSAEVENT,
 236                                 lpNetworkEvents: LPWSANETWORKEVENTS)
 237                                 -> libc::c_int;
 238     pub fn WSADuplicateSocketW(s: libc::SOCKET,
 239                                dwProcessId: libc::DWORD,
 240                                lpProtocolInfo: LPWSAPROTOCOL_INFO)
 241                                -> libc::c_int;
 242     pub fn GetCurrentProcessId() -> libc::DWORD;
 243     pub fn WSASocketW(af: libc::c_int,
 244                       kind: libc::c_int,
 245                       protocol: libc::c_int,
 246                       lpProtocolInfo: LPWSAPROTOCOL_INFO,
 247                       g: GROUP,
 248                       dwFlags: libc::DWORD) -> libc::SOCKET;
 249
 250     pub fn ioctlsocket(s: libc::SOCKET, cmd: libc::c_long,
 251                        argp: *mut libc::c_ulong) -> libc::c_int;
 252     pub fn select(nfds: libc::c_int,
 253                   readfds: *mut fd_set,
 254                   writefds: *mut fd_set,
 255                   exceptfds: *mut fd_set,
 256                   timeout: *mut libc::timeval) -> libc::c_int;
 257     pub fn getsockopt(sockfd: libc::SOCKET,
 258                       level: libc::c_int,
 259                       optname: libc::c_int,
 260                       optval: *mut libc::c_char,
 261                       optlen: *mut libc::c_int) -> libc::c_int;
 262
 263     pub fn SetEvent(hEvent: libc::HANDLE) -> libc::BOOL;
 264     pub fn WaitForMultipleObjects(nCount: libc::DWORD,
 265                                   lpHandles: *const libc::HANDLE,
 266                                   bWaitAll: libc::BOOL,
 267                                   dwMilliseconds: libc::DWORD) -> libc::DWORD;
 268
 269     pub fn CancelIo(hFile: libc::HANDLE) -> libc::BOOL;
 270     pub fn CancelIoEx(hFile: libc::HANDLE,
 271                       lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL;
 272 }
 273
 274 pub mod compat {
 275     use prelude::v1::*;
 276
 277     use ffi::CString;
 278     use libc::types::os::arch::extra::{LPCWSTR, HMODULE, LPCSTR, LPVOID};
 279     use sync::atomic::{AtomicUsize, Ordering};
 280
 281     extern "system" {
 282         fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE;
 283         fn GetProcAddress(hModule: HMODULE, lpProcName: LPCSTR) -> LPVOID;
 284     }
 285
 286     fn store_func(ptr: &AtomicUsize, module: &str, symbol: &str,
 287                   fallback: usize) -> usize {
 288         let mut module: Vec<u16> = module.utf16_units().collect();
 289         module.push(0);
 290         let symbol = CString::new(symbol).unwrap();
 291         let func = unsafe {
 292             let handle = GetModuleHandleW(module.as_ptr());
 293             GetProcAddress(handle, symbol.as_ptr()) as usize
 294         };
 295         let value = if func == 0 {fallback} else {func};
 296         ptr.store(value, Ordering::SeqCst);
 297         value
 298     }
 299
 300     /// Macro for creating a compatibility fallback for a Windows function
 301     ///
 302     /// # Examples
 303     /// ```
 304     /// compat_fn!(adll32::SomeFunctionW(_arg: LPCWSTR) {
 305     ///     // Fallback implementation
 306     /// })
 307     /// ```
 308     ///
 309     /// Note that arguments unused by the fallback implementation should not be
 310     /// called `_` as they are used to be passed to the real function if
 311     /// available.
 312     macro_rules! compat_fn {
 313         ($module:ident::$symbol:ident($($argname:ident: $argtype:ty),*)
 314                                       -> $rettype:ty { $fallback:expr }) => (
 315             #[inline(always)]
 316             pub unsafe fn $symbol($($argname: $argtype),*) -> $rettype {
 317                 use sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 318                 use mem;
 319
 320                 static PTR: AtomicUsize = ATOMIC_USIZE_INIT;
 321
 322                 fn load() -> usize {
 323                     ::sys::c::compat::store_func(&PTR,
 324                                                  stringify!($module),
 325                                                  stringify!($symbol),
 326                                                  fallback as usize)
 327                 }
 328
 329                 extern "system" fn fallback($($argname: $argtype),*)
 330                                             -> $rettype { $fallback }
 331
 332                 let addr = match PTR.load(Ordering::SeqCst) {
 333                     0 => load(),
 334                     n => n,
 335                 };
 336                 let f: extern "system" fn($($argtype),*) -> $rettype =
 337                     mem::transmute(addr);
 338                 f($($argname),*)
 339             }
 340         )
 341     }
 342
 343     /// Compatibility layer for functions in `kernel32.dll`
 344     ///
 345     /// Latest versions of Windows this is needed for:
 346     ///
 347     /// * `CreateSymbolicLinkW`: Windows XP, Windows Server 2003
 348     /// * `GetFinalPathNameByHandleW`: Windows XP, Windows Server 2003
 349     pub mod kernel32 {
 350         use libc::c_uint;
 351         use libc::types::os::arch::extra::{DWORD, LPCWSTR, BOOLEAN, HANDLE};
 352         use libc::consts::os::extra::ERROR_CALL_NOT_IMPLEMENTED;
 353         use sys::c::SetLastError;
 354
 355         compat_fn! {
 356             kernel32::CreateSymbolicLinkW(_lpSymlinkFileName: LPCWSTR,
 357                                           _lpTargetFileName: LPCWSTR,
 358                                           _dwFlags: DWORD) -> BOOLEAN {
 359                 unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
 360             }
 361         }
 362
 363         compat_fn! {
 364             kernel32::GetFinalPathNameByHandleW(_hFile: HANDLE,
 365                                                 _lpszFilePath: LPCWSTR,
 366                                                 _cchFilePath: DWORD,
 367                                                 _dwFlags: DWORD) -> DWORD {
 368                 unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
 369             }
 370         }
 371
 372         compat_fn! {
 373             kernel32::SetThreadErrorMode(_dwNewMode: DWORD, _lpOldMode: *mut DWORD) -> c_uint {
 374                 unsafe { SetLastError(ERROR_CALL_NOT_IMPLEMENTED as DWORD); 0 }
 375             }
 376         }
 377     }
 378 }
 379
 380 extern "system" {
 381     // FIXME - pInputControl should be PCONSOLE_READCONSOLE_CONTROL
 382     pub fn ReadConsoleW(hConsoleInput: libc::HANDLE,
 383                         lpBuffer: libc::LPVOID,
 384                         nNumberOfCharsToRead: libc::DWORD,
 385                         lpNumberOfCharsRead: libc::LPDWORD,
 386                         pInputControl: libc::LPVOID) -> libc::BOOL;
 387
 388     pub fn WriteConsoleW(hConsoleOutput: libc::HANDLE,
 389                          lpBuffer: libc::types::os::arch::extra::LPCVOID,
 390                          nNumberOfCharsToWrite: libc::DWORD,
 391                          lpNumberOfCharsWritten: libc::LPDWORD,
 392                          lpReserved: libc::LPVOID) -> libc::BOOL;
 393
 394     pub fn GetConsoleMode(hConsoleHandle: libc::HANDLE,
 395                           lpMode: libc::LPDWORD) -> libc::BOOL;
 396
 397     pub fn SetConsoleMode(hConsoleHandle: libc::HANDLE,
 398                           lpMode: libc::DWORD) -> libc::BOOL;
 399     pub fn GetConsoleScreenBufferInfo(
 400         hConsoleOutput: libc::HANDLE,
 401         lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO,
 402     ) -> libc::BOOL;
 403
 404     pub fn GetFileAttributesExW(lpFileName: libc::LPCWSTR,
 405                                 fInfoLevelId: GET_FILEEX_INFO_LEVELS,
 406                                 lpFileInformation: libc::LPVOID) -> libc::BOOL;
 407     pub fn RemoveDirectoryW(lpPathName: libc::LPCWSTR) -> libc::BOOL;
 408     pub fn SetFileAttributesW(lpFileName: libc::LPCWSTR,
 409                               dwFileAttributes: libc::DWORD) -> libc::BOOL;
 410     pub fn GetFileAttributesW(lpFileName: libc::LPCWSTR) -> libc::DWORD;
 411     pub fn GetFileInformationByHandle(hFile: libc::HANDLE,
 412                             lpFileInformation: LPBY_HANDLE_FILE_INFORMATION)
 413                             -> libc::BOOL;
 414
 415     pub fn SetLastError(dwErrCode: libc::DWORD);
 416     pub fn GetCommandLineW() -> *mut libc::LPCWSTR;
 417     pub fn LocalFree(ptr: *mut libc::c_void);
 418     pub fn CommandLineToArgvW(lpCmdLine: *mut libc::LPCWSTR,
 419                               pNumArgs: *mut libc::c_int) -> *mut *mut u16;
 420     pub fn SetFileTime(hFile: libc::HANDLE,
 421                        lpCreationTime: *const libc::FILETIME,
 422                        lpLastAccessTime: *const libc::FILETIME,
 423                        lpLastWriteTime: *const libc::FILETIME) -> libc::BOOL;
 424     pub fn SetFileInformationByHandle(hFile: libc::HANDLE,
 425                     FileInformationClass: FILE_INFO_BY_HANDLE_CLASS,
 426                     lpFileInformation: libc::LPVOID,
 427                     dwBufferSize: libc::DWORD) -> libc::BOOL;
 428     pub fn GetTempPathW(nBufferLength: libc::DWORD,
 429                         lpBuffer: libc::LPCWSTR) -> libc::DWORD;
 430     pub fn OpenProcessToken(ProcessHandle: libc::HANDLE,
 431                             DesiredAccess: libc::DWORD,
 432                             TokenHandle: *mut libc::HANDLE) -> libc::BOOL;
 433     pub fn GetCurrentProcess() -> libc::HANDLE;
 434     pub fn GetStdHandle(which: libc::DWORD) -> libc::HANDLE;
 435     pub fn ExitProcess(uExitCode: libc::c_uint) -> !;
 436 }
 437
 438 #[link(name = "userenv")]
 439 extern "system" {
 440     pub fn GetUserProfileDirectoryW(hToken: libc::HANDLE,
 441                                     lpProfileDir: libc::LPCWSTR,
 442                                     lpcchSize: *mut libc::DWORD) -> libc::BOOL;
 443 }