use std::collections::{BTreeMap, BTreeSet, HashMap, VecDeque};
use std::ffi::c_int;
use std::fmt;
use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex, MutexGuard, Weak};
use std::time::Duration;
use crate::limits::{Charge, SockBuf};
use crate::netstats::ProtoStats;
use crate::readiness::Deadline;
use crate::scope::{self, SimShared};
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SocketId(u64);
impl SocketId {
pub fn get(self) -> u64 {
self.0
}
}
impl fmt::Display for SocketId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "socket#{}", self.0)
}
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SocketKind {
Udp,
TcpStream,
TcpListener,
Packet,
Netlink,
Unix,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Membership {
pub group: IpAddr,
pub interface_addr: Option<IpAddr>,
pub ifindex: u32,
}
#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SocketEntry {
pub id: SocketId,
pub kind: SocketKind,
pub local: Option<SocketAddr>,
pub peer: Option<SocketAddr>,
pub listener: Option<SocketId>,
pub memberships: Vec<Membership>,
pub queued: usize,
pub queued_bytes: usize,
pub delivered: u64,
pub delivered_bytes: u64,
pub sent: u64,
pub pending_error: Option<i32>,
pub created_at: Duration,
pub closed_at: Option<Duration>,
pub interface: Option<String>,
pub last_tx_nic: Option<String>,
pub last_rx_nic: Option<String>,
pub bound_device: Option<String>,
pub multicast_if: Option<String>,
pub rcvbuf: u32,
pub sndbuf: u32,
pub rmem_alloc: usize,
pub overflowed: u64,
pub wire_lost: u64,
pub drops: u32,
pub unmodelled_options: Vec<UnmodelledOption>,
}
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum UnmodelledOption {
Set { level: i32, name: i32 },
Get { level: i32, name: i32 },
Ioctl { request: u64 },
}
impl fmt::Display for UnmodelledOption {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
UnmodelledOption::Set { level, name } => {
write!(f, "setsockopt(level {level}, option {name})")
}
UnmodelledOption::Get { level, name } => {
write!(f, "getsockopt(level {level}, option {name})")
}
UnmodelledOption::Ioctl { request } => write!(f, "ioctl(request {request:#x})"),
}
}
}
pub(crate) trait RxProbe: Send + Sync {
fn pending_time(&self) -> bool {
false
}
fn land(&self);
fn queued(&self) -> (usize, usize);
fn next_len(&self) -> Option<usize> {
None
}
#[cfg_attr(windows, allow(dead_code))]
fn landed(&self) -> u64 {
0
}
}
#[derive(Clone, Copy, Default)]
pub(crate) struct SockOpts {
pub(crate) rcvtimeo: Option<Duration>,
pub(crate) sndtimeo: Option<Duration>,
pub(crate) linger: Option<Duration>,
pub(crate) reuseaddr: bool,
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) priority: c_int,
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) mark: u32,
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) busy_poll: BusyPoll,
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) syncnt: Option<u8>,
#[cfg_attr(target_os = "linux", allow(dead_code))]
pub(crate) connect_give_up: Option<Duration>,
}
#[derive(Clone, Copy, Default)]
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) struct BusyPoll {
pub(crate) usecs: c_int,
pub(crate) prefer: bool,
pub(crate) budget: u16,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ErrorOrigin {
Connect,
Raised,
Icmp { from: SocketAddr },
}
struct PendingError {
#[cfg(windows)]
order: ErrorOrder,
#[cfg(unix)]
wake_counted: bool,
errno: c_int,
visible: Option<Deadline>,
origin: ErrorOrigin,
}
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) enum Taker {
Send,
Recv,
Peek,
SoError,
}
impl Taker {
fn call(self) -> &'static str {
match self {
Taker::Send => "send",
Taker::Recv | Taker::Peek => "recv",
Taker::SoError => "getsockopt",
}
}
}
#[derive(Clone, Copy)]
pub(crate) struct DgramOpts {
pub(crate) recverr: bool,
pub(crate) connreset: bool,
pub(crate) mc_all: bool,
pub(crate) mc6_all: bool,
#[cfg(windows)]
pub(crate) cpu_affinity: Option<u16>,
}
impl Default for DgramOpts {
fn default() -> Self {
DgramOpts {
recverr: false,
connreset: true,
mc_all: true,
mc6_all: true,
#[cfg(windows)]
cpu_affinity: None,
}
}
}
#[derive(Clone, Copy)]
pub(crate) struct FragOpts {
pub(crate) pmtudisc: u8,
pub(crate) pmtudisc6: u8,
pub(crate) dontfrag: bool,
pub(crate) dontfrag6: bool,
}
impl Default for FragOpts {
fn default() -> Self {
let mode = if cfg!(windows) { 0 } else { 1 };
FragOpts {
pmtudisc: mode,
pmtudisc6: mode,
dontfrag: false,
dontfrag6: false,
}
}
}
#[derive(Clone)]
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) struct IcmpReport {
#[cfg(unix)]
wake_counted: bool,
pub(crate) errno: c_int,
pub(crate) offender: SocketAddr,
arrives: Option<Deadline>,
pub(crate) payload: Vec<u8>,
#[cfg(target_os = "linux")]
order: ErrorOrder,
#[cfg(target_os = "linux")]
charge: usize,
#[cfg(target_os = "linux")]
charged: bool,
}
#[cfg(any(target_os = "linux", windows))]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) struct ErrorOrder(Duration, u64);
#[cfg(any(target_os = "linux", windows))]
impl ErrorOrder {
pub(crate) fn at(&self) -> Duration {
self.0
}
pub(crate) fn new(arrives: Option<Deadline>) -> Self {
static SEQUENCE: AtomicU64 = AtomicU64::new(0);
let arrives = arrives.unwrap_or_else(|| Deadline::after(Duration::ZERO));
Self(arrives.at(), SEQUENCE.fetch_add(1, Ordering::Relaxed))
}
}
#[cfg(target_os = "linux")]
pub(crate) enum ErrorReport {
Icmp(IcmpReport),
Tx(crate::tstamp::TxReport),
}
pub(crate) struct SockState {
pub(crate) kind: SocketKind,
#[cfg(target_os = "linux")]
pub(crate) family: (c_int, c_int),
fds: BTreeSet<c_int>,
pub(crate) local: Option<SocketAddr>,
station: bool,
pub(crate) peer: Option<SocketAddr>,
pub(crate) tcp_established: bool,
#[cfg(unix)]
pub(crate) connect_ack: bool,
#[cfg(unix)]
pub(crate) tcp_failed: bool,
listener: Option<SocketId>,
memberships: Vec<Membership>,
pub(crate) opts: SockOpts,
pending_error: Option<PendingError>,
#[cfg(windows)]
icmp_errors: VecDeque<PendingError>,
#[cfg(unix)]
error_wakes: u64,
pub(crate) dgram: DgramOpts,
pub(crate) frag: FragOpts,
errq: VecDeque<IcmpReport>,
delivered: u64,
delivered_bytes: u64,
sent: u64,
closed_at: Option<Duration>,
pub(crate) device: Option<(u32, String)>,
pub(crate) mcast_if: Option<(u32, String)>,
last_nic: Option<String>,
last_tx_nic: Option<String>,
last_rx_nic: Option<String>,
pub(crate) buf: SockBuf,
#[cfg(unix)]
pub(crate) ts: crate::tstamp::TsState,
#[cfg(windows)]
pub(crate) win: crate::win_sockopt::WinSock,
unmodelled: Vec<UnmodelledOption>,
ignored: HashMap<(c_int, c_int), Vec<u8>>,
}
#[cfg(target_os = "linux")]
impl SockState {
fn land_errors(&mut self, until: Option<Duration>) {
loop {
let icmp = self
.errq
.iter()
.enumerate()
.filter(|(_, r)| {
!r.charged
&& r.arrives.is_none_or(|d| d.passed())
&& until.is_none_or(|until| r.order.at() <= until)
})
.min_by_key(|(_, r)| r.order)
.map(|(i, r)| (i, r.order, r.charge));
let tx = crate::tstamp::pending_tx_report(&self.ts, until);
if let Some((i, order, charge)) = tx
&& icmp.is_none_or(|(_, icmp, _)| order < icmp)
{
if self.buf.admit_error(charge) {
self.ts.admit_tx_report(i);
} else {
self.ts.pop_tx_report(i);
}
} else if let Some((i, _, charge)) = icmp {
if self.buf.admit_error(charge) {
self.errq[i].charged = true;
} else {
self.errq.remove(i);
}
} else {
break;
}
}
}
}
pub(crate) struct SockRec {
pub(crate) id: SocketId,
created_at: Duration,
probe: Mutex<Option<Weak<dyn RxProbe>>>,
state: Mutex<SockState>,
stats: Arc<ProtoStats>,
#[cfg(target_os = "linux")]
next_data_arrival: AtomicU64,
}
impl SockRec {
pub(crate) fn state(&self) -> MutexGuard<'_, SockState> {
let state = self.state.lock().unwrap();
#[cfg(target_os = "linux")]
{
let mut state = state;
let next_data = self.next_data_arrival.load(Ordering::Acquire);
if next_data == u64::MAX {
state.land_errors(None);
} else if next_data != 0 {
state.land_errors(Some(Duration::from_nanos(next_data - 1)));
}
state
}
#[cfg(not(target_os = "linux"))]
state
}
#[cfg(target_os = "linux")]
pub(crate) fn set_data_arrival(&self, arrives: Option<Deadline>) {
let at = arrives.map_or(u64::MAX, |d| {
d.at().as_nanos().min(u128::from(u64::MAX - 1)) as u64
});
self.next_data_arrival.store(at, Ordering::Release);
}
#[cfg(target_os = "linux")]
pub(crate) fn note_data_arrival(&self, arrives: Deadline) {
let at = arrives.at().as_nanos().min(u128::from(u64::MAX - 1)) as u64;
self.next_data_arrival.fetch_min(at, Ordering::AcqRel);
}
pub(crate) fn opts(&self) -> SockOpts {
self.state().opts
}
pub(crate) fn set_kind(&self, kind: SocketKind) {
self.state().kind = kind;
}
#[cfg(target_os = "linux")]
pub(crate) fn set_family(&self, family: c_int, protocol: c_int) {
self.state().family = (family, protocol);
}
pub(crate) fn set_local(&self, local: SocketAddr) {
let station = snare_interpose::real(|| {
crate::scope::try_here().is_some_and(|shared| shared.topo().is_station_ip(local.ip()))
});
let mut state = self.state();
state.local = Some(local);
state.station = station;
}
pub(crate) fn set_peer(&self, peer: Option<SocketAddr>) {
self.state().peer = peer;
}
pub(crate) fn set_ends(&self, local: SocketAddr, peer: SocketAddr) {
let mut state = self.state();
state.local = Some(local);
state.peer = Some(peer);
state.tcp_established = true;
}
pub(crate) fn set_listener(&self, listener: SocketId) {
self.state().listener = Some(listener);
}
#[cfg(windows)]
pub(crate) fn join(&self, membership: Membership) {
let mut state = self.state();
if !state.memberships.contains(&membership) {
state.memberships.push(membership);
}
}
#[cfg(unix)]
pub(crate) fn change_membership(
&self,
membership: Membership,
join: bool,
) -> Result<(), c_int> {
let mut state = self.state();
let present = state
.memberships
.iter()
.position(|held| *held == membership);
match (join, present) {
(true, Some(_)) => Err(libc::EADDRINUSE),
(true, None) => {
state.memberships.push(membership);
Ok(())
}
(false, Some(index)) => {
state.memberships.remove(index);
Ok(())
}
(false, None) => Err(libc::EADDRNOTAVAIL),
}
}
pub(crate) fn inherit_buffers(&self, listener: &SockRec) {
let from = listener.state().buf;
self.state().buf.inherit(&from);
}
pub(crate) fn joined(&self, group: IpAddr) -> bool {
self.state().memberships.iter().any(|m| m.group == group)
}
pub(crate) fn takes_group(&self, local: SocketAddr, group: IpAddr, host_joined: bool) -> bool {
if cfg!(unix) && !(local.ip().is_unspecified() || local.ip() == group) {
return false;
}
let state = self.state();
if state.memberships.iter().any(|m| m.group == group) {
return true;
}
let all = if group.is_ipv6() {
state.dgram.mc6_all
} else {
state.dgram.mc_all
};
cfg!(target_os = "linux") && all && host_joined
}
pub(crate) fn set_probe(&self, probe: Weak<dyn RxProbe>) {
*self.probe.lock().unwrap() = Some(probe);
}
pub(crate) fn count_sent(&self) {
self.state().sent += 1;
}
#[cfg(any(target_os = "linux", windows))]
pub(crate) fn count_udp_sent(&self, dest: SocketAddr, sender: &crate::netif::Sender) {
self.count_sent();
if let crate::netif::Sender::Host(_) = sender {
self.stats
.udp(dest.ip())
.out
.fetch_add(1, Ordering::Relaxed);
}
}
#[cfg(unix)]
pub(crate) fn finish_udp_send(&self, dest: SocketAddr, sender: &crate::netif::Sender) -> bool {
let mut state = self.state();
if let Some(nic) = sender.egress_name() {
Self::update_nic(&mut state.last_nic, nic);
Self::update_nic(&mut state.last_tx_nic, nic);
self.stats
.udp(dest.ip())
.out
.fetch_add(1, Ordering::Relaxed);
}
state.sent += 1;
Self::error_reports_pending(&state)
}
pub(crate) fn view(&self, local: Option<SocketAddr>) -> crate::netif::SockView {
let state = self.state();
crate::netif::SockView {
local,
device: state.device.as_ref().map(|(i, _)| *i),
mcast_if: state.mcast_if.as_ref().map(|(i, _)| *i),
}
}
pub(crate) fn note_tx_nic(&self, nic: Option<&str>) {
if let Some(nic) = nic {
let mut state = self.state();
Self::update_nic(&mut state.last_nic, nic);
Self::update_nic(&mut state.last_tx_nic, nic);
}
}
pub(crate) fn note_rx_nic(&self, nic: Option<&str>) {
if let Some(nic) = nic {
let mut state = self.state();
Self::update_nic(&mut state.last_nic, nic);
Self::update_nic(&mut state.last_rx_nic, nic);
}
}
fn update_nic(slot: &mut Option<String>, nic: &str) {
match slot {
Some(stored) if stored != nic => {
stored.clear();
stored.push_str(nic);
}
Some(_) => {}
None => *slot = Some(nic.to_owned()),
}
}
pub(crate) fn note_conn_nic(&self, nic: Option<&str>) {
self.note_tx_nic(nic);
self.note_rx_nic(nic);
}
pub(crate) fn count_delivered(&self, bytes: usize) {
let mut state = self.state();
state.delivered += 1;
state.delivered_bytes += bytes as u64;
}
pub(crate) fn admit(
&self,
len: usize,
src: SocketAddr,
mtu: Option<u32>,
arrives: Option<Deadline>,
) -> Option<(Charge, u32)> {
let mut state = self.state.lock().unwrap();
#[cfg(target_os = "linux")]
state.land_errors(arrives.map(|d| d.at()));
#[cfg(not(target_os = "linux"))]
let _ = arrives;
if state.kind == SocketKind::Udp && state.peer.is_some_and(|peer| peer != src) {
return None;
}
let admitted = state.buf.admit(len, src.is_ipv6(), mtu);
if admitted.is_some() {
state.delivered += 1;
state.delivered_bytes += len as u64;
}
if state.kind == SocketKind::Udp && !state.station {
let udp = self.stats.udp(src.ip());
match admitted {
Some(_) => udp.received.fetch_add(1, Ordering::Relaxed),
None => udp.rcvbuf_errors.fetch_add(1, Ordering::Relaxed),
};
}
admitted
}
pub(crate) fn consumed(&self, len: usize, charge: Charge, src: SocketAddr) {
let mut state = self.state();
state.buf.consumed(len, charge);
if state.kind == SocketKind::Udp && !state.station {
self.stats
.udp(src.ip())
.read
.fetch_add(1, Ordering::Relaxed);
}
}
pub(crate) fn count_wire_lost(&self) {
self.state().buf.wire_lost += 1;
}
fn probe(&self) -> Option<Arc<dyn RxProbe>> {
let probe = self.probe.lock().unwrap().as_ref().and_then(Weak::upgrade);
if let Some(probe) = &probe {
probe.land();
}
probe
}
#[cfg_attr(windows, allow(dead_code))]
pub(crate) fn dgram_readiness(&self) -> Option<(bool, u64)> {
if !matches!(
self.state.lock().unwrap().kind,
SocketKind::Udp | SocketKind::Netlink
) {
return None;
}
let probe = self.probe()?;
Some((probe.queued().0 > 0, probe.landed()))
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) fn land(&self) {
self.probe();
}
pub(crate) fn fionread(&self) -> c_int {
let Some(probe) = self.probe() else {
return 0;
};
let kind = self.state().kind;
let n = if kind != SocketKind::Udp {
probe.queued().1
} else if cfg!(target_os = "linux") {
probe.next_len().unwrap_or(0)
} else if cfg!(target_os = "macos") {
self.state().buf.rx.cc
} else {
let buf = self.state().buf;
buf.rx.queued_bytes.min(buf.rcvbuf.max(0) as usize)
};
n.min(c_int::MAX as usize) as c_int
}
#[cfg(target_os = "macos")]
pub(crate) fn nread(&self) -> c_int {
let Some(probe) = self.probe() else {
return 0;
};
let udp = self.state().kind == SocketKind::Udp;
let n = if udp {
probe.next_len().unwrap_or(0)
} else {
probe.queued().1
};
n.min(c_int::MAX as usize) as c_int
}
pub(crate) fn set_pending_error(&self, errno: c_int, visible: Option<Deadline>) {
self.raise_error(errno, ErrorOrigin::Connect, visible);
}
pub(crate) fn wake_key(&self) -> crate::readiness::WakeKey {
crate::readiness::WakeKey::Socket(self.id.get())
}
#[cfg(windows)]
pub(crate) fn has_error_reports(&self) -> bool {
Self::error_reports_pending(&self.state())
}
fn error_reports_pending(state: &SockState) -> bool {
#[cfg(unix)]
let stamps = state.ts.has_tx_reports();
#[cfg(windows)]
let stamps = false;
#[cfg(windows)]
let indications = !state.icmp_errors.is_empty();
#[cfg(unix)]
let indications = false;
state.pending_error.is_some() || !state.errq.is_empty() || stamps || indications
}
pub(crate) fn pending_time(&self) -> bool {
let pending = {
let state = self.state();
#[cfg(unix)]
let stamps = state.ts.pending_time();
#[cfg(windows)]
let stamps = state
.icmp_errors
.iter()
.any(|error| error.visible.is_some());
state
.pending_error
.as_ref()
.is_some_and(|e| e.visible.is_some())
|| state.errq.iter().any(|e| e.arrives.is_some())
|| stamps
};
let probe = self.probe.lock().unwrap().as_ref().and_then(Weak::upgrade);
pending || probe.is_some_and(|probe| probe.pending_time())
}
pub(crate) fn raise_error(&self, errno: c_int, origin: ErrorOrigin, visible: Option<Deadline>) {
let mut state = self.state();
let error = PendingError {
#[cfg(windows)]
order: ErrorOrder::new(visible),
#[cfg(unix)]
wake_counted: false,
errno,
visible,
origin,
};
#[cfg(windows)]
if matches!(origin, ErrorOrigin::Icmp { .. }) {
let position = state
.icmp_errors
.partition_point(|pending| pending.order < error.order);
state.icmp_errors.insert(position, error);
return;
}
#[cfg(unix)]
if matches!(origin, ErrorOrigin::Icmp { .. })
&& state
.pending_error
.as_ref()
.is_some_and(|pending| matches!(pending.origin, ErrorOrigin::Icmp { .. }))
{
return;
}
state.pending_error = Some(error);
}
pub(crate) fn take_error_as(&self, shared: &SimShared, taker: Taker) -> Option<c_int> {
self.take_error_when(shared, taker, |_| true)
}
#[cfg(windows)]
pub(crate) fn take_error_before(
&self,
shared: &SimShared,
taker: Taker,
next: Option<ErrorOrder>,
cutoff: Duration,
) -> Option<c_int> {
self.take_error_when(shared, taker, |pending| {
!matches!(pending.origin, ErrorOrigin::Icmp { .. })
|| (pending.order.at() <= cutoff && next.is_none_or(|data| pending.order < data))
})
}
fn take_error_when(
&self,
shared: &SimShared,
taker: Taker,
eligible: impl FnOnce(&PendingError) -> bool,
) -> Option<c_int> {
let mut state = self.state();
#[cfg(unix)]
Self::count_error_wakes(&mut state);
#[cfg(windows)]
let indication = state.pending_error.is_none();
#[cfg(windows)]
let pending = state
.pending_error
.as_ref()
.or_else(|| state.icmp_errors.front())?;
#[cfg(unix)]
let pending = state.pending_error.as_ref()?;
if !eligible(pending) || pending.visible.is_some_and(|d| !d.passed()) {
return None;
}
let (errno, origin) = (pending.errno, pending.origin);
if cfg!(windows)
&& matches!(taker, Taker::Send | Taker::SoError)
&& matches!(origin, ErrorOrigin::Icmp { .. })
{
return None;
}
#[cfg(windows)]
if indication {
if taker != Taker::Peek {
state.icmp_errors.pop_front();
}
} else {
state.pending_error = None;
}
#[cfg(unix)]
if !(taker == Taker::Peek && cfg!(target_os = "macos")) {
state.pending_error = None;
}
let local = state.local;
drop(state);
let fault = match origin {
ErrorOrigin::Connect => return Some(errno),
ErrorOrigin::Raised => crate::events::Fault::Error {
errno,
call: taker.call(),
},
ErrorOrigin::Icmp { from } => crate::events::Fault::IcmpPortUnreachable { from },
};
shared.record(crate::events::RecordedEvent::Fault { addr: local, fault });
Some(errno)
}
#[cfg_attr(not(target_os = "linux"), allow(dead_code))]
pub(crate) fn queue_icmp_report(
&self,
errno: c_int,
offender: SocketAddr,
arrives: Option<Deadline>,
payload: &[u8],
) {
let mut state = self.state();
#[cfg(target_os = "linux")]
let payload = &payload[..payload
.len()
.min(if offender.is_ipv6() { 1184 } else { 520 })];
#[cfg(target_os = "linux")]
let charge = state.buf.error_charge(
payload.len() + if offender.is_ipv6() { 48 } else { 28 },
offender.is_ipv6(),
);
state.errq.push_back(IcmpReport {
#[cfg(unix)]
wake_counted: false,
errno,
offender,
arrives,
payload: payload.to_vec(),
#[cfg(target_os = "linux")]
order: ErrorOrder::new(arrives),
#[cfg(target_os = "linux")]
charge,
#[cfg(target_os = "linux")]
charged: false,
});
}
#[cfg(target_os = "linux")]
pub(crate) fn pop_error_report(&self) -> Option<ErrorReport> {
let mut state = self.state();
Self::count_error_wakes(&mut state);
let icmp = state
.errq
.iter()
.enumerate()
.filter(|(_, report)| report.charged)
.min_by_key(|(_, report)| report.order)
.map(|(i, report)| (i, report.order));
let tx = crate::tstamp::next_tx_report(&state.ts);
if tx.is_some_and(|(_, order)| icmp.is_none_or(|(_, icmp)| order < icmp)) {
let (i, _) = tx?;
let report = state.ts.pop_tx_report(i)?;
state.buf.consume_error(report.charge);
return Some(ErrorReport::Tx(report));
}
let (i, _) = icmp?;
let report = state.errq.remove(i)?;
state.buf.consume_error(report.charge);
if state
.pending_error
.as_ref()
.is_some_and(|e| matches!(e.origin, ErrorOrigin::Icmp { .. }))
{
state.pending_error = None;
}
Some(ErrorReport::Icmp(report))
}
#[cfg(target_os = "linux")]
pub(crate) fn icmp_report_ready(&self) -> bool {
self.state().errq.iter().any(|r| r.charged)
}
pub(crate) fn kind(&self) -> SocketKind {
self.state().kind
}
pub(crate) fn take_error(&self) -> Option<c_int> {
let mut state = self.state();
#[cfg(unix)]
Self::count_error_wakes(&mut state);
let visible = state
.pending_error
.as_ref()
.is_some_and(|e| e.visible.is_none_or(|d| d.passed()));
if !visible {
return None;
}
state.pending_error.take().map(|e| e.errno)
}
pub(crate) fn peek_error(&self) -> Option<c_int> {
let state = self.state();
let pending = state.pending_error.as_ref();
#[cfg(windows)]
let pending = pending.or_else(|| state.icmp_errors.front());
pending
.filter(|error| error.visible.is_none_or(|deadline| deadline.passed()))
.map(|error| error.errno)
}
#[cfg(windows)]
pub(crate) fn peek_socket_error(&self) -> Option<c_int> {
self.state()
.pending_error
.as_ref()
.filter(|error| error.visible.is_none_or(|deadline| deadline.passed()))
.map(|error| error.errno)
}
#[cfg(windows)]
pub(crate) fn icmp_order(&self) -> Option<ErrorOrder> {
self.state()
.icmp_errors
.front()
.filter(|error| error.visible.is_none_or(|deadline| deadline.passed()))
.map(|error| error.order)
}
#[cfg(unix)]
pub(crate) fn error_wakes(&self) -> u64 {
Self::count_error_wakes(&mut self.state())
}
#[cfg(unix)]
fn count_error_wakes(state: &mut SockState) -> u64 {
let mut added = 0;
if let Some(error) = &mut state.pending_error
&& !error.wake_counted
&& error.visible.is_none_or(|d| d.passed())
{
error.wake_counted = true;
added += 1;
}
for report in &mut state.errq {
#[cfg(target_os = "linux")]
let ready = report.charged;
#[cfg(not(target_os = "linux"))]
let ready = report.arrives.is_none_or(|d| d.passed());
if !report.wake_counted && ready {
report.wake_counted = true;
added += 1;
}
}
state.error_wakes = state.error_wakes.saturating_add(added);
let wakes = state.error_wakes;
#[cfg(target_os = "linux")]
let wakes = wakes.saturating_add(crate::tstamp::tx_report_wakes(&mut state.ts));
wakes
}
fn entry(&self) -> SocketEntry {
let probe = self.probe();
let (queued, queued_bytes) = probe.map_or((0, 0), |p| p.queued());
let state = self.state();
let pending_error = state.pending_error.as_ref();
#[cfg(windows)]
let pending_error = pending_error.or_else(|| state.icmp_errors.front());
SocketEntry {
id: self.id,
kind: state.kind,
local: state.local,
peer: state.peer,
listener: state.listener,
memberships: state.memberships.clone(),
queued,
queued_bytes,
delivered: state.delivered,
delivered_bytes: state.delivered_bytes,
sent: state.sent,
pending_error: pending_error
.filter(|e| e.visible.is_none_or(|d| d.passed()))
.map(|e| e.errno),
created_at: self.created_at,
closed_at: state.closed_at,
interface: state.last_nic.clone(),
last_tx_nic: state.last_tx_nic.clone(),
last_rx_nic: state.last_rx_nic.clone(),
bound_device: state.device.as_ref().map(|(_, n)| n.clone()),
multicast_if: state.mcast_if.as_ref().map(|(_, n)| n.clone()),
rcvbuf: state.buf.rcvbuf as u32,
sndbuf: state.buf.sndbuf as u32,
rmem_alloc: state.buf.rx.rmem_alloc,
overflowed: state.buf.overflowed,
wire_lost: state.buf.wire_lost,
drops: state.buf.drops,
unmodelled_options: state.unmodelled.clone(),
}
}
pub(crate) fn keep_ignored(&self, level: c_int, name: c_int, value: &[u8]) {
self.state().ignored.insert((level, name), value.to_vec());
}
pub(crate) fn ignored_value(&self, level: c_int, name: c_int) -> Option<Vec<u8>> {
self.state().ignored.get(&(level, name)).cloned()
}
}
pub(crate) struct SocketTable {
next: AtomicU64,
live: Mutex<BTreeMap<SocketId, Arc<SockRec>>>,
by_fd: Mutex<HashMap<c_int, SocketId>>,
closed: Mutex<Vec<SocketEntry>>,
}
impl SocketTable {
pub(crate) fn new() -> Self {
SocketTable {
next: AtomicU64::new(1),
live: Mutex::default(),
by_fd: Mutex::default(),
closed: Mutex::default(),
}
}
pub(crate) fn create(
&self,
kind: SocketKind,
fd: c_int,
now: Duration,
buf: SockBuf,
stats: Arc<ProtoStats>,
) -> Arc<SockRec> {
let id = SocketId(self.next.fetch_add(1, Ordering::Relaxed));
let rec = Arc::new(SockRec {
id,
created_at: now,
probe: Mutex::new(None),
#[cfg(target_os = "linux")]
next_data_arrival: AtomicU64::new(u64::MAX),
state: Mutex::new(SockState {
kind,
#[cfg(target_os = "linux")]
family: (0, 0),
fds: BTreeSet::from([fd]),
local: None,
station: false,
peer: None,
tcp_established: false,
#[cfg(unix)]
connect_ack: false,
#[cfg(unix)]
tcp_failed: false,
listener: None,
memberships: Vec::new(),
opts: SockOpts::default(),
pending_error: None,
#[cfg(windows)]
icmp_errors: VecDeque::new(),
#[cfg(unix)]
error_wakes: 0,
dgram: DgramOpts::default(),
frag: FragOpts::default(),
errq: VecDeque::new(),
delivered: 0,
delivered_bytes: 0,
sent: 0,
closed_at: None,
device: None,
mcast_if: None,
last_nic: None,
last_tx_nic: None,
last_rx_nic: None,
buf,
#[cfg(unix)]
ts: Default::default(),
#[cfg(windows)]
win: Default::default(),
unmodelled: Vec::new(),
ignored: HashMap::new(),
}),
stats,
});
self.live.lock().unwrap().insert(id, rec.clone());
self.by_fd.lock().unwrap().insert(fd, id);
rec
}
pub(crate) fn alias(&self, fd: c_int, rec: &Arc<SockRec>) {
rec.state().fds.insert(fd);
self.by_fd.lock().unwrap().insert(fd, rec.id);
}
#[cfg(any(target_os = "linux", windows))]
pub(crate) fn fd_closed(&self, fd: c_int, now: Duration) {
let Some(id) = self.by_fd.lock().unwrap().remove(&fd) else {
return;
};
let Some(rec) = self.live.lock().unwrap().get(&id).cloned() else {
return;
};
let last = {
let mut state = rec.state();
state.fds.remove(&fd);
let last = state.fds.is_empty();
if last {
state.closed_at = Some(now);
}
last
};
if last {
let entry = rec.entry();
self.live.lock().unwrap().remove(&id);
self.closed.lock().unwrap().push(entry);
}
}
#[cfg(unix)]
pub(crate) fn detach_replaced_fd(
&self,
fd: c_int,
previous: &Arc<SockRec>,
now: Duration,
) -> bool {
{
let mut by_fd = self.by_fd.lock().unwrap();
if by_fd.get(&fd) == Some(&previous.id) {
by_fd.remove(&fd);
}
}
let mut state = previous.state();
state.fds.remove(&fd);
let last = state.fds.is_empty();
if last {
state.closed_at = Some(now);
}
last
}
#[cfg(unix)]
pub(crate) fn finish_replaced_fd(&self, previous: &Arc<SockRec>) {
let entry = previous.entry();
self.live.lock().unwrap().remove(&previous.id);
self.closed.lock().unwrap().push(entry);
}
#[cfg(target_os = "linux")]
pub(crate) fn fd_replaced(&self, fd: c_int, previous: &Arc<SockRec>, now: Duration) {
if self.detach_replaced_fd(fd, previous, now) {
self.finish_replaced_fd(previous);
}
}
pub(crate) fn live_recs(&self) -> Vec<Arc<SockRec>> {
self.live.lock().unwrap().values().cloned().collect()
}
pub(crate) fn lookup_fd(&self, fd: c_int) -> Option<Arc<SockRec>> {
let id = *self.by_fd.lock().unwrap().get(&fd)?;
self.live.lock().unwrap().get(&id).cloned()
}
fn lookup(&self, id: SocketId) -> Option<Arc<SockRec>> {
self.live.lock().unwrap().get(&id).cloned()
}
#[cfg(target_os = "linux")]
pub(crate) fn lookup_raw_id(&self, id: u64) -> Option<Arc<SockRec>> {
self.lookup(SocketId(id))
}
pub(crate) fn entry(&self, id: SocketId) -> Option<SocketEntry> {
if let Some(rec) = self.lookup(id) {
return Some(rec.entry());
}
self.closed
.lock()
.unwrap()
.iter()
.find(|e| e.id == id)
.cloned()
}
#[cfg(windows)]
pub(crate) fn cpu_affinity(&self, id: SocketId) -> Option<u16> {
self.lookup(id)?.state().dgram.cpu_affinity
}
pub(crate) fn live(&self) -> Vec<SocketEntry> {
let recs: Vec<_> = self.live.lock().unwrap().values().cloned().collect();
recs.iter().map(|rec| rec.entry()).collect()
}
pub(crate) fn closed(&self) -> Vec<SocketEntry> {
self.closed.lock().unwrap().clone()
}
}
impl SimShared {
pub(crate) fn new_socket(&self, kind: SocketKind, fd: c_int) -> Arc<SockRec> {
let buf = SockBuf::new(kind, &self.sys.limits());
self.sockets
.create(kind, fd, self.stamp(), buf, self.stats.clone())
}
#[cfg(any(target_os = "linux", windows))]
pub(crate) fn socket_closed(&self, fd: c_int) {
self.sockets.fd_closed(fd, self.stamp());
}
pub(crate) fn socket_entry(&self, id: SocketId) -> Option<SocketEntry> {
snare_interpose::real(|| self.sockets.entry(id))
}
pub(crate) fn socket_table(&self) -> Vec<SocketEntry> {
snare_interpose::real(|| self.sockets.live())
}
pub(crate) fn closed_sockets(&self) -> Vec<SocketEntry> {
snare_interpose::real(|| self.sockets.closed())
}
}
fn id_of_fd(fd: c_int) -> Option<SocketId> {
let shared = scope::try_here()?;
snare_interpose::real(|| shared.sockets.lookup_fd(fd).map(|rec| rec.id))
}
#[cfg(unix)]
pub fn socket_id<S: std::os::fd::AsFd>(socket: &S) -> Option<SocketId> {
use std::os::fd::AsRawFd;
id_of_fd(socket.as_fd().as_raw_fd())
}
#[cfg(windows)]
pub fn socket_id<S: std::os::windows::io::AsSocket>(socket: &S) -> Option<SocketId> {
use std::os::windows::io::AsRawSocket;
let raw = socket.as_socket().as_raw_socket();
id_of_fd(c_int::try_from(raw).ok()?)
}
#[track_caller]
pub fn socket_entry(id: SocketId) -> Option<SocketEntry> {
scope::here().socket_entry(id)
}
#[track_caller]
pub fn socket_table() -> Vec<SocketEntry> {
scope::here().socket_table()
}
#[track_caller]
pub fn closed_sockets() -> Vec<SocketEntry> {
scope::here().closed_sockets()
}
#[track_caller]
pub fn sockets_bound(local: impl ToSocketAddrs) -> Vec<SocketEntry> {
let shared = scope::here();
let addrs: Vec<SocketAddr> = snare_interpose::real(|| local.to_socket_addrs())
.map(Iterator::collect)
.unwrap_or_default();
shared
.socket_table()
.into_iter()
.filter(|e| e.local.is_some_and(|l| addrs.contains(&l)))
.collect()
}
#[doc(hidden)]
pub fn __set_pending_error(id: SocketId, errno: i32) {
let shared = scope::here();
snare_interpose::real(|| {
if let Some(rec) = shared.sockets.lookup(id) {
rec.set_pending_error(errno, None);
}
});
}
#[track_caller]
pub fn inject_socket_drops(id: SocketId, n: u32) -> std::io::Result<()> {
scope::here().inject_socket_drops(id, n)
}
impl SimShared {
pub(crate) fn inject_socket_drops(&self, id: SocketId, n: u32) -> std::io::Result<()> {
snare_interpose::real(|| {
let rec = self
.sockets
.lookup(id)
.ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?;
let mut state = rec.state();
state.buf.drops = state.buf.drops.wrapping_add(n);
Ok(())
})
}
}
#[track_caller]
pub fn set_socket_device(id: SocketId, nic: Option<&str>) -> std::io::Result<()> {
scope::here().set_socket_device(id, nic)
}
impl SimShared {
pub(crate) fn set_socket_device(&self, id: SocketId, nic: Option<&str>) -> std::io::Result<()> {
snare_interpose::real(|| {
let rec = self
.sockets
.lookup(id)
.ok_or_else(|| std::io::Error::from(std::io::ErrorKind::NotFound))?;
let device = match nic {
None => None,
Some(name) => {
let index = self
.topo()
.index_of(name)
.ok_or_else(|| std::io::Error::from_raw_os_error(NO_SUCH_DEVICE))?;
Some((index, name.to_string()))
}
};
rec.state().device = device;
Ok::<(), std::io::Error>(())
})?;
self.kick();
Ok(())
}
}
#[cfg(target_os = "linux")]
const NO_SUCH_DEVICE: c_int = libc::ENODEV;
#[cfg(target_os = "macos")]
const NO_SUCH_DEVICE: c_int = libc::ENXIO;
#[cfg(windows)]
const NO_SUCH_DEVICE: c_int = 10022;
impl SimShared {
pub(crate) fn unmodelled_option(&self, rec: &SockRec, option: UnmodelledOption) -> bool {
let strict = self.strict_sockopts.load(Ordering::Relaxed);
self.list_unmodelled(rec, option, strict);
if strict && !self.strict_reported.swap(true, Ordering::Relaxed) {
let id = rec.id;
snare_interpose::real(|| {
eprintln!(
"snare: strict_sockopts: {option} on {id} is not modelled by the sim; \
failing the call (later ones fail without this message, see \
SocketEntry::unmodelled_options)"
)
});
}
strict
}
#[cfg(windows)]
pub(crate) fn unservable_option(&self, rec: &SockRec, option: UnmodelledOption) {
self.list_unmodelled(rec, option, true);
}
fn list_unmodelled(&self, rec: &SockRec, option: UnmodelledOption, refused: bool) {
let (first, local) = {
let mut state = rec.state();
let first = !state.unmodelled.contains(&option);
if first {
state.unmodelled.push(option);
}
(first, state.local)
};
if first {
self.record(crate::events::RecordedEvent::UnmodelledOption {
socket: rec.id,
local,
option,
refused,
});
}
}
}