use std::collections::{HashMap, 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::faults::{ConnectAttempt, Outcome, Syn};
use crate::limits::{Arrival, Buf, RxQueue};
use crate::netif::{Cand, Hop, LinkState, Op, Sender, Wire};
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 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 SO_TIMESTAMP: c_int = 0x300A;
const SO_TIMESTAMP_ID: c_int = 0x300B;
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_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 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,
}
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)>,
}
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>>,
}
impl DgramQueue {
fn for_socket(rec: &Arc<SockRec>) -> Arc<Self> {
let queue = Arc::new(DgramQueue {
packets: Mutex::default(),
rec: Some(rec.clone()),
});
rec.set_probe(Arc::downgrade(&queue) as Weak<dyn RxProbe>);
queue
}
fn push_after(
&self,
(src, dest): (SocketAddr, SocketAddr),
sent: Duration,
data: Vec<u8>,
delay: std::time::Duration,
via: Option<(Arc<LinkState>, u64)>,
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,
};
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,
}
}
}
fn tcp_bind_conflict(
(held, held_reuse): (SocketAddr, bool),
want: SocketAddr,
reuse: bool,
) -> Option<c_int> {
match (held == want, reuse, held_reuse) {
(false, _, _) | (true, true, true) => None,
(true, false, _) => Some(WSAEADDRINUSE),
(true, true, false) => Some(WSAEACCES),
}
}
#[derive(Default)]
pub(crate) struct Registry {
udp: HashMap<SocketAddr, Arc<DgramQueue>>,
listeners: HashMap<SocketAddr, Arc<ListenerState>>,
}
impl Registry {
fn alloc_port(&self, ip: IpAddr) -> u16 {
let taken = |port: u16| {
self.udp.keys().any(|a| {
a.port() == port
&& a.is_ipv4() == ip.is_ipv4()
&& (a.ip() == ip || ip.is_unspecified())
})
};
(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)),
q: q.clone(),
};
let group = dest.ip();
self.udp
.iter()
.filter(|(addr, _)| addr.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.udp
.iter()
.any(|(addr, q)| addr.ip() == ip && q.rec.is_none())
|| self
.listeners
.iter()
.any(|(addr, l)| l.tester && addr.ip() == 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 = SocketAddr> + '_ {
socks.values().filter_map(|sock| match sock {
Sock::Dgram {
local: Some(local),
requested,
..
} => Some(requested.map_or(*local, |r| SocketAddr::new(r.ip(), local.port()))),
_ => 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: SocketAddr,
reuse: bool,
) -> Result<SocketAddr, c_int> {
let mut held: Vec<(SocketAddr, bool)> = socks
.values()
.filter_map(|sock| match sock {
Sock::Fresh {
local: Some(local),
rec,
..
}
| Sock::Connecting {
local: Some(local),
rec,
..
} => Some((*local, rec.opts().reuseaddr)),
Sock::Listener { addr, rec, .. } => Some((*addr, rec.opts().reuseaddr)),
_ => None,
})
.collect();
let testers: Vec<SocketAddr> = regs
.lock()
.listeners
.keys()
.filter(|&addr| !held.iter().any(|&(h, _)| h == *addr))
.copied()
.collect();
held.extend(testers.into_iter().map(|addr| (addr, false)));
let conflict = |addr: SocketAddr| held.iter().find_map(|&h| tcp_bind_conflict(h, addr, reuse));
if want.port() != 0 {
return conflict(want).map_or(Ok(want), Err);
}
let port = (0..=u16::MAX - crate::scope::EPHEMERAL_FIRST)
.map(|_| regs.shared.ephemeral_port())
.find(|&port| conflict(SocketAddr::new(want.ip(), port)).is_none())
.ok_or(WSAEADDRINUSE)?;
want.set_port(port);
Ok(want)
}
struct PcapHandle {
device: Vec<u8>,
rx: VecDeque<Vec<u8>>,
last_frame: Vec<u8>,
last_hdr: Vec<u8>,
}
pub(crate) struct WinNet {
socks: Mutex<HashMap<c_int, Sock>>,
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::new(HashMap::new()),
regs: Arc::new(Registries {
reg: Mutex::default(),
shared,
}),
next_handle: AtomicI32::new(0x2000),
pcaps: Mutex::new(HashMap::new()),
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) -> Option<NetResult> {
let (local, queue, domain, broadcast, nonblocking, rec) = {
let socks = self.socks.lock().unwrap();
match socks.get(&fd) {
Some(Sock::Dgram {
local,
queue,
domain,
broadcast,
nonblocking,
rec,
..
}) => (
*local,
queue.clone(),
*domain,
*broadcast,
*nonblocking,
rec.clone(),
),
_ => return None,
}
};
if let Some(code) = rec.take_error_as(&self.regs.shared, Taker::Send) {
return err(code);
}
let station = self.regs.lock().station_at(dest.ip());
let sender =
match self
.regs
.shared
.route_send(&rec.view(local), dest, Op::Send, station, broadcast)
{
Ok(sender) => sender,
Err(code) => return err(code),
};
if let Err(code) =
win_sockopt::check_send(&self.regs.shared, &rec, &sender, dest, data.len())
{
return err(code);
}
let local = match local {
Some(local) => local,
None => self.autobind(fd, &queue, &rec, unspecified_like(loopback_for(domain))),
};
let src = sender.source(local);
let stalled = || {
let policies = &self.regs.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);
}
}
self.regs
.shared
.capture_udp(&sender, src, dest, Dir::Out, &data, None);
if self.regs.deliver(&sender, src, dest, &data) == 0 {
self.regs
.shared
.unreachable_port(&rec, &sender, src, dest, &data, station);
}
rec.note_tx_nic(sender.egress_name());
rec.count_udp_sent(dest, &sender);
if rec.has_error_reports() {
self.regs.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 mut regs = self.regs.lock();
let sa = SocketAddr::new(ip, regs.alloc_port(ip));
regs.udp.insert(sa, queue.clone());
drop(regs);
if let Some(Sock::Dgram { local, .. }) = self.socks.lock().unwrap().get_mut(&fd) {
*local = Some(sa);
}
rec.set_local(sa);
sa
}
fn rehash(
&self,
queue: &Arc<DgramQueue>,
rec: &Arc<SockRec>,
from: SocketAddr,
to: SocketAddr,
) {
if from == to {
return;
}
let mut regs = self.regs.lock();
if regs.udp.contains_key(&to) {
return;
}
regs.udp.remove(&from);
regs.udp.insert(to, queue.clone());
drop(regs);
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) = {
let mut socks = self.socks.lock().unwrap();
let Some(Sock::Dgram {
queue,
rec,
local,
requested,
peer,
..
}) = socks.get_mut(&fd)
else {
return false;
};
*peer = None;
(queue.clone(), rec.clone(), *local, *requested)
};
rec.set_peer(None);
if let Some(bound) = local {
let ip = requested.map_or(unspecified_like(bound.ip()), |r| r.ip());
self.rehash(&queue, &rec, bound, 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();
reg.listeners
.get(&dest)
.or_else(|| {
host_local
.then(|| {
reg.listeners
.get(&SocketAddr::new(unspecified_like(dest.ip()), dest.port()))
})
.flatten()
})
.cloned()
}
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 connecting: Vec<c_int> = self
.socks
.lock()
.unwrap()
.iter()
.filter(|(fd, sock)| {
matches!(sock, Sock::Connecting { .. }) && fds.is_none_or(|fds| fds.contains(fd))
})
.map(|(fd, _)| *fd)
.collect();
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 cap = msg.Control.len as usize;
let header = size_of::<CmsgHdr>();
let mut used = 0usize;
let mut flags = 0;
for (level, ty, data) in messages {
let space = cmsg_align(header) + cmsg_align(data.len());
if msg.Control.buf.is_null() || used + space > cap {
flags |= MSG_CTRUNC;
continue;
}
let at = unsafe { msg.Control.buf.add(used) };
let hdr = CmsgHdr {
cmsg_len: cmsg_align(header) + data.len(),
cmsg_level: *level,
cmsg_type: *ty,
};
unsafe {
std::ptr::write_bytes(at, 0, space);
at.cast::<CmsgHdr>().write_unaligned(hdr);
std::ptr::copy_nonoverlapping(data.as_ptr(), at.add(cmsg_align(header)), data.len());
}
used += space;
}
msg.Control.len = used as u32;
flags
}
unsafe fn read_cmsgs(msg: &WsaMsg) -> Vec<(c_int, c_int, Vec<u8>)> {
let mut out = Vec::new();
if msg.Control.buf.is_null() {
return 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() };
let data_at = at + cmsg_align(header);
if hdr.cmsg_len < cmsg_align(header) || at + hdr.cmsg_len > control.len() {
break;
}
out.push((
hdr.cmsg_level,
hdr.cmsg_type,
control[data_at..at + hdr.cmsg_len].to_vec(),
));
at += cmsg_align(hdr.cmsg_len);
}
out
}
impl WinNet {
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, .. } => win_sockopt::Kind {
stream: false,
connecting: false,
v6: *domain == AF_INET6,
},
_ => win_sockopt::Kind {
stream: true,
connecting: matches!(sock, Sock::Connecting { .. }),
v6: sock.rec().state().win.v6,
},
})
}
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(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);
rec.state().win.v6 = domain == AF_INET6;
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 Some(want) = (unsafe { parse_addr(addr, len) }) else {
return err(WSAEFAULT);
};
let mut socks = self.socks.lock().unwrap();
match socks.get(&fd)? {
Sock::Fresh {
local: None, rec, ..
} => {
let rec = rec.clone();
if let Err(code) = self.regs.shared.claim_address(want.ip()) {
return err(code);
}
let want = match tcp_bind_addr(&socks, &self.regs, want, rec.opts().reuseaddr) {
Ok(want) => want,
Err(code) => return err(code),
};
if let Some(Sock::Fresh { local, .. }) = socks.get_mut(&fd) {
*local = Some(want);
}
rec.set_local(want);
ok(0)
}
Sock::Dgram {
local: None,
queue,
rec,
..
} => {
let (queue, rec) = (queue.clone(), rec.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()));
} else if regs.udp.contains_key(&want) || dgram_claims(&socks).any(|c| c == want) {
return err(WSAEADDRINUSE);
}
regs.udp.insert(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 state = Arc::new(ListenerState {
rec: Some(Arc::downgrade(&rec)),
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().listeners.insert(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);
rec.state().win.v6 = lrec.state().win.v6;
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(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 Some(dest) = (unsafe { parse_addr(addr, len) }) else {
return err(WSAEFAULT);
};
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,
queue,
rec,
broadcast,
..
} => {
let (local, queue, rec, broadcast) =
(*local, queue.clone(), rec.clone(), *broadcast);
drop(socks);
let sender = match self.regs.shared.route_send(
&rec.view(local),
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) => {
self.rehash(&queue, &rec, bound, sender.connected_local(bound))
}
}
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),
}
};
let sender =
match self
.regs
.shared
.route_send(&rec.view(bound), 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, bound, &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 => 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 Some(dest) = (unsafe { parse_addr(addr, addr_len) }) else {
return err(WSAEFAULT);
};
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).delivered()
}
_ => 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.delivered(),
);
}
None => conn.close(end),
}
}
}
Sock::Listener { state, addr, .. } => {
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()
.listeners
.retain(|a, l| *a != addr || !Arc::ptr_eq(l, &state));
let orphans: Vec<_> = state.pending.lock().unwrap().drain(..).collect();
for conn in orphans {
conn.reset(End::B);
}
}
}
Sock::Dgram { local, queue, .. } => {
let shared =
self.socks.lock().unwrap().values().any(
|o| matches!(o, Sock::Dgram { queue: q, .. } if Arc::ptr_eq(q, &queue)),
);
if !shared {
let mut regs = self.regs.lock();
if let Some(local) = local {
regs.udp.remove(&local);
}
}
}
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 local = match socks.get(&fd)? {
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);
};
drop(socks);
unsafe { write_addr(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 peer = match socks.get(&fd)? {
Sock::Stream { conn, end, .. } => conn.peer(*end),
Sock::Dgram { peer: Some(p), .. } => *p,
_ => return err(WSAENOTCONN),
};
drop(socks);
unsafe { write_addr(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 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_TCP
&& let Some(result) = unsafe { crate::faults::sockopt::set(&rec, 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);
return ok(0);
}
if level == SOL_SOCKET
&& matches!(
name,
SO_RCVTIMEO | SO_SNDTIMEO | SO_REUSEADDR | 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_REUSEADDR => state.opts.reuseaddr = unsafe { read_int(val, len) } != 0,
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 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);
}
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_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;
unsafe { write_addr(dg.src, msg.name.cast(), &mut len) };
msg.namelen = len as i32;
}
if extension {
let stamps: Vec<(c_int, c_int, Vec<u8>)> = win_sockopt::rx_stamp(&rec, dg.at)
.map(|stamp| (SOL_SOCKET, SO_TIMESTAMP, stamp.to_ne_bytes().to_vec()))
.into_iter()
.collect();
let cut = unsafe { write_cmsgs(msg, &stamps) };
msg.dwFlags = self.msg_flags(&dg, truncated) | cut;
} else {
msg.Control.len = 0;
msg.dwFlags = 0;
}
if truncated {
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 tx_id = if extension {
let controls = unsafe { read_cmsgs(msg) };
if controls
.iter()
.any(|(level, ty, _)| *level != SOL_SOCKET || *ty != SO_TIMESTAMP_ID)
{
return err(WSAEOPNOTSUPP);
}
if controls.iter().any(|(_, _, data)| data.len() != 4) {
return err(WSAEINVAL);
}
controls
.first()
.map(|(_, _, data)| u32::from_ne_bytes([data[0], data[1], data[2], data[3]]))
} else {
None
};
let flags = flags as c_int & !MSG_DONTROUTE;
let sent = if msg.name.is_null() || !dgram {
unsafe { self.send(fd, data.as_ptr(), data.len(), flags) }
} else {
let Some(dest) = (unsafe { parse_addr(msg.name.cast(), msg.namelen.max(0) as u32) })
else {
return err(WSAEFAULT);
};
self.udp_send(fd, data, dest)
};
if let (Some(id), Some(NetResult::Ok(_))) = (tx_id, &sent) {
win_sockopt::note_tx_stamp(&rec, id, monotonic(&self.regs.shared));
}
sent
}
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 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]) -> 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());
}
}
for delay in copy.delays {
copy.q.push_after(
(src, dest),
sent,
data.to_vec(),
delay,
copy.via.clone(),
self.shared.domain_key(),
);
}
}
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().listeners.insert(addr, listener.clone()));
listener
}
pub(crate) fn unlisten(regs: &Registries, listener: &Arc<Listener>) {
snare_interpose::real(|| {
regs.lock()
.listeners
.retain(|_, l| !Arc::ptr_eq(l, listener))
});
}
impl ListenerState {
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.udp.insert(addr, queue.clone());
});
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) == 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(|| {
let mut reg = self.regs.lock();
if reg
.udp
.get(&self.addr)
.is_some_and(|q| Arc::ptr_eq(q, &self.queue))
{
reg.udp.remove(&self.addr);
}
});
}
}