use std::collections::VecDeque;
use std::ffi::c_int;
use std::io;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs};
use std::sync::Arc;
use std::time::{Duration, Instant};
use crate::HashMap;
use crate::events::{Direction, Fault, RecordedEvent};
use crate::netif::{Presence, Sender};
use crate::pcapng::TcpTap;
use crate::readiness::Deadline;
use crate::scope::{self, SimShared};
use crate::sockets::{ErrorOrigin, SockOpts, SockRec, SocketKind};
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum ListenerBehavior {
#[default]
Accepting,
Refusing,
DelayingUntil(Instant),
}
#[derive(Clone, Copy)]
pub(crate) enum Behavior {
Accepting,
Refusing,
Delaying(Deadline),
}
impl Behavior {
fn here(behavior: ListenerBehavior) -> Self {
Self::convert(behavior, Deadline::timeout)
}
fn on(shared: &SimShared, behavior: ListenerBehavior) -> Self {
let mine = scope::try_here().is_some_and(|here| std::ptr::eq(&*here, shared));
if mine {
return Self::here(behavior);
}
Self::convert(behavior, |span| {
Deadline::on_clock(shared.clock.as_deref(), span)
})
}
fn convert(behavior: ListenerBehavior, deadline: impl FnOnce(Duration) -> Deadline) -> Self {
match behavior {
ListenerBehavior::Accepting => Behavior::Accepting,
ListenerBehavior::Refusing => Behavior::Refusing,
ListenerBehavior::DelayingUntil(until) => {
Behavior::Delaying(deadline(until.saturating_duration_since(Instant::now())))
}
}
}
}
#[track_caller]
pub fn set_listener_behavior(addr: impl ToSocketAddrs, behavior: ListenerBehavior) {
let shared = scope::here();
let addrs = resolve(addr);
shared.set_listener_behavior(&addrs, Behavior::here(behavior));
}
pub(crate) fn set_listener_behavior_on(
shared: &SimShared,
addr: impl ToSocketAddrs,
behavior: ListenerBehavior,
) {
let addrs = resolve(addr);
shared.set_listener_behavior(&addrs, Behavior::on(shared, behavior));
}
#[track_caller]
fn resolve(addr: impl ToSocketAddrs) -> Vec<SocketAddr> {
addr.to_socket_addrs()
.expect("fault address must parse")
.collect()
}
#[track_caller]
pub fn raise_socket_error(addr: impl ToSocketAddrs, error: io::Error) {
let shared = scope::here();
shared.raise_socket_error(&resolve(addr), socket_errno(&error));
}
#[track_caller]
pub fn inject_icmp_port_unreachable(to: impl ToSocketAddrs, from: impl ToSocketAddrs) {
let shared = scope::here();
let from = resolve(from)
.into_iter()
.next()
.expect("fault address resolved to nothing");
shared.inject_icmp(&resolve(to), from);
}
#[track_caller]
pub fn quiesce(addr: impl ToSocketAddrs, span: Duration, direction: Direction) {
let shared = scope::here();
shared.quiesce(&resolve(addr), span, direction);
}
pub(crate) fn raise_socket_error_on(
shared: &SimShared,
addr: impl ToSocketAddrs,
error: io::Error,
) {
shared.raise_socket_error(&resolve(addr), socket_errno(&error));
}
pub(crate) fn inject_icmp_on(shared: &SimShared, to: impl ToSocketAddrs, from: impl ToSocketAddrs) {
let from = resolve(from)
.into_iter()
.next()
.expect("fault address resolved to nothing");
shared.inject_icmp(&resolve(to), from);
}
pub(crate) fn quiesce_on(
shared: &SimShared,
addr: impl ToSocketAddrs,
span: Duration,
direction: Direction,
) {
shared.quiesce(&resolve(addr), span, direction);
}
#[track_caller]
pub(crate) fn socket_errno(error: &io::Error) -> c_int {
if let Some(code) = error.raw_os_error() {
return code;
}
use io::ErrorKind as K;
match error.kind() {
K::ConnectionReset => code::ECONNRESET,
K::ConnectionAborted => code::ECONNABORTED,
K::ConnectionRefused => code::ECONNREFUSED,
K::TimedOut => code::ETIMEDOUT,
K::BrokenPipe => code::EPIPE,
K::NotConnected => code::ENOTCONN,
K::NetworkUnreachable => code::ENETUNREACH,
K::HostUnreachable => code::EHOSTUNREACH,
K::NetworkDown => code::ENETDOWN,
K::AddrNotAvailable => code::EADDRNOTAVAIL,
kind => panic!("no socket error code for {kind:?}"),
}
}
impl SimShared {
pub(crate) fn deadline_after(&self, span: Duration) -> Deadline {
if self.is_here() {
snare_interpose::real(|| Deadline::after(span))
} else {
Deadline::on_clock(self.clock.as_deref(), span)
}
}
pub(crate) fn wake_at(&self, at: Deadline) {
snare_interpose::real(|| {
if self.is_here() {
at.wake_waiters_then();
} else {
at.wake_waiters_on(self.clock.as_deref());
}
});
}
fn is_here(&self) -> bool {
scope::try_here().is_some_and(|here| std::ptr::eq(&*here, self))
}
pub(crate) fn raise_socket_error(&self, addrs: &[SocketAddr], errno: c_int) {
let keys = snare_interpose::real(|| {
let mut keys = crate::readiness::WakeKeys::default();
for rec in self.sockets.live_recs() {
let state = rec.state();
let at = |a: Option<SocketAddr>| a.is_some_and(|a| addrs.contains(&a));
let hit = matches!(state.kind, SocketKind::TcpStream | SocketKind::Udp)
&& (at(state.local) || at(state.peer));
drop(state);
if hit {
rec.raise_error(errno, ErrorOrigin::Raised, None);
keys.push(rec.wake_key());
}
}
keys
});
self.kick_keys(keys.as_slice());
}
pub(crate) fn inject_icmp(&self, to: &[SocketAddr], from: SocketAddr) {
let keys = snare_interpose::real(|| {
let mut keys = crate::readiness::WakeKeys::default();
for rec in self.sockets.live_recs() {
let local = rec.state().local;
let bound_at = local.and_then(|l| {
to.iter().copied().find(|t| {
*t == l
|| (l.ip().is_unspecified()
&& l.port() == t.port()
&& l.is_ipv4() == t.is_ipv4())
})
});
if let Some(at) = bound_at
&& rec.kind() == SocketKind::Udp
{
self.capture_icmp(&Sender::Station(from.ip()), at, from, &[], Duration::ZERO);
self.icmp_to(&rec, from, None, &[]);
keys.push(rec.wake_key());
}
}
keys
});
self.kick_keys(keys.as_slice());
}
pub(crate) fn icmp_to(
&self,
rec: &SockRec,
from: SocketAddr,
arrives: Option<Deadline>,
payload: &[u8],
) {
let (peer, opts) = {
let state = rec.state();
(state.peer, state.dgram)
};
let connected = match peer {
Some(peer) if peer != from => return,
Some(_) => true,
None => false,
};
let taken = if cfg!(target_os = "linux") {
connected || opts.recverr
} else if cfg!(windows) {
opts.connreset
} else {
connected
};
if cfg!(target_os = "linux") && opts.recverr {
rec.queue_icmp_report(code::ECONNREFUSED, from, arrives, payload);
}
if taken {
rec.raise_error(code::ICMP_UNREACH, ErrorOrigin::Icmp { from }, arrives);
}
}
pub(crate) fn unreachable_port(
&self,
rec: &Arc<SockRec>,
sender: &Sender,
src: SocketAddr,
dest: SocketAddr,
data: &[u8],
station: bool,
) {
self.count_unreceived(dest, station);
let Some(nic) = self.icmp_one_way(sender, dest.ip(), station) else {
return;
};
let one_way = nic + self.policies.udp_latency(dest);
self.capture_icmp(sender, src, dest, data, one_way);
let round_trip = one_way * 2;
let arrives = (!round_trip.is_zero()).then(|| Deadline::after(round_trip));
if let Some(arrives) = arrives {
arrives.wake_waiters_then();
}
self.icmp_to(rec, dest, arrives, data);
}
pub(crate) fn quiesce(&self, addrs: &[SocketAddr], span: Duration, direction: Direction) {
#[cfg(target_os = "macos")]
let since = self.deadline_after(Duration::ZERO);
let until = self.deadline_after(span);
snare_interpose::real(|| {
for &addr in addrs {
#[cfg(target_os = "macos")]
self.policies.stall_at(addr, direction, since, until);
#[cfg(not(target_os = "macos"))]
self.policies.stall(addr, direction, until);
self.record(RecordedEvent::Fault {
addr: Some(addr),
fault: Fault::Stalled { span, direction },
});
}
#[cfg(target_os = "macos")]
for rec in self.sockets.live_recs() {
rec.land();
}
});
self.wake_at(until);
self.kick();
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Syn {
Accept,
Rst,
Silent,
Absent { on_link: bool },
}
impl SimShared {
pub(crate) fn set_listener_behavior(&self, addrs: &[SocketAddr], behavior: Behavior) {
snare_interpose::real(|| {
let mut table = self.listener_behavior.lock().unwrap();
for &addr in addrs {
match behavior {
Behavior::Accepting => table.remove(&addr),
_ => table.insert(addr, behavior),
};
}
});
}
fn behavior_at(&self, dest: SocketAddr) -> Behavior {
snare_interpose::real(|| {
let table = self.listener_behavior.lock().unwrap();
let wildcard = SocketAddr::new(unspecified_like(dest.ip()), dest.port());
table
.get(&dest)
.or_else(|| table.get(&wildcard))
.copied()
.unwrap_or(Behavior::Accepting)
})
}
pub(crate) fn syn_probe(&self, dest: SocketAddr, listening: bool, station: bool) -> Syn {
match self.behavior_at(dest) {
Behavior::Refusing => return Syn::Rst,
Behavior::Delaying(until) if !until.passed() => return Syn::Silent,
_ => {}
}
if listening {
return Syn::Accept;
}
let (presence, on_link) = self.syn_target(dest.ip(), station);
match presence {
Presence::Absent => Syn::Absent { on_link },
_ => Syn::Rst,
}
}
pub(crate) fn syn_plan(&self, opts: &SockOpts, first: Syn) -> SynPlan {
let mut plan = base_plan(self, opts);
if let (Syn::Absent { on_link: true }, Some((at, errno))) = (first, NEIGHBOUR_FAILURE)
&& at < plan.give_up
{
plan.give_up = at;
plan.errno = errno;
plan.retransmits.retain(|t| *t < at);
}
plan
}
pub(crate) fn connect_settled(&self, dest: SocketAddr, outcome: Outcome, waited: bool) {
if matches!(outcome, Outcome::Failed(_)) {
crate::netstats::bump(&self.stats.tcp(dest.ip()).attempt_fails);
}
let fault = match outcome {
Outcome::Connected if waited => Fault::ConnectDelayed {
until: self.stamp(),
},
Outcome::Connected => return,
Outcome::Failed(errno) if errno == code::ECONNREFUSED => {
if !matches!(self.behavior_at(dest), Behavior::Refusing) {
return;
}
Fault::ConnectRefused
}
Outcome::Failed(errno) if errno == code::ETIMEDOUT => Fault::ConnectTimedOut,
Outcome::Failed(errno) => Fault::Unreachable { errno },
};
self.record(RecordedEvent::Fault {
addr: Some(dest),
fault,
});
}
}
fn unspecified_like(ip: IpAddr) -> IpAddr {
match ip {
IpAddr::V4(_) => Ipv4Addr::UNSPECIFIED.into(),
IpAddr::V6(_) => Ipv6Addr::UNSPECIFIED.into(),
}
}
#[cfg(unix)]
pub(crate) mod code {
pub(crate) const ECONNREFUSED: i32 = libc::ECONNREFUSED;
pub(crate) const ETIMEDOUT: i32 = libc::ETIMEDOUT;
pub(crate) const EHOSTUNREACH: i32 = libc::EHOSTUNREACH;
pub(crate) const ECONNRESET: i32 = libc::ECONNRESET;
pub(crate) const ECONNABORTED: i32 = libc::ECONNABORTED;
pub(crate) const EPIPE: i32 = libc::EPIPE;
pub(crate) const ENOTCONN: i32 = libc::ENOTCONN;
pub(crate) const ENETUNREACH: i32 = libc::ENETUNREACH;
pub(crate) const ENETDOWN: i32 = libc::ENETDOWN;
pub(crate) const EADDRNOTAVAIL: i32 = libc::EADDRNOTAVAIL;
pub(crate) const ICMP_UNREACH: i32 = libc::ECONNREFUSED;
}
#[cfg(windows)]
pub(crate) mod code {
pub(crate) const ECONNREFUSED: i32 = 10061;
pub(crate) const ETIMEDOUT: i32 = 10060;
pub(crate) const EHOSTUNREACH: i32 = 10065;
pub(crate) const ECONNRESET: i32 = 10054;
pub(crate) const ECONNABORTED: i32 = 10053;
pub(crate) const EPIPE: i32 = 10058;
pub(crate) const ENOTCONN: i32 = 10057;
pub(crate) const ENETUNREACH: i32 = 10051;
pub(crate) const ENETDOWN: i32 = 10050;
pub(crate) const EADDRNOTAVAIL: i32 = 10049;
pub(crate) const ICMP_UNREACH: i32 = 10054;
}
#[cfg(target_os = "linux")]
const NEIGHBOUR_FAILURE: Option<(Duration, c_int)> =
Some((Duration::from_secs(3), code::EHOSTUNREACH));
#[cfg(not(target_os = "linux"))]
const NEIGHBOUR_FAILURE: Option<(Duration, c_int)> = None;
#[cfg(target_os = "linux")]
const LINUX_RTO_INIT: Duration = Duration::from_secs(1);
#[cfg(target_os = "linux")]
const LINUX_RTO_MAX: Duration = Duration::from_secs(120);
#[cfg(target_os = "macos")]
const MACOS_SYN_BACKOFF: [u64; 11] = [1, 1, 1, 1, 1, 2, 4, 8, 16, 32, 64];
#[cfg(target_os = "macos")]
const MACOS_KEEPINIT: Duration = Duration::from_secs(75);
#[cfg(windows)]
const WINDOWS_INITIAL_RTO: Duration = Duration::from_secs(3);
#[cfg(windows)]
const WINDOWS_MAX_SYN_RETRANSMISSIONS: u32 = 2;
#[cfg(windows)]
pub(crate) const WINDOWS_REFUSED_AFTER: Duration = Duration::from_secs(2);
#[cfg(windows)]
const WINDOWS_REFUSED_RETRY: Duration = Duration::from_millis(500);
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct SynPlan {
pub(crate) retransmits: Vec<Duration>,
pub(crate) give_up: Duration,
pub(crate) errno: c_int,
#[cfg(windows)]
repeat_rto: Option<Duration>,
}
impl SynPlan {
#[cfg_attr(target_os = "macos", allow(dead_code))]
fn doubling(rto: Duration, cap: Duration, retries: u32) -> Self {
let mut at = Duration::ZERO;
let mut rto = rto;
let mut retransmits = Vec::new();
for _ in 0..retries {
at += rto;
retransmits.push(at);
rto = (rto * 2).min(cap);
}
SynPlan {
retransmits,
give_up: at + rto,
errno: code::ETIMEDOUT,
#[cfg(windows)]
repeat_rto: None,
}
}
}
#[cfg(target_os = "linux")]
fn base_plan(shared: &SimShared, opts: &SockOpts) -> SynPlan {
let retries = opts
.syncnt
.unwrap_or_else(|| shared.sys.limits().tcp_syn_retries);
linux_plan(retries, shared.sys.limits().tcp_syn_linear_timeouts)
}
#[cfg(target_os = "linux")]
fn linux_plan(retries: u8, linear: u8) -> SynPlan {
let elapsed_limit = SynPlan::doubling(LINUX_RTO_INIT, LINUX_RTO_MAX, retries.into()).give_up;
let mut at = Duration::ZERO;
let mut rto = LINUX_RTO_INIT;
let mut retransmits = Vec::new();
for retry in 0..=u32::from(retries) + u32::from(linear) {
at += rto;
if at >= elapsed_limit || retry == u32::from(retries) + u32::from(linear) {
break;
}
retransmits.push(at);
if retry >= u32::from(linear) {
rto = (rto * 2).min(LINUX_RTO_MAX);
}
}
SynPlan {
retransmits,
give_up: at,
errno: code::ETIMEDOUT,
}
}
#[cfg(target_os = "macos")]
fn base_plan(_shared: &SimShared, opts: &SockOpts) -> SynPlan {
macos_plan(opts.connect_give_up.unwrap_or(MACOS_KEEPINIT))
}
#[cfg(target_os = "macos")]
fn macos_plan(give_up: Duration) -> SynPlan {
let retransmits = MACOS_SYN_BACKOFF
.iter()
.scan(Duration::ZERO, |at, &k| {
*at += Duration::from_secs(k);
Some(*at)
})
.take_while(|at| *at < give_up)
.collect();
SynPlan {
retransmits,
give_up,
errno: code::ETIMEDOUT,
}
}
#[cfg(windows)]
fn base_plan(_shared: &SimShared, opts: &SockOpts) -> SynPlan {
let mut plan = SynPlan::doubling(
WINDOWS_INITIAL_RTO,
Duration::MAX,
WINDOWS_MAX_SYN_RETRANSMISSIONS,
);
if let Some(give_up) = opts.connect_give_up {
if give_up > plan.give_up {
plan.repeat_rto = Some(Duration::from_secs(12));
}
plan.give_up = give_up;
plan.retransmits.retain(|t| *t < give_up);
}
plan
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Outcome {
Connected,
Failed(c_int),
}
#[derive(Clone, Copy)]
enum Event {
RefuseCheck,
#[cfg(windows)]
RefuseRetry,
Retransmit,
GiveUp,
}
pub(crate) struct ConnectAttempt {
pub(crate) client: SocketAddr,
tap: Option<TcpTap>,
retransmits: VecDeque<Deadline>,
#[cfg(windows)]
repeat_rto: Option<Duration>,
#[cfg(windows)]
dynamic_retransmit: bool,
#[cfg(windows)]
dynamic_timer: Option<u64>,
give_up: Deadline,
errno: c_int,
refuse_at: Option<Deadline>,
#[cfg(windows)]
refuse_retries: VecDeque<Deadline>,
settled_at: Option<Deadline>,
accepted: Option<TcpTap>,
armed: bool,
timers: Vec<u64>,
}
impl ConnectAttempt {
pub(crate) fn start(
plan: &SynPlan,
first: Syn,
client: SocketAddr,
tap: Option<TcpTap>,
) -> Result<Self, Outcome> {
let now = Deadline::timeout(Duration::ZERO);
if let Some(tap) = &tap {
tap.syn();
}
let mut attempt = ConnectAttempt {
client,
tap,
retransmits: plan.retransmits.iter().map(|&t| now.later(t)).collect(),
#[cfg(windows)]
repeat_rto: plan.repeat_rto,
#[cfg(windows)]
dynamic_retransmit: false,
#[cfg(windows)]
dynamic_timer: None,
give_up: now.later(plan.give_up),
errno: plan.errno,
refuse_at: None,
#[cfg(windows)]
refuse_retries: VecDeque::new(),
settled_at: None,
accepted: None,
armed: false,
timers: Vec::new(),
};
if let Some(outcome) = attempt.react(now, first) {
return Err(outcome);
}
if let Some(tap) = &attempt.tap {
tap.syn_plan(&plan.retransmits);
}
#[allow(unused_mut)]
let mut points: Vec<Deadline> = attempt
.retransmits
.iter()
.copied()
.chain((plan.give_up != Duration::MAX).then_some(attempt.give_up))
.chain(attempt.refuse_at)
.collect();
#[cfg(windows)]
points.extend(attempt.refuse_retries.iter().copied());
attempt.timers = points.iter().filter_map(Deadline::arm).collect();
attempt.armed = true;
Ok(attempt)
}
#[cfg_attr(not(windows), allow(unused_variables))]
fn react(&mut self, at: Deadline, syn: Syn) -> Option<Outcome> {
if let (Syn::Rst, Some(tap)) = (syn, &self.tap) {
tap.refused(at.overdue());
}
match syn {
Syn::Accept => Some(Outcome::Connected),
#[cfg(windows)]
Syn::Rst => {
if self.refuse_at.is_none() {
let refuse_at = at.later(WINDOWS_REFUSED_AFTER);
self.refuse_at = Some(refuse_at);
self.refuse_retries = (1..4)
.map(|retry| at.later(WINDOWS_REFUSED_RETRY * retry))
.collect();
if self.armed {
self.timers.extend(refuse_at.arm());
self.timers
.extend(self.refuse_retries.iter().filter_map(Deadline::arm));
}
}
None
}
#[cfg(unix)]
Syn::Rst => Some(Outcome::Failed(code::ECONNREFUSED)),
Syn::Silent | Syn::Absent { .. } => None,
}
}
fn next(&self) -> (Deadline, Event) {
[
(self.refuse_at, Event::RefuseCheck),
#[cfg(windows)]
(self.refuse_retries.front().copied(), Event::RefuseRetry),
(self.retransmits.front().copied(), Event::Retransmit),
(Some(self.give_up), Event::GiveUp),
]
.into_iter()
.filter_map(|(at, event)| Some((at?, event)))
.min_by_key(|(at, _)| at.instant())
.expect("an attempt always has a give-up point")
}
pub(crate) fn due(&self) -> bool {
self.next().0.passed()
}
pub(crate) fn poll(&mut self, mut probe: impl FnMut() -> Syn) -> Result<Deadline, Outcome> {
loop {
let (at, event) = self.next();
if !at.passed() {
return Ok(at);
}
let outcome = match event {
#[cfg(windows)]
Event::RefuseRetry => {
self.refuse_retries.pop_front();
if let Some(tap) = &self.tap {
tap.resend_syn(at.overdue());
}
self.react(at, probe())
}
Event::RefuseCheck => {
self.refuse_at = None;
if let Some(tap) = &self.tap {
tap.resend_syn(at.overdue());
}
match probe() {
Syn::Rst => {
if let Some(tap) = &self.tap {
tap.refused(at.overdue());
}
Some(Outcome::Failed(code::ECONNREFUSED))
}
syn => self.react(at, syn),
}
}
Event::Retransmit => {
#[cfg(windows)]
if self.dynamic_retransmit
&& let Some(tap) = &self.tap
{
tap.resend_syn(at.overdue());
}
self.retransmits.pop_front();
#[cfg(windows)]
if self.retransmits.is_empty()
&& let Some(rto) = self.repeat_rto
{
let next = at.later(rto);
if next.instant() < self.give_up.instant() {
self.retransmits.push_back(next);
self.dynamic_timer = next.arm();
self.dynamic_retransmit = true;
self.repeat_rto = Some((rto * 2).min(Duration::from_secs(60)));
}
}
self.react(at, probe())
}
Event::GiveUp => Some(Outcome::Failed(self.errno)),
};
match outcome {
Some(outcome) => {
if let Some(tap) = self.tap.take() {
match outcome {
Outcome::Connected => self.accepted = Some(tap),
Outcome::Failed(_) => tap.failed(at.overdue()),
}
}
self.settled_at = Some(at);
self.disarm();
return Err(outcome);
}
None => {
if let Some(tap) = &self.tap {
tap.confirm_plan(at.overdue());
}
}
}
}
}
pub(crate) fn established(&mut self, conn: Option<&TcpTap>) {
self.accepted = None;
if let Some(tap) = conn {
let ago = self.settled_at.map_or(Duration::ZERO, |at| at.overdue());
tap.open(true, ago);
}
}
fn disarm(&mut self) {
#[cfg(windows)]
if let Some(key) = self.dynamic_timer.take() {
snare_interpose::unregister_event_timer(key);
}
for key in self.timers.drain(..) {
snare_interpose::unregister_event_timer(key);
}
}
}
impl Drop for ConnectAttempt {
fn drop(&mut self) {
if let Some(tap) = self.tap.take().or_else(|| self.accepted.take()) {
tap.failed(Duration::ZERO);
}
self.disarm();
}
}
pub(crate) mod sockopt {
use std::ffi::c_int;
#[cfg(not(target_os = "linux"))]
use std::time::Duration;
use crate::scope::SimShared;
use crate::sockets::SockRec;
#[cfg(target_os = "linux")]
const NAME: c_int = libc::TCP_SYNCNT;
#[cfg(target_os = "macos")]
const NAME: c_int = 0x20;
#[cfg(windows)]
const NAME: c_int = 5;
#[cfg(target_os = "linux")]
const MAX_TCP_SYNCNT: c_int = 127;
#[cfg(unix)]
const EINVAL: c_int = libc::EINVAL;
#[cfg(unix)]
const SHORT: c_int = EINVAL;
#[cfg(windows)]
const SHORT: c_int = 10014;
pub(crate) unsafe fn set(
rec: &SockRec,
name: c_int,
val: *const u8,
len: u32,
) -> Option<Result<(), c_int>> {
if name != NAME {
return None;
}
if val.is_null() || (len as usize) < size_of::<c_int>() {
return Some(Err(SHORT));
}
let v = unsafe { val.cast::<c_int>().read_unaligned() };
let mut state = rec.state();
#[cfg(target_os = "linux")]
{
if !(1..=MAX_TCP_SYNCNT).contains(&v) {
return Some(Err(EINVAL));
}
state.opts.syncnt = Some(v as u8);
}
#[cfg(target_os = "macos")]
{
if v < 0 {
return Some(Err(EINVAL));
}
state.opts.connect_give_up = (v > 0).then(|| Duration::from_secs(v as u64));
}
#[cfg(windows)]
{
state.opts.connect_give_up = match v {
0 => None,
v if v < 0 => Some(Duration::MAX),
v => Some(Duration::from_secs(v as u64)),
};
}
Some(Ok(()))
}
#[cfg_attr(not(target_os = "linux"), allow(unused_variables))]
pub(crate) fn get(shared: &SimShared, rec: &SockRec, name: c_int) -> Option<c_int> {
if name != NAME {
return None;
}
let opts = rec.opts();
#[cfg(target_os = "linux")]
let value = opts
.syncnt
.unwrap_or_else(|| shared.sys.limits().tcp_syn_retries)
.into();
#[cfg(not(target_os = "linux"))]
let value = opts
.connect_give_up
.map_or(0, |d| d.as_secs().min(c_int::MAX as u64) as c_int);
Some(value)
}
}
pub(crate) type BehaviorTable = std::sync::Mutex<HashMap<SocketAddr, Behavior>>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
#[cfg(target_os = "linux")]
fn linux_plan_doubles_to_127_s() {
let plan = SynPlan::doubling(LINUX_RTO_INIT, LINUX_RTO_MAX, 6);
let secs: Vec<u64> = plan.retransmits.iter().map(Duration::as_secs).collect();
assert_eq!(secs, [1, 3, 7, 15, 31, 63]);
assert_eq!(plan.give_up, Duration::from_secs(127));
let capped = SynPlan::doubling(LINUX_RTO_INIT, LINUX_RTO_MAX, 8);
assert_eq!(capped.give_up, Duration::from_secs(367));
}
#[test]
#[cfg(target_os = "linux")]
fn linux_linear_plan_obeys_both_retry_limits() {
let plan = linux_plan(6, 4);
assert_eq!(
plan.retransmits
.iter()
.map(Duration::as_secs)
.collect::<Vec<_>>(),
[1, 2, 3, 4, 5, 7, 11, 19, 35, 67]
);
assert_eq!(plan.give_up, Duration::from_secs(131));
assert_eq!(
linux_plan(6, 0),
SynPlan::doubling(LINUX_RTO_INIT, LINUX_RTO_MAX, 6)
);
let short = linux_plan(1, 4);
assert_eq!(
short.retransmits,
[Duration::from_secs(1), Duration::from_secs(2)]
);
assert_eq!(short.give_up, Duration::from_secs(3));
assert_eq!(linux_plan(2, 4).give_up, Duration::from_secs(7));
}
#[test]
#[cfg(target_os = "macos")]
fn macos_plan_backs_off_to_keepinit() {
let plan = macos_plan(MACOS_KEEPINIT);
let secs: Vec<u64> = plan.retransmits.iter().map(Duration::as_secs).collect();
assert_eq!(secs, [1, 2, 3, 4, 5, 7, 11, 19, 35, 67]);
assert_eq!(plan.give_up, Duration::from_secs(75));
}
#[test]
#[cfg(windows)]
fn windows_plan_gives_up_at_21_s() {
let plan = SynPlan::doubling(
WINDOWS_INITIAL_RTO,
Duration::MAX,
WINDOWS_MAX_SYN_RETRANSMISSIONS,
);
assert_eq!(
plan.retransmits,
[Duration::from_secs(3), Duration::from_secs(9)]
);
assert_eq!(plan.give_up, Duration::from_secs(21));
}
}