mod addr;
mod cc;
mod codec;
#[cfg(feature = "discovery")]
mod discovery;
mod engine;
mod error;
mod event;
mod frag;
mod frame;
#[cfg(feature = "security")]
mod handshake;
mod mtu;
mod peer;
mod rate;
#[cfg(feature = "security")]
mod relay;
#[cfg(feature = "security")]
mod security;
mod socket;
pub const DEFAULT_STREAM: u16 = 0;
pub use addr::{Path, PeerAddr};
#[cfg(all(feature = "wincode", not(feature = "serde"), not(feature = "rkyv")))]
pub use codec::WincodeConfig;
pub use codec::{Decode, Encode};
#[cfg(feature = "discovery")]
pub use discovery::{
AdvertiseHandle, AppId, DISCOVERY_PORT, DiscoveredPeer, Discovery, DiscoveryConfig,
DiscoveryEvent, ScanStream,
};
pub use error::Error;
pub use event::{DisconnectReason, PeerEvent, PeerEvents};
pub use frame::WIRE_VERSION;
#[cfg(feature = "relay")]
#[doc(hidden)]
pub use relay::node::RelayTap;
#[cfg(feature = "relay")]
pub use relay::node::{RelayLimits, RelayPolicy};
#[cfg(feature = "security")]
pub use security::{Keypair, ReplayWindow};
#[derive(Debug, Clone)]
pub struct RawBytes(pub Bytes);
impl Encode for RawBytes {
fn encode_to_bytes(&self) -> Result<Vec<u8>, Error> {
Ok(self.0.to_vec())
}
}
impl Decode for RawBytes {
fn decode_from_bytes(bytes: &[u8]) -> Result<Self, Error> {
Ok(RawBytes(Bytes::copy_from_slice(bytes)))
}
}
#[derive(Clone)]
pub struct ZudpSender {
inner: Arc<Inner>,
}
impl ZudpSender {
#[must_use]
pub fn events(&self) -> PeerEvents {
self.inner.events()
}
#[must_use = "false means the peer was not known"]
pub fn remove_peer(&self, peer: impl Into<PeerAddr>) -> bool {
self.inner.engine.remove_peer(peer.into())
}
pub async fn send_stream<M: Encode>(
&self,
msg: M,
peer: impl Into<PeerAddr>,
stream_id: u16,
) -> Result<(), Error> {
self.inner
.send_msg(&msg, peer.into(), true, stream_id)
.await
}
pub async fn connect(&self, peer: SocketAddr) -> Result<PeerAddr, Error> {
Ok(*self.inner.connect(peer).await?.read())
}
#[cfg(feature = "security")]
pub async fn connect_via(
&self,
relay: SocketAddr,
target: [u8; 32],
) -> Result<PeerAddr, Error> {
Ok(*self.inner.connect_via(relay, target).await?.read())
}
#[cfg(feature = "security")]
pub fn accept_relayed_from(&self, relay: SocketAddr) {
self.inner.accept_relayed_from(relay);
}
#[cfg(feature = "security")]
pub fn punch(&self, peer: impl Into<PeerAddr>) -> Result<(), Error> {
relay::punch(&self.inner.engine, peer.into())
}
#[must_use]
pub fn peer_srtt(&self, peer: impl Into<PeerAddr>) -> Option<std::time::Duration> {
self.inner.engine.peers.get(&peer.into())?.cc.lock().srtt()
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct PeerStats {
pub srtt: Option<Duration>,
pub congestion_factor: Option<f64>,
pub pacing_rate_bps: u64,
pub rx_bytes: u64,
pub tx_bytes: u64,
pub retransmit_count: u64,
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct EngineStats {
pub dropped_rate_limited: u64,
pub dropped_peer_cap: u64,
pub dropped_unauthenticated: u64,
pub dropped_forged: u64,
pub dropped_relay_unaccepted: u64,
pub relay_forwarded_packets: u64,
pub relay_forwarded_bytes: u64,
pub relay_dropped_rate_limited: u64,
pub relay_dropped_oversize: u64,
pub relay_unreachable: u64,
pub relay_denied: u64,
pub relay_sessions_evicted: u64,
pub relay_introductions: u64,
}
#[derive(Debug)]
pub struct Packet<M> {
pub msg: M,
pub from: PeerAddr,
pub stream: u16,
}
#[cfg(feature = "bitcode")]
pub use ::bitcode;
#[cfg(feature = "serde")]
pub use ::postcard;
#[cfg(feature = "rkyv")]
pub use ::rkyv;
#[cfg(feature = "serde")]
pub use ::serde;
#[cfg(feature = "wincode")]
pub use ::wincode;
use std::{
marker::PhantomData,
net::{IpAddr, Ipv4Addr, SocketAddr},
sync::{
Arc,
atomic::{AtomicU32, AtomicU64, Ordering},
},
time::Duration,
};
use bytes::Bytes;
use dashmap::DashMap;
use engine::EngineInner;
use parking_lot::RwLock;
use tokio::sync::mpsc;
use frag::fragment;
use frame::Frame;
use peer::PeerState;
use socket::RawSocket;
#[derive(Clone)]
pub struct Config {
pub(crate) port: u16,
pub(crate) bind_ip: IpAddr,
pub(crate) reliable: bool,
pub(crate) keepalive_interval: Duration,
pub(crate) sent_prune_age: Duration,
pub(crate) mtu: usize,
pub(crate) max_mtu: usize,
#[cfg(feature = "security")]
pub(crate) security: Option<security::Keypair>,
#[cfg(feature = "security")]
pub(crate) pinned_keys: Vec<[u8; 32]>,
#[cfg(feature = "security")]
pub(crate) punching: bool,
#[cfg(feature = "security")]
pub(crate) accept_relays: Vec<SocketAddr>,
#[cfg(feature = "relay")]
pub(crate) relay: Option<RelayLimits>,
#[cfg(feature = "relay")]
pub(crate) relay_policy: Option<Arc<dyn RelayPolicy>>,
pub(crate) max_peers: usize,
pub(crate) max_pps_per_ip: f64,
pub(crate) sent_buffer_frames: usize,
pub(crate) handshake_timeout: Duration,
pub(crate) peer_timeout: Option<Duration>,
}
impl Config {
pub(crate) fn effective_peer_timeout(&self) -> Duration {
self.peer_timeout.unwrap_or(self.keepalive_interval * 3)
}
}
impl Default for Config {
fn default() -> Self {
Self {
port: 0,
bind_ip: IpAddr::V4(Ipv4Addr::UNSPECIFIED),
reliable: true,
keepalive_interval: Duration::from_secs(5),
sent_prune_age: Duration::from_secs(10),
mtu: 1400,
max_mtu: mtu::DEFAULT_MTU_CEILING,
#[cfg(feature = "security")]
security: None,
#[cfg(feature = "security")]
pinned_keys: Vec::new(),
#[cfg(feature = "security")]
punching: true,
#[cfg(feature = "security")]
accept_relays: Vec::new(),
#[cfg(feature = "relay")]
relay: None,
#[cfg(feature = "relay")]
relay_policy: None,
max_peers: 1_024,
max_pps_per_ip: 1_000.0,
sent_buffer_frames: 1_024,
handshake_timeout: Duration::from_secs(5),
peer_timeout: None,
}
}
}
#[derive(Clone, Default)]
pub struct Zudp {
config: Config,
}
impl Zudp {
#[must_use]
pub fn port(mut self, port: u16) -> Self {
self.config.port = port;
self
}
#[must_use]
pub fn bind_ip(mut self, ip: IpAddr) -> Self {
self.config.bind_ip = ip;
self
}
#[must_use]
pub fn reliable(mut self, enabled: bool) -> Self {
self.config.reliable = enabled;
self
}
#[must_use]
pub fn keepalive_interval(mut self, interval: Duration) -> Self {
self.config.keepalive_interval = interval;
self
}
#[must_use]
pub fn mtu(mut self, bytes: usize) -> Self {
self.config.mtu = bytes;
self
}
#[must_use]
pub fn max_mtu(mut self, bytes: usize) -> Self {
self.config.max_mtu = bytes;
self
}
#[cfg(feature = "security")]
#[must_use]
pub fn security(mut self, keypair: Keypair) -> Self {
self.config.security = Some(keypair);
self
}
#[cfg(feature = "security")]
#[must_use]
pub fn pin_remote_key(mut self, key: [u8; 32]) -> Self {
if !self.config.pinned_keys.contains(&key) {
self.config.pinned_keys.push(key);
}
self
}
#[cfg(feature = "security")]
#[must_use]
pub fn punching(mut self, enabled: bool) -> Self {
self.config.punching = enabled;
self
}
#[cfg(feature = "security")]
#[must_use]
pub fn accept_relayed_from(mut self, relay: SocketAddr) -> Self {
let relay = reachable(relay);
if !self.config.accept_relays.contains(&relay) {
self.config.accept_relays.push(relay);
}
self
}
#[cfg(feature = "relay")]
#[must_use]
pub fn relay_node(mut self, limits: RelayLimits, policy: impl RelayPolicy + 'static) -> Self {
self.config.relay = Some(limits);
self.config.relay_policy = Some(Arc::new(policy));
self
}
#[must_use]
pub fn max_peers(mut self, n: usize) -> Self {
self.config.max_peers = n;
self
}
#[must_use]
pub fn rate_limit(mut self, max_pps: f64) -> Self {
self.config.max_pps_per_ip = max_pps;
self
}
#[must_use]
pub fn sent_buffer(mut self, frames: usize) -> Self {
self.config.sent_buffer_frames = frames;
self
}
#[must_use]
pub fn peer_timeout(mut self, timeout: Duration) -> Self {
self.config.peer_timeout = Some(timeout);
self
}
#[must_use]
pub fn handshake_timeout(mut self, timeout: Duration) -> Self {
self.config.handshake_timeout = timeout;
self
}
pub async fn listen<M>(self) -> Result<ZudpSocket<M>, Error> {
ZudpSocket::new(self.config).await
}
pub async fn connect<M>(self, peer: SocketAddr) -> Result<ZudpConn<M>, Error> {
let socket = ZudpSocket::new(self.config).await?;
let peer = socket.inner.connect(peer).await?;
Ok(ZudpConn::new(socket, peer))
}
#[cfg(feature = "security")]
pub async fn connect_via<M>(
self,
relay: SocketAddr,
target: [u8; 32],
) -> Result<ZudpConn<M>, Error> {
let socket = ZudpSocket::new(self.config).await?;
socket.inner.connect(relay).await?;
let peer = socket.inner.connect_via(relay, target).await?;
Ok(ZudpConn::new(socket, peer))
}
}
fn reachable(peer: SocketAddr) -> SocketAddr {
match peer.ip() {
IpAddr::V4(ip) if ip.is_unspecified() => {
SocketAddr::new(Ipv4Addr::LOCALHOST.into(), peer.port())
}
IpAddr::V6(ip) if ip.is_unspecified() => {
SocketAddr::new(std::net::Ipv6Addr::LOCALHOST.into(), peer.port())
}
_ => peer,
}
}
struct Inner {
engine: Arc<EngineInner>,
config: Arc<Config>,
next_msg_id: AtomicU32,
_shutdown: tokio::sync::oneshot::Sender<()>,
}
impl Inner {
async fn new(
config: Config,
) -> Result<(Arc<Self>, mpsc::Receiver<(Bytes, PeerAddr, u16)>), Error> {
let addr = SocketAddr::new(config.bind_ip, config.port);
let socket = RawSocket::bind(addr).await?;
let config = Arc::new(config);
let engine = Arc::new(EngineInner {
socket: RwLock::new(socket),
peers: DashMap::new(),
sessions: DashMap::new(),
instance_id: peer::random_u64(),
events: tokio::sync::broadcast::channel(event::EVENT_CAPACITY).0,
config: config.clone(),
#[cfg(feature = "security")]
keypair: config.security.clone(),
shutdown_reason: parking_lot::Mutex::new(None),
dropped_rate_limited: AtomicU64::new(0),
dropped_peer_cap: AtomicU64::new(0),
dropped_unauthenticated: AtomicU64::new(0),
delivery_stalled: std::sync::atomic::AtomicBool::new(false),
#[cfg(feature = "security")]
pending: parking_lot::Mutex::new(std::collections::HashMap::new()),
#[cfg(feature = "security")]
by_index: DashMap::new(),
#[cfg(feature = "security")]
hint_limiter: parking_lot::Mutex::new(
rate::RateLimiter::<PeerAddr>::new(5.0, 5.0).capped(engine::MAX_HINT_KEYS),
),
#[cfg(feature = "security")]
by_key: DashMap::new(),
#[cfg(feature = "security")]
punched: DashMap::new(),
dropped_forged: AtomicU64::new(0),
dropped_relay_unaccepted: AtomicU64::new(0),
#[cfg(feature = "security")]
inbound_relays: RwLock::new(config.accept_relays.iter().copied().collect()),
#[cfg(feature = "security")]
punch_allowed: RwLock::new(std::collections::HashSet::new()),
#[cfg(feature = "security")]
relayed_hs_limiter: parking_lot::Mutex::new(rate::RateLimiter::new(
relay::RELAYED_HANDSHAKES_PER_SEC,
relay::RELAYED_HANDSHAKES_PER_SEC,
)),
#[cfg(feature = "relay")]
relay: config
.relay
.clone()
.map(|limits| relay::node::RelayNode::new(limits, config.relay_policy.clone())),
});
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
let rx = engine::spawn(engine.clone(), shutdown_rx);
let inner = Arc::new(Self {
engine,
config,
next_msg_id: AtomicU32::new(0),
_shutdown: shutdown_tx,
});
Ok((inner, rx))
}
fn events(&self) -> PeerEvents {
PeerEvents {
rx: self.engine.events.subscribe(),
}
}
async fn connect(&self, peer: SocketAddr) -> Result<Arc<RwLock<PeerAddr>>, Error> {
let peer = reachable(peer);
let handle = PeerAddr::Direct(peer);
#[cfg(feature = "security")]
if let Some(existing) = self.established(handle) {
return Ok(existing.addr_arc());
}
let peer_state = self.get_or_create_peer(handle);
let live = peer_state.addr_arc();
#[cfg(feature = "security")]
if self.engine.secured() {
handshake::initiate(&Arc::downgrade(&self.engine), handle).await?;
}
if !self.engine.secured()
&& let Some(ping) = engine::ping_for(&self.engine, &peer_state)
{
self.engine.get_socket().send_to(&ping, peer).await?;
}
engine::spawn_mtu_probe(&self.engine, peer);
Ok(live)
}
#[cfg(feature = "security")]
fn established(&self, peer: PeerAddr) -> Option<Arc<PeerState>> {
self.engine
.peers
.get(&peer)
.map(|p| p.value().clone())
.filter(|p| p.has_channel() && p.is_confirmed())
}
#[cfg(feature = "security")]
async fn connect_via(
&self,
relay: SocketAddr,
target: [u8; 32],
) -> Result<Arc<RwLock<PeerAddr>>, Error> {
let relay = reachable(relay);
if !self.engine.secured() || self.established(PeerAddr::Direct(relay)).is_none() {
return Err(Error::NoSession {
peer: PeerAddr::Direct(relay),
});
}
let handle = PeerAddr::Relayed { relay, key: target };
if self.established(handle).is_none() {
handshake::initiate(&Arc::downgrade(&self.engine), handle).await?;
}
self.engine
.peers
.get(&handle)
.map(|p| p.addr_arc())
.ok_or(Error::HandshakeTimeout { peer: handle })
}
#[cfg(feature = "security")]
fn accept_relayed_from(&self, relay: SocketAddr) {
self.engine.inbound_relays.write().insert(reachable(relay));
}
fn peer_path(&self, peer: PeerAddr) -> Option<Path> {
let state = self.engine.peers.get(&peer)?.value().clone();
match peer {
PeerAddr::Direct(addr) => Some(Path::Direct(addr)),
PeerAddr::Relayed { relay, .. } => {
#[cfg(feature = "security")]
if let Some(direct) = state.direct_path() {
return Some(Path::Direct(direct));
}
let _ = state;
Some(Path::Relayed(relay))
}
}
}
fn alloc_msg_id(&self) -> u32 {
self.next_msg_id.fetch_add(1, Ordering::Relaxed)
}
fn get_or_create_peer(&self, addr: PeerAddr) -> Arc<PeerState> {
self.engine.get_or_create_peer(addr)
}
async fn send_msg<M: Encode>(
&self,
msg: &M,
dest: PeerAddr,
reliable: bool,
stream_id: u16,
) -> Result<(), Error> {
let payload = Bytes::from(msg.encode_to_bytes()?);
let reliable = reliable && self.config.reliable;
let peer = if self.engine.secured() {
self.engine
.peers
.get(&dest)
.map(|p| p.value().clone())
.filter(|p| p.has_channel())
.ok_or(Error::NoSession { peer: dest })?
} else if dest.is_relayed() {
return Err(Error::NoSession { peer: dest });
} else {
self.get_or_create_peer(dest)
};
let mtu = if let PeerAddr::Relayed { relay, .. } = dest {
let relay_path = self
.engine
.peers
.get(&PeerAddr::Direct(relay))
.map_or(self.config.mtu, |r| r.effective_mtu_or(self.config.mtu));
relayed_mtu(relay_path.min(self.config.mtu))
} else {
peer.effective_mtu_or(self.config.mtu)
};
if payload.len() <= mtu {
self.send_single(payload, peer, reliable, stream_id).await
} else {
self.send_fragmented(payload, peer, stream_id, mtu).await
}
}
async fn send_single(
&self,
payload: Bytes,
peer: Arc<PeerState>,
reliable: bool,
stream_id: u16,
) -> Result<(), Error> {
if reliable {
let seq = peer.alloc_seq(stream_id);
let plain_frame = Frame::Stream {
seq,
stream_id,
payload,
}
.encode();
let (wire, dest) = routed(&self.engine, &peer, &plain_frame)?;
peer.cc.lock().consume(wire.len());
self.engine.get_socket().send_to(&wire, dest).await?;
peer.record_sent(stream_id, seq, plain_frame, self.config.sent_buffer_frames);
engine::arm_tail_probe(&self.engine, &peer, stream_id);
} else if let (false, PeerAddr::Direct(dest)) = (self.engine.secured(), peer.addr()) {
let type_tag = [frame::TYPE_DATAGRAM];
self.engine
.get_socket()
.send_to_vectored(
&[
std::io::IoSlice::new(&payload),
std::io::IoSlice::new(&type_tag),
],
dest,
)
.await?;
} else {
let (wire, dest) = routed(&self.engine, &peer, &Frame::Datagram(payload).encode())?;
self.engine.get_socket().send_to(&wire, dest).await?;
}
peer.mark_sent();
Ok(())
}
async fn send_fragmented(
&self,
payload: Bytes,
peer: Arc<PeerState>,
stream_id: u16,
mtu: usize,
) -> Result<(), Error> {
let chunks = fragment(&payload, mtu)?;
let msg_id = self.alloc_msg_id();
let frag_total = u16::try_from(chunks.len()).map_err(|_| Error::MessageTooLarge {
got: chunks.len(),
max: frag::MAX_FRAGMENTS,
})?;
for (frag_idx, chunk) in (0u16..).zip(chunks) {
let seq = peer.alloc_seq(stream_id);
let plain_frame = Frame::Fragment {
msg_id,
frag_idx,
frag_total,
seq,
stream_id,
payload: chunk,
}
.encode();
let (wire, dest) = routed(&self.engine, &peer, &plain_frame)?;
peer.cc.lock().consume(wire.len());
self.engine.get_socket().send_to(&wire, dest).await?;
peer.record_sent(stream_id, seq, plain_frame, self.config.sent_buffer_frames);
}
engine::arm_tail_probe(&self.engine, &peer, stream_id);
Ok(())
}
}
fn relayed_mtu(mtu: usize) -> usize {
#[cfg(feature = "security")]
{
mtu.saturating_sub(frame::VIA_OVERHEAD).clamp(
64,
frame::RELAYED_INNER_MAX - frame::SECURE_FRAGMENT_OVERHEAD,
)
}
#[cfg(not(feature = "security"))]
{
mtu
}
}
fn routed(
engine: &EngineInner,
peer: &PeerState,
plain: &Bytes,
) -> Result<(Bytes, SocketAddr), Error> {
engine::seal(engine, peer, plain)
.and_then(|wire| engine.outbound(peer, wire))
.ok_or(Error::NoSession { peer: peer.addr() })
}
#[cfg_attr(not(feature = "relay"), allow(clippy::needless_pass_by_value))]
fn relay_stats(engine: &EngineInner) -> EngineStats {
#[cfg(feature = "relay")]
if let Some(node) = &engine.relay {
let c = &node.counters;
return EngineStats {
relay_forwarded_packets: c.forwarded_packets.load(Ordering::Relaxed),
relay_forwarded_bytes: c.forwarded_bytes.load(Ordering::Relaxed),
relay_dropped_rate_limited: c.dropped_rate_limited.load(Ordering::Relaxed),
relay_dropped_oversize: c.dropped_oversize.load(Ordering::Relaxed),
relay_unreachable: c.unreachable.load(Ordering::Relaxed),
relay_denied: c.denied.load(Ordering::Relaxed),
relay_sessions_evicted: c.sessions_evicted.load(Ordering::Relaxed),
relay_introductions: c.introductions.load(Ordering::Relaxed),
..EngineStats::default()
};
}
let _ = engine;
EngineStats::default()
}
pub struct ZudpSocket<M> {
inner: Arc<Inner>,
rx: mpsc::Receiver<(Bytes, PeerAddr, u16)>,
_phantom: PhantomData<fn() -> M>,
}
impl<M> ZudpSocket<M> {
async fn new(config: Config) -> Result<Self, Error> {
let (inner, rx) = Inner::new(config).await?;
Ok(Self {
inner,
rx,
_phantom: PhantomData,
})
}
#[must_use = "the address is returned, not printed"]
pub fn local_addr(&self) -> Result<SocketAddr, Error> {
self.inner.engine.get_socket().local_addr()
}
#[must_use]
pub fn peer_srtt(&self, peer: impl Into<PeerAddr>) -> Option<Duration> {
self.inner.engine.peers.get(&peer.into())?.cc.lock().srtt()
}
#[must_use]
pub fn peer_congestion_factor(&self, peer: impl Into<PeerAddr>) -> Option<f64> {
self.inner
.engine
.peers
.get(&peer.into())?
.cc
.lock()
.congestion_factor()
}
#[must_use]
pub fn peer_stats(&self, peer: impl Into<PeerAddr>) -> Option<PeerStats> {
let p = self.inner.engine.peers.get(&peer.into())?.value().clone();
let (srtt, congestion_factor, pacing_rate_bps) = {
let cc = p.cc.lock();
#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
let rate = cc.pacing_rate() as u64;
(cc.srtt(), cc.congestion_factor(), rate)
};
Some(PeerStats {
srtt,
congestion_factor,
pacing_rate_bps,
rx_bytes: p.rx_bytes.load(Ordering::Relaxed),
tx_bytes: p.tx_bytes.load(Ordering::Relaxed),
retransmit_count: p.retransmit_count.load(Ordering::Relaxed),
})
}
#[must_use]
pub fn engine_stats(&self) -> EngineStats {
let e = &self.inner.engine;
EngineStats {
dropped_rate_limited: e.dropped_rate_limited.load(Ordering::Relaxed),
dropped_peer_cap: e.dropped_peer_cap.load(Ordering::Relaxed),
dropped_unauthenticated: e.dropped_unauthenticated.load(Ordering::Relaxed),
dropped_forged: e.dropped_forged.load(Ordering::Relaxed),
dropped_relay_unaccepted: e.dropped_relay_unaccepted.load(Ordering::Relaxed),
..relay_stats(e)
}
}
#[must_use]
pub fn sender(&self) -> ZudpSender {
ZudpSender {
inner: self.inner.clone(),
}
}
#[must_use]
pub fn events(&self) -> PeerEvents {
self.inner.events()
}
#[must_use = "false means the peer was not known"]
pub fn remove_peer(&self, peer: impl Into<PeerAddr>) -> bool {
self.inner.engine.remove_peer(peer.into())
}
pub async fn connect(&self, peer: SocketAddr) -> Result<PeerAddr, Error> {
Ok(*self.inner.connect(peer).await?.read())
}
#[cfg(feature = "security")]
pub async fn connect_via(
&self,
relay: SocketAddr,
target: [u8; 32],
) -> Result<PeerAddr, Error> {
Ok(*self.inner.connect_via(relay, target).await?.read())
}
#[must_use]
pub fn peer_path(&self, peer: impl Into<PeerAddr>) -> Option<Path> {
self.inner.peer_path(peer.into())
}
#[cfg(feature = "security")]
pub fn accept_relayed_from(&self, relay: SocketAddr) {
self.inner.accept_relayed_from(relay);
}
#[cfg(feature = "security")]
pub fn punch(&self, peer: impl Into<PeerAddr>) -> Result<(), Error> {
relay::punch(&self.inner.engine, peer.into())
}
#[cfg(feature = "relay")]
pub fn set_relay_policy(&self, policy: Option<Arc<dyn RelayPolicy>>) {
if let Some(node) = &self.inner.engine.relay {
node.set_policy(policy);
}
}
#[cfg(feature = "relay")]
#[doc(hidden)]
pub fn set_relay_tap(&self, tap: Option<RelayTap>) {
if let Some(node) = &self.inner.engine.relay {
node.set_tap(tap);
}
}
#[doc(hidden)]
pub fn debug_block_addr(&self, addr: SocketAddr, blocked: bool) {
self.inner
.engine
.get_socket()
.set_blocked(addr, blocked, false);
}
#[doc(hidden)]
pub fn debug_delay_to(&self, addr: SocketAddr, delay: Option<Duration>) {
self.inner
.engine
.get_socket()
.set_fault(addr, delay.map(socket::Fault::Delayed));
}
#[doc(hidden)]
pub fn debug_drop_from(&self, addr: SocketAddr, dropped: bool) {
self.inner
.engine
.get_socket()
.set_blocked(addr, dropped, true);
}
#[cfg(feature = "security")]
#[must_use]
pub fn peer_remote_static_key(&self, peer: impl Into<PeerAddr>) -> Option<[u8; 32]> {
self.inner
.engine
.peers
.get(&peer.into())
.and_then(|p| p.remote_static_key())
}
pub async fn send(&self, msg: M, peer: impl Into<PeerAddr>) -> Result<(), Error>
where
M: Encode,
{
self.inner
.send_msg(&msg, peer.into(), true, DEFAULT_STREAM)
.await
}
pub async fn send_stream(
&self,
msg: M,
peer: impl Into<PeerAddr>,
stream_id: u16,
) -> Result<(), Error>
where
M: Encode,
{
self.inner
.send_msg(&msg, peer.into(), true, stream_id)
.await
}
pub async fn send_unreliable(&self, msg: M, peer: impl Into<PeerAddr>) -> Result<(), Error>
where
M: Encode,
{
self.inner
.send_msg(&msg, peer.into(), false, DEFAULT_STREAM)
.await
}
pub async fn recv(&mut self) -> Result<Packet<M>, Error>
where
M: Decode,
{
loop {
let Some((bytes, from, stream)) = self.rx.recv().await else {
let reason = self
.inner
.engine
.shutdown_reason
.lock()
.clone()
.unwrap_or_else(|| "channel closed".into());
return Err(Error::EngineStopped { reason });
};
match M::decode_from_bytes(&bytes) {
Ok(msg) => return Ok(Packet { msg, from, stream }),
Err(e) => {
tracing::warn!(target: "zudp", peer = %from, "decode failed: {e}");
}
}
}
}
}
pub struct ZudpConn<M> {
socket: ZudpSocket<M>,
peer: Arc<RwLock<PeerAddr>>,
events: PeerEvents,
}
impl<M> ZudpConn<M> {
fn new(socket: ZudpSocket<M>, peer: Arc<RwLock<PeerAddr>>) -> Self {
let events = socket.events();
Self {
socket,
peer,
events,
}
}
#[must_use]
pub fn path(&self) -> Option<Path> {
self.socket.peer_path(self.peer())
}
#[must_use]
pub fn events(&self) -> PeerEvents {
self.socket.events()
}
#[must_use]
pub fn peer(&self) -> PeerAddr {
*self.peer.read()
}
#[must_use]
pub fn sender(&self) -> ZudpSender {
self.socket.sender()
}
#[must_use = "the address is returned, not printed"]
pub fn local_addr(&self) -> Result<SocketAddr, Error> {
self.socket.local_addr()
}
#[must_use]
pub fn effective_mtu(&self) -> Option<usize> {
self.socket
.inner
.engine
.peers
.get(&self.peer())
.map(|p| p.effective_mtu_or(0))
.filter(|&v| v != 0)
}
#[must_use]
pub fn srtt(&self) -> Option<Duration> {
self.socket.peer_srtt(self.peer())
}
#[must_use]
pub fn congestion_factor(&self) -> Option<f64> {
self.socket.peer_congestion_factor(self.peer())
}
#[must_use]
pub fn peer_stats(&self) -> Option<PeerStats> {
self.socket.peer_stats(self.peer())
}
#[must_use]
pub fn engine_stats(&self) -> EngineStats {
self.socket.engine_stats()
}
pub async fn send(&self, msg: M) -> Result<(), Error>
where
M: Encode,
{
self.socket.send(msg, self.peer()).await
}
pub async fn send_stream(&self, msg: M, stream_id: u16) -> Result<(), Error>
where
M: Encode,
{
self.socket.send_stream(msg, self.peer(), stream_id).await
}
pub async fn send_unreliable(&self, msg: M) -> Result<(), Error>
where
M: Encode,
{
self.socket.send_unreliable(msg, self.peer()).await
}
pub async fn recv(&mut self) -> Result<Packet<M>, Error>
where
M: Decode,
{
loop {
let pkt = tokio::select! {
biased;
pkt = self.socket.recv() => pkt?,
event = self.events.recv() => {
if let Ok(PeerEvent::Disconnected { addr, reason: DisconnectReason::TimedOut }) = event
&& addr == *self.peer.read()
{
return Err(Error::PeerTimeout { peer: addr });
}
continue;
}
};
let current = *self.peer.read();
if pkt.from == current {
return Ok(pkt);
}
tracing::debug!(
target: "zudp",
unexpected = %pkt.from,
expected = %current,
"dropping message from unexpected peer"
);
}
}
}