use std::net::SocketAddr;
use std::sync::atomic::{AtomicBool, AtomicU16, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::Duration;
use snare_interpose::WeakDomain;
use crate::clock::Clock;
use crate::dns::Hosts;
use crate::events::{EventLog, RecordedEvent};
#[cfg(unix)]
use crate::fabric as peer;
use crate::faults::BehaviorTable;
use crate::limits::SysConfig;
use crate::netif::Topology;
use crate::netpolicy::{Policies, TcpPolicy, UdpPolicy};
use crate::netstats::ProtoStats;
use crate::pcapng::Capture;
use crate::signals::SignalTable;
use crate::sockets::SocketTable;
#[cfg(windows)]
use crate::win_net as peer;
pub(crate) const EPHEMERAL_FIRST: u16 = 49152;
pub(crate) struct SimShared {
pub(crate) seed: u64,
pub(crate) clock: Option<Arc<Clock>>,
pub(crate) policies: Policies,
#[cfg(target_os = "linux")]
pub(crate) rx_timestamp_startup: crate::tstamp::RxStartup,
pub(crate) events: EventLog,
next_ephemeral: AtomicU16,
pub(crate) domain: OnceLock<WeakDomain>,
real_origin: Duration,
pub(crate) executive: AtomicBool,
pub(crate) sockets: SocketTable,
pub(crate) topology: Mutex<Topology>,
pub(crate) dns: Hosts,
pub(crate) signals: SignalTable,
pub(crate) sys: SysConfig,
pub(crate) listener_behavior: BehaviorTable,
pub(crate) capture: OnceLock<Arc<Capture>>,
pub(crate) stats: Arc<ProtoStats>,
pub(crate) strict_sockopts: AtomicBool,
pub(crate) strict_reported: AtomicBool,
}
impl SimShared {
pub(crate) fn new(seed: u64, clock: Option<Arc<Clock>>) -> Arc<Self> {
crate::readiness::readiness();
Arc::new_cyclic(|me| SimShared {
seed,
clock,
policies: Policies::with_seed(seed),
#[cfg(target_os = "linux")]
rx_timestamp_startup: crate::tstamp::RxStartup::default(),
events: EventLog::new(),
next_ephemeral: AtomicU16::new(EPHEMERAL_FIRST),
domain: OnceLock::new(),
real_origin: crate::readiness::real_now(),
executive: AtomicBool::new(false),
sockets: SocketTable::new(),
topology: Mutex::new(Topology::new(me.clone())),
dns: Hosts::default(),
signals: SignalTable::new(),
sys: SysConfig::new(),
listener_behavior: BehaviorTable::default(),
capture: OnceLock::new(),
stats: Arc::default(),
strict_sockopts: AtomicBool::new(false),
strict_reported: AtomicBool::new(false),
})
}
pub(crate) fn stamp(&self) -> Duration {
timeline(self.clock.as_deref(), self.real_origin)
}
pub(crate) fn real_origin(&self) -> Duration {
self.real_origin
}
pub(crate) fn record(&self, event: RecordedEvent) {
if self.events.enabled() {
self.events.push(|| self.stamp(), event);
}
}
pub(crate) fn record_ago(&self, ago: Duration, event: RecordedEvent) {
if self.events.enabled() {
self.events.push(|| self.stamp().saturating_sub(ago), event);
}
}
pub(crate) fn update_udp_policy(&self, addr: SocketAddr, change: impl FnOnce(&mut UdpPolicy)) {
let policy = self.policies.update(addr, change);
self.record(RecordedEvent::UdpPolicyChanged { addr, policy });
}
pub(crate) fn update_tcp_policy(&self, addr: SocketAddr, change: impl FnOnce(&mut TcpPolicy)) {
let policy = self.policies.update_tcp(addr, change);
self.record(RecordedEvent::TcpPolicyChanged { addr, policy });
}
pub(crate) fn kick(&self) {
snare_interpose::real(|| {
if let Some(clock) = &self.clock {
clock.wake_due();
}
crate::readiness::readiness().bump(self.domain_key());
if let Some(domain) = self.domain.get().and_then(WeakDomain::upgrade) {
domain.kick_after_readiness();
}
});
}
pub(crate) fn kick_keys(&self, keys: &[crate::readiness::WakeKey]) {
snare_interpose::real(|| {
if let Some(clock) = &self.clock {
clock.wake_due();
}
self.bump_keys(keys);
if let Some(domain) = self.domain.get().and_then(WeakDomain::upgrade) {
domain.kick();
}
});
}
pub(crate) fn domain_key(&self) -> usize {
self.domain.get().map_or(0, WeakDomain::key)
}
pub(crate) fn bump_keys(&self, keys: &[crate::readiness::WakeKey]) {
crate::readiness::readiness().bump_keys(self.domain_key(), keys);
}
#[cfg(windows)]
pub(crate) fn bump(&self) {
crate::readiness::readiness().bump(self.domain_key());
}
#[track_caller]
pub(crate) fn assert_clock_free(&self) {
assert!(
!self.executive.load(Ordering::Acquire),
"this Sim's clock is owned by an Executive; move time through it"
);
}
pub(crate) fn ephemeral_port(&self) -> u16 {
let next = |port: u16| Some(port.checked_add(1).unwrap_or(EPHEMERAL_FIRST));
self.next_ephemeral
.try_update(Ordering::Relaxed, Ordering::Relaxed, next)
.unwrap_or(EPHEMERAL_FIRST)
}
#[track_caller]
pub(crate) fn time(self: &Arc<Self>) -> crate::TimeHandle {
let Some(clock) = &self.clock else {
panic!(
"this Sim runs on the real clock (SimBuilder::wall_clock); build it with \
time_rate(1.0) for a controllable clock that tracks real time"
);
};
crate::TimeHandle {
clock: clock.clone(),
shared: self.clone(),
}
}
}
pub(crate) fn timeline(clock: Option<&Clock>, real_origin: Duration) -> Duration {
match clock {
Some(clock) => clock.value(),
None => crate::readiness::real_now().saturating_sub(real_origin),
}
}
#[track_caller]
pub(crate) fn here() -> Arc<SimShared> {
match try_here() {
Some(shared) => shared,
None => panic!("must be called from a thread running inside Sim::run"),
}
}
pub(crate) fn try_here() -> Option<Arc<SimShared>> {
peer::try_registries_here().map(|regs| regs.shared.clone())
}