diff options
Diffstat (limited to 'src/libstd/sys')
42 files changed, 1887 insertions, 2293 deletions
diff --git a/src/libstd/sys/common/backtrace.rs b/src/libstd/sys/common/backtrace.rs index e7bda9a7ba2..3c84783d215 100644 --- a/src/libstd/sys/common/backtrace.rs +++ b/src/libstd/sys/common/backtrace.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![cfg_attr(target_os = "nacl", allow(dead_code))] + use env; use io::prelude::*; use io; diff --git a/src/libstd/sys/common/libunwind.rs b/src/libstd/sys/common/libunwind.rs index da7ebbf4ed3..75bb11216e1 100644 --- a/src/libstd/sys/common/libunwind.rs +++ b/src/libstd/sys/common/libunwind.rs @@ -99,35 +99,23 @@ pub type _Unwind_Exception_Cleanup_Fn = extern "C" fn(unwind_code: _Unwind_Reason_Code, exception: *mut _Unwind_Exception); -#[cfg(any(all(target_os = "linux", not(target_env = "musl")), - target_os = "freebsd"))] -#[link(name = "gcc_s")] -extern {} - -#[cfg(all(target_os = "linux", target_env = "musl", not(test)))] -#[link(name = "unwind", kind = "static")] -extern {} - -#[cfg(any(target_os = "android", target_os = "openbsd"))] -#[link(name = "gcc")] -extern {} - -#[cfg(all(target_os = "netbsd", not(target_vendor = "rumprun")))] -#[link(name = "gcc")] -extern {} - -#[cfg(all(target_os = "netbsd", target_vendor = "rumprun"))] -#[link(name = "unwind")] -extern {} - -#[cfg(target_os = "dragonfly")] -#[link(name = "gcc_pic")] -extern {} - -#[cfg(target_os = "bitrig")] -#[link(name = "c++abi")] -extern {} - +#[cfg_attr(any(all(target_os = "linux", not(target_env = "musl")), + target_os = "freebsd"), + link(name = "gcc_s"))] +#[cfg_attr(all(target_os = "linux", target_env = "musl", not(test)), + link(name = "unwind", kind = "static"))] +#[cfg_attr(any(target_os = "android", target_os = "openbsd"), + link(name = "gcc"))] +#[cfg_attr(all(target_os = "netbsd", not(target_vendor = "rumprun")), + link(name = "gcc"))] +#[cfg_attr(all(target_os = "netbsd", target_vendor = "rumprun"), + link(name = "unwind"))] +#[cfg_attr(target_os = "dragonfly", + link(name = "gcc_pic"))] +#[cfg_attr(target_os = "bitrig", + link(name = "c++abi"))] +#[cfg_attr(all(target_os = "windows", target_env="gnu"), + link(name = "gcc_eh"))] extern "C" { // iOS on armv7 uses SjLj exceptions and requires to link // against corresponding routine (..._SjLj_...) @@ -142,6 +130,11 @@ extern "C" { -> _Unwind_Reason_Code; pub fn _Unwind_DeleteException(exception: *mut _Unwind_Exception); + + // remove cfg after new snapshot + #[cfg(not(all(stage0, target_os="windows", target_arch="x86_64")))] + #[unwind] + pub fn _Unwind_Resume(exception: *mut _Unwind_Exception) -> !; } // ... and now we just providing access to SjLj counterspart diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs index 37379596251..449cd9d8c97 100644 --- a/src/libstd/sys/common/net.rs +++ b/src/libstd/sys/common/net.rs @@ -13,13 +13,13 @@ use prelude::v1::*; use ffi::{CStr, CString}; use fmt; use io::{self, Error, ErrorKind}; -use libc::{self, c_int, c_char, c_void, socklen_t}; +use libc::{c_int, c_char, c_void}; use mem; use net::{SocketAddr, Shutdown, IpAddr}; use ptr; use str::from_utf8; -use sys::c; use sys::net::{cvt, cvt_r, cvt_gai, Socket, init, wrlen_t}; +use sys::net::netc as c; use sys_common::{AsInner, FromInner, IntoInner}; use time::Duration; @@ -31,8 +31,8 @@ pub fn setsockopt<T>(sock: &Socket, opt: c_int, val: c_int, payload: T) -> io::Result<()> { unsafe { let payload = &payload as *const T as *const c_void; - try!(cvt(libc::setsockopt(*sock.as_inner(), opt, val, payload, - mem::size_of::<T>() as socklen_t))); + try!(cvt(c::setsockopt(*sock.as_inner(), opt, val, payload, + mem::size_of::<T>() as c::socklen_t))); Ok(()) } } @@ -41,7 +41,7 @@ pub fn getsockopt<T: Copy>(sock: &Socket, opt: c_int, val: c_int) -> io::Result<T> { unsafe { let mut slot: T = mem::zeroed(); - let mut len = mem::size_of::<T>() as socklen_t; + let mut len = mem::size_of::<T>() as c::socklen_t; try!(cvt(c::getsockopt(*sock.as_inner(), opt, val, &mut slot as *mut _ as *mut _, &mut len))); @@ -51,29 +51,29 @@ pub fn getsockopt<T: Copy>(sock: &Socket, opt: c_int, } fn sockname<F>(f: F) -> io::Result<SocketAddr> - where F: FnOnce(*mut libc::sockaddr, *mut socklen_t) -> c_int + where F: FnOnce(*mut c::sockaddr, *mut c::socklen_t) -> c_int { unsafe { - let mut storage: libc::sockaddr_storage = mem::zeroed(); - let mut len = mem::size_of_val(&storage) as socklen_t; + let mut storage: c::sockaddr_storage = mem::zeroed(); + let mut len = mem::size_of_val(&storage) as c::socklen_t; try!(cvt(f(&mut storage as *mut _ as *mut _, &mut len))); sockaddr_to_addr(&storage, len as usize) } } -fn sockaddr_to_addr(storage: &libc::sockaddr_storage, +fn sockaddr_to_addr(storage: &c::sockaddr_storage, len: usize) -> io::Result<SocketAddr> { - match storage.ss_family as libc::c_int { - libc::AF_INET => { - assert!(len as usize >= mem::size_of::<libc::sockaddr_in>()); + match storage.ss_family as c_int { + c::AF_INET => { + assert!(len as usize >= mem::size_of::<c::sockaddr_in>()); Ok(SocketAddr::V4(FromInner::from_inner(unsafe { - *(storage as *const _ as *const libc::sockaddr_in) + *(storage as *const _ as *const c::sockaddr_in) }))) } - libc::AF_INET6 => { - assert!(len as usize >= mem::size_of::<libc::sockaddr_in6>()); + c::AF_INET6 => { + assert!(len as usize >= mem::size_of::<c::sockaddr_in6>()); Ok(SocketAddr::V6(FromInner::from_inner(unsafe { - *(storage as *const _ as *const libc::sockaddr_in6) + *(storage as *const _ as *const c::sockaddr_in6) }))) } _ => { @@ -86,16 +86,9 @@ fn sockaddr_to_addr(storage: &libc::sockaddr_storage, // get_host_addresses //////////////////////////////////////////////////////////////////////////////// -extern "system" { - fn getaddrinfo(node: *const c_char, service: *const c_char, - hints: *const libc::addrinfo, - res: *mut *mut libc::addrinfo) -> c_int; - fn freeaddrinfo(res: *mut libc::addrinfo); -} - pub struct LookupHost { - original: *mut libc::addrinfo, - cur: *mut libc::addrinfo, + original: *mut c::addrinfo, + cur: *mut c::addrinfo, } impl Iterator for LookupHost { @@ -105,7 +98,7 @@ impl Iterator for LookupHost { if self.cur.is_null() { return None } let ret = sockaddr_to_addr(mem::transmute((*self.cur).ai_addr), (*self.cur).ai_addrlen as usize); - self.cur = (*self.cur).ai_next as *mut libc::addrinfo; + self.cur = (*self.cur).ai_next as *mut c::addrinfo; Some(ret) } } @@ -116,7 +109,7 @@ unsafe impl Send for LookupHost {} impl Drop for LookupHost { fn drop(&mut self) { - unsafe { freeaddrinfo(self.original) } + unsafe { c::freeaddrinfo(self.original) } } } @@ -126,8 +119,8 @@ pub fn lookup_host(host: &str) -> io::Result<LookupHost> { let c_host = try!(CString::new(host)); let mut res = ptr::null_mut(); unsafe { - try!(cvt_gai(getaddrinfo(c_host.as_ptr(), ptr::null(), ptr::null(), - &mut res))); + try!(cvt_gai(c::getaddrinfo(c_host.as_ptr(), ptr::null(), ptr::null(), + &mut res))); Ok(LookupHost { original: res, cur: res }) } } @@ -136,26 +129,18 @@ pub fn lookup_host(host: &str) -> io::Result<LookupHost> { // lookup_addr //////////////////////////////////////////////////////////////////////////////// -extern "system" { - fn getnameinfo(sa: *const libc::sockaddr, salen: socklen_t, - host: *mut c_char, hostlen: libc::size_t, - serv: *mut c_char, servlen: libc::size_t, - flags: c_int) -> c_int; -} - -const NI_MAXHOST: usize = 1025; - pub fn lookup_addr(addr: &IpAddr) -> io::Result<String> { init(); let saddr = SocketAddr::new(*addr, 0); let (inner, len) = saddr.into_inner(); - let mut hostbuf = [0 as c_char; NI_MAXHOST]; + let mut hostbuf = [0 as c_char; c::NI_MAXHOST as usize]; let data = unsafe { - try!(cvt_gai(getnameinfo(inner, len, - hostbuf.as_mut_ptr(), NI_MAXHOST as libc::size_t, - ptr::null_mut(), 0, 0))); + try!(cvt_gai(c::getnameinfo(inner, len, + hostbuf.as_mut_ptr(), + c::NI_MAXHOST, + ptr::null_mut(), 0, 0))); CStr::from_ptr(hostbuf.as_ptr()) }; @@ -179,10 +164,10 @@ impl TcpStream { pub fn connect(addr: &SocketAddr) -> io::Result<TcpStream> { init(); - let sock = try!(Socket::new(addr, libc::SOCK_STREAM)); + let sock = try!(Socket::new(addr, c::SOCK_STREAM)); let (addrp, len) = addr.into_inner(); - try!(cvt_r(|| unsafe { libc::connect(*sock.as_inner(), addrp, len) })); + try!(cvt_r(|| unsafe { c::connect(*sock.as_inner(), addrp, len) })); Ok(TcpStream { inner: sock }) } @@ -191,19 +176,19 @@ impl TcpStream { pub fn into_socket(self) -> Socket { self.inner } pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> { - self.inner.set_timeout(dur, libc::SO_RCVTIMEO) + self.inner.set_timeout(dur, c::SO_RCVTIMEO) } pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> { - self.inner.set_timeout(dur, libc::SO_SNDTIMEO) + self.inner.set_timeout(dur, c::SO_SNDTIMEO) } pub fn read_timeout(&self) -> io::Result<Option<Duration>> { - self.inner.timeout(libc::SO_RCVTIMEO) + self.inner.timeout(c::SO_RCVTIMEO) } pub fn write_timeout(&self) -> io::Result<Option<Duration>> { - self.inner.timeout(libc::SO_SNDTIMEO) + self.inner.timeout(c::SO_SNDTIMEO) } pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { @@ -212,36 +197,28 @@ impl TcpStream { pub fn write(&self, buf: &[u8]) -> io::Result<usize> { let ret = try!(cvt(unsafe { - libc::send(*self.inner.as_inner(), - buf.as_ptr() as *const c_void, - buf.len() as wrlen_t, - 0) + c::send(*self.inner.as_inner(), + buf.as_ptr() as *const c_void, + buf.len() as wrlen_t, + 0) })); Ok(ret as usize) } pub fn peer_addr(&self) -> io::Result<SocketAddr> { sockname(|buf, len| unsafe { - libc::getpeername(*self.inner.as_inner(), buf, len) + c::getpeername(*self.inner.as_inner(), buf, len) }) } pub fn socket_addr(&self) -> io::Result<SocketAddr> { sockname(|buf, len| unsafe { - libc::getsockname(*self.inner.as_inner(), buf, len) + c::getsockname(*self.inner.as_inner(), buf, len) }) } pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { - use libc::consts::os::bsd44::SHUT_RDWR; - - let how = match how { - Shutdown::Write => libc::SHUT_WR, - Shutdown::Read => libc::SHUT_RD, - Shutdown::Both => SHUT_RDWR, - }; - try!(cvt(unsafe { libc::shutdown(*self.inner.as_inner(), how) })); - Ok(()) + self.inner.shutdown(how) } pub fn duplicate(&self) -> io::Result<TcpStream> { @@ -285,22 +262,22 @@ impl TcpListener { pub fn bind(addr: &SocketAddr) -> io::Result<TcpListener> { init(); - let sock = try!(Socket::new(addr, libc::SOCK_STREAM)); + let sock = try!(Socket::new(addr, c::SOCK_STREAM)); // On platforms with Berkeley-derived sockets, this allows // to quickly rebind a socket, without needing to wait for // the OS to clean up the previous one. if !cfg!(windows) { - try!(setsockopt(&sock, libc::SOL_SOCKET, libc::SO_REUSEADDR, + try!(setsockopt(&sock, c::SOL_SOCKET, c::SO_REUSEADDR, 1 as c_int)); } // Bind our new socket let (addrp, len) = addr.into_inner(); - try!(cvt(unsafe { libc::bind(*sock.as_inner(), addrp, len) })); + try!(cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })); // Start listening - try!(cvt(unsafe { libc::listen(*sock.as_inner(), 128) })); + try!(cvt(unsafe { c::listen(*sock.as_inner(), 128) })); Ok(TcpListener { inner: sock }) } @@ -310,13 +287,13 @@ impl TcpListener { pub fn socket_addr(&self) -> io::Result<SocketAddr> { sockname(|buf, len| unsafe { - libc::getsockname(*self.inner.as_inner(), buf, len) + c::getsockname(*self.inner.as_inner(), buf, len) }) } pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> { - let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() }; - let mut len = mem::size_of_val(&storage) as socklen_t; + let mut storage: c::sockaddr_storage = unsafe { mem::zeroed() }; + let mut len = mem::size_of_val(&storage) as c::socklen_t; let sock = try!(self.inner.accept(&mut storage as *mut _ as *mut _, &mut len)); let addr = try!(sockaddr_to_addr(&storage, len as usize)); @@ -360,9 +337,9 @@ impl UdpSocket { pub fn bind(addr: &SocketAddr) -> io::Result<UdpSocket> { init(); - let sock = try!(Socket::new(addr, libc::SOCK_DGRAM)); + let sock = try!(Socket::new(addr, c::SOCK_DGRAM)); let (addrp, len) = addr.into_inner(); - try!(cvt(unsafe { libc::bind(*sock.as_inner(), addrp, len) })); + try!(cvt(unsafe { c::bind(*sock.as_inner(), addrp, len) })); Ok(UdpSocket { inner: sock }) } @@ -372,19 +349,19 @@ impl UdpSocket { pub fn socket_addr(&self) -> io::Result<SocketAddr> { sockname(|buf, len| unsafe { - libc::getsockname(*self.inner.as_inner(), buf, len) + c::getsockname(*self.inner.as_inner(), buf, len) }) } pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> { - let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() }; - let mut addrlen = mem::size_of_val(&storage) as socklen_t; + let mut storage: c::sockaddr_storage = unsafe { mem::zeroed() }; + let mut addrlen = mem::size_of_val(&storage) as c::socklen_t; let n = try!(cvt(unsafe { - libc::recvfrom(*self.inner.as_inner(), - buf.as_mut_ptr() as *mut c_void, - buf.len() as wrlen_t, 0, - &mut storage as *mut _ as *mut _, &mut addrlen) + c::recvfrom(*self.inner.as_inner(), + buf.as_mut_ptr() as *mut c_void, + buf.len() as wrlen_t, 0, + &mut storage as *mut _ as *mut _, &mut addrlen) })); Ok((n as usize, try!(sockaddr_to_addr(&storage, addrlen as usize)))) } @@ -392,9 +369,9 @@ impl UdpSocket { pub fn send_to(&self, buf: &[u8], dst: &SocketAddr) -> io::Result<usize> { let (dstp, dstlen) = dst.into_inner(); let ret = try!(cvt(unsafe { - libc::sendto(*self.inner.as_inner(), - buf.as_ptr() as *const c_void, buf.len() as wrlen_t, - 0, dstp, dstlen) + c::sendto(*self.inner.as_inner(), + buf.as_ptr() as *const c_void, buf.len() as wrlen_t, + 0, dstp, dstlen) })); Ok(ret as usize) } @@ -404,19 +381,19 @@ impl UdpSocket { } pub fn set_read_timeout(&self, dur: Option<Duration>) -> io::Result<()> { - self.inner.set_timeout(dur, libc::SO_RCVTIMEO) + self.inner.set_timeout(dur, c::SO_RCVTIMEO) } pub fn set_write_timeout(&self, dur: Option<Duration>) -> io::Result<()> { - self.inner.set_timeout(dur, libc::SO_SNDTIMEO) + self.inner.set_timeout(dur, c::SO_SNDTIMEO) } pub fn read_timeout(&self) -> io::Result<Option<Duration>> { - self.inner.timeout(libc::SO_RCVTIMEO) + self.inner.timeout(c::SO_RCVTIMEO) } pub fn write_timeout(&self) -> io::Result<Option<Duration>> { - self.inner.timeout(libc::SO_SNDTIMEO) + self.inner.timeout(c::SO_SNDTIMEO) } } diff --git a/src/libstd/sys/common/unwind/gcc.rs b/src/libstd/sys/common/unwind/gcc.rs index 361cef08c11..0a598b55951 100644 --- a/src/libstd/sys/common/unwind/gcc.rs +++ b/src/libstd/sys/common/unwind/gcc.rs @@ -231,3 +231,36 @@ pub mod eabi { } } } + +// See docs in the `unwind` module. +#[cfg(all(target_os="windows", target_arch = "x86", target_env="gnu", not(test)))] +#[lang = "eh_unwind_resume"] +#[unwind] +unsafe extern fn rust_eh_unwind_resume(panic_ctx: *mut u8) -> ! { + uw::_Unwind_Resume(panic_ctx as *mut uw::_Unwind_Exception); +} + +#[cfg(all(target_os="windows", target_arch = "x86", target_env="gnu"))] +pub mod eh_frame_registry { + // The implementation of stack unwinding is (for now) deferred to libgcc_eh, however Rust + // crates use these Rust-specific entry points to avoid potential clashes with GCC runtime. + // See also: rtbegin.rs, `unwind` module. + + #[link(name = "gcc_eh")] + extern { + fn __register_frame_info(eh_frame_begin: *const u8, object: *mut u8); + fn __deregister_frame_info(eh_frame_begin: *const u8, object: *mut u8); + } + #[cfg(not(test))] + #[no_mangle] + pub unsafe extern fn rust_eh_register_frames(eh_frame_begin: *const u8, + object: *mut u8) { + __register_frame_info(eh_frame_begin, object); + } + #[cfg(not(test))] + #[no_mangle] + pub unsafe extern fn rust_eh_unregister_frames(eh_frame_begin: *const u8, + object: *mut u8) { + __deregister_frame_info(eh_frame_begin, object); + } +} diff --git a/src/libstd/sys/common/unwind/mod.rs b/src/libstd/sys/common/unwind/mod.rs index d87ab56d4e1..e455d163ed9 100644 --- a/src/libstd/sys/common/unwind/mod.rs +++ b/src/libstd/sys/common/unwind/mod.rs @@ -34,28 +34,35 @@ //! object being thrown, and to decide whether it should be caught at that stack //! frame. Once the handler frame has been identified, cleanup phase begins. //! -//! In the cleanup phase, personality routines invoke cleanup code associated -//! with their stack frames (i.e. destructors). Once stack has been unwound down -//! to the handler frame level, unwinding stops and the last personality routine -//! transfers control to its catch block. +//! In the cleanup phase, the unwinder invokes each personality routine again. +//! This time it decides which (if any) cleanup code needs to be run for +//! the current stack frame. If so, the control is transferred to a special branch +//! in the function body, the "landing pad", which invokes destructors, frees memory, +//! etc. At the end of the landing pad, control is transferred back to the unwinder +//! and unwinding resumes. //! -//! ## Frame unwind info registration +//! Once stack has been unwound down to the handler frame level, unwinding stops +//! and the last personality routine transfers control to the catch block. //! -//! Each module has its own frame unwind info section (usually ".eh_frame"), and -//! unwinder needs to know about all of them in order for unwinding to be able to -//! cross module boundaries. +//! ## `eh_personality` and `eh_unwind_resume` //! -//! On some platforms, like Linux, this is achieved by dynamically enumerating -//! currently loaded modules via the dl_iterate_phdr() API and finding all -//! .eh_frame sections. +//! These language items are used by the compiler when generating unwind info. +//! The first one is the personality routine described above. The second one +//! allows compilation target to customize the process of resuming unwind at the +//! end of the landing pads. `eh_unwind_resume` is used only if `custom_unwind_resume` +//! flag in the target options is set. //! -//! Others, like Windows, require modules to actively register their unwind info -//! sections by calling __register_frame_info() API at startup. In the latter -//! case it is essential that there is only one copy of the unwinder runtime in -//! the process. This is usually achieved by linking to the dynamic version of -//! the unwind runtime. +//! ## Frame unwind info registration //! -//! Currently Rust uses unwind runtime provided by libgcc. +//! Each module's image contains a frame unwind info section (usually ".eh_frame"). +//! When a module is loaded/unloaded into the process, the unwinder must be informed +//! about the location of this section in memory. The methods of achieving that vary +//! by the platform. +//! On some (e.g. Linux), the unwinder can discover unwind info sections on its own +//! (by dynamically enumerating currently loaded modules via the dl_iterate_phdr() API +//! and finding their ".eh_frame" sections); +//! Others, like Windows, require modules to actively register their unwind info +//! sections via unwinder API (see `rust_eh_register_frames`/`rust_eh_unregister_frames`). #![allow(dead_code)] #![allow(unused_imports)] diff --git a/src/libstd/sys/common/unwind/seh.rs b/src/libstd/sys/common/unwind/seh.rs index a89e8b499ac..7296194efda 100644 --- a/src/libstd/sys/common/unwind/seh.rs +++ b/src/libstd/sys/common/unwind/seh.rs @@ -52,45 +52,14 @@ use prelude::v1::*; use any::Any; -use libc::{c_ulong, DWORD, c_void}; use ptr; use sys_common::thread_local::StaticKey; +use sys::c; -// 0x R U S T -const RUST_PANIC: DWORD = 0x52555354; +// 0x R U S T +const RUST_PANIC: c::DWORD = 0x52555354; static PANIC_DATA: StaticKey = StaticKey::new(None); -// This function is provided by kernel32.dll -extern "system" { - #[unwind] - fn RaiseException(dwExceptionCode: DWORD, - dwExceptionFlags: DWORD, - nNumberOfArguments: DWORD, - lpArguments: *const c_ulong); -} - -#[repr(C)] -pub struct EXCEPTION_POINTERS { - ExceptionRecord: *mut EXCEPTION_RECORD, - ContextRecord: *mut CONTEXT, -} - -enum CONTEXT {} - -#[repr(C)] -struct EXCEPTION_RECORD { - ExceptionCode: DWORD, - ExceptionFlags: DWORD, - ExceptionRecord: *mut _EXCEPTION_RECORD, - ExceptionAddress: *mut c_void, - NumberParameters: DWORD, - ExceptionInformation: [*mut c_ulong; EXCEPTION_MAXIMUM_PARAMETERS], -} - -enum _EXCEPTION_RECORD {} - -const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15; - pub unsafe fn panic(data: Box<Any + Send + 'static>) -> ! { // See module docs above for an explanation of why `data` is stored in a // thread local instead of being passed as an argument to the @@ -100,14 +69,14 @@ pub unsafe fn panic(data: Box<Any + Send + 'static>) -> ! { rtassert!(PANIC_DATA.get().is_null()); PANIC_DATA.set(Box::into_raw(exception) as *mut u8); - RaiseException(RUST_PANIC, 0, 0, ptr::null()); + c::RaiseException(RUST_PANIC, 0, 0, ptr::null()); rtabort!("could not unwind stack"); } pub unsafe fn cleanup(ptr: *mut u8) -> Box<Any + Send + 'static> { // The `ptr` here actually corresponds to the code of the exception, and our // real data is stored in our thread local. - rtassert!(ptr as DWORD == RUST_PANIC); + rtassert!(ptr as c::DWORD == RUST_PANIC); let data = PANIC_DATA.get() as *mut Box<Any + Send + 'static>; PANIC_DATA.set(ptr::null_mut()); @@ -139,7 +108,7 @@ fn rust_eh_personality() { #[lang = "msvc_try_filter"] #[linkage = "external"] #[allow(private_no_mangle_fns)] -extern fn __rust_try_filter(eh_ptrs: *mut EXCEPTION_POINTERS, +extern fn __rust_try_filter(eh_ptrs: *mut c::EXCEPTION_POINTERS, _rbp: *mut u8) -> i32 { unsafe { ((*(*eh_ptrs).ExceptionRecord).ExceptionCode == RUST_PANIC) as i32 diff --git a/src/libstd/sys/common/unwind/seh64_gnu.rs b/src/libstd/sys/common/unwind/seh64_gnu.rs index 9478678fda9..26c2cee9222 100644 --- a/src/libstd/sys/common/unwind/seh64_gnu.rs +++ b/src/libstd/sys/common/unwind/seh64_gnu.rs @@ -17,12 +17,10 @@ use prelude::v1::*; use any::Any; -use self::EXCEPTION_DISPOSITION::*; use sys_common::dwarf::eh; use core::mem; use core::ptr; -use libc::{c_void, c_ulonglong, DWORD, LPVOID}; -type ULONG_PTR = c_ulonglong; +use sys::c; // Define our exception codes: // according to http://msdn.microsoft.com/en-us/library/het71c37(v=VS.80).aspx, @@ -32,80 +30,10 @@ type ULONG_PTR = c_ulonglong; // we define bits: // [24:27] = type // [0:23] = magic -const ETYPE: DWORD = 0b1110_u32 << 28; -const MAGIC: DWORD = 0x525354; // "RST" +const ETYPE: c::DWORD = 0b1110_u32 << 28; +const MAGIC: c::DWORD = 0x525354; // "RST" -const RUST_PANIC: DWORD = ETYPE | (1 << 24) | MAGIC; - -const EXCEPTION_NONCONTINUABLE: DWORD = 0x1; // Noncontinuable exception -const EXCEPTION_UNWINDING: DWORD = 0x2; // Unwind is in progress -const EXCEPTION_EXIT_UNWIND: DWORD = 0x4; // Exit unwind is in progress -const EXCEPTION_STACK_INVALID: DWORD = 0x8; // Stack out of limits or unaligned -const EXCEPTION_NESTED_CALL: DWORD = 0x10; // Nested exception handler call -const EXCEPTION_TARGET_UNWIND: DWORD = 0x20; // Target unwind in progress -const EXCEPTION_COLLIDED_UNWIND: DWORD = 0x40; // Collided exception handler call -const EXCEPTION_UNWIND: DWORD = EXCEPTION_UNWINDING | - EXCEPTION_EXIT_UNWIND | - EXCEPTION_TARGET_UNWIND | - EXCEPTION_COLLIDED_UNWIND; - -#[repr(C)] -pub struct EXCEPTION_RECORD { - ExceptionCode: DWORD, - ExceptionFlags: DWORD, - ExceptionRecord: *const EXCEPTION_RECORD, - ExceptionAddress: LPVOID, - NumberParameters: DWORD, - ExceptionInformation: [ULONG_PTR; 15], -} - -pub enum CONTEXT {} -pub enum UNWIND_HISTORY_TABLE {} - -#[repr(C)] -pub struct RUNTIME_FUNCTION { - BeginAddress: DWORD, - EndAddress: DWORD, - UnwindData: DWORD, -} - -#[repr(C)] -pub struct DISPATCHER_CONTEXT { - ControlPc: LPVOID, - ImageBase: LPVOID, - FunctionEntry: *const RUNTIME_FUNCTION, - EstablisherFrame: LPVOID, - TargetIp: LPVOID, - ContextRecord: *const CONTEXT, - LanguageHandler: LPVOID, - HandlerData: *const u8, - HistoryTable: *const UNWIND_HISTORY_TABLE, -} - -#[repr(C)] -#[derive(Copy, Clone)] -pub enum EXCEPTION_DISPOSITION { - ExceptionContinueExecution, - ExceptionContinueSearch, - ExceptionNestedException, - ExceptionCollidedUnwind -} - -// From kernel32.dll -extern "system" { - #[unwind] - fn RaiseException(dwExceptionCode: DWORD, - dwExceptionFlags: DWORD, - nNumberOfArguments: DWORD, - lpArguments: *const ULONG_PTR); - - fn RtlUnwindEx(TargetFrame: LPVOID, - TargetIp: LPVOID, - ExceptionRecord: *const EXCEPTION_RECORD, - ReturnValue: LPVOID, - OriginalContext: *const CONTEXT, - HistoryTable: *const UNWIND_HISTORY_TABLE); -} +const RUST_PANIC: c::DWORD = ETYPE | (1 << 24) | MAGIC; #[repr(C)] struct PanicData { @@ -114,11 +42,11 @@ struct PanicData { pub unsafe fn panic(data: Box<Any + Send + 'static>) -> ! { let panic_ctx = Box::new(PanicData { data: data }); - let params = [Box::into_raw(panic_ctx) as ULONG_PTR]; - RaiseException(RUST_PANIC, - EXCEPTION_NONCONTINUABLE, - params.len() as DWORD, - ¶ms as *const ULONG_PTR); + let params = [Box::into_raw(panic_ctx) as c::ULONG_PTR]; + c::RaiseException(RUST_PANIC, + c::EXCEPTION_NONCONTINUABLE, + params.len() as c::DWORD, + ¶ms as *const c::ULONG_PTR); rtabort!("could not unwind stack"); } @@ -152,11 +80,11 @@ pub unsafe fn cleanup(ptr: *mut u8) -> Box<Any + Send + 'static> { #[lang = "eh_personality_catch"] #[cfg(not(test))] unsafe extern fn rust_eh_personality_catch( - exceptionRecord: *mut EXCEPTION_RECORD, - establisherFrame: LPVOID, - contextRecord: *mut CONTEXT, - dispatcherContext: *mut DISPATCHER_CONTEXT -) -> EXCEPTION_DISPOSITION + exceptionRecord: *mut c::EXCEPTION_RECORD, + establisherFrame: c::LPVOID, + contextRecord: *mut c::CONTEXT, + dispatcherContext: *mut c::DISPATCHER_CONTEXT +) -> c::EXCEPTION_DISPOSITION { rust_eh_personality(exceptionRecord, establisherFrame, contextRecord, dispatcherContext) @@ -165,51 +93,44 @@ unsafe extern fn rust_eh_personality_catch( #[lang = "eh_personality"] #[cfg(not(test))] unsafe extern fn rust_eh_personality( - exceptionRecord: *mut EXCEPTION_RECORD, - establisherFrame: LPVOID, - contextRecord: *mut CONTEXT, - dispatcherContext: *mut DISPATCHER_CONTEXT -) -> EXCEPTION_DISPOSITION + exceptionRecord: *mut c::EXCEPTION_RECORD, + establisherFrame: c::LPVOID, + contextRecord: *mut c::CONTEXT, + dispatcherContext: *mut c::DISPATCHER_CONTEXT +) -> c::EXCEPTION_DISPOSITION { let er = &*exceptionRecord; let dc = &*dispatcherContext; - if er.ExceptionFlags & EXCEPTION_UNWIND == 0 { // we are in the dispatch phase + if er.ExceptionFlags & c::EXCEPTION_UNWIND == 0 { // we are in the dispatch phase if er.ExceptionCode == RUST_PANIC { if let Some(lpad) = find_landing_pad(dc) { - RtlUnwindEx(establisherFrame, - lpad as LPVOID, - exceptionRecord, - er.ExceptionInformation[0] as LPVOID, // pointer to PanicData - contextRecord, - dc.HistoryTable); + c::RtlUnwindEx(establisherFrame, + lpad as c::LPVOID, + exceptionRecord, + er.ExceptionInformation[0] as c::LPVOID, // pointer to PanicData + contextRecord, + dc.HistoryTable); rtabort!("could not unwind"); } } } - ExceptionContinueSearch + c::ExceptionContinueSearch } -// The `resume` instruction, found at the end of the landing pads, and whose job -// is to resume stack unwinding, is typically lowered by LLVM into a call to -// `_Unwind_Resume` routine. To avoid confusion with the same symbol exported -// from libgcc, we redirect it to `rust_eh_unwind_resume`. -// Since resolution of this symbol is done by the linker, `rust_eh_unwind_resume` -// must be marked `pub` + `#[no_mangle]`. (Can we make it a lang item?) - -#[lang = "eh_unwind_resume"] #[cfg(not(test))] +#[lang = "eh_unwind_resume"] #[unwind] -unsafe extern fn rust_eh_unwind_resume(panic_ctx: LPVOID) { - let params = [panic_ctx as ULONG_PTR]; - RaiseException(RUST_PANIC, - EXCEPTION_NONCONTINUABLE, - params.len() as DWORD, - ¶ms as *const ULONG_PTR); +unsafe extern fn rust_eh_unwind_resume(panic_ctx: c::LPVOID) -> ! { + let params = [panic_ctx as c::ULONG_PTR]; + c::RaiseException(RUST_PANIC, + c::EXCEPTION_NONCONTINUABLE, + params.len() as c::DWORD, + ¶ms as *const c::ULONG_PTR); rtabort!("could not resume unwind"); } -unsafe fn find_landing_pad(dc: &DISPATCHER_CONTEXT) -> Option<usize> { +unsafe fn find_landing_pad(dc: &c::DISPATCHER_CONTEXT) -> Option<usize> { let eh_ctx = eh::EHContext { ip: dc.ControlPc as usize, func_start: dc.ImageBase as usize + (*dc.FunctionEntry).BeginAddress as usize, diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs deleted file mode 100644 index 051b3d8897d..00000000000 --- a/src/libstd/sys/unix/c.rs +++ /dev/null @@ -1,410 +0,0 @@ -// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! C definitions used by std::sys that don't belong in liblibc - -// These are definitions sufficient for the users in this directory. -// This is not a general-purpose binding to this functionality, and in -// some cases (notably the definition of siginfo_t), we intentionally -// have incomplete bindings so that we don't need to fight with unions. -// -// Note that these types need to match the definitions from the platform -// libc (currently glibc on Linux), not the kernel definitions / the -// syscall interface. This has a few weirdnesses, like glibc's sigset_t -// being 1024 bits on all platforms. If you're adding a new GNU/Linux -// port, check glibc's sysdeps/unix/sysv/linux, not the kernel headers. - -#![allow(dead_code)] -#![allow(non_camel_case_types)] - -pub use self::signal_os::{sigaction, siginfo, sigset_t, sigaltstack}; -pub use self::signal_os::{SA_ONSTACK, SA_SIGINFO, SIGBUS, SIGSTKSZ, SIG_SETMASK}; - -use libc; - -#[cfg(any(target_os = "macos", - target_os = "ios", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "netbsd", - target_os = "openbsd"))] -pub const FIOCLEX: libc::c_ulong = 0x20006601; - -#[cfg(any(all(target_os = "linux", - any(target_arch = "x86", - target_arch = "x86_64", - target_arch = "arm", - target_arch = "aarch64")), - target_os = "android"))] -pub const FIOCLEX: libc::c_ulong = 0x5451; - -#[cfg(all(target_os = "linux", - any(target_arch = "mips", - target_arch = "mipsel", - target_arch = "powerpc")))] -pub const FIOCLEX: libc::c_ulong = 0x6601; - -pub const WNOHANG: libc::c_int = 1; - -#[cfg(target_os = "linux")] -pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 70; -#[cfg(any(target_os = "macos", - target_os = "freebsd", - target_os = "dragonfly"))] -pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 71; -#[cfg(any(target_os = "bitrig", - target_os = "openbsd"))] -pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 101; -#[cfg(target_os = "netbsd")] -pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 48; -#[cfg(target_os = "android")] -pub const _SC_GETPW_R_SIZE_MAX: libc::c_int = 0x0048; - -#[repr(C)] -#[cfg(target_os = "linux")] -pub struct passwd { - pub pw_name: *mut libc::c_char, - pub pw_passwd: *mut libc::c_char, - pub pw_uid: libc::uid_t, - pub pw_gid: libc::gid_t, - pub pw_gecos: *mut libc::c_char, - pub pw_dir: *mut libc::c_char, - pub pw_shell: *mut libc::c_char, -} - -#[repr(C)] -#[cfg(any(target_os = "macos", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "netbsd", - target_os = "openbsd"))] -pub struct passwd { - pub pw_name: *mut libc::c_char, - pub pw_passwd: *mut libc::c_char, - pub pw_uid: libc::uid_t, - pub pw_gid: libc::gid_t, - pub pw_change: libc::time_t, - pub pw_class: *mut libc::c_char, - pub pw_gecos: *mut libc::c_char, - pub pw_dir: *mut libc::c_char, - pub pw_shell: *mut libc::c_char, - pub pw_expire: libc::time_t, -} - -#[repr(C)] -#[cfg(target_os = "android")] -pub struct passwd { - pub pw_name: *mut libc::c_char, - pub pw_passwd: *mut libc::c_char, - pub pw_uid: libc::uid_t, - pub pw_gid: libc::gid_t, - pub pw_dir: *mut libc::c_char, - pub pw_shell: *mut libc::c_char, -} - -// This is really a function pointer (or a union of multiple function -// pointers), except for constants like SIG_DFL. -pub type sighandler_t = *mut libc::c_void; - -pub const SIG_DFL: sighandler_t = 0 as sighandler_t; -pub const SIG_ERR: sighandler_t = !0 as sighandler_t; - -extern { - pub fn getsockopt(sockfd: libc::c_int, - level: libc::c_int, - optname: libc::c_int, - optval: *mut libc::c_void, - optlen: *mut libc::socklen_t) -> libc::c_int; - pub fn ioctl(fd: libc::c_int, req: libc::c_ulong, ...) -> libc::c_int; - - - pub fn waitpid(pid: libc::pid_t, status: *mut libc::c_int, - options: libc::c_int) -> libc::pid_t; - - pub fn raise(signum: libc::c_int) -> libc::c_int; - - #[cfg_attr(target_os = "netbsd", link_name = "__sigaction14")] - pub fn sigaction(signum: libc::c_int, - act: *const sigaction, - oldact: *mut sigaction) -> libc::c_int; - - #[cfg_attr(target_os = "netbsd", link_name = "__sigaltstack14")] - pub fn sigaltstack(ss: *const sigaltstack, - oss: *mut sigaltstack) -> libc::c_int; - - #[cfg(not(target_os = "android"))] - #[cfg_attr(target_os = "netbsd", link_name = "__sigemptyset14")] - pub fn sigemptyset(set: *mut sigset_t) -> libc::c_int; - - pub fn pthread_sigmask(how: libc::c_int, set: *const sigset_t, - oldset: *mut sigset_t) -> libc::c_int; - - #[cfg(not(target_os = "ios"))] - #[cfg_attr(target_os = "netbsd", link_name = "__getpwuid_r50")] - pub fn getpwuid_r(uid: libc::uid_t, - pwd: *mut passwd, - buf: *mut libc::c_char, - buflen: libc::size_t, - result: *mut *mut passwd) -> libc::c_int; - - #[cfg_attr(target_os = "netbsd", link_name = "__utimes50")] - pub fn utimes(filename: *const libc::c_char, - times: *const libc::timeval) -> libc::c_int; - pub fn gai_strerror(errcode: libc::c_int) -> *const libc::c_char; - pub fn setgroups(ngroups: libc::c_int, - ptr: *const libc::c_void) -> libc::c_int; - pub fn realpath(pathname: *const libc::c_char, resolved: *mut libc::c_char) - -> *mut libc::c_char; -} - -// Ugh. This is only available as an inline until Android API 21. -#[cfg(target_os = "android")] -pub unsafe fn sigemptyset(set: *mut sigset_t) -> libc::c_int { - use intrinsics; - intrinsics::write_bytes(set, 0, 1); - return 0; -} - -#[cfg(any(target_os = "linux", - target_os = "android"))] -mod signal_os { - pub use self::arch::{SA_ONSTACK, SA_SIGINFO, SIGBUS, SIG_SETMASK, - sigaction, sigaltstack}; - use libc; - - #[cfg(any(target_arch = "x86", - target_arch = "x86_64", - target_arch = "arm", - target_arch = "mips", - target_arch = "mipsel"))] - pub const SIGSTKSZ: libc::size_t = 8192; - - // This is smaller on musl and Android, but no harm in being generous. - #[cfg(any(target_arch = "aarch64", - target_arch = "powerpc"))] - pub const SIGSTKSZ: libc::size_t = 16384; - - // This definition is intentionally a subset of the C structure: the - // fields after si_code are actually a giant union. We're only - // interested in si_addr for this module, though. - #[repr(C)] - pub struct siginfo { - _signo: libc::c_int, - _errno: libc::c_int, - _code: libc::c_int, - // This structure will need extra padding here for MIPS64. - pub si_addr: *mut libc::c_void - } - - #[cfg(all(target_os = "linux", target_pointer_width = "32"))] - #[repr(C)] - pub struct sigset_t { - __val: [libc::c_ulong; 32], - } - - #[cfg(all(target_os = "linux", target_pointer_width = "64"))] - #[repr(C)] - pub struct sigset_t { - __val: [libc::c_ulong; 16], - } - - // Android for MIPS has a 128-bit sigset_t, but we don't currently - // support it. Android for AArch64 technically has a structure of a - // single ulong. - #[cfg(target_os = "android")] - pub type sigset_t = libc::c_ulong; - - #[cfg(any(target_arch = "x86", - target_arch = "x86_64", - target_arch = "powerpc", - target_arch = "arm", - target_arch = "aarch64"))] - mod arch { - use libc; - use super::super::sighandler_t; - use super::sigset_t; - - pub const SA_ONSTACK: libc::c_ulong = 0x08000000; - pub const SA_SIGINFO: libc::c_ulong = 0x00000004; - - pub const SIGBUS: libc::c_int = 7; - - pub const SIG_SETMASK: libc::c_int = 2; - - #[cfg(target_os = "linux")] - #[repr(C)] - pub struct sigaction { - pub sa_sigaction: sighandler_t, - pub sa_mask: sigset_t, - pub sa_flags: libc::c_ulong, - _restorer: *mut libc::c_void, - } - - #[cfg(all(target_os = "android", target_pointer_width = "32"))] - #[repr(C)] - pub struct sigaction { - pub sa_sigaction: sighandler_t, - pub sa_flags: libc::c_ulong, - _restorer: *mut libc::c_void, - pub sa_mask: sigset_t, - } - - #[cfg(all(target_os = "android", target_pointer_width = "64"))] - #[repr(C)] - pub struct sigaction { - pub sa_flags: libc::c_uint, - pub sa_sigaction: sighandler_t, - pub sa_mask: sigset_t, - _restorer: *mut libc::c_void, - } - - #[repr(C)] - pub struct sigaltstack { - pub ss_sp: *mut libc::c_void, - pub ss_flags: libc::c_int, - pub ss_size: libc::size_t - } - } - - #[cfg(any(target_arch = "mips", - target_arch = "mipsel"))] - mod arch { - use libc; - use super::super::sighandler_t; - use super::sigset_t; - - pub const SA_ONSTACK: libc::c_ulong = 0x08000000; - pub const SA_SIGINFO: libc::c_ulong = 0x00000008; - - pub const SIGBUS: libc::c_int = 10; - - pub const SIG_SETMASK: libc::c_int = 3; - - #[cfg(all(target_os = "linux", not(target_env = "musl")))] - #[repr(C)] - pub struct sigaction { - pub sa_flags: libc::c_uint, - pub sa_sigaction: sighandler_t, - pub sa_mask: sigset_t, - _restorer: *mut libc::c_void, - _resv: [libc::c_int; 1], - } - - #[cfg(target_env = "musl")] - #[repr(C)] - pub struct sigaction { - pub sa_sigaction: sighandler_t, - pub sa_mask: sigset_t, - pub sa_flags: libc::c_ulong, - _restorer: *mut libc::c_void, - } - - #[cfg(target_os = "android")] - #[repr(C)] - pub struct sigaction { - pub sa_flags: libc::c_uint, - pub sa_sigaction: sighandler_t, - pub sa_mask: sigset_t, - } - - #[repr(C)] - pub struct sigaltstack { - pub ss_sp: *mut libc::c_void, - pub ss_size: libc::size_t, - pub ss_flags: libc::c_int, - } - } -} - -#[cfg(any(target_os = "macos", - target_os = "ios", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "netbsd", - target_os = "openbsd"))] -mod signal_os { - use libc; - use super::sighandler_t; - - pub const SA_ONSTACK: libc::c_int = 0x0001; - pub const SA_SIGINFO: libc::c_int = 0x0040; - - pub const SIGBUS: libc::c_int = 10; - - #[cfg(any(target_os = "macos", target_os = "ios"))] - pub const SIGSTKSZ: libc::size_t = 131072; - // FreeBSD's is actually arch-dependent, but never more than 40960. - // No harm in being generous. - #[cfg(not(any(target_os = "macos", target_os = "ios")))] - pub const SIGSTKSZ: libc::size_t = 40960; - - pub const SIG_SETMASK: libc::c_int = 3; - - #[cfg(any(target_os = "macos", - target_os = "ios"))] - pub type sigset_t = u32; - #[cfg(any(target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd"))] - #[repr(C)] - pub struct sigset_t { - bits: [u32; 4], - } - #[cfg(any(target_os = "bitrig", target_os = "openbsd"))] - pub type sigset_t = libc::c_uint; - - // This structure has more fields, but we're not all that interested in - // them. - #[cfg(any(target_os = "macos", target_os = "ios", - target_os = "freebsd", target_os = "dragonfly"))] - #[repr(C)] - pub struct siginfo { - pub _signo: libc::c_int, - pub _errno: libc::c_int, - pub _code: libc::c_int, - pub _pid: libc::pid_t, - pub _uid: libc::uid_t, - pub _status: libc::c_int, - pub si_addr: *mut libc::c_void - } - #[cfg(any(target_os = "bitrig", target_os = "netbsd", target_os = "openbsd"))] - #[repr(C)] - pub struct siginfo { - pub si_signo: libc::c_int, - pub si_code: libc::c_int, - pub si_errno: libc::c_int, - pub si_addr: *mut libc::c_void - } - - #[cfg(any(target_os = "macos", target_os = "ios", - target_os = "bitrig", target_os = "netbsd", target_os = "openbsd"))] - #[repr(C)] - pub struct sigaction { - pub sa_sigaction: sighandler_t, - pub sa_mask: sigset_t, - pub sa_flags: libc::c_int, - } - - #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))] - #[repr(C)] - pub struct sigaction { - pub sa_sigaction: sighandler_t, - pub sa_flags: libc::c_int, - pub sa_mask: sigset_t, - } - - #[repr(C)] - pub struct sigaltstack { - pub ss_sp: *mut libc::c_void, - pub ss_size: libc::size_t, - pub ss_flags: libc::c_int, - } -} diff --git a/src/libstd/sys/unix/condvar.rs b/src/libstd/sys/unix/condvar.rs index b9538867b25..3e0f41933e6 100644 --- a/src/libstd/sys/unix/condvar.rs +++ b/src/libstd/sys/unix/condvar.rs @@ -13,10 +13,9 @@ use libc; use ptr; use sys::mutex::{self, Mutex}; use sys::time; -use sys::sync as ffi; use time::Duration; -pub struct Condvar { inner: UnsafeCell<ffi::pthread_cond_t> } +pub struct Condvar { inner: UnsafeCell<libc::pthread_cond_t> } unsafe impl Send for Condvar {} unsafe impl Sync for Condvar {} @@ -25,24 +24,24 @@ impl Condvar { pub const fn new() -> Condvar { // Might be moved and address is changing it is better to avoid // initialization of potentially opaque OS data before it landed - Condvar { inner: UnsafeCell::new(ffi::PTHREAD_COND_INITIALIZER) } + Condvar { inner: UnsafeCell::new(libc::PTHREAD_COND_INITIALIZER) } } #[inline] pub unsafe fn notify_one(&self) { - let r = ffi::pthread_cond_signal(self.inner.get()); + let r = libc::pthread_cond_signal(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] pub unsafe fn notify_all(&self) { - let r = ffi::pthread_cond_broadcast(self.inner.get()); + let r = libc::pthread_cond_broadcast(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] pub unsafe fn wait(&self, mutex: &Mutex) { - let r = ffi::pthread_cond_wait(self.inner.get(), mutex::raw(mutex)); + let r = libc::pthread_cond_wait(self.inner.get(), mutex::raw(mutex)); debug_assert_eq!(r, 0); } @@ -55,7 +54,7 @@ impl Condvar { // report timeout based on stable time. let mut sys_now = libc::timeval { tv_sec: 0, tv_usec: 0 }; let stable_now = time::SteadyTime::now(); - let r = ffi::gettimeofday(&mut sys_now, ptr::null_mut()); + let r = libc::gettimeofday(&mut sys_now, ptr::null_mut()); debug_assert_eq!(r, 0); let nsec = dur.subsec_nanos() as libc::c_long + @@ -76,7 +75,7 @@ impl Condvar { }); // And wait! - let r = ffi::pthread_cond_timedwait(self.inner.get(), mutex::raw(mutex), + let r = libc::pthread_cond_timedwait(self.inner.get(), mutex::raw(mutex), &timeout); debug_assert!(r == libc::ETIMEDOUT || r == 0); @@ -88,17 +87,17 @@ impl Condvar { #[inline] #[cfg(not(target_os = "dragonfly"))] pub unsafe fn destroy(&self) { - let r = ffi::pthread_cond_destroy(self.inner.get()); + let r = libc::pthread_cond_destroy(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] #[cfg(target_os = "dragonfly")] pub unsafe fn destroy(&self) { - let r = ffi::pthread_cond_destroy(self.inner.get()); + let r = libc::pthread_cond_destroy(self.inner.get()); // On DragonFly pthread_cond_destroy() returns EINVAL if called on // a condvar that was just initialized with - // ffi::PTHREAD_COND_INITIALIZER. Once it is used or + // libc::PTHREAD_COND_INITIALIZER. Once it is used or // pthread_cond_init() is called, this behaviour no longer occurs. debug_assert!(r == 0 || r == libc::EINVAL); } diff --git a/src/libstd/sys/unix/ext/process.rs b/src/libstd/sys/unix/ext/process.rs index dcfa376c81e..3e7260f0757 100644 --- a/src/libstd/sys/unix/ext/process.rs +++ b/src/libstd/sys/unix/ext/process.rs @@ -75,10 +75,7 @@ pub trait ExitStatusExt { #[stable(feature = "rust1", since = "1.0.0")] impl ExitStatusExt for process::ExitStatus { fn signal(&self) -> Option<i32> { - match *self.as_inner() { - sys::process::ExitStatus::Signal(s) => Some(s), - _ => None - } + self.as_inner().signal() } } diff --git a/src/libstd/sys/unix/fd.rs b/src/libstd/sys/unix/fd.rs index 4ac498f77ce..d42c15a97ac 100644 --- a/src/libstd/sys/unix/fd.rs +++ b/src/libstd/sys/unix/fd.rs @@ -11,7 +11,6 @@ use io; use libc::{self, c_int, size_t, c_void}; use mem; -use sys::c; use sys::cvt; use sys_common::AsInner; @@ -51,9 +50,18 @@ impl FileDesc { Ok(ret as usize) } + #[cfg(not(target_env = "newlib"))] pub fn set_cloexec(&self) { unsafe { - let ret = c::ioctl(self.fd, c::FIOCLEX); + let ret = libc::ioctl(self.fd, libc::FIOCLEX); + debug_assert_eq!(ret, 0); + } + } + #[cfg(target_env = "newlib")] + pub fn set_cloexec(&self) { + unsafe { + let previous = libc::fnctl(self.fd, libc::F_GETFD); + let ret = libc::fnctl(self.fd, libc::F_SETFD, previous | libc::FD_CLOEXEC); debug_assert_eq!(ret, 0); } } diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs index c2145ac875a..018c9100288 100644 --- a/src/libstd/sys/unix/fs.rs +++ b/src/libstd/sys/unix/fs.rs @@ -21,7 +21,7 @@ use ptr; use sync::Arc; use sys::fd::FileDesc; use sys::platform::raw; -use sys::{c, cvt, cvt_r}; +use sys::{cvt, cvt_r}; use sys_common::{AsInner, FromInner}; use vec::Vec; @@ -43,7 +43,7 @@ unsafe impl Send for Dir {} unsafe impl Sync for Dir {} pub struct DirEntry { - buf: Vec<u8>, // actually *mut libc::dirent_t + buf: Vec<u8>, // actually *mut libc::dirent root: Arc<PathBuf>, } @@ -133,7 +133,7 @@ impl Iterator for ReadDir { let mut buf: Vec<u8> = Vec::with_capacity(unsafe { rust_dirent_t_size() as usize }); - let ptr = buf.as_mut_ptr() as *mut libc::dirent_t; + let ptr = buf.as_mut_ptr() as *mut libc::dirent; let mut entry_ptr = ptr::null_mut(); loop { @@ -179,7 +179,7 @@ impl DirEntry { pub fn file_type(&self) -> io::Result<FileType> { extern { - fn rust_dir_get_mode(ptr: *mut libc::dirent_t) -> c_int; + fn rust_dir_get_mode(ptr: *mut libc::dirent) -> c_int; } unsafe { match rust_dir_get_mode(self.dirent()) { @@ -191,21 +191,21 @@ impl DirEntry { pub fn ino(&self) -> raw::ino_t { extern { - fn rust_dir_get_ino(ptr: *mut libc::dirent_t) -> raw::ino_t; + fn rust_dir_get_ino(ptr: *mut libc::dirent) -> raw::ino_t; } unsafe { rust_dir_get_ino(self.dirent()) } } fn name_bytes(&self) -> &[u8] { extern { - fn rust_list_dir_val(ptr: *mut libc::dirent_t) -> *const c_char; + fn rust_list_dir_val(ptr: *mut libc::dirent) -> *const c_char; } unsafe { CStr::from_ptr(rust_list_dir_val(self.dirent())).to_bytes() } } - fn dirent(&self) -> *mut libc::dirent_t { + fn dirent(&self) -> *mut libc::dirent { self.buf.as_ptr() as *mut _ } } @@ -267,7 +267,7 @@ impl File { (false, false) => libc::O_RDONLY, }; let fd = try!(cvt_r(|| unsafe { - libc::open(path.as_ptr(), flags, opts.mode) + libc::open(path.as_ptr(), flags, opts.mode as c_int) })); let fd = FileDesc::new(fd); // Even though we open with the O_CLOEXEC flag, still set CLOEXEC here, @@ -532,7 +532,7 @@ pub fn canonicalize(p: &Path) -> io::Result<PathBuf> { let path = try!(CString::new(p.as_os_str().as_bytes())); let buf; unsafe { - let r = c::realpath(path.as_ptr(), ptr::null_mut()); + let r = libc::realpath(path.as_ptr(), ptr::null_mut()); if r.is_null() { return Err(io::Error::last_os_error()) } diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index 3a88f36399e..68b0c3d6b0e 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -12,7 +12,6 @@ #![allow(non_camel_case_types)] use io::{self, ErrorKind}; -use libc::funcs::posix01::signal::signal; use libc; use num::One; use ops::Neg; @@ -29,7 +28,6 @@ use ops::Neg; #[cfg(target_os = "openbsd")] pub use os::openbsd as platform; pub mod backtrace; -pub mod c; pub mod condvar; pub mod ext; pub mod fd; @@ -42,13 +40,14 @@ pub mod pipe; pub mod process; pub mod rwlock; pub mod stack_overflow; -pub mod sync; pub mod thread; pub mod thread_local; pub mod time; pub mod stdio; +#[cfg(not(target_os = "nacl"))] pub fn init() { + use libc::signal; // By default, some platforms will send a *signal* when an EPIPE error // would otherwise be delivered. This runtime doesn't install a SIGPIPE // handler, causing it to kill the program, which isn't exactly what we @@ -60,6 +59,8 @@ pub fn init() { assert!(signal(libc::SIGPIPE, libc::SIG_IGN) != !0); } } +#[cfg(target_os = "nacl")] +pub fn init() { } pub fn decode_error_kind(errno: i32) -> ErrorKind { match errno as libc::c_int { @@ -75,7 +76,7 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind { libc::EINTR => ErrorKind::Interrupted, libc::EINVAL => ErrorKind::InvalidInput, libc::ETIMEDOUT => ErrorKind::TimedOut, - libc::consts::os::posix88::EEXIST => ErrorKind::AlreadyExists, + libc::EEXIST => ErrorKind::AlreadyExists, // These two constants can have the same value on some systems, // but different values on others, so we can't use a match diff --git a/src/libstd/sys/unix/mutex.rs b/src/libstd/sys/unix/mutex.rs index e4c231ff971..4e4abcfbeee 100644 --- a/src/libstd/sys/unix/mutex.rs +++ b/src/libstd/sys/unix/mutex.rs @@ -9,13 +9,13 @@ // except according to those terms. use cell::UnsafeCell; -use sys::sync as ffi; +use libc; use mem; -pub struct Mutex { inner: UnsafeCell<ffi::pthread_mutex_t> } +pub struct Mutex { inner: UnsafeCell<libc::pthread_mutex_t> } #[inline] -pub unsafe fn raw(m: &Mutex) -> *mut ffi::pthread_mutex_t { +pub unsafe fn raw(m: &Mutex) -> *mut libc::pthread_mutex_t { m.inner.get() } @@ -27,42 +27,42 @@ impl Mutex { pub const fn new() -> Mutex { // Might be moved and address is changing it is better to avoid // initialization of potentially opaque OS data before it landed - Mutex { inner: UnsafeCell::new(ffi::PTHREAD_MUTEX_INITIALIZER) } + Mutex { inner: UnsafeCell::new(libc::PTHREAD_MUTEX_INITIALIZER) } } #[inline] pub unsafe fn lock(&self) { - let r = ffi::pthread_mutex_lock(self.inner.get()); + let r = libc::pthread_mutex_lock(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] pub unsafe fn unlock(&self) { - let r = ffi::pthread_mutex_unlock(self.inner.get()); + let r = libc::pthread_mutex_unlock(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] pub unsafe fn try_lock(&self) -> bool { - ffi::pthread_mutex_trylock(self.inner.get()) == 0 + libc::pthread_mutex_trylock(self.inner.get()) == 0 } #[inline] #[cfg(not(target_os = "dragonfly"))] pub unsafe fn destroy(&self) { - let r = ffi::pthread_mutex_destroy(self.inner.get()); + let r = libc::pthread_mutex_destroy(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] #[cfg(target_os = "dragonfly")] pub unsafe fn destroy(&self) { use libc; - let r = ffi::pthread_mutex_destroy(self.inner.get()); + let r = libc::pthread_mutex_destroy(self.inner.get()); // On DragonFly pthread_mutex_destroy() returns EINVAL if called on a - // mutex that was just initialized with ffi::PTHREAD_MUTEX_INITIALIZER. + // mutex that was just initialized with libc::PTHREAD_MUTEX_INITIALIZER. // Once it is used (locked/unlocked) or pthread_mutex_init() is called, // this behaviour no longer occurs. debug_assert!(r == 0 || r == libc::EINVAL); } } -pub struct ReentrantMutex { inner: UnsafeCell<ffi::pthread_mutex_t> } +pub struct ReentrantMutex { inner: UnsafeCell<libc::pthread_mutex_t> } unsafe impl Send for ReentrantMutex {} unsafe impl Sync for ReentrantMutex {} @@ -73,35 +73,35 @@ impl ReentrantMutex { } pub unsafe fn init(&mut self) { - let mut attr: ffi::pthread_mutexattr_t = mem::uninitialized(); - let result = ffi::pthread_mutexattr_init(&mut attr as *mut _); + let mut attr: libc::pthread_mutexattr_t = mem::uninitialized(); + let result = libc::pthread_mutexattr_init(&mut attr as *mut _); debug_assert_eq!(result, 0); - let result = ffi::pthread_mutexattr_settype(&mut attr as *mut _, - ffi::PTHREAD_MUTEX_RECURSIVE); + let result = libc::pthread_mutexattr_settype(&mut attr as *mut _, + libc::PTHREAD_MUTEX_RECURSIVE); debug_assert_eq!(result, 0); - let result = ffi::pthread_mutex_init(self.inner.get(), &attr as *const _); + let result = libc::pthread_mutex_init(self.inner.get(), &attr as *const _); debug_assert_eq!(result, 0); - let result = ffi::pthread_mutexattr_destroy(&mut attr as *mut _); + let result = libc::pthread_mutexattr_destroy(&mut attr as *mut _); debug_assert_eq!(result, 0); } pub unsafe fn lock(&self) { - let result = ffi::pthread_mutex_lock(self.inner.get()); + let result = libc::pthread_mutex_lock(self.inner.get()); debug_assert_eq!(result, 0); } #[inline] pub unsafe fn try_lock(&self) -> bool { - ffi::pthread_mutex_trylock(self.inner.get()) == 0 + libc::pthread_mutex_trylock(self.inner.get()) == 0 } pub unsafe fn unlock(&self) { - let result = ffi::pthread_mutex_unlock(self.inner.get()); + let result = libc::pthread_mutex_unlock(self.inner.get()); debug_assert_eq!(result, 0); } pub unsafe fn destroy(&self) { - let result = ffi::pthread_mutex_destroy(self.inner.get()); + let result = libc::pthread_mutex_destroy(self.inner.get()); debug_assert_eq!(result, 0); } } diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index 6d65cb838f6..bcda1d651d6 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -13,16 +13,16 @@ use prelude::v1::*; use ffi::CStr; use io; use libc::{self, c_int, size_t}; -use net::SocketAddr; +use net::{SocketAddr, Shutdown}; use str; -use sync::atomic::{self, AtomicBool}; -use sys::c; +use sync::atomic::{AtomicBool, Ordering}; use sys::fd::FileDesc; use sys_common::{AsInner, FromInner, IntoInner}; use sys_common::net::{getsockopt, setsockopt}; use time::Duration; pub use sys::{cvt, cvt_r}; +pub use libc as netc; pub type wrlen_t = size_t; @@ -34,7 +34,7 @@ pub fn cvt_gai(err: c_int) -> io::Result<()> { if err == 0 { return Ok(()) } let detail = unsafe { - str::from_utf8(CStr::from_ptr(c::gai_strerror(err)).to_bytes()).unwrap() + str::from_utf8(CStr::from_ptr(libc::gai_strerror(err)).to_bytes()).unwrap() .to_owned() }; Err(io::Error::new(io::ErrorKind::Other, @@ -67,29 +67,44 @@ impl Socket { } pub fn duplicate(&self) -> io::Result<Socket> { - use libc::funcs::posix88::fcntl::fcntl; + // We want to atomically duplicate this file descriptor and set the + // CLOEXEC flag, and currently that's done via F_DUPFD_CLOEXEC. This + // flag, however, isn't supported on older Linux kernels (earlier than + // 2.6.24). + // + // To detect this and ensure that CLOEXEC is still set, we + // follow a strategy similar to musl [1] where if passing + // F_DUPFD_CLOEXEC causes `fcntl` to return EINVAL it means it's not + // supported (the third parameter, 0, is always valid), so we stop + // trying that. We also *still* call the `set_cloexec` method as + // apparently some kernel at some point stopped setting CLOEXEC even + // though it reported doing so on F_DUPFD_CLOEXEC. + // + // Also note that Android doesn't have F_DUPFD_CLOEXEC, but get it to + // resolve so we at least compile this. + // + // [1]: http://comments.gmane.org/gmane.linux.lib.musl.general/2963 + #[cfg(target_os = "android")] + use libc::F_DUPFD as F_DUPFD_CLOEXEC; + #[cfg(not(target_os = "android"))] + use libc::F_DUPFD_CLOEXEC; + let make_socket = |fd| { let fd = FileDesc::new(fd); fd.set_cloexec(); Socket(fd) }; - static EMULATE_F_DUPFD_CLOEXEC: AtomicBool = AtomicBool::new(false); - if !EMULATE_F_DUPFD_CLOEXEC.load(atomic::Ordering::Relaxed) { - match cvt(unsafe { fcntl(self.0.raw(), libc::F_DUPFD_CLOEXEC, 0) }) { - // `EINVAL` can only be returned on two occasions: Invalid - // command (second parameter) or invalid third parameter. 0 is - // always a valid third parameter, so it must be the second - // parameter. - // - // Store the result in a global variable so we don't try each - // syscall twice. + static TRY_CLOEXEC: AtomicBool = AtomicBool::new(true); + let fd = self.0.raw(); + if !cfg!(target_os = "android") && TRY_CLOEXEC.load(Ordering::Relaxed) { + match cvt(unsafe { libc::fcntl(fd, F_DUPFD_CLOEXEC, 0) }) { Err(ref e) if e.raw_os_error() == Some(libc::EINVAL) => { - EMULATE_F_DUPFD_CLOEXEC.store(true, atomic::Ordering::Relaxed); + TRY_CLOEXEC.store(false, Ordering::Relaxed); } res => return res.map(make_socket), } } - cvt(unsafe { fcntl(self.0.raw(), libc::F_DUPFD, 0) }).map(make_socket) + cvt(unsafe { libc::fcntl(fd, libc::F_DUPFD, 0) }).map(make_socket) } pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { @@ -138,6 +153,16 @@ impl Socket { Ok(Some(Duration::new(sec, nsec))) } } + + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + let how = match how { + Shutdown::Write => libc::SHUT_WR, + Shutdown::Read => libc::SHUT_RD, + Shutdown::Both => libc::SHUT_RDWR, + }; + try!(cvt(unsafe { libc::shutdown(self.0.raw(), how) })); + Ok(()) + } } impl AsInner<c_int> for Socket { diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index 59b385b9481..3c53db53f85 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -26,38 +26,25 @@ use path::{self, PathBuf}; use ptr; use slice; use str; -use sys::c; +use sync::StaticMutex; +use sys::cvt; use sys::fd; use vec; const TMPBUF_SZ: usize = 128; +static ENV_LOCK: StaticMutex = StaticMutex::new(); /// Returns the platform-specific value of errno pub fn errno() -> i32 { - #[cfg(any(target_os = "macos", - target_os = "ios", - target_os = "freebsd"))] - unsafe fn errno_location() -> *const c_int { - extern { fn __error() -> *const c_int; } - __error() - } - - #[cfg(target_os = "dragonfly")] - unsafe fn errno_location() -> *const c_int { - extern { fn __dfly_error() -> *const c_int; } - __dfly_error() - } - - #[cfg(any(target_os = "bitrig", target_os = "netbsd", target_os = "openbsd"))] - unsafe fn errno_location() -> *const c_int { - extern { fn __errno() -> *const c_int; } - __errno() - } - - #[cfg(any(target_os = "linux", target_os = "android"))] - unsafe fn errno_location() -> *const c_int { - extern { fn __errno_location() -> *const c_int; } - __errno_location() + extern { + #[cfg_attr(any(target_os = "linux", target_os = "android"), link_name = "__errno_location")] + #[cfg_attr(any(target_os = "bitrig", target_os = "netbsd", target_os = "openbsd", + target_env = "newlib"), + link_name = "__errno")] + #[cfg_attr(target_os = "dragonfly", link_name = "__dfly_error")] + #[cfg_attr(any(target_os = "macos", target_os = "ios", target_os = "freebsd"), + link_name = "__error")] + fn errno_location() -> *const c_int; } unsafe { @@ -67,14 +54,9 @@ pub fn errno() -> i32 { /// Gets a detailed string description for the given error number. pub fn error_string(errno: i32) -> String { - #[cfg(target_os = "linux")] - extern { - #[link_name = "__xpg_strerror_r"] - fn strerror_r(errnum: c_int, buf: *mut c_char, - buflen: libc::size_t) -> c_int; - } - #[cfg(not(target_os = "linux"))] extern { + #[cfg_attr(any(target_os = "linux", target_env = "newlib"), + link_name = "__xpg_strerror_r")] fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: libc::size_t) -> c_int; } @@ -247,8 +229,11 @@ pub fn current_exe() -> io::Result<PathBuf> { #[cfg(any(target_os = "macos", target_os = "ios"))] pub fn current_exe() -> io::Result<PathBuf> { + extern { + fn _NSGetExecutablePath(buf: *mut libc::c_char, + bufsize: *mut u32) -> libc::c_int; + } unsafe { - use libc::funcs::extra::_NSGetExecutablePath; let mut sz: u32 = 0; _NSGetExecutablePath(ptr::null_mut(), &mut sz); if sz == 0 { return Err(io::Error::last_os_error()); } @@ -361,7 +346,8 @@ pub fn args() -> Args { target_os = "dragonfly", target_os = "bitrig", target_os = "netbsd", - target_os = "openbsd"))] + target_os = "openbsd", + target_os = "nacl"))] pub fn args() -> Args { use sys_common; let bytes = sys_common::args::clone().unwrap_or(Vec::new()); @@ -397,6 +383,7 @@ pub unsafe fn environ() -> *mut *const *const c_char { /// Returns a vector of (variable, value) byte-vector pairs for all the /// environment variables of the current process. pub fn env() -> Env { + let _g = ENV_LOCK.lock(); return unsafe { let mut environ = *environ(); if environ as usize == 0 { @@ -420,35 +407,36 @@ pub fn env() -> Env { } } -pub fn getenv(k: &OsStr) -> Option<OsString> { - unsafe { - let s = k.to_cstring().unwrap(); - let s = libc::getenv(s.as_ptr()) as *const _; +pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> { + // environment variables with a nul byte can't be set, so their value is + // always None as well + let k = try!(CString::new(k.as_bytes())); + let _g = ENV_LOCK.lock(); + Ok(unsafe { + let s = libc::getenv(k.as_ptr()) as *const _; if s.is_null() { None } else { Some(OsStringExt::from_vec(CStr::from_ptr(s).to_bytes().to_vec())) } - } + }) } -pub fn setenv(k: &OsStr, v: &OsStr) { - unsafe { - let k = k.to_cstring().unwrap(); - let v = v.to_cstring().unwrap(); - if libc::funcs::posix01::unistd::setenv(k.as_ptr(), v.as_ptr(), 1) != 0 { - panic!("failed setenv: {}", io::Error::last_os_error()); - } - } +pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> { + let k = try!(CString::new(k.as_bytes())); + let v = try!(CString::new(v.as_bytes())); + let _g = ENV_LOCK.lock(); + cvt(unsafe { + libc::setenv(k.as_ptr(), v.as_ptr(), 1) + }).map(|_| ()) } -pub fn unsetenv(n: &OsStr) { - unsafe { - let nbuf = n.to_cstring().unwrap(); - if libc::funcs::posix01::unistd::unsetenv(nbuf.as_ptr()) != 0 { - panic!("failed unsetenv: {}", io::Error::last_os_error()); - } - } +pub fn unsetenv(n: &OsStr) -> io::Result<()> { + let nbuf = try!(CString::new(n.as_bytes())); + let _g = ENV_LOCK.lock(); + cvt(unsafe { + libc::unsetenv(nbuf.as_ptr()) + }).map(|_| ()) } pub fn page_size() -> usize { @@ -458,7 +446,7 @@ pub fn page_size() -> usize { } pub fn temp_dir() -> PathBuf { - getenv("TMPDIR".as_ref()).map(PathBuf::from).unwrap_or_else(|| { + ::env::var_os("TMPDIR").map(PathBuf::from).unwrap_or_else(|| { if cfg!(target_os = "android") { PathBuf::from("/data/local/tmp") } else { @@ -468,28 +456,30 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option<PathBuf> { - return getenv("HOME".as_ref()).or_else(|| unsafe { + return ::env::var_os("HOME").or_else(|| unsafe { fallback() }).map(PathBuf::from); #[cfg(any(target_os = "android", - target_os = "ios"))] + target_os = "ios", + target_os = "nacl"))] unsafe fn fallback() -> Option<OsString> { None } #[cfg(not(any(target_os = "android", - target_os = "ios")))] + target_os = "ios", + target_os = "nacl")))] unsafe fn fallback() -> Option<OsString> { - let amt = match libc::sysconf(c::_SC_GETPW_R_SIZE_MAX) { + let amt = match libc::sysconf(libc::_SC_GETPW_R_SIZE_MAX) { n if n < 0 => 512 as usize, n => n as usize, }; let me = libc::getuid(); loop { let mut buf = Vec::with_capacity(amt); - let mut passwd: c::passwd = mem::zeroed(); + let mut passwd: libc::passwd = mem::zeroed(); let mut result = ptr::null_mut(); - match c::getpwuid_r(me, &mut passwd, buf.as_mut_ptr(), - buf.capacity() as libc::size_t, - &mut result) { + match libc::getpwuid_r(me, &mut passwd, buf.as_mut_ptr(), + buf.capacity() as libc::size_t, + &mut result) { 0 if !result.is_null() => {} _ => return None } diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index 7f50e75f6fc..8d80296ab03 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#![allow(non_snake_case)] + use prelude::v1::*; use os::unix::prelude::*; @@ -17,12 +19,11 @@ use ffi::{OsString, OsStr, CString, CStr}; use fmt; use io::{self, Error, ErrorKind}; use libc::{self, pid_t, c_void, c_int, gid_t, uid_t}; -use mem; use ptr; use sys::fd::FileDesc; use sys::fs::{File, OpenOptions}; use sys::pipe::AnonPipe; -use sys::{self, c, cvt, cvt_r}; +use sys::{self, cvt, cvt_r}; //////////////////////////////////////////////////////////////////////////////// // Command @@ -85,33 +86,62 @@ impl Command { /// Unix exit statuses #[derive(PartialEq, Eq, Clone, Copy, Debug)] -pub enum ExitStatus { - /// Normal termination with an exit code. - Code(i32), - - /// Termination by signal, with the signal number. - /// - /// Never generated on Windows. - Signal(i32), +pub struct ExitStatus(c_int); + +#[cfg(any(target_os = "linux", target_os = "android", + target_os = "nacl"))] +mod status_imp { + pub fn WIFEXITED(status: i32) -> bool { (status & 0xff) == 0 } + pub fn WEXITSTATUS(status: i32) -> i32 { (status >> 8) & 0xff } + pub fn WTERMSIG(status: i32) -> i32 { status & 0x7f } +} + +#[cfg(any(target_os = "macos", + target_os = "ios", + target_os = "freebsd", + target_os = "dragonfly", + target_os = "bitrig", + target_os = "netbsd", + target_os = "openbsd"))] +mod status_imp { + pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 } + pub fn WEXITSTATUS(status: i32) -> i32 { status >> 8 } + pub fn WTERMSIG(status: i32) -> i32 { status & 0o177 } } impl ExitStatus { + fn exited(&self) -> bool { + status_imp::WIFEXITED(self.0) + } + pub fn success(&self) -> bool { - *self == ExitStatus::Code(0) + self.code() == Some(0) } + pub fn code(&self) -> Option<i32> { - match *self { - ExitStatus::Code(c) => Some(c), - _ => None + if self.exited() { + Some(status_imp::WEXITSTATUS(self.0)) + } else { + None + } + } + + pub fn signal(&self) -> Option<i32> { + if !self.exited() { + Some(status_imp::WTERMSIG(self.0)) + } else { + None } } } impl fmt::Display for ExitStatus { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - match *self { - ExitStatus::Code(code) => write!(f, "exit code: {}", code), - ExitStatus::Signal(code) => write!(f, "signal: {}", code), + if let Some(code) = self.code() { + write!(f, "exit code: {}", code) + } else { + let signal = self.signal().unwrap(); + write!(f, "signal: {}", signal) } } } @@ -133,7 +163,7 @@ const CLOEXEC_MSG_FOOTER: &'static [u8] = b"NOEX"; impl Process { pub unsafe fn kill(&self) -> io::Result<()> { - try!(cvt(libc::funcs::posix88::signal::kill(self.pid, libc::SIGKILL))); + try!(cvt(libc::kill(self.pid, libc::SIGKILL))); Ok(()) } @@ -296,7 +326,7 @@ impl Process { // fail if we aren't root, so don't bother checking the // return value, this is just done as an optimistic // privilege dropping function. - let _ = c::setgroups(0, ptr::null()); + let _ = libc::setgroups(0, ptr::null()); if libc::setuid(u as libc::uid_t) != 0 { fail(&mut output); @@ -315,21 +345,31 @@ impl Process { *sys::os::environ() = envp as *const _; } - // Reset signal handling so the child process starts in a - // standardized state. libstd ignores SIGPIPE, and signal-handling - // libraries often set a mask. Child processes inherit ignored - // signals and the signal mask from their parent, but most - // UNIX programs do not reset these things on their own, so we - // need to clean things up now to avoid confusing the program - // we're about to run. - let mut set: c::sigset_t = mem::uninitialized(); - if c::sigemptyset(&mut set) != 0 || - c::pthread_sigmask(c::SIG_SETMASK, &set, ptr::null_mut()) != 0 || - libc::funcs::posix01::signal::signal( - libc::SIGPIPE, mem::transmute(c::SIG_DFL) - ) == mem::transmute(c::SIG_ERR) { - fail(&mut output); + #[cfg(not(target_os = "nacl"))] + unsafe fn reset_signal_handling(output: &mut AnonPipe) { + use mem; + // Reset signal handling so the child process starts in a + // standardized state. libstd ignores SIGPIPE, and signal-handling + // libraries often set a mask. Child processes inherit ignored + // signals and the signal mask from their parent, but most + // UNIX programs do not reset these things on their own, so we + // need to clean things up now to avoid confusing the program + // we're about to run. + let mut set: libc::sigset_t = mem::uninitialized(); + if libc::sigemptyset(&mut set) != 0 || + libc::pthread_sigmask(libc::SIG_SETMASK, &set, ptr::null_mut()) != 0 || + libc::signal( + libc::SIGPIPE, mem::transmute(libc::SIG_DFL) + ) == mem::transmute(libc::SIG_ERR) + { + fail(output); + } + } + #[cfg(target_os = "nacl")] + unsafe fn reset_signal_handling(_output: &mut AnonPipe) { + // NaCl has no signal support. } + reset_signal_handling(&mut output); let _ = libc::execvp(*argv, argv); fail(&mut output) @@ -341,17 +381,17 @@ impl Process { pub fn wait(&self) -> io::Result<ExitStatus> { let mut status = 0 as c_int; - try!(cvt_r(|| unsafe { c::waitpid(self.pid, &mut status, 0) })); - Ok(translate_status(status)) + try!(cvt_r(|| unsafe { libc::waitpid(self.pid, &mut status, 0) })); + Ok(ExitStatus(status)) } pub fn try_wait(&self) -> Option<ExitStatus> { let mut status = 0 as c_int; match cvt_r(|| unsafe { - c::waitpid(self.pid, &mut status, c::WNOHANG) + libc::waitpid(self.pid, &mut status, libc::WNOHANG) }) { Ok(0) => None, - Ok(n) if n == self.pid => Some(translate_status(status)), + Ok(n) if n == self.pid => Some(ExitStatus(status)), Ok(n) => panic!("unknown pid: {}", n), Err(e) => panic!("unknown waitpid error: {}", e), } @@ -409,35 +449,6 @@ fn make_envp(env: Option<&HashMap<OsString, OsString>>) } } -fn translate_status(status: c_int) -> ExitStatus { - #![allow(non_snake_case)] - #[cfg(any(target_os = "linux", target_os = "android"))] - mod imp { - pub fn WIFEXITED(status: i32) -> bool { (status & 0xff) == 0 } - pub fn WEXITSTATUS(status: i32) -> i32 { (status >> 8) & 0xff } - pub fn WTERMSIG(status: i32) -> i32 { status & 0x7f } - } - - #[cfg(any(target_os = "macos", - target_os = "ios", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "netbsd", - target_os = "openbsd"))] - mod imp { - pub fn WIFEXITED(status: i32) -> bool { (status & 0x7f) == 0 } - pub fn WEXITSTATUS(status: i32) -> i32 { status >> 8 } - pub fn WTERMSIG(status: i32) -> i32 { status & 0o177 } - } - - if imp::WIFEXITED(status) { - ExitStatus::Code(imp::WEXITSTATUS(status)) - } else { - ExitStatus::Signal(imp::WTERMSIG(status)) - } -} - #[cfg(test)] mod tests { use super::*; @@ -448,7 +459,7 @@ mod tests { use ptr; use libc; use slice; - use sys::{self, c, cvt, pipe}; + use sys::{self, cvt, pipe}; macro_rules! t { ($e:expr) => { @@ -462,12 +473,12 @@ mod tests { #[cfg(not(target_os = "android"))] extern { #[cfg_attr(target_os = "netbsd", link_name = "__sigaddset14")] - fn sigaddset(set: *mut c::sigset_t, signum: libc::c_int) -> libc::c_int; + fn sigaddset(set: *mut libc::sigset_t, signum: libc::c_int) -> libc::c_int; } #[cfg(target_os = "android")] - unsafe fn sigaddset(set: *mut c::sigset_t, signum: libc::c_int) -> libc::c_int { - let raw = slice::from_raw_parts_mut(set as *mut u8, mem::size_of::<c::sigset_t>()); + unsafe fn sigaddset(set: *mut libc::sigset_t, signum: libc::c_int) -> libc::c_int { + let raw = slice::from_raw_parts_mut(set as *mut u8, mem::size_of::<libc::sigset_t>()); let bit = (signum - 1) as usize; raw[bit / 8] |= 1 << (bit % 8); return 0; @@ -478,6 +489,7 @@ mod tests { // test from being flaky we ignore it on OSX. #[test] #[cfg_attr(target_os = "macos", ignore)] + #[cfg_attr(target_os = "nacl", ignore)] // no signals on NaCl. fn test_process_mask() { unsafe { // Test to make sure that a signal mask does not get inherited. @@ -485,11 +497,11 @@ mod tests { let (stdin_read, stdin_write) = t!(sys::pipe::anon_pipe()); let (stdout_read, stdout_write) = t!(sys::pipe::anon_pipe()); - let mut set: c::sigset_t = mem::uninitialized(); - let mut old_set: c::sigset_t = mem::uninitialized(); - t!(cvt(c::sigemptyset(&mut set))); + let mut set: libc::sigset_t = mem::uninitialized(); + let mut old_set: libc::sigset_t = mem::uninitialized(); + t!(cvt(libc::sigemptyset(&mut set))); t!(cvt(sigaddset(&mut set, libc::SIGINT))); - t!(cvt(c::pthread_sigmask(c::SIG_SETMASK, &set, &mut old_set))); + t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &set, &mut old_set))); let cat = t!(Process::spawn(&cmd, Stdio::Raw(stdin_read.raw()), Stdio::Raw(stdout_write.raw()), @@ -497,11 +509,10 @@ mod tests { drop(stdin_read); drop(stdout_write); - t!(cvt(c::pthread_sigmask(c::SIG_SETMASK, &old_set, - ptr::null_mut()))); + t!(cvt(libc::pthread_sigmask(libc::SIG_SETMASK, &old_set, + ptr::null_mut()))); - t!(cvt(libc::funcs::posix88::signal::kill(cat.id() as libc::pid_t, - libc::SIGINT))); + t!(cvt(libc::kill(cat.id() as libc::pid_t, libc::SIGINT))); // We need to wait until SIGINT is definitely delivered. The // easiest way is to write something to cat, and try to read it // back: if SIGINT is unmasked, it'll get delivered when cat is diff --git a/src/libstd/sys/unix/rwlock.rs b/src/libstd/sys/unix/rwlock.rs index 788bff62430..44bd5d895f2 100644 --- a/src/libstd/sys/unix/rwlock.rs +++ b/src/libstd/sys/unix/rwlock.rs @@ -10,20 +10,19 @@ use libc; use cell::UnsafeCell; -use sys::sync as ffi; -pub struct RWLock { inner: UnsafeCell<ffi::pthread_rwlock_t> } +pub struct RWLock { inner: UnsafeCell<libc::pthread_rwlock_t> } unsafe impl Send for RWLock {} unsafe impl Sync for RWLock {} impl RWLock { pub const fn new() -> RWLock { - RWLock { inner: UnsafeCell::new(ffi::PTHREAD_RWLOCK_INITIALIZER) } + RWLock { inner: UnsafeCell::new(libc::PTHREAD_RWLOCK_INITIALIZER) } } #[inline] pub unsafe fn read(&self) { - let r = ffi::pthread_rwlock_rdlock(self.inner.get()); + let r = libc::pthread_rwlock_rdlock(self.inner.get()); // According to the pthread_rwlock_rdlock spec, this function **may** // fail with EDEADLK if a deadlock is detected. On the other hand @@ -44,11 +43,11 @@ impl RWLock { } #[inline] pub unsafe fn try_read(&self) -> bool { - ffi::pthread_rwlock_tryrdlock(self.inner.get()) == 0 + libc::pthread_rwlock_tryrdlock(self.inner.get()) == 0 } #[inline] pub unsafe fn write(&self) { - let r = ffi::pthread_rwlock_wrlock(self.inner.get()); + let r = libc::pthread_rwlock_wrlock(self.inner.get()); // see comments above for why we check for EDEADLK if r == libc::EDEADLK { panic!("rwlock write lock would result in deadlock"); @@ -58,21 +57,21 @@ impl RWLock { } #[inline] pub unsafe fn try_write(&self) -> bool { - ffi::pthread_rwlock_trywrlock(self.inner.get()) == 0 + libc::pthread_rwlock_trywrlock(self.inner.get()) == 0 } #[inline] pub unsafe fn read_unlock(&self) { - let r = ffi::pthread_rwlock_unlock(self.inner.get()); + let r = libc::pthread_rwlock_unlock(self.inner.get()); debug_assert_eq!(r, 0); } #[inline] pub unsafe fn write_unlock(&self) { self.read_unlock() } #[inline] pub unsafe fn destroy(&self) { - let r = ffi::pthread_rwlock_destroy(self.inner.get()); + let r = libc::pthread_rwlock_destroy(self.inner.get()); // On DragonFly pthread_rwlock_destroy() returns EINVAL if called on a // rwlock that was just initialized with - // ffi::PTHREAD_RWLOCK_INITIALIZER. Once it is used (locked/unlocked) + // libc::PTHREAD_RWLOCK_INITIALIZER. Once it is used (locked/unlocked) // or pthread_rwlock_init() is called, this behaviour no longer occurs. if cfg!(target_os = "dragonfly") { debug_assert!(r == 0 || r == libc::EINVAL); diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index f5fd11b61b1..9a7f98d24cd 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -34,6 +34,8 @@ impl Drop for Handler { #[cfg(any(target_os = "linux", target_os = "macos", target_os = "bitrig", + target_os = "dragonfly", + target_os = "freebsd", all(target_os = "netbsd", not(target_vendor = "rumprun")), target_os = "openbsd"))] mod imp { @@ -41,11 +43,11 @@ mod imp { use sys_common::util::report_overflow; use mem; use ptr; - use sys::c::{siginfo, sigaction, SIGBUS, SIG_DFL, - SA_SIGINFO, SA_ONSTACK, sigaltstack, - SIGSTKSZ, sighandler_t}; + use libc::{sigaction, SIGBUS, SIG_DFL, + SA_SIGINFO, SA_ONSTACK, sigaltstack, + SIGSTKSZ, sighandler_t}; use libc; - use libc::funcs::posix88::mman::{mmap, munmap}; + use libc::{mmap, munmap}; use libc::{SIGSEGV, PROT_READ, PROT_WRITE, MAP_PRIVATE, MAP_ANON}; use libc::MAP_FAILED; @@ -55,6 +57,22 @@ mod imp { // This is initialized in init() and only read from after static mut PAGE_SIZE: usize = 0; + #[cfg(any(target_os = "linux", target_os = "android"))] + unsafe fn siginfo_si_addr(info: *mut libc::siginfo_t) -> *mut libc::c_void { + #[repr(C)] + struct siginfo_t { + a: [libc::c_int; 3], // si_signo, si_code, si_errno, + si_addr: *mut libc::c_void, + } + + (*(info as *const siginfo_t)).si_addr + } + + #[cfg(not(any(target_os = "linux", target_os = "android")))] + unsafe fn siginfo_si_addr(info: *mut libc::siginfo_t) -> *mut libc::c_void { + (*info).si_addr + } + // Signal handler for the SIGSEGV and SIGBUS handlers. We've got guard pages // (unmapped pages) at the end of every thread's stack, so if a thread ends // up running into the guard page it'll trigger this handler. We want to @@ -74,10 +92,10 @@ mod imp { // handler to work. For a more detailed explanation see the comments on // #26458. unsafe extern fn signal_handler(signum: libc::c_int, - info: *mut siginfo, + info: *mut libc::siginfo_t, _data: *mut libc::c_void) { let guard = thread_info::stack_guard().unwrap_or(0); - let addr = (*info).si_addr as usize; + let addr = siginfo_si_addr(info) as usize; // If the faulting address is within the guard page, then we print a // message saying so. @@ -124,7 +142,7 @@ mod imp { panic!("failed to allocate an alternative stack"); } - let mut stack: sigaltstack = mem::zeroed(); + let mut stack: libc::stack_t = mem::zeroed(); stack.ss_sp = alt_stack; stack.ss_flags = 0; @@ -143,6 +161,8 @@ mod imp { #[cfg(not(any(target_os = "linux", target_os = "macos", target_os = "bitrig", + target_os = "dragonfly", + target_os = "freebsd", all(target_os = "netbsd", not(target_vendor = "rumprun")), target_os = "openbsd")))] mod imp { diff --git a/src/libstd/sys/unix/sync.rs b/src/libstd/sys/unix/sync.rs deleted file mode 100644 index 954bfbb6b18..00000000000 --- a/src/libstd/sys/unix/sync.rs +++ /dev/null @@ -1,315 +0,0 @@ -// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -#![allow(bad_style)] - -use libc; - -pub use self::os::{PTHREAD_MUTEX_INITIALIZER, PTHREAD_MUTEX_RECURSIVE, pthread_mutex_t, - pthread_mutexattr_t}; -pub use self::os::{PTHREAD_COND_INITIALIZER, pthread_cond_t}; -pub use self::os::{PTHREAD_RWLOCK_INITIALIZER, pthread_rwlock_t}; - -extern { - // mutexes - pub fn pthread_mutex_init(lock: *mut pthread_mutex_t, attr: *const pthread_mutexattr_t) - -> libc::c_int; - pub fn pthread_mutex_destroy(lock: *mut pthread_mutex_t) -> libc::c_int; - pub fn pthread_mutex_lock(lock: *mut pthread_mutex_t) -> libc::c_int; - pub fn pthread_mutex_trylock(lock: *mut pthread_mutex_t) -> libc::c_int; - pub fn pthread_mutex_unlock(lock: *mut pthread_mutex_t) -> libc::c_int; - - pub fn pthread_mutexattr_init(attr: *mut pthread_mutexattr_t) -> libc::c_int; - pub fn pthread_mutexattr_destroy(attr: *mut pthread_mutexattr_t) -> libc::c_int; - pub fn pthread_mutexattr_settype(attr: *mut pthread_mutexattr_t, _type: libc::c_int) - -> libc::c_int; - - // cvars - pub fn pthread_cond_wait(cond: *mut pthread_cond_t, - lock: *mut pthread_mutex_t) -> libc::c_int; - pub fn pthread_cond_timedwait(cond: *mut pthread_cond_t, - lock: *mut pthread_mutex_t, - abstime: *const libc::timespec) -> libc::c_int; - pub fn pthread_cond_signal(cond: *mut pthread_cond_t) -> libc::c_int; - pub fn pthread_cond_broadcast(cond: *mut pthread_cond_t) -> libc::c_int; - pub fn pthread_cond_destroy(cond: *mut pthread_cond_t) -> libc::c_int; - #[cfg_attr(target_os = "netbsd", link_name = "__gettimeofday50")] - pub fn gettimeofday(tp: *mut libc::timeval, - tz: *mut libc::c_void) -> libc::c_int; - - // rwlocks - pub fn pthread_rwlock_destroy(lock: *mut pthread_rwlock_t) -> libc::c_int; - pub fn pthread_rwlock_rdlock(lock: *mut pthread_rwlock_t) -> libc::c_int; - pub fn pthread_rwlock_tryrdlock(lock: *mut pthread_rwlock_t) -> libc::c_int; - pub fn pthread_rwlock_wrlock(lock: *mut pthread_rwlock_t) -> libc::c_int; - pub fn pthread_rwlock_trywrlock(lock: *mut pthread_rwlock_t) -> libc::c_int; - pub fn pthread_rwlock_unlock(lock: *mut pthread_rwlock_t) -> libc::c_int; -} - -#[cfg(any(target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "openbsd"))] -mod os { - use libc; - use ptr; - - pub type pthread_mutex_t = *mut libc::c_void; - pub type pthread_mutexattr_t = *mut libc::c_void; - pub type pthread_cond_t = *mut libc::c_void; - pub type pthread_rwlock_t = *mut libc::c_void; - - pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = ptr::null_mut(); - pub const PTHREAD_COND_INITIALIZER: pthread_cond_t = ptr::null_mut(); - pub const PTHREAD_RWLOCK_INITIALIZER: pthread_rwlock_t = ptr::null_mut(); - pub const PTHREAD_MUTEX_RECURSIVE: libc::c_int = 2; -} - -#[cfg(any(target_os = "macos", target_os = "ios"))] -mod os { - use libc; - - #[cfg(any(target_arch = "x86_64", - target_arch = "aarch64"))] - const __PTHREAD_MUTEX_SIZE__: usize = 56; - #[cfg(any(target_arch = "x86", - target_arch = "arm"))] - const __PTHREAD_MUTEX_SIZE__: usize = 40; - - #[cfg(any(target_arch = "x86_64", - target_arch = "aarch64"))] - const __PTHREAD_COND_SIZE__: usize = 40; - #[cfg(any(target_arch = "x86", - target_arch = "arm"))] - const __PTHREAD_COND_SIZE__: usize = 24; - - #[cfg(any(target_arch = "x86_64", - target_arch = "aarch64"))] - const __PTHREAD_RWLOCK_SIZE__: usize = 192; - #[cfg(any(target_arch = "x86", - target_arch = "arm"))] - const __PTHREAD_RWLOCK_SIZE__: usize = 124; - - const _PTHREAD_MUTEX_SIG_INIT: libc::c_long = 0x32AAABA7; - const _PTHREAD_COND_SIG_INIT: libc::c_long = 0x3CB0B1BB; - const _PTHREAD_RWLOCK_SIG_INIT: libc::c_long = 0x2DA8B3B4; - - #[repr(C)] - pub struct pthread_mutex_t { - __sig: libc::c_long, - __opaque: [u8; __PTHREAD_MUTEX_SIZE__], - } - #[repr(C)] - pub struct pthread_mutexattr_t { - __sig: libc::c_long, - // note, that this is 16 bytes just to be safe, the actual struct might be smaller. - __opaque: [u8; 16], - } - #[repr(C)] - pub struct pthread_cond_t { - __sig: libc::c_long, - __opaque: [u8; __PTHREAD_COND_SIZE__], - } - #[repr(C)] - pub struct pthread_rwlock_t { - __sig: libc::c_long, - __opaque: [u8; __PTHREAD_RWLOCK_SIZE__], - } - - pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t { - __sig: _PTHREAD_MUTEX_SIG_INIT, - __opaque: [0; __PTHREAD_MUTEX_SIZE__], - }; - pub const PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t { - __sig: _PTHREAD_COND_SIG_INIT, - __opaque: [0; __PTHREAD_COND_SIZE__], - }; - pub const PTHREAD_RWLOCK_INITIALIZER: pthread_rwlock_t = pthread_rwlock_t { - __sig: _PTHREAD_RWLOCK_SIG_INIT, - __opaque: [0; __PTHREAD_RWLOCK_SIZE__], - }; - - pub const PTHREAD_MUTEX_RECURSIVE: libc::c_int = 2; -} - -#[cfg(target_os = "linux")] -mod os { - use libc; - - // minus 8 because we have an 'align' field - #[cfg(target_arch = "x86_64")] - const __SIZEOF_PTHREAD_MUTEX_T: usize = 40 - 8; - #[cfg(any(target_arch = "x86", - target_arch = "arm", - target_arch = "mips", - target_arch = "mipsel", - target_arch = "powerpc"))] - const __SIZEOF_PTHREAD_MUTEX_T: usize = 24 - 8; - #[cfg(target_arch = "aarch64")] - const __SIZEOF_PTHREAD_MUTEX_T: usize = 48 - 8; - - #[cfg(any(target_arch = "x86_64", - target_arch = "x86", - target_arch = "arm", - target_arch = "aarch64", - target_arch = "mips", - target_arch = "mipsel", - target_arch = "powerpc"))] - const __SIZEOF_PTHREAD_COND_T: usize = 48 - 8; - - #[cfg(any(target_arch = "x86_64", - target_arch = "aarch64"))] - const __SIZEOF_PTHREAD_RWLOCK_T: usize = 56 - 8; - - #[cfg(any(target_arch = "x86", - target_arch = "arm", - target_arch = "mips", - target_arch = "mipsel", - target_arch = "powerpc"))] - const __SIZEOF_PTHREAD_RWLOCK_T: usize = 32 - 8; - - #[repr(C)] - pub struct pthread_mutex_t { - __align: libc::c_longlong, - size: [u8; __SIZEOF_PTHREAD_MUTEX_T], - } - #[repr(C)] - pub struct pthread_mutexattr_t { - __align: libc::c_longlong, - // note, that this is 16 bytes just to be safe, the actual struct might be smaller. - size: [u8; 16], - } - #[repr(C)] - pub struct pthread_cond_t { - __align: libc::c_longlong, - size: [u8; __SIZEOF_PTHREAD_COND_T], - } - #[repr(C)] - pub struct pthread_rwlock_t { - __align: libc::c_longlong, - size: [u8; __SIZEOF_PTHREAD_RWLOCK_T], - } - - pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t { - __align: 0, - size: [0; __SIZEOF_PTHREAD_MUTEX_T], - }; - pub const PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t { - __align: 0, - size: [0; __SIZEOF_PTHREAD_COND_T], - }; - pub const PTHREAD_RWLOCK_INITIALIZER: pthread_rwlock_t = pthread_rwlock_t { - __align: 0, - size: [0; __SIZEOF_PTHREAD_RWLOCK_T], - }; - pub const PTHREAD_MUTEX_RECURSIVE: libc::c_int = 1; -} -#[cfg(target_os = "android")] -mod os { - use libc; - use ptr; - - #[repr(C)] - pub struct pthread_mutex_t { value: libc::c_int } - pub type pthread_mutexattr_t = libc::c_long; - #[repr(C)] - pub struct pthread_cond_t { value: libc::c_int } - #[repr(C)] - pub struct pthread_rwlock_t { - lock: pthread_mutex_t, - cond: pthread_cond_t, - numLocks: libc::c_int, - writerThreadId: libc::c_int, - pendingReaders: libc::c_int, - pendingWriters: libc::c_int, - reserved: [*mut libc::c_void; 4], - } - - pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t { - value: 0, - }; - pub const PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t { - value: 0, - }; - pub const PTHREAD_RWLOCK_INITIALIZER: pthread_rwlock_t = pthread_rwlock_t { - lock: PTHREAD_MUTEX_INITIALIZER, - cond: PTHREAD_COND_INITIALIZER, - numLocks: 0, - writerThreadId: 0, - pendingReaders: 0, - pendingWriters: 0, - reserved: [ptr::null_mut(); 4], - }; - pub const PTHREAD_MUTEX_RECURSIVE: libc::c_int = 1; -} - -#[cfg(target_os = "netbsd")] -mod os { - use libc; - - // size of the type minus width of the magic and alignment field - #[cfg(target_arch = "x86_64")] - const __PTHREAD_MUTEX_SIZE__: usize = 48 - 4 - 8; - - #[cfg(target_arch = "x86_64")] - const __PTHREAD_MUTEXATTR_SIZE__: usize = 16 - 8; // no magic field - - #[cfg(target_arch = "x86_64")] - const __PTHREAD_COND_SIZE__: usize = 40 - 4 - 8; - - #[cfg(target_arch = "x86_64")] - const __PTHREAD_RWLOCK_SIZE__: usize = 64 - 4 - 8; - - const _PTHREAD_MUTEX_MAGIC_INIT: libc::c_uint = 0x33330003; - const _PTHREAD_COND_MAGIC_INIT: libc::c_uint = 0x55550005; - const _PTHREAD_RWLOCK_MAGIC_INIT: libc::c_uint = 0x99990009; - - #[repr(C)] - pub struct pthread_mutex_t { - __magic: libc::c_uint, - __opaque: [u8; __PTHREAD_MUTEX_SIZE__], - __align: libc::c_longlong, - } - #[repr(C)] - pub struct pthread_mutexattr_t { - __opaque: [u8; __PTHREAD_MUTEXATTR_SIZE__], - __align: libc::c_longlong, - } - #[repr(C)] - pub struct pthread_cond_t { - __magic: libc::c_uint, - __opaque: [u8; __PTHREAD_COND_SIZE__], - __align: libc::c_longlong, - } - #[repr(C)] - pub struct pthread_rwlock_t { - __magic: libc::c_uint, - __opaque: [u8; __PTHREAD_RWLOCK_SIZE__], - __align: libc::c_longlong, - } - - pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t { - __magic: _PTHREAD_MUTEX_MAGIC_INIT, - __opaque: [0; __PTHREAD_MUTEX_SIZE__], - __align: 0, - }; - pub const PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t { - __magic: _PTHREAD_COND_MAGIC_INIT, - __opaque: [0; __PTHREAD_COND_SIZE__], - __align: 0, - }; - pub const PTHREAD_RWLOCK_INITIALIZER: pthread_rwlock_t = pthread_rwlock_t { - __magic: _PTHREAD_RWLOCK_MAGIC_INIT, - __opaque: [0; __PTHREAD_RWLOCK_SIZE__], - __align: 0, - }; - - pub const PTHREAD_MUTEX_RECURSIVE: libc::c_int = 2; -} diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs index b7968e9344f..f111f97be60 100644 --- a/src/libstd/sys/unix/thread.rs +++ b/src/libstd/sys/unix/thread.rs @@ -14,9 +14,10 @@ use prelude::v1::*; use alloc::boxed::FnBox; use cmp; +#[cfg(not(target_env = "newlib"))] use ffi::CString; use io; -use libc::consts::os::posix01::PTHREAD_STACK_MIN; +use libc::PTHREAD_STACK_MIN; use libc; use mem; use ptr; @@ -40,10 +41,11 @@ impl Thread { let p = box p; let mut native: libc::pthread_t = mem::zeroed(); let mut attr: libc::pthread_attr_t = mem::zeroed(); - assert_eq!(pthread_attr_init(&mut attr), 0); + assert_eq!(libc::pthread_attr_init(&mut attr), 0); let stack_size = cmp::max(stack, min_stack_size(&attr)); - match pthread_attr_setstacksize(&mut attr, stack_size as libc::size_t) { + match libc::pthread_attr_setstacksize(&mut attr, + stack_size as libc::size_t) { 0 => {} n => { assert_eq!(n, libc::EINVAL); @@ -55,13 +57,14 @@ impl Thread { let stack_size = (stack_size + page_size - 1) & (-(page_size as isize - 1) as usize - 1); let stack_size = stack_size as libc::size_t; - assert_eq!(pthread_attr_setstacksize(&mut attr, stack_size), 0); + assert_eq!(libc::pthread_attr_setstacksize(&mut attr, + stack_size), 0); } }; - let ret = pthread_create(&mut native, &attr, thread_start, - &*p as *const _ as *mut _); - assert_eq!(pthread_attr_destroy(&mut attr), 0); + let ret = libc::pthread_create(&mut native, &attr, thread_start, + &*p as *const _ as *mut _); + assert_eq!(libc::pthread_attr_destroy(&mut attr), 0); return if ret != 0 { Err(io::Error::from_raw_os_error(ret)) @@ -77,25 +80,20 @@ impl Thread { } pub fn yield_now() { - let ret = unsafe { sched_yield() }; + let ret = unsafe { libc::sched_yield() }; debug_assert_eq!(ret, 0); } #[cfg(any(target_os = "linux", target_os = "android"))] pub fn set_name(name: &str) { - // pthread wrapper only appeared in glibc 2.12, so we use syscall - // directly. - extern { - fn prctl(option: libc::c_int, arg2: libc::c_ulong, - arg3: libc::c_ulong, arg4: libc::c_ulong, - arg5: libc::c_ulong) -> libc::c_int; - } const PR_SET_NAME: libc::c_int = 15; let cname = CString::new(name).unwrap_or_else(|_| { panic!("thread name may not contain interior null bytes") }); + // pthread wrapper only appeared in glibc 2.12, so we use syscall + // directly. unsafe { - prctl(PR_SET_NAME, cname.as_ptr() as libc::c_ulong, 0, 0, 0); + libc::prctl(PR_SET_NAME, cname.as_ptr() as libc::c_ulong, 0, 0, 0); } } @@ -104,41 +102,33 @@ impl Thread { target_os = "bitrig", target_os = "openbsd"))] pub fn set_name(name: &str) { - extern { - fn pthread_set_name_np(tid: libc::pthread_t, - name: *const libc::c_char); - } let cname = CString::new(name).unwrap(); unsafe { - pthread_set_name_np(pthread_self(), cname.as_ptr()); + libc::pthread_set_name_np(libc::pthread_self(), cname.as_ptr()); } } #[cfg(any(target_os = "macos", target_os = "ios"))] pub fn set_name(name: &str) { - extern { - fn pthread_setname_np(name: *const libc::c_char) -> libc::c_int; - } let cname = CString::new(name).unwrap(); unsafe { - pthread_setname_np(cname.as_ptr()); + libc::pthread_setname_np(cname.as_ptr()); } } #[cfg(target_os = "netbsd")] pub fn set_name(name: &str) { - extern { - fn pthread_setname_np(thread: libc::pthread_t, - name: *const libc::c_char, - arg: *mut libc::c_void) -> libc::c_int; - } let cname = CString::new(&b"%s"[..]).unwrap(); let carg = CString::new(name).unwrap(); unsafe { - pthread_setname_np(pthread_self(), cname.as_ptr(), - carg.as_ptr() as *mut libc::c_void); + libc::pthread_setname_np(libc::pthread_self(), cname.as_ptr(), + carg.as_ptr() as *mut libc::c_void); } } + #[cfg(target_env = "newlib")] + pub unsafe fn set_name(_name: &str) { + // Newlib has no way to set a thread name. + } pub fn sleep(dur: Duration) { let mut ts = libc::timespec { @@ -157,7 +147,7 @@ impl Thread { pub fn join(self) { unsafe { - let ret = pthread_join(self.id, ptr::null_mut()); + let ret = libc::pthread_join(self.id, ptr::null_mut()); mem::forget(self); debug_assert_eq!(ret, 0); } @@ -166,7 +156,7 @@ impl Thread { impl Drop for Thread { fn drop(&mut self) { - let ret = unsafe { pthread_detach(self.id) }; + let ret = unsafe { libc::pthread_detach(self.id) }; debug_assert_eq!(ret, 0); } } @@ -192,15 +182,10 @@ pub mod guard { use prelude::v1::*; use libc::{self, pthread_t}; - use libc::funcs::posix88::mman::mmap; - use libc::consts::os::posix88::{PROT_NONE, - MAP_PRIVATE, - MAP_ANON, - MAP_FAILED, - MAP_FIXED}; + use libc::mmap; + use libc::{PROT_NONE, MAP_PRIVATE, MAP_ANON, MAP_FAILED, MAP_FIXED}; use mem; use ptr; - use super::{pthread_self, pthread_attr_destroy}; use sys::os; #[cfg(any(target_os = "macos", @@ -212,19 +197,17 @@ pub mod guard { #[cfg(any(target_os = "linux", target_os = "android", target_os = "netbsd"))] unsafe fn get_stack_start() -> Option<*mut libc::c_void> { - use super::pthread_attr_init; - let mut ret = None; let mut attr: libc::pthread_attr_t = mem::zeroed(); - assert_eq!(pthread_attr_init(&mut attr), 0); - if pthread_getattr_np(pthread_self(), &mut attr) == 0 { + assert_eq!(libc::pthread_attr_init(&mut attr), 0); + if libc::pthread_getattr_np(libc::pthread_self(), &mut attr) == 0 { let mut stackaddr = ptr::null_mut(); let mut stacksize = 0; - assert_eq!(pthread_attr_getstack(&attr, &mut stackaddr, - &mut stacksize), 0); + assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, + &mut stacksize), 0); ret = Some(stackaddr); } - assert_eq!(pthread_attr_destroy(&mut attr), 0); + assert_eq!(libc::pthread_attr_destroy(&mut attr), 0); ret } @@ -268,33 +251,18 @@ pub mod guard { #[cfg(target_os = "macos")] pub unsafe fn current() -> Option<usize> { - extern { - fn pthread_get_stackaddr_np(thread: pthread_t) -> *mut libc::c_void; - fn pthread_get_stacksize_np(thread: pthread_t) -> libc::size_t; - } - Some((pthread_get_stackaddr_np(pthread_self()) as libc::size_t - - pthread_get_stacksize_np(pthread_self())) as usize) + Some((libc::pthread_get_stackaddr_np(libc::pthread_self()) as libc::size_t - + libc::pthread_get_stacksize_np(libc::pthread_self())) as usize) } #[cfg(any(target_os = "openbsd", target_os = "bitrig"))] pub unsafe fn current() -> Option<usize> { - #[repr(C)] - struct stack_t { - ss_sp: *mut libc::c_void, - ss_size: libc::size_t, - ss_flags: libc::c_int, - } - extern { - fn pthread_main_np() -> libc::c_uint; - fn pthread_stackseg_np(thread: pthread_t, - sinfo: *mut stack_t) -> libc::c_uint; - } - - let mut current_stack: stack_t = mem::zeroed(); - assert_eq!(pthread_stackseg_np(pthread_self(), &mut current_stack), 0); + let mut current_stack: libc::stack_t = mem::zeroed(); + assert_eq!(libc::pthread_stackseg_np(libc::pthread_self(), + &mut current_stack), 0); let extra = if cfg!(target_os = "bitrig") {3} else {1} * os::page_size(); - Some(if pthread_main_np() == 1 { + Some(if libc::pthread_main_np() == 1 { // main thread current_stack.ss_sp as usize - current_stack.ss_size as usize + extra } else { @@ -305,20 +273,19 @@ pub mod guard { #[cfg(any(target_os = "linux", target_os = "android", target_os = "netbsd"))] pub unsafe fn current() -> Option<usize> { - use super::pthread_attr_init; - let mut ret = None; let mut attr: libc::pthread_attr_t = mem::zeroed(); - assert_eq!(pthread_attr_init(&mut attr), 0); - if pthread_getattr_np(pthread_self(), &mut attr) == 0 { + assert_eq!(libc::pthread_attr_init(&mut attr), 0); + if libc::pthread_getattr_np(libc::pthread_self(), &mut attr) == 0 { let mut guardsize = 0; - assert_eq!(pthread_attr_getguardsize(&attr, &mut guardsize), 0); + assert_eq!(libc::pthread_attr_getguardsize(&attr, &mut guardsize), 0); if guardsize == 0 { panic!("there is no guard page"); } let mut stackaddr = ptr::null_mut(); let mut size = 0; - assert_eq!(pthread_attr_getstack(&attr, &mut stackaddr, &mut size), 0); + assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, + &mut size), 0); ret = if cfg!(target_os = "netbsd") { Some(stackaddr as usize) @@ -326,20 +293,9 @@ pub mod guard { Some(stackaddr as usize + guardsize as usize) }; } - assert_eq!(pthread_attr_destroy(&mut attr), 0); + assert_eq!(libc::pthread_attr_destroy(&mut attr), 0); ret } - - #[cfg(any(target_os = "linux", target_os = "android", target_os = "netbsd"))] - extern { - fn pthread_getattr_np(native: libc::pthread_t, - attr: *mut libc::pthread_attr_t) -> libc::c_int; - fn pthread_attr_getguardsize(attr: *const libc::pthread_attr_t, - guardsize: *mut libc::size_t) -> libc::c_int; - fn pthread_attr_getstack(attr: *const libc::pthread_attr_t, - stackaddr: *mut *mut libc::c_void, - stacksize: *mut libc::size_t) -> libc::c_int; - } } // glibc >= 2.15 has a __pthread_get_minstack() function that returns @@ -389,21 +345,3 @@ fn min_stack_size(attr: *const libc::pthread_attr_t) -> usize { fn min_stack_size(_: *const libc::pthread_attr_t) -> usize { PTHREAD_STACK_MIN as usize } - -extern { - fn pthread_self() -> libc::pthread_t; - fn pthread_create(native: *mut libc::pthread_t, - attr: *const libc::pthread_attr_t, - f: extern fn(*mut libc::c_void) -> *mut libc::c_void, - value: *mut libc::c_void) -> libc::c_int; - fn pthread_join(native: libc::pthread_t, - value: *mut *mut libc::c_void) -> libc::c_int; - fn pthread_attr_init(attr: *mut libc::pthread_attr_t) -> libc::c_int; - fn pthread_attr_destroy(attr: *mut libc::pthread_attr_t) -> libc::c_int; - fn pthread_attr_setstacksize(attr: *mut libc::pthread_attr_t, - stack_size: libc::size_t) -> libc::c_int; - fn pthread_attr_setdetachstate(attr: *mut libc::pthread_attr_t, - state: libc::c_int) -> libc::c_int; - fn pthread_detach(thread: libc::pthread_t) -> libc::c_int; - fn sched_yield() -> libc::c_int; -} diff --git a/src/libstd/sys/unix/thread_local.rs b/src/libstd/sys/unix/thread_local.rs index e697417675d..d22118d4d79 100644 --- a/src/libstd/sys/unix/thread_local.rs +++ b/src/libstd/sys/unix/thread_local.rs @@ -8,60 +8,33 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -#![allow(dead_code)] // sys isn't exported yet +#![allow(dead_code)] // not used on all platforms -use libc::c_int; +use mem; +use libc; -pub type Key = pthread_key_t; +pub type Key = libc::pthread_key_t; #[inline] pub unsafe fn create(dtor: Option<unsafe extern fn(*mut u8)>) -> Key { let mut key = 0; - assert_eq!(pthread_key_create(&mut key, dtor), 0); + assert_eq!(libc::pthread_key_create(&mut key, mem::transmute(dtor)), 0); key } #[inline] pub unsafe fn set(key: Key, value: *mut u8) { - let r = pthread_setspecific(key, value); + let r = libc::pthread_setspecific(key, value as *mut _); debug_assert_eq!(r, 0); } #[inline] pub unsafe fn get(key: Key) -> *mut u8 { - pthread_getspecific(key) + libc::pthread_getspecific(key) as *mut u8 } #[inline] pub unsafe fn destroy(key: Key) { - let r = pthread_key_delete(key); + let r = libc::pthread_key_delete(key); debug_assert_eq!(r, 0); } - -#[cfg(any(target_os = "macos", - target_os = "ios"))] -type pthread_key_t = ::libc::c_ulong; - -#[cfg(any(target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "netbsd", - target_os = "openbsd"))] -type pthread_key_t = ::libc::c_int; - -#[cfg(not(any(target_os = "macos", - target_os = "ios", - target_os = "freebsd", - target_os = "dragonfly", - target_os = "bitrig", - target_os = "netbsd", - target_os = "openbsd")))] -type pthread_key_t = ::libc::c_uint; - -extern { - fn pthread_key_create(key: *mut pthread_key_t, - dtor: Option<unsafe extern fn(*mut u8)>) -> c_int; - fn pthread_key_delete(key: pthread_key_t) -> c_int; - fn pthread_getspecific(key: pthread_key_t) -> *mut u8; - fn pthread_setspecific(key: pthread_key_t, value: *mut u8) -> c_int; -} diff --git a/src/libstd/sys/unix/time.rs b/src/libstd/sys/unix/time.rs index 73b66877588..5192f01269d 100644 --- a/src/libstd/sys/unix/time.rs +++ b/src/libstd/sys/unix/time.rs @@ -24,15 +24,10 @@ mod inner { t: u64 } - extern { - pub fn mach_absolute_time() -> u64; - pub fn mach_timebase_info(info: *mut libc::mach_timebase_info) -> libc::c_int; - } - impl SteadyTime { pub fn now() -> SteadyTime { SteadyTime { - t: unsafe { mach_absolute_time() }, + t: unsafe { libc::mach_absolute_time() }, } } } @@ -46,7 +41,7 @@ mod inner { unsafe { ONCE.call_once(|| { - mach_timebase_info(&mut INFO); + libc::mach_timebase_info(&mut INFO); }); &INFO } @@ -77,21 +72,16 @@ mod inner { // Apparently android provides this in some other library? // Bitrig's RT extensions are in the C library, not a separate librt - // OpenBSD provide it via libc + // OpenBSD and NaCl provide it via libc #[cfg(not(any(target_os = "android", target_os = "bitrig", target_os = "netbsd", target_os = "openbsd", - target_env = "musl")))] + target_env = "musl", + target_os = "nacl")))] #[link(name = "rt")] extern {} - - extern { - #[cfg_attr(target_os = "netbsd", link_name = "__clock_gettime50")] - fn clock_gettime(clk_id: libc::c_int, tp: *mut libc::timespec) -> libc::c_int; - } - impl SteadyTime { pub fn now() -> SteadyTime { let mut t = SteadyTime { @@ -101,7 +91,8 @@ mod inner { } }; unsafe { - assert_eq!(0, clock_gettime(libc::CLOCK_MONOTONIC, &mut t.t)); + assert_eq!(0, libc::clock_gettime(libc::CLOCK_MONOTONIC, + &mut t.t)); } t } diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs index b562e772b9c..d106bc3285c 100644 --- a/src/libstd/sys/windows/backtrace.rs +++ b/src/libstd/sys/windows/backtrace.rs @@ -27,12 +27,13 @@ use io::prelude::*; use dynamic_lib::DynamicLibrary; -use intrinsics; use io; -use libc; +use libc::c_void; +use mem; use path::Path; use ptr; use sync::StaticMutex; +use sys::c; macro_rules! sym{ ($lib:expr, $e:expr, $t:ident) => (unsafe { let lib = $lib; @@ -50,264 +51,50 @@ mod printing; #[path = "printing/gnu.rs"] mod printing; -#[allow(non_snake_case)] -extern "system" { - fn GetCurrentProcess() -> libc::HANDLE; - fn GetCurrentThread() -> libc::HANDLE; - fn RtlCaptureContext(ctx: *mut arch::CONTEXT); -} - type SymFromAddrFn = - extern "system" fn(libc::HANDLE, u64, *mut u64, - *mut SYMBOL_INFO) -> libc::BOOL; + extern "system" fn(c::HANDLE, u64, *mut u64, + *mut c::SYMBOL_INFO) -> c::BOOL; type SymGetLineFromAddr64Fn = - extern "system" fn(libc::HANDLE, u64, *mut u32, - *mut IMAGEHLP_LINE64) -> libc::BOOL; + extern "system" fn(c::HANDLE, u64, *mut u32, + *mut c::IMAGEHLP_LINE64) -> c::BOOL; type SymInitializeFn = - extern "system" fn(libc::HANDLE, *mut libc::c_void, - libc::BOOL) -> libc::BOOL; + extern "system" fn(c::HANDLE, *mut c_void, + c::BOOL) -> c::BOOL; type SymCleanupFn = - extern "system" fn(libc::HANDLE) -> libc::BOOL; + extern "system" fn(c::HANDLE) -> c::BOOL; type StackWalk64Fn = - extern "system" fn(libc::DWORD, libc::HANDLE, libc::HANDLE, - *mut STACKFRAME64, *mut arch::CONTEXT, - *mut libc::c_void, *mut libc::c_void, - *mut libc::c_void, *mut libc::c_void) -> libc::BOOL; - -const MAX_SYM_NAME: usize = 2000; -const IMAGE_FILE_MACHINE_I386: libc::DWORD = 0x014c; -const IMAGE_FILE_MACHINE_IA64: libc::DWORD = 0x0200; -const IMAGE_FILE_MACHINE_AMD64: libc::DWORD = 0x8664; - -#[repr(C)] -struct SYMBOL_INFO { - SizeOfStruct: libc::c_ulong, - TypeIndex: libc::c_ulong, - Reserved: [u64; 2], - Index: libc::c_ulong, - Size: libc::c_ulong, - ModBase: u64, - Flags: libc::c_ulong, - Value: u64, - Address: u64, - Register: libc::c_ulong, - Scope: libc::c_ulong, - Tag: libc::c_ulong, - NameLen: libc::c_ulong, - MaxNameLen: libc::c_ulong, - // note that windows has this as 1, but it basically just means that - // the name is inline at the end of the struct. For us, we just bump - // the struct size up to MAX_SYM_NAME. - Name: [libc::c_char; MAX_SYM_NAME], -} - -#[repr(C)] -struct IMAGEHLP_LINE64 { - SizeOfStruct: u32, - Key: *const libc::c_void, - LineNumber: u32, - Filename: *const libc::c_char, - Address: u64, -} - -#[repr(C)] -enum ADDRESS_MODE { - AddrMode1616, - AddrMode1632, - AddrModeReal, - AddrModeFlat, -} - -struct ADDRESS64 { - Offset: u64, - Segment: u16, - Mode: ADDRESS_MODE, -} - -pub struct STACKFRAME64 { - AddrPC: ADDRESS64, - AddrReturn: ADDRESS64, - AddrFrame: ADDRESS64, - AddrStack: ADDRESS64, - AddrBStore: ADDRESS64, - FuncTableEntry: *mut libc::c_void, - Params: [u64; 4], - Far: libc::BOOL, - Virtual: libc::BOOL, - Reserved: [u64; 3], - KdHelp: KDHELP64, -} - -struct KDHELP64 { - Thread: u64, - ThCallbackStack: libc::DWORD, - ThCallbackBStore: libc::DWORD, - NextCallback: libc::DWORD, - FramePointer: libc::DWORD, - KiCallUserMode: u64, - KeUserCallbackDispatcher: u64, - SystemRangeStart: u64, - KiUserExceptionDispatcher: u64, - StackBase: u64, - StackLimit: u64, - Reserved: [u64; 5], -} + extern "system" fn(c::DWORD, c::HANDLE, c::HANDLE, + *mut c::STACKFRAME64, *mut c::CONTEXT, + *mut c_void, *mut c_void, + *mut c_void, *mut c_void) -> c::BOOL; #[cfg(target_arch = "x86")] -mod arch { - use libc; - - const MAXIMUM_SUPPORTED_EXTENSION: usize = 512; - - #[repr(C)] - pub struct CONTEXT { - ContextFlags: libc::DWORD, - Dr0: libc::DWORD, - Dr1: libc::DWORD, - Dr2: libc::DWORD, - Dr3: libc::DWORD, - Dr6: libc::DWORD, - Dr7: libc::DWORD, - FloatSave: FLOATING_SAVE_AREA, - SegGs: libc::DWORD, - SegFs: libc::DWORD, - SegEs: libc::DWORD, - SegDs: libc::DWORD, - Edi: libc::DWORD, - Esi: libc::DWORD, - Ebx: libc::DWORD, - Edx: libc::DWORD, - Ecx: libc::DWORD, - Eax: libc::DWORD, - Ebp: libc::DWORD, - Eip: libc::DWORD, - SegCs: libc::DWORD, - EFlags: libc::DWORD, - Esp: libc::DWORD, - SegSs: libc::DWORD, - ExtendedRegisters: [u8; MAXIMUM_SUPPORTED_EXTENSION], - } - - #[repr(C)] - pub struct FLOATING_SAVE_AREA { - ControlWord: libc::DWORD, - StatusWord: libc::DWORD, - TagWord: libc::DWORD, - ErrorOffset: libc::DWORD, - ErrorSelector: libc::DWORD, - DataOffset: libc::DWORD, - DataSelector: libc::DWORD, - RegisterArea: [u8; 80], - Cr0NpxState: libc::DWORD, - } - - pub fn init_frame(frame: &mut super::STACKFRAME64, - ctx: &CONTEXT) -> libc::DWORD { - frame.AddrPC.Offset = ctx.Eip as u64; - frame.AddrPC.Mode = super::ADDRESS_MODE::AddrModeFlat; - frame.AddrStack.Offset = ctx.Esp as u64; - frame.AddrStack.Mode = super::ADDRESS_MODE::AddrModeFlat; - frame.AddrFrame.Offset = ctx.Ebp as u64; - frame.AddrFrame.Mode = super::ADDRESS_MODE::AddrModeFlat; - super::IMAGE_FILE_MACHINE_I386 - } +pub fn init_frame(frame: &mut c::STACKFRAME64, + ctx: &c::CONTEXT) -> c::DWORD { + frame.AddrPC.Offset = ctx.Eip as u64; + frame.AddrPC.Mode = c::ADDRESS_MODE::AddrModeFlat; + frame.AddrStack.Offset = ctx.Esp as u64; + frame.AddrStack.Mode = c::ADDRESS_MODE::AddrModeFlat; + frame.AddrFrame.Offset = ctx.Ebp as u64; + frame.AddrFrame.Mode = c::ADDRESS_MODE::AddrModeFlat; + c::IMAGE_FILE_MACHINE_I386 } #[cfg(target_arch = "x86_64")] -mod arch { - #![allow(deprecated)] - - use libc::{c_longlong, c_ulonglong}; - use libc::types::os::arch::extra::{WORD, DWORD, DWORDLONG}; - use simd; - - #[repr(C)] - pub struct CONTEXT { - _align_hack: [simd::u64x2; 0], // FIXME align on 16-byte - P1Home: DWORDLONG, - P2Home: DWORDLONG, - P3Home: DWORDLONG, - P4Home: DWORDLONG, - P5Home: DWORDLONG, - P6Home: DWORDLONG, - - ContextFlags: DWORD, - MxCsr: DWORD, - - SegCs: WORD, - SegDs: WORD, - SegEs: WORD, - SegFs: WORD, - SegGs: WORD, - SegSs: WORD, - EFlags: DWORD, - - Dr0: DWORDLONG, - Dr1: DWORDLONG, - Dr2: DWORDLONG, - Dr3: DWORDLONG, - Dr6: DWORDLONG, - Dr7: DWORDLONG, - - Rax: DWORDLONG, - Rcx: DWORDLONG, - Rdx: DWORDLONG, - Rbx: DWORDLONG, - Rsp: DWORDLONG, - Rbp: DWORDLONG, - Rsi: DWORDLONG, - Rdi: DWORDLONG, - R8: DWORDLONG, - R9: DWORDLONG, - R10: DWORDLONG, - R11: DWORDLONG, - R12: DWORDLONG, - R13: DWORDLONG, - R14: DWORDLONG, - R15: DWORDLONG, - - Rip: DWORDLONG, - - FltSave: FLOATING_SAVE_AREA, - - VectorRegister: [M128A; 26], - VectorControl: DWORDLONG, - - DebugControl: DWORDLONG, - LastBranchToRip: DWORDLONG, - LastBranchFromRip: DWORDLONG, - LastExceptionToRip: DWORDLONG, - LastExceptionFromRip: DWORDLONG, - } - - #[repr(C)] - pub struct M128A { - _align_hack: [simd::u64x2; 0], // FIXME align on 16-byte - Low: c_ulonglong, - High: c_longlong - } - - #[repr(C)] - pub struct FLOATING_SAVE_AREA { - _align_hack: [simd::u64x2; 0], // FIXME align on 16-byte - _Dummy: [u8; 512] // FIXME: Fill this out - } - - pub fn init_frame(frame: &mut super::STACKFRAME64, - ctx: &CONTEXT) -> DWORD { - frame.AddrPC.Offset = ctx.Rip as u64; - frame.AddrPC.Mode = super::ADDRESS_MODE::AddrModeFlat; - frame.AddrStack.Offset = ctx.Rsp as u64; - frame.AddrStack.Mode = super::ADDRESS_MODE::AddrModeFlat; - frame.AddrFrame.Offset = ctx.Rbp as u64; - frame.AddrFrame.Mode = super::ADDRESS_MODE::AddrModeFlat; - super::IMAGE_FILE_MACHINE_AMD64 - } +pub fn init_frame(frame: &mut c::STACKFRAME64, + ctx: &c::CONTEXT) -> c::DWORD { + frame.AddrPC.Offset = ctx.Rip as u64; + frame.AddrPC.Mode = c::ADDRESS_MODE::AddrModeFlat; + frame.AddrStack.Offset = ctx.Rsp as u64; + frame.AddrStack.Mode = c::ADDRESS_MODE::AddrModeFlat; + frame.AddrFrame.Offset = ctx.Rbp as u64; + frame.AddrFrame.Mode = c::ADDRESS_MODE::AddrModeFlat; + c::IMAGE_FILE_MACHINE_AMD64 } struct Cleanup { - handle: libc::HANDLE, + handle: c::HANDLE, SymCleanup: SymCleanupFn, } @@ -335,16 +122,16 @@ pub fn write(w: &mut Write) -> io::Result<()> { let StackWalk64 = sym!(&dbghelp, "StackWalk64", StackWalk64Fn); // Allocate necessary structures for doing the stack walk - let process = unsafe { GetCurrentProcess() }; - let thread = unsafe { GetCurrentThread() }; - let mut context: arch::CONTEXT = unsafe { intrinsics::init() }; - unsafe { RtlCaptureContext(&mut context); } - let mut frame: STACKFRAME64 = unsafe { intrinsics::init() }; - let image = arch::init_frame(&mut frame, &context); + let process = unsafe { c::GetCurrentProcess() }; + let thread = unsafe { c::GetCurrentThread() }; + let mut context: c::CONTEXT = unsafe { mem::zeroed() }; + unsafe { c::RtlCaptureContext(&mut context); } + let mut frame: c::STACKFRAME64 = unsafe { mem::zeroed() }; + let image = init_frame(&mut frame, &context); // Initialize this process's symbols - let ret = SymInitialize(process, ptr::null_mut(), libc::TRUE); - if ret != libc::TRUE { return Ok(()) } + let ret = SymInitialize(process, ptr::null_mut(), c::TRUE); + if ret != c::TRUE { return Ok(()) } let _c = Cleanup { handle: process, SymCleanup: SymCleanup }; // And now that we're done with all the setup, do the stack walking! @@ -356,7 +143,7 @@ pub fn write(w: &mut Write) -> io::Result<()> { ptr::null_mut(), ptr::null_mut(), ptr::null_mut(), - ptr::null_mut()) == libc::TRUE{ + ptr::null_mut()) == c::TRUE { let addr = frame.AddrPC.Offset; if addr == frame.AddrReturn.Offset || addr == 0 || frame.AddrReturn.Offset == 0 { break } diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index a9eb4db2f53..42f182eb010 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -10,86 +10,336 @@ //! C definitions used by libnative that don't belong in liblibc -#![allow(bad_style, dead_code, overflowing_literals)] +#![allow(bad_style, overflowing_literals, dead_code, deprecated, unused_imports)] -use libc; -use libc::{c_uint, c_ulong}; -use libc::{DWORD, BOOL, BOOLEAN, ERROR_CALL_NOT_IMPLEMENTED, LPVOID, HANDLE}; -use libc::{LPCWSTR, LONG}; +use os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort}; +use os::raw::{c_char, c_short, c_ulonglong}; +use libc::{wchar_t, size_t, c_void}; use ptr; +use simd; pub use self::GET_FILEEX_INFO_LEVELS::*; pub use self::FILE_INFO_BY_HANDLE_CLASS::*; -pub use libc::consts::os::extra::{ - FILE_ATTRIBUTE_READONLY, - FILE_ATTRIBUTE_DIRECTORY, - WSAPROTOCOL_LEN, -}; -pub use libc::types::os::arch::extra::{GROUP, GUID, WSAPROTOCOLCHAIN}; +pub use self::EXCEPTION_DISPOSITION::*; -pub const WSADESCRIPTION_LEN: usize = 256; -pub const WSASYS_STATUS_LEN: usize = 128; -pub const FIONBIO: libc::c_long = 0x8004667e; +pub type DWORD = c_ulong; +pub type HANDLE = LPVOID; +pub type HINSTANCE = HANDLE; +pub type HMODULE = HINSTANCE; +pub type BOOL = c_int; +pub type BYTE = u8; +pub type BOOLEAN = BYTE; +pub type GROUP = c_uint; +pub type LONG_PTR = isize; +pub type LARGE_INTEGER = c_longlong; +pub type LONG = c_long; +pub type UINT = c_uint; +pub type WCHAR = u16; +pub type USHORT = c_ushort; +pub type SIZE_T = usize; +pub type WORD = u16; +pub type CHAR = c_char; +pub type HCRYPTPROV = LONG_PTR; +pub type ULONG_PTR = c_ulonglong; +pub type ULONG = c_ulong; +pub type ULONGLONG = u64; +pub type DWORDLONG = ULONGLONG; + +pub type LPBOOL = *mut BOOL; +pub type LPBYTE = *mut BYTE; +pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION; +pub type LPCSTR = *const CHAR; +pub type LPCVOID = *const c_void; +pub type LPCWSTR = *const WCHAR; +pub type LPDWORD = *mut DWORD; +pub type LPHANDLE = *mut HANDLE; +pub type LPOVERLAPPED = *mut OVERLAPPED; +pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION; +pub type LPSECURITY_ATTRIBUTES = *mut SECURITY_ATTRIBUTES; +pub type LPSTARTUPINFO = *mut STARTUPINFO; +pub type LPVOID = *mut c_void; +pub type LPWCH = *mut WCHAR; +pub type LPWIN32_FIND_DATAW = *mut WIN32_FIND_DATAW; +pub type LPWSADATA = *mut WSADATA; +pub type LPWSANETWORKEVENTS = *mut WSANETWORKEVENTS; +pub type LPWSAPROTOCOLCHAIN = *mut WSAPROTOCOLCHAIN; +pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO; +pub type LPWSTR = *mut WCHAR; + +pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; +pub type PLARGE_INTEGER = *mut c_longlong; +pub type PSRWLOCK = *mut SRWLOCK; + +pub type SOCKET = ::os::windows::raw::SOCKET; +pub type socklen_t = c_int; +pub type ADDRESS_FAMILY = USHORT; + +pub const TRUE: BOOL = 1; +pub const FALSE: BOOL = 0; + +pub const FILE_ATTRIBUTE_READONLY: DWORD = 0x1; +pub const FILE_ATTRIBUTE_DIRECTORY: DWORD = 0x10; +pub const FILE_ATTRIBUTE_NORMAL: DWORD = 0x80; +pub const FILE_ATTRIBUTE_REPARSE_POINT: DWORD = 0x400; +pub const FILE_SHARE_DELETE: DWORD = 0x4; +pub const FILE_SHARE_READ: DWORD = 0x1; +pub const FILE_SHARE_WRITE: DWORD = 0x2; +pub const CREATE_ALWAYS: DWORD = 2; +pub const CREATE_NEW: DWORD = 1; +pub const OPEN_ALWAYS: DWORD = 4; +pub const OPEN_EXISTING: DWORD = 3; +pub const TRUNCATE_EXISTING: DWORD = 5; +pub const FILE_APPEND_DATA: DWORD = 0x00000004; +pub const FILE_READ_DATA: DWORD = 0x00000001; +pub const FILE_WRITE_DATA: DWORD = 0x00000002; +pub const STANDARD_RIGHTS_READ: DWORD = 0x20000; +pub const STANDARD_RIGHTS_WRITE: DWORD = 0x20000; +pub const FILE_WRITE_EA: DWORD = 0x00000010; +pub const FILE_READ_EA: DWORD = 0x00000008; +pub const SYNCHRONIZE: DWORD = 0x00100000; +pub const FILE_WRITE_ATTRIBUTES: DWORD = 0x00000100; +pub const FILE_READ_ATTRIBUTES: DWORD = 0x00000080; +pub const FILE_GENERIC_READ: DWORD = STANDARD_RIGHTS_READ | FILE_READ_DATA | + FILE_READ_ATTRIBUTES | + FILE_READ_EA | + SYNCHRONIZE; +pub const FILE_GENERIC_WRITE: DWORD = STANDARD_RIGHTS_WRITE | FILE_WRITE_DATA | + FILE_WRITE_ATTRIBUTES | + FILE_WRITE_EA | + FILE_APPEND_DATA | + SYNCHRONIZE; + +#[repr(C)] +#[derive(Copy)] +pub struct WIN32_FIND_DATAW { + pub dwFileAttributes: DWORD, + pub ftCreationTime: FILETIME, + pub ftLastAccessTime: FILETIME, + pub ftLastWriteTime: FILETIME, + pub nFileSizeHigh: DWORD, + pub nFileSizeLow: DWORD, + pub dwReserved0: DWORD, + pub dwReserved1: DWORD, + pub cFileName: [wchar_t; 260], // #define MAX_PATH 260 + pub cAlternateFileName: [wchar_t; 14], +} +impl Clone for WIN32_FIND_DATAW { + fn clone(&self) -> Self { *self } +} + +pub const FIONBIO: c_long = 0x8004667e; pub const FD_SETSIZE: usize = 64; -pub const MSG_DONTWAIT: libc::c_int = 0; -pub const ERROR_ILLEGAL_CHARACTER: libc::c_int = 582; -pub const ENABLE_ECHO_INPUT: libc::DWORD = 0x4; -pub const ENABLE_EXTENDED_FLAGS: libc::DWORD = 0x80; -pub const ENABLE_INSERT_MODE: libc::DWORD = 0x20; -pub const ENABLE_LINE_INPUT: libc::DWORD = 0x2; -pub const ENABLE_PROCESSED_INPUT: libc::DWORD = 0x1; -pub const ENABLE_QUICK_EDIT_MODE: libc::DWORD = 0x40; -pub const WSA_INVALID_EVENT: WSAEVENT = 0 as WSAEVENT; +pub const MSG_DONTWAIT: c_int = 0; +pub const ENABLE_ECHO_INPUT: DWORD = 0x4; +pub const ENABLE_EXTENDED_FLAGS: DWORD = 0x80; +pub const ENABLE_INSERT_MODE: DWORD = 0x20; +pub const ENABLE_LINE_INPUT: DWORD = 0x2; +pub const ENABLE_PROCESSED_INPUT: DWORD = 0x1; +pub const ENABLE_QUICK_EDIT_MODE: DWORD = 0x40; -pub const FD_ACCEPT: libc::c_long = 0x08; +pub const FD_ACCEPT: c_long = 0x08; pub const FD_MAX_EVENTS: usize = 10; -pub const WSA_INFINITE: libc::DWORD = libc::INFINITE; -pub const WSA_WAIT_TIMEOUT: libc::DWORD = libc::consts::os::extra::WAIT_TIMEOUT; -pub const WSA_WAIT_EVENT_0: libc::DWORD = libc::consts::os::extra::WAIT_OBJECT_0; -pub const WSA_WAIT_FAILED: libc::DWORD = libc::consts::os::extra::WAIT_FAILED; -pub const WSAESHUTDOWN: libc::c_int = 10058; -pub const WSA_FLAG_OVERLAPPED: libc::DWORD = 0x01; -pub const WSA_FLAG_NO_HANDLE_INHERIT: libc::DWORD = 0x80; - -pub const ERROR_NO_MORE_FILES: libc::DWORD = 18; -pub const TOKEN_READ: libc::DWORD = 0x20008; -pub const FILE_FLAG_OPEN_REPARSE_POINT: libc::DWORD = 0x00200000; -pub const FILE_FLAG_BACKUP_SEMANTICS: libc::DWORD = 0x02000000; + +pub const WSA_INVALID_EVENT: WSAEVENT = 0 as WSAEVENT; +pub const WSA_INFINITE: DWORD = INFINITE; +pub const WSA_WAIT_TIMEOUT: DWORD = WAIT_TIMEOUT; +pub const WSA_WAIT_EVENT_0: DWORD = WAIT_OBJECT_0; +pub const WSA_WAIT_FAILED: DWORD = WAIT_FAILED; +pub const WSA_FLAG_OVERLAPPED: DWORD = 0x01; +pub const WSA_FLAG_NO_HANDLE_INHERIT: DWORD = 0x80; + +pub const WSADESCRIPTION_LEN: usize = 256; +pub const WSASYS_STATUS_LEN: usize = 128; +pub const WSAPROTOCOL_LEN: DWORD = 255; +pub const INVALID_SOCKET: SOCKET = !0; + +pub const WSAEINTR: c_int = 10004; +pub const WSAEBADF: c_int = 10009; +pub const WSAEACCES: c_int = 10013; +pub const WSAEFAULT: c_int = 10014; +pub const WSAEINVAL: c_int = 10022; +pub const WSAEMFILE: c_int = 10024; +pub const WSAEWOULDBLOCK: c_int = 10035; +pub const WSAEINPROGRESS: c_int = 10036; +pub const WSAEALREADY: c_int = 10037; +pub const WSAENOTSOCK: c_int = 10038; +pub const WSAEDESTADDRREQ: c_int = 10039; +pub const WSAEMSGSIZE: c_int = 10040; +pub const WSAEPROTOTYPE: c_int = 10041; +pub const WSAENOPROTOOPT: c_int = 10042; +pub const WSAEPROTONOSUPPORT: c_int = 10043; +pub const WSAESOCKTNOSUPPORT: c_int = 10044; +pub const WSAEOPNOTSUPP: c_int = 10045; +pub const WSAEPFNOSUPPORT: c_int = 10046; +pub const WSAEAFNOSUPPORT: c_int = 10047; +pub const WSAEADDRINUSE: c_int = 10048; +pub const WSAEADDRNOTAVAIL: c_int = 10049; +pub const WSAENETDOWN: c_int = 10050; +pub const WSAENETUNREACH: c_int = 10051; +pub const WSAENETRESET: c_int = 10052; +pub const WSAECONNABORTED: c_int = 10053; +pub const WSAECONNRESET: c_int = 10054; +pub const WSAENOBUFS: c_int = 10055; +pub const WSAEISCONN: c_int = 10056; +pub const WSAENOTCONN: c_int = 10057; +pub const WSAESHUTDOWN: c_int = 10058; +pub const WSAETOOMANYREFS: c_int = 10059; +pub const WSAETIMEDOUT: c_int = 10060; +pub const WSAECONNREFUSED: c_int = 10061; +pub const WSAELOOP: c_int = 10062; +pub const WSAENAMETOOLONG: c_int = 10063; +pub const WSAEHOSTDOWN: c_int = 10064; +pub const WSAEHOSTUNREACH: c_int = 10065; +pub const WSAENOTEMPTY: c_int = 10066; +pub const WSAEPROCLIM: c_int = 10067; +pub const WSAEUSERS: c_int = 10068; +pub const WSAEDQUOT: c_int = 10069; +pub const WSAESTALE: c_int = 10070; +pub const WSAEREMOTE: c_int = 10071; +pub const WSASYSNOTREADY: c_int = 10091; +pub const WSAVERNOTSUPPORTED: c_int = 10092; +pub const WSANOTINITIALISED: c_int = 10093; +pub const WSAEDISCON: c_int = 10101; +pub const WSAENOMORE: c_int = 10102; +pub const WSAECANCELLED: c_int = 10103; +pub const WSAEINVALIDPROCTABLE: c_int = 10104; +pub const NI_MAXHOST: DWORD = 1025; + +pub const MAX_PROTOCOL_CHAIN: DWORD = 7; + +pub const TOKEN_READ: DWORD = 0x20008; +pub const FILE_FLAG_OPEN_REPARSE_POINT: DWORD = 0x00200000; +pub const FILE_FLAG_BACKUP_SEMANTICS: DWORD = 0x02000000; pub const MAXIMUM_REPARSE_DATA_BUFFER_SIZE: usize = 16 * 1024; -pub const FSCTL_GET_REPARSE_POINT: libc::DWORD = 0x900a8; -pub const IO_REPARSE_TAG_SYMLINK: libc::DWORD = 0xa000000c; -pub const IO_REPARSE_TAG_MOUNT_POINT: libc::DWORD = 0xa0000003; -pub const FSCTL_SET_REPARSE_POINT: libc::DWORD = 0x900a4; -pub const FSCTL_DELETE_REPARSE_POINT: libc::DWORD = 0x900ac; +pub const FSCTL_GET_REPARSE_POINT: DWORD = 0x900a8; +pub const IO_REPARSE_TAG_SYMLINK: DWORD = 0xa000000c; +pub const IO_REPARSE_TAG_MOUNT_POINT: DWORD = 0xa0000003; +pub const FSCTL_SET_REPARSE_POINT: DWORD = 0x900a4; +pub const FSCTL_DELETE_REPARSE_POINT: DWORD = 0x900ac; -pub const SYMBOLIC_LINK_FLAG_DIRECTORY: libc::DWORD = 0x1; +pub const SYMBOLIC_LINK_FLAG_DIRECTORY: DWORD = 0x1; // Note that these are not actually HANDLEs, just values to pass to GetStdHandle -pub const STD_INPUT_HANDLE: libc::DWORD = -10i32 as libc::DWORD; -pub const STD_OUTPUT_HANDLE: libc::DWORD = -11i32 as libc::DWORD; -pub const STD_ERROR_HANDLE: libc::DWORD = -12i32 as libc::DWORD; +pub const STD_INPUT_HANDLE: DWORD = -10i32 as DWORD; +pub const STD_OUTPUT_HANDLE: DWORD = -11i32 as DWORD; +pub const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD; + +pub const HANDLE_FLAG_INHERIT: DWORD = 0x00000001; + +pub const PROGRESS_CONTINUE: DWORD = 0; +pub const PROGRESS_CANCEL: DWORD = 1; +pub const PROGRESS_STOP: DWORD = 2; +pub const PROGRESS_QUIET: DWORD = 3; + +pub const TOKEN_ADJUST_PRIVILEGES: DWORD = 0x0020; +pub const SE_PRIVILEGE_ENABLED: DWORD = 2; + -pub const HANDLE_FLAG_INHERIT: libc::DWORD = 0x00000001; +pub const ERROR_SUCCESS: DWORD = 0; +pub const ERROR_INVALID_FUNCTION: DWORD = 1; +pub const ERROR_FILE_NOT_FOUND: DWORD = 2; +pub const ERROR_PATH_NOT_FOUND: DWORD = 3; +pub const ERROR_ACCESS_DENIED: DWORD = 5; +pub const ERROR_INVALID_HANDLE: DWORD = 6; +pub const ERROR_NO_MORE_FILES: DWORD = 18; +pub const ERROR_BROKEN_PIPE: DWORD = 109; +pub const ERROR_DISK_FULL: DWORD = 112; +pub const ERROR_CALL_NOT_IMPLEMENTED: DWORD = 120; +pub const ERROR_INSUFFICIENT_BUFFER: DWORD = 122; +pub const ERROR_INVALID_NAME: DWORD = 123; +pub const ERROR_ALREADY_EXISTS: DWORD = 183; +pub const ERROR_PIPE_BUSY: DWORD = 231; +pub const ERROR_NO_DATA: DWORD = 232; +pub const ERROR_INVALID_ADDRESS: DWORD = 487; +pub const ERROR_PIPE_CONNECTED: DWORD = 535; +pub const ERROR_ILLEGAL_CHARACTER: DWORD = 582; +pub const ERROR_ENVVAR_NOT_FOUND: DWORD = 203; +pub const ERROR_NOTHING_TO_TERMINATE: DWORD = 758; +pub const ERROR_OPERATION_ABORTED: DWORD = 995; +pub const ERROR_IO_PENDING: DWORD = 997; +pub const ERROR_FILE_INVALID: DWORD = 1006; +pub const ERROR_NOT_FOUND: DWORD = 1168; +pub const ERROR_TIMEOUT: DWORD = 0x5B4; + +pub const INVALID_HANDLE_VALUE: HANDLE = !0 as HANDLE; + +pub const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; +pub const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; + +pub const TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF; + +pub const DLL_THREAD_DETACH: DWORD = 3; +pub const DLL_PROCESS_DETACH: DWORD = 0; + +pub const INFINITE: DWORD = !0; + +pub const DUPLICATE_SAME_ACCESS: DWORD = 0x00000002; + +pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = CONDITION_VARIABLE { + ptr: ptr::null_mut(), +}; +pub const SRWLOCK_INIT: SRWLOCK = SRWLOCK { ptr: ptr::null_mut() }; -pub const PROGRESS_CONTINUE: libc::DWORD = 0; -pub const PROGRESS_CANCEL: libc::DWORD = 1; -pub const PROGRESS_STOP: libc::DWORD = 2; -pub const PROGRESS_QUIET: libc::DWORD = 3; +pub const STILL_ACTIVE: DWORD = 259; -pub const TOKEN_ADJUST_PRIVILEGES: libc::DWORD = 0x0020; -pub const SE_PRIVILEGE_ENABLED: libc::DWORD = 2; +pub const DETACHED_PROCESS: DWORD = 0x00000008; +pub const CREATE_NEW_PROCESS_GROUP: DWORD = 0x00000200; +pub const CREATE_UNICODE_ENVIRONMENT: DWORD = 0x00000400; +pub const STARTF_USESTDHANDLES: DWORD = 0x00000100; + +pub const AF_INET: c_int = 2; +pub const AF_INET6: c_int = 23; +pub const SD_BOTH: c_int = 2; +pub const SD_RECEIVE: c_int = 0; +pub const SD_SEND: c_int = 1; +pub const SOCK_DGRAM: c_int = 2; +pub const SOCK_STREAM: c_int = 1; +pub const SOL_SOCKET: c_int = 0xffff; +pub const SO_RCVTIMEO: c_int = 0x1006; +pub const SO_SNDTIMEO: c_int = 0x1005; +pub const SO_REUSEADDR: c_int = 0x0004; + +pub const VOLUME_NAME_DOS: DWORD = 0x0; +pub const MOVEFILE_REPLACE_EXISTING: DWORD = 1; + +pub const FILE_BEGIN: DWORD = 0; +pub const FILE_CURRENT: DWORD = 1; +pub const FILE_END: DWORD = 2; + +pub const WAIT_ABANDONED: DWORD = 0x00000080; +pub const WAIT_OBJECT_0: DWORD = 0x00000000; +pub const WAIT_TIMEOUT: DWORD = 0x00000102; +pub const WAIT_FAILED: DWORD = !0; + +pub const MAX_SYM_NAME: usize = 2000; +pub const IMAGE_FILE_MACHINE_I386: DWORD = 0x014c; +pub const IMAGE_FILE_MACHINE_IA64: DWORD = 0x0200; +pub const IMAGE_FILE_MACHINE_AMD64: DWORD = 0x8664; + +pub const PROV_RSA_FULL: DWORD = 1; +pub const CRYPT_SILENT: DWORD = 64; +pub const CRYPT_VERIFYCONTEXT: DWORD = 0xF0000000; pub const EXCEPTION_CONTINUE_SEARCH: LONG = 0; -pub const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15; pub const EXCEPTION_STACK_OVERFLOW: DWORD = 0xc00000fd; - -pub const ERROR_PATH_NOT_FOUND: libc::c_int = 3; +pub const EXCEPTION_MAXIMUM_PARAMETERS: usize = 15; +pub const EXCEPTION_NONCONTINUABLE: DWORD = 0x1; // Noncontinuable exception +pub const EXCEPTION_UNWINDING: DWORD = 0x2; // Unwind is in progress +pub const EXCEPTION_EXIT_UNWIND: DWORD = 0x4; // Exit unwind is in progress +pub const EXCEPTION_STACK_INVALID: DWORD = 0x8; // Stack out of limits or unaligned +pub const EXCEPTION_NESTED_CALL: DWORD = 0x10; // Nested exception handler call +pub const EXCEPTION_TARGET_UNWIND: DWORD = 0x20; // Target unwind in progress +pub const EXCEPTION_COLLIDED_UNWIND: DWORD = 0x40; // Collided exception handler call +pub const EXCEPTION_UNWIND: DWORD = EXCEPTION_UNWINDING | + EXCEPTION_EXIT_UNWIND | + EXCEPTION_TARGET_UNWIND | + EXCEPTION_COLLIDED_UNWIND; #[repr(C)] #[cfg(target_arch = "x86")] pub struct WSADATA { - pub wVersion: libc::WORD, - pub wHighVersion: libc::WORD, + pub wVersion: WORD, + pub wHighVersion: WORD, pub szDescription: [u8; WSADESCRIPTION_LEN + 1], pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1], pub iMaxSockets: u16, @@ -99,8 +349,8 @@ pub struct WSADATA { #[repr(C)] #[cfg(target_arch = "x86_64")] pub struct WSADATA { - pub wVersion: libc::WORD, - pub wHighVersion: libc::WORD, + pub wVersion: WORD, + pub wHighVersion: WORD, pub iMaxSockets: u16, pub iMaxUdpDg: u16, pub lpVendorInfo: *mut u8, @@ -108,56 +358,50 @@ pub struct WSADATA { pub szSystemStatus: [u8; WSASYS_STATUS_LEN + 1], } -pub type LPWSADATA = *mut WSADATA; - #[repr(C)] pub struct WSANETWORKEVENTS { - pub lNetworkEvents: libc::c_long, - pub iErrorCode: [libc::c_int; FD_MAX_EVENTS], + pub lNetworkEvents: c_long, + pub iErrorCode: [c_int; FD_MAX_EVENTS], } -pub type LPWSANETWORKEVENTS = *mut WSANETWORKEVENTS; - -pub type WSAEVENT = libc::HANDLE; +pub type WSAEVENT = HANDLE; #[repr(C)] pub struct WSAPROTOCOL_INFO { - pub dwServiceFlags1: libc::DWORD, - pub dwServiceFlags2: libc::DWORD, - pub dwServiceFlags3: libc::DWORD, - pub dwServiceFlags4: libc::DWORD, - pub dwProviderFlags: libc::DWORD, + pub dwServiceFlags1: DWORD, + pub dwServiceFlags2: DWORD, + pub dwServiceFlags3: DWORD, + pub dwServiceFlags4: DWORD, + pub dwProviderFlags: DWORD, pub ProviderId: GUID, - pub dwCatalogEntryId: libc::DWORD, + pub dwCatalogEntryId: DWORD, pub ProtocolChain: WSAPROTOCOLCHAIN, - pub iVersion: libc::c_int, - pub iAddressFamily: libc::c_int, - pub iMaxSockAddr: libc::c_int, - pub iMinSockAddr: libc::c_int, - pub iSocketType: libc::c_int, - pub iProtocol: libc::c_int, - pub iProtocolMaxOffset: libc::c_int, - pub iNetworkByteOrder: libc::c_int, - pub iSecurityScheme: libc::c_int, - pub dwMessageSize: libc::DWORD, - pub dwProviderReserved: libc::DWORD, + pub iVersion: c_int, + pub iAddressFamily: c_int, + pub iMaxSockAddr: c_int, + pub iMinSockAddr: c_int, + pub iSocketType: c_int, + pub iProtocol: c_int, + pub iProtocolMaxOffset: c_int, + pub iNetworkByteOrder: c_int, + pub iSecurityScheme: c_int, + pub dwMessageSize: DWORD, + pub dwProviderReserved: DWORD, pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1], } -pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO; - #[repr(C)] pub struct fd_set { - fd_count: libc::c_uint, - fd_array: [libc::SOCKET; FD_SETSIZE], + fd_count: c_uint, + fd_array: [SOCKET; FD_SETSIZE], } -pub fn fd_set(set: &mut fd_set, s: libc::SOCKET) { +pub fn fd_set(set: &mut fd_set, s: SOCKET) { set.fd_array[set.fd_count as usize] = s; set.fd_count += 1; } -pub type SHORT = libc::c_short; +pub type SHORT = c_short; #[repr(C)] pub struct COORD { @@ -177,39 +421,37 @@ pub struct SMALL_RECT { pub struct CONSOLE_SCREEN_BUFFER_INFO { pub dwSize: COORD, pub dwCursorPosition: COORD, - pub wAttributes: libc::WORD, + pub wAttributes: WORD, pub srWindow: SMALL_RECT, pub dwMaximumWindowSize: COORD, } pub type PCONSOLE_SCREEN_BUFFER_INFO = *mut CONSOLE_SCREEN_BUFFER_INFO; #[repr(C)] -#[derive(Clone)] +#[derive(Copy, Clone)] pub struct WIN32_FILE_ATTRIBUTE_DATA { - pub dwFileAttributes: libc::DWORD, - pub ftCreationTime: libc::FILETIME, - pub ftLastAccessTime: libc::FILETIME, - pub ftLastWriteTime: libc::FILETIME, - pub nFileSizeHigh: libc::DWORD, - pub nFileSizeLow: libc::DWORD, + pub dwFileAttributes: DWORD, + pub ftCreationTime: FILETIME, + pub ftLastAccessTime: FILETIME, + pub ftLastWriteTime: FILETIME, + pub nFileSizeHigh: DWORD, + pub nFileSizeLow: DWORD, } #[repr(C)] pub struct BY_HANDLE_FILE_INFORMATION { - pub dwFileAttributes: libc::DWORD, - pub ftCreationTime: libc::FILETIME, - pub ftLastAccessTime: libc::FILETIME, - pub ftLastWriteTime: libc::FILETIME, - pub dwVolumeSerialNumber: libc::DWORD, - pub nFileSizeHigh: libc::DWORD, - pub nFileSizeLow: libc::DWORD, - pub nNumberOfLinks: libc::DWORD, - pub nFileIndexHigh: libc::DWORD, - pub nFileIndexLow: libc::DWORD, + pub dwFileAttributes: DWORD, + pub ftCreationTime: FILETIME, + pub ftLastAccessTime: FILETIME, + pub ftLastWriteTime: FILETIME, + pub dwVolumeSerialNumber: DWORD, + pub nFileSizeHigh: DWORD, + pub nFileSizeLow: DWORD, + pub nNumberOfLinks: DWORD, + pub nFileIndexHigh: DWORD, + pub nFileIndexLow: DWORD, } -pub type LPBY_HANDLE_FILE_INFORMATION = *mut BY_HANDLE_FILE_INFORMATION; - #[repr(C)] pub enum GET_FILEEX_INFO_LEVELS { GetFileExInfoStandard, @@ -244,38 +486,32 @@ pub enum FILE_INFO_BY_HANDLE_CLASS { #[repr(C)] pub struct FILE_END_OF_FILE_INFO { - pub EndOfFile: libc::LARGE_INTEGER, + pub EndOfFile: LARGE_INTEGER, } #[repr(C)] pub struct REPARSE_DATA_BUFFER { - pub ReparseTag: libc::c_uint, - pub ReparseDataLength: libc::c_ushort, - pub Reserved: libc::c_ushort, + pub ReparseTag: c_uint, + pub ReparseDataLength: c_ushort, + pub Reserved: c_ushort, pub rest: (), } #[repr(C)] pub struct SYMBOLIC_LINK_REPARSE_BUFFER { - pub SubstituteNameOffset: libc::c_ushort, - pub SubstituteNameLength: libc::c_ushort, - pub PrintNameOffset: libc::c_ushort, - pub PrintNameLength: libc::c_ushort, - pub Flags: libc::c_ulong, - pub PathBuffer: libc::WCHAR, + pub SubstituteNameOffset: c_ushort, + pub SubstituteNameLength: c_ushort, + pub PrintNameOffset: c_ushort, + pub PrintNameLength: c_ushort, + pub Flags: c_ulong, + pub PathBuffer: WCHAR, } -pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; -pub type PSRWLOCK = *mut SRWLOCK; -pub type ULONG = c_ulong; -pub type ULONG_PTR = c_ulong; -pub type LPBOOL = *mut BOOL; - pub type LPPROGRESS_ROUTINE = ::option::Option<unsafe extern "system" fn( - TotalFileSize: libc::LARGE_INTEGER, - TotalBytesTransferred: libc::LARGE_INTEGER, - StreamSize: libc::LARGE_INTEGER, - StreamBytesTransferred: libc::LARGE_INTEGER, + TotalFileSize: LARGE_INTEGER, + TotalBytesTransferred: LARGE_INTEGER, + StreamSize: LARGE_INTEGER, + StreamBytesTransferred: LARGE_INTEGER, dwStreamNumber: DWORD, dwCallbackReason: DWORD, hSourceFile: HANDLE, @@ -297,22 +533,17 @@ pub struct CRITICAL_SECTION { SpinCount: ULONG_PTR } -pub const CONDITION_VARIABLE_INIT: CONDITION_VARIABLE = CONDITION_VARIABLE { - ptr: ptr::null_mut(), -}; -pub const SRWLOCK_INIT: SRWLOCK = SRWLOCK { ptr: ptr::null_mut() }; - #[repr(C)] pub struct LUID { - pub LowPart: libc::DWORD, - pub HighPart: libc::c_long, + pub LowPart: DWORD, + pub HighPart: c_long, } pub type PLUID = *mut LUID; #[repr(C)] pub struct TOKEN_PRIVILEGES { - pub PrivilegeCount: libc::DWORD, + pub PrivilegeCount: DWORD, pub Privileges: [LUID_AND_ATTRIBUTES; 1], } @@ -321,18 +552,18 @@ pub type PTOKEN_PRIVILEGES = *mut TOKEN_PRIVILEGES; #[repr(C)] pub struct LUID_AND_ATTRIBUTES { pub Luid: LUID, - pub Attributes: libc::DWORD, + pub Attributes: DWORD, } #[repr(C)] pub struct REPARSE_MOUNTPOINT_DATA_BUFFER { - pub ReparseTag: libc::DWORD, - pub ReparseDataLength: libc::DWORD, - pub Reserved: libc::WORD, - pub ReparseTargetLength: libc::WORD, - pub ReparseTargetMaximumLength: libc::WORD, - pub Reserved1: libc::WORD, - pub ReparseTarget: libc::WCHAR, + pub ReparseTag: DWORD, + pub ReparseDataLength: DWORD, + pub Reserved: WORD, + pub ReparseTargetLength: WORD, + pub ReparseTargetMaximumLength: WORD, + pub Reserved1: WORD, + pub ReparseTarget: WCHAR, } #[repr(C)] @@ -348,69 +579,383 @@ pub struct EXCEPTION_RECORD { #[repr(C)] pub struct EXCEPTION_POINTERS { pub ExceptionRecord: *mut EXCEPTION_RECORD, - pub ContextRecord: LPVOID + pub ContextRecord: *mut CONTEXT, } pub type PVECTORED_EXCEPTION_HANDLER = extern "system" fn(ExceptionInfo: *mut EXCEPTION_POINTERS) -> LONG; +#[repr(C)] +pub struct GUID { + pub Data1: DWORD, + pub Data2: WORD, + pub Data3: WORD, + pub Data4: [BYTE; 8], +} + +#[repr(C)] +pub struct WSAPROTOCOLCHAIN { + pub ChainLen: c_int, + pub ChainEntries: [DWORD; MAX_PROTOCOL_CHAIN as usize], +} + +#[repr(C)] +pub struct SECURITY_ATTRIBUTES { + pub nLength: DWORD, + pub lpSecurityDescriptor: LPVOID, + pub bInheritHandle: BOOL, +} + +#[repr(C)] +pub struct PROCESS_INFORMATION { + pub hProcess: HANDLE, + pub hThread: HANDLE, + pub dwProcessId: DWORD, + pub dwThreadId: DWORD, +} + +#[repr(C)] +pub struct STARTUPINFO { + pub cb: DWORD, + pub lpReserved: LPWSTR, + pub lpDesktop: LPWSTR, + pub lpTitle: LPWSTR, + pub dwX: DWORD, + pub dwY: DWORD, + pub dwXSize: DWORD, + pub dwYSize: DWORD, + pub dwXCountChars: DWORD, + pub dwYCountCharts: DWORD, + pub dwFillAttribute: DWORD, + pub dwFlags: DWORD, + pub wShowWindow: WORD, + pub cbReserved2: WORD, + pub lpReserved2: LPBYTE, + pub hStdInput: HANDLE, + pub hStdOutput: HANDLE, + pub hStdError: HANDLE, +} + +#[repr(C)] +pub struct SOCKADDR { + pub sa_family: ADDRESS_FAMILY, + pub sa_data: [CHAR; 14], +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct FILETIME { + pub dwLowDateTime: DWORD, + pub dwHighDateTime: DWORD, +} + +#[repr(C)] +pub struct OVERLAPPED { + pub Internal: *mut c_ulong, + pub InternalHigh: *mut c_ulong, + pub Offset: DWORD, + pub OffsetHigh: DWORD, + pub hEvent: HANDLE, +} + +#[repr(C)] +pub struct SYMBOL_INFO { + pub SizeOfStruct: c_ulong, + pub TypeIndex: c_ulong, + pub Reserved: [u64; 2], + pub Index: c_ulong, + pub Size: c_ulong, + pub ModBase: u64, + pub Flags: c_ulong, + pub Value: u64, + pub Address: u64, + pub Register: c_ulong, + pub Scope: c_ulong, + pub Tag: c_ulong, + pub NameLen: c_ulong, + pub MaxNameLen: c_ulong, + // note that windows has this as 1, but it basically just means that + // the name is inline at the end of the struct. For us, we just bump + // the struct size up to MAX_SYM_NAME. + pub Name: [c_char; MAX_SYM_NAME], +} + +#[repr(C)] +pub struct IMAGEHLP_LINE64 { + pub SizeOfStruct: u32, + pub Key: *const c_void, + pub LineNumber: u32, + pub Filename: *const c_char, + pub Address: u64, +} + +#[repr(C)] +pub enum ADDRESS_MODE { + AddrMode1616, + AddrMode1632, + AddrModeReal, + AddrModeFlat, +} + +#[repr(C)] +pub struct ADDRESS64 { + pub Offset: u64, + pub Segment: u16, + pub Mode: ADDRESS_MODE, +} + +#[repr(C)] +pub struct STACKFRAME64 { + pub AddrPC: ADDRESS64, + pub AddrReturn: ADDRESS64, + pub AddrFrame: ADDRESS64, + pub AddrStack: ADDRESS64, + pub AddrBStore: ADDRESS64, + pub FuncTableEntry: *mut c_void, + pub Params: [u64; 4], + pub Far: BOOL, + pub Virtual: BOOL, + pub Reserved: [u64; 3], + pub KdHelp: KDHELP64, +} + +#[repr(C)] +pub struct KDHELP64 { + pub Thread: u64, + pub ThCallbackStack: DWORD, + pub ThCallbackBStore: DWORD, + pub NextCallback: DWORD, + pub FramePointer: DWORD, + pub KiCallUserMode: u64, + pub KeUserCallbackDispatcher: u64, + pub SystemRangeStart: u64, + pub KiUserExceptionDispatcher: u64, + pub StackBase: u64, + pub StackLimit: u64, + pub Reserved: [u64; 5], +} + +#[cfg(target_arch = "x86")] +#[repr(C)] +pub struct CONTEXT { + pub ContextFlags: DWORD, + pub Dr0: DWORD, + pub Dr1: DWORD, + pub Dr2: DWORD, + pub Dr3: DWORD, + pub Dr6: DWORD, + pub Dr7: DWORD, + pub FloatSave: FLOATING_SAVE_AREA, + pub SegGs: DWORD, + pub SegFs: DWORD, + pub SegEs: DWORD, + pub SegDs: DWORD, + pub Edi: DWORD, + pub Esi: DWORD, + pub Ebx: DWORD, + pub Edx: DWORD, + pub Ecx: DWORD, + pub Eax: DWORD, + pub Ebp: DWORD, + pub Eip: DWORD, + pub SegCs: DWORD, + pub EFlags: DWORD, + pub Esp: DWORD, + pub SegSs: DWORD, + pub ExtendedRegisters: [u8; 512], +} + +#[cfg(target_arch = "x86")] +#[repr(C)] +pub struct FLOATING_SAVE_AREA { + pub ControlWord: DWORD, + pub StatusWord: DWORD, + pub TagWord: DWORD, + pub ErrorOffset: DWORD, + pub ErrorSelector: DWORD, + pub DataOffset: DWORD, + pub DataSelector: DWORD, + pub RegisterArea: [u8; 80], + pub Cr0NpxState: DWORD, +} + +#[cfg(target_arch = "x86_64")] +#[repr(C)] +pub struct CONTEXT { + _align_hack: [simd::u64x2; 0], // FIXME align on 16-byte + pub P1Home: DWORDLONG, + pub P2Home: DWORDLONG, + pub P3Home: DWORDLONG, + pub P4Home: DWORDLONG, + pub P5Home: DWORDLONG, + pub P6Home: DWORDLONG, + + pub ContextFlags: DWORD, + pub MxCsr: DWORD, + + pub SegCs: WORD, + pub SegDs: WORD, + pub SegEs: WORD, + pub SegFs: WORD, + pub SegGs: WORD, + pub SegSs: WORD, + pub EFlags: DWORD, + + pub Dr0: DWORDLONG, + pub Dr1: DWORDLONG, + pub Dr2: DWORDLONG, + pub Dr3: DWORDLONG, + pub Dr6: DWORDLONG, + pub Dr7: DWORDLONG, + + pub Rax: DWORDLONG, + pub Rcx: DWORDLONG, + pub Rdx: DWORDLONG, + pub Rbx: DWORDLONG, + pub Rsp: DWORDLONG, + pub Rbp: DWORDLONG, + pub Rsi: DWORDLONG, + pub Rdi: DWORDLONG, + pub R8: DWORDLONG, + pub R9: DWORDLONG, + pub R10: DWORDLONG, + pub R11: DWORDLONG, + pub R12: DWORDLONG, + pub R13: DWORDLONG, + pub R14: DWORDLONG, + pub R15: DWORDLONG, + + pub Rip: DWORDLONG, + + pub FltSave: FLOATING_SAVE_AREA, + + pub VectorRegister: [M128A; 26], + pub VectorControl: DWORDLONG, + + pub DebugControl: DWORDLONG, + pub LastBranchToRip: DWORDLONG, + pub LastBranchFromRip: DWORDLONG, + pub LastExceptionToRip: DWORDLONG, + pub LastExceptionFromRip: DWORDLONG, +} + +#[cfg(target_arch = "x86_64")] +#[repr(C)] +pub struct M128A { + _align_hack: [simd::u64x2; 0], // FIXME align on 16-byte + pub Low: c_ulonglong, + pub High: c_longlong +} + +#[cfg(target_arch = "x86_64")] +#[repr(C)] +pub struct FLOATING_SAVE_AREA { + _align_hack: [simd::u64x2; 0], // FIXME align on 16-byte + _Dummy: [u8; 512] // FIXME: Fill this out +} + +#[repr(C)] +pub struct SOCKADDR_STORAGE_LH { + pub ss_family: ADDRESS_FAMILY, + pub __ss_pad1: [CHAR; 6], + pub __ss_align: i64, + pub __ss_pad2: [CHAR; 112], +} + +#[repr(C)] +pub struct ADDRINFOA { + pub ai_flags: c_int, + pub ai_family: c_int, + pub ai_socktype: c_int, + pub ai_protocol: c_int, + pub ai_addrlen: size_t, + pub ai_canonname: *mut c_char, + pub ai_addr: *mut SOCKADDR, + pub ai_next: *mut ADDRINFOA, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sockaddr_in { + pub sin_family: ADDRESS_FAMILY, + pub sin_port: USHORT, + pub sin_addr: in_addr, + pub sin_zero: [CHAR; 8], +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct sockaddr_in6 { + pub sin6_family: ADDRESS_FAMILY, + pub sin6_port: USHORT, + pub sin6_flowinfo: c_ulong, + pub sin6_addr: in6_addr, + pub sin6_scope_id: c_ulong, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct in_addr { + pub s_addr: u32, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub struct in6_addr { + pub s6_addr: [u8; 16], +} + +pub enum UNWIND_HISTORY_TABLE {} + +#[repr(C)] +pub struct RUNTIME_FUNCTION { + pub BeginAddress: DWORD, + pub EndAddress: DWORD, + pub UnwindData: DWORD, +} + +#[repr(C)] +pub struct DISPATCHER_CONTEXT { + pub ControlPc: LPVOID, + pub ImageBase: LPVOID, + pub FunctionEntry: *const RUNTIME_FUNCTION, + pub EstablisherFrame: LPVOID, + pub TargetIp: LPVOID, + pub ContextRecord: *const CONTEXT, + pub LanguageHandler: LPVOID, + pub HandlerData: *const u8, + pub HistoryTable: *const UNWIND_HISTORY_TABLE, +} + +#[repr(C)] +#[derive(Copy, Clone)] +pub enum EXCEPTION_DISPOSITION { + ExceptionContinueExecution, + ExceptionContinueSearch, + ExceptionNestedException, + ExceptionCollidedUnwind +} + #[link(name = "ws2_32")] #[link(name = "userenv")] +#[link(name = "shell32")] +#[link(name = "advapi32")] extern "system" { - pub fn WSAStartup(wVersionRequested: libc::WORD, - 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, + pub fn WSAStartup(wVersionRequested: WORD, + lpWSAData: LPWSADATA) -> c_int; + pub fn WSACleanup() -> c_int; + pub fn WSAGetLastError() -> c_int; + pub fn WSADuplicateSocketW(s: SOCKET, + dwProcessId: DWORD, lpProtocolInfo: LPWSAPROTOCOL_INFO) - -> libc::c_int; - pub fn GetCurrentProcessId() -> libc::DWORD; - pub fn WSASocketW(af: libc::c_int, - kind: libc::c_int, - protocol: libc::c_int, + -> c_int; + pub fn GetCurrentProcessId() -> DWORD; + pub fn WSASocketW(af: c_int, + kind: c_int, + protocol: c_int, 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; - + dwFlags: DWORD) -> SOCKET; pub fn InitializeCriticalSection(CriticalSection: *mut CRITICAL_SECTION); pub fn EnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION); pub fn TryEnterCriticalSection(CriticalSection: *mut CRITICAL_SECTION) -> BOOLEAN; @@ -418,104 +963,274 @@ extern "system" { pub fn DeleteCriticalSection(CriticalSection: *mut CRITICAL_SECTION); // FIXME - pInputControl should be PCONSOLE_READCONSOLE_CONTROL - pub fn ReadConsoleW(hConsoleInput: libc::HANDLE, - lpBuffer: libc::LPVOID, - nNumberOfCharsToRead: libc::DWORD, - lpNumberOfCharsRead: libc::LPDWORD, - pInputControl: libc::LPVOID) -> libc::BOOL; - - pub fn WriteConsoleW(hConsoleOutput: libc::HANDLE, - lpBuffer: libc::types::os::arch::extra::LPCVOID, - nNumberOfCharsToWrite: libc::DWORD, - lpNumberOfCharsWritten: libc::LPDWORD, - lpReserved: libc::LPVOID) -> libc::BOOL; - - 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, + pub fn ReadConsoleW(hConsoleInput: HANDLE, + lpBuffer: LPVOID, + nNumberOfCharsToRead: DWORD, + lpNumberOfCharsRead: LPDWORD, + pInputControl: LPVOID) -> BOOL; + + pub fn WriteConsoleW(hConsoleOutput: HANDLE, + lpBuffer: LPCVOID, + nNumberOfCharsToWrite: DWORD, + lpNumberOfCharsWritten: LPDWORD, + lpReserved: LPVOID) -> BOOL; + + pub fn GetConsoleMode(hConsoleHandle: HANDLE, + lpMode: LPDWORD) -> BOOL; + pub fn GetFileAttributesExW(lpFileName: 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: LPVOID) -> BOOL; + pub fn RemoveDirectoryW(lpPathName: LPCWSTR) -> BOOL; + pub fn SetFileAttributesW(lpFileName: LPCWSTR, + dwFileAttributes: DWORD) -> BOOL; + pub fn GetFileInformationByHandle(hFile: HANDLE, lpFileInformation: LPBY_HANDLE_FILE_INFORMATION) - -> libc::BOOL; - - pub fn SetLastError(dwErrCode: libc::DWORD); - pub fn GetCommandLineW() -> *mut libc::LPCWSTR; - pub fn LocalFree(ptr: *mut libc::c_void); - pub fn CommandLineToArgvW(lpCmdLine: *mut libc::LPCWSTR, - pNumArgs: *mut libc::c_int) -> *mut *mut u16; - pub fn SetFileTime(hFile: libc::HANDLE, - lpCreationTime: *const libc::FILETIME, - lpLastAccessTime: *const libc::FILETIME, - lpLastWriteTime: *const libc::FILETIME) -> libc::BOOL; - pub fn GetTempPathW(nBufferLength: libc::DWORD, - lpBuffer: libc::LPCWSTR) -> libc::DWORD; - pub fn OpenProcessToken(ProcessHandle: libc::HANDLE, - DesiredAccess: libc::DWORD, - TokenHandle: *mut libc::HANDLE) -> libc::BOOL; - pub fn GetCurrentProcess() -> libc::HANDLE; - pub fn GetStdHandle(which: libc::DWORD) -> libc::HANDLE; - pub fn ExitProcess(uExitCode: libc::c_uint) -> !; - pub fn DeviceIoControl(hDevice: libc::HANDLE, - dwIoControlCode: libc::DWORD, - lpInBuffer: libc::LPVOID, - nInBufferSize: libc::DWORD, - lpOutBuffer: libc::LPVOID, - nOutBufferSize: libc::DWORD, - lpBytesReturned: libc::LPDWORD, - lpOverlapped: libc::LPOVERLAPPED) -> libc::BOOL; - pub fn CreatePipe(hReadPipe: libc::LPHANDLE, - hWritePipe: libc::LPHANDLE, - lpPipeAttributes: libc::LPSECURITY_ATTRIBUTES, - nSize: libc::DWORD) -> libc::BOOL; - pub fn CreateThread(lpThreadAttributes: libc::LPSECURITY_ATTRIBUTES, - dwStackSize: libc::SIZE_T, - lpStartAddress: extern "system" fn(*mut libc::c_void) - -> libc::DWORD, - lpParameter: libc::LPVOID, - dwCreationFlags: libc::DWORD, - lpThreadId: libc::LPDWORD) -> libc::HANDLE; - pub fn WaitForSingleObject(hHandle: libc::HANDLE, - dwMilliseconds: libc::DWORD) -> libc::DWORD; - pub fn SwitchToThread() -> libc::BOOL; - pub fn Sleep(dwMilliseconds: libc::DWORD); - pub fn GetProcessId(handle: libc::HANDLE) -> libc::DWORD; - pub fn GetUserProfileDirectoryW(hToken: libc::HANDLE, - lpProfileDir: libc::LPCWSTR, - lpcchSize: *mut libc::DWORD) -> libc::BOOL; - pub fn SetHandleInformation(hObject: libc::HANDLE, - dwMask: libc::DWORD, - dwFlags: libc::DWORD) -> libc::BOOL; - pub fn CopyFileExW(lpExistingFileName: libc::LPCWSTR, - lpNewFileName: libc::LPCWSTR, + -> BOOL; + + pub fn SetLastError(dwErrCode: DWORD); + pub fn GetCommandLineW() -> *mut LPCWSTR; + pub fn LocalFree(ptr: *mut c_void); + pub fn CommandLineToArgvW(lpCmdLine: *mut LPCWSTR, + pNumArgs: *mut c_int) -> *mut *mut u16; + pub fn GetTempPathW(nBufferLength: DWORD, + lpBuffer: LPCWSTR) -> DWORD; + pub fn OpenProcessToken(ProcessHandle: HANDLE, + DesiredAccess: DWORD, + TokenHandle: *mut HANDLE) -> BOOL; + pub fn GetCurrentProcess() -> HANDLE; + pub fn GetCurrentThread() -> HANDLE; + pub fn GetStdHandle(which: DWORD) -> HANDLE; + pub fn ExitProcess(uExitCode: c_uint) -> !; + pub fn DeviceIoControl(hDevice: HANDLE, + dwIoControlCode: DWORD, + lpInBuffer: LPVOID, + nInBufferSize: DWORD, + lpOutBuffer: LPVOID, + nOutBufferSize: DWORD, + lpBytesReturned: LPDWORD, + lpOverlapped: LPOVERLAPPED) -> BOOL; + pub fn CreatePipe(hReadPipe: LPHANDLE, + hWritePipe: LPHANDLE, + lpPipeAttributes: LPSECURITY_ATTRIBUTES, + nSize: DWORD) -> BOOL; + pub fn CreateThread(lpThreadAttributes: LPSECURITY_ATTRIBUTES, + dwStackSize: SIZE_T, + lpStartAddress: extern "system" fn(*mut c_void) + -> DWORD, + lpParameter: LPVOID, + dwCreationFlags: DWORD, + lpThreadId: LPDWORD) -> HANDLE; + pub fn WaitForSingleObject(hHandle: HANDLE, + dwMilliseconds: DWORD) -> DWORD; + pub fn SwitchToThread() -> BOOL; + pub fn Sleep(dwMilliseconds: DWORD); + pub fn GetProcessId(handle: HANDLE) -> DWORD; + pub fn GetUserProfileDirectoryW(hToken: HANDLE, + lpProfileDir: LPCWSTR, + lpcchSize: *mut DWORD) -> BOOL; + pub fn SetHandleInformation(hObject: HANDLE, + dwMask: DWORD, + dwFlags: DWORD) -> BOOL; + pub fn CopyFileExW(lpExistingFileName: LPCWSTR, + lpNewFileName: LPCWSTR, lpProgressRoutine: LPPROGRESS_ROUTINE, - lpData: libc::LPVOID, + lpData: LPVOID, pbCancel: LPBOOL, - dwCopyFlags: libc::DWORD) -> libc::BOOL; - pub fn LookupPrivilegeValueW(lpSystemName: libc::LPCWSTR, - lpName: libc::LPCWSTR, - lpLuid: PLUID) -> libc::BOOL; - pub fn AdjustTokenPrivileges(TokenHandle: libc::HANDLE, - DisableAllPrivileges: libc::BOOL, + dwCopyFlags: DWORD) -> BOOL; + pub fn LookupPrivilegeValueW(lpSystemName: LPCWSTR, + lpName: LPCWSTR, + lpLuid: PLUID) -> BOOL; + pub fn AdjustTokenPrivileges(TokenHandle: HANDLE, + DisableAllPrivileges: BOOL, NewState: PTOKEN_PRIVILEGES, - BufferLength: libc::DWORD, + BufferLength: DWORD, PreviousState: PTOKEN_PRIVILEGES, - ReturnLength: *mut libc::DWORD) -> libc::BOOL; + ReturnLength: *mut DWORD) -> BOOL; pub fn AddVectoredExceptionHandler(FirstHandler: ULONG, VectoredHandler: PVECTORED_EXCEPTION_HANDLER) -> LPVOID; + pub fn FormatMessageW(flags: DWORD, + lpSrc: LPVOID, + msgId: DWORD, + langId: DWORD, + buf: LPWSTR, + nsize: DWORD, + args: *const c_void) + -> DWORD; + pub fn TlsAlloc() -> DWORD; + pub fn TlsFree(dwTlsIndex: DWORD) -> BOOL; + pub fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID; + pub fn TlsSetValue(dwTlsIndex: DWORD, lpTlsvalue: LPVOID) -> BOOL; + pub fn GetLastError() -> DWORD; + pub fn QueryPerformanceFrequency(lpFrequency: *mut LARGE_INTEGER) -> BOOL; + pub fn QueryPerformanceCounter(lpPerformanceCount: *mut LARGE_INTEGER) + -> BOOL; + pub fn GetExitCodeProcess(hProcess: HANDLE, lpExitCode: LPDWORD) -> BOOL; + pub fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL; + 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 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 DeleteFileW(lpPathName: LPCWSTR) -> BOOL; + pub fn GetCurrentDirectoryW(nBufferLength: DWORD, lpBuffer: LPWSTR) -> DWORD; + pub fn SetCurrentDirectoryW(lpPathName: LPCWSTR) -> BOOL; + + pub fn closesocket(socket: SOCKET) -> c_int; + pub fn recv(socket: SOCKET, buf: *mut c_void, len: c_int, + flags: c_int) -> c_int; + pub fn send(socket: SOCKET, buf: *const c_void, len: c_int, + flags: c_int) -> c_int; + pub fn recvfrom(socket: SOCKET, + buf: *mut c_void, + len: c_int, + flags: c_int, + addr: *mut SOCKADDR, + addrlen: *mut c_int) + -> c_int; + pub fn sendto(socket: SOCKET, + buf: *const c_void, + len: c_int, + flags: c_int, + addr: *const SOCKADDR, + addrlen: c_int) + -> c_int; + pub fn shutdown(socket: SOCKET, how: c_int) -> c_int; + pub fn accept(socket: SOCKET, + address: *mut SOCKADDR, + address_len: *mut c_int) + -> SOCKET; + pub fn DuplicateHandle(hSourceProcessHandle: HANDLE, + hSourceHandle: HANDLE, + hTargetProcessHandle: HANDLE, + lpTargetHandle: LPHANDLE, + dwDesiredAccess: DWORD, + bInheritHandle: BOOL, + dwOptions: DWORD) + -> BOOL; + 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 CloseHandle(hObject: HANDLE) -> BOOL; + pub fn CreateHardLinkW(lpSymlinkFileName: LPCWSTR, + lpTargetFileName: LPCWSTR, + lpSecurityAttributes: LPSECURITY_ATTRIBUTES) + -> BOOL; + pub fn MoveFileExW(lpExistingFileName: LPCWSTR, + lpNewFileName: LPCWSTR, + dwFlags: DWORD) + -> BOOL; + pub fn SetFilePointerEx(hFile: HANDLE, + liDistanceToMove: LARGE_INTEGER, + lpNewFilePointer: PLARGE_INTEGER, + dwMoveMethod: DWORD) + -> 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 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 RtlCaptureContext(ctx: *mut CONTEXT); + pub fn getsockopt(s: SOCKET, + level: c_int, + optname: c_int, + optval: *mut c_char, + optlen: *mut c_int) + -> c_int; + pub fn setsockopt(s: SOCKET, + level: c_int, + optname: c_int, + optval: *const c_void, + optlen: c_int) + -> c_int; + pub fn getsockname(socket: SOCKET, + address: *mut SOCKADDR, + address_len: *mut c_int) + -> c_int; + pub fn getpeername(socket: SOCKET, + address: *mut SOCKADDR, + address_len: *mut c_int) + -> c_int; + pub fn bind(socket: SOCKET, address: *const SOCKADDR, + address_len: socklen_t) -> c_int; + pub fn listen(socket: SOCKET, backlog: c_int) -> c_int; + pub fn connect(socket: SOCKET, address: *const SOCKADDR, len: c_int) + -> c_int; + pub fn getaddrinfo(node: *const c_char, service: *const c_char, + hints: *const ADDRINFOA, + res: *mut *mut ADDRINFOA) -> c_int; + pub fn freeaddrinfo(res: *mut ADDRINFOA); + pub fn getnameinfo(sa: *const SOCKADDR, salen: c_int, + host: *mut c_char, hostlen: DWORD, + serv: *mut c_char, servlen: DWORD, + flags: c_int) -> c_int; + + pub fn LoadLibraryW(name: LPCWSTR) -> HMODULE; + pub fn GetModuleHandleExW(dwFlags: DWORD, name: LPCWSTR, + handle: *mut HMODULE) -> BOOL; + pub fn GetProcAddress(handle: HMODULE, + name: LPCSTR) -> *mut c_void; + pub fn FreeLibrary(handle: HMODULE) -> BOOL; + pub fn SetErrorMode(uMode: c_uint) -> c_uint; + pub fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE; + pub fn CryptAcquireContextA(phProv: *mut HCRYPTPROV, + pszContainer: LPCSTR, + pszProvider: LPCSTR, + dwProvType: DWORD, + dwFlags: DWORD) -> BOOL; + pub fn CryptGenRandom(hProv: HCRYPTPROV, + dwLen: DWORD, + pbBuffer: *mut BYTE) -> BOOL; + pub fn CryptReleaseContext(hProv: HCRYPTPROV, dwFlags: DWORD) -> BOOL; + + #[unwind] + pub fn RaiseException(dwExceptionCode: DWORD, + dwExceptionFlags: DWORD, + nNumberOfArguments: DWORD, + lpArguments: *const ULONG_PTR); + pub fn RtlUnwindEx(TargetFrame: LPVOID, + TargetIp: LPVOID, + ExceptionRecord: *const EXCEPTION_RECORD, + ReturnValue: LPVOID, + OriginalContext: *const CONTEXT, + HistoryTable: *const UNWIND_HISTORY_TABLE); } // Functions that aren't available on Windows XP, but we still use them and just diff --git a/src/libstd/sys/windows/compat.rs b/src/libstd/sys/windows/compat.rs index 3a03b91f24e..780a0d9427d 100644 --- a/src/libstd/sys/windows/compat.rs +++ b/src/libstd/sys/windows/compat.rs @@ -24,21 +24,16 @@ use prelude::v1::*; use ffi::CString; -use libc::{LPVOID, LPCWSTR, HMODULE, LPCSTR}; use sync::atomic::{AtomicUsize, Ordering}; - -extern "system" { - fn GetModuleHandleW(lpModuleName: LPCWSTR) -> HMODULE; - fn GetProcAddress(hModule: HMODULE, lpProcName: LPCSTR) -> LPVOID; -} +use sys::c; pub fn lookup(module: &str, symbol: &str) -> Option<usize> { let mut module: Vec<u16> = module.utf16_units().collect(); module.push(0); let symbol = CString::new(symbol).unwrap(); unsafe { - let handle = GetModuleHandleW(module.as_ptr()); - match GetProcAddress(handle, symbol.as_ptr()) as usize { + let handle = c::GetModuleHandleW(module.as_ptr()); + match c::GetProcAddress(handle, symbol.as_ptr()) as usize { 0 => None, n => Some(n), } diff --git a/src/libstd/sys/windows/condvar.rs b/src/libstd/sys/windows/condvar.rs index ac76479d7db..8075374d42b 100644 --- a/src/libstd/sys/windows/condvar.rs +++ b/src/libstd/sys/windows/condvar.rs @@ -9,7 +9,6 @@ // except according to those terms. use cell::UnsafeCell; -use libc::{self, DWORD}; use sys::c; use sys::mutex::{self, Mutex}; use sys::os; @@ -29,7 +28,7 @@ impl Condvar { pub unsafe fn wait(&self, mutex: &Mutex) { let r = c::SleepConditionVariableSRW(self.inner.get(), mutex::raw(mutex), - libc::INFINITE, + c::INFINITE, 0); debug_assert!(r != 0); } @@ -40,8 +39,7 @@ impl Condvar { super::dur2timeout(dur), 0); if r == 0 { - const ERROR_TIMEOUT: DWORD = 0x5B4; - debug_assert_eq!(os::errno() as usize, ERROR_TIMEOUT as usize); + debug_assert_eq!(os::errno() as usize, c::ERROR_TIMEOUT as usize); false } else { true diff --git a/src/libstd/sys/windows/ext/io.rs b/src/libstd/sys/windows/ext/io.rs index 9f10b0e8563..2ddb6c65fd3 100644 --- a/src/libstd/sys/windows/ext/io.rs +++ b/src/libstd/sys/windows/ext/io.rs @@ -15,6 +15,7 @@ use os::windows::raw; use net; use sys_common::{self, AsInner, FromInner, IntoInner}; use sys; +use sys::c; /// Raw HANDLEs. #[stable(feature = "rust1", since = "1.0.0")] @@ -73,7 +74,7 @@ impl AsRawHandle for fs::File { #[stable(feature = "from_raw_os", since = "1.1.0")] impl FromRawHandle for fs::File { unsafe fn from_raw_handle(handle: RawHandle) -> fs::File { - let handle = handle as ::libc::HANDLE; + let handle = handle as c::HANDLE; fs::File::from_inner(sys::fs::File::from_inner(handle)) } } diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index fb2456564eb..0b0e1a1ece7 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -14,7 +14,6 @@ use os::windows::prelude::*; use ffi::OsString; use fmt; use io::{self, Error, SeekFrom}; -use libc::{self, HANDLE}; use mem; use path::{Path, PathBuf}; use ptr; @@ -30,7 +29,7 @@ pub struct File { handle: Handle } #[derive(Clone)] pub struct FileAttr { data: c::WIN32_FILE_ATTRIBUTE_DATA, - reparse_tag: libc::DWORD, + reparse_tag: c::DWORD, } #[derive(Copy, Clone, PartialEq, Eq, Hash)] @@ -41,17 +40,17 @@ pub enum FileType { pub struct ReadDir { handle: FindNextFileHandle, root: Arc<PathBuf>, - first: Option<libc::WIN32_FIND_DATAW>, + first: Option<c::WIN32_FIND_DATAW>, } -struct FindNextFileHandle(libc::HANDLE); +struct FindNextFileHandle(c::HANDLE); unsafe impl Send for FindNextFileHandle {} unsafe impl Sync for FindNextFileHandle {} pub struct DirEntry { root: Arc<PathBuf>, - data: libc::WIN32_FIND_DATAW, + data: c::WIN32_FIND_DATAW, } #[derive(Clone, Default)] @@ -61,15 +60,15 @@ pub struct OpenOptions { read: bool, write: bool, truncate: bool, - desired_access: Option<libc::DWORD>, - share_mode: Option<libc::DWORD>, - creation_disposition: Option<libc::DWORD>, - flags_and_attributes: Option<libc::DWORD>, + desired_access: Option<c::DWORD>, + share_mode: Option<c::DWORD>, + creation_disposition: Option<c::DWORD>, + flags_and_attributes: Option<c::DWORD>, security_attributes: usize, // *mut T doesn't have a Default impl } #[derive(Clone, PartialEq, Eq, Debug)] -pub struct FilePermissions { attrs: libc::DWORD } +pub struct FilePermissions { attrs: c::DWORD } pub struct DirBuilder; @@ -84,9 +83,8 @@ impl Iterator for ReadDir { unsafe { let mut wfd = mem::zeroed(); loop { - if libc::FindNextFileW(self.handle.0, &mut wfd) == 0 { - if libc::GetLastError() == - c::ERROR_NO_MORE_FILES as libc::DWORD { + if c::FindNextFileW(self.handle.0, &mut wfd) == 0 { + if c::GetLastError() == c::ERROR_NO_MORE_FILES { return None } else { return Some(Err(Error::last_os_error())) @@ -102,13 +100,13 @@ 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); } } impl DirEntry { - fn new(root: &Arc<PathBuf>, wfd: &libc::WIN32_FIND_DATAW) -> Option<DirEntry> { + fn new(root: &Arc<PathBuf>, wfd: &c::WIN32_FIND_DATAW) -> Option<DirEntry> { match &wfd.cFileName[0..3] { // check for '.' and '..' [46, 0, ..] | @@ -170,50 +168,50 @@ impl OpenOptions { pub fn share_mode(&mut self, val: u32) { self.share_mode = Some(val); } - pub fn security_attributes(&mut self, attrs: libc::LPSECURITY_ATTRIBUTES) { + pub fn security_attributes(&mut self, attrs: c::LPSECURITY_ATTRIBUTES) { self.security_attributes = attrs as usize; } - fn get_desired_access(&self) -> libc::DWORD { + fn get_desired_access(&self) -> c::DWORD { self.desired_access.unwrap_or({ - let mut base = if self.read {libc::FILE_GENERIC_READ} else {0} | - if self.write {libc::FILE_GENERIC_WRITE} else {0}; + let mut base = if self.read {c::FILE_GENERIC_READ} else {0} | + if self.write {c::FILE_GENERIC_WRITE} else {0}; if self.append { - base &= !libc::FILE_WRITE_DATA; - base |= libc::FILE_APPEND_DATA; + base &= !c::FILE_WRITE_DATA; + base |= c::FILE_APPEND_DATA; } base }) } - fn get_share_mode(&self) -> libc::DWORD { + fn get_share_mode(&self) -> c::DWORD { // libuv has a good comment about this, but the basic idea is that // we try to emulate unix semantics by enabling all sharing by // allowing things such as deleting a file while it's still open. - self.share_mode.unwrap_or(libc::FILE_SHARE_READ | - libc::FILE_SHARE_WRITE | - libc::FILE_SHARE_DELETE) + self.share_mode.unwrap_or(c::FILE_SHARE_READ | + c::FILE_SHARE_WRITE | + c::FILE_SHARE_DELETE) } - fn get_creation_disposition(&self) -> libc::DWORD { + fn get_creation_disposition(&self) -> c::DWORD { self.creation_disposition.unwrap_or({ match (self.create, self.truncate) { - (true, true) => libc::CREATE_ALWAYS, - (true, false) => libc::OPEN_ALWAYS, - (false, false) => libc::OPEN_EXISTING, + (true, true) => c::CREATE_ALWAYS, + (true, false) => c::OPEN_ALWAYS, + (false, false) => c::OPEN_EXISTING, (false, true) => { if self.write && !self.append { - libc::CREATE_ALWAYS + c::CREATE_ALWAYS } else { - libc::TRUNCATE_EXISTING + c::TRUNCATE_EXISTING } } } }) } - fn get_flags_and_attributes(&self) -> libc::DWORD { - self.flags_and_attributes.unwrap_or(libc::FILE_ATTRIBUTE_NORMAL) + fn get_flags_and_attributes(&self) -> c::DWORD { + self.flags_and_attributes.unwrap_or(c::FILE_ATTRIBUTE_NORMAL) } } @@ -230,15 +228,15 @@ impl File { pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> { 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 { + if handle == c::INVALID_HANDLE_VALUE { Err(Error::last_os_error()) } else { Ok(File { handle: Handle::new(handle) }) @@ -246,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(()) } @@ -254,14 +252,14 @@ impl File { pub fn truncate(&self, size: u64) -> io::Result<()> { let mut info = c::FILE_END_OF_FILE_INFO { - EndOfFile: size as libc::LARGE_INTEGER, + EndOfFile: size as c::LARGE_INTEGER, }; let size = mem::size_of_val(&info); try!(cvt(unsafe { c::SetFileInformationByHandle(self.handle.raw(), c::FileEndOfFileInfo, &mut info as *mut _ as *mut _, - size as libc::DWORD) + size as c::DWORD) })); Ok(()) } @@ -304,15 +302,15 @@ impl File { pub fn seek(&self, pos: SeekFrom) -> io::Result<u64> { let (whence, pos) = match pos { - SeekFrom::Start(n) => (libc::FILE_BEGIN, n as i64), - SeekFrom::End(n) => (libc::FILE_END, n), - SeekFrom::Current(n) => (libc::FILE_CURRENT, n), + SeekFrom::Start(n) => (c::FILE_BEGIN, n as i64), + SeekFrom::End(n) => (c::FILE_END, n), + SeekFrom::Current(n) => (c::FILE_CURRENT, n), }; - let pos = pos as libc::LARGE_INTEGER; + let pos = pos as c::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) } @@ -323,7 +321,7 @@ impl File { fn reparse_point<'a>(&self, space: &'a mut [u8; c::MAXIMUM_REPARSE_DATA_BUFFER_SIZE]) - -> io::Result<(libc::DWORD, &'a c::REPARSE_DATA_BUFFER)> { + -> io::Result<(c::DWORD, &'a c::REPARSE_DATA_BUFFER)> { unsafe { let mut bytes = 0; try!(cvt({ @@ -332,7 +330,7 @@ impl File { ptr::null_mut(), 0, space.as_mut_ptr() as *mut _, - space.len() as libc::DWORD, + space.len() as c::DWORD, &mut bytes, ptr::null_mut()) })); @@ -361,8 +359,8 @@ impl File { } } -impl FromInner<libc::HANDLE> for File { - fn from_inner(handle: libc::HANDLE) -> File { +impl FromInner<c::HANDLE> for File { + fn from_inner(handle: c::HANDLE) -> File { File { handle: Handle::new(handle) } } } @@ -402,12 +400,12 @@ impl FileAttr { pub fn accessed(&self) -> u64 { self.to_u64(&self.data.ftLastAccessTime) } pub fn modified(&self) -> u64 { self.to_u64(&self.data.ftLastWriteTime) } - fn to_u64(&self, ft: &libc::FILETIME) -> u64 { + fn to_u64(&self, ft: &c::FILETIME) -> u64 { (ft.dwLowDateTime as u64) | ((ft.dwHighDateTime as u64) << 32) } fn is_reparse_point(&self) -> bool { - self.data.dwFileAttributes & libc::FILE_ATTRIBUTE_REPARSE_POINT != 0 + self.data.dwFileAttributes & c::FILE_ATTRIBUTE_REPARSE_POINT != 0 } } @@ -426,8 +424,8 @@ impl FilePermissions { } impl FileType { - fn new(attrs: libc::DWORD, reparse_tag: libc::DWORD) -> FileType { - if attrs & libc::FILE_ATTRIBUTE_REPARSE_POINT != 0 { + fn new(attrs: c::DWORD, reparse_tag: c::DWORD) -> FileType { + if attrs & c::FILE_ATTRIBUTE_REPARSE_POINT != 0 { match reparse_tag { c::IO_REPARSE_TAG_SYMLINK => FileType::Symlink, c::IO_REPARSE_TAG_MOUNT_POINT => FileType::MountPoint, @@ -453,7 +451,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(()) } @@ -466,8 +464,8 @@ pub fn readdir(p: &Path) -> io::Result<ReadDir> { unsafe { let mut wfd = mem::zeroed(); - let find_handle = libc::FindFirstFileW(path.as_ptr(), &mut wfd); - if find_handle != libc::INVALID_HANDLE_VALUE { + let find_handle = c::FindFirstFileW(path.as_ptr(), &mut wfd); + if find_handle != c::INVALID_HANDLE_VALUE { Ok(ReadDir { handle: FindNextFileHandle(find_handle), root: Arc::new(root), @@ -481,7 +479,7 @@ pub fn readdir(p: &Path) -> io::Result<ReadDir> { 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(()) } @@ -489,8 +487,7 @@ 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(), c::MOVEFILE_REPLACE_EXISTING) })); Ok(()) } @@ -515,7 +512,7 @@ pub fn symlink_inner(src: &Path, dst: &Path, dir: bool) -> io::Result<()> { let dst = to_utf16(dst); let flags = if dir { c::SYMBOLIC_LINK_FLAG_DIRECTORY } else { 0 }; try!(cvt(unsafe { - c::CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), flags) as libc::BOOL + c::CreateSymbolicLinkW(dst.as_ptr(), src.as_ptr(), flags) as c::BOOL })); Ok(()) } @@ -524,7 +521,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(()) } @@ -575,7 +572,7 @@ pub fn set_perm(p: &Path, perm: FilePermissions) -> io::Result<()> { fn get_path(f: &File) -> io::Result<PathBuf> { super::fill_utf16_buf(|buf, sz| unsafe { c::GetFinalPathNameByHandleW(f.handle.raw(), buf, sz, - libc::VOLUME_NAME_DOS) + c::VOLUME_NAME_DOS) }, |buf| { PathBuf::from(OsString::from_wide(buf)) }) @@ -592,16 +589,16 @@ pub fn canonicalize(p: &Path) -> io::Result<PathBuf> { pub fn copy(from: &Path, to: &Path) -> io::Result<u64> { unsafe extern "system" fn callback( - _TotalFileSize: libc::LARGE_INTEGER, - TotalBytesTransferred: libc::LARGE_INTEGER, - _StreamSize: libc::LARGE_INTEGER, - _StreamBytesTransferred: libc::LARGE_INTEGER, - _dwStreamNumber: libc::DWORD, - _dwCallbackReason: libc::DWORD, - _hSourceFile: HANDLE, - _hDestinationFile: HANDLE, - lpData: libc::LPVOID, - ) -> libc::DWORD { + _TotalFileSize: c::LARGE_INTEGER, + TotalBytesTransferred: c::LARGE_INTEGER, + _StreamSize: c::LARGE_INTEGER, + _StreamBytesTransferred: c::LARGE_INTEGER, + _dwStreamNumber: c::DWORD, + _dwCallbackReason: c::DWORD, + _hSourceFile: c::HANDLE, + _hDestinationFile: c::HANDLE, + lpData: c::LPVOID, + ) -> c::DWORD { *(lpData as *mut i64) = TotalBytesTransferred; c::PROGRESS_CONTINUE } @@ -673,10 +670,10 @@ fn directory_junctions_are_directories() { *buf.offset(i) = 0; i += 1; (*db).ReparseTag = c::IO_REPARSE_TAG_MOUNT_POINT; - (*db).ReparseTargetMaximumLength = (i * 2) as libc::WORD; - (*db).ReparseTargetLength = ((i - 1) * 2) as libc::WORD; + (*db).ReparseTargetMaximumLength = (i * 2) as c::WORD; + (*db).ReparseTargetLength = ((i - 1) * 2) as c::WORD; (*db).ReparseDataLength = - (*db).ReparseTargetLength as libc::DWORD + 12; + (*db).ReparseTargetLength as c::DWORD + 12; let mut ret = 0; cvt(c::DeviceIoControl(h as *mut _, @@ -707,10 +704,10 @@ fn directory_junctions_are_directories() { &mut tp.Privileges[0].Luid))); tp.PrivilegeCount = 1; tp.Privileges[0].Attributes = c::SE_PRIVILEGE_ENABLED; - let size = mem::size_of::<c::TOKEN_PRIVILEGES>() as libc::DWORD; - try!(cvt(c::AdjustTokenPrivileges(token, libc::FALSE, &mut tp, size, + let size = mem::size_of::<c::TOKEN_PRIVILEGES>() as c::DWORD; + try!(cvt(c::AdjustTokenPrivileges(token, c::FALSE, &mut tp, size, ptr::null_mut(), ptr::null_mut()))); - try!(cvt(libc::CloseHandle(token))); + try!(cvt(c::CloseHandle(token))); File::open_reparse_point(p, write) } diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index a9e9b0e2520..cb41b05daae 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -10,11 +10,10 @@ 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. @@ -28,17 +27,17 @@ pub struct Handle(RawHandle); /// This does **not** drop the handle when it goes out of scope, use `Handle` /// instead for that. #[derive(Copy, Clone)] -pub struct RawHandle(HANDLE); +pub struct RawHandle(c::HANDLE); unsafe impl Send for RawHandle {} unsafe impl Sync for RawHandle {} impl Handle { - pub fn new(handle: HANDLE) -> Handle { + pub fn new(handle: c::HANDLE) -> Handle { Handle(RawHandle::new(handle)) } - pub fn into_raw(self) -> HANDLE { + pub fn into_raw(self) -> c::HANDLE { let ret = self.raw(); mem::forget(self); return ret; @@ -52,22 +51,22 @@ impl Deref for Handle { impl Drop for Handle { fn drop(&mut self) { - unsafe { let _ = libc::CloseHandle(self.raw()); } + unsafe { let _ = c::CloseHandle(self.raw()); } } } impl RawHandle { - pub fn new(handle: HANDLE) -> RawHandle { + pub fn new(handle: c::HANDLE) -> RawHandle { RawHandle(handle) } - pub fn raw(&self) -> HANDLE { self.0 } + pub fn raw(&self) -> c::HANDLE { self.0 } pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { 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, + c::ReadFile(self.0, buf.as_ptr() as c::LPVOID, + buf.len() as c::DWORD, &mut read, ptr::null_mut()) }); @@ -87,20 +86,20 @@ impl RawHandle { pub fn write(&self, buf: &[u8]) -> io::Result<usize> { let mut amt = 0; try!(cvt(unsafe { - libc::WriteFile(self.0, buf.as_ptr() as libc::LPVOID, - buf.len() as libc::DWORD, &mut amt, + c::WriteFile(self.0, buf.as_ptr() as c::LPVOID, + buf.len() as c::DWORD, &mut amt, ptr::null_mut()) })); Ok(amt as usize) } - pub fn duplicate(&self, access: libc::DWORD, inherit: bool, - options: libc::DWORD) -> io::Result<Handle> { - let mut ret = 0 as libc::HANDLE; + pub fn duplicate(&self, access: c::DWORD, inherit: bool, + options: c::DWORD) -> io::Result<Handle> { + let mut ret = 0 as c::HANDLE; try!(cvt(unsafe { - let cur_proc = GetCurrentProcess(); - DuplicateHandle(cur_proc, self.0, cur_proc, &mut ret, - access, inherit as libc::BOOL, + let cur_proc = c::GetCurrentProcess(); + c::DuplicateHandle(cur_proc, self.0, cur_proc, &mut ret, + access, inherit as c::BOOL, options) })); Ok(Handle::new(ret)) diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 4df3c561ab1..3f76218eafe 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -16,7 +16,6 @@ use prelude::v1::*; use ffi::{OsStr, OsString}; use io::{self, ErrorKind}; -use libc; use num::Zero; use os::windows::ffi::{OsStrExt, OsStringExt}; use path::PathBuf; @@ -46,25 +45,28 @@ pub mod stdio; pub fn init() {} pub fn decode_error_kind(errno: i32) -> ErrorKind { - match errno as libc::c_int { - libc::ERROR_ACCESS_DENIED => ErrorKind::PermissionDenied, - libc::ERROR_ALREADY_EXISTS => ErrorKind::AlreadyExists, - libc::ERROR_BROKEN_PIPE => ErrorKind::BrokenPipe, - libc::ERROR_FILE_NOT_FOUND => ErrorKind::NotFound, - c::ERROR_PATH_NOT_FOUND => ErrorKind::NotFound, - libc::ERROR_NO_DATA => ErrorKind::BrokenPipe, - libc::ERROR_OPERATION_ABORTED => ErrorKind::TimedOut, - - libc::WSAEACCES => ErrorKind::PermissionDenied, - libc::WSAEADDRINUSE => ErrorKind::AddrInUse, - libc::WSAEADDRNOTAVAIL => ErrorKind::AddrNotAvailable, - libc::WSAECONNABORTED => ErrorKind::ConnectionAborted, - libc::WSAECONNREFUSED => ErrorKind::ConnectionRefused, - libc::WSAECONNRESET => ErrorKind::ConnectionReset, - libc::WSAEINVAL => ErrorKind::InvalidInput, - libc::WSAENOTCONN => ErrorKind::NotConnected, - libc::WSAEWOULDBLOCK => ErrorKind::WouldBlock, - libc::WSAETIMEDOUT => ErrorKind::TimedOut, + match errno as c::DWORD { + c::ERROR_ACCESS_DENIED => return ErrorKind::PermissionDenied, + c::ERROR_ALREADY_EXISTS => return ErrorKind::AlreadyExists, + c::ERROR_BROKEN_PIPE => return ErrorKind::BrokenPipe, + c::ERROR_FILE_NOT_FOUND => return ErrorKind::NotFound, + c::ERROR_PATH_NOT_FOUND => return ErrorKind::NotFound, + c::ERROR_NO_DATA => return ErrorKind::BrokenPipe, + c::ERROR_OPERATION_ABORTED => return ErrorKind::TimedOut, + _ => {} + } + + match errno { + c::WSAEACCES => ErrorKind::PermissionDenied, + c::WSAEADDRINUSE => ErrorKind::AddrInUse, + c::WSAEADDRNOTAVAIL => ErrorKind::AddrNotAvailable, + c::WSAECONNABORTED => ErrorKind::ConnectionAborted, + c::WSAECONNREFUSED => ErrorKind::ConnectionRefused, + c::WSAECONNRESET => ErrorKind::ConnectionReset, + c::WSAEINVAL => ErrorKind::InvalidInput, + c::WSAENOTCONN => ErrorKind::NotConnected, + c::WSAEWOULDBLOCK => ErrorKind::WouldBlock, + c::WSAETIMEDOUT => ErrorKind::TimedOut, _ => ErrorKind::Other, } @@ -91,7 +93,7 @@ fn to_utf16_os(s: &OsStr) -> Vec<u16> { // yielded the data which has been read from the syscall. The return value // from this closure is then the return value of the function. fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> io::Result<T> - where F1: FnMut(*mut u16, libc::DWORD) -> libc::DWORD, + where F1: FnMut(*mut u16, c::DWORD) -> c::DWORD, F2: FnOnce(&[u16]) -> T { // Start off with a stack buf but then spill over to the heap if we end up @@ -120,13 +122,12 @@ fn fill_utf16_buf<F1, F2, T>(mut f1: F1, f2: F2) -> io::Result<T> // error" is still 0 then we interpret it as a 0 length buffer and // 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, + let k = match f1(buf.as_mut_ptr(), n as c::DWORD) { + 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() == c::ERROR_INSUFFICIENT_BUFFER { n *= 2; } else if k >= n { n = k; @@ -157,7 +158,7 @@ fn cvt<I: PartialEq + Zero>(i: I) -> io::Result<I> { } } -fn dur2timeout(dur: Duration) -> libc::DWORD { +fn dur2timeout(dur: Duration) -> c::DWORD { // Note that a duration is a (u64, u32) (seconds, nanoseconds) pair, and the // timeouts in windows APIs are typically u32 milliseconds. To translate, we // have two pieces to take care of: @@ -170,10 +171,10 @@ fn dur2timeout(dur: Duration) -> libc::DWORD { }).and_then(|ms| { ms.checked_add(if dur.subsec_nanos() % 1_000_000 > 0 {1} else {0}) }).map(|ms| { - if ms > <libc::DWORD>::max_value() as u64 { - libc::INFINITE + if ms > <c::DWORD>::max_value() as u64 { + c::INFINITE } else { - ms as libc::DWORD + ms as c::DWORD } - }).unwrap_or(libc::INFINITE) + }).unwrap_or(c::INFINITE) } diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 998b4fcb1a1..3e69902dcb6 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -9,23 +9,30 @@ // except according to those terms. use io; -use libc::consts::os::extra::INVALID_SOCKET; -use libc::{self, c_int, c_void}; +use libc::{c_int, c_void}; use mem; -use net::SocketAddr; +use net::{SocketAddr, Shutdown}; use num::One; use ops::Neg; use ptr; use sync::Once; -use sys; use sys::c; +use sys; use sys_common::{self, AsInner, FromInner, IntoInner}; -use sys_common::net::{setsockopt, getsockopt}; +use sys_common::net; use time::Duration; pub type wrlen_t = i32; -pub struct Socket(libc::SOCKET); +pub mod netc { + pub use sys::c::*; + pub use sys::c::SOCKADDR as sockaddr; + pub use sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage; + pub use sys::c::ADDRINFOA as addrinfo; + pub use sys::c::ADDRESS_FAMILY as sa_family_t; +} + +pub struct Socket(c::SOCKET); /// Checks whether the Windows socket interface has been started already, and /// if not, starts it. @@ -76,13 +83,13 @@ pub fn cvt_r<T, F>(mut f: F) -> io::Result<T> impl Socket { pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> { let fam = match *addr { - SocketAddr::V4(..) => libc::AF_INET, - SocketAddr::V6(..) => libc::AF_INET6, + SocketAddr::V4(..) => c::AF_INET, + SocketAddr::V6(..) => c::AF_INET6, }; let socket = try!(unsafe { match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0, c::WSA_FLAG_OVERLAPPED) { - INVALID_SOCKET => Err(last_error()), + c::INVALID_SOCKET => Err(last_error()), n => Ok(Socket(n)), } }); @@ -90,11 +97,11 @@ impl Socket { Ok(socket) } - pub fn accept(&self, storage: *mut libc::sockaddr, - len: *mut libc::socklen_t) -> io::Result<Socket> { + pub fn accept(&self, storage: *mut c::SOCKADDR, + len: *mut c_int) -> io::Result<Socket> { let socket = try!(unsafe { - match libc::accept(self.0, storage, len) { - INVALID_SOCKET => Err(last_error()), + match c::accept(self.0, storage, len) { + c::INVALID_SOCKET => Err(last_error()), n => Ok(Socket(n)), } }); @@ -113,7 +120,7 @@ impl Socket { info.iProtocol, &mut info, 0, c::WSA_FLAG_OVERLAPPED) { - INVALID_SOCKET => Err(last_error()), + c::INVALID_SOCKET => Err(last_error()), n => Ok(Socket(n)), } }); @@ -125,7 +132,7 @@ impl Socket { // On unix when a socket is shut down all further reads return 0, so we // do the same on windows to map a shut down socket to returning EOF. unsafe { - match libc::recv(self.0, buf.as_mut_ptr() as *mut c_void, + match c::recv(self.0, buf.as_mut_ptr() as *mut c_void, buf.len() as i32, 0) { -1 if c::WSAGetLastError() == c::WSAESHUTDOWN => Ok(0), -1 => Err(last_error()), @@ -134,7 +141,8 @@ impl Socket { } } - pub fn set_timeout(&self, dur: Option<Duration>, kind: libc::c_int) -> io::Result<()> { + pub fn set_timeout(&self, dur: Option<Duration>, + kind: c_int) -> io::Result<()> { let timeout = match dur { Some(dur) => { let timeout = sys::dur2timeout(dur); @@ -146,11 +154,11 @@ impl Socket { } None => 0 }; - setsockopt(self, libc::SOL_SOCKET, kind, timeout) + net::setsockopt(self, c::SOL_SOCKET, kind, timeout) } - pub fn timeout(&self, kind: libc::c_int) -> io::Result<Option<Duration>> { - let raw: libc::DWORD = try!(getsockopt(self, libc::SOL_SOCKET, kind)); + pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> { + let raw: c::DWORD = try!(net::getsockopt(self, c::SOL_SOCKET, kind)); if raw == 0 { Ok(None) } else { @@ -162,28 +170,38 @@ impl Socket { fn set_no_inherit(&self) -> io::Result<()> { sys::cvt(unsafe { - c::SetHandleInformation(self.0 as libc::HANDLE, + c::SetHandleInformation(self.0 as c::HANDLE, c::HANDLE_FLAG_INHERIT, 0) }).map(|_| ()) } + + pub fn shutdown(&self, how: Shutdown) -> io::Result<()> { + let how = match how { + Shutdown::Write => c::SD_SEND, + Shutdown::Read => c::SD_RECEIVE, + Shutdown::Both => c::SD_BOTH, + }; + try!(cvt(unsafe { c::shutdown(self.0, how) })); + Ok(()) + } } impl Drop for Socket { fn drop(&mut self) { - let _ = unsafe { libc::closesocket(self.0) }; + let _ = unsafe { c::closesocket(self.0) }; } } -impl AsInner<libc::SOCKET> for Socket { - fn as_inner(&self) -> &libc::SOCKET { &self.0 } +impl AsInner<c::SOCKET> for Socket { + fn as_inner(&self) -> &c::SOCKET { &self.0 } } -impl FromInner<libc::SOCKET> for Socket { - fn from_inner(sock: libc::SOCKET) -> Socket { Socket(sock) } +impl FromInner<c::SOCKET> for Socket { + fn from_inner(sock: c::SOCKET) -> Socket { Socket(sock) } } -impl IntoInner<libc::SOCKET> for Socket { - fn into_inner(self) -> libc::SOCKET { +impl IntoInner<c::SOCKET> for Socket { + fn into_inner(self) -> c::SOCKET { let ret = self.0; mem::forget(self); ret diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 1680ea88d0b..52740b2cad4 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -19,62 +19,36 @@ use error::Error as StdError; use ffi::{OsString, OsStr}; use fmt; use io; -use libc::types::os::arch::extra::LPWCH; -use libc::{self, c_int, c_void}; +use libc::{c_int, c_void}; use ops::Range; use os::windows::ffi::EncodeWide; use path::{self, PathBuf}; use ptr; use slice; -use sys::c; +use sys::{c, cvt}; 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. pub fn error_string(errnum: i32) -> String { - use libc::types::os::arch::extra::DWORD; - use libc::types::os::arch::extra::LPWSTR; - use libc::types::os::arch::extra::LPVOID; - use libc::types::os::arch::extra::WCHAR; - - #[link_name = "kernel32"] - extern "system" { - fn FormatMessageW(flags: DWORD, - lpSrc: LPVOID, - msgId: DWORD, - langId: DWORD, - buf: LPWSTR, - nsize: DWORD, - args: *const c_void) - -> DWORD; - } - - const FORMAT_MESSAGE_FROM_SYSTEM: DWORD = 0x00001000; - const FORMAT_MESSAGE_IGNORE_INSERTS: DWORD = 0x00000200; - // This value is calculated from the macro // MAKELANGID(LANG_SYSTEM_DEFAULT, SUBLANG_SYS_DEFAULT) - let langId = 0x0800 as DWORD; + let langId = 0x0800 as c::DWORD; - let mut buf = [0 as WCHAR; 2048]; + let mut buf = [0 as c::WCHAR; 2048]; unsafe { - let res = FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - ptr::null_mut(), - errnum as DWORD, - langId, - buf.as_mut_ptr(), - buf.len() as DWORD, - ptr::null()) as usize; + let res = c::FormatMessageW(c::FORMAT_MESSAGE_FROM_SYSTEM | + c::FORMAT_MESSAGE_IGNORE_INSERTS, + ptr::null_mut(), + errnum as c::DWORD, + langId, + buf.as_mut_ptr(), + buf.len() as c::DWORD, + ptr::null()) as usize; if res == 0 { // Sometimes FormatMessageW can fail e.g. system doesn't like langId, let fm_err = errno(); @@ -96,8 +70,8 @@ pub fn error_string(errnum: i32) -> String { } pub struct Env { - base: LPWCH, - cur: LPWCH, + base: c::LPWCH, + cur: c::LPWCH, } impl Iterator for Env { @@ -126,13 +100,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()); @@ -233,13 +207,13 @@ impl StdError for JoinPathsError { pub fn current_exe() -> io::Result<PathBuf> { 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<PathBuf> { super::fill_utf16_buf(|buf, sz| unsafe { - libc::GetCurrentDirectoryW(sz, buf) + c::GetCurrentDirectoryW(sz, buf) }, super::os2path) } @@ -248,41 +222,44 @@ pub fn chdir(p: &path::Path) -> io::Result<()> { let mut p = p.encode_wide().collect::<Vec<_>>(); p.push(0); - unsafe { - match libc::SetCurrentDirectoryW(p.as_ptr()) != (0 as libc::BOOL) { - true => Ok(()), - false => Err(io::Error::last_os_error()), - } - } + cvt(unsafe { + c::SetCurrentDirectoryW(p.as_ptr()) + }).map(|_| ()) } -pub fn getenv(k: &OsStr) -> Option<OsString> { +pub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> { let k = super::to_utf16_os(k); - super::fill_utf16_buf(|buf, sz| unsafe { - libc::GetEnvironmentVariableW(k.as_ptr(), buf, sz) + let res = super::fill_utf16_buf(|buf, sz| unsafe { + c::GetEnvironmentVariableW(k.as_ptr(), buf, sz) }, |buf| { OsStringExt::from_wide(buf) - }).ok() + }); + match res { + Ok(value) => Ok(Some(value)), + Err(e) => { + if e.raw_os_error() == Some(c::ERROR_ENVVAR_NOT_FOUND as i32) { + Ok(None) + } else { + Err(e) + } + } + } } -pub fn setenv(k: &OsStr, v: &OsStr) { +pub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> { let k = super::to_utf16_os(k); let v = super::to_utf16_os(v); - unsafe { - if libc::SetEnvironmentVariableW(k.as_ptr(), v.as_ptr()) == 0 { - panic!("failed to set env: {}", io::Error::last_os_error()); - } - } + cvt(unsafe { + c::SetEnvironmentVariableW(k.as_ptr(), v.as_ptr()) + }).map(|_| ()) } -pub fn unsetenv(n: &OsStr) { +pub fn unsetenv(n: &OsStr) -> io::Result<()> { let v = super::to_utf16_os(n); - unsafe { - if libc::SetEnvironmentVariableW(v.as_ptr(), ptr::null()) == 0 { - panic!("failed to unset env: {}", io::Error::last_os_error()); - } - } + cvt(unsafe { + c::SetEnvironmentVariableW(v.as_ptr(), ptr::null()) + }).map(|_| ()) } pub struct Args { @@ -339,8 +316,8 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option<PathBuf> { - getenv("HOME".as_ref()).or_else(|| { - getenv("USERPROFILE".as_ref()) + ::env::var_os("HOME").or_else(|| { + ::env::var_os("USERPROFILE") }).map(PathBuf::from).or_else(|| unsafe { let me = c::GetCurrentProcess(); let mut token = ptr::null_mut(); @@ -350,14 +327,14 @@ pub fn home_dir() -> Option<PathBuf> { 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, + n => n as c::DWORD, } }, super::os2path).ok() }) } pub fn exit(code: i32) -> ! { - unsafe { c::ExitProcess(code as libc::c_uint) } + unsafe { c::ExitProcess(code as c::UINT) } } diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index 3e2f442f073..a6e69c789d0 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -9,7 +9,6 @@ // except according to those terms. use io; -use libc; use ptr; use sys::cvt; use sys::c; @@ -24,8 +23,8 @@ pub struct AnonPipe { } pub fn anon_pipe() -> io::Result<(AnonPipe, AnonPipe)> { - let mut reader = libc::INVALID_HANDLE_VALUE; - let mut writer = libc::INVALID_HANDLE_VALUE; + let mut reader = c::INVALID_HANDLE_VALUE; + let mut writer = c::INVALID_HANDLE_VALUE; try!(cvt(unsafe { c::CreatePipe(&mut reader, &mut writer, ptr::null_mut(), 0) })); @@ -38,7 +37,7 @@ impl AnonPipe { pub fn handle(&self) -> &Handle { &self.inner } pub fn into_handle(self) -> Handle { self.inner } - pub fn raw(&self) -> libc::HANDLE { self.inner.raw() } + pub fn raw(&self) -> c::HANDLE { self.inner.raw() } pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> { self.inner.read(buf) diff --git a/src/libstd/sys/windows/printing/gnu.rs b/src/libstd/sys/windows/printing/gnu.rs index e27bef0b1e9..c1367d5381d 100644 --- a/src/libstd/sys/windows/printing/gnu.rs +++ b/src/libstd/sys/windows/printing/gnu.rs @@ -11,14 +11,15 @@ #![allow(deprecated)] use dynamic_lib::DynamicLibrary; -use io; use io::prelude::*; -use libc; +use io; +use sys::c; +use libc::c_void; use sys_common::gnu::libbacktrace; -pub fn print(w: &mut Write, i: isize, addr: u64, _: &DynamicLibrary, _: libc::HANDLE) +pub fn print(w: &mut Write, i: isize, addr: u64, _: &DynamicLibrary, _: c::HANDLE) -> io::Result<()> { - let addr = addr as usize as *mut libc::c_void; + let addr = addr as usize as *mut c_void; libbacktrace::print(w, i, addr, addr) } diff --git a/src/libstd/sys/windows/printing/msvc.rs b/src/libstd/sys/windows/printing/msvc.rs index 6f1db5df7db..d04691a6a47 100644 --- a/src/libstd/sys/windows/printing/msvc.rs +++ b/src/libstd/sys/windows/printing/msvc.rs @@ -10,22 +10,23 @@ #![allow(deprecated)] -use sys_common::backtrace::{output, output_fileline}; -use ffi::CStr; use dynamic_lib::DynamicLibrary; -use super::{SymFromAddrFn, SymGetLineFromAddr64Fn, SYMBOL_INFO, MAX_SYM_NAME, IMAGEHLP_LINE64}; -use io; +use ffi::CStr; use io::prelude::*; -use intrinsics; -use libc; +use io; +use libc::{c_ulong, c_int, c_char, c_void}; +use mem; +use super::{SymFromAddrFn, SymGetLineFromAddr64Fn}; +use sys::c; +use sys_common::backtrace::{output, output_fileline}; -pub fn print(w: &mut Write, i: isize, addr: u64, dbghelp: &DynamicLibrary, process: libc::HANDLE) - -> io::Result<()> { +pub fn print(w: &mut Write, i: isize, addr: u64, dbghelp: &DynamicLibrary, + process: c::HANDLE) -> io::Result<()> { let SymFromAddr = sym!(dbghelp, "SymFromAddr", SymFromAddrFn); let SymGetLineFromAddr64 = sym!(dbghelp, "SymGetLineFromAddr64", SymGetLineFromAddr64Fn); - let mut info: SYMBOL_INFO = unsafe { intrinsics::init() }; - info.MaxNameLen = MAX_SYM_NAME as libc::c_ulong; + let mut info: c::SYMBOL_INFO = unsafe { mem::zeroed() }; + info.MaxNameLen = c::MAX_SYM_NAME as c_ulong; // the struct size in C. the value is different to // `size_of::<SYMBOL_INFO>() - MAX_SYM_NAME + 1` (== 81) // due to struct alignment. @@ -34,25 +35,25 @@ pub fn print(w: &mut Write, i: isize, addr: u64, dbghelp: &DynamicLibrary, proce let mut displacement = 0u64; let ret = SymFromAddr(process, addr, &mut displacement, &mut info); - let name = if ret == libc::TRUE { - let ptr = info.Name.as_ptr() as *const libc::c_char; + let name = if ret == c::TRUE { + let ptr = info.Name.as_ptr() as *const c_char; Some(unsafe { CStr::from_ptr(ptr).to_bytes() }) } else { None }; - try!(output(w, i, addr as usize as *mut libc::c_void, name)); + try!(output(w, i, addr as usize as *mut c_void, name)); // Now find out the filename and line number - let mut line: IMAGEHLP_LINE64 = unsafe { intrinsics::init() }; - line.SizeOfStruct = ::mem::size_of::<IMAGEHLP_LINE64>() as u32; + let mut line: c::IMAGEHLP_LINE64 = unsafe { mem::zeroed() }; + line.SizeOfStruct = ::mem::size_of::<c::IMAGEHLP_LINE64>() as u32; let mut displacement = 0u32; let ret = SymGetLineFromAddr64(process, addr, &mut displacement, &mut line); - if ret == libc::TRUE { + if ret == c::TRUE { output_fileline(w, unsafe { CStr::from_ptr(line.Filename).to_bytes() }, - line.LineNumber as libc::c_int, + line.LineNumber as c_int, false) } else { Ok(()) diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index ca33e11eea0..e0f8d6f9df9 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -19,13 +19,14 @@ use ffi::{OsString, OsStr}; use fmt; use fs; use io::{self, Error}; -use libc::{self, c_void}; +use libc::c_void; use mem; use os::windows::ffi::OsStrExt; use path::Path; use ptr; use sync::StaticMutex; use sys::c; + use sys::fs::{OpenOptions, File}; use sys::handle::{Handle, RawHandle}; use sys::stdio; @@ -107,7 +108,7 @@ pub struct Process { pub enum Stdio { Inherit, None, - Raw(libc::HANDLE), + Raw(c::HANDLE), } pub type RawStdio = Handle; @@ -118,9 +119,6 @@ impl Process { out_handle: Stdio, err_handle: Stdio) -> io::Result<Process> { - use libc::{TRUE, STARTF_USESTDHANDLES}; - use libc::{DWORD, STARTUPINFO, CreateProcessW}; - // 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 // details. @@ -143,8 +141,8 @@ impl Process { }); let mut si = zeroed_startupinfo(); - si.cb = mem::size_of::<STARTUPINFO>() as DWORD; - si.dwFlags = STARTF_USESTDHANDLES; + si.cb = mem::size_of::<c::STARTUPINFO>() as c::DWORD; + si.dwFlags = c::STARTF_USESTDHANDLES; let stdin = try!(in_handle.to_handle(c::STD_INPUT_HANDLE)); let stdout = try!(out_handle.to_handle(c::STD_OUTPUT_HANDLE)); @@ -159,9 +157,9 @@ impl Process { cmd_str.push(0); // add null terminator // stolen from the libuv code. - let mut flags = libc::CREATE_UNICODE_ENVIRONMENT; + let mut flags = c::CREATE_UNICODE_ENVIRONMENT; if cfg.detach { - flags |= libc::DETACHED_PROCESS | libc::CREATE_NEW_PROCESS_GROUP; + flags |= c::DETACHED_PROCESS | c::CREATE_NEW_PROCESS_GROUP; } let (envp, _data) = make_envp(cfg.env.as_ref()); @@ -173,12 +171,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(), + c::TRUE, flags, envp, dirp, + &mut si, &mut pi)) }); // We close the thread handle because we don't care about keeping @@ -190,7 +188,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(()) } @@ -201,21 +199,14 @@ impl Process { } pub fn wait(&self) -> io::Result<ExitStatus> { - 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))); - if status != STILL_ACTIVE { - return Ok(ExitStatus(status as i32)); - } - match WaitForSingleObject(self.handle.raw(), INFINITE) { - WAIT_OBJECT_0 => {} - _ => return Err(Error::last_os_error()), - } + let res = c::WaitForSingleObject(self.handle.raw(), c::INFINITE); + if res != c::WAIT_OBJECT_0 { + return Err(Error::last_os_error()) } + let mut status = 0; + try!(cvt(c::GetExitCodeProcess(self.handle.raw(), &mut status))); + Ok(ExitStatus(status)) } } @@ -225,14 +216,14 @@ impl Process { } #[derive(PartialEq, Eq, Clone, Copy, Debug)] -pub struct ExitStatus(i32); +pub struct ExitStatus(c::DWORD); impl ExitStatus { pub fn success(&self) -> bool { self.0 == 0 } pub fn code(&self) -> Option<i32> { - Some(self.0) + Some(self.0 as i32) } } @@ -242,8 +233,8 @@ impl fmt::Display for ExitStatus { } } -fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO { - libc::types::os::arch::extra::STARTUPINFO { +fn zeroed_startupinfo() -> c::STARTUPINFO { + c::STARTUPINFO { cb: 0, lpReserved: ptr::null_mut(), lpDesktop: ptr::null_mut(), @@ -259,14 +250,14 @@ fn zeroed_startupinfo() -> libc::types::os::arch::extra::STARTUPINFO { wShowWindow: 0, cbReserved2: 0, lpReserved2: ptr::null_mut(), - hStdInput: libc::INVALID_HANDLE_VALUE, - hStdOutput: libc::INVALID_HANDLE_VALUE, - hStdError: libc::INVALID_HANDLE_VALUE, + hStdInput: c::INVALID_HANDLE_VALUE, + hStdOutput: c::INVALID_HANDLE_VALUE, + hStdError: c::INVALID_HANDLE_VALUE, } } -fn zeroed_process_information() -> libc::types::os::arch::extra::PROCESS_INFORMATION { - libc::types::os::arch::extra::PROCESS_INFORMATION { +fn zeroed_process_information() -> c::PROCESS_INFORMATION { + c::PROCESS_INFORMATION { hProcess: ptr::null_mut(), hThread: ptr::null_mut(), dwProcessId: 0, @@ -358,17 +349,15 @@ fn make_dirp(d: Option<&OsString>) -> (*const u16, Vec<u16>) { } impl Stdio { - fn to_handle(&self, stdio_id: libc::DWORD) -> io::Result<Handle> { - use libc::DUPLICATE_SAME_ACCESS; - + fn to_handle(&self, stdio_id: c::DWORD) -> io::Result<Handle> { match *self { Stdio::Inherit => { stdio::get(stdio_id).and_then(|io| { - io.handle().duplicate(0, true, DUPLICATE_SAME_ACCESS) + io.handle().duplicate(0, true, c::DUPLICATE_SAME_ACCESS) }) } Stdio::Raw(handle) => { - RawHandle::new(handle).duplicate(0, true, DUPLICATE_SAME_ACCESS) + RawHandle::new(handle).duplicate(0, true, c::DUPLICATE_SAME_ACCESS) } // Similarly to unix, we don't actually leave holes for the @@ -376,9 +365,9 @@ impl Stdio { // equivalents. These equivalents are drawn from libuv's // windows process spawning. Stdio::None => { - let size = mem::size_of::<libc::SECURITY_ATTRIBUTES>(); - let mut sa = libc::SECURITY_ATTRIBUTES { - nLength: size as libc::DWORD, + let size = mem::size_of::<c::SECURITY_ATTRIBUTES>(); + let mut sa = c::SECURITY_ATTRIBUTES { + nLength: size as c::DWORD, lpSecurityDescriptor: ptr::null_mut(), bInheritHandle: 1, }; diff --git a/src/libstd/sys/windows/stack_overflow.rs b/src/libstd/sys/windows/stack_overflow.rs index d1c2144ef0d..01317bec0de 100644 --- a/src/libstd/sys/windows/stack_overflow.rs +++ b/src/libstd/sys/windows/stack_overflow.rs @@ -8,7 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use libc::{self, LONG}; use sys_common::util::report_overflow; use sys::c; @@ -19,7 +18,7 @@ impl Handler { // This API isn't available on XP, so don't panic in that case and just // pray it works out ok. if c::SetThreadStackGuarantee(&mut 0x5000) == 0 { - if libc::GetLastError() as u32 != libc::ERROR_CALL_NOT_IMPLEMENTED as u32 { + if c::GetLastError() as u32 != c::ERROR_CALL_NOT_IMPLEMENTED as u32 { panic!("failed to reserve stack space for exception handling"); } } @@ -28,7 +27,7 @@ impl Handler { } extern "system" fn vectored_handler(ExceptionInfo: *mut c::EXCEPTION_POINTERS) - -> LONG { + -> c::LONG { unsafe { let rec = &(*(*ExceptionInfo).ExceptionRecord); let code = rec.ExceptionCode; diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs index 356787d5bf0..8f37dc02e87 100644 --- a/src/libstd/sys/windows/stdio.rs +++ b/src/libstd/sys/windows/stdio.rs @@ -12,7 +12,6 @@ use prelude::v1::*; use io::prelude::*; use io::{self, Cursor}; -use libc; use ptr; use str; use sync::Mutex; @@ -34,9 +33,9 @@ pub struct Stdin { pub struct Stdout(Output); pub struct Stderr(Output); -pub fn get(handle: libc::DWORD) -> io::Result<Output> { +pub fn get(handle: c::DWORD) -> io::Result<Output> { let handle = unsafe { c::GetStdHandle(handle) }; - if handle == libc::INVALID_HANDLE_VALUE { + if handle == c::INVALID_HANDLE_VALUE { Err(io::Error::last_os_error()) } else if handle.is_null() { Err(io::Error::new(io::ErrorKind::Other, @@ -63,7 +62,7 @@ fn write(out: &Output, data: &[u8]) -> io::Result<usize> { let mut written = 0; try!(cvt(unsafe { c::WriteConsoleW(handle, - utf16.as_ptr() as libc::LPCVOID, + utf16.as_ptr() as c::LPCVOID, utf16.len() as u32, &mut written, ptr::null_mut()) @@ -97,7 +96,7 @@ impl Stdin { let mut num = 0; try!(cvt(unsafe { c::ReadConsoleW(handle, - utf16.as_mut_ptr() as libc::LPVOID, + utf16.as_mut_ptr() as c::LPVOID, utf16.len() as u32, &mut num, ptr::null_mut()) @@ -147,7 +146,7 @@ impl io::Write for Stderr { } impl NoClose { - fn new(handle: libc::HANDLE) -> NoClose { + fn new(handle: c::HANDLE) -> NoClose { NoClose(Some(Handle::new(handle))) } diff --git a/src/libstd/sys/windows/thread.rs b/src/libstd/sys/windows/thread.rs index cf1b3ebddb9..a6e6cc94b76 100644 --- a/src/libstd/sys/windows/thread.rs +++ b/src/libstd/sys/windows/thread.rs @@ -12,8 +12,8 @@ use prelude::v1::*; use alloc::boxed::FnBox; use io; -use libc::{self, c_void, DWORD}; use mem; +use libc::c_void; use ptr; use sys::c; use sys::handle::Handle; @@ -37,7 +37,7 @@ impl Thread { // Round up to the next 64 kB because that's what the NT kernel does, // might as well make it explicit. let stack_size = (stack + 0xfffe) & (!0xfffe); - let ret = c::CreateThread(ptr::null_mut(), stack_size as libc::size_t, + let ret = c::CreateThread(ptr::null_mut(), stack_size, thread_start, &*p as *const _ as *mut _, 0, ptr::null_mut()); @@ -48,7 +48,7 @@ impl Thread { Ok(Thread { handle: Handle::new(ret) }) }; - extern "system" fn thread_start(main: *mut libc::c_void) -> DWORD { + extern "system" fn thread_start(main: *mut c_void) -> c::DWORD { unsafe { start_thread(main); } 0 } @@ -62,8 +62,7 @@ impl Thread { } pub fn join(self) { - use libc::consts::os::extra::INFINITE; - unsafe { c::WaitForSingleObject(self.handle.raw(), INFINITE); } + unsafe { c::WaitForSingleObject(self.handle.raw(), c::INFINITE); } } pub fn yield_now() { diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index c544eec7fce..db2ad1d89c4 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -10,13 +10,12 @@ use prelude::v1::*; -use libc::types::os::arch::extra::{DWORD, LPVOID, BOOL}; - use ptr; -use sys_common; +use sys::c; use sys_common::mutex::Mutex; +use sys_common; -pub type Key = DWORD; +pub type Key = c::DWORD; pub type Dtor = unsafe extern fn(*mut u8); // Turns out, like pretty much everything, Windows is pretty close the @@ -68,9 +67,8 @@ static mut DTORS: *mut Vec<(Key, Dtor)> = ptr::null_mut(); #[inline] pub unsafe fn create(dtor: Option<Dtor>) -> Key { - const TLS_OUT_OF_INDEXES: DWORD = 0xFFFFFFFF; - let key = TlsAlloc(); - assert!(key != TLS_OUT_OF_INDEXES); + let key = c::TlsAlloc(); + assert!(key != c::TLS_OUT_OF_INDEXES); match dtor { Some(f) => register_dtor(key, f), None => {} @@ -80,13 +78,13 @@ pub unsafe fn create(dtor: Option<Dtor>) -> Key { #[inline] pub unsafe fn set(key: Key, value: *mut u8) { - let r = TlsSetValue(key, value as LPVOID); + let r = c::TlsSetValue(key, value as c::LPVOID); debug_assert!(r != 0); } #[inline] pub unsafe fn get(key: Key) -> *mut u8 { - TlsGetValue(key) as *mut u8 + c::TlsGetValue(key) as *mut u8 } #[inline] @@ -107,18 +105,11 @@ pub unsafe fn destroy(key: Key) { // Note that source [2] above shows precedent for this sort // of strategy. } else { - let r = TlsFree(key); + let r = c::TlsFree(key); debug_assert!(r != 0); } } -extern "system" { - fn TlsAlloc() -> DWORD; - fn TlsFree(dwTlsIndex: DWORD) -> BOOL; - fn TlsGetValue(dwTlsIndex: DWORD) -> LPVOID; - fn TlsSetValue(dwTlsIndex: DWORD, lpTlsvalue: LPVOID) -> BOOL; -} - // ------------------------------------------------------------------------- // Dtor registration // @@ -243,17 +234,15 @@ unsafe fn unregister_dtor(key: Key) -> bool { #[link_section = ".CRT$XLB"] #[linkage = "external"] #[allow(warnings)] -pub static p_thread_callback: unsafe extern "system" fn(LPVOID, DWORD, - LPVOID) = +pub static p_thread_callback: unsafe extern "system" fn(c::LPVOID, c::DWORD, + c::LPVOID) = on_tls_callback; #[allow(warnings)] -unsafe extern "system" fn on_tls_callback(h: LPVOID, - dwReason: DWORD, - pv: LPVOID) { - const DLL_THREAD_DETACH: DWORD = 3; - const DLL_PROCESS_DETACH: DWORD = 0; - if dwReason == DLL_THREAD_DETACH || dwReason == DLL_PROCESS_DETACH { +unsafe extern "system" fn on_tls_callback(h: c::LPVOID, + dwReason: c::DWORD, + pv: c::LPVOID) { + if dwReason == c::DLL_THREAD_DETACH || dwReason == c::DLL_PROCESS_DETACH { run_dtors(); } @@ -286,9 +275,9 @@ unsafe fn run_dtors() { ret }; for &(key, dtor) in &dtors { - let ptr = TlsGetValue(key); + let ptr = c::TlsGetValue(key); if !ptr.is_null() { - TlsSetValue(key, ptr::null_mut()); + c::TlsSetValue(key, ptr::null_mut()); dtor(ptr as *mut _); any_run = true; } diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs index f5a70ccc907..4dc7997d22e 100644 --- a/src/libstd/sys/windows/time.rs +++ b/src/libstd/sys/windows/time.rs @@ -7,32 +7,33 @@ // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. -use libc; + use ops::Sub; -use time::Duration; use sync::Once; +use sys::c; +use time::Duration; const NANOS_PER_SEC: u64 = 1_000_000_000; pub struct SteadyTime { - t: libc::LARGE_INTEGER, + t: c::LARGE_INTEGER, } 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 } } -fn frequency() -> libc::LARGE_INTEGER { - static mut FREQUENCY: libc::LARGE_INTEGER = 0; +fn frequency() -> c::LARGE_INTEGER { + static mut FREQUENCY: c::LARGE_INTEGER = 0; static ONCE: Once = Once::new(); unsafe { ONCE.call_once(|| { - libc::QueryPerformanceFrequency(&mut FREQUENCY); + c::QueryPerformanceFrequency(&mut FREQUENCY); }); FREQUENCY } |