use std::collections::VecDeque;
use std::ffi::{c_char, c_int};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
use std::sync::atomic::{AtomicI32, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, Weak};
use std::time::Duration;
use snare_interpose::{Net, NetResult};
#[path = "win_iocp.rs"]
mod iocp;
use crate::HashMap;
use crate::ancillary::Header;
use crate::faults::{ConnectAttempt, Outcome, Syn};
use crate::limits::{Arrival, Buf, RxQueue};
use crate::netif::{
Cand, Hop, LinkState, Op, Sender, Share, Wire, code, pick_shared, reported, toward, unmapped,
};
use crate::pcapng::{Dir, TcpTap};
use crate::readiness::{Deadline, readiness};
use crate::scope::SimShared;
use crate::sockets::{
ErrorOrder, Membership, RxProbe, SockRec, SocketKind, Taker, UnmodelledOption,
};
use crate::stream::{Ends, Pipe, Read, Sent};
use crate::win_sockopt::{self, WSAENOPROTOOPT};
const WSAEFAULT: c_int = 10014;
const WSAEINVAL: c_int = 10022;
const WSAEOPNOTSUPP: c_int = 10045;
const WSAEISCONN: c_int = 10056;
const WSAEWOULDBLOCK: c_int = 10035;
const WSAENOTCONN: c_int = 10057;
const WSAEACCES: c_int = 10013;
const WSAEADDRINUSE: c_int = 10048;
const WSAEDESTADDRREQ: c_int = 10039;
const WSAECONNREFUSED: c_int = 10061;
const WSAEALREADY: c_int = 10037;
const WSAECONNABORTED: c_int = 10053;
const WSAENOTSOCK: c_int = 10038;
const WSAECONNRESET: c_int = 10054;
const WSAETIMEDOUT: c_int = 10060;
const WSAESHUTDOWN: c_int = 10058;
const WSAEAFNOSUPPORT: c_int = 10047;
const WSAEMSGSIZE: c_int = win_sockopt::WSAEMSGSIZE;
const MSG_OOB: c_int = 0x1;
const MSG_PEEK: c_int = 0x2;
const MSG_DONTROUTE: c_int = 0x4;
const MSG_WAITALL: c_int = 0x8;
const MSG_PUSH_IMMEDIATE: c_int = 0x20;
const MSG_PARTIAL: c_int = 0x8000;
const MSG_TRUNC: u32 = 0x0100;
const MSG_CTRUNC: u32 = 0x0200;
const MSG_BCAST: u32 = 0x0400;
const MSG_MCAST: u32 = 0x0800;
const AF_UNSPEC: c_int = 0;
const AF_INET: c_int = 2;
const AF_INET6: c_int = 23;
const SOCK_STREAM: c_int = 1;
const SOCK_DGRAM: c_int = 2;
const SOL_SOCKET: c_int = 0xffff;
const SO_TYPE: c_int = 0x1008;
const SO_BROADCAST: c_int = 0x0020;
const SO_RCVTIMEO: c_int = 0x1006;
const SO_SNDTIMEO: c_int = 0x1005;
const SO_ERROR: c_int = 0x1007;
const SO_REUSEADDR: c_int = 0x0004;
const SO_EXCLUSIVEADDRUSE: c_int = !SO_REUSEADDR;
const SO_ACCEPTCONN: c_int = 0x0002;
const SO_LINGER: c_int = 0x0080;
const SO_DONTLINGER: c_int = !SO_LINGER;
const SIO_UDP_CONNRESET: u32 = 0x9800_000C;
const SO_SNDBUF: c_int = 0x1001;
const SO_RCVBUF: c_int = 0x1002;
const FIONREAD: u32 = 0x4004_667f;
const SD_RECEIVE: c_int = 0;
const SD_SEND: c_int = 1;
const SD_BOTH: c_int = 2;
const IPPROTO_IP: c_int = 0;
const IPPROTO_IPV6: c_int = 41;
const IPV6_V6ONLY: c_int = 27;
const IP_ADD_MEMBERSHIP: c_int = 12;
const IPV6_ADD_MEMBERSHIP: c_int = 12;
const IP_UNICAST_IF: c_int = 31;
const IPV6_UNICAST_IF: c_int = 31;
const IP_MULTICAST_IF: c_int = 9;
const IPV6_MULTICAST_IF: c_int = 9;
const FIONBIO: u64 = 0x8004667e;
const SIOCATMARK: u32 = 0x4004_7307;
const SIO_BASE_HANDLE: u32 = 0x4800_0022;
const SIO_BSP_HANDLE: u32 = 0x4800_001B;
const SIO_BSP_HANDLE_SELECT: u32 = 0x4800_001C;
const SIO_BSP_HANDLE_POLL: u32 = 0x4800_001D;
const SIO_KEEPALIVE_VALS: u32 = 0x9800_0004;
const SIO_UDP_NETRESET: u32 = 0x9800_000F;
const SIO_LOOPBACK_FAST_PATH: u32 = 0x9800_0010;
const SIO_CPU_AFFINITY: u32 = 0x9800_0015;
const SIO_GET_TX_TIMESTAMP: u32 = 0x9800_00EA;
const SIO_TIMESTAMPING: u32 = 0x9800_00EB;
const POLLRDNORM: i16 = 0x0100;
const POLLRDBAND: i16 = 0x0200;
const POLLIN: i16 = POLLRDNORM | POLLRDBAND;
const POLLWRNORM: i16 = 0x0010;
const POLLOUT: i16 = POLLWRNORM;
const POLLERR: i16 = 0x0001;
const POLLHUP: i16 = 0x0002;
const IPPROTO_TCP: c_int = 6;
#[repr(C)]
#[derive(Clone, Copy)]
struct WsaPollfd {
fd: usize,
events: i16,
revents: i16,
}
fn ok(n: i64) -> Option<NetResult> {
Some(NetResult::Ok(n))
}
fn would_block() -> Option<NetResult> {
snare_interpose::charge_latency();
err(WSAEWOULDBLOCK)
}
fn err(code: c_int) -> Option<NetResult> {
Some(NetResult::Err(code))
}
fn done(result: Result<i64, c_int>) -> Option<NetResult> {
Some(match result {
Ok(n) => NetResult::Ok(n),
Err(code) => NetResult::Err(code),
})
}
fn monotonic(shared: &SimShared) -> Duration {
shared.clock.as_ref().map_or_else(
|| shared.stamp(),
|clock| Duration::from_nanos(clock.monotonic()),
)
}
#[derive(Clone, Copy, PartialEq)]
enum End {
A,
B,
}
pub(crate) struct Conn {
a_to_b: Arc<Pipe>,
b_to_a: Arc<Pipe>,
pub(crate) client: SocketAddr,
server: SocketAddr,
regs: Arc<Registries>,
hop: Option<Hop>,
tap: Option<TcpTap>,
}
impl Conn {
fn write(&self, end: End, bytes: &[u8]) -> Option<usize> {
let shared = &self.regs.shared;
let delay = shared.policies.tcp_delay(self.server, self.client)
+ shared.hop_delay(self.hop.as_ref());
let n = self
.write_pipe(end)
.write_after(bytes, delay, |sent, arrival, _| {
if let Some(tap) = &self.tap {
tap.data(end.index(), sent, arrival);
}
})?;
let pipe = self.write_pipe(end);
shared.account_tcp(
self.hop.as_ref(),
end == End::A,
n,
self.server.ip(),
(pipe.has_writer(), pipe.has_reader()),
);
Some(n)
}
fn read_pipe(&self, end: End) -> &Pipe {
match end {
End::A => &self.b_to_a,
End::B => &self.a_to_b,
}
}
fn write_pipe(&self, end: End) -> &Pipe {
match end {
End::A => &self.a_to_b,
End::B => &self.b_to_a,
}
}
fn close(&self, end: End) {
self.write_pipe(end).close(|arrival| {
if let Some(tap) = &self.tap {
tap.fin(end.index(), arrival);
}
});
}
fn local(&self, end: End) -> SocketAddr {
match end {
End::A => self.client,
End::B => self.server,
}
}
fn peer(&self, end: End) -> SocketAddr {
match end {
End::A => self.server,
End::B => self.client,
}
}
}
#[derive(Default)]
pub(crate) struct ListenerState {
rec: Option<std::sync::Weak<SockRec>>,
pending: Mutex<VecDeque<Arc<Conn>>>,
capacity: AtomicUsize,
occupied: AtomicUsize,
tester: bool,
dual: bool,
}
impl Conn {
fn reset(&self, from: End) {
if !self.a_to_b.is_reset() {
self.regs.shared.count_reset(
self.server.ip(),
self.write_pipe(from).has_writer(),
[
self.a_to_b.established_reader(),
self.b_to_a.established_reader(),
],
);
}
if let Some(tap) = &self.tap {
tap.rst(from.index());
}
self.a_to_b.reset();
self.b_to_a.reset();
}
}
impl End {
fn index(self) -> usize {
match self {
End::A => 0,
End::B => 1,
}
}
}
pub(crate) type Listener = ListenerState;
#[derive(Clone)]
struct Datagram {
order: ErrorOrder,
src: SocketAddr,
dest: SocketAddr,
at: Duration,
data: Vec<u8>,
arrives: Option<Deadline>,
via: Option<(Arc<LinkState>, u64)>,
ip: Header,
}
impl Arrival for Datagram {
fn src(&self) -> SocketAddr {
self.src
}
fn payload(&self) -> usize {
self.data.len()
}
fn arrives(&self) -> Option<Deadline> {
self.arrives
}
fn lost(&self) -> bool {
match (&self.via, self.arrives) {
(Some((link, epoch)), Some(at)) => link.lost_in_flight(*epoch, at.instant()),
_ => false,
}
}
}
#[derive(Default)]
pub(crate) struct DgramQueue {
packets: Mutex<RxQueue<Datagram>>,
rec: Option<Arc<SockRec>>,
bound_at: Mutex<Option<SocketAddr>>,
}
impl DgramQueue {
fn for_socket(rec: &Arc<SockRec>) -> Arc<Self> {
let queue = Arc::new(DgramQueue {
packets: Mutex::default(),
rec: Some(rec.clone()),
bound_at: Mutex::default(),
});
rec.set_probe(Arc::downgrade(&queue) as Weak<dyn RxProbe>);
queue
}
fn dual_at(&self, addr: SocketAddr) -> bool {
self.rec
.as_ref()
.is_some_and(|rec| rec.state().dual_at(addr))
}
#[allow(clippy::too_many_arguments)]
fn push_after(
&self,
(src, dest): (SocketAddr, SocketAddr),
sent: Duration,
data: Vec<u8>,
delay: std::time::Duration,
via: Option<(Arc<LinkState>, u64)>,
ip: Header,
domain: usize,
) {
let arrives = (!delay.is_zero()).then(|| Deadline::after(delay));
if let Some(arrives) = arrives {
arrives.wake_waiters_then();
}
let dg = Datagram {
order: ErrorOrder::new(arrives),
src,
dest,
at: sent.saturating_add(delay),
data,
arrives,
via,
ip,
};
self.packets.lock().unwrap().push(dg, self.rec.as_deref());
if let Some(rec) = &self.rec {
readiness().bump_keys(domain, &[rec.wake_key()]);
} else {
readiness().bump_keys(domain, &[]);
}
}
fn pop(&self, accept: impl Fn(SocketAddr) -> bool) -> Option<Datagram> {
let mut q = self.packets.lock().unwrap();
q.pop(accept, self.rec.as_deref()).map(|(dg, _)| dg)
}
fn take(
&self,
accept: impl Fn(SocketAddr) -> bool,
shared: &SimShared,
taker: Taker,
) -> Result<Option<Datagram>, c_int> {
let cutoff = Deadline::after(Duration::ZERO).at();
let mut queue = self.packets.lock().unwrap();
let rec = self.rec.as_deref();
let next = queue
.first_matching_at(&accept, rec, cutoff)
.map(|dg| dg.order);
if let Some(rec) = rec
&& let Some(error) = rec.take_error_before(shared, taker, next, cutoff)
{
return Err(error);
}
if next.is_none_or(|data| data.at() > cutoff) {
return Ok(None);
}
Ok(if taker == Taker::Peek {
queue.peek_landed(accept)
} else {
queue.pop_landed(accept, rec)
}
.map(|(dg, _)| dg))
}
fn has(&self, accept: impl Fn(SocketAddr) -> bool) -> bool {
self.packets
.lock()
.unwrap()
.has(accept, self.rec.as_deref())
}
}
impl RxProbe for DgramQueue {
fn pending_time(&self) -> bool {
self.packets.lock().unwrap().pending_time()
}
fn land(&self) {
self.packets.lock().unwrap().land(self.rec.as_deref());
}
fn queued(&self) -> (usize, usize) {
self.packets.lock().unwrap().queued()
}
fn next_len(&self) -> Option<usize> {
self.packets.lock().unwrap().next_len(self.rec.as_deref())
}
}
enum Sock {
Fresh {
nonblocking: bool,
local: Option<SocketAddr>,
rec: Arc<SockRec>,
},
Connecting {
nonblocking: bool,
local: Option<SocketAddr>,
rec: Arc<SockRec>,
dest: SocketAddr,
attempt: Arc<Mutex<ConnectAttempt>>,
},
Stream {
conn: Arc<Conn>,
end: End,
nonblocking: bool,
rec: Arc<SockRec>,
},
Listener {
state: Arc<ListenerState>,
addr: SocketAddr,
nonblocking: bool,
rec: Arc<SockRec>,
},
Dgram {
queue: Arc<DgramQueue>,
domain: c_int,
local: Option<SocketAddr>,
requested: Option<SocketAddr>,
peer: Option<SocketAddr>,
nonblocking: bool,
broadcast: bool,
rec: Arc<SockRec>,
},
}
impl Sock {
fn rec(&self) -> &Arc<SockRec> {
match self {
Sock::Fresh { rec, .. }
| Sock::Connecting { rec, .. }
| Sock::Stream { rec, .. }
| Sock::Listener { rec, .. }
| Sock::Dgram { rec, .. } => rec,
}
}
}
#[derive(Clone, Copy)]
struct Claim {
addr: SocketAddr,
reuse: bool,
exclusive: bool,
dual: bool,
station: bool,
}
impl Claim {
fn of(rec: &SockRec, addr: SocketAddr) -> Self {
let state = rec.state();
Claim {
addr,
reuse: state.opts.reuseaddr,
exclusive: state.opts.exclusive,
dual: state.dual_at(addr),
station: state.station,
}
}
fn tester(addr: SocketAddr, dual: bool) -> Self {
Claim {
addr,
reuse: false,
exclusive: false,
dual,
station: false,
}
}
}
fn bind_conflict(held: Claim, want: Claim) -> Option<c_int> {
if held.station != want.station {
return None;
}
if (held.addr, held.dual) == (want.addr, want.dual) {
return match (want.reuse && !want.exclusive, held.reuse) {
(false, _) => Some(WSAEADDRINUSE),
(true, true) => None,
(true, false) => Some(WSAEACCES),
};
}
if held.addr.port() != want.addr.port() {
None
} else if held.exclusive && covers(held, want) {
Some(WSAEACCES)
} else if want.exclusive && covers(want, held) {
Some(WSAEADDRINUSE)
} else {
None
}
}
fn covers(wide: Claim, narrow: Claim) -> bool {
wide.addr.ip().is_unspecified()
&& (wide.dual
|| (wide.addr.is_ipv4() == narrow.addr.is_ipv4() && !narrow.addr.ip().is_unspecified()))
}
#[derive(Default)]
pub(crate) struct Registry {
udp: HashMap<SocketAddr, Vec<Arc<DgramQueue>>>,
udp_ports: HashMap<u16, Vec<SocketAddr>>,
endpoints: HashMap<IpAddr, usize>,
listeners: HashMap<SocketAddr, Vec<Arc<ListenerState>>>,
testers: HashMap<IpAddr, usize>,
}
impl Registry {
fn bind_udp(&mut self, addr: SocketAddr, queue: &Arc<DgramQueue>) {
*queue.bound_at.lock().unwrap() = Some(addr);
if queue.rec.is_none() {
count(&mut self.endpoints, addr.ip(), true);
}
let held = self.udp.entry(addr).or_default();
if held.is_empty() {
self.udp_ports.entry(addr.port()).or_default().push(addr);
}
held.push(queue.clone());
}
fn unbind_udp(&mut self, queue: &Arc<DgramQueue>) {
let Some(addr) = queue.bound_at.lock().unwrap().take() else {
return;
};
let Some(held) = self.udp.get_mut(&addr) else {
return;
};
let before = held.len();
held.retain(|q| !Arc::ptr_eq(q, queue));
if held.len() < before && queue.rec.is_none() {
count(&mut self.endpoints, addr.ip(), false);
}
if held.is_empty() {
self.udp.remove(&addr);
if let Some(addrs) = self.udp_ports.get_mut(&addr.port()) {
addrs.retain(|a| *a != addr);
if addrs.is_empty() {
self.udp_ports.remove(&addr.port());
}
}
}
}
fn udp_on_port(&self, port: u16) -> impl Iterator<Item = (&SocketAddr, &Arc<DgramQueue>)> {
self.udp_ports
.get(&port)
.map_or(&[][..], Vec::as_slice)
.iter()
.flat_map(|addr| self.udp[addr].iter().map(move |q| (addr, q)))
}
fn listen(&mut self, addr: SocketAddr, listener: Arc<ListenerState>) {
if listener.tester {
for replaced in self.listeners.remove(&addr).into_iter().flatten() {
if replaced.tester {
count(&mut self.testers, addr.ip(), false);
}
}
}
let held = self.listeners.entry(addr).or_default();
if !held.iter().any(|l| Arc::ptr_eq(l, &listener)) {
if listener.tester {
count(&mut self.testers, addr.ip(), true);
}
held.push(listener);
}
}
fn unlisten(&mut self, listener: &Arc<ListenerState>) {
let testers = &mut self.testers;
self.listeners.retain(|addr, held| {
let before = held.len();
held.retain(|l| !Arc::ptr_eq(l, listener));
if listener.tester {
for _ in held.len()..before {
count(testers, addr.ip(), false);
}
}
!held.is_empty()
});
}
fn alloc_port(&self, ip: IpAddr, dual: bool) -> u16 {
let taken = |port: u16| {
self.udp_on_port(port).any(|(a, q)| {
dual || (a.is_ipv4() == ip.is_ipv4()
&& (a.ip() == ip || ip.is_unspecified() || a.ip().is_unspecified()))
|| (ip.is_ipv4() && q.dual_at(*a))
})
};
(49152..=65535).find(|&p| !taken(p)).unwrap_or(0)
}
fn candidates(&self, dest: SocketAddr) -> Vec<Cand<Arc<DgramQueue>>> {
let cand = |addr: SocketAddr, q: &Arc<DgramQueue>| Cand {
addr,
endpoint: q.rec.is_none(),
device: q
.rec
.as_ref()
.and_then(|r| r.state().device.as_ref().map(|d| d.0)),
dual: q.dual_at(addr),
share: q.rec.as_deref().map(Share::of).unwrap_or_default(),
q: q.clone(),
};
let group = dest.ip();
self.udp_on_port(dest.port())
.filter(|(addr, q)| {
!group.is_multicast()
|| q.rec
.as_ref()
.is_some_and(|r| r.takes_group(**addr, group, false))
})
.map(|(addr, q)| cand(*addr, q))
.collect()
}
fn station_at(&self, ip: IpAddr) -> bool {
self.endpoints.contains_key(&ip) || self.testers.contains_key(&ip)
}
}
fn count(counts: &mut HashMap<IpAddr, usize>, ip: IpAddr, up: bool) {
if up {
*counts.entry(ip).or_default() += 1;
} else if let Some(n) = counts.get_mut(&ip) {
*n -= 1;
if *n == 0 {
counts.remove(&ip);
}
}
}
fn unspecified_like(ip: IpAddr) -> IpAddr {
match ip {
IpAddr::V4(_) => IpAddr::V4(Ipv4Addr::UNSPECIFIED),
IpAddr::V6(_) => IpAddr::V6(Ipv6Addr::UNSPECIFIED),
}
}
fn dgram_claims(socks: &HashMap<c_int, Sock>) -> impl Iterator<Item = Claim> + '_ {
socks.values().filter_map(|sock| match sock {
Sock::Dgram {
local: Some(local),
requested,
rec,
..
} => {
let addr = requested.map_or(*local, |r| SocketAddr::new(r.ip(), local.port()));
Some(Claim::of(rec, addr))
}
_ => None,
})
}
fn loopback_for(domain: c_int) -> IpAddr {
if domain == AF_INET6 {
IpAddr::V6(Ipv6Addr::LOCALHOST)
} else {
IpAddr::V4(Ipv4Addr::LOCALHOST)
}
}
fn tcp_bind_addr(
socks: &HashMap<c_int, Sock>,
regs: &Registries,
mut want: Claim,
) -> Result<SocketAddr, c_int> {
let mut held: Vec<Claim> = socks
.values()
.filter_map(|sock| {
let addr = match sock {
Sock::Fresh {
local: Some(local), ..
}
| Sock::Connecting {
local: Some(local), ..
} => *local,
Sock::Listener { addr, .. } => *addr,
_ => return None,
};
Some(Claim::of(sock.rec(), addr))
})
.collect();
let testers: Vec<Claim> = regs
.lock()
.listeners
.iter()
.flat_map(|(addr, held)| held.iter().map(move |l| (addr, l)))
.filter(|(_, listener)| listener.tester)
.map(|(addr, listener)| Claim::tester(*addr, listener.dual))
.collect();
held.extend(testers);
let conflict = |want: Claim| held.iter().find_map(|&h| bind_conflict(h, want));
if want.addr.port() != 0 {
return conflict(want).map_or(Ok(want.addr), Err);
}
let port = (0..=u16::MAX - crate::scope::EPHEMERAL_FIRST)
.map(|_| regs.shared.ephemeral_port())
.find(|&port| {
conflict(Claim {
addr: SocketAddr::new(want.addr.ip(), port),
..want
})
.is_none()
})
.ok_or(WSAEADDRINUSE)?;
want.addr.set_port(port);
Ok(want.addr)
}
struct PcapHandle {
device: Vec<u8>,
rx: VecDeque<Vec<u8>>,
last_frame: Vec<u8>,
last_hdr: Vec<u8>,
}
#[derive(Default)]
struct SockTable {
socks: HashMap<c_int, Sock>,
connecting: usize,
}
impl std::ops::Deref for SockTable {
type Target = HashMap<c_int, Sock>;
fn deref(&self) -> &Self::Target {
&self.socks
}
}
impl SockTable {
fn insert(&mut self, fd: c_int, sock: Sock) -> Option<Sock> {
self.connecting += usize::from(matches!(sock, Sock::Connecting { .. }));
let replaced = self.socks.insert(fd, sock);
self.forget(replaced.as_ref());
replaced
}
fn remove(&mut self, fd: &c_int) -> Option<Sock> {
let removed = self.socks.remove(fd);
self.forget(removed.as_ref());
removed
}
fn forget(&mut self, sock: Option<&Sock>) {
if matches!(sock, Some(Sock::Connecting { .. })) {
self.connecting -= 1;
}
}
fn get_mut(&mut self, fd: &c_int) -> Option<&mut Sock> {
self.socks.get_mut(fd)
}
fn values_mut(&mut self) -> impl Iterator<Item = &mut Sock> {
self.socks.values_mut()
}
}
pub(crate) struct WinNet {
socks: Mutex<SockTable>,
regs: Arc<Registries>,
next_handle: AtomicI32,
pcaps: Mutex<HashMap<u64, PcapHandle>>,
completions: Mutex<iocp::State>,
next_pcap: std::sync::atomic::AtomicU64,
}
impl WinNet {
pub(crate) fn new(shared: Arc<SimShared>) -> Self {
WinNet {
socks: Mutex::default(),
regs: Arc::new(Registries {
reg: Mutex::default(),
shared,
}),
next_handle: AtomicI32::new(0x2000),
pcaps: Mutex::new(HashMap::default()),
completions: Mutex::default(),
next_pcap: std::sync::atomic::AtomicU64::new(0x9000_0000),
}
}
pub(crate) fn registries(&self) -> Arc<Registries> {
self.regs.clone()
}
fn recv_deadline(&self, fd: c_int) -> Option<Deadline> {
let span = self.rec(fd)?.opts().rcvtimeo?;
Some(Deadline::timeout(span))
}
fn rec(&self, fd: c_int) -> Option<Arc<SockRec>> {
self.socks
.lock()
.unwrap()
.get(&fd)
.map(|sock| sock.rec().clone())
}
fn fd_interests(
&self,
fds: impl IntoIterator<Item = c_int>,
keys: &mut crate::readiness::WakeKeys,
) -> bool {
let mut time_sensitive = false;
for fd in fds {
let connecting = matches!(
self.socks.lock().unwrap().get(&fd),
Some(Sock::Connecting { .. })
);
if let Some(rec) = self.rec(fd) {
keys.push(rec.wake_key());
time_sensitive |= connecting || rec.pending_time();
}
}
time_sensitive
}
fn mint(&self) -> c_int {
self.next_handle.fetch_add(1, Ordering::Relaxed)
}
fn udp_send(
&self,
fd: c_int,
data: Vec<u8>,
dest: SocketAddr,
msgs: &[(c_int, c_int, Vec<u8>)],
) -> Option<NetResult> {
let (local, requested, queue, domain, broadcast, nonblocking, rec) = {
let socks = self.socks.lock().unwrap();
match socks.get(&fd) {
Some(Sock::Dgram {
local,
requested,
queue,
domain,
broadcast,
nonblocking,
rec,
..
}) => (
*local,
*requested,
queue.clone(),
*domain,
*broadcast,
*nonblocking,
rec.clone(),
),
_ => return None,
}
};
let shared = &self.regs.shared;
let ctl = match win_sockopt::send_ctl(shared, &rec, dest, msgs) {
Ok(ctl) => ctl,
Err(code) => return err(code),
};
let seg = match win_sockopt::segment(&ctl, dest, data.len()) {
Ok(seg) => usize::from(seg),
Err(code) => return err(code),
};
if let Some(code) = rec.take_error_as(shared, Taker::Send) {
return err(code);
}
if domain == AF_INET6
&& let Err(code) = crossing(&rec, requested, dest)
{
if local.is_none() {
self.autobind(fd, &queue, &rec, Ipv6Addr::UNSPECIFIED.into());
}
return err(code);
}
let station = self.regs.lock().station_at(dest.ip());
let sender = match shared.route_send(
&rec.view(local.map(|l| toward(l, dest))),
dest,
Op::Send,
station,
broadcast,
) {
Ok(sender) => sender,
Err(code) => return err(code),
};
let longest = if seg == 0 { data.len() } else { seg };
if let Err(code) = win_sockopt::check_send(shared, &rec, &sender, dest, longest) {
return err(code);
}
let local = match local {
Some(local) => local,
None => self.autobind(fd, &queue, &rec, unspecified_like(loopback_for(domain))),
};
let src = match ctl.src {
Some(ip) => SocketAddr::new(ip, local.port()),
None => sender.source(toward(local, dest)),
};
let stalled = || {
let policies = &shared.policies;
policies.send_stalled(local) || policies.send_stalled(src)
};
if stalled() {
if nonblocking {
return would_block();
}
if !readiness()
.wait_until_on("udp send", None, &[rec.wake_key()], &stalled, || !stalled())
{
return err(WSAEWOULDBLOCK);
}
}
let looped = matches!(&sender, Sender::Host(path) if path.local);
let packets: Vec<&[u8]> = if seg == 0 || looped {
vec![&data]
} else {
data.chunks(seg).collect()
};
let ip = Header {
gso: if looped { seg as u16 } else { 0 },
..win_sockopt::header(&ctl, dest)
};
for packet in packets {
shared.capture_udp(&sender, src, dest, Dir::Out, packet, None);
if self.regs.deliver(&sender, src, dest, packet, ip) == 0 {
shared.unreachable_port(&rec, &sender, src, dest, packet, station);
}
rec.count_udp_sent(dest, &sender);
}
rec.note_tx_nic(sender.egress_name());
if let Some(id) = ctl.tx_id {
win_sockopt::note_tx_stamp(&rec, id, monotonic(shared));
}
if rec.has_error_reports() {
shared.bump_keys(&[rec.wake_key()]);
}
ok(data.len() as i64)
}
fn autobind(
&self,
fd: c_int,
queue: &Arc<DgramQueue>,
rec: &Arc<SockRec>,
ip: IpAddr,
) -> SocketAddr {
let dual = rec.state().dual_at(SocketAddr::new(ip, 0));
let mut regs = self.regs.lock();
let sa = SocketAddr::new(ip, regs.alloc_port(ip, dual));
rec.state().bound_order = self.regs.shared.bind_order();
regs.bind_udp(sa, queue);
drop(regs);
if let Some(Sock::Dgram { local, .. }) = self.socks.lock().unwrap().get_mut(&fd) {
*local = Some(sa);
}
rec.set_local(sa);
sa
}
fn relocate(&self, queue: &Arc<DgramQueue>, rec: &Arc<SockRec>, to: SocketAddr) {
for sock in self.socks.lock().unwrap().values_mut() {
if let Sock::Dgram {
queue: q, local, ..
} = sock
&& Arc::ptr_eq(q, queue)
{
*local = Some(to);
}
}
rec.set_local(to);
}
fn disconnect_dgram(&self, fd: c_int) -> bool {
let (queue, rec, local, requested, domain) = {
let mut socks = self.socks.lock().unwrap();
let Some(Sock::Dgram {
queue,
rec,
local,
requested,
peer,
domain,
..
}) = socks.get_mut(&fd)
else {
return false;
};
*peer = None;
(queue.clone(), rec.clone(), *local, *requested, *domain)
};
rec.set_peer(None);
if let Some(bound) = local {
let ip = requested.map_or(unspecified_like(loopback_for(domain)), |r| r.ip());
self.relocate(&queue, &rec, SocketAddr::new(ip, bound.port()));
}
true
}
fn poll_revents(&self, fd: c_int, events: i16) -> i16 {
let socks = self.socks.lock().unwrap();
let Some(sock) = socks.get(&fd) else {
return 0;
};
let (readable, writable) = match sock {
Sock::Stream { rec, .. } | Sock::Dgram { rec, .. }
if rec.peek_socket_error().is_some() =>
{
return POLLERR | if events & POLLIN != 0 { POLLRDNORM } else { 0 };
}
Sock::Stream { conn, end, .. } => (
conn.read_pipe(*end).readable_or_closed(),
conn.write_pipe(*end).writable(),
),
Sock::Dgram { queue, rec, .. } => {
(queue.has(|_| true) || rec.icmp_order().is_some(), true)
}
Sock::Listener { state, .. } => (!state.pending.lock().unwrap().is_empty(), false),
Sock::Fresh { rec, .. } if rec.peek_error().is_some() => return POLLERR | POLLHUP,
Sock::Fresh { .. } | Sock::Connecting { .. } => (false, false),
};
let mut r = 0i16;
if events & POLLIN != 0 && readable {
r |= POLLRDNORM;
}
if events & POLLOUT != 0 && writable {
r |= POLLWRNORM;
}
r
}
fn set_nonblocking(&self, fd: c_int, on: bool) {
if let Some(
Sock::Fresh { nonblocking, .. }
| Sock::Connecting { nonblocking, .. }
| Sock::Stream { nonblocking, .. }
| Sock::Listener { nonblocking, .. }
| Sock::Dgram { nonblocking, .. },
) = self.socks.lock().unwrap().get_mut(&fd)
{
*nonblocking = on;
}
}
fn join_group(&self, fd: c_int, membership: Membership) {
if let Some(Sock::Dgram {
local: Some(_),
rec,
..
}) = self.socks.lock().unwrap().get(&fd)
{
rec.join(membership);
}
}
}
enum Progress {
Pending(Deadline),
Settled(Outcome, Arc<SockRec>),
Idle,
}
#[repr(C)]
struct FdSet {
fd_count: u32,
fd_array: [usize; FD_SETSIZE],
}
const FD_SETSIZE: usize = 64;
#[repr(C)]
struct Timeval {
tv_sec: i32,
tv_usec: i32,
}
unsafe fn read_fd_set(set: *const u8) -> Vec<c_int> {
let set = set.cast::<FdSet>();
let count = unsafe { std::ptr::addr_of!((*set).fd_count).read_unaligned() };
let array = unsafe { std::ptr::addr_of!((*set).fd_array).cast::<usize>() };
(0..(count as usize).min(FD_SETSIZE))
.map(|i| unsafe { array.add(i).read_unaligned() } as c_int)
.collect()
}
unsafe fn write_fd_set(set: *mut u8, fds: &[c_int]) {
let set = set.cast::<FdSet>();
unsafe { std::ptr::addr_of_mut!((*set).fd_count).write_unaligned(fds.len() as u32) };
let array = unsafe { std::ptr::addr_of_mut!((*set).fd_array).cast::<usize>() };
for (i, &fd) in fds.iter().enumerate() {
unsafe { array.add(i).write_unaligned(fd as usize) };
}
}
impl WinNet {
fn listener_for(&self, dest: SocketAddr, host_local: bool) -> Option<Arc<ListenerState>> {
let reg = self.regs.lock();
let pick = |held: Vec<&Arc<ListenerState>>| {
let shares: Vec<Share> = held.iter().map(|l| l.share()).collect();
let i = match held.len() {
0 => return None,
1 => 0,
_ => pick_shared(&shares, false, dest, dest, self.regs.shared.seed),
};
Some(held[i].clone())
};
let at = |ip| {
reg.listeners
.get(&SocketAddr::new(ip, dest.port()))
.into_iter()
.flatten()
};
if let Some(listener) = pick(at(dest.ip()).collect()) {
return Some(listener);
}
if !host_local {
return None;
}
pick(at(unspecified_like(dest.ip())).collect()).or_else(|| {
pick(
at(Ipv6Addr::UNSPECIFIED.into())
.filter(|listener| dest.is_ipv4() && listener.dual)
.collect(),
)
})
}
fn client_addr(
&self,
dest: SocketAddr,
bound: Option<SocketAddr>,
sender: &Sender,
) -> SocketAddr {
let src = sender
.source(SocketAddr::new(unspecified_like(dest.ip()), 0))
.ip();
match bound {
Some(local) if !local.ip().is_unspecified() => local,
Some(local) => SocketAddr::new(src, local.port()),
None => SocketAddr::new(src, self.regs.shared.ephemeral_port()),
}
}
fn establish(
&self,
rec: &Arc<SockRec>,
dest: SocketAddr,
client: SocketAddr,
sender: &Sender,
server_in: bool,
) -> Arc<Conn> {
let hop = self.regs.shared.tcp_hop(sender, dest.ip());
let via = hop.as_ref().map(|hop| hop.link.clone());
let ends = |from, to| {
Some(Ends {
shared: self.regs.shared.clone(),
from,
to,
})
};
let conn = Arc::new(Conn {
a_to_b: Pipe::new(
via.clone(),
ends(client, dest),
self.regs.shared.domain_key(),
),
b_to_a: Pipe::new(via, ends(dest, client), self.regs.shared.domain_key()),
client,
server: dest,
regs: self.regs.clone(),
hop,
tap: self.regs.shared.tcp_tap(sender, client, dest, server_in),
});
rec.set_ends(client, dest);
rec.note_conn_nic(sender.egress_name());
if !server_in {
crate::netstats::bump(&self.regs.shared.stats.tcp(dest.ip()).passive_opens);
}
conn.b_to_a.read_by(rec);
conn.a_to_b.write_by(rec);
conn
}
fn advance_connect(&self, fd: c_int) -> Progress {
let mut socks = self.socks.lock().unwrap();
let Some(Sock::Connecting {
local,
rec,
dest,
attempt,
..
}) = socks.get(&fd)
else {
return Progress::Idle;
};
let (local, rec, dest, attempt) = (*local, rec.clone(), *dest, attempt.clone());
let client = attempt.lock().unwrap().client;
let shared = &self.regs.shared;
let mut listener = None;
let mut admission = None;
let step = attempt.lock().unwrap().poll(|| {
let station = self.regs.lock().station_at(dest.ip());
let host_local = shared.dest_is_host(dest.ip(), station);
listener = self.listener_for(dest, host_local);
let syn = shared.syn_probe(dest, listener.is_some(), station);
if matches!(syn, Syn::Accept) {
admission = listener.as_ref().and_then(ListenerState::reserve);
if admission.is_none() {
return Syn::Silent;
}
}
if host_local && matches!(syn, Syn::Rst) {
crate::netstats::bump(&shared.stats.tcp(dest.ip()).out_rsts);
}
syn
});
let outcome = match step {
Ok(next) => return Progress::Pending(next),
Err(outcome) => outcome,
};
let conn = match (outcome, listener) {
(Outcome::Connected, Some(listener)) => {
let station = self.regs.lock().station_at(dest.ip());
shared
.route_send(&rec.view(local), dest, Op::Connect, station, true)
.map(|sender| {
let conn = self.establish(&rec, dest, client, &sender, listener.tester);
(conn, listener)
})
}
(Outcome::Connected, None) => Err(WSAECONNREFUSED),
(Outcome::Failed(code), _) => Err(code),
};
let aliases: Vec<c_int> = socks
.iter()
.filter(|(_, sock)| {
matches!(sock, Sock::Connecting { attempt: a, .. } if Arc::ptr_eq(a, &attempt))
})
.map(|(fd, _)| *fd)
.collect();
for alias in aliases {
let Some(Sock::Connecting {
local,
nonblocking,
rec,
..
}) = socks.remove(&alias)
else {
continue;
};
let settled = match &conn {
Ok((conn, _)) => Sock::Stream {
conn: conn.clone(),
end: End::A,
nonblocking,
rec,
},
Err(_) => Sock::Fresh {
nonblocking,
local,
rec,
},
};
socks.insert(alias, settled);
}
let mut keys = crate::readiness::WakeKeys::default();
keys.push(rec.wake_key());
let outcome = match conn {
Ok((conn, listener)) => {
attempt.lock().unwrap().established(conn.tap.as_ref());
if let Some(key) = listener.wake_key() {
keys.push(key);
}
admission
.expect("accepted SYN reserves a queue entry")
.queue(conn);
Outcome::Connected
}
Err(code) => {
rec.set_pending_error(code, None);
Outcome::Failed(code)
}
};
drop(socks);
shared.connect_settled(dest, outcome, true);
shared.bump_keys(keys.as_slice());
Progress::Settled(outcome, rec)
}
fn advance_connecting(&self, fds: Option<&[c_int]>) {
let socks = self.socks.lock().unwrap();
if socks.connecting == 0 {
return;
}
let connecting: Vec<c_int> = socks
.iter()
.filter(|(fd, sock)| {
matches!(sock, Sock::Connecting { .. }) && fds.is_none_or(|fds| fds.contains(fd))
})
.map(|(fd, _)| *fd)
.collect();
drop(socks);
for fd in connecting {
self.advance_connect(fd);
}
}
fn connect_due(&self, fd: c_int) -> bool {
match self.socks.lock().unwrap().get(&fd) {
Some(Sock::Connecting { attempt, .. }) => attempt.lock().unwrap().due(),
_ => true,
}
}
fn connecting_due(&self, fds: Option<&[c_int]>) -> bool {
self.socks
.lock()
.unwrap()
.iter()
.any(|(fd, sock)| match sock {
Sock::Connecting { attempt, .. } => {
fds.is_none_or(|fds| fds.contains(fd)) && attempt.lock().unwrap().due()
}
_ => false,
})
}
fn select_ready(&self, sets: &[Option<Vec<c_int>>; 3]) -> [Vec<c_int>; 3] {
let [read, write, except] = sets;
let pick = |set: &Option<Vec<c_int>>, ready: &dyn Fn(c_int) -> bool| -> Vec<c_int> {
set.iter()
.flatten()
.copied()
.filter(|fd| ready(*fd))
.collect()
};
[
pick(read, &|fd| self.poll_revents(fd, POLLIN) & POLLIN != 0),
pick(write, &|fd| self.poll_revents(fd, POLLOUT) & POLLOUT != 0),
pick(
except,
&|fd| matches!(self.socks.lock().unwrap().get(&fd), Some(Sock::Fresh { rec, .. }) if rec.peek_error().is_some()),
),
]
}
}
impl WinNet {
unsafe fn interface_opt(
&self,
rec: &SockRec,
level: c_int,
name: c_int,
val: *const u8,
len: u32,
) -> Option<Result<(), c_int>> {
let unicast = (level == IPPROTO_IP && name == IP_UNICAST_IF)
|| (level == IPPROTO_IPV6 && name == IPV6_UNICAST_IF);
let multicast = (level == IPPROTO_IP && name == IP_MULTICAST_IF)
|| (level == IPPROTO_IPV6 && name == IPV6_MULTICAST_IF);
if !unicast && !multicast {
return None;
}
if val.is_null() || len < 4 {
return Some(Err(WSAEFAULT));
}
let raw = unsafe { val.cast::<[u8; 4]>().read_unaligned() };
let topo = self.regs.shared.topo();
let index = if level == IPPROTO_IP && multicast && raw[0] != 0 {
match topo.index_of_address(IpAddr::V4(Ipv4Addr::from(raw))) {
Some(index) => index,
None => return Some(Err(WSAEINVAL)),
}
} else if level == IPPROTO_IP {
u32::from_be_bytes(raw)
} else {
u32::from_ne_bytes(raw)
};
let nic = match index {
0 => None,
index => match topo.name_of(index) {
Some(name) => Some((index, name)),
None => return Some(Err(WSAEINVAL)),
},
};
drop(topo);
let mut state = rec.state();
if unicast {
state.device = nic;
} else {
state.mcast_if = nic;
}
Some(Ok(()))
}
}
#[derive(Clone, Copy, PartialEq)]
enum RecvCall {
Plain,
Wsa,
Msg,
}
type WsaBuf = windows_sys::Win32::Networking::WinSock::WSABUF;
type WsaMsg = windows_sys::Win32::Networking::WinSock::WSAMSG;
type CmsgHdr = windows_sys::Win32::Networking::WinSock::CMSGHDR;
fn cmsg_align(n: usize) -> usize {
(n + size_of::<usize>() - 1) & !(size_of::<usize>() - 1)
}
unsafe fn wsa_buffers(msg: &WsaMsg) -> Result<&[WsaBuf], c_int> {
if msg.dwBufferCount == 0 {
return Ok(&[]);
}
if msg.lpBuffers.is_null() {
return Err(WSAEFAULT);
}
Ok(unsafe { std::slice::from_raw_parts(msg.lpBuffers, msg.dwBufferCount as usize) })
}
unsafe fn scatter(buffers: &[WsaBuf], data: &[u8]) -> usize {
let mut at = 0;
for buf in buffers {
let n = (buf.len as usize).min(data.len() - at);
if n > 0 {
unsafe { std::ptr::copy_nonoverlapping(data.as_ptr().add(at), buf.buf, n) };
}
at += n;
if at == data.len() {
break;
}
}
at
}
unsafe fn gather(buffers: &[WsaBuf]) -> Vec<u8> {
let mut out = Vec::with_capacity(buffers.iter().map(|b| b.len as usize).sum());
for buf in buffers.iter().filter(|b| b.len > 0) {
out.extend_from_slice(unsafe { std::slice::from_raw_parts(buf.buf, buf.len as usize) });
}
out
}
unsafe fn write_cmsgs(msg: &mut WsaMsg, messages: &[(c_int, c_int, Vec<u8>)]) -> u32 {
let header = cmsg_align(size_of::<CmsgHdr>());
let mut bytes = Vec::new();
for (level, ty, data) in messages {
let at = bytes.len();
bytes.resize(at + header + cmsg_align(data.len()), 0);
let hdr = CmsgHdr {
cmsg_len: header + data.len(),
cmsg_level: *level,
cmsg_type: *ty,
};
unsafe {
bytes
.as_mut_ptr()
.add(at)
.cast::<CmsgHdr>()
.write_unaligned(hdr)
};
bytes[at + header..at + header + data.len()].copy_from_slice(data);
}
let cap = if msg.Control.buf.is_null() {
0
} else {
msg.Control.len as usize
};
let n = cap.min(bytes.len());
if n > 0 {
unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), msg.Control.buf, n) };
}
msg.Control.len = bytes.len() as u32;
if bytes.len() > cap { MSG_CTRUNC } else { 0 }
}
unsafe fn read_cmsgs(msg: &WsaMsg) -> Result<Vec<(c_int, c_int, Vec<u8>)>, c_int> {
let mut out = Vec::new();
if msg.Control.buf.is_null() {
return Ok(out);
}
let control = unsafe { std::slice::from_raw_parts(msg.Control.buf, msg.Control.len as usize) };
let header = size_of::<CmsgHdr>();
let mut at = 0usize;
while at + header <= control.len() {
let hdr = unsafe { control.as_ptr().add(at).cast::<CmsgHdr>().read_unaligned() };
if hdr.cmsg_len < cmsg_align(header) || hdr.cmsg_len > control.len() - at {
return Err(WSAEINVAL);
}
out.push((
hdr.cmsg_level,
hdr.cmsg_type,
control[at + cmsg_align(header)..at + hdr.cmsg_len].to_vec(),
));
at += cmsg_align(hdr.cmsg_len);
}
Ok(out)
}
impl WinNet {
unsafe fn set_v6only(
&self,
fd: c_int,
rec: &SockRec,
kind: win_sockopt::Kind,
val: *const u8,
len: u32,
) -> Result<(), c_int> {
let size = if kind.stream { 4 } else { 1 };
if val.is_null() || (len as usize) < size {
return Err(WSAEFAULT);
}
let bound = match self.socks.lock().unwrap().get(&fd) {
Some(Sock::Dgram { local, .. } | Sock::Fresh { local, .. }) => local.is_some(),
_ => true,
};
if bound {
return Err(WSAEINVAL);
}
let on = if kind.stream {
(unsafe { val.cast::<u32>().read_unaligned() }) != 0
} else {
(unsafe { *val }) != 0
};
rec.state().v6only = on;
Ok(())
}
fn kind(&self, fd: c_int) -> Option<win_sockopt::Kind> {
let socks = self.socks.lock().unwrap();
let sock = socks.get(&fd)?;
Some(match sock {
Sock::Dgram { domain, rec, .. } => win_sockopt::Kind {
stream: false,
connecting: false,
v6: *domain == AF_INET6,
v6only: rec.state().v6only,
},
_ => {
let state = sock.rec().state();
win_sockopt::Kind {
stream: true,
connecting: matches!(sock, Sock::Connecting { .. }),
v6: state.win.v6,
v6only: state.v6only,
}
}
})
}
fn recv_flags(
&self,
rec: &SockRec,
call: RecvCall,
stream: bool,
nonblocking: bool,
flags: c_int,
) -> Result<(), c_int> {
let known = match call {
RecvCall::Plain => MSG_OOB | MSG_PEEK | MSG_WAITALL,
RecvCall::Wsa => MSG_OOB | MSG_PEEK | MSG_WAITALL | MSG_PARTIAL | MSG_PUSH_IMMEDIATE,
RecvCall::Msg => MSG_PEEK,
};
if flags & !known != 0 {
return Err(WSAEINVAL);
}
if flags & MSG_WAITALL != 0
&& (!stream || nonblocking || flags & (MSG_OOB | MSG_PEEK | MSG_PARTIAL) != 0)
{
return Err(WSAEOPNOTSUPP);
}
if flags & MSG_OOB != 0 {
let inline = rec
.ignored_value(win_sockopt::SOL_SOCKET, win_sockopt::SO_OOBINLINE)
.is_some_and(|v| v.iter().any(|&b| b != 0));
return Err(if stream && inline {
WSAEINVAL
} else {
WSAEOPNOTSUPP
});
}
Ok(())
}
fn stream_take(
&self,
fd: c_int,
out: &mut [u8],
flags: c_int,
) -> Option<(usize, Result<usize, c_int>)> {
let (conn, end, nonblocking, rec) = match self.socks.lock().unwrap().get(&fd)? {
Sock::Stream {
conn,
end,
nonblocking,
rec,
} => (conn.clone(), *end, *nonblocking, rec.clone()),
_ => return Some((0, Err(WSAENOTCONN))),
};
let peek = flags & MSG_PEEK != 0;
let all = flags & MSG_WAITALL != 0;
let taker = if peek { Taker::Peek } else { Taker::Recv };
let pipe = conn.read_pipe(end);
let deadline = self.recv_deadline(fd);
let mut got = 0usize;
let partial =
|got: usize, code: c_int| Some((got, if got > 0 { Ok(got) } else { Err(code) }));
loop {
if let Some(code) = rec.take_error_as(&self.regs.shared, taker) {
return partial(got, code);
}
let rest = &mut out[got..];
let read = if peek {
pipe.peek(rest)
} else {
pipe.read(rest)
};
match read {
Read::Data(n) => {
got += n;
if !all || got == out.len() {
return Some((got, Ok(got)));
}
}
Read::Eof => return Some((got, Ok(got))),
Read::Reset => return Some((got, Err(WSAECONNRESET))),
Read::Shut => return partial(got, WSAESHUTDOWN),
Read::WouldBlock if nonblocking => {
snare_interpose::charge_latency();
return Some((got, Err(WSAEWOULDBLOCK)));
}
Read::WouldBlock => {
if !readiness().wait_until_on(
"tcp recv",
deadline,
&[rec.wake_key()],
|| rec.pending_time(),
|| pipe.readable_or_closed() || rec.peek_error().is_some(),
) {
let timed_out = deadline.is_some_and(|d| d.passed());
if timed_out && got > 0 && all {
return Some((got, Ok(0)));
}
return partial(
got,
if timed_out {
WSAETIMEDOUT
} else {
WSAEWOULDBLOCK
},
);
}
}
}
}
}
fn dgram_take(&self, fd: c_int, flags: c_int) -> Option<Result<Datagram, c_int>> {
let (queue, peer, nonblocking, rec) = match self.socks.lock().unwrap().get(&fd)? {
Sock::Dgram {
queue,
peer,
nonblocking,
rec,
..
} => (queue.clone(), *peer, *nonblocking, rec.clone()),
_ => return None,
};
let peek = flags & MSG_PEEK != 0;
let taker = if peek { Taker::Peek } else { Taker::Recv };
let accept = |src: SocketAddr| peer.is_none_or(|p| p == src);
let deadline = self.recv_deadline(fd);
loop {
match queue.take(accept, &self.regs.shared, taker) {
Ok(Some(dg)) => return Some(Ok(dg)),
Err(error) => return Some(Err(error)),
Ok(None) => {}
}
if nonblocking {
snare_interpose::charge_latency();
return Some(Err(WSAEWOULDBLOCK));
}
if !readiness().wait_until_on(
"udp recv",
deadline,
&[rec.wake_key()],
|| rec.pending_time(),
|| queue.has(accept) || rec.peek_error().is_some(),
) {
let timed_out = deadline.is_some_and(|d| d.passed());
return Some(Err(if timed_out {
WSAETIMEDOUT
} else {
WSAEWOULDBLOCK
}));
}
}
}
fn recv_state(&self, fd: c_int) -> Option<(bool, Arc<SockRec>, bool)> {
let socks = self.socks.lock().unwrap();
let sock = socks.get(&fd)?;
let nonblocking = match sock {
Sock::Fresh { nonblocking, .. }
| Sock::Connecting { nonblocking, .. }
| Sock::Stream { nonblocking, .. }
| Sock::Listener { nonblocking, .. }
| Sock::Dgram { nonblocking, .. } => *nonblocking,
};
Some((
nonblocking,
sock.rec().clone(),
matches!(sock, Sock::Dgram { .. }),
))
}
unsafe fn receive(
&self,
fd: c_int,
buf: *mut u8,
len: usize,
flags: c_int,
call: RecvCall,
(addr, addr_len): (*mut u8, *mut u32),
) -> Option<Result<i64, c_int>> {
let (nonblocking, rec, dgram) = self.recv_state(fd)?;
if let Err(code) = self.recv_flags(&rec, call, !dgram, nonblocking, flags) {
return Some(Err(code));
}
let out: &mut [u8] = if len == 0 {
&mut []
} else {
unsafe { std::slice::from_raw_parts_mut(buf, len) }
};
if !dgram {
return self
.stream_take(fd, out, flags)
.map(|(_, reported)| reported.map(|reported| reported as i64));
}
let dg = match self.dgram_take(fd, flags)? {
Ok(dg) => dg,
Err(code) => return Some(Err(code)),
};
let n = len.min(dg.data.len());
out[..n].copy_from_slice(&dg.data[..n]);
if !addr.is_null() && !addr_len.is_null() {
unsafe { write_addr(reported(rec.state().inet6, dg.src), addr, addr_len) };
}
Some(if dg.data.len() > len {
Err(WSAEMSGSIZE)
} else {
Ok(n as i64)
})
}
fn msg_flags(&self, dg: &Datagram, truncated: bool) -> u32 {
let mut flags = if truncated { MSG_TRUNC } else { 0 };
if dg.dest.ip().is_multicast() {
flags |= MSG_MCAST;
} else if self.regs.shared.topo().is_broadcast(dg.dest.ip()) {
flags |= MSG_BCAST;
}
flags
}
}
impl Net for WinNet {
unsafe fn completion(&self, call: snare_interpose::CompletionCall) -> Option<NetResult> {
unsafe { iocp::call(self, call) }
}
unsafe fn iphlp(&self, call: snare_interpose::IpHlpCall<'_>) -> Option<NetResult> {
unsafe { crate::iphlp::call(&self.regs.shared, call) }
}
fn owns(&self, fd: c_int) -> bool {
self.socks.lock().unwrap().contains_key(&fd)
}
unsafe fn socket(&self, domain: c_int, ty: c_int, _protocol: c_int) -> Option<NetResult> {
if domain != AF_INET && domain != AF_INET6 {
return None;
}
let kind = match ty & 0xff {
SOCK_STREAM => SocketKind::TcpStream,
SOCK_DGRAM => SocketKind::Udp,
_ => return None,
};
let fd = self.mint();
let rec = self.regs.shared.new_socket(kind, fd);
{
let mut state = rec.state();
state.win.v6 = domain == AF_INET6;
state.inet6 = domain == AF_INET6;
state.v6only = self.regs.shared.sys.limits().bindv6only;
}
let sock = match kind {
SocketKind::Udp => Sock::Dgram {
queue: DgramQueue::for_socket(&rec),
domain,
local: None,
requested: None,
peer: None,
nonblocking: false,
broadcast: false,
rec,
},
_ => Sock::Fresh {
nonblocking: false,
local: None,
rec,
},
};
self.socks.lock().unwrap().insert(fd, sock);
ok(fd as i64)
}
unsafe fn bind(&self, fd: c_int, addr: *const u8, len: u32) -> Option<NetResult> {
let mut socks = self.socks.lock().unwrap();
let rec = socks.get(&fd)?.rec().clone();
let inet6 = rec.state().inet6;
let want = match unsafe { family_addr(inet6, addr, len) } {
Ok(want) => want,
Err(code) => return err(code),
};
if inet6 && want.is_ipv4() && rec.state().v6only {
return err(code::EADDRNOTAVAIL);
}
let station = self.regs.shared.topo().is_station_ip(want.ip());
let claim = |want: SocketAddr| Claim {
station,
..Claim::of(&rec, want)
};
match socks.get(&fd)? {
Sock::Fresh { local: None, .. } => {
if let Err(code) = self.regs.shared.claim_address(want.ip()) {
return err(code);
}
let want = match tcp_bind_addr(&socks, &self.regs, claim(want)) {
Ok(want) => want,
Err(code) => return err(code),
};
if let Some(Sock::Fresh { local, .. }) = socks.get_mut(&fd) {
*local = Some(want);
}
rec.state().bound_order = self.regs.shared.bind_order();
rec.set_local(want);
ok(0)
}
Sock::Dgram {
local: None, queue, ..
} => {
let queue = queue.clone();
if let Err(code) = self.regs.shared.claim_address(want.ip()) {
return err(code);
}
let asked = want;
let mut want = want;
let mut regs = self.regs.lock();
if want.port() == 0 {
want.set_port(regs.alloc_port(want.ip(), rec.state().dual_at(want)));
} else {
let wanted = claim(want);
if let Some(code) =
dgram_claims(&socks).find_map(|held| bind_conflict(held, wanted))
{
return err(code);
}
if regs
.udp
.get(&want)
.is_some_and(|held| held.iter().any(|q| q.rec.is_none()))
{
return err(WSAEADDRINUSE);
}
}
rec.state().bound_order = self.regs.shared.bind_order();
regs.bind_udp(want, &queue);
drop(regs);
if let Some(Sock::Dgram {
local, requested, ..
}) = socks.get_mut(&fd)
{
*local = Some(want);
*requested = Some(asked);
}
rec.set_local(want);
ok(0)
}
_ => err(WSAEINVAL),
}
}
unsafe fn listen(&self, fd: c_int, backlog: c_int) -> Option<NetResult> {
let mut socks = self.socks.lock().unwrap();
let (addr, nonblocking, rec) = match socks.get(&fd)? {
Sock::Fresh {
local: Some(local),
nonblocking,
rec,
} => (*local, *nonblocking, rec.clone()),
Sock::Listener { .. } => return ok(0),
Sock::Fresh { local: None, .. } => return err(WSAEINVAL),
Sock::Stream { .. } | Sock::Connecting { .. } => return err(WSAEISCONN),
Sock::Dgram { .. } => return err(WSAEOPNOTSUPP),
};
let dual = rec.state().dual_at(addr);
let state = Arc::new(ListenerState {
rec: Some(Arc::downgrade(&rec)),
dual,
capacity: AtomicUsize::new(if backlog == i32::MAX {
self.regs.shared.sys.limits().listen_backlog_max
} else if backlog < 0 {
(backlog.unsigned_abs() as usize).clamp(200, 65535)
} else {
(backlog as usize).max(1)
}),
..ListenerState::default()
});
self.regs.lock().listen(addr, state.clone());
rec.set_kind(SocketKind::TcpListener);
socks.insert(
fd,
Sock::Listener {
state,
addr,
nonblocking,
rec,
},
);
ok(0)
}
unsafe fn accept(
&self,
fd: c_int,
addr: *mut u8,
addr_len: *mut u32,
_flags: c_int,
) -> Option<NetResult> {
let (state, nonblocking, lrec) = match self.socks.lock().unwrap().get(&fd)? {
Sock::Listener {
state,
nonblocking,
rec,
..
} => (state.clone(), *nonblocking, rec.clone()),
Sock::Dgram { .. } => return err(WSAEOPNOTSUPP),
_ => return err(WSAEINVAL),
};
let pop = || state.pending.lock().unwrap().pop_front();
let conn = if let Some(c) = pop() {
c
} else if nonblocking {
return would_block();
} else if readiness().wait_until_on(
"accept",
None,
&[lrec.wake_key()],
|| lrec.pending_time(),
|| !state.pending.lock().unwrap().is_empty(),
) {
match pop() {
Some(c) => c,
None => return err(WSAEWOULDBLOCK),
}
} else {
return err(WSAEWOULDBLOCK);
};
let peer = conn.client;
let new_fd = self.mint();
state.occupied.fetch_sub(1, Ordering::AcqRel);
let rec = self.regs.shared.new_socket(SocketKind::TcpStream, new_fd);
rec.set_ends(conn.server, conn.client);
rec.set_listener(lrec.id);
rec.inherit_buffers(&lrec);
let inet6 = {
let listener = lrec.state();
let mut state = rec.state();
state.win.v6 = listener.win.v6;
state.inet6 = listener.inet6;
state.v6only = listener.v6only;
listener.inet6
};
rec.note_conn_nic(self.regs.shared.hop_name(conn.hop.as_ref()).as_deref());
conn.a_to_b.read_by(&rec);
conn.b_to_a.write_by(&rec);
self.socks.lock().unwrap().insert(
new_fd,
Sock::Stream {
conn,
end: End::B,
nonblocking,
rec,
},
);
if !addr.is_null() && !addr_len.is_null() {
unsafe { write_addr(reported(inet6, peer), addr, addr_len) };
}
ok(new_fd as i64)
}
unsafe fn connect(&self, fd: c_int, addr: *const u8, len: u32) -> Option<NetResult> {
if !addr.is_null()
&& len >= 2
&& unsafe { addr.cast::<u16>().read_unaligned() } == AF_UNSPEC as u16
&& let Some(Sock::Dgram { domain, .. }) = self.socks.lock().unwrap().get(&fd)
{
let size = if *domain == AF_INET6 { 28 } else { 16 };
if len < size {
return err(WSAEFAULT);
}
}
if !addr.is_null()
&& len >= 2
&& unsafe { addr.cast::<u16>().read_unaligned() } == AF_UNSPEC as u16
&& self.disconnect_dgram(fd)
{
return ok(0);
}
let inet6 = self.rec(fd)?.state().inet6;
let dest = match unsafe { family_addr(inet6, addr, len) } {
Ok(dest) => dest,
Err(code) => return err(code),
};
if dest.ip().is_unspecified() && dest.port() == 0 && self.disconnect_dgram(fd) {
return ok(0);
}
let station = self.regs.lock().station_at(dest.ip());
let (nonblocking, bound, rec) = {
let socks = self.socks.lock().unwrap();
match socks.get(&fd)? {
Sock::Dgram { peer: Some(_), .. } => {
drop(socks);
self.disconnect_dgram(fd);
return unsafe { self.connect(fd, addr, len) };
}
Sock::Dgram {
local,
requested,
queue,
rec,
broadcast,
..
} => {
let (local, requested, queue, rec, broadcast) =
(*local, *requested, queue.clone(), rec.clone(), *broadcast);
drop(socks);
if inet6 && let Err(code) = crossing(&rec, requested, dest) {
return err(code);
}
let sender = match self.regs.shared.route_send(
&rec.view(local.map(|l| toward(l, dest))),
dest,
Op::Connect,
station,
broadcast,
) {
Ok(sender) => sender,
Err(code) => return err(code),
};
match local {
None => {
let ip = sender
.connected_local(SocketAddr::new(unspecified_like(dest.ip()), 0))
.ip();
self.autobind(fd, &queue, &rec, ip);
}
Some(bound) => {
let to = sender.connected_local(toward(bound, dest));
self.relocate(&queue, &rec, to);
}
}
if let Some(Sock::Dgram { peer, .. }) = self.socks.lock().unwrap().get_mut(&fd)
{
*peer = Some(dest);
}
rec.set_peer(Some(dest));
rec.note_tx_nic(sender.egress_name());
return ok(0);
}
Sock::Fresh {
nonblocking,
local,
rec,
} => (*nonblocking, *local, rec.clone()),
Sock::Connecting { .. } => {
drop(socks);
return match self.advance_connect(fd) {
Progress::Pending(_) => {
snare_interpose::charge_latency();
err(WSAEALREADY)
}
Progress::Settled(Outcome::Failed(code), rec) => {
rec.take_error();
err(code)
}
Progress::Settled(Outcome::Connected, _) => err(WSAEISCONN),
Progress::Idle => unsafe { self.connect(fd, addr, len) },
};
}
_ => return err(WSAEISCONN),
}
};
if inet6 {
let refused = if dest.is_ipv4() {
rec.state().v6only || bound.is_some_and(|b| b.is_ipv6() && !b.ip().is_unspecified())
} else {
bound.is_some_and(|b| b.is_ipv4())
};
if refused {
return err(if dest.is_ipv4() {
code::EADDRNOTAVAIL
} else {
code::ENETUNREACH
});
}
}
let from = bound.map(|b| toward(b, dest));
let sender =
match self
.regs
.shared
.route_send(&rec.view(from), dest, Op::Connect, station, true)
{
Ok(sender) => sender,
Err(code) => return err(code),
};
crate::netstats::bump(&self.regs.shared.stats.tcp(dest.ip()).active_opens);
let host_local = matches!(&sender, Sender::Host(path) if path.local);
let listener = self.listener_for(dest, host_local);
let mut syn = self
.regs
.shared
.syn_probe(dest, listener.is_some(), station);
let admission = if matches!(syn, Syn::Accept) {
listener.as_ref().and_then(ListenerState::reserve)
} else {
None
};
if matches!(syn, Syn::Accept) && admission.is_none() {
syn = Syn::Silent;
}
if host_local && matches!(syn, Syn::Rst) {
crate::netstats::bump(&self.regs.shared.stats.tcp(dest.ip()).out_rsts);
}
let client = self.client_addr(dest, from, &sender);
if let (Syn::Accept, Some(listener)) = (syn, &listener) {
let conn = self.establish(&rec, dest, client, &sender, listener.tester);
if let Some(tap) = &conn.tap {
tap.open(false, Duration::ZERO);
}
self.socks.lock().unwrap().insert(
fd,
Sock::Stream {
conn: conn.clone(),
end: End::A,
nonblocking,
rec,
},
);
admission
.expect("accepted SYN reserves a queue entry")
.queue(conn);
let mut keys = crate::readiness::WakeKeys::default();
self.fd_interests([fd], &mut keys);
if let Some(key) = listener.wake_key() {
keys.push(key);
}
self.regs.shared.bump_keys(keys.as_slice());
return ok(0);
}
let plan = self.regs.shared.syn_plan(&rec.opts(), syn);
let server_in = listener.as_ref().is_none_or(|l| l.tester);
let tap = self.regs.shared.tcp_tap(&sender, client, dest, server_in);
let attempt = match ConnectAttempt::start(&plan, syn, client, tap) {
Ok(attempt) => attempt,
Err(Outcome::Failed(code)) => {
self.regs
.shared
.connect_settled(dest, Outcome::Failed(code), false);
return err(code);
}
Err(Outcome::Connected) => unreachable!("a SYN a listener accepts connects at once"),
};
self.socks.lock().unwrap().insert(
fd,
Sock::Connecting {
nonblocking,
local: bound,
rec,
dest,
attempt: Arc::new(Mutex::new(attempt)),
},
);
if nonblocking {
return err(WSAEWOULDBLOCK);
}
loop {
match self.advance_connect(fd) {
Progress::Pending(next) => {
readiness().wait_until_dynamic(
"connect",
Some(next),
|keys| self.fd_interests([fd], keys),
|| self.connect_due(fd),
);
}
Progress::Settled(Outcome::Connected, _) => return ok(0),
Progress::Settled(Outcome::Failed(code), rec) => {
rec.take_error();
return err(code);
}
Progress::Idle => {
return match self.socks.lock().unwrap().get(&fd) {
Some(Sock::Stream { .. }) => ok(0),
Some(Sock::Fresh { rec, .. }) => {
err(rec.take_error().unwrap_or(WSAECONNABORTED))
}
_ => err(WSAENOTSOCK),
};
}
}
}
}
unsafe fn send(
&self,
fd: c_int,
buf: *const u8,
len: usize,
flags: c_int,
) -> Option<NetResult> {
let socks = self.socks.lock().unwrap();
if flags & MSG_OOB != 0 && socks.contains_key(&fd) {
return err(WSAEOPNOTSUPP);
}
match socks.get(&fd) {
Some(Sock::Stream {
conn,
end,
rec,
nonblocking,
}) => {
let (conn, end, rec, nonblocking) = (conn.clone(), *end, rec.clone(), *nonblocking);
drop(socks);
if let Some(code) = rec.take_error_as(&self.regs.shared, Taker::Send) {
return err(code);
}
let bytes = unsafe { std::slice::from_raw_parts(buf, len) };
let sent = conn.write_pipe(end).send(
bytes,
nonblocking,
rec.opts().sndtimeo,
|rest| conn.write(end, rest),
|| rec.peek_error().is_some(),
);
match sent {
Sent::Bytes(n) => {
rec.count_sent();
ok(n as i64)
}
Sent::Closed if conn.a_to_b.is_reset() => err(WSAECONNRESET),
Sent::Closed => err(WSAESHUTDOWN),
Sent::WouldBlock | Sent::Stuck | Sent::Interrupted => err(WSAEWOULDBLOCK),
Sent::TimedOut => err(WSAETIMEDOUT),
Sent::Error => err(rec
.take_error_as(&self.regs.shared, Taker::Send)
.unwrap_or(WSAEWOULDBLOCK)),
}
}
Some(Sock::Dgram { peer, .. }) => {
let peer = *peer;
drop(socks);
let Some(dest) = peer else {
return err(WSAEDESTADDRREQ);
};
let data = unsafe { std::slice::from_raw_parts(buf, len) }.to_vec();
self.udp_send(fd, data, dest, &[])
}
Some(_) => err(WSAENOTCONN),
None => None,
}
}
unsafe fn sendto(
&self,
fd: c_int,
buf: *const u8,
len: usize,
flags: c_int,
addr: *const u8,
addr_len: u32,
) -> Option<NetResult> {
let dgram = matches!(self.socks.lock().unwrap().get(&fd)?, Sock::Dgram { .. });
if addr.is_null() || !dgram {
return unsafe { self.send(fd, buf, len, flags) };
}
if flags & MSG_OOB != 0 {
return err(WSAEOPNOTSUPP);
}
let inet6 = self.rec(fd)?.state().inet6;
let dest = match unsafe { family_addr(inet6, addr, addr_len) } {
Ok(dest) => dest,
Err(code) => return err(code),
};
let data = unsafe { std::slice::from_raw_parts(buf, len) }.to_vec();
self.udp_send(fd, data, dest, &[])
}
unsafe fn recv(&self, fd: c_int, buf: *mut u8, len: usize, flags: c_int) -> Option<NetResult> {
let r = unsafe {
self.receive(
fd,
buf,
len,
flags,
RecvCall::Plain,
(std::ptr::null_mut(), std::ptr::null_mut()),
)
}?;
done(r)
}
unsafe fn recvfrom(
&self,
fd: c_int,
buf: *mut u8,
len: usize,
flags: c_int,
addr: *mut u8,
addr_len: *mut u32,
) -> Option<NetResult> {
let r = unsafe { self.receive(fd, buf, len, flags, RecvCall::Plain, (addr, addr_len)) }?;
done(r)
}
unsafe fn shutdown(&self, fd: c_int, how: c_int) -> Option<NetResult> {
let socks = self.socks.lock().unwrap();
let sock = socks.get(&fd)?;
if ![SD_RECEIVE, SD_SEND, SD_BOTH].contains(&how) {
return err(WSAEINVAL);
}
match sock {
Sock::Stream { conn, end, .. } => {
let (conn, end) = (conn.clone(), *end);
drop(socks);
if how != SD_RECEIVE {
conn.close(end);
}
if how != SD_SEND {
conn.read_pipe(end).shut_read();
}
ok(0)
}
Sock::Dgram { peer: Some(_), .. } => ok(0),
_ => err(WSAENOTCONN),
}
}
unsafe fn close(&self, fd: c_int) -> Option<NetResult> {
let would_linger = match self.socks.lock().unwrap().get(&fd)? {
Sock::Stream {
conn,
end,
rec,
nonblocking: true,
} => {
rec.opts().linger.is_some_and(|l| !l.is_zero())
&& !conn.write_pipe(*end).acknowledged()
}
_ => false,
};
if would_linger {
return err(WSAEWOULDBLOCK);
}
let sock = self.socks.lock().unwrap().remove(&fd)?;
let key = sock.rec().wake_key();
match sock {
Sock::Stream { conn, end, rec, .. } => {
let shared = self.socks.lock().unwrap().values().any(
|o| matches!(o, Sock::Stream { conn: c, end: e, .. } if Arc::ptr_eq(c, &conn) && *e == end),
);
if !shared {
match rec.opts().linger {
Some(linger) if linger.is_zero() => conn.reset(end),
Some(linger) => {
conn.close(end);
let pipe = conn.write_pipe(end);
readiness().wait_until(
"linger",
Some(Deadline::timeout(linger)),
|| pipe.acknowledged(),
);
}
None => conn.close(end),
}
}
}
Sock::Listener { state, .. } => {
let shared = self.socks.lock().unwrap().values().any(
|o| matches!(o, Sock::Listener { state: s, .. } if Arc::ptr_eq(s, &state)),
);
if !shared {
self.regs.lock().unlisten(&state);
let orphans: Vec<_> = state.pending.lock().unwrap().drain(..).collect();
for conn in orphans {
conn.reset(End::B);
}
}
}
Sock::Dgram { queue, .. } => {
let shared =
self.socks.lock().unwrap().values().any(
|o| matches!(o, Sock::Dgram { queue: q, .. } if Arc::ptr_eq(q, &queue)),
);
if !shared {
self.regs.lock().unbind_udp(&queue);
}
}
Sock::Fresh { .. } | Sock::Connecting { .. } => {}
}
self.regs.shared.socket_closed(fd);
self.regs.shared.bump_keys(&[key]);
ok(0)
}
unsafe fn getsockname(
&self,
fd: c_int,
addr: *mut u8,
addr_len: *mut u32,
) -> Option<NetResult> {
let socks = self.socks.lock().unwrap();
let sock = socks.get(&fd)?;
let local = match sock {
Sock::Stream { conn, end, .. } => Some(conn.local(*end)),
Sock::Listener { addr, .. } => Some(*addr),
Sock::Dgram { local, .. } | Sock::Fresh { local, .. } => *local,
Sock::Connecting { local, attempt, .. } => {
local.or_else(|| Some(attempt.lock().unwrap().client))
}
};
let Some(local) = local else {
return err(WSAEINVAL);
};
let inet6 = sock.rec().state().inet6;
drop(socks);
unsafe { write_addr(reported(inet6, local), addr, addr_len) };
ok(0)
}
unsafe fn getpeername(
&self,
fd: c_int,
addr: *mut u8,
addr_len: *mut u32,
) -> Option<NetResult> {
let socks = self.socks.lock().unwrap();
let sock = socks.get(&fd)?;
let peer = match sock {
Sock::Stream { conn, end, .. } => conn.peer(*end),
Sock::Dgram { peer: Some(p), .. } => *p,
_ => return err(WSAENOTCONN),
};
let inet6 = sock.rec().state().inet6;
drop(socks);
unsafe { write_addr(reported(inet6, peer), addr, addr_len) };
ok(0)
}
unsafe fn setsockopt(
&self,
fd: c_int,
level: c_int,
name: c_int,
val: *const u8,
len: u32,
) -> Option<NetResult> {
let rec = self.rec(fd)?;
let kind = self.kind(fd)?;
if (level, name) == (IPPROTO_IPV6, IPV6_V6ONLY) {
return done(unsafe { self.set_v6only(fd, &rec, kind, val, len) }.map(|()| 0));
}
if let Err(code) = win_sockopt::level_applies(kind, level, name) {
return err(code);
}
if level == SOL_SOCKET
&& matches!(
name,
win_sockopt::SO_PROTOCOL_INFOA | win_sockopt::SO_PROTOCOL_INFOW
)
{
return err(if name == win_sockopt::SO_PROTOCOL_INFOW && !kind.stream {
WSAEINVAL
} else {
WSAENOPROTOOPT
});
}
if level == IPPROTO_IP
&& kind.v6
&& let Err(code) = win_sockopt::ip_on_v6(&rec, name)
{
return err(code);
}
if level == IPPROTO_TCP
&& let Some(result) = unsafe { crate::faults::sockopt::set(&rec, name, val, len) }
{
return done(result.map(|()| 0));
}
if let Some(result) = unsafe { win_sockopt::set_anc(&rec, level, name, val, len) } {
return done(result.map(|()| 0));
}
if let Some(result) = unsafe { self.interface_opt(&rec, level, name, val, len) } {
return done(result.map(|()| 0));
}
if let Some(result) = unsafe { win_sockopt::set_frag(&rec, level, name, val, len) } {
return done(result.map(|()| 0));
}
if level == SOL_SOCKET && name == SO_BROADCAST {
let on = unsafe { read_int(val, len) } != 0;
if let Some(Sock::Dgram { broadcast, .. }) = self.socks.lock().unwrap().get_mut(&fd) {
*broadcast = on;
}
return ok(0);
}
if level == SOL_SOCKET && (name == SO_RCVBUF || name == SO_SNDBUF) {
if val.is_null() || (len as usize) < size_of::<c_int>() {
return err(WSAEFAULT);
}
let v = unsafe { read_int(val, len) };
let which = if name == SO_RCVBUF {
Buf::Rcv
} else {
Buf::Snd
};
let limits = self.regs.shared.sys.limits();
let stored = match crate::limits::sockbuf_value(&limits, which, v, 0, false) {
Ok(stored) => stored,
Err(code) => return err(code),
};
rec.state().buf.set(which, stored);
crate::notices::notice(self.regs.shared.domain_key(), rec.wake_key());
return ok(0);
}
if level == SOL_SOCKET && (name == SO_REUSEADDR || name == SO_EXCLUSIVEADDRUSE) {
let on = unsafe { read_int(val, len) } != 0;
let mut state = rec.state();
let opts = &mut state.opts;
let (this, other) = if name == SO_REUSEADDR {
(&mut opts.reuseaddr, opts.exclusive)
} else {
(&mut opts.exclusive, opts.reuseaddr)
};
if on && other {
return err(WSAEINVAL);
}
*this = on;
return ok(0);
}
if level == SOL_SOCKET
&& matches!(name, SO_RCVTIMEO | SO_SNDTIMEO | SO_LINGER | SO_DONTLINGER)
{
let millis = || {
let ms = unsafe { read_int(val, len) } as u32;
(ms != 0).then(|| Duration::from_millis(ms.into()))
};
let mut state = rec.state();
match name {
SO_RCVTIMEO => state.opts.rcvtimeo = millis(),
SO_SNDTIMEO => state.opts.sndtimeo = millis(),
SO_LINGER => state.opts.linger = unsafe { parse_linger(val, len) },
_ if unsafe { read_int(val, len) } != 0 => state.opts.linger = None,
_ => {}
}
return ok(0);
}
if (level == IPPROTO_IP && name == IP_ADD_MEMBERSHIP)
|| (level == IPPROTO_IPV6 && name == IPV6_ADD_MEMBERSHIP)
{
let Some(membership) = (unsafe { parse_add_membership(level, name, val, len) }) else {
return err(WSAEFAULT);
};
self.join_group(fd, membership);
return ok(0);
}
let set = unsafe { win_sockopt::set(&self.regs.shared, &rec, kind, level, name, val, len) };
done(set.map(|()| 0))
}
unsafe fn getsockopt(
&self,
fd: c_int,
level: c_int,
name: c_int,
val: *mut u8,
len: *mut u32,
) -> Option<NetResult> {
if level == SOL_SOCKET && name == SO_ERROR {
self.advance_connect(fd);
}
let rec = self.rec(fd)?;
let kind = self.kind(fd)?;
if (level, name) == (IPPROTO_IPV6, IPV6_V6ONLY) {
let size = if kind.stream { 4 } else { 1 };
if val.is_null() || len.is_null() || (unsafe { *len } as usize) < size {
return err(WSAEFAULT);
}
let value = c_int::from(rec.state().v6only).to_ne_bytes();
unsafe {
std::ptr::copy_nonoverlapping(value.as_ptr(), val, size);
*len = size as u32;
}
return ok(0);
}
if let Err(code) = win_sockopt::level_applies(kind, level, name) {
return err(code);
}
if level == SOL_SOCKET
&& matches!(
name,
win_sockopt::SO_PROTOCOL_INFOA | win_sockopt::SO_PROTOCOL_INFOW
)
{
return done(
unsafe { win_sockopt::get_protocol_info(kind, name, val, len) }.map(|()| 0),
);
}
if level == IPPROTO_TCP
&& let Some(value) = crate::faults::sockopt::get(&self.regs.shared, &rec, name)
{
unsafe { write_opt(value, val, len) };
return ok(0);
}
if let Some(value) = win_sockopt::get_anc(&rec, level, name) {
if val.is_null() || len.is_null() || unsafe { *len } < 4 {
return err(WSAEFAULT);
}
unsafe { write_opt(value as i32, val, len) };
return ok(0);
}
let millis = |d: Option<Duration>| {
d.map_or(0, |d| d.as_millis().min(u32::MAX as u128) as u32 as i32)
};
let index = |nic: &Option<(u32, String)>| nic.as_ref().map_or(0, |d| d.0);
let value: Option<i32> = match (level, name) {
(IPPROTO_IP, IP_UNICAST_IF) => Some(index(&rec.state().device).to_be() as i32),
(IPPROTO_IPV6, IPV6_UNICAST_IF) => Some(index(&rec.state().device) as i32),
(IPPROTO_IP, IP_MULTICAST_IF) | (IPPROTO_IPV6, IPV6_MULTICAST_IF) => {
Some(index(&rec.state().mcast_if) as i32)
}
(SOL_SOCKET, SO_RCVTIMEO) => Some(millis(rec.opts().rcvtimeo)),
(SOL_SOCKET, SO_SNDTIMEO) => Some(millis(rec.opts().sndtimeo)),
(SOL_SOCKET, SO_ERROR) => Some(
rec.take_error_as(&self.regs.shared, Taker::SoError)
.unwrap_or(0),
),
(SOL_SOCKET, SO_LINGER) => {
let linger = rec.opts().linger;
let secs = linger.map_or(0, |d| d.as_secs().min(u16::MAX.into()) as u16);
if !val.is_null() && !len.is_null() && unsafe { *len } >= 4 {
unsafe {
val.cast::<u16>().write_unaligned(linger.is_some() as u16);
val.add(2).cast::<u16>().write_unaligned(secs);
*len = 4;
}
}
return ok(0);
}
(SOL_SOCKET, SO_DONTLINGER) => Some(rec.opts().linger.is_none() as i32),
(SOL_SOCKET, SO_REUSEADDR) => Some(rec.opts().reuseaddr as i32),
(SOL_SOCKET, SO_EXCLUSIVEADDRUSE) => Some(rec.opts().exclusive as i32),
(SOL_SOCKET, SO_RCVBUF) => Some(rec.state().buf.rcvbuf),
(SOL_SOCKET, SO_SNDBUF) => Some(rec.state().buf.sndbuf),
(SOL_SOCKET, SO_TYPE) => Some(if kind.stream { SOCK_STREAM } else { SOCK_DGRAM }),
(SOL_SOCKET, SO_BROADCAST) => Some(matches!(
self.socks.lock().unwrap().get(&fd),
Some(Sock::Dgram {
broadcast: true,
..
})
) as i32),
(SOL_SOCKET, SO_ACCEPTCONN) => Some(matches!(
self.socks.lock().unwrap().get(&fd),
Some(Sock::Listener { .. })
) as i32),
_ => win_sockopt::get_frag(&rec, level, name),
};
if let Some(value) = value {
unsafe { write_opt(value, val, len) };
return ok(0);
}
match win_sockopt::get(&self.regs.shared, &rec, kind, level, name) {
Ok(bytes) => {
unsafe { write_bytes(&bytes, val, len) };
ok(0)
}
Err(code) => err(code),
}
}
unsafe fn ioctl(&self, fd: c_int, request: u64, arg: i64) -> Option<NetResult> {
let rec = self.rec(fd)?;
let argp = arg as *mut u32;
let command = request as u32;
if ![FIONBIO as u32, FIONREAD, SIOCATMARK].contains(&command) {
return err(WSAEOPNOTSUPP);
}
if argp.is_null() {
return err(WSAEFAULT);
}
match command {
c if c == FIONBIO as u32 => {
self.set_nonblocking(fd, unsafe { argp.read_unaligned() } != 0);
}
FIONREAD => unsafe { argp.write_unaligned(rec.fionread() as u32) },
_ => unsafe { argp.write_unaligned(1) },
}
ok(0)
}
unsafe fn wsa_ioctl(
&self,
fd: c_int,
code: u32,
input: *const u8,
input_len: u32,
output: *mut u8,
output_len: u32,
returned: *mut u32,
) -> Option<NetResult> {
let rec = self.rec(fd)?;
let kind = self.kind(fd)?;
let set_returned = |n: u32| {
if !returned.is_null() {
unsafe { returned.write_unaligned(n) };
}
};
let input_dword = || {
(!input.is_null() && (input_len as usize) >= size_of::<u32>())
.then(|| unsafe { input.cast::<u32>().read_unaligned() })
};
let output_dword = |value: u32| {
if output.is_null() || (output_len as usize) < size_of::<u32>() {
return err(WSAEFAULT);
}
unsafe { output.cast::<u32>().write_unaligned(value) };
set_returned(size_of::<u32>() as u32);
ok(0)
};
match code {
c if c == FIONBIO as u32 => {
let Some(on) = input_dword() else {
return err(WSAEFAULT);
};
self.set_nonblocking(fd, on != 0);
set_returned(0);
ok(0)
}
FIONREAD => output_dword(rec.fionread() as u32),
SIOCATMARK => output_dword(1),
SIO_UDP_CONNRESET | SIO_UDP_NETRESET => {
if kind.stream {
return err(WSAEINVAL);
}
let Some(on) = input_dword() else {
return err(WSAEFAULT);
};
if code == SIO_UDP_CONNRESET {
rec.state().dgram.connreset = on != 0;
}
set_returned(0);
ok(0)
}
SIO_BASE_HANDLE | SIO_BSP_HANDLE | SIO_BSP_HANDLE_SELECT | SIO_BSP_HANDLE_POLL => {
if output.is_null() || (output_len as usize) < size_of::<usize>() {
return err(WSAEFAULT);
}
unsafe { output.cast::<usize>().write_unaligned(fd as usize) };
set_returned(size_of::<usize>() as u32);
ok(0)
}
SIO_KEEPALIVE_VALS => {
if !kind.stream {
return err(WSAENOPROTOOPT);
}
if input.is_null() || (input_len as usize) < 3 * size_of::<u32>() {
return err(WSAEFAULT);
}
let on = unsafe { input.cast::<u32>().read_unaligned() } != 0;
rec.keep_ignored(
win_sockopt::SOL_SOCKET,
win_sockopt::SO_KEEPALIVE,
&c_int::from(on).to_ne_bytes(),
);
set_returned(0);
ok(0)
}
SIO_LOOPBACK_FAST_PATH => {
if !kind.stream {
return err(WSAEOPNOTSUPP);
}
if input_dword().is_none() {
return err(WSAEFAULT);
}
set_returned(0);
ok(0)
}
SIO_CPU_AFFINITY => {
if kind.stream {
return err(WSAEOPNOTSUPP);
}
if input.is_null() || (input_len as usize) < size_of::<u16>() {
return err(WSAEFAULT);
}
let mut state = rec.state();
if state.local.is_some() {
return err(WSAEINVAL);
}
state.dgram.cpu_affinity = Some(unsafe { input.cast::<u16>().read_unaligned() });
set_returned(0);
ok(0)
}
SIO_TIMESTAMPING => {
if kind.stream {
return err(WSAEINVAL);
}
let configured = unsafe { win_sockopt::configure_stamping(&rec, input, input_len) };
set_returned(0);
done(configured.map(|()| 0))
}
SIO_GET_TX_TIMESTAMP => {
if kind.stream {
return err(WSAEOPNOTSUPP);
}
done(
unsafe {
win_sockopt::take_tx_stamp(
&rec, input, input_len, output, output_len, returned,
)
}
.map(|()| 0),
)
}
_ => {
self.regs.shared.unservable_option(
&rec,
UnmodelledOption::Ioctl {
request: code.into(),
},
);
err(WSAEOPNOTSUPP)
}
}
}
unsafe fn wsa_recv(&self, fd: c_int, msg: *mut u8, extension: bool) -> Option<NetResult> {
let (nonblocking, rec, dgram) = self.recv_state(fd)?;
let msg = unsafe { &mut *msg.cast::<WsaMsg>() };
if extension && !msg.Control.buf.is_null() && msg.Control.len == 0 {
return err(WSAEFAULT);
}
if extension && !dgram {
return err(WSAEINVAL);
}
let call = if extension {
RecvCall::Msg
} else {
RecvCall::Wsa
};
let flags = msg.dwFlags as c_int;
if let Err(code) = self.recv_flags(&rec, call, !dgram, nonblocking, flags) {
return err(code);
}
let buffers = match unsafe { wsa_buffers(msg) } {
Ok(buffers) => buffers,
Err(code) => return err(code),
};
if msg.Control.buf.is_null() && msg.Control.len != 0 {
return err(WSAEFAULT);
}
let total = buffers
.iter()
.fold(0usize, |n, b| n.saturating_add(b.len as usize));
if !dgram {
let mut data = vec![0u8; total];
let (copied, reported) = self.stream_take(fd, &mut data, flags)?;
unsafe { scatter(buffers, &data[..copied]) };
let reported = match reported {
Ok(reported) => reported,
Err(code) => return err(code),
};
msg.Control.len = 0;
msg.dwFlags = 0;
return ok(reported as i64);
}
let need = if self.kind(fd).is_some_and(|k| k.v6) {
28
} else {
16
};
if (msg.name.is_null() && msg.namelen != 0)
|| (!msg.name.is_null() && (msg.namelen.max(0) as usize) < need)
{
return err(WSAEFAULT);
}
let dg = match self.dgram_take(fd, flags)? {
Ok(dg) => dg,
Err(code) => return err(code),
};
let n = unsafe { scatter(buffers, &dg.data) };
let truncated = dg.data.len() > total;
if !msg.name.is_null() {
let mut len = msg.namelen as u32;
let src = reported(rec.state().inet6, dg.src);
unsafe { write_addr(src, msg.name.cast(), &mut len) };
msg.namelen = len as i32;
}
let mut cut = 0;
if extension {
cut = unsafe { write_cmsgs(msg, &win_sockopt::rx_cmsgs(&rec, &dg.ip, dg.at)) };
msg.dwFlags = self.msg_flags(&dg, truncated) | cut;
} else {
msg.Control.len = 0;
msg.dwFlags = 0;
}
if truncated || cut != 0 {
return err(WSAEMSGSIZE);
}
ok(n as i64)
}
unsafe fn wsa_send(
&self,
fd: c_int,
msg: *const u8,
flags: u32,
extension: bool,
) -> Option<NetResult> {
let (_, rec, dgram) = self.recv_state(fd)?;
let msg = unsafe { &*msg.cast::<WsaMsg>() };
if extension && !dgram {
return err(WSAEINVAL);
}
if flags as c_int & (MSG_OOB | MSG_PARTIAL) != 0 {
return err(WSAEOPNOTSUPP);
}
let buffers = match unsafe { wsa_buffers(msg) } {
Ok(buffers) => buffers,
Err(code) => return err(code),
};
if (msg.name.is_null() && msg.namelen != 0)
|| (msg.Control.buf.is_null() && msg.Control.len != 0)
{
return err(WSAEFAULT);
}
let data = unsafe { gather(buffers) };
let msgs = if extension {
match unsafe { read_cmsgs(msg) } {
Ok(msgs) => msgs,
Err(code) => return err(code),
}
} else {
Vec::new()
};
let flags = flags as c_int & !MSG_DONTROUTE;
if !dgram {
return unsafe { self.send(fd, data.as_ptr(), data.len(), flags) };
}
let dest = if msg.name.is_null() {
match self.socks.lock().unwrap().get(&fd)? {
Sock::Dgram {
peer: Some(peer), ..
} => *peer,
_ => return err(WSAEDESTADDRREQ),
}
} else {
let inet6 = rec.state().inet6;
let name = msg.name.cast();
match unsafe { family_addr(inet6, name, msg.namelen.max(0) as u32) } {
Ok(dest) => dest,
Err(code) => return err(code),
}
};
self.udp_send(fd, data, dest, &msgs)
}
unsafe fn dup(&self, fd: c_int) -> Option<NetResult> {
let mut socks = self.socks.lock().unwrap();
let clone = match socks.get(&fd)? {
Sock::Fresh {
nonblocking,
local,
rec,
} => Sock::Fresh {
nonblocking: *nonblocking,
local: *local,
rec: rec.clone(),
},
Sock::Connecting {
nonblocking,
local,
rec,
dest,
attempt,
} => Sock::Connecting {
nonblocking: *nonblocking,
local: *local,
rec: rec.clone(),
dest: *dest,
attempt: attempt.clone(),
},
Sock::Stream {
conn,
end,
nonblocking,
rec,
} => Sock::Stream {
conn: conn.clone(),
end: *end,
nonblocking: *nonblocking,
rec: rec.clone(),
},
Sock::Listener {
state,
addr,
nonblocking,
rec,
} => Sock::Listener {
state: state.clone(),
addr: *addr,
nonblocking: *nonblocking,
rec: rec.clone(),
},
Sock::Dgram {
queue,
domain,
local,
requested,
peer,
nonblocking,
broadcast,
rec,
} => Sock::Dgram {
queue: queue.clone(),
domain: *domain,
local: *local,
requested: *requested,
peer: *peer,
nonblocking: *nonblocking,
broadcast: *broadcast,
rec: rec.clone(),
},
};
let new_fd = self.mint();
self.regs.shared.sockets.alias(new_fd, clone.rec());
socks.insert(new_fd, clone);
ok(new_fd as i64)
}
unsafe fn select(
&self,
_nfds: c_int,
read: *mut u8,
write: *mut u8,
except: *mut u8,
timeout: *const u8,
) -> Option<NetResult> {
let ptrs = [read, write, except];
let sets = ptrs.map(|p| (!p.is_null()).then(|| unsafe { read_fd_set(p) }));
let listed: Vec<c_int> = sets.iter().flatten().flatten().copied().collect();
let owned = {
let socks = self.socks.lock().unwrap();
listed.iter().filter(|fd| socks.contains_key(fd)).count()
};
if owned == 0 {
return None;
}
if owned < listed.len() {
return err(WSAEOPNOTSUPP);
}
let deadline = (!timeout.is_null()).then(|| {
let tv = unsafe { timeout.cast::<Timeval>().read_unaligned() };
Deadline::timeout(
Duration::from_secs(tv.tv_sec.max(0) as u64)
+ Duration::from_micros(tv.tv_usec.max(0) as u64),
)
});
let mut waited = false;
let mut last = deadline.is_some_and(|d| d.passed());
loop {
self.advance_connecting(Some(&listed));
let found = self.select_ready(&sets);
let total: usize = found.iter().map(Vec::len).sum();
if total > 0 || last {
for (p, ready) in ptrs.into_iter().zip(&found) {
if !p.is_null() {
unsafe { write_fd_set(p, ready) };
}
}
if !waited {
snare_interpose::charge_latency();
}
return ok(total as i64);
}
last = !readiness().wait_until_dynamic(
"select",
deadline,
|keys| self.fd_interests(listed.iter().copied(), keys),
|| {
self.select_ready(&sets)
.iter()
.any(|ready| !ready.is_empty())
|| self.connecting_due(Some(&listed))
},
);
waited = true;
}
}
unsafe fn poll(&self, fds: *mut u8, nfds: u64, timeout: c_int) -> Option<NetResult> {
if fds.is_null() || nfds == 0 {
return None;
}
let pfds =
unsafe { std::slice::from_raw_parts_mut(fds.cast::<WsaPollfd>(), nfds as usize) };
let owned = {
let socks = self.socks.lock().unwrap();
pfds.iter()
.filter(|p| c_int::try_from(p.fd).is_ok_and(|fd| socks.contains_key(&fd)))
.count()
};
if owned == 0 {
return None;
}
if owned < pfds.len() {
return err(WSAEOPNOTSUPP);
}
let deadline = (timeout >= 0)
.then(|| Deadline::timeout(std::time::Duration::from_millis(timeout as u64)));
let collect = |pfds: &mut [WsaPollfd]| -> i64 {
let mut n = 0;
for p in pfds.iter_mut() {
p.revents = self.poll_revents(p.fd as c_int, p.events);
if p.revents != 0 {
n += 1;
}
}
n
};
let fds: Vec<c_int> = pfds.iter().map(|p| p.fd as c_int).collect();
let mut waited = false;
loop {
self.advance_connecting(Some(&fds));
let n = collect(pfds);
if n > 0 {
if !waited {
snare_interpose::charge_latency();
}
return ok(n);
}
if timeout == 0 {
snare_interpose::charge_latency();
return ok(0);
}
let woke = readiness().wait_until_dynamic(
"WSAPoll",
deadline,
|keys| self.fd_interests(fds.iter().copied(), keys),
|| {
pfds.iter()
.any(|p| self.poll_revents(p.fd as c_int, p.events) != 0)
|| self.connecting_due(Some(&fds))
},
);
if !woke {
self.advance_connecting(Some(&fds));
return ok(collect(pfds));
}
waited = true;
}
}
unsafe fn pcap_open(&self, device: *const c_char) -> Option<NetResult> {
let dev = if device.is_null() {
Vec::new()
} else {
unsafe { std::ffi::CStr::from_ptr(device) }
.to_bytes()
.to_vec()
};
let handle = self.next_pcap.fetch_add(1, Ordering::Relaxed);
self.pcaps.lock().unwrap().insert(
handle,
PcapHandle {
device: dev,
rx: VecDeque::new(),
last_frame: Vec::new(),
last_hdr: vec![0u8; 16],
},
);
ok(handle as i64)
}
fn pcap_configure(&self, handle: u64) -> Option<NetResult> {
if self.pcaps.lock().unwrap().contains_key(&handle) {
ok(0)
} else {
None
}
}
unsafe fn pcap_send(&self, handle: u64, buf: *const u8, len: usize) -> Option<NetResult> {
let frame = unsafe { std::slice::from_raw_parts(buf, len) }.to_vec();
let dev = self
.pcaps
.lock()
.unwrap()
.get(&handle)
.map(|h| h.device.clone())?;
let name = String::from_utf8_lossy(&dev).into_owned();
let index = self.regs.shared.topo().index_of(&name);
let sent = index.map(|index| self.regs.shared.raw_send(index, len));
if !matches!(sent, Some(Err(_))) {
self.regs.shared.capture_l2_named(&name, &frame);
}
match sent {
Some(Err(code)) => return err(code),
Some(Ok(false)) => return ok(len as i64),
_ => {}
}
let mut pcaps = self.pcaps.lock().unwrap();
for h in pcaps.values_mut() {
if h.device == dev {
h.rx.push_back(frame.clone());
}
}
drop(pcaps);
self.regs.shared.bump_keys(&[]);
ok(len as i64)
}
unsafe fn pcap_next(
&self,
handle: u64,
header: *mut *mut u8,
data: *mut *const u8,
) -> Option<NetResult> {
let mut pcaps = self.pcaps.lock().unwrap();
let h = pcaps.get_mut(&handle)?;
let Some(frame) = h.rx.pop_front() else {
return ok(0);
};
let fl = frame.len() as u32;
h.last_hdr = vec![0u8; 16];
h.last_hdr[8..12].copy_from_slice(&fl.to_ne_bytes());
h.last_hdr[12..16].copy_from_slice(&fl.to_ne_bytes());
h.last_frame = frame;
unsafe {
*header = h.last_hdr.as_mut_ptr();
*data = h.last_frame.as_ptr();
}
ok(1)
}
fn pcap_close(&self, handle: u64) -> Option<NetResult> {
if self.pcaps.lock().unwrap().remove(&handle).is_some() {
ok(0)
} else {
None
}
}
}
unsafe fn read_int(val: *const u8, len: u32) -> c_int {
if val.is_null() || (len as usize) < size_of::<c_int>() {
return 0;
}
unsafe { val.cast::<c_int>().read_unaligned() }
}
unsafe fn parse_add_membership(
level: c_int,
name: c_int,
val: *const u8,
len: u32,
) -> Option<Membership> {
if val.is_null() {
return None;
}
let bytes = unsafe { std::slice::from_raw_parts(val, len as usize) };
if level == IPPROTO_IP && name == IP_ADD_MEMBERSHIP && bytes.len() >= 4 {
let group = Ipv4Addr::new(bytes[0], bytes[1], bytes[2], bytes[3]);
let interface = bytes
.get(4..8)
.map(|b| Ipv4Addr::new(b[0], b[1], b[2], b[3]))
.filter(|a| !a.is_unspecified());
return Some(Membership {
group: IpAddr::V4(group),
interface_addr: interface.map(IpAddr::V4),
ifindex: 0,
});
}
if level == IPPROTO_IPV6 && name == IPV6_ADD_MEMBERSHIP && bytes.len() >= 16 {
let mut o = [0u8; 16];
o.copy_from_slice(&bytes[..16]);
let ifindex = bytes
.get(16..20)
.map_or(0, |b| u32::from_ne_bytes([b[0], b[1], b[2], b[3]]));
return Some(Membership {
group: IpAddr::V6(Ipv6Addr::from(o)),
interface_addr: None,
ifindex,
});
}
None
}
unsafe fn parse_linger(val: *const u8, len: u32) -> Option<Duration> {
if val.is_null() || len < 4 {
return None;
}
let onoff = unsafe { val.cast::<u16>().read_unaligned() };
let secs = unsafe { val.add(2).cast::<u16>().read_unaligned() };
(onoff != 0).then(|| Duration::from_secs(secs.into()))
}
unsafe fn family_addr(inet6: bool, ptr: *const u8, len: u32) -> Result<SocketAddr, c_int> {
let addr = unsafe { parse_addr(ptr, len) }.ok_or(WSAEFAULT)?;
match (inet6, addr.is_ipv6()) {
(true, true) => Ok(unmapped(addr)),
(false, false) => Ok(addr),
(true, false) => Err(WSAEFAULT),
(false, true) => Err(WSAEAFNOSUPPORT),
}
}
fn crossing(rec: &SockRec, bound: Option<SocketAddr>, dest: SocketAddr) -> Result<(), c_int> {
let refused = if dest.is_ipv4() {
rec.state().v6only || bound.is_some_and(|b| b.is_ipv6() && !b.ip().is_unspecified())
} else {
bound.is_some_and(|b| b.is_ipv4())
};
if refused {
Err(code::EADDRNOTAVAIL)
} else {
Ok(())
}
}
unsafe fn parse_addr(ptr: *const u8, len: u32) -> Option<SocketAddr> {
if ptr.is_null() || (len as usize) < 4 {
return None;
}
let family = unsafe { ptr.cast::<u16>().read_unaligned() } as c_int;
match family {
AF_INET => {
if (len as usize) < 8 {
return None;
}
let port = u16::from_be(unsafe { ptr.add(2).cast::<u16>().read_unaligned() });
let mut o = [0u8; 4];
unsafe { std::ptr::copy_nonoverlapping(ptr.add(4), o.as_mut_ptr(), 4) };
Some(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::from(o), port)))
}
AF_INET6 => {
if (len as usize) < 28 {
return None;
}
let port = u16::from_be(unsafe { ptr.add(2).cast::<u16>().read_unaligned() });
let mut o = [0u8; 16];
unsafe { std::ptr::copy_nonoverlapping(ptr.add(8), o.as_mut_ptr(), 16) };
Some(SocketAddr::V6(SocketAddrV6::new(
Ipv6Addr::from(o),
port,
0,
0,
)))
}
_ => None,
}
}
unsafe fn write_addr(addr: SocketAddr, out: *mut u8, out_len: *mut u32) {
if out.is_null() || out_len.is_null() {
return;
}
let cap = unsafe { *out_len } as usize;
match addr {
SocketAddr::V4(v4) => {
let mut buf = [0u8; 16];
buf[0..2].copy_from_slice(&(AF_INET as u16).to_ne_bytes());
buf[2..4].copy_from_slice(&v4.port().to_be_bytes());
buf[4..8].copy_from_slice(&v4.ip().octets());
let n = cap.min(16);
unsafe { std::ptr::copy_nonoverlapping(buf.as_ptr(), out, n) };
unsafe { *out_len = 16 };
}
SocketAddr::V6(v6) => {
let mut buf = [0u8; 28];
buf[0..2].copy_from_slice(&(AF_INET6 as u16).to_ne_bytes());
buf[2..4].copy_from_slice(&v6.port().to_be_bytes());
buf[8..24].copy_from_slice(&v6.ip().octets());
let n = cap.min(28);
unsafe { std::ptr::copy_nonoverlapping(buf.as_ptr(), out, n) };
unsafe { *out_len = 28 };
}
}
}
unsafe fn write_opt(value: i32, val: *mut u8, len: *mut u32) {
if val.is_null() || len.is_null() {
return;
}
let cap = unsafe { *len } as usize;
let n = size_of::<i32>().min(cap);
unsafe {
std::ptr::copy_nonoverlapping(value.to_ne_bytes().as_ptr(), val, n);
*len = size_of::<i32>() as u32;
}
}
unsafe fn write_bytes(bytes: &[u8], val: *mut u8, len: *mut u32) {
if let Ok(dword) = <[u8; 4]>::try_from(bytes) {
return unsafe { write_opt(i32::from_ne_bytes(dword), val, len) };
}
if len.is_null() {
return;
}
let n = bytes.len().min(unsafe { *len } as usize);
if !val.is_null() {
unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), val, n) };
}
unsafe { *len = n as u32 };
}
pub(crate) struct Registries {
reg: Mutex<Registry>,
pub(crate) shared: Arc<SimShared>,
}
impl Registries {
fn lock(&self) -> std::sync::MutexGuard<'_, Registry> {
self.reg.lock().unwrap()
}
fn deliver(
&self,
sender: &Sender,
src: SocketAddr,
dest: SocketAddr,
data: &[u8],
ip: Header,
) -> usize {
let sent = monotonic(&self.shared);
let (cands, station) = {
let reg = self.lock();
(reg.candidates(dest), reg.station_at(dest.ip()))
};
let copies = self.shared.fan_out(
sender,
Wire {
src,
dest,
len: data.len(),
},
station,
cands,
true,
);
let reached = copies.len();
for copy in copies {
if let Some(rec) = ©.q.rec {
if copy.delays.is_empty() {
rec.count_wire_lost();
} else {
rec.note_rx_nic(copy.nic.as_deref());
}
}
let seg = usize::from(ip.gso);
let reads = match seg {
0 => vec![data.len()],
seg => win_sockopt::coalesce(
copy.q.rec.as_deref(),
seg,
data.len(),
win_sockopt::max_payload(dest),
),
};
let ip = Header {
ifindex: copy.ingress.unwrap_or(0),
..ip
};
for delay in copy.delays {
let mut at = 0;
for &len in &reads {
copy.q.push_after(
(src, dest),
sent,
data[at..at + len].to_vec(),
delay,
copy.via.clone(),
Header {
gso: if len > seg { ip.gso } else { 0 },
..ip
},
self.shared.domain_key(),
);
at += len;
}
}
}
reached
}
}
thread_local! {
static CURRENT: std::cell::RefCell<Option<Arc<Registries>>> = const { std::cell::RefCell::new(None) };
}
pub(crate) fn enter(regs: Arc<Registries>) -> RegistryGuard {
let previous = CURRENT.with(|c| c.replace(Some(regs)));
RegistryGuard { previous }
}
pub(crate) struct RegistryGuard {
previous: Option<Arc<Registries>>,
}
impl Drop for RegistryGuard {
fn drop(&mut self) {
CURRENT.with(|c| *c.borrow_mut() = self.previous.take());
}
}
pub(crate) fn registries_here() -> Arc<Registries> {
try_registries_here().expect("snare tester functions must be called inside Sim::run")
}
pub(crate) fn try_registries_here() -> Option<Arc<Registries>> {
CURRENT.with(|c| c.borrow().clone())
}
pub(crate) struct ScopeLayer(pub(crate) Arc<Registries>);
impl snare_interpose::Layer for ScopeLayer {
fn thread_started(&self) {
std::mem::forget(enter(self.0.clone()));
}
}
pub(crate) fn listen_at(addr: SocketAddr) -> Arc<Listener> {
let listener = Arc::new(Listener {
tester: true,
capacity: AtomicUsize::new(usize::MAX),
..Listener::default()
});
let regs = registries_here();
snare_interpose::real(|| regs.lock().listen(addr, listener.clone()));
listener
}
pub(crate) fn unlisten(regs: &Registries, listener: &Arc<Listener>) {
snare_interpose::real(|| regs.lock().unlisten(listener));
}
impl ListenerState {
fn share(&self) -> Share {
self.rec
.as_ref()
.and_then(std::sync::Weak::upgrade)
.map(|rec| Share::of(&rec))
.unwrap_or_default()
}
fn reserve(self: &Arc<Self>) -> Option<ListenerAdmission> {
let mut used = self.occupied.load(Ordering::Acquire);
loop {
if used >= self.capacity.load(Ordering::Acquire) {
return None;
}
match self.occupied.compare_exchange_weak(
used,
used + 1,
Ordering::AcqRel,
Ordering::Acquire,
) {
Ok(_) => {
return Some(ListenerAdmission {
listener: self.clone(),
reserved: true,
});
}
Err(current) => used = current,
}
}
}
fn wake_key(&self) -> Option<crate::readiness::WakeKey> {
self.rec.as_ref()?.upgrade().map(|rec| rec.wake_key())
}
pub(crate) fn try_accept(&self) -> Option<Arc<Conn>> {
snare_interpose::real(|| {
let conn = self.pending.lock().unwrap().pop_front()?;
self.occupied.fetch_sub(1, Ordering::AcqRel);
Some(conn)
})
}
pub(crate) fn has_pending(&self) -> bool {
snare_interpose::real(|| !self.pending.lock().unwrap().is_empty())
}
}
struct ListenerAdmission {
listener: Arc<ListenerState>,
reserved: bool,
}
impl ListenerAdmission {
fn queue(mut self, conn: Arc<Conn>) {
self.listener.pending.lock().unwrap().push_back(conn);
self.reserved = false;
}
}
impl Drop for ListenerAdmission {
fn drop(&mut self) {
if self.reserved {
self.listener.occupied.fetch_sub(1, Ordering::AcqRel);
}
}
}
impl Conn {
pub(crate) fn write_from_peer(&self, bytes: &[u8]) -> usize {
snare_interpose::real(|| self.write(End::B, bytes).unwrap_or(0))
}
pub(crate) fn peer_can_write(&self, len: usize) -> bool {
snare_interpose::real(|| self.write_pipe(End::B).can_write(len))
}
pub(crate) fn read_from_peer(&self, out: &mut [u8]) -> std::io::Result<usize> {
snare_interpose::real(|| match self.read_pipe(End::B).read(out) {
Read::Data(n) => Ok(n),
Read::Eof => Ok(0),
Read::Reset => Err(std::io::ErrorKind::ConnectionReset.into()),
Read::WouldBlock | Read::Shut => Err(std::io::ErrorKind::WouldBlock.into()),
})
}
pub(crate) fn close_peer(&self) {
snare_interpose::real(|| self.close(End::B));
}
pub(crate) fn reset_peer(&self) {
snare_interpose::real(|| self.reset(End::B));
}
pub(crate) fn peer_readable(&self) -> bool {
snare_interpose::real(|| self.read_pipe(End::B).readable_or_closed())
}
}
pub(crate) struct UdpEndpoint {
regs: Arc<Registries>,
addr: SocketAddr,
queue: Arc<DgramQueue>,
}
impl UdpEndpoint {
pub(crate) fn bind(regs: Arc<Registries>, addr: SocketAddr) -> Self {
let queue = Arc::new(DgramQueue::default());
snare_interpose::real(|| {
let mut reg = regs.lock();
assert!(
!reg.udp.contains_key(&addr),
"udp tester address {addr} is already bound"
);
reg.bind_udp(addr, &queue);
});
UdpEndpoint { regs, addr, queue }
}
pub(crate) fn try_recv(&self) -> Option<(SocketAddr, Vec<u8>)> {
snare_interpose::real(|| self.queue.pop(|_| true).map(|dg| (dg.src, dg.data)))
}
pub(crate) fn has_pending(&self) -> bool {
snare_interpose::real(|| self.queue.has(|_| true))
}
pub(crate) fn send_to(&self, dest: SocketAddr, data: &[u8]) {
snare_interpose::real(|| {
let sender = Sender::Station(self.addr.ip());
self.regs
.shared
.capture_udp(&sender, self.addr, dest, Dir::In, data, None);
if self
.regs
.deliver(&sender, self.addr, dest, data, Header::plain(dest.ip()))
== 0
{
let station = self.regs.lock().station_at(dest.ip());
self.regs.shared.count_unreceived(dest, station);
}
});
}
}
impl Drop for UdpEndpoint {
fn drop(&mut self) {
snare_interpose::real(|| self.regs.lock().unbind_udp(&self.queue));
}
}