From 32262e46cfdd02ef0f03c75b09fe7003d0b98366 Mon Sep 17 00:00:00 2001 From: Peter Atashian Date: Fri, 5 Jun 2015 11:26:36 -0400 Subject: [PATCH] Move WinAPI functions from libc to std::sys::windows::c Also remove unused WinAPI functions Signed-off-by: Peter Atashian --- src/liblibc/lib.rs | 224 +---------------------- src/librustdoc/flock.rs | 35 +--- src/libstd/sys/windows/c.rs | 131 ++++++++----- src/libstd/sys/windows/fs.rs | 38 ++-- src/libstd/sys/windows/handle.rs | 24 +-- src/libstd/sys/windows/mod.rs | 6 +- src/libstd/sys/windows/os.rs | 27 ++- src/libstd/sys/windows/process.rs | 21 +-- src/libstd/sys/windows/stack_overflow.rs | 3 +- src/libstd/sys/windows/time.rs | 5 +- 10 files changed, 158 insertions(+), 356 deletions(-) diff --git a/src/liblibc/lib.rs b/src/liblibc/lib.rs index b7a40a3f9cf13..30a70148528e2 100644 --- a/src/liblibc/lib.rs +++ b/src/liblibc/lib.rs @@ -134,11 +134,6 @@ pub use funcs::bsd43::*; #[cfg(unix)] pub use funcs::posix01::unistd::*; #[cfg(unix)] pub use funcs::posix01::resource::*; - -#[cfg(windows)] pub use funcs::extra::kernel32::*; -#[cfg(windows)] pub use funcs::extra::winsock::*; -#[cfg(windows)] pub use funcs::extra::msvcrt::*; - // On NaCl, these libraries are static. Thus it would be a Bad Idea to link them // in when creating a test crate. #[cfg(not(any(windows, target_env = "musl", all(target_os = "nacl", test))))] @@ -6165,224 +6160,7 @@ pub mod funcs { #[cfg(target_os = "windows")] - pub mod extra { - - pub mod kernel32 { - use types::os::arch::c95::{c_uint}; - use types::os::arch::extra::{BOOL, DWORD, SIZE_T, HMODULE, - LPCWSTR, LPWSTR, - LPWCH, LPDWORD, LPVOID, - LPCVOID, LPOVERLAPPED, - LPSECURITY_ATTRIBUTES, - LPSTARTUPINFO, - LPPROCESS_INFORMATION, - LPMEMORY_BASIC_INFORMATION, - LPSYSTEM_INFO, HANDLE, LPHANDLE, - LARGE_INTEGER, PLARGE_INTEGER, - LPFILETIME, LPWIN32_FIND_DATAW}; - - extern "system" { - pub fn GetEnvironmentVariableW(n: LPCWSTR, - v: LPWSTR, - nsize: DWORD) - -> DWORD; - pub fn SetEnvironmentVariableW(n: LPCWSTR, v: LPCWSTR) - -> BOOL; - pub fn GetEnvironmentStringsW() -> LPWCH; - pub fn FreeEnvironmentStringsW(env_ptr: LPWCH) -> BOOL; - pub fn GetModuleFileNameW(hModule: HMODULE, - lpFilename: LPWSTR, - nSize: DWORD) - -> DWORD; - pub fn CreateDirectoryW(lpPathName: LPCWSTR, - lpSecurityAttributes: - LPSECURITY_ATTRIBUTES) - -> BOOL; - pub fn CopyFileW(lpExistingFileName: LPCWSTR, - lpNewFileName: LPCWSTR, - bFailIfExists: BOOL) - -> BOOL; - pub fn DeleteFileW(lpPathName: LPCWSTR) -> BOOL; - pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL; - pub fn GetCurrentDirectoryW(nBufferLength: DWORD, - lpBuffer: LPWSTR) - -> DWORD; - pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL; - pub fn GetLastError() -> DWORD; - pub fn FindFirstFileW(fileName: LPCWSTR, findFileData: LPWIN32_FIND_DATAW) - -> HANDLE; - pub fn FindNextFileW(findFile: HANDLE, findFileData: LPWIN32_FIND_DATAW) - -> BOOL; - pub fn FindClose(findFile: HANDLE) -> BOOL; - pub fn DuplicateHandle(hSourceProcessHandle: HANDLE, - hSourceHandle: HANDLE, - hTargetProcessHandle: HANDLE, - lpTargetHandle: LPHANDLE, - dwDesiredAccess: DWORD, - bInheritHandle: BOOL, - dwOptions: DWORD) - -> BOOL; - pub fn CloseHandle(hObject: HANDLE) -> BOOL; - pub fn OpenProcess(dwDesiredAccess: DWORD, - bInheritHandle: BOOL, - dwProcessId: DWORD) - -> HANDLE; - pub fn GetCurrentProcess() -> HANDLE; - pub fn CreateProcessW(lpApplicationName: LPCWSTR, - lpCommandLine: LPWSTR, - lpProcessAttributes: - LPSECURITY_ATTRIBUTES, - lpThreadAttributes: - LPSECURITY_ATTRIBUTES, - bInheritHandles: BOOL, - dwCreationFlags: DWORD, - lpEnvironment: LPVOID, - lpCurrentDirectory: LPCWSTR, - lpStartupInfo: LPSTARTUPINFO, - lpProcessInformation: - LPPROCESS_INFORMATION) - -> BOOL; - pub fn WaitForSingleObject(hHandle: HANDLE, - dwMilliseconds: DWORD) - -> DWORD; - pub fn TerminateProcess(hProcess: HANDLE, uExitCode: c_uint) - -> BOOL; - pub fn GetExitCodeProcess(hProcess: HANDLE, - lpExitCode: LPDWORD) - -> BOOL; - pub fn GetSystemInfo(lpSystemInfo: LPSYSTEM_INFO); - pub fn VirtualAlloc(lpAddress: LPVOID, - dwSize: SIZE_T, - flAllocationType: DWORD, - flProtect: DWORD) - -> LPVOID; - pub fn VirtualFree(lpAddress: LPVOID, - dwSize: SIZE_T, - dwFreeType: DWORD) - -> BOOL; - pub fn VirtualLock(lpAddress: LPVOID, dwSize: SIZE_T) -> BOOL; - pub fn VirtualUnlock(lpAddress: LPVOID, dwSize: SIZE_T) - -> BOOL; - pub fn VirtualProtect(lpAddress: LPVOID, - dwSize: SIZE_T, - flNewProtect: DWORD, - lpflOldProtect: LPDWORD) - -> BOOL; - pub fn VirtualQuery(lpAddress: LPCVOID, - lpBuffer: LPMEMORY_BASIC_INFORMATION, - dwLength: SIZE_T) - -> SIZE_T; - pub fn CreateFileMappingW(hFile: HANDLE, - lpAttributes: LPSECURITY_ATTRIBUTES, - flProtect: DWORD, - dwMaximumSizeHigh: DWORD, - dwMaximumSizeLow: DWORD, - lpName: LPCWSTR) - -> HANDLE; - pub fn MapViewOfFile(hFileMappingObject: HANDLE, - dwDesiredAccess: DWORD, - dwFileOffsetHigh: DWORD, - dwFileOffsetLow: DWORD, - dwNumberOfBytesToMap: SIZE_T) - -> LPVOID; - pub fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL; - pub fn MoveFileExW(lpExistingFileName: LPCWSTR, - lpNewFileName: LPCWSTR, - dwFlags: DWORD) -> BOOL; - pub fn CreateHardLinkW(lpSymlinkFileName: LPCWSTR, - lpTargetFileName: LPCWSTR, - lpSecurityAttributes: LPSECURITY_ATTRIBUTES) - -> BOOL; - pub fn FlushFileBuffers(hFile: HANDLE) -> BOOL; - pub fn CreateFileW(lpFileName: LPCWSTR, - dwDesiredAccess: DWORD, - dwShareMode: DWORD, - lpSecurityAttributes: LPSECURITY_ATTRIBUTES, - dwCreationDisposition: DWORD, - dwFlagsAndAttributes: DWORD, - hTemplateFile: HANDLE) -> HANDLE; - pub fn ReadFile(hFile: HANDLE, - lpBuffer: LPVOID, - nNumberOfBytesToRead: DWORD, - lpNumberOfBytesRead: LPDWORD, - lpOverlapped: LPOVERLAPPED) -> BOOL; - pub fn WriteFile(hFile: HANDLE, - lpBuffer: LPVOID, - nNumberOfBytesToWrite: DWORD, - lpNumberOfBytesWritten: LPDWORD, - lpOverlapped: LPOVERLAPPED) -> BOOL; - pub fn SetFilePointerEx(hFile: HANDLE, - liDistanceToMove: LARGE_INTEGER, - lpNewFilePointer: PLARGE_INTEGER, - dwMoveMethod: DWORD) -> BOOL; - pub fn SetEndOfFile(hFile: HANDLE) -> BOOL; - - pub fn GetSystemTimeAsFileTime( - lpSystemTimeAsFileTime: LPFILETIME); - - pub fn QueryPerformanceFrequency( - lpFrequency: *mut LARGE_INTEGER) -> BOOL; - pub fn QueryPerformanceCounter( - lpPerformanceCount: *mut LARGE_INTEGER) -> BOOL; - - pub fn GetCurrentProcessId() -> DWORD; - pub fn CreateNamedPipeW( - lpName: LPCWSTR, - dwOpenMode: DWORD, - dwPipeMode: DWORD, - nMaxInstances: DWORD, - nOutBufferSize: DWORD, - nInBufferSize: DWORD, - nDefaultTimeOut: DWORD, - lpSecurityAttributes: LPSECURITY_ATTRIBUTES - ) -> HANDLE; - pub fn ConnectNamedPipe(hNamedPipe: HANDLE, - lpOverlapped: LPOVERLAPPED) -> BOOL; - pub fn WaitNamedPipeW(lpNamedPipeName: LPCWSTR, - nTimeOut: DWORD) -> BOOL; - pub fn SetNamedPipeHandleState(hNamedPipe: HANDLE, - lpMode: LPDWORD, - lpMaxCollectionCount: LPDWORD, - lpCollectDataTimeout: LPDWORD) - -> BOOL; - pub fn CreateEventW(lpEventAttributes: LPSECURITY_ATTRIBUTES, - bManualReset: BOOL, - bInitialState: BOOL, - lpName: LPCWSTR) -> HANDLE; - pub fn GetOverlappedResult(hFile: HANDLE, - lpOverlapped: LPOVERLAPPED, - lpNumberOfBytesTransferred: LPDWORD, - bWait: BOOL) -> BOOL; - pub fn DisconnectNamedPipe(hNamedPipe: HANDLE) -> BOOL; - } - } - - pub mod msvcrt { - use types::os::arch::c95::{c_int, c_long}; - use types::os::arch::c99::intptr_t; - - extern { - #[link_name = "_commit"] - pub fn commit(fd: c_int) -> c_int; - - #[link_name = "_get_osfhandle"] - pub fn get_osfhandle(fd: c_int) -> c_long; - - #[link_name = "_open_osfhandle"] - pub fn open_osfhandle(osfhandle: intptr_t, - flags: c_int) -> c_int; - } - } - - pub mod winsock { - use types::os::arch::c95::{c_int, c_long, c_ulong}; - use types::os::common::bsd44::SOCKET; - - extern "system" { - pub fn ioctlsocket(s: SOCKET, cmd: c_long, argp: *mut c_ulong) -> c_int; - } - } - } + pub mod extra {} } #[doc(hidden)] diff --git a/src/librustdoc/flock.rs b/src/librustdoc/flock.rs index 760fa329fd986..277d4b08ce04c 100644 --- a/src/librustdoc/flock.rs +++ b/src/librustdoc/flock.rs @@ -165,12 +165,11 @@ mod imp { #[cfg(windows)] mod imp { use libc; + use std::fs::File; use std::io; use std::mem; - use std::ffi::OsStr; use std::os::windows::prelude::*; use std::path::Path; - use std::ptr; const LOCKFILE_EXCLUSIVE_LOCK: libc::DWORD = 0x00000002; @@ -190,40 +189,22 @@ mod imp { } pub struct Lock { - handle: libc::HANDLE, + file: File, } impl Lock { pub fn new(p: &Path) -> Lock { - let os: &OsStr = p.as_ref(); - let mut p_16: Vec<_> = os.encode_wide().collect(); - p_16.push(0); - let handle = unsafe { - libc::CreateFileW(p_16.as_ptr(), - libc::FILE_GENERIC_READ | - libc::FILE_GENERIC_WRITE, - libc::FILE_SHARE_READ | - libc::FILE_SHARE_DELETE | - libc::FILE_SHARE_WRITE, - ptr::null_mut(), - libc::CREATE_ALWAYS, - libc::FILE_ATTRIBUTE_NORMAL, - ptr::null_mut()) - }; - if handle == libc::INVALID_HANDLE_VALUE { - panic!("create file error: {}", io::Error::last_os_error()); - } + let file = File::create(p).unwrap(); let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() }; let ret = unsafe { - LockFileEx(handle, LOCKFILE_EXCLUSIVE_LOCK, 0, 100, 0, - &mut overlapped) + LockFileEx(file.as_raw_handle() as libc::HANDLE, LOCKFILE_EXCLUSIVE_LOCK, + 0, 100, 0, &mut overlapped) }; if ret == 0 { let err = io::Error::last_os_error(); - unsafe { libc::CloseHandle(handle); } panic!("could not lock `{}`: {}", p.display(), err); } - Lock { handle: handle } + Lock { file: file } } } @@ -231,8 +212,8 @@ mod imp { fn drop(&mut self) { let mut overlapped: libc::OVERLAPPED = unsafe { mem::zeroed() }; unsafe { - UnlockFileEx(self.handle, 0, 100, 0, &mut overlapped); - libc::CloseHandle(self.handle); + UnlockFileEx(self.file.as_raw_handle() as libc::HANDLE, + 0, 100, 0, &mut overlapped); } } } diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index 3c9b2ef1b986e..45c760e12775f 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -246,21 +246,6 @@ extern "system" { lpWSAData: LPWSADATA) -> libc::c_int; pub fn WSACleanup() -> libc::c_int; pub fn WSAGetLastError() -> libc::c_int; - pub fn WSACloseEvent(hEvent: WSAEVENT) -> libc::BOOL; - pub fn WSACreateEvent() -> WSAEVENT; - pub fn WSAEventSelect(s: libc::SOCKET, - hEventObject: WSAEVENT, - lNetworkEvents: libc::c_long) -> libc::c_int; - pub fn WSASetEvent(hEvent: WSAEVENT) -> libc::BOOL; - pub fn WSAWaitForMultipleEvents(cEvents: libc::DWORD, - lphEvents: *const WSAEVENT, - fWaitAll: libc::BOOL, - dwTimeout: libc::DWORD, - fAltertable: libc::BOOL) -> libc::DWORD; - pub fn WSAEnumNetworkEvents(s: libc::SOCKET, - hEventObject: WSAEVENT, - lpNetworkEvents: LPWSANETWORKEVENTS) - -> libc::c_int; pub fn WSADuplicateSocketW(s: libc::SOCKET, dwProcessId: libc::DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFO) @@ -272,29 +257,11 @@ extern "system" { lpProtocolInfo: LPWSAPROTOCOL_INFO, g: GROUP, dwFlags: libc::DWORD) -> libc::SOCKET; - - pub fn ioctlsocket(s: libc::SOCKET, cmd: libc::c_long, - argp: *mut libc::c_ulong) -> libc::c_int; - pub fn select(nfds: libc::c_int, - readfds: *mut fd_set, - writefds: *mut fd_set, - exceptfds: *mut fd_set, - timeout: *mut libc::timeval) -> libc::c_int; pub fn getsockopt(sockfd: libc::SOCKET, level: libc::c_int, optname: libc::c_int, optval: *mut libc::c_char, optlen: *mut libc::c_int) -> libc::c_int; - - pub fn SetEvent(hEvent: libc::HANDLE) -> libc::BOOL; - pub fn WaitForMultipleObjects(nCount: libc::DWORD, - lpHandles: *const libc::HANDLE, - bWaitAll: libc::BOOL, - dwMilliseconds: libc::DWORD) -> libc::DWORD; - - pub fn CancelIo(hFile: libc::HANDLE) -> libc::BOOL; - pub fn CancelIoEx(hFile: libc::HANDLE, - lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL; } pub mod compat { @@ -419,21 +386,12 @@ extern "system" { pub fn GetConsoleMode(hConsoleHandle: libc::HANDLE, lpMode: libc::LPDWORD) -> libc::BOOL; - - pub fn SetConsoleMode(hConsoleHandle: libc::HANDLE, - lpMode: libc::DWORD) -> libc::BOOL; - pub fn GetConsoleScreenBufferInfo( - hConsoleOutput: libc::HANDLE, - lpConsoleScreenBufferInfo: PCONSOLE_SCREEN_BUFFER_INFO, - ) -> libc::BOOL; - pub fn GetFileAttributesExW(lpFileName: libc::LPCWSTR, fInfoLevelId: GET_FILEEX_INFO_LEVELS, lpFileInformation: libc::LPVOID) -> libc::BOOL; pub fn RemoveDirectoryW(lpPathName: libc::LPCWSTR) -> libc::BOOL; pub fn SetFileAttributesW(lpFileName: libc::LPCWSTR, dwFileAttributes: libc::DWORD) -> libc::BOOL; - pub fn GetFileAttributesW(lpFileName: libc::LPCWSTR) -> libc::DWORD; pub fn GetFileInformationByHandle(hFile: libc::HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) -> libc::BOOL; @@ -483,6 +441,95 @@ extern "system" { pub fn SwitchToThread() -> libc::BOOL; pub fn Sleep(dwMilliseconds: libc::DWORD); pub fn GetProcessId(handle: libc::HANDLE) -> libc::DWORD; + pub fn GetEnvironmentVariableW(n: libc::LPCWSTR, + v: libc::LPWSTR, + nsize: libc::DWORD) + -> libc::DWORD; + pub fn SetEnvironmentVariableW(n: libc::LPCWSTR, v: libc::LPCWSTR) + -> libc::BOOL; + pub fn GetEnvironmentStringsW() -> libc::LPWCH; + pub fn FreeEnvironmentStringsW(env_ptr: libc::LPWCH) -> libc::BOOL; + pub fn GetModuleFileNameW(hModule: libc::HMODULE, + lpFilename: libc::LPWSTR, + nSize: libc::DWORD) + -> libc::DWORD; + pub fn CreateDirectoryW(lpPathName: libc::LPCWSTR, + lpSecurityAttributes: + libc::LPSECURITY_ATTRIBUTES) + -> libc::BOOL; + pub fn DeleteFileW(lpPathName: libc::LPCWSTR) -> libc::BOOL; + pub fn GetCurrentDirectoryW(nBufferLength: libc::DWORD, + lpBuffer: libc::LPWSTR) + -> libc::DWORD; + pub fn SetCurrentDirectoryW(lpPathName: libc::LPCWSTR) -> libc::BOOL; + pub fn GetLastError() -> libc::DWORD; + pub fn FindFirstFileW(fileName: libc::LPCWSTR, findFileData: libc::LPWIN32_FIND_DATAW) + -> libc::HANDLE; + pub fn FindNextFileW(findFile: libc::HANDLE, findFileData: libc::LPWIN32_FIND_DATAW) + -> libc::BOOL; + pub fn FindClose(findFile: libc::HANDLE) -> libc::BOOL; + pub fn DuplicateHandle(hSourceProcessHandle: libc::HANDLE, + hSourceHandle: libc::HANDLE, + hTargetProcessHandle: libc::HANDLE, + lpTargetHandle: libc::LPHANDLE, + dwDesiredAccess: libc::DWORD, + bInheritHandle: libc::BOOL, + dwOptions: libc::DWORD) + -> libc::BOOL; + pub fn CloseHandle(hObject: libc::HANDLE) -> libc::BOOL; + pub fn CreateProcessW(lpApplicationName: libc::LPCWSTR, + lpCommandLine: libc::LPWSTR, + lpProcessAttributes: + libc::LPSECURITY_ATTRIBUTES, + lpThreadAttributes: + libc::LPSECURITY_ATTRIBUTES, + bInheritHandles: libc::BOOL, + dwCreationFlags: libc::DWORD, + lpEnvironment: libc::LPVOID, + lpCurrentDirectory: libc::LPCWSTR, + lpStartupInfo: libc::LPSTARTUPINFO, + lpProcessInformation: + libc::LPPROCESS_INFORMATION) + -> libc::BOOL; + pub fn TerminateProcess(hProcess: libc::HANDLE, uExitCode: libc::c_uint) + -> libc::BOOL; + pub fn GetExitCodeProcess(hProcess: libc::HANDLE, + lpExitCode: libc::LPDWORD) + -> libc::BOOL; + pub fn GetSystemInfo(lpSystemInfo: libc::LPSYSTEM_INFO); + pub fn MoveFileExW(lpExistingFileName: libc::LPCWSTR, + lpNewFileName: libc::LPCWSTR, + dwFlags: libc::DWORD) -> libc::BOOL; + pub fn CreateHardLinkW(lpSymlinkFileName: libc::LPCWSTR, + lpTargetFileName: libc::LPCWSTR, + lpSecurityAttributes: libc::LPSECURITY_ATTRIBUTES) + -> libc::BOOL; + pub fn FlushFileBuffers(hFile: libc::HANDLE) -> libc::BOOL; + pub fn CreateFileW(lpFileName: libc::LPCWSTR, + dwDesiredAccess: libc::DWORD, + dwShareMode: libc::DWORD, + lpSecurityAttributes: libc::LPSECURITY_ATTRIBUTES, + dwCreationDisposition: libc::DWORD, + dwFlagsAndAttributes: libc::DWORD, + hTemplateFile: libc::HANDLE) -> libc::HANDLE; + pub fn ReadFile(hFile: libc::HANDLE, + lpBuffer: libc::LPVOID, + nNumberOfBytesToRead: libc::DWORD, + lpNumberOfBytesRead: libc::LPDWORD, + lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL; + pub fn WriteFile(hFile: libc::HANDLE, + lpBuffer: libc::LPVOID, + nNumberOfBytesToWrite: libc::DWORD, + lpNumberOfBytesWritten: libc::LPDWORD, + lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL; + pub fn SetFilePointerEx(hFile: libc::HANDLE, + liDistanceToMove: libc::LARGE_INTEGER, + lpNewFilePointer: libc::PLARGE_INTEGER, + dwMoveMethod: libc::DWORD) -> libc::BOOL; + pub fn QueryPerformanceFrequency( + lpFrequency: *mut libc::LARGE_INTEGER) -> libc::BOOL; + pub fn QueryPerformanceCounter( + lpPerformanceCount: *mut libc::LARGE_INTEGER) -> libc::BOOL; } #[link(name = "userenv")] diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index 03a56e2958a6e..e8c04c60049da 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -84,8 +84,8 @@ impl Iterator for ReadDir { unsafe { let mut wfd = mem::zeroed(); loop { - if libc::FindNextFileW(self.handle.0, &mut wfd) == 0 { - if libc::GetLastError() == + if c::FindNextFileW(self.handle.0, &mut wfd) == 0 { + if c::GetLastError() == c::ERROR_NO_MORE_FILES as libc::DWORD { return None } else { @@ -102,7 +102,7 @@ impl Iterator for ReadDir { impl Drop for FindNextFileHandle { fn drop(&mut self) { - let r = unsafe { libc::FindClose(self.0) }; + let r = unsafe { c::FindClose(self.0) }; debug_assert!(r != 0); } } @@ -228,13 +228,13 @@ impl File { pub fn open(path: &Path, opts: &OpenOptions) -> io::Result { let path = to_utf16(path); let handle = unsafe { - libc::CreateFileW(path.as_ptr(), - opts.get_desired_access(), - opts.get_share_mode(), - opts.security_attributes as *mut _, - opts.get_creation_disposition(), - opts.get_flags_and_attributes(), - ptr::null_mut()) + c::CreateFileW(path.as_ptr(), + opts.get_desired_access(), + opts.get_share_mode(), + opts.security_attributes as *mut _, + opts.get_creation_disposition(), + opts.get_flags_and_attributes(), + ptr::null_mut()) }; if handle == libc::INVALID_HANDLE_VALUE { Err(Error::last_os_error()) @@ -244,7 +244,7 @@ impl File { } pub fn fsync(&self) -> io::Result<()> { - try!(cvt(unsafe { libc::FlushFileBuffers(self.handle.raw()) })); + try!(cvt(unsafe { c::FlushFileBuffers(self.handle.raw()) })); Ok(()) } @@ -306,8 +306,8 @@ impl File { let pos = pos as libc::LARGE_INTEGER; let mut newpos = 0; try!(cvt(unsafe { - libc::SetFilePointerEx(self.handle.raw(), pos, - &mut newpos, whence) + c::SetFilePointerEx(self.handle.raw(), pos, + &mut newpos, whence) })); Ok(newpos as u64) } @@ -439,7 +439,7 @@ impl DirBuilder { pub fn mkdir(&self, p: &Path) -> io::Result<()> { let p = to_utf16(p); try!(cvt(unsafe { - libc::CreateDirectoryW(p.as_ptr(), ptr::null_mut()) + c::CreateDirectoryW(p.as_ptr(), ptr::null_mut()) })); Ok(()) } @@ -452,7 +452,7 @@ pub fn readdir(p: &Path) -> io::Result { unsafe { let mut wfd = mem::zeroed(); - let find_handle = libc::FindFirstFileW(path.as_ptr(), &mut wfd); + let find_handle = c::FindFirstFileW(path.as_ptr(), &mut wfd); if find_handle != libc::INVALID_HANDLE_VALUE { Ok(ReadDir { handle: FindNextFileHandle(find_handle), @@ -467,7 +467,7 @@ pub fn readdir(p: &Path) -> io::Result { pub fn unlink(p: &Path) -> io::Result<()> { let p_utf16 = to_utf16(p); - try!(cvt(unsafe { libc::DeleteFileW(p_utf16.as_ptr()) })); + try!(cvt(unsafe { c::DeleteFileW(p_utf16.as_ptr()) })); Ok(()) } @@ -475,8 +475,8 @@ pub fn rename(old: &Path, new: &Path) -> io::Result<()> { let old = to_utf16(old); let new = to_utf16(new); try!(cvt(unsafe { - libc::MoveFileExW(old.as_ptr(), new.as_ptr(), - libc::MOVEFILE_REPLACE_EXISTING) + c::MoveFileExW(old.as_ptr(), new.as_ptr(), + libc::MOVEFILE_REPLACE_EXISTING) })); Ok(()) } @@ -511,7 +511,7 @@ pub fn link(src: &Path, dst: &Path) -> io::Result<()> { let src = to_utf16(src); let dst = to_utf16(dst); try!(cvt(unsafe { - libc::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut()) + c::CreateHardLinkW(dst.as_ptr(), src.as_ptr(), ptr::null_mut()) })); Ok(()) } diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index a566c5eff324e..665aa03d756f3 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -12,11 +12,11 @@ use prelude::v1::*; use io::ErrorKind; use io; -use libc::funcs::extra::kernel32::{GetCurrentProcess, DuplicateHandle}; use libc::{self, HANDLE}; use mem; use ops::Deref; use ptr; +use sys::c; use sys::cvt; /// An owned container for `HANDLE` object, closing them on Drop. @@ -54,7 +54,7 @@ impl Deref for Handle { impl Drop for Handle { fn drop(&mut self) { - unsafe { let _ = libc::CloseHandle(self.raw()); } + unsafe { let _ = c::CloseHandle(self.raw()); } } } @@ -68,9 +68,9 @@ impl RawHandle { pub fn read(&self, buf: &mut [u8]) -> io::Result { let mut read = 0; let res = cvt(unsafe { - libc::ReadFile(self.0, buf.as_ptr() as libc::LPVOID, - buf.len() as libc::DWORD, &mut read, - ptr::null_mut()) + c::ReadFile(self.0, buf.as_ptr() as libc::LPVOID, + buf.len() as libc::DWORD, &mut read, + ptr::null_mut()) }); match res { @@ -89,9 +89,9 @@ impl RawHandle { pub fn write(&self, buf: &[u8]) -> io::Result { let mut amt = 0; try!(cvt(unsafe { - libc::WriteFile(self.0, buf.as_ptr() as libc::LPVOID, - buf.len() as libc::DWORD, &mut amt, - ptr::null_mut()) + c::WriteFile(self.0, buf.as_ptr() as libc::LPVOID, + buf.len() as libc::DWORD, &mut amt, + ptr::null_mut()) })); Ok(amt as usize) } @@ -100,10 +100,10 @@ impl RawHandle { options: libc::DWORD) -> io::Result { let mut ret = 0 as libc::HANDLE; try!(cvt(unsafe { - let cur_proc = GetCurrentProcess(); - DuplicateHandle(cur_proc, self.0, cur_proc, &mut ret, - access, inherit as libc::BOOL, - options) + let cur_proc = c::GetCurrentProcess(); + c::DuplicateHandle(cur_proc, self.0, cur_proc, &mut ret, + access, inherit as libc::BOOL, + options) })); Ok(Handle::new(ret)) } diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 18c8add17a6d6..d76c24a6c11d0 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -117,12 +117,12 @@ fn fill_utf16_buf(mut f1: F1, f2: F2) -> io::Result // not an actual error. c::SetLastError(0); let k = match f1(buf.as_mut_ptr(), n as libc::DWORD) { - 0 if libc::GetLastError() == 0 => 0, + 0 if c::GetLastError() == 0 => 0, 0 => return Err(io::Error::last_os_error()), n => n, } as usize; - if k == n && libc::GetLastError() == - libc::ERROR_INSUFFICIENT_BUFFER as libc::DWORD { + if k == n && c::GetLastError() == + libc::ERROR_INSUFFICIENT_BUFFER as libc::DWORD { n *= 2; } else if k >= n { n = k; diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 5cfc20104245b..0b3963668c66a 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -30,13 +30,8 @@ use slice; use sys::c; use sys::handle::Handle; -use libc::funcs::extra::kernel32::{ - GetEnvironmentStringsW, - FreeEnvironmentStringsW -}; - pub fn errno() -> i32 { - unsafe { libc::GetLastError() as i32 } + unsafe { c::GetLastError() as i32 } } /// Gets a detailed string description for the given error number. @@ -124,13 +119,13 @@ impl Iterator for Env { impl Drop for Env { fn drop(&mut self) { - unsafe { FreeEnvironmentStringsW(self.base); } + unsafe { c::FreeEnvironmentStringsW(self.base); } } } pub fn env() -> Env { unsafe { - let ch = GetEnvironmentStringsW(); + let ch = c::GetEnvironmentStringsW(); if ch as usize == 0 { panic!("failure getting env string from OS: {}", io::Error::last_os_error()); @@ -231,13 +226,13 @@ impl StdError for JoinPathsError { pub fn current_exe() -> io::Result { super::fill_utf16_buf(|buf, sz| unsafe { - libc::GetModuleFileNameW(ptr::null_mut(), buf, sz) + c::GetModuleFileNameW(ptr::null_mut(), buf, sz) }, super::os2path) } pub fn getcwd() -> io::Result { super::fill_utf16_buf(|buf, sz| unsafe { - libc::GetCurrentDirectoryW(sz, buf) + c::GetCurrentDirectoryW(sz, buf) }, super::os2path) } @@ -247,7 +242,7 @@ pub fn chdir(p: &path::Path) -> io::Result<()> { p.push(0); unsafe { - match libc::SetCurrentDirectoryW(p.as_ptr()) != (0 as libc::BOOL) { + match c::SetCurrentDirectoryW(p.as_ptr()) != (0 as libc::BOOL) { true => Ok(()), false => Err(io::Error::last_os_error()), } @@ -257,7 +252,7 @@ pub fn chdir(p: &path::Path) -> io::Result<()> { pub fn getenv(k: &OsStr) -> Option { let k = super::to_utf16_os(k); super::fill_utf16_buf(|buf, sz| unsafe { - libc::GetEnvironmentVariableW(k.as_ptr(), buf, sz) + c::GetEnvironmentVariableW(k.as_ptr(), buf, sz) }, |buf| { OsStringExt::from_wide(buf) }).ok() @@ -268,7 +263,7 @@ pub fn setenv(k: &OsStr, v: &OsStr) { let v = super::to_utf16_os(v); unsafe { - if libc::SetEnvironmentVariableW(k.as_ptr(), v.as_ptr()) == 0 { + if c::SetEnvironmentVariableW(k.as_ptr(), v.as_ptr()) == 0 { panic!("failed to set env: {}", io::Error::last_os_error()); } } @@ -277,7 +272,7 @@ pub fn setenv(k: &OsStr, v: &OsStr) { pub fn unsetenv(n: &OsStr) { let v = super::to_utf16_os(n); unsafe { - if libc::SetEnvironmentVariableW(v.as_ptr(), ptr::null()) == 0 { + if c::SetEnvironmentVariableW(v.as_ptr(), ptr::null()) == 0 { panic!("failed to unset env: {}", io::Error::last_os_error()); } } @@ -328,7 +323,7 @@ pub fn args() -> Args { pub fn page_size() -> usize { unsafe { let mut info = mem::zeroed(); - libc::GetSystemInfo(&mut info); + c::GetSystemInfo(&mut info); return info.dwPageSize as usize; } } @@ -351,7 +346,7 @@ pub fn home_dir() -> Option { let _handle = Handle::new(token); super::fill_utf16_buf(|buf, mut sz| { match c::GetUserProfileDirectoryW(token, buf, &mut sz) { - 0 if libc::GetLastError() != 0 => 0, + 0 if c::GetLastError() != 0 => 0, 0 => sz, n => n as libc::DWORD, } diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 05073e60f5d26..266e01ee1426b 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -119,7 +119,7 @@ impl Process { err_handle: Stdio) -> io::Result { use libc::{TRUE, STARTF_USESTDHANDLES}; - use libc::{DWORD, STARTUPINFO, CreateProcessW}; + use libc::{DWORD, STARTUPINFO}; // To have the spawning semantics of unix/windows stay the same, we need // to read the *child's* PATH if one is provided. See #15149 for more @@ -173,12 +173,12 @@ impl Process { static CREATE_PROCESS_LOCK: StaticMutex = StaticMutex::new(); let _lock = CREATE_PROCESS_LOCK.lock(); - cvt(CreateProcessW(ptr::null(), - cmd_str.as_mut_ptr(), - ptr::null_mut(), - ptr::null_mut(), - TRUE, flags, envp, dirp, - &mut si, &mut pi)) + cvt(c::CreateProcessW(ptr::null(), + cmd_str.as_mut_ptr(), + ptr::null_mut(), + ptr::null_mut(), + TRUE, flags, envp, dirp, + &mut si, &mut pi)) }); // We close the thread handle because we don't care about keeping @@ -190,7 +190,7 @@ impl Process { } pub unsafe fn kill(&self) -> io::Result<()> { - try!(cvt(libc::TerminateProcess(self.handle.raw(), 1))); + try!(cvt(c::TerminateProcess(self.handle.raw(), 1))); Ok(()) } @@ -202,16 +202,15 @@ impl Process { pub fn wait(&self) -> io::Result { use libc::{STILL_ACTIVE, INFINITE, WAIT_OBJECT_0}; - use libc::{GetExitCodeProcess, WaitForSingleObject}; unsafe { loop { let mut status = 0; - try!(cvt(GetExitCodeProcess(self.handle.raw(), &mut status))); + try!(cvt(c::GetExitCodeProcess(self.handle.raw(), &mut status))); if status != STILL_ACTIVE { return Ok(ExitStatus(status as i32)); } - match WaitForSingleObject(self.handle.raw(), INFINITE) { + match c::WaitForSingleObject(self.handle.raw(), INFINITE) { WAIT_OBJECT_0 => {} _ => return Err(Error::last_os_error()), } diff --git a/src/libstd/sys/windows/stack_overflow.rs b/src/libstd/sys/windows/stack_overflow.rs index 79b7de4f341ac..a0fa0eb9ae334 100644 --- a/src/libstd/sys/windows/stack_overflow.rs +++ b/src/libstd/sys/windows/stack_overflow.rs @@ -14,6 +14,7 @@ use ptr; use mem; use libc; use libc::types::os::arch::extra::{LPVOID, DWORD, LONG, BOOL}; +use sys::c; use sys_common::stack; pub struct Handler { @@ -55,7 +56,7 @@ extern "system" fn vectored_handler(ExceptionInfo: *mut EXCEPTION_POINTERS) -> L pub unsafe fn init() { let mut info = mem::zeroed(); - libc::GetSystemInfo(&mut info); + c::GetSystemInfo(&mut info); PAGE_SIZE = info.dwPageSize as usize; if AddVectoredExceptionHandler(0, vectored_handler) == ptr::null_mut() { diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs index f5a70ccc90743..46ad4985e400c 100644 --- a/src/libstd/sys/windows/time.rs +++ b/src/libstd/sys/windows/time.rs @@ -11,6 +11,7 @@ use libc; use ops::Sub; use time::Duration; use sync::Once; +use sys::c; const NANOS_PER_SEC: u64 = 1_000_000_000; @@ -21,7 +22,7 @@ pub struct SteadyTime { impl SteadyTime { pub fn now() -> SteadyTime { let mut t = SteadyTime { t: 0 }; - unsafe { libc::QueryPerformanceCounter(&mut t.t); } + unsafe { c::QueryPerformanceCounter(&mut t.t); } t } } @@ -32,7 +33,7 @@ fn frequency() -> libc::LARGE_INTEGER { unsafe { ONCE.call_once(|| { - libc::QueryPerformanceFrequency(&mut FREQUENCY); + c::QueryPerformanceFrequency(&mut FREQUENCY); }); FREQUENCY }