#[cfg(feature = "security")]
use std::sync::OnceLock;
use std::{
collections::{BTreeMap, HashMap},
hash::{Hash, Hasher},
net::SocketAddr,
sync::{
Arc,
atomic::{AtomicU32, AtomicU64, Ordering},
},
time::{Duration, Instant, SystemTime},
};
use tokio::sync::oneshot;
use bytes::Bytes;
use parking_lot::{Mutex, RwLock};
#[cfg(feature = "security")]
use crate::security::SecureChannel;
use crate::cc::CongestionCtrl;
const MAX_SENT_FRAMES_PER_STREAM: usize = 1_024;
pub struct SentPacket {
pub frame: Bytes,
pub sent_at: Instant,
}
pub struct PeerState {
addr: Arc<RwLock<SocketAddr>>,
pub my_session_id: u64,
their_session_id: Mutex<Option<u64>>,
next_seqs: Mutex<HashMap<u16, u64>>,
pub sent: Mutex<HashMap<u16, BTreeMap<u64, SentPacket>>>,
pub last_sent: Mutex<Instant>,
pub last_seen: Mutex<Instant>,
pub cc: Mutex<CongestionCtrl>,
effective_mtu: AtomicU32,
pub probe_acks: Mutex<HashMap<u16, oneshot::Sender<()>>>,
#[cfg(feature = "security")]
pub handshake: Mutex<Option<snow::HandshakeState>>,
#[cfg(feature = "security")]
pub channel: OnceLock<SecureChannel>,
#[cfg(feature = "security")]
pub remote_static_key: OnceLock<[u8; 32]>,
#[cfg(feature = "security")]
pub channel_ready: tokio::sync::Notify,
pub rx_bytes: AtomicU64,
pub tx_bytes: AtomicU64,
pub retransmit_count: AtomicU64,
}
impl PeerState {
#[must_use]
pub fn new(addr: SocketAddr) -> Self {
let now = Instant::now();
Self {
addr: Arc::new(RwLock::new(addr)),
my_session_id: gen_session_id(),
their_session_id: Mutex::new(None),
next_seqs: Mutex::new(HashMap::new()),
sent: Mutex::new(HashMap::new()),
last_sent: Mutex::new(now),
last_seen: Mutex::new(now),
cc: Mutex::new(CongestionCtrl::new()),
effective_mtu: AtomicU32::new(0),
probe_acks: Mutex::new(HashMap::new()),
#[cfg(feature = "security")]
handshake: Mutex::new(None),
#[cfg(feature = "security")]
channel: OnceLock::new(),
#[cfg(feature = "security")]
remote_static_key: OnceLock::new(),
#[cfg(feature = "security")]
channel_ready: tokio::sync::Notify::new(),
rx_bytes: AtomicU64::new(0),
tx_bytes: AtomicU64::new(0),
retransmit_count: AtomicU64::new(0),
}
}
pub fn addr(&self) -> SocketAddr {
*self.addr.read()
}
pub fn addr_arc(&self) -> Arc<RwLock<SocketAddr>> {
self.addr.clone()
}
pub fn migrate_to(&self, new_addr: SocketAddr) {
*self.addr.write() = new_addr;
}
pub fn store_their_session_id(&self, id: u64) -> bool {
let mut guard = self.their_session_id.lock();
if guard.is_none() {
*guard = Some(id);
true
} else {
false
}
}
pub fn alloc_seq(&self, stream_id: u16) -> u64 {
let mut map = self.next_seqs.lock();
let counter = map.entry(stream_id).or_insert(1);
let seq = *counter;
*counter += 1;
seq
}
pub fn record_sent(&self, stream_id: u16, seq: u64, frame: Bytes) {
self.tx_bytes.fetch_add(frame.len() as u64, Ordering::Relaxed);
let mut map = self.sent.lock();
let stream_buf = map.entry(stream_id).or_default();
if stream_buf.len() >= MAX_SENT_FRAMES_PER_STREAM
&& let Some((evicted_seq, _)) = stream_buf.pop_first()
{
tracing::warn!(
target: "zudp::peer",
stream_id,
evicted_seq,
cap = MAX_SENT_FRAMES_PER_STREAM,
"sent buffer full — evicting oldest frame (NACK for it will not retransmit)"
);
}
stream_buf.insert(seq, SentPacket { frame, sent_at: Instant::now() });
drop(map);
*self.last_sent.lock() = Instant::now();
}
pub fn frames_for_retransmit(&self, stream_id: u16, seqs: &[u64]) -> Vec<(u64, Bytes)> {
let map = self.sent.lock();
let Some(stream_buf) = map.get(&stream_id) else {
return vec![];
};
let frames: Vec<(u64, Bytes)> = seqs
.iter()
.filter_map(|seq| stream_buf.get(seq).map(|p| (*seq, p.frame.clone())))
.collect();
self.retransmit_count
.fetch_add(frames.len() as u64, Ordering::Relaxed);
frames
}
pub fn prune_sent(&self, max_age: Duration) {
if let Some(cutoff) = Instant::now().checked_sub(max_age) {
let mut map = self.sent.lock();
for stream_buf in map.values_mut() {
stream_buf.retain(|_, p| p.sent_at > cutoff);
}
}
}
pub fn mark_seen(&self) {
*self.last_seen.lock() = Instant::now();
}
pub fn secs_since_sent(&self) -> u64 {
self.last_sent.lock().elapsed().as_secs()
}
pub fn effective_mtu_or(&self, default: usize) -> usize {
match self.effective_mtu.load(Ordering::Relaxed) {
0 => default,
v => v as usize,
}
}
pub fn set_effective_mtu(&self, mtu: usize) {
self.effective_mtu.store(mtu as u32, Ordering::Relaxed);
}
#[cfg(feature = "security")]
#[must_use]
pub fn remote_static_key(&self) -> Option<&[u8; 32]> {
self.remote_static_key.get()
}
}
fn gen_session_id() -> u64 {
use std::collections::hash_map::DefaultHasher;
static SEQ: AtomicU64 = AtomicU64::new(0);
let mut h = DefaultHasher::new();
SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap_or_default()
.hash(&mut h);
SEQ.fetch_add(1, Ordering::Relaxed).hash(&mut h);
let addr: u64 = (&h as *const _ as usize) as u64;
addr.hash(&mut h);
h.finish()
}
#[derive(Debug)]
pub enum Inbound {
Data(Bytes),
Fragment {
msg_id: u32,
frag_idx: u16,
frag_total: u16,
data: Bytes,
},
}
pub struct RecvState {
pub expected_seq: u64,
buf: BTreeMap<u64, Inbound>,
}
impl RecvState {
#[must_use]
pub fn new() -> Self {
Self {
expected_seq: 1,
buf: BTreeMap::new(),
}
}
pub fn ingest(&mut self, seq: u64, payload: Inbound) -> (Vec<Inbound>, Vec<u64>) {
if seq < self.expected_seq {
return (vec![], vec![]);
}
if seq > self.expected_seq {
let nack_seqs: Vec<u64> = (self.expected_seq..seq).collect();
self.buf.insert(seq, payload);
return (vec![], nack_seqs);
}
let mut ready = vec![payload];
self.expected_seq += 1;
while let Some(next) = self.buf.remove(&self.expected_seq) {
ready.push(next);
self.expected_seq += 1;
}
(ready, vec![])
}
}