mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #85792 - mjptree:refactor-windows-sockets, r=JohnTitor

Browse Source 
Refactor windows sockets impl methods

No behavioural changes, but a bit tidier visual flow.
This commit is contained in:
Yuki Okushi 2021-06-15 17:40:09 +09:00 committed by GitHub
commit 3f4d6d73a9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 171 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
library/std/src/sys/windows/c.rs
View File

@ -234,6 +234,7 @@ pub const SD_RECEIVE: c_int = 0;
pub const SD_SEND: c_int = 1; pub const SD_SEND: c_int = 1;
pub const SOCK_DGRAM: c_int = 2; pub const SOCK_DGRAM: c_int = 2;
pub const SOCK_STREAM: c_int = 1; pub const SOCK_STREAM: c_int = 1;
pub const SOCKET_ERROR: c_int = -1;
pub const SOL_SOCKET: c_int = 0xffff; pub const SOL_SOCKET: c_int = 0xffff;
pub const SO_RCVTIMEO: c_int = 0x1006; pub const SO_RCVTIMEO: c_int = 0x1006;
pub const SO_SNDTIMEO: c_int = 0x1005; pub const SO_SNDTIMEO: c_int = 0x1005;

301
library/std/src/sys/windows/net.rs
View File

@ -12,7 +12,7 @@ use crate::sys_common::net;
use crate::sys_common::{AsInner, FromInner, IntoInner}; use crate::sys_common::{AsInner, FromInner, IntoInner};
use crate::time::Duration; use crate::time::Duration;
use libc::{c_int, c_long, c_ulong, c_void}; use libc::{c_int, c_long, c_ulong};
pub type wrlen_t = i32; pub type wrlen_t = i32;
@ -93,153 +93,177 @@ where
impl Socket { impl Socket {
pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> { pub fn new(addr: &SocketAddr, ty: c_int) -> io::Result<Socket> {
let fam = match *addr { let family = match *addr {
SocketAddr::V4(..) => c::AF_INET, SocketAddr::V4(..) => c::AF_INET,
SocketAddr::V6(..) => c::AF_INET6, SocketAddr::V6(..) => c::AF_INET6,
}; };
let socket = unsafe { let socket = unsafe {
match c::WSASocketW( c::WSASocketW(
fam, family,
ty, ty,
0, 0,
ptr::null_mut(), ptr::null_mut(),
0, 0,
c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT, c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT,
) { )
c::INVALID_SOCKET => match c::WSAGetLastError() { };
c::WSAEPROTOTYPE | c::WSAEINVAL => {
match c::WSASocketW(fam, ty, 0, ptr::null_mut(), 0, c::WSA_FLAG_OVERLAPPED) if socket != c::INVALID_SOCKET {
{ Ok(Self(socket))
c::INVALID_SOCKET => Err(last_error()), } else {
n => { let error = unsafe { c::WSAGetLastError() };
let s = Socket(n);
s.set_no_inherit()?; if error != c::WSAEPROTOTYPE && error != c::WSAEINVAL {
Ok(s) return Err(io::Error::from_raw_os_error(error));
}
}
}
n => Err(io::Error::from_raw_os_error(n)),
},
n => Ok(Socket(n)),
} }
}?;
Ok(socket) let socket =
unsafe { c::WSASocketW(family, ty, 0, ptr::null_mut(), 0, c::WSA_FLAG_OVERLAPPED) };
if socket == c::INVALID_SOCKET {
return Err(last_error());
}
let socket = Self(socket);
socket.set_no_inherit()?;
Ok(socket)
}
} }
pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> { pub fn connect_timeout(&self, addr: &SocketAddr, timeout: Duration) -> io::Result<()> {
self.set_nonblocking(true)?; self.set_nonblocking(true)?;
let r = unsafe { let result = {
let (addrp, len) = addr.into_inner(); let (addrp, len) = addr.into_inner();
cvt(c::connect(self.0, addrp, len)) let result = unsafe { c::connect(self.0, addrp, len) };
cvt(result).map(drop)
}; };
self.set_nonblocking(false)?; self.set_nonblocking(false)?;
match r { match result {
Ok(_) => return Ok(()), Err(ref error) if error.kind() == io::ErrorKind::WouldBlock => {
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {} if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 {
Err(e) => return Err(e), return Err(io::Error::new_const(
} io::ErrorKind::InvalidInput,
&"cannot set a 0 duration timeout",
));
}
if timeout.as_secs() == 0 && timeout.subsec_nanos() == 0 { let mut timeout = c::timeval {
return Err(io::Error::new_const( tv_sec: timeout.as_secs() as c_long,
io::ErrorKind::InvalidInput, tv_usec: (timeout.subsec_nanos() / 1000) as c_long,
&"cannot set a 0 duration timeout", };
));
}
let mut timeout = c::timeval { if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
tv_sec: timeout.as_secs() as c_long, timeout.tv_usec = 1;
tv_usec: (timeout.subsec_nanos() / 1000) as c_long, }
};
if timeout.tv_sec == 0 && timeout.tv_usec == 0 {
timeout.tv_usec = 1;
}
let fds = unsafe { let fds = {
let mut fds = mem::zeroed::<c::fd_set>(); let mut fds = unsafe { mem::zeroed::<c::fd_set>() };
fds.fd_count = 1; fds.fd_count = 1;
fds.fd_array[0] = self.0; fds.fd_array[0] = self.0;
fds fds
}; };
let mut writefds = fds; let mut writefds = fds;
let mut errorfds = fds; let mut errorfds = fds;
let n = let count = {
unsafe { cvt(c::select(1, ptr::null_mut(), &mut writefds, &mut errorfds, &timeout))? }; let result = unsafe {
c::select(1, ptr::null_mut(), &mut writefds, &mut errorfds, &timeout)
};
cvt(result)?
};
match n { match count {
0 => Err(io::Error::new_const(io::ErrorKind::TimedOut, &"connection timed out")), 0 => {
_ => { Err(io::Error::new_const(io::ErrorKind::TimedOut, &"connection timed out"))
if writefds.fd_count != 1 { }
if let Some(e) = self.take_error()? { _ => {
return Err(e); if writefds.fd_count != 1 {
if let Some(e) = self.take_error()? {
return Err(e);
}
}
Ok(())
} }
} }
Ok(())
} }
_ => result,
} }
} }
pub fn accept(&self, storage: *mut c::SOCKADDR, len: *mut c_int) -> io::Result<Socket> { pub fn accept(&self, storage: *mut c::SOCKADDR, len: *mut c_int) -> io::Result<Socket> {
let socket = unsafe { let socket = unsafe { c::accept(self.0, storage, len) };
match c::accept(self.0, storage, len) {
c::INVALID_SOCKET => Err(last_error()), match socket {
n => Ok(Socket(n)), c::INVALID_SOCKET => Err(last_error()),
} _ => Ok(Self(socket)),
}?; }
Ok(socket)
} }
pub fn duplicate(&self) -> io::Result<Socket> { pub fn duplicate(&self) -> io::Result<Socket> {
let mut info = unsafe { mem::zeroed::<c::WSAPROTOCOL_INFO>() };
let result = unsafe { c::WSADuplicateSocketW(self.0, c::GetCurrentProcessId(), &mut info) };
cvt(result)?;
let socket = unsafe { let socket = unsafe {
let mut info: c::WSAPROTOCOL_INFO = mem::zeroed(); c::WSASocketW(
cvt(c::WSADuplicateSocketW(self.0, c::GetCurrentProcessId(), &mut info))?;
match c::WSASocketW(
info.iAddressFamily, info.iAddressFamily,
info.iSocketType, info.iSocketType,
info.iProtocol, info.iProtocol,
&mut info, &mut info,
0, 0,
c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT, c::WSA_FLAG_OVERLAPPED | c::WSA_FLAG_NO_HANDLE_INHERIT,
) { )
c::INVALID_SOCKET => match c::WSAGetLastError() { };
c::WSAEPROTOTYPE | c::WSAEINVAL => {
match c::WSASocketW( if socket != c::INVALID_SOCKET {
info.iAddressFamily, Ok(Self(socket))
info.iSocketType, } else {
info.iProtocol, let error = unsafe { c::WSAGetLastError() };
&mut info,
0, if error != c::WSAEPROTOTYPE && error != c::WSAEINVAL {
c::WSA_FLAG_OVERLAPPED, return Err(io::Error::from_raw_os_error(error));
) {
c::INVALID_SOCKET => Err(last_error()),
n => {
let s = Socket(n);
s.set_no_inherit()?;
Ok(s)
}
}
}
n => Err(io::Error::from_raw_os_error(n)),
},
n => Ok(Socket(n)),
} }
}?;
Ok(socket) let socket = unsafe {
c::WSASocketW(
info.iAddressFamily,
info.iSocketType,
info.iProtocol,
&mut info,
0,
c::WSA_FLAG_OVERLAPPED,
)
};
if socket == c::INVALID_SOCKET {
return Err(last_error());
}
let socket = Self(socket);
socket.set_no_inherit()?;
Ok(socket)
}
} }
fn recv_with_flags(&self, buf: &mut [u8], flags: c_int) -> io::Result<usize> { fn recv_with_flags(&self, buf: &mut [u8], flags: c_int) -> io::Result<usize> {
// On unix when a socket is shut down all further reads return 0, so we // 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. // do the same on windows to map a shut down socket to returning EOF.
let len = cmp::min(buf.len(), i32::MAX as usize) as i32; let length = cmp::min(buf.len(), i32::MAX as usize) as i32;
unsafe { let result = unsafe { c::recv(self.0, buf.as_mut_ptr() as *mut _, length, flags) };
match c::recv(self.0, buf.as_mut_ptr() as *mut c_void, len, flags) {
-1 if c::WSAGetLastError() == c::WSAESHUTDOWN => Ok(0), match result {
-1 => Err(last_error()), c::SOCKET_ERROR => {
n => Ok(n as usize), let error = unsafe { c::WSAGetLastError() };
if error == c::WSAESHUTDOWN {
Ok(0)
} else {
Err(io::Error::from_raw_os_error(error))
}
} }
_ => Ok(result as usize),
} }
} }
@ -250,23 +274,31 @@ impl Socket {
pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> { pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
// On unix when a socket is shut down all further reads return 0, so we // 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. // do the same on windows to map a shut down socket to returning EOF.
let len = cmp::min(bufs.len(), c::DWORD::MAX as usize) as c::DWORD; let length = cmp::min(bufs.len(), c::DWORD::MAX as usize) as c::DWORD;
let mut nread = 0; let mut nread = 0;
let mut flags = 0; let mut flags = 0;
unsafe { let result = unsafe {
let ret = c::WSARecv( c::WSARecv(
self.0, self.0,
bufs.as_mut_ptr() as *mut c::WSABUF, bufs.as_mut_ptr() as *mut c::WSABUF,
len, length,
&mut nread, &mut nread,
&mut flags, &mut flags,
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
); )
match ret { };
0 => Ok(nread as usize),
_ if c::WSAGetLastError() == c::WSAESHUTDOWN => Ok(0), match result {
_ => Err(last_error()), 0 => Ok(nread as usize),
_ => {
let error = unsafe { c::WSAGetLastError() };
if error == c::WSAESHUTDOWN {
Ok(0)
} else {
Err(io::Error::from_raw_os_error(error))
}
} }
} }
} }
@ -285,27 +317,34 @@ impl Socket {
buf: &mut [u8], buf: &mut [u8],
flags: c_int, flags: c_int,
) -> io::Result<(usize, SocketAddr)> { ) -> io::Result<(usize, SocketAddr)> {
let mut storage: c::SOCKADDR_STORAGE_LH = unsafe { mem::zeroed() }; let mut storage = unsafe { mem::zeroed::<c::SOCKADDR_STORAGE_LH>() };
let mut addrlen = mem::size_of_val(&storage) as c::socklen_t; let mut addrlen = mem::size_of_val(&storage) as c::socklen_t;
let len = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t; let length = cmp::min(buf.len(), <wrlen_t>::MAX as usize) as wrlen_t;
// On unix when a socket is shut down all further reads return 0, so we // 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. // do the same on windows to map a shut down socket to returning EOF.
unsafe { let result = unsafe {
match c::recvfrom( c::recvfrom(
self.0, self.0,
buf.as_mut_ptr() as *mut c_void, buf.as_mut_ptr() as *mut _,
len, length,
flags, flags,
&mut storage as *mut _ as *mut _, &mut storage as *mut _ as *mut _,
&mut addrlen, &mut addrlen,
) { )
-1 if c::WSAGetLastError() == c::WSAESHUTDOWN => { };
match result {
c::SOCKET_ERROR => {
let error = unsafe { c::WSAGetLastError() };
if error == c::WSAESHUTDOWN {
Ok((0, net::sockaddr_to_addr(&storage, addrlen as usize)?)) Ok((0, net::sockaddr_to_addr(&storage, addrlen as usize)?))
} else {
Err(io::Error::from_raw_os_error(error))
} }
-1 => Err(last_error()),
n => Ok((n as usize, net::sockaddr_to_addr(&storage, addrlen as usize)?)),
} }
_ => Ok((result as usize, net::sockaddr_to_addr(&storage, addrlen as usize)?)),
} }
} }
@ -318,20 +357,20 @@ impl Socket {
} }
pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> { pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
let len = cmp::min(bufs.len(), c::DWORD::MAX as usize) as c::DWORD; let length = cmp::min(bufs.len(), c::DWORD::MAX as usize) as c::DWORD;
let mut nwritten = 0; let mut nwritten = 0;
unsafe { let result = unsafe {
cvt(c::WSASend( c::WSASend(
self.0, self.0,
bufs.as_ptr() as *const c::WSABUF as *mut c::WSABUF, bufs.as_ptr() as *const c::WSABUF as *mut _,
len, length,
&mut nwritten, &mut nwritten,
0, 0,
ptr::null_mut(), ptr::null_mut(),
ptr::null_mut(), ptr::null_mut(),
))?; )
} };
Ok(nwritten as usize) cvt(result).map(|_| nwritten as usize)
} }
#[inline] #[inline]
@ -384,14 +423,14 @@ impl Socket {
Shutdown::Read => c::SD_RECEIVE, Shutdown::Read => c::SD_RECEIVE,
Shutdown::Both => c::SD_BOTH, Shutdown::Both => c::SD_BOTH,
}; };
cvt(unsafe { c::shutdown(self.0, how) })?; let result = unsafe { c::shutdown(self.0, how) };
Ok(()) cvt(result).map(drop)
} }
pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> { pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
let mut nonblocking = nonblocking as c_ulong; let mut nonblocking = nonblocking as c_ulong;
let r = unsafe { c::ioctlsocket(self.0, c::FIONBIO as c_int, &mut nonblocking) }; let result = unsafe { c::ioctlsocket(self.0, c::FIONBIO as c_int, &mut nonblocking) };
if r == 0 { Ok(()) } else { Err(io::Error::last_os_error()) } cvt(result).map(drop)
} }
pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> { pub fn set_nodelay(&self, nodelay: bool) -> io::Result<()> {