use std::{
collections::HashMap,
net::SocketAddr,
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
time::Duration,
};
use bytes::{Bytes, BytesMut};
use dashmap::DashMap;
use parking_lot::{Mutex, RwLock};
use tokio::{sync::mpsc, task::JoinSet, time};
use crate::{
Config,
frag::FragAssembler,
frame::Frame,
peer::{Inbound, PeerState, RecvState},
socket::RawSocket,
};
pub struct RelayPolicy {
pub allowlist: Vec<std::net::IpAddr>,
pub max_entries: usize,
}
const MAX_RETRANSMIT_TASKS: usize = 32;
const INBOUND_CAP: usize = 8_192;
pub(crate) struct EngineInner {
pub socket: RwLock<RawSocket>,
pub peers: DashMap<SocketAddr, Arc<PeerState>>,
pub sessions: DashMap<u64, Arc<PeerState>>,
pub config: Arc<Config>,
#[cfg(feature = "security")]
pub keypair: Option<crate::security::Keypair>,
pub shutdown_reason: Mutex<Option<String>>,
pub dropped_rate_limited: AtomicU64,
pub dropped_peer_cap: AtomicU64,
pub dropped_relay_blocked: AtomicU64,
pub dropped_relay_cap: AtomicU64,
pub relay_policy: RwLock<RelayPolicy>,
}
impl EngineInner {
pub fn get_socket(&self) -> RawSocket {
self.socket.read().clone()
}
pub fn get_or_create_peer(self: &Arc<Self>, addr: SocketAddr) -> Arc<PeerState> {
if let Some(p) = self.peers.get(&addr) {
return p.value().clone();
}
if self.peers.len() >= self.config.max_peers {
let evict_addr = self.peers.iter()
.min_by_key(|r| *r.value().last_seen.lock())
.map(|r| *r.key());
if let Some(evict) = evict_addr {
tracing::warn!(
target: "zudp::engine",
evicted = %evict,
new = %addr,
"peer table full — evicting least-recently-seen peer"
);
self.peers.remove(&evict);
}
self.dropped_peer_cap.fetch_add(1, Ordering::Relaxed);
}
self.peers.entry(addr)
.or_insert_with(|| Arc::new(PeerState::new(addr)))
.value()
.clone()
}
}
pub(crate) fn spawn(
inner: Arc<EngineInner>,
shutdown_rx: tokio::sync::oneshot::Receiver<()>,
) -> mpsc::Receiver<(Bytes, SocketAddr, u16)> {
let (inbound_tx, inbound_rx) = mpsc::channel(INBOUND_CAP);
tokio::spawn(run(inner, inbound_tx, shutdown_rx));
inbound_rx
}
async fn run(
inner: Arc<EngineInner>,
inbound_tx: mpsc::Sender<(Bytes, SocketAddr, u16)>,
mut shutdown_rx: tokio::sync::oneshot::Receiver<()>,
) {
let mut recv_states: HashMap<(SocketAddr, u16), (RecvState, FragAssembler)> = HashMap::new();
let mut relay_table: HashMap<SocketAddr, (SocketAddr, u32)> = HashMap::new();
let mut relay_gen: u32 = 0;
let relay_ttl_ticks = {
let tick_secs = inner.config.keepalive_interval.as_secs_f64() / 4.0;
(300.0_f64 / tick_secs).ceil() as u32
};
let keepalive_interval = inner.config.keepalive_interval;
let sent_prune_age = inner.config.sent_prune_age;
let mut rate_limiter = crate::rate::RateLimiter::new(
inner.config.max_pps_per_ip,
(inner.config.max_pps_per_ip / 5.0).max(1.0),
);
let mut retransmit_tasks: JoinSet<()> = JoinSet::new();
let mut recv_sock = inner.get_socket();
let mut ticker = time::interval(keepalive_interval / 4);
loop {
while retransmit_tasks.try_join_next().is_some() {}
tokio::select! {
biased;
_ = &mut shutdown_rx => {
*inner.shutdown_reason.lock() = Some("shutdown requested".into());
tracing::info!(target: "zudp::engine", "graceful shutdown — draining retransmits");
break;
}
result = recv_sock.recv_from() => {
match result {
Ok((data, from)) => {
if inner.config.max_pps_per_ip > 0.0
&& !rate_limiter.allow(from.ip())
{
tracing::trace!(target: "zudp::engine", %from, "rate limited");
inner.dropped_rate_limited.fetch_add(1, Ordering::Relaxed);
continue;
}
handle_incoming(
data, from, &inner, &inbound_tx,
&mut recv_states, &mut relay_table, relay_gen,
&mut retransmit_tasks,
).await;
}
Err(e) => {
tracing::warn!(target: "zudp::engine", "recv error: {e} — attempting socket rebind");
match rebind_socket(&inner).await {
Ok(new_sock) => {
recv_sock = new_sock;
ping_all_peers(&inner, &recv_sock).await;
}
Err(bind_err) => {
let reason = format!("socket rebind failed: {bind_err}");
tracing::error!(target: "zudp::engine", "{reason}");
*inner.shutdown_reason.lock() = Some(reason);
break;
}
}
}
}
}
_ = ticker.tick() => {
run_background(
&inner, &mut recv_states, &mut relay_table, &mut relay_gen,
relay_ttl_ticks, &mut rate_limiter, keepalive_interval, sent_prune_age,
);
}
}
}
retransmit_tasks.shutdown().await;
tracing::info!(target: "zudp::engine", "engine task exited");
}
async fn rebind_socket(inner: &Arc<EngineInner>) -> Result<RawSocket, crate::Error> {
let old_local = inner.get_socket().local_addr()?;
let new_sock = match RawSocket::bind(old_local).await {
Ok(s) => s,
Err(_) => {
let any = SocketAddr::new(old_local.ip(), 0);
RawSocket::bind(any).await?
}
};
let new_addr = new_sock.local_addr()?;
*inner.socket.write() = new_sock.clone();
tracing::info!(target: "zudp::engine", old = %old_local, new = %new_addr, "socket rebound");
Ok(new_sock)
}
async fn ping_all_peers(inner: &Arc<EngineInner>, sock: &RawSocket) {
let now_ms = now_micros();
let peers: Vec<Arc<PeerState>> = inner.peers.iter().map(|r| r.value().clone()).collect();
for peer in peers {
let ping = secure_frame(&peer, Frame::Ping { echo: now_ms, session_id: peer.my_session_id });
if let Err(e) = sock.send_to(&ping, peer.addr()).await {
tracing::warn!(target: "zudp::engine", peer = %peer.addr(), "post-rebind ping failed: {e}");
}
}
}
#[allow(clippy::too_many_arguments)]
async fn handle_incoming(
data: BytesMut,
from: SocketAddr,
inner: &Arc<EngineInner>,
inbound_tx: &mpsc::Sender<(Bytes, SocketAddr, u16)>,
recv_states: &mut HashMap<(SocketAddr, u16), (RecvState, FragAssembler)>,
relay_table: &mut HashMap<SocketAddr, (SocketAddr, u32)>,
relay_gen: u32,
retransmit_tasks: &mut JoinSet<()>,
) {
if let Some(&(client_addr, _)) = relay_table.get(&from) {
tracing::trace!(target: "zudp::engine", server = %from, client = %client_addr, "relay ← server → client");
if let Err(e) = inner.get_socket().send_to(&data, client_addr).await {
tracing::warn!(target: "zudp::engine", client = %client_addr, "relay forward to client failed: {e}");
}
return;
}
let frame = match Frame::decode(data) {
Ok(f) => f,
Err(e) => {
tracing::warn!(target: "zudp::engine", peer = %from, "bad frame: {e}");
return;
}
};
let known_peer = inner.peers.get(&from).map(|r| r.value().clone());
if let Some(peer) = &known_peer {
peer.mark_seen();
}
#[cfg(feature = "security")]
{
match frame {
Frame::Handshake { payload } => {
handle_handshake(payload, from, inner).await;
}
Frame::Secure { nonce, ciphertext } => {
let Some(peer) = known_peer else {
tracing::warn!(target: "zudp::engine", peer = %from, "secure frame from unknown peer");
return;
};
let Some(channel) = peer.channel.get() else {
tracing::warn!(target: "zudp::engine", peer = %from, "secure frame but no channel yet");
return;
};
let plain = match channel.decrypt(nonce, &ciphertext) {
Ok(p) => p,
Err(e) => {
tracing::warn!(target: "zudp::engine", peer = %from, "decrypt failed: {e}");
return;
}
};
let inner_frame = match Frame::decode(BytesMut::from(plain.as_slice())) {
Ok(f) => f,
Err(e) => {
tracing::warn!(target: "zudp::engine", peer = %from, "inner frame decode failed: {e}");
return;
}
};
dispatch_frame(inner_frame, from, inner, inbound_tx, recv_states, relay_table, relay_gen, retransmit_tasks).await;
}
frame => dispatch_frame(frame, from, inner, inbound_tx, recv_states, relay_table, relay_gen, retransmit_tasks).await,
}
}
#[cfg(not(feature = "security"))]
dispatch_frame(frame, from, inner, inbound_tx, recv_states, relay_table, relay_gen, retransmit_tasks).await;
}
#[allow(clippy::too_many_arguments, clippy::too_many_lines)]
async fn dispatch_frame(
frame: Frame,
from: SocketAddr,
inner: &Arc<EngineInner>,
inbound_tx: &mpsc::Sender<(Bytes, SocketAddr, u16)>,
recv_states: &mut HashMap<(SocketAddr, u16), (RecvState, FragAssembler)>,
relay_table: &mut HashMap<SocketAddr, (SocketAddr, u32)>,
relay_gen: u32,
retransmit_tasks: &mut JoinSet<()>,
) {
match frame {
Frame::Datagram(payload) => {
let peer = inner.get_or_create_peer(from);
peer.rx_bytes.fetch_add(payload.len() as u64, std::sync::atomic::Ordering::Relaxed);
if inbound_tx.try_send((payload, from, 0)).is_err() {
tracing::warn!(target: "zudp::engine", %from, "inbound channel full — dropping datagram");
}
}
Frame::Stream {
seq,
stream_id,
payload,
} => {
let (recv, _frag) = recv_states
.entry((from, stream_id))
.or_insert_with(|| (RecvState::new(), FragAssembler::new()));
let (ready, nack_seqs) = recv.ingest(seq, Inbound::Data(payload));
send_nack_if_needed(nack_seqs, stream_id, from, inner).await;
let peer = inner.get_or_create_peer(from);
for item in ready {
if let Inbound::Data(bytes) = item {
peer.rx_bytes.fetch_add(bytes.len() as u64, std::sync::atomic::Ordering::Relaxed);
if inbound_tx.try_send((bytes, from, stream_id)).is_err() {
tracing::warn!(target: "zudp::engine", %from, stream_id, "inbound channel full — dropping stream frame");
}
}
}
}
Frame::Nack { stream_id, seqs } => {
if let Some(peer) = inner.peers.get(&from).map(|r| r.value().clone()) {
let to_retransmit = peer.frames_for_retransmit(stream_id, &seqs);
if !to_retransmit.is_empty() {
if retransmit_tasks.len() >= MAX_RETRANSMIT_TASKS {
tracing::warn!(
target: "zudp::engine",
peer = %from, stream_id,
cap = MAX_RETRANSMIT_TASKS,
"retransmit pool full — dropping NACK batch"
);
} else {
let sock = inner.get_socket();
retransmit_tasks.spawn(async move {
for (seq, plain_frame) in to_retransmit {
let wire = encrypt_or_plain(&peer, &plain_frame);
let delay = peer.cc.lock().consume(wire.len());
if let Some(d) = delay {
tokio::time::sleep(d).await;
}
tracing::debug!(
target: "zudp::engine",
peer = %from, seq, stream_id,
"retransmit on NACK"
);
if let Err(e) = sock.send_to(&wire, from).await {
tracing::warn!(
target: "zudp::engine",
peer = %from,
"retransmit failed: {e}"
);
}
}
});
}
}
}
}
Frame::Ping { echo, session_id } => {
let peer = find_or_migrate_peer(from, session_id, inner, recv_states);
let pong = secure_frame(&peer, Frame::Pong { echo, session_id: peer.my_session_id });
if let Err(e) = inner.get_socket().send_to(&pong, from).await {
tracing::warn!(target: "zudp::engine", peer = %from, "pong failed: {e}");
}
}
Frame::Pong { echo, session_id } => {
if let Some(peer) = inner.peers.get(&from).map(|r| r.value().clone()) {
if peer.store_their_session_id(session_id) {
inner.sessions.insert(session_id, peer.clone());
}
let now_us = now_micros();
if echo <= now_us {
let rtt_us = now_us - echo;
let pacing_rate = {
let mut cc = peer.cc.lock();
cc.on_rtt_sample(rtt_us);
cc.pacing_rate() as u64
};
tracing::debug!(
target: "zudp::engine",
peer = %from,
rtt_us,
pacing_rate,
"RTT sample"
);
}
}
}
Frame::Fragment {
msg_id,
frag_idx,
frag_total,
seq,
stream_id,
payload,
} => {
let (recv, frag_assembler) = recv_states
.entry((from, stream_id))
.or_insert_with(|| (RecvState::new(), FragAssembler::new()));
let inbound = Inbound::Fragment {
msg_id,
frag_idx,
frag_total,
data: payload,
};
let (ready, nack_seqs) = recv.ingest(seq, inbound);
send_nack_if_needed(nack_seqs, stream_id, from, inner).await;
let peer = inner.get_or_create_peer(from);
for item in ready {
if let Inbound::Fragment {
msg_id,
frag_idx,
frag_total,
data,
} = item
&& let Some(complete) =
frag_assembler.insert(msg_id, frag_idx, frag_total, data)
{
peer.rx_bytes.fetch_add(complete.len() as u64, std::sync::atomic::Ordering::Relaxed);
if inbound_tx.try_send((complete, from, stream_id)).is_err() {
tracing::warn!(target: "zudp::engine", %from, stream_id, "inbound channel full — dropping reassembled fragment");
}
}
}
}
Frame::Relay {
dest,
inner: payload,
} => {
let (policy_allowlist, policy_max) = {
let p = inner.relay_policy.read();
(p.allowlist.clone(), p.max_entries)
};
if !policy_allowlist.is_empty() && !policy_allowlist.contains(&from.ip()) {
tracing::warn!(target: "zudp::engine", %from, "relay denied — not in allowlist");
inner.dropped_relay_blocked.fetch_add(1, Ordering::Relaxed);
return;
}
if !relay_table.contains_key(&dest) && relay_table.len() >= policy_max {
tracing::warn!(target: "zudp::engine", "relay table full — dropping entry for {dest}");
inner.dropped_relay_cap.fetch_add(1, Ordering::Relaxed);
return;
}
relay_table
.entry(dest)
.and_modify(|(stored_from, last_gen)| {
*stored_from = from;
*last_gen = relay_gen;
})
.or_insert((from, relay_gen));
tracing::trace!(target: "zudp::engine", client = %from, server = %dest, "relay client → server");
if let Err(e) = inner.get_socket().send_to(&payload, dest).await {
tracing::warn!(target: "zudp::engine", %dest, "relay forward failed: {e}");
}
}
Frame::MtuProbe { probe_id, .. } => {
let ack_frame = Frame::MtuAck { probe_id };
let ack = if let Some(peer) = inner.peers.get(&from).map(|r| r.value().clone()) {
secure_frame(&peer, ack_frame)
} else {
ack_frame.encode()
};
if let Err(e) = inner.get_socket().send_to(&ack, from).await {
tracing::warn!(target: "zudp::engine", peer = %from, "mtu ack send failed: {e}");
}
}
Frame::MtuAck { probe_id } => {
if let Some(peer) = inner.peers.get(&from).map(|r| r.value().clone())
&& let Some(tx) = peer.probe_acks.lock().remove(&probe_id)
{
let _ = tx.send(());
}
}
Frame::Probe { .. } | Frame::Beacon { .. } => {}
#[cfg(feature = "security")]
Frame::Handshake { .. } | Frame::Secure { .. } => {}
}
}
fn find_or_migrate_peer(
from: SocketAddr,
session_id: u64,
inner: &Arc<EngineInner>,
recv_states: &mut HashMap<(SocketAddr, u16), (RecvState, FragAssembler)>,
) -> Arc<PeerState> {
if let Some(peer) = inner.peers.get(&from).map(|r| r.value().clone()) {
if peer.store_their_session_id(session_id) {
inner.sessions.insert(session_id, peer.clone());
}
return peer;
}
if let Some(peer) = inner.sessions.get(&session_id).map(|r| r.value().clone()) {
let old_addr = peer.addr();
if old_addr != from {
tracing::info!(
target: "zudp::engine",
old = %old_addr,
new = %from,
"peer address migrated"
);
peer.migrate_to(from);
inner.peers.remove(&old_addr);
inner.peers.insert(from, peer.clone());
let stream_ids: Vec<u16> = recv_states
.keys()
.filter(|(a, _)| *a == old_addr)
.map(|(_, s)| *s)
.collect();
for sid in stream_ids {
if let Some(state) = recv_states.remove(&(old_addr, sid)) {
recv_states.insert((from, sid), state);
}
}
peer.set_effective_mtu(0);
spawn_mtu_probe(inner, from);
}
return peer;
}
let peer = inner.get_or_create_peer(from);
peer.store_their_session_id(session_id);
inner.sessions.insert(session_id, peer.clone());
spawn_mtu_probe(inner, from);
peer
}
fn spawn_mtu_probe(inner: &Arc<EngineInner>, peer_addr: SocketAddr) {
let inner = inner.clone();
let initial_mtu = inner.config.mtu;
let _mtu_probe = tokio::spawn(async move {
let discovered = crate::mtu::probe(&inner, peer_addr, initial_mtu).await;
if let Some(p) = inner.peers.get(&peer_addr) {
p.set_effective_mtu(discovered);
}
tracing::info!(
target: "zudp::mtu",
peer = %peer_addr,
mtu = discovered,
"path MTU discovered"
);
});
}
fn secure_frame(peer: &PeerState, frame: Frame) -> Bytes {
let plain = frame.encode();
encrypt_or_plain(peer, &plain)
}
#[allow(unused_variables)]
fn encrypt_or_plain(peer: &PeerState, plain: &Bytes) -> Bytes {
#[cfg(feature = "security")]
if let Some(channel) = peer.channel.get() {
match channel.encrypt(plain) {
Ok((nonce, ct)) => {
return Frame::Secure {
nonce,
ciphertext: Bytes::from(ct),
}
.encode();
}
Err(e) => {
tracing::warn!(target: "zudp::engine", "retransmit encrypt failed: {e}");
}
}
}
plain.clone()
}
async fn send_nack_if_needed(
nack_seqs: Vec<u64>,
stream_id: u16,
to: SocketAddr,
inner: &Arc<EngineInner>,
) {
if nack_seqs.is_empty() {
return;
}
tracing::debug!(target: "zudp::engine", peer = %to, count = nack_seqs.len(), stream_id, "sending NACK");
let nack = Frame::Nack { stream_id, seqs: nack_seqs };
let wire = if let Some(peer) = inner.peers.get(&to).map(|r| r.value().clone()) {
secure_frame(&peer, nack)
} else {
nack.encode()
};
if let Err(e) = inner.get_socket().send_to(&wire, to).await {
tracing::warn!(target: "zudp::engine", peer = %to, "nack send failed: {e}");
}
}
#[allow(clippy::too_many_arguments)]
fn run_background(
inner: &Arc<EngineInner>,
recv_states: &mut HashMap<(SocketAddr, u16), (RecvState, FragAssembler)>,
relay_table: &mut HashMap<SocketAddr, (SocketAddr, u32)>,
relay_gen: &mut u32,
relay_ttl_ticks: u32,
rate_limiter: &mut crate::rate::RateLimiter,
keepalive_interval: Duration,
sent_prune_age: Duration,
) {
let keepalive_threshold = keepalive_interval.as_secs();
let now_ms = now_micros();
let peers: Vec<Arc<PeerState>> = inner.peers.iter().map(|r| r.value().clone()).collect();
for peer in peers {
if peer.secs_since_sent() >= keepalive_threshold {
let sock = inner.get_socket();
let peer_clone = peer.clone();
tokio::spawn(async move {
let addr = peer_clone.addr();
let ping = secure_frame(&peer_clone, Frame::Ping { echo: now_ms, session_id: peer_clone.my_session_id });
if let Err(e) = sock.send_to(&ping, addr).await {
tracing::warn!(target: "zudp::engine", peer = %addr, "keepalive failed: {e}");
}
tracing::trace!(target: "zudp::engine", peer = %addr, "sent keepalive ping");
});
}
peer.prune_sent(sent_prune_age);
}
for (_, frag_assembler) in recv_states.values_mut() {
frag_assembler.prune(sent_prune_age);
}
*relay_gen = relay_gen.wrapping_add(1);
let current_gen = *relay_gen;
relay_table.retain(|_, (_, last_seen_gen)| {
current_gen.wrapping_sub(*last_seen_gen) < relay_ttl_ticks
});
rate_limiter.tick_prune();
}
fn now_micros() -> u64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0u64, |d| u64::try_from(d.as_micros()).unwrap_or(u64::MAX))
}
#[cfg(feature = "security")]
async fn handle_handshake(payload: Bytes, from: SocketAddr, inner: &Arc<EngineInner>) {
use crate::security::{SecureChannel, build_responder};
let Some(kp) = inner.keypair.as_ref() else {
tracing::debug!(target: "zudp::engine", peer = %from, "handshake ignored — security not configured");
return;
};
let peer = inner.get_or_create_peer(from);
{
let mut guard = peer.handshake.lock();
if guard.is_none() {
match build_responder(kp) {
Ok(hs) => *guard = Some(hs),
Err(e) => {
tracing::error!(target: "zudp::engine", peer = %from, "build_responder: {e}");
return;
}
}
}
}
let outcome = 'step: {
let mut guard = peer.handshake.lock();
let hs = guard.as_mut().expect("initialised above");
let mut rbuf = vec![0u8; 1024];
if let Err(e) = hs.read_message(&payload, &mut rbuf) {
tracing::warn!(target: "zudp::engine", peer = %from, "handshake read: {e}");
return;
}
let finished_after_read = hs.is_handshake_finished();
if finished_after_read {
if !check_pinned_key(hs, inner, from) {
let _ = guard.take();
break 'step (None::<Bytes>, None, true);
}
let hs_owned = guard.take().unwrap();
break 'step (None, Some(hs_owned), false);
}
let mut wbuf = vec![0u8; 1024];
let n = match hs.write_message(&[], &mut wbuf) {
Ok(n) => n,
Err(e) => {
tracing::warn!(target: "zudp::engine", peer = %from, "handshake write: {e}");
return;
}
};
wbuf.truncate(n);
let reply = Bytes::from(wbuf);
let finished_after_write = hs.is_handshake_finished();
if finished_after_write {
if !check_pinned_key(hs, inner, from) {
let _ = guard.take();
break 'step (None, None, true);
}
}
let hs_owned = if finished_after_write { guard.take() } else { None };
(Some(reply), hs_owned, false)
};
let (reply, finished_hs, key_mismatch) = outcome;
if key_mismatch {
tracing::warn!(target: "zudp::security", peer = %from, "handshake aborted — key mismatch");
return;
}
if let Some(reply_bytes) = reply {
let wire = Frame::Handshake { payload: reply_bytes }.encode();
if let Err(e) = inner.get_socket().send_to(&wire, from).await {
tracing::warn!(target: "zudp::engine", peer = %from, "handshake send: {e}");
}
}
if let Some(hs) = finished_hs {
if let Some(remote) = hs.get_remote_static() {
let mut key = [0u8; 32];
key.copy_from_slice(remote);
let _ = peer.remote_static_key.set(key);
}
match hs.into_stateless_transport_mode() {
Ok(transport) => {
let _ = peer.channel.set(SecureChannel::new(transport));
peer.channel_ready.notify_one();
tracing::info!(target: "zudp::engine", peer = %from, "Noise XX handshake complete");
}
Err(e) => {
tracing::error!(target: "zudp::engine", peer = %from, "into_transport_mode: {e}");
}
}
}
}
#[cfg(feature = "security")]
fn check_pinned_key(
hs: &snow::HandshakeState,
inner: &Arc<EngineInner>,
from: SocketAddr,
) -> bool {
let Some(expected) = &inner.config.remote_key else {
return true;
};
match hs.get_remote_static() {
Some(remote) if remote == expected.as_slice() => true,
Some(_) => {
tracing::warn!(target: "zudp::security", peer = %from, "key mismatch — remote key does not match pinned key");
false
}
None => {
tracing::warn!(target: "zudp::security", peer = %from, "key pinning: remote static not available");
false
}
}
}