1 #![unstable(issue = "none", feature = "windows_net")]
4 use crate::io::{self, IoSlice, IoSliceMut, Read};
6 use crate::net::{Shutdown, SocketAddr};
11 use crate::sys_common::net;
12 use crate::sys_common::{AsInner, FromInner, IntoInner};
13 use crate::time::Duration;
15 use libc::{c_int, c_long, c_ulong, c_void};
17 pub type wrlen_t = i32;
20 pub use crate::sys::c::ADDRESS_FAMILY as sa_family_t;
21 pub use crate::sys::c::ADDRINFOA as addrinfo;
22 pub use crate::sys::c::SOCKADDR as sockaddr;
23 pub use crate::sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage;
24 pub use crate::sys::c::*;
27 pub struct Socket(c::SOCKET);
29 /// Checks whether the Windows socket interface has been started already, and
30 /// if not, starts it.
32 static START: Once = Once::new();
34 START.call_once(|| unsafe {
35 let mut data: c::WSADATA = mem::zeroed();
36 let ret = c::WSAStartup(
50 /// Returns the last error from the Windows socket interface.
51 fn last_error() -> io::Error {
52 io::Error::from_raw_os_error(unsafe { c::WSAGetLastError() })
56 pub trait IsMinusOne {
57 fn is_minus_one(&self) -> bool;
60 macro_rules! impl_is_minus_one {
61 ($($t:ident)*) => ($(impl IsMinusOne for $t {
62 fn is_minus_one(&self) -> bool {
68 impl_is_minus_one! { i8 i16 i32 i64 isize }
70 /// Checks if the signed integer is the Windows constant `SOCKET_ERROR` (-1)
71 /// and if so, returns the last error from the Windows socket interface. This
72 /// function must be called before another call to the socket API is made.
73 pub fn cvt<T: IsMinusOne>(t: T) -> io::Result<T> {
74 if t.is_minus_one() { Err(last_error()) } else { Ok(t) }
77 /// A variant of `cvt` for `getaddrinfo` which return 0 for a success.
78 pub fn cvt_gai(err: c_int) -> io::Result<()> {
79 if err == 0 { Ok(()) } else { Err(last_error()) }
82 /// Just to provide the same interface as sys/unix/net.rs
83 pub fn cvt_r<T, F>(mut f: F) -> io::Result<T>
92 pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
93 let fam = match *addr {
94 SocketAddr::V4(..) => c::AF_INET,
95 SocketAddr::V6(..) => c::AF_INET6,
104 c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT,
106 c::INVALID_SOCKET => match c::WSAGetLastError() {
107 c::WSAEPROTOTYPE | c::WSAEINVAL => {
108 match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0, c::WSA_FLAG_OVERLAPPED)
110 c::INVALID_SOCKET => Err(last_error()),
118 n => Err(io::Error::from_raw_os_error(n)),
126 pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> {
127 self.set_nonblocking(true)?;
129 let (addrp, len) = addr.into_inner();
130 cvt(c::connect(self.0, addrp, len))
132 self.set_nonblocking(false)?;
135 Ok(_) => return Ok(()),
136 Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {}
137 Err(e) => return Err(e),
140 if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
141 return Err(io::Error::new_const(
142 io::ErrorKind::InvalidInput,
143 &"cannot set a 0 duration timeout",
147 let mut timeout = c::timeval {
148 tv_sec: timeout.as_secs() as c_long,
149 tv_usec: (timeout.subsec_nanos() / 1000) as c_long,
151 if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
156 let mut fds = mem::zeroed::<c::fd_set>();
158 fds.fd_array[0] = self.0;
162 let mut writefds = fds;
163 let mut errorfds = fds;
166 unsafe { cvt(c::select(1, ptr::null_mut(), &mut writefds, &mut errorfds, &timeout))? };
169 0 => Err(io::Error::new_const(io::ErrorKind::TimedOut, &"connection timed out")),
171 if writefds.fd_count != 1 {
172 if let Some(e) = self.take_error()? {
181 pub fn accept(&self, storage: *mut c::SOCKADDR, len: *mut c_int) -> io::Result<Socket> {
182 let socket = unsafe {
183 match c::accept(self.0, storage, len) {
184 c::INVALID_SOCKET => Err(last_error()),
191 pub fn duplicate(&self) -> io::Result<Socket> {
192 let socket = unsafe {
193 let mut info: c::WSAPROTOCOL_INFO = mem::zeroed();
194 cvt(c::WSADuplicateSocketW(self.0, c::GetCurrentProcessId(), &mut info))?;
202 c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT,
204 c::INVALID_SOCKET => match c::WSAGetLastError() {
205 c::WSAEPROTOTYPE | c::WSAEINVAL => {
212 c::WSA_FLAG_OVERLAPPED,
214 c::INVALID_SOCKET => Err(last_error()),
222 n => Err(io::Error::from_raw_os_error(n)),
230 fn recv_with_flags(&self, buf: &mut [u8], flags: c_int) -> io::Result<usize> {
231 // On unix when a socket is shut down all further reads return 0, so we
232 // do the same on windows to map a shut down socket to returning EOF.
233 let len = cmp::min(buf.len(), i32::MAX as usize) as i32;
235 match c::recv(self.0, buf.as_mut_ptr() as *mut c_void, len, flags) {
236 -1 if c::WSAGetLastError() == c::WSAESHUTDOWN => Ok(0),
237 -1 => Err(last_error()),
243 pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
244 self.recv_with_flags(buf, 0)
247 pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
248 // On unix when a socket is shut down all further reads return 0, so we
249 // do the same on windows to map a shut down socket to returning EOF.
250 let len = cmp::min(bufs.len(), c::DWORD::MAX as usize) as c::DWORD;
254 let ret = c::WSARecv(
256 bufs.as_mut_ptr() as *mut c::WSABUF,
264 0 => Ok(nread as usize),
265 _ if c::WSAGetLastError() == c::WSAESHUTDOWN => Ok(0),
266 _ => Err(last_error()),
272 pub fn is_read_vectored(&self) -> bool {
276 pub fn peek(&self, buf: &mut [u8]) -> io::Result<usize> {
277 self.recv_with_flags(buf, c::MSG_PEEK)
280 fn recv_from_with_flags(
284 ) -> io::Result<(usize, SocketAddr)> {
285 let mut storage: c::SOCKADDR_STORAGE_LH = unsafe { mem::zeroed() };
286 let mut addrlen = mem::size_of_val(&storage) as c::socklen_t;
287 let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
289 // On unix when a socket is shut down all further reads return 0, so we
290 // do the same on windows to map a shut down socket to returning EOF.
294 buf.as_mut_ptr() as *mut c_void,
297 &mut storage as *mut _ as *mut _,
300 -1 if c::WSAGetLastError() == c::WSAESHUTDOWN => {
301 Ok((0, net::sockaddr_to_addr(&storage, addrlen as usize)?))
303 -1 => Err(last_error()),
304 n => Ok((n as usize, net::sockaddr_to_addr(&storage, addrlen as usize)?)),
309 pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
310 self.recv_from_with_flags(buf, 0)
313 pub fn peek_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {
314 self.recv_from_with_flags(buf, c::MSG_PEEK)
317 pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
318 let len = cmp::min(bufs.len(), c::DWORD::MAX as usize) as c::DWORD;
319 let mut nwritten = 0;
323 bufs.as_ptr() as *const c::WSABUF as *mut c::WSABUF,
331 Ok(nwritten as usize)
335 pub fn is_write_vectored(&self) -> bool {
339 pub fn set_timeout(&self, dur: Option<Duration>, kind: c_int) -> io::Result<()> {
340 let timeout = match dur {
342 let timeout = sys::dur2timeout(dur);
344 return Err(io::Error::new_const(
345 io::ErrorKind::InvalidInput,
346 &"cannot set a 0 duration timeout",
353 net::setsockopt(self, c::SOL_SOCKET, kind, timeout)
356 pub fn timeout(&self, kind: c_int) -> io::Result<Option<Duration>> {
357 let raw: c::DWORD = net::getsockopt(self, c::SOL_SOCKET, kind)?;
361 let secs = raw / 1000;
362 let nsec = (raw % 1000) * 1000000;
363 Ok(Some(Duration::new(secs as u64, nsec as u32)))
367 #[cfg(not(target_vendor = "uwp"))]
368 fn set_no_inherit(&self) -> io::Result<()> {
369 sys::cvt(unsafe { c::SetHandleInformation(self.0 as c::HANDLE, c::HANDLE_FLAG_INHERIT, 0) })
373 #[cfg(target_vendor = "uwp")]
374 fn set_no_inherit(&self) -> io::Result<()> {
375 Err(io::Error::new_const(io::ErrorKind::Unsupported, &"Unavailable on UWP"))
378 pub fn shutdown(&self, how: Shutdown) -> io::Result<()> {
379 let how = match how {
380 Shutdown::Write => c::SD_SEND,
381 Shutdown::Read => c::SD_RECEIVE,
382 Shutdown::Both => c::SD_BOTH,
384 cvt(unsafe { c::shutdown(self.0, how) })?;
388 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
389 let mut nonblocking = nonblocking as c_ulong;
390 let r = unsafe { c::ioctlsocket(self.0, c::FIONBIO as c_int, &mut nonblocking) };
391 if r == 0 { Ok(()) } else { Err(io::Error::last_os_error()) }
394 pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {
395 net::setsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY, nodelay as c::BYTE)
398 pub fn nodelay(&self) -> io::Result<bool> {
399 let raw: c::BYTE = net::getsockopt(self, c::IPPROTO_TCP, c::TCP_NODELAY)?;
403 pub fn take_error(&self) -> io::Result<Option<io::Error>> {
404 let raw: c_int = net::getsockopt(self, c::SOL_SOCKET, c::SO_ERROR)?;
405 if raw == 0 { Ok(None) } else { Ok(Some(io::Error::from_raw_os_error(raw as i32))) }
409 #[unstable(reason = "not public", issue = "none", feature = "fd_read")]
410 impl<'a> Read for &'a Socket {
411 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
416 impl Drop for Socket {
418 let _ = unsafe { c::closesocket(self.0) };
422 impl AsInner<c::SOCKET> for Socket {
423 fn as_inner(&self) -> &c::SOCKET {
428 impl FromInner<c::SOCKET> for Socket {
429 fn from_inner(sock: c::SOCKET) -> Socket {
434 impl IntoInner<c::SOCKET> for Socket {
435 fn into_inner(self) -> c::SOCKET {