snare 3.0.0

Ergonomic in-process network testing on top of snare-interpose: write the code under test against std, describe the peer with a tester builder
Documentation
use std::collections::VecDeque;

pub(crate) struct Segment {
    pub(crate) bytes: Vec<u8>,
    pub(crate) mss: usize,
    pub(crate) end: u64,
}

pub(crate) struct TcpTransport {
    pending: VecDeque<Vec<u8>>,
    offset: usize,
    pub(crate) written: u64,
    pub(crate) transmitted: u64,
    received: u64,
    window_end: u64,
    advertised: usize,
    max_window: usize,
    buffer: usize,
    ratio: usize,
    threshold: usize,
    clamp: usize,
    receive_mss: usize,
    advmss: usize,
    initial_mss: usize,
    initial_goal: usize,
    initial_pushes: usize,
    scale: usize,
    gso_max: usize,
    cwnd: usize,
}

impl TcpTransport {
    pub(crate) fn new(buffer: usize, mtu: u32, v6: bool, gso_size: usize) -> Self {
        let header = if v6 { 72 } else { 52 };
        let advmss = (mtu as usize).min(65535).saturating_sub(header).max(1);
        let gso_max = gso_size.saturating_sub(header).max(advmss);
        let space = buffer / 2;
        let mut advertised = if space > advmss {
            space / advmss * advmss
        } else {
            space
        };
        advertised = advertised.min(65535);
        let mut scale = 1;
        while buffer / 2 / scale > 65535 && scale < 128 {
            scale *= 2;
        }
        let initial_mss = advmss.min((advertised / 2).max(1));
        let initial_goal = initial_mss * (gso_max.min(advertised / 2) / initial_mss).max(1);
        Self {
            pending: VecDeque::new(),
            offset: 0,
            written: 0,
            transmitted: 0,
            received: 0,
            window_end: advertised as u64,
            advertised,
            max_window: advertised,
            buffer,
            ratio: 128,
            threshold: space,
            clamp: space,
            receive_mss: initial_goal.min(536),
            advmss,
            initial_mss,
            initial_goal,
            initial_pushes: 2,
            scale,
            gso_max,
            cwnd: 10,
        }
    }

    pub(crate) fn pending_bytes(&self) -> usize {
        self.pending.iter().map(Vec::len).sum::<usize>() - self.offset
    }

    pub(crate) fn push(&mut self, bytes: &[u8]) {
        self.pending.push_back(bytes.to_vec());
        self.written += bytes.len() as u64;
    }

    pub(crate) fn direct(&mut self, len: usize) -> Option<usize> {
        let mss = self.advmss.min((self.max_window / 2).max(1));
        if !self.pending.is_empty()
            || len > mss
            || len as u64 > self.window_end.saturating_sub(self.transmitted)
        {
            return None;
        }
        self.written += len as u64;
        self.transmitted += len as u64;
        Some(mss)
    }

    pub(crate) fn next(&mut self) -> Option<Segment> {
        let available = self.window_end.saturating_sub(self.transmitted) as usize;
        if available == 0 {
            return None;
        }
        let pending = self.pending_bytes();
        if pending == 0 {
            return None;
        }
        let mss = self.advmss.min((self.max_window / 2).max(1));
        let initial = self.initial_pushes > 0 && pending > self.initial_goal;
        let goal = if initial {
            self.initial_pushes -= 1;
            self.initial_goal
        } else {
            let quota = (self.cwnd / 2).max(1);
            let segments = (self.gso_max / mss).max(1).min(quota);
            mss * segments
        };
        let packet_mss = if initial { self.initial_mss } else { mss };
        let n = goal
            .min(packet_mss * (self.cwnd / 2).max(1))
            .min(available)
            .min(pending);
        let mut bytes = Vec::with_capacity(n);
        while bytes.len() < n {
            let front = self.pending.front().unwrap();
            let take = (n - bytes.len()).min(front.len() - self.offset);
            bytes.extend_from_slice(&front[self.offset..self.offset + take]);
            self.offset += take;
            if self.offset == front.len() {
                self.pending.pop_front();
                self.offset = 0;
            }
        }
        self.transmitted += n as u64;
        Some(Segment {
            bytes,
            mss: packet_mss,
            end: self.transmitted,
        })
    }

    pub(crate) fn arrive(&mut self, len: usize, mss: usize, memory: usize, head: usize) {
        let measured = len.min(mss);
        let previous_mss = self.receive_mss;
        let previous_threshold = self.threshold;
        if measured >= self.receive_mss {
            if measured != self.receive_mss {
                self.ratio = (len.saturating_mul(256) / (len + head)).max(1);
                self.clamp = self.buffer.saturating_mul(self.ratio) / 256;
            }
            self.receive_mss = measured.min(self.advmss);
        }
        if len >= 128 {
            let free = self.buffer.saturating_sub(memory) * self.ratio / 256;
            let room = self.clamp.min(free).saturating_sub(self.threshold);
            self.threshold += room.min((2 * self.advmss).max(2 * len));
        }
        self.received += len as u64;
        if self.receive_mss != previous_mss || self.threshold != previous_threshold {
            self.advertise(memory);
        } else {
            self.advertised = self.window_end.saturating_sub(self.received) as usize;
        }
    }

    pub(crate) fn advertise(&mut self, memory: usize) {
        let allowed = self.buffer.saturating_mul(self.ratio) / 256;
        let full = self.clamp.min(allowed);
        let mss = self.receive_mss.min(full).max(1);
        let mut free = self.buffer.saturating_sub(memory) * self.ratio / 256;
        if free < full / 2 && (free < allowed / 16 || free < mss) {
            free = 0;
        }
        free = free.min(self.threshold);
        let window = if self.scale > 1 {
            free.div_ceil(self.scale) * self.scale
        } else if self.advertised > free || self.advertised <= free.saturating_sub(mss) {
            free / mss * mss
        } else {
            self.advertised
        };
        let end = self.received + window as u64;
        if end.saturating_sub(self.window_end) >= mss.min(allowed / 2).max(1) as u64 {
            self.window_end = end;
        }
        self.advertised = self.window_end.saturating_sub(self.received) as usize;
        self.max_window = self.max_window.max(self.advertised);
    }
}