diff options
Diffstat (limited to 'third_party/rust/socket2/src/sys/windows.rs')
| -rw-r--r-- | third_party/rust/socket2/src/sys/windows.rs | 882 |
1 files changed, 882 insertions, 0 deletions
diff --git a/third_party/rust/socket2/src/sys/windows.rs b/third_party/rust/socket2/src/sys/windows.rs new file mode 100644 index 0000000000..0e36a1ccff --- /dev/null +++ b/third_party/rust/socket2/src/sys/windows.rs @@ -0,0 +1,882 @@ +// Copyright 2015 The Rust Project Developers. +// +// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or +// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license +// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +use std::cmp::min; +use std::io::{self, IoSlice}; +use std::marker::PhantomData; +use std::mem::{self, size_of, MaybeUninit}; +use std::net::{self, Ipv4Addr, Ipv6Addr, Shutdown}; +use std::os::windows::prelude::*; +use std::sync::Once; +use std::time::{Duration, Instant}; +use std::{ptr, slice}; + +use winapi::ctypes::c_long; +use winapi::shared::in6addr::*; +use winapi::shared::inaddr::*; +use winapi::shared::minwindef::DWORD; +use winapi::shared::minwindef::ULONG; +use winapi::shared::mstcpip::{tcp_keepalive, SIO_KEEPALIVE_VALS}; +use winapi::shared::ntdef::HANDLE; +use winapi::shared::ws2def; +use winapi::shared::ws2def::WSABUF; +use winapi::um::handleapi::SetHandleInformation; +use winapi::um::processthreadsapi::GetCurrentProcessId; +use winapi::um::winbase::{self, INFINITE}; +use winapi::um::winsock2::{ + self as sock, u_long, POLLERR, POLLHUP, POLLRDNORM, POLLWRNORM, SD_BOTH, SD_RECEIVE, SD_SEND, + WSAPOLLFD, +}; +use winapi::um::winsock2::{SOCKET_ERROR, WSAEMSGSIZE, WSAESHUTDOWN}; + +use crate::{RecvFlags, SockAddr, TcpKeepalive, Type}; + +pub(crate) use winapi::ctypes::c_int; + +/// Fake MSG_TRUNC flag for the [`RecvFlags`] struct. +/// +/// The flag is enabled when a `WSARecv[From]` call returns `WSAEMSGSIZE`. The +/// value of the flag is defined by us. +pub(crate) const MSG_TRUNC: c_int = 0x01; + +// Used in `Domain`. +pub(crate) use winapi::shared::ws2def::{AF_INET, AF_INET6}; +// Used in `Type`. +pub(crate) use winapi::shared::ws2def::{SOCK_DGRAM, SOCK_STREAM}; +#[cfg(feature = "all")] +pub(crate) use winapi::shared::ws2def::{SOCK_RAW, SOCK_SEQPACKET}; +// Used in `Protocol`. +pub(crate) const IPPROTO_ICMP: c_int = winapi::shared::ws2def::IPPROTO_ICMP as c_int; +pub(crate) const IPPROTO_ICMPV6: c_int = winapi::shared::ws2def::IPPROTO_ICMPV6 as c_int; +pub(crate) const IPPROTO_TCP: c_int = winapi::shared::ws2def::IPPROTO_TCP as c_int; +pub(crate) const IPPROTO_UDP: c_int = winapi::shared::ws2def::IPPROTO_UDP as c_int; +// Used in `SockAddr`. +pub(crate) use winapi::shared::ws2def::{ + ADDRESS_FAMILY as sa_family_t, SOCKADDR as sockaddr, SOCKADDR_IN as sockaddr_in, + SOCKADDR_STORAGE as sockaddr_storage, +}; +pub(crate) use winapi::shared::ws2ipdef::SOCKADDR_IN6_LH as sockaddr_in6; +pub(crate) use winapi::um::ws2tcpip::socklen_t; +// Used in `Socket`. +pub(crate) use winapi::shared::ws2def::{ + IPPROTO_IP, SOL_SOCKET, SO_BROADCAST, SO_ERROR, SO_KEEPALIVE, SO_LINGER, SO_OOBINLINE, + SO_RCVBUF, SO_RCVTIMEO, SO_REUSEADDR, SO_SNDBUF, SO_SNDTIMEO, SO_TYPE, TCP_NODELAY, +}; +#[cfg(feature = "all")] +pub(crate) use winapi::shared::ws2ipdef::IP_HDRINCL; +pub(crate) use winapi::shared::ws2ipdef::{ + IPV6_ADD_MEMBERSHIP, IPV6_DROP_MEMBERSHIP, IPV6_MREQ as Ipv6Mreq, IPV6_MULTICAST_HOPS, + IPV6_MULTICAST_IF, IPV6_MULTICAST_LOOP, IPV6_UNICAST_HOPS, IPV6_V6ONLY, IP_ADD_MEMBERSHIP, + IP_ADD_SOURCE_MEMBERSHIP, IP_DROP_MEMBERSHIP, IP_DROP_SOURCE_MEMBERSHIP, IP_MREQ as IpMreq, + IP_MREQ_SOURCE as IpMreqSource, IP_MULTICAST_IF, IP_MULTICAST_LOOP, IP_MULTICAST_TTL, IP_TOS, + IP_TTL, +}; +pub(crate) use winapi::um::winsock2::{linger, MSG_OOB, MSG_PEEK}; +pub(crate) const IPPROTO_IPV6: c_int = winapi::shared::ws2def::IPPROTO_IPV6 as c_int; + +/// Type used in set/getsockopt to retrieve the `TCP_NODELAY` option. +/// +/// NOTE: <https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-getsockopt> +/// documents that options such as `TCP_NODELAY` and `SO_KEEPALIVE` expect a +/// `BOOL` (alias for `c_int`, 4 bytes), however in practice this turns out to +/// be false (or misleading) as a `BOOLEAN` (`c_uchar`, 1 byte) is returned by +/// `getsockopt`. +pub(crate) type Bool = winapi::shared::ntdef::BOOLEAN; + +/// Maximum size of a buffer passed to system call like `recv` and `send`. +const MAX_BUF_LEN: usize = <c_int>::max_value() as usize; + +/// Helper macro to execute a system call that returns an `io::Result`. +macro_rules! syscall { + ($fn: ident ( $($arg: expr),* $(,)* ), $err_test: path, $err_value: expr) => {{ + #[allow(unused_unsafe)] + let res = unsafe { sock::$fn($($arg, )*) }; + if $err_test(&res, &$err_value) { + Err(io::Error::last_os_error()) + } else { + Ok(res) + } + }}; +} + +impl_debug!( + crate::Domain, + ws2def::AF_INET, + ws2def::AF_INET6, + ws2def::AF_UNIX, + ws2def::AF_UNSPEC, // = 0. +); + +/// Windows only API. +impl Type { + /// Our custom flag to set `WSA_FLAG_NO_HANDLE_INHERIT` on socket creation. + /// Trying to mimic `Type::cloexec` on windows. + const NO_INHERIT: c_int = 1 << ((size_of::<c_int>() * 8) - 1); // Last bit. + + /// Set `WSA_FLAG_NO_HANDLE_INHERIT` on the socket. + #[cfg(feature = "all")] + #[cfg_attr(docsrs, doc(cfg(all(windows, feature = "all"))))] + pub const fn no_inherit(self) -> Type { + self._no_inherit() + } + + pub(crate) const fn _no_inherit(self) -> Type { + Type(self.0 | Type::NO_INHERIT) + } +} + +impl_debug!( + crate::Type, + ws2def::SOCK_STREAM, + ws2def::SOCK_DGRAM, + ws2def::SOCK_RAW, + ws2def::SOCK_RDM, + ws2def::SOCK_SEQPACKET, +); + +impl_debug!( + crate::Protocol, + self::IPPROTO_ICMP, + self::IPPROTO_ICMPV6, + self::IPPROTO_TCP, + self::IPPROTO_UDP, +); + +impl std::fmt::Debug for RecvFlags { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("RecvFlags") + .field("is_truncated", &self.is_truncated()) + .finish() + } +} + +#[repr(transparent)] +pub struct MaybeUninitSlice<'a> { + vec: WSABUF, + _lifetime: PhantomData<&'a mut [MaybeUninit<u8>]>, +} + +unsafe impl<'a> Send for MaybeUninitSlice<'a> {} + +unsafe impl<'a> Sync for MaybeUninitSlice<'a> {} + +impl<'a> MaybeUninitSlice<'a> { + pub fn new(buf: &'a mut [MaybeUninit<u8>]) -> MaybeUninitSlice<'a> { + assert!(buf.len() <= ULONG::MAX as usize); + MaybeUninitSlice { + vec: WSABUF { + len: buf.len() as ULONG, + buf: buf.as_mut_ptr().cast(), + }, + _lifetime: PhantomData, + } + } + + pub fn as_slice(&self) -> &[MaybeUninit<u8>] { + unsafe { slice::from_raw_parts(self.vec.buf.cast(), self.vec.len as usize) } + } + + pub fn as_mut_slice(&mut self) -> &mut [MaybeUninit<u8>] { + unsafe { slice::from_raw_parts_mut(self.vec.buf.cast(), self.vec.len as usize) } + } +} + +fn init() { + static INIT: Once = Once::new(); + + INIT.call_once(|| { + // Initialize winsock through the standard library by just creating a + // dummy socket. Whether this is successful or not we drop the result as + // libstd will be sure to have initialized winsock. + let _ = net::UdpSocket::bind("127.0.0.1:34254"); + }); +} + +pub(crate) type Socket = sock::SOCKET; + +pub(crate) unsafe fn socket_from_raw(socket: Socket) -> crate::socket::Inner { + crate::socket::Inner::from_raw_socket(socket as RawSocket) +} + +pub(crate) fn socket_as_raw(socket: &crate::socket::Inner) -> Socket { + socket.as_raw_socket() as Socket +} + +pub(crate) fn socket_into_raw(socket: crate::socket::Inner) -> Socket { + socket.into_raw_socket() as Socket +} + +pub(crate) fn socket(family: c_int, mut ty: c_int, protocol: c_int) -> io::Result<Socket> { + init(); + + // Check if we set our custom flag. + let flags = if ty & Type::NO_INHERIT != 0 { + ty = ty & !Type::NO_INHERIT; + sock::WSA_FLAG_NO_HANDLE_INHERIT + } else { + 0 + }; + + syscall!( + WSASocketW( + family, + ty, + protocol, + ptr::null_mut(), + 0, + sock::WSA_FLAG_OVERLAPPED | flags, + ), + PartialEq::eq, + sock::INVALID_SOCKET + ) +} + +pub(crate) fn bind(socket: Socket, addr: &SockAddr) -> io::Result<()> { + syscall!(bind(socket, addr.as_ptr(), addr.len()), PartialEq::ne, 0).map(|_| ()) +} + +pub(crate) fn connect(socket: Socket, addr: &SockAddr) -> io::Result<()> { + syscall!(connect(socket, addr.as_ptr(), addr.len()), PartialEq::ne, 0).map(|_| ()) +} + +pub(crate) fn poll_connect(socket: &crate::Socket, timeout: Duration) -> io::Result<()> { + let start = Instant::now(); + + let mut fd_array = WSAPOLLFD { + fd: socket.as_raw(), + events: POLLRDNORM | POLLWRNORM, + revents: 0, + }; + + loop { + let elapsed = start.elapsed(); + if elapsed >= timeout { + return Err(io::ErrorKind::TimedOut.into()); + } + + let timeout = (timeout - elapsed).as_millis(); + let timeout = clamp(timeout, 1, c_int::max_value() as u128) as c_int; + + match syscall!( + WSAPoll(&mut fd_array, 1, timeout), + PartialEq::eq, + sock::SOCKET_ERROR + ) { + Ok(0) => return Err(io::ErrorKind::TimedOut.into()), + Ok(_) => { + // Error or hang up indicates an error (or failure to connect). + if (fd_array.revents & POLLERR) != 0 || (fd_array.revents & POLLHUP) != 0 { + match socket.take_error() { + Ok(Some(err)) => return Err(err), + Ok(None) => { + return Err(io::Error::new( + io::ErrorKind::Other, + "no error set after POLLHUP", + )) + } + Err(err) => return Err(err), + } + } + return Ok(()); + } + // Got interrupted, try again. + Err(ref err) if err.kind() == io::ErrorKind::Interrupted => continue, + Err(err) => return Err(err), + } + } +} + +// TODO: use clamp from std lib, stable since 1.50. +fn clamp<T>(value: T, min: T, max: T) -> T +where + T: Ord, +{ + if value <= min { + min + } else if value >= max { + max + } else { + value + } +} + +pub(crate) fn listen(socket: Socket, backlog: c_int) -> io::Result<()> { + syscall!(listen(socket, backlog), PartialEq::ne, 0).map(|_| ()) +} + +pub(crate) fn accept(socket: Socket) -> io::Result<(Socket, SockAddr)> { + // Safety: `accept` initialises the `SockAddr` for us. + unsafe { + SockAddr::init(|storage, len| { + syscall!( + accept(socket, storage.cast(), len), + PartialEq::eq, + sock::INVALID_SOCKET + ) + }) + } +} + +pub(crate) fn getsockname(socket: Socket) -> io::Result<SockAddr> { + // Safety: `getsockname` initialises the `SockAddr` for us. + unsafe { + SockAddr::init(|storage, len| { + syscall!( + getsockname(socket, storage.cast(), len), + PartialEq::eq, + sock::SOCKET_ERROR + ) + }) + } + .map(|(_, addr)| addr) +} + +pub(crate) fn getpeername(socket: Socket) -> io::Result<SockAddr> { + // Safety: `getpeername` initialises the `SockAddr` for us. + unsafe { + SockAddr::init(|storage, len| { + syscall!( + getpeername(socket, storage.cast(), len), + PartialEq::eq, + sock::SOCKET_ERROR + ) + }) + } + .map(|(_, addr)| addr) +} + +pub(crate) fn try_clone(socket: Socket) -> io::Result<Socket> { + let mut info: MaybeUninit<sock::WSAPROTOCOL_INFOW> = MaybeUninit::uninit(); + syscall!( + WSADuplicateSocketW(socket, GetCurrentProcessId(), info.as_mut_ptr()), + PartialEq::eq, + sock::SOCKET_ERROR + )?; + // Safety: `WSADuplicateSocketW` intialised `info` for us. + let mut info = unsafe { info.assume_init() }; + + syscall!( + WSASocketW( + info.iAddressFamily, + info.iSocketType, + info.iProtocol, + &mut info, + 0, + sock::WSA_FLAG_OVERLAPPED | sock::WSA_FLAG_NO_HANDLE_INHERIT, + ), + PartialEq::eq, + sock::INVALID_SOCKET + ) +} + +pub(crate) fn set_nonblocking(socket: Socket, nonblocking: bool) -> io::Result<()> { + let mut nonblocking = nonblocking as u_long; + ioctlsocket(socket, sock::FIONBIO, &mut nonblocking) +} + +pub(crate) fn shutdown(socket: Socket, how: Shutdown) -> io::Result<()> { + let how = match how { + Shutdown::Write => SD_SEND, + Shutdown::Read => SD_RECEIVE, + Shutdown::Both => SD_BOTH, + }; + syscall!(shutdown(socket, how), PartialEq::eq, sock::SOCKET_ERROR).map(|_| ()) +} + +pub(crate) fn recv(socket: Socket, buf: &mut [MaybeUninit<u8>], flags: c_int) -> io::Result<usize> { + let res = syscall!( + recv( + socket, + buf.as_mut_ptr().cast(), + min(buf.len(), MAX_BUF_LEN) as c_int, + flags, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ); + match res { + Ok(n) => Ok(n as usize), + Err(ref err) if err.raw_os_error() == Some(sock::WSAESHUTDOWN as i32) => Ok(0), + Err(err) => Err(err), + } +} + +pub(crate) fn recv_vectored( + socket: Socket, + bufs: &mut [crate::MaybeUninitSlice<'_>], + flags: c_int, +) -> io::Result<(usize, RecvFlags)> { + let mut nread = 0; + let mut flags = flags as DWORD; + let res = syscall!( + WSARecv( + socket, + bufs.as_mut_ptr().cast(), + min(bufs.len(), DWORD::max_value() as usize) as DWORD, + &mut nread, + &mut flags, + ptr::null_mut(), + None, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ); + match res { + Ok(_) => Ok((nread as usize, RecvFlags(0))), + Err(ref err) if err.raw_os_error() == Some(sock::WSAESHUTDOWN as i32) => { + Ok((0, RecvFlags(0))) + } + Err(ref err) if err.raw_os_error() == Some(sock::WSAEMSGSIZE as i32) => { + Ok((nread as usize, RecvFlags(MSG_TRUNC))) + } + Err(err) => Err(err), + } +} + +pub(crate) fn recv_from( + socket: Socket, + buf: &mut [MaybeUninit<u8>], + flags: c_int, +) -> io::Result<(usize, SockAddr)> { + // Safety: `recvfrom` initialises the `SockAddr` for us. + unsafe { + SockAddr::init(|storage, addrlen| { + let res = syscall!( + recvfrom( + socket, + buf.as_mut_ptr().cast(), + min(buf.len(), MAX_BUF_LEN) as c_int, + flags, + storage.cast(), + addrlen, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ); + match res { + Ok(n) => Ok(n as usize), + Err(ref err) if err.raw_os_error() == Some(sock::WSAESHUTDOWN as i32) => Ok(0), + Err(err) => Err(err), + } + }) + } +} + +pub(crate) fn peek_sender(socket: Socket) -> io::Result<SockAddr> { + // Safety: `recvfrom` initialises the `SockAddr` for us. + let ((), sender) = unsafe { + SockAddr::init(|storage, addrlen| { + let res = syscall!( + recvfrom( + socket, + // Windows *appears* not to care if you pass a null pointer. + ptr::null_mut(), + 0, + MSG_PEEK, + storage.cast(), + addrlen, + ), + PartialEq::eq, + SOCKET_ERROR + ); + match res { + Ok(_n) => Ok(()), + Err(e) => match e.raw_os_error() { + Some(code) if code == (WSAESHUTDOWN as i32) || code == (WSAEMSGSIZE as i32) => { + Ok(()) + } + _ => Err(e), + }, + } + }) + }?; + + Ok(sender) +} + +pub(crate) fn recv_from_vectored( + socket: Socket, + bufs: &mut [crate::MaybeUninitSlice<'_>], + flags: c_int, +) -> io::Result<(usize, RecvFlags, SockAddr)> { + // Safety: `recvfrom` initialises the `SockAddr` for us. + unsafe { + SockAddr::init(|storage, addrlen| { + let mut nread = 0; + let mut flags = flags as DWORD; + let res = syscall!( + WSARecvFrom( + socket, + bufs.as_mut_ptr().cast(), + min(bufs.len(), DWORD::max_value() as usize) as DWORD, + &mut nread, + &mut flags, + storage.cast(), + addrlen, + ptr::null_mut(), + None, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ); + match res { + Ok(_) => Ok((nread as usize, RecvFlags(0))), + Err(ref err) if err.raw_os_error() == Some(sock::WSAESHUTDOWN as i32) => { + Ok((nread as usize, RecvFlags(0))) + } + Err(ref err) if err.raw_os_error() == Some(sock::WSAEMSGSIZE as i32) => { + Ok((nread as usize, RecvFlags(MSG_TRUNC))) + } + Err(err) => Err(err), + } + }) + } + .map(|((n, recv_flags), addr)| (n, recv_flags, addr)) +} + +pub(crate) fn send(socket: Socket, buf: &[u8], flags: c_int) -> io::Result<usize> { + syscall!( + send( + socket, + buf.as_ptr().cast(), + min(buf.len(), MAX_BUF_LEN) as c_int, + flags, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|n| n as usize) +} + +pub(crate) fn send_vectored( + socket: Socket, + bufs: &[IoSlice<'_>], + flags: c_int, +) -> io::Result<usize> { + let mut nsent = 0; + syscall!( + WSASend( + socket, + // FIXME: From the `WSASend` docs [1]: + // > For a Winsock application, once the WSASend function is called, + // > the system owns these buffers and the application may not + // > access them. + // + // So what we're doing is actually UB as `bufs` needs to be `&mut + // [IoSlice<'_>]`. + // + // Tracking issue: https://github.com/rust-lang/socket2-rs/issues/129. + // + // NOTE: `send_to_vectored` has the same problem. + // + // [1] https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasend + bufs.as_ptr() as *mut _, + min(bufs.len(), DWORD::max_value() as usize) as DWORD, + &mut nsent, + flags as DWORD, + std::ptr::null_mut(), + None, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|_| nsent as usize) +} + +pub(crate) fn send_to( + socket: Socket, + buf: &[u8], + addr: &SockAddr, + flags: c_int, +) -> io::Result<usize> { + syscall!( + sendto( + socket, + buf.as_ptr().cast(), + min(buf.len(), MAX_BUF_LEN) as c_int, + flags, + addr.as_ptr(), + addr.len(), + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|n| n as usize) +} + +pub(crate) fn send_to_vectored( + socket: Socket, + bufs: &[IoSlice<'_>], + addr: &SockAddr, + flags: c_int, +) -> io::Result<usize> { + let mut nsent = 0; + syscall!( + WSASendTo( + socket, + // FIXME: Same problem as in `send_vectored`. + bufs.as_ptr() as *mut _, + bufs.len().min(DWORD::MAX as usize) as DWORD, + &mut nsent, + flags as DWORD, + addr.as_ptr(), + addr.len(), + ptr::null_mut(), + None, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|_| nsent as usize) +} + +/// Wrapper around `getsockopt` to deal with platform specific timeouts. +pub(crate) fn timeout_opt(fd: Socket, lvl: c_int, name: c_int) -> io::Result<Option<Duration>> { + unsafe { getsockopt(fd, lvl, name).map(from_ms) } +} + +fn from_ms(duration: DWORD) -> Option<Duration> { + if duration == 0 { + None + } else { + let secs = duration / 1000; + let nsec = (duration % 1000) * 1000000; + Some(Duration::new(secs as u64, nsec as u32)) + } +} + +/// Wrapper around `setsockopt` to deal with platform specific timeouts. +pub(crate) fn set_timeout_opt( + fd: Socket, + level: c_int, + optname: c_int, + duration: Option<Duration>, +) -> io::Result<()> { + let duration = into_ms(duration); + unsafe { setsockopt(fd, level, optname, duration) } +} + +fn into_ms(duration: Option<Duration>) -> 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: + // + // * Nanosecond precision is rounded up + // * Greater than u32::MAX milliseconds (50 days) is rounded up to + // INFINITE (never time out). + duration + .map(|duration| min(duration.as_millis(), INFINITE as u128) as DWORD) + .unwrap_or(0) +} + +pub(crate) fn set_tcp_keepalive(socket: Socket, keepalive: &TcpKeepalive) -> io::Result<()> { + let mut keepalive = tcp_keepalive { + onoff: 1, + keepalivetime: into_ms(keepalive.time), + keepaliveinterval: into_ms(keepalive.interval), + }; + let mut out = 0; + syscall!( + WSAIoctl( + socket, + SIO_KEEPALIVE_VALS, + &mut keepalive as *mut _ as *mut _, + size_of::<tcp_keepalive>() as _, + ptr::null_mut(), + 0, + &mut out, + ptr::null_mut(), + None, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|_| ()) +} + +/// Caller must ensure `T` is the correct type for `level` and `optname`. +pub(crate) unsafe fn getsockopt<T>(socket: Socket, level: c_int, optname: c_int) -> io::Result<T> { + let mut optval: MaybeUninit<T> = MaybeUninit::uninit(); + let mut optlen = mem::size_of::<T>() as c_int; + syscall!( + getsockopt( + socket, + level, + optname, + optval.as_mut_ptr().cast(), + &mut optlen, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|_| { + debug_assert_eq!(optlen as usize, mem::size_of::<T>()); + // Safety: `getsockopt` initialised `optval` for us. + optval.assume_init() + }) +} + +/// Caller must ensure `T` is the correct type for `level` and `optname`. +pub(crate) unsafe fn setsockopt<T>( + socket: Socket, + level: c_int, + optname: c_int, + optval: T, +) -> io::Result<()> { + syscall!( + setsockopt( + socket, + level, + optname, + (&optval as *const T).cast(), + mem::size_of::<T>() as c_int, + ), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|_| ()) +} + +fn ioctlsocket(socket: Socket, cmd: c_long, payload: &mut u_long) -> io::Result<()> { + syscall!( + ioctlsocket(socket, cmd, payload), + PartialEq::eq, + sock::SOCKET_ERROR + ) + .map(|_| ()) +} + +pub(crate) fn to_in_addr(addr: &Ipv4Addr) -> IN_ADDR { + let mut s_un: in_addr_S_un = unsafe { mem::zeroed() }; + // `S_un` is stored as BE on all machines, and the array is in BE order. So + // the native endian conversion method is used so that it's never swapped. + unsafe { *(s_un.S_addr_mut()) = u32::from_ne_bytes(addr.octets()) }; + IN_ADDR { S_un: s_un } +} + +pub(crate) fn from_in_addr(in_addr: IN_ADDR) -> Ipv4Addr { + Ipv4Addr::from(unsafe { *in_addr.S_un.S_addr() }.to_ne_bytes()) +} + +pub(crate) fn to_in6_addr(addr: &Ipv6Addr) -> in6_addr { + let mut ret_addr: in6_addr_u = unsafe { mem::zeroed() }; + unsafe { *(ret_addr.Byte_mut()) = addr.octets() }; + let mut ret: in6_addr = unsafe { mem::zeroed() }; + ret.u = ret_addr; + ret +} + +pub(crate) fn from_in6_addr(addr: in6_addr) -> Ipv6Addr { + Ipv6Addr::from(*unsafe { addr.u.Byte() }) +} + +pub(crate) fn to_mreqn( + multiaddr: &Ipv4Addr, + interface: &crate::socket::InterfaceIndexOrAddress, +) -> IpMreq { + IpMreq { + imr_multiaddr: to_in_addr(multiaddr), + // Per https://docs.microsoft.com/en-us/windows/win32/api/ws2ipdef/ns-ws2ipdef-ip_mreq#members: + // + // imr_interface + // + // The local IPv4 address of the interface or the interface index on + // which the multicast group should be joined or dropped. This value is + // in network byte order. If this member specifies an IPv4 address of + // 0.0.0.0, the default IPv4 multicast interface is used. + // + // To use an interface index of 1 would be the same as an IP address of + // 0.0.0.1. + imr_interface: match interface { + crate::socket::InterfaceIndexOrAddress::Index(interface) => { + to_in_addr(&(*interface).into()) + } + crate::socket::InterfaceIndexOrAddress::Address(interface) => to_in_addr(interface), + }, + } +} + +/// Windows only API. +impl crate::Socket { + /// Sets `HANDLE_FLAG_INHERIT` using `SetHandleInformation`. + #[cfg(feature = "all")] + #[cfg_attr(docsrs, doc(cfg(all(windows, feature = "all"))))] + pub fn set_no_inherit(&self, no_inherit: bool) -> io::Result<()> { + self._set_no_inherit(no_inherit) + } + + pub(crate) fn _set_no_inherit(&self, no_inherit: bool) -> io::Result<()> { + // NOTE: can't use `syscall!` because it expects the function in the + // `sock::` path. + let res = unsafe { + SetHandleInformation( + self.as_raw() as HANDLE, + winbase::HANDLE_FLAG_INHERIT, + !no_inherit as _, + ) + }; + if res == 0 { + // Zero means error. + Err(io::Error::last_os_error()) + } else { + Ok(()) + } + } +} + +impl AsRawSocket for crate::Socket { + fn as_raw_socket(&self) -> RawSocket { + self.as_raw() as RawSocket + } +} + +impl IntoRawSocket for crate::Socket { + fn into_raw_socket(self) -> RawSocket { + self.into_raw() as RawSocket + } +} + +impl FromRawSocket for crate::Socket { + unsafe fn from_raw_socket(socket: RawSocket) -> crate::Socket { + crate::Socket::from_raw(socket as Socket) + } +} + +#[test] +fn in_addr_convertion() { + let ip = Ipv4Addr::new(127, 0, 0, 1); + let raw = to_in_addr(&ip); + assert_eq!(unsafe { *raw.S_un.S_addr() }, 127 << 0 | 1 << 24); + assert_eq!(from_in_addr(raw), ip); + + let ip = Ipv4Addr::new(127, 34, 4, 12); + let raw = to_in_addr(&ip); + assert_eq!( + unsafe { *raw.S_un.S_addr() }, + 127 << 0 | 34 << 8 | 4 << 16 | 12 << 24 + ); + assert_eq!(from_in_addr(raw), ip); +} + +#[test] +fn in6_addr_convertion() { + let ip = Ipv6Addr::new(0x2000, 1, 2, 3, 4, 5, 6, 7); + let raw = to_in6_addr(&ip); + let want = [ + 0x2000u16.to_be(), + 1u16.to_be(), + 2u16.to_be(), + 3u16.to_be(), + 4u16.to_be(), + 5u16.to_be(), + 6u16.to_be(), + 7u16.to_be(), + ]; + assert_eq!(unsafe { *raw.u.Word() }, want); + assert_eq!(from_in6_addr(raw), ip); +} |