use std::collections::HashMap;
use std::net::{SocketAddr, ToSocketAddrs};
use std::sync::Mutex;
use std::time::Duration;
use crate::events::{Direction, LinkFault};
use crate::readiness::Deadline;
#[derive(Default)]
pub(crate) struct Delays {
values: [Duration; 4],
len: usize,
}
impl Delays {
pub(crate) fn one(delay: Duration) -> Self {
Self {
values: [delay, Duration::ZERO, Duration::ZERO, Duration::ZERO],
len: 1,
}
}
pub(crate) fn extend(&mut self, delays: impl IntoIterator<Item = Duration>) {
for delay in delays {
self.values[self.len] = delay;
self.len += 1;
}
}
}
impl std::ops::Deref for Delays {
type Target = [Duration];
fn deref(&self) -> &Self::Target {
&self.values[..self.len]
}
}
impl std::ops::DerefMut for Delays {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.values[..self.len]
}
}
impl FromIterator<Duration> for Delays {
fn from_iter<T: IntoIterator<Item = Duration>>(iter: T) -> Self {
let mut delays = Self::default();
delays.extend(iter);
delays
}
}
impl IntoIterator for Delays {
type Item = Duration;
type IntoIter = std::iter::Take<std::array::IntoIter<Duration, 4>>;
fn into_iter(self) -> Self::IntoIter {
self.values.into_iter().take(self.len)
}
}
impl<'a> IntoIterator for &'a Delays {
type Item = &'a Duration;
type IntoIter = std::slice::Iter<'a, Duration>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
impl<'a> IntoIterator for &'a mut Delays {
type Item = &'a mut Duration;
type IntoIter = std::slice::IterMut<'a, Duration>;
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UdpPolicy {
pub latency: Duration,
pub jitter: Duration,
pub loss_rate: f64,
pub duplicate_rate: f64,
pub mtu: Option<usize>,
pub send_queue_depth: Option<usize>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TcpPolicy {
pub latency: Duration,
pub jitter: Duration,
pub recv_window: Option<usize>,
}
pub fn set_tcp_policy(addr: impl ToSocketAddrs, change: impl FnOnce(&mut TcpPolicy)) {
set_tcp_policy_on(&crate::scope::here(), addr, change);
}
pub(crate) fn set_tcp_policy_on(
shared: &crate::scope::SimShared,
addr: impl ToSocketAddrs,
change: impl FnOnce(&mut TcpPolicy),
) {
let addr = policy_addr(addr);
snare_interpose::real(|| shared.update_tcp_policy(addr, change));
shared.kick();
}
#[track_caller]
fn policy_addr(addr: impl ToSocketAddrs) -> SocketAddr {
addr.to_socket_addrs()
.expect("policy address must parse")
.next()
.expect("policy address resolved to nothing")
}
pub fn set_udp_policy(addr: impl ToSocketAddrs, change: impl FnOnce(&mut UdpPolicy)) {
set_udp_policy_on(&crate::scope::here(), addr, change);
}
pub(crate) fn set_udp_policy_on(
shared: &crate::scope::SimShared,
addr: impl ToSocketAddrs,
change: impl FnOnce(&mut UdpPolicy),
) {
let addr = policy_addr(addr);
snare_interpose::real(|| shared.update_udp_policy(addr, change));
shared.kick();
}
pub(crate) struct Policies {
by_addr: Mutex<HashMap<SocketAddr, UdpPolicy>>,
tcp_by_addr: Mutex<HashMap<SocketAddr, TcpPolicy>>,
stalls: Mutex<HashMap<SocketAddr, Stall>>,
rng: Mutex<SplitMix64>,
}
#[derive(Clone, Default)]
#[cfg_attr(not(target_os = "macos"), derive(Copy))]
struct Stall {
receive_until: Option<Deadline>,
send_until: Option<Deadline>,
#[cfg(target_os = "macos")]
receive_history: Vec<StallWindow>,
#[cfg(target_os = "macos")]
send_history: Vec<StallWindow>,
}
#[cfg(target_os = "macos")]
#[derive(Clone, Copy)]
struct StallWindow {
since: Deadline,
until: Deadline,
}
#[cfg(target_os = "macos")]
fn replace_stall(history: &mut Vec<StallWindow>, since: Deadline, until: Deadline) {
if let Some(last) = history.last_mut()
&& last.until.instant() > since.instant()
{
last.until = since;
if last.until.instant() <= last.since.instant() {
history.pop();
}
}
if until.instant() > since.instant() {
history.push(StallWindow { since, until });
}
}
impl Policies {
pub(crate) fn with_seed(seed: u64) -> Self {
Policies {
by_addr: Mutex::default(),
tcp_by_addr: Mutex::default(),
stalls: Mutex::default(),
rng: Mutex::new(SplitMix64(seed)),
}
}
pub(crate) fn update(
&self,
addr: SocketAddr,
change: impl FnOnce(&mut UdpPolicy),
) -> UdpPolicy {
let mut by_addr = self.by_addr.lock().unwrap();
let policy = by_addr.entry(addr).or_default();
change(policy);
let policy = policy.clone();
if policy == UdpPolicy::default() {
by_addr.remove(&addr);
}
policy
}
pub(crate) fn deliveries(&self, to: SocketAddr, len: usize) -> (Delays, Option<LinkFault>) {
let Some(policy) = self.by_addr.lock().unwrap().get(&to).cloned() else {
return (Delays::one(Duration::ZERO), None);
};
if policy.mtu.is_some_and(|mtu| len > mtu) {
return (Delays::default(), Some(LinkFault::TooBig));
}
let mut rng = self.rng.lock().unwrap();
if policy.loss_rate > 0.0 && rng.unit() < policy.loss_rate {
return (Delays::default(), Some(LinkFault::Lost));
}
let duplicated = policy.duplicate_rate > 0.0 && rng.unit() < policy.duplicate_rate;
let delays = (0..if duplicated { 2 } else { 1 })
.map(|_| policy.latency + policy.jitter.mul_f64(rng.unit()))
.collect();
(delays, duplicated.then_some(LinkFault::Duplicated))
}
pub(crate) fn update_tcp(
&self,
addr: SocketAddr,
change: impl FnOnce(&mut TcpPolicy),
) -> TcpPolicy {
let mut by_addr = self.tcp_by_addr.lock().unwrap();
let policy = by_addr.entry(addr).or_default();
change(policy);
let policy = policy.clone();
if policy == TcpPolicy::default() {
by_addr.remove(&addr);
}
policy
}
pub(crate) fn tcp_delay(&self, a: SocketAddr, b: SocketAddr) -> Duration {
let by_addr = self.tcp_by_addr.lock().unwrap();
let Some(policy) = by_addr.get(&a).or_else(|| by_addr.get(&b)).cloned() else {
return Duration::ZERO;
};
drop(by_addr);
if policy.jitter.is_zero() {
return policy.latency;
}
policy.latency + policy.jitter.mul_f64(self.rng.lock().unwrap().unit())
}
pub(crate) fn recv_window(&self, addr: SocketAddr) -> Option<usize> {
self.tcp_by_addr.lock().unwrap().get(&addr)?.recv_window
}
pub(crate) fn udp_latency(&self, to: SocketAddr) -> Duration {
self.by_addr
.lock()
.unwrap()
.get(&to)
.map_or(Duration::ZERO, |p| p.latency)
}
#[cfg(not(target_os = "macos"))]
pub(crate) fn stall(&self, addr: SocketAddr, direction: Direction, until: Deadline) {
let mut stalls = self.stalls.lock().unwrap();
let stall = stalls.entry(addr).or_default();
if direction != Direction::Send {
stall.receive_until = Some(until);
}
if direction != Direction::Receive {
stall.send_until = Some(until);
}
}
#[cfg(target_os = "macos")]
pub(crate) fn stall_at(
&self,
addr: SocketAddr,
direction: Direction,
since: Deadline,
until: Deadline,
) {
let mut stalls = self.stalls.lock().unwrap();
let stall = stalls.entry(addr).or_default();
if direction != Direction::Send {
stall.receive_until = Some(until);
replace_stall(&mut stall.receive_history, since, until);
}
if direction != Direction::Receive {
stall.send_until = Some(until);
replace_stall(&mut stall.send_history, since, until);
}
}
#[cfg(target_os = "macos")]
pub(crate) fn held_until_on(
&self,
from: SocketAddr,
to: SocketAddr,
clock: Option<&crate::clock::Clock>,
) -> Option<Deadline> {
let stalls = self.stalls.lock().unwrap();
[
stalls.get(&to).and_then(|s| s.receive_until),
stalls.get(&from).and_then(|s| s.send_until),
]
.into_iter()
.flatten()
.filter(|at| !at.passed_on(clock))
.max_by_key(Deadline::instant)
}
#[cfg(target_os = "macos")]
pub(crate) fn effective_arrival(
&self,
from: SocketAddr,
to: SocketAddr,
mut at: Deadline,
) -> Deadline {
let stalls = self.stalls.lock().unwrap();
let mut send = stalls
.get(&from)
.into_iter()
.flat_map(|stall| &stall.send_history)
.peekable();
let mut receive = stalls
.get(&to)
.into_iter()
.flat_map(|stall| &stall.receive_history)
.peekable();
loop {
let window = match (send.peek(), receive.peek()) {
(Some(a), Some(b)) if a.since.instant() <= b.since.instant() => send.next(),
(Some(_), Some(_)) | (None, Some(_)) => receive.next(),
(Some(_), None) => send.next(),
(None, None) => break,
}
.expect("stall window");
if window.since.instant() > at.instant() {
break;
}
if window.until.instant() > at.instant() {
at = window.until;
}
}
at
}
#[cfg(not(target_os = "macos"))]
pub(crate) fn held_until(&self, from: SocketAddr, to: SocketAddr) -> Option<Deadline> {
let stalls = self.stalls.lock().unwrap();
if stalls.is_empty() {
return None;
}
[
stalls.get(&to).and_then(|s| s.receive_until),
stalls.get(&from).and_then(|s| s.send_until),
]
.into_iter()
.flatten()
.filter(|d| !d.passed())
.max_by_key(Deadline::instant)
}
pub(crate) fn held_until_pair(
&self,
from: SocketAddr,
to: SocketAddr,
bound: SocketAddr,
) -> Option<Deadline> {
let stalls = self.stalls.lock().unwrap();
if stalls.is_empty() {
return None;
}
[
stalls.get(&from).and_then(|s| s.send_until),
stalls.get(&to).and_then(|s| s.receive_until),
(bound != to)
.then(|| stalls.get(&bound).and_then(|s| s.receive_until))
.flatten(),
]
.into_iter()
.flatten()
.filter(|d| !d.passed())
.max_by_key(Deadline::instant)
}
pub(crate) fn unit(&self) -> f64 {
self.rng.lock().unwrap().unit()
}
pub(crate) fn jitter(&self, span: Duration) -> Duration {
if span.is_zero() {
return Duration::ZERO;
}
span.mul_f64(self.unit())
}
pub(crate) fn send_stalled(&self, from: SocketAddr) -> bool {
self.by_addr
.lock()
.unwrap()
.get(&from)
.is_some_and(|p| p.send_queue_depth == Some(0))
}
}
pub(crate) struct SplitMix64(pub(crate) u64);
impl SplitMix64 {
pub(crate) fn next_u64(&mut self) -> u64 {
self.0 = self.0.wrapping_add(0x9e37_79b9_7f4a_7c15);
let mut z = self.0;
z = (z ^ (z >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
z = (z ^ (z >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
z ^ (z >> 31)
}
fn unit(&mut self) -> f64 {
(self.next_u64() >> 11) as f64 / (1u64 << 53) as f64
}
}