mod codec;
#[cfg(feature = "discovery")]
mod discovery;
mod engine;
mod error;
mod frag;
mod frame;
mod peer;
#[cfg(feature = "security")]
mod security;
mod socket;
pub const DEFAULT_STREAM: u16 = 0;
pub use codec::{Decode, Encode};
#[cfg(feature = "discovery")]
pub use discovery::{
AdvertiseHandle, AppId, DISCOVERY_PORT, DiscoveredPeer, Discovery, DiscoveryConfig, ScanStream,
};
pub use error::Error;
#[cfg(feature = "security")]
pub use security::Keypair;
#[derive(Debug)]
pub struct Packet<M> {
pub msg: M,
pub from: std::net::SocketAddr,
pub stream: u16,
}
#[cfg(feature = "bitcode")]
pub use ::bitcode;
#[cfg(feature = "serde")]
pub use ::serde;
#[cfg(feature = "serde")]
pub use ::postcard;
use std::{
marker::PhantomData,
net::{IpAddr, Ipv4Addr, SocketAddr},
sync::{
Arc,
atomic::{AtomicU32, Ordering},
},
time::Duration,
};
use bytes::Bytes;
use parking_lot::RwLock;
use tokio::sync::mpsc;
use engine::EngineInner;
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) relay_addr: Option<SocketAddr>,
#[cfg(feature = "security")]
pub(crate) security: Option<security::Keypair>,
}
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,
relay_addr: None,
#[cfg(feature = "security")]
security: 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 relay(mut self, relay_addr: SocketAddr) -> Self {
self.config.relay_addr = Some(relay_addr);
self
}
#[cfg(feature = "security")]
#[must_use]
pub fn security(mut self, keypair: Keypair) -> Self {
self.config.security = Some(keypair);
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?;
#[cfg(feature = "security")]
if socket.inner.config.security.is_some() {
socket.inner.initiate_handshake(peer).await?;
}
Ok(ZudpConn { socket, peer })
}
}
struct Inner {
engine: Arc<EngineInner>,
config: Arc<Config>,
next_msg_id: AtomicU32,
}
impl Inner {
async fn new(
config: Config,
) -> Result<(Arc<Self>, mpsc::UnboundedReceiver<(Bytes, SocketAddr, 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,
peers: RwLock::new(std::collections::HashMap::new()),
config: config.clone(),
#[cfg(feature = "security")]
keypair: config.security.clone(),
});
let rx = engine::spawn(engine.clone());
let inner = Arc::new(Self {
engine,
config,
next_msg_id: AtomicU32::new(0),
});
Ok((inner, rx))
}
#[cfg(feature = "security")]
async fn initiate_handshake(&self, peer_addr: SocketAddr) -> Result<(), Error> {
use security::build_initiator;
let kp = self
.config
.security
.as_ref()
.expect("called only when security is Some");
let mut hs = build_initiator(kp)?;
let mut buf = vec![0u8; 1024];
let n = hs.write_message(&[], &mut buf)?;
buf.truncate(n);
let wire = Frame::Handshake {
payload: Bytes::from(buf),
}
.encode();
self.engine.socket.send_to(&wire, peer_addr).await?;
let peer = self.get_or_create_peer(peer_addr);
*peer.handshake.lock() = Some(hs);
Ok(())
}
fn alloc_msg_id(&self) -> u32 {
self.next_msg_id.fetch_add(1, Ordering::Relaxed)
}
fn get_or_create_peer(&self, addr: SocketAddr) -> Arc<PeerState> {
self.engine.get_or_create_peer(addr)
}
async fn send_msg<M: Encode>(
&self,
msg: &M,
dest: SocketAddr,
reliable: bool,
stream_id: u16,
) -> Result<(), Error> {
let payload = Bytes::from(msg.encode_to_bytes()?);
let actual_dest = self.config.relay_addr.unwrap_or(dest);
let wrap_relay = self.config.relay_addr.is_some();
let reliable = reliable && self.config.reliable;
if payload.len() <= self.config.mtu {
self.send_single(payload, dest, actual_dest, wrap_relay, reliable, stream_id)
.await
} else {
self.send_fragmented(payload, dest, actual_dest, wrap_relay, stream_id)
.await
}
}
async fn send_single(
&self,
payload: Bytes,
peer_addr: SocketAddr,
actual_dest: SocketAddr,
wrap_relay: bool,
reliable: bool,
stream_id: u16,
) -> Result<(), Error> {
if reliable {
let peer = self.get_or_create_peer(peer_addr);
let seq = peer.alloc_seq(stream_id);
let plain_frame = Frame::Stream {
seq,
stream_id,
payload,
}
.encode();
let inner_wire = maybe_encrypt(&peer, &plain_frame)?;
let wire = if wrap_relay {
Frame::Relay {
dest: peer_addr,
inner: inner_wire,
}
.encode()
} else {
inner_wire
};
self.engine.socket.send_to(&wire, actual_dest).await?;
peer.record_sent(stream_id, seq, plain_frame);
} else if wrap_relay {
let frame = Frame::Datagram(payload).encode();
let wire = Frame::Relay {
dest: peer_addr,
inner: frame,
}
.encode();
self.engine.socket.send_to(&wire, actual_dest).await?;
} else {
let type_tag = [frame::TYPE_DATAGRAM];
self.engine
.socket
.send_to_vectored(
&[
std::io::IoSlice::new(&payload),
std::io::IoSlice::new(&type_tag),
],
actual_dest,
)
.await?;
}
Ok(())
}
async fn send_fragmented(
&self,
payload: Bytes,
peer_addr: SocketAddr,
actual_dest: SocketAddr,
wrap_relay: bool,
stream_id: u16,
) -> Result<(), Error> {
let chunks = fragment(&payload, self.config.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,
})?;
let peer = self.get_or_create_peer(peer_addr);
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 inner_wire = maybe_encrypt(&peer, &plain_frame)?;
let wire = if wrap_relay {
Frame::Relay {
dest: peer_addr,
inner: inner_wire,
}
.encode()
} else {
inner_wire
};
self.engine.socket.send_to(&wire, actual_dest).await?;
peer.record_sent(stream_id, seq, plain_frame);
}
Ok(())
}
}
#[allow(clippy::unnecessary_wraps)]
fn maybe_encrypt(peer: &PeerState, plain: &Bytes) -> Result<Bytes, Error> {
#[cfg(feature = "security")]
if let Some(channel) = peer.channel.get() {
let (nonce, ct) = channel.encrypt(plain)?;
return Ok(Frame::Secure {
nonce,
ciphertext: Bytes::from(ct),
}
.encode());
}
let _ = peer;
Ok(plain.clone())
}
pub struct ZudpSocket<M> {
inner: Arc<Inner>,
rx: mpsc::UnboundedReceiver<(Bytes, SocketAddr, 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.socket.local_addr()
}
pub async fn send(&self, msg: M, peer: SocketAddr) -> Result<(), Error>
where
M: Encode,
{
self.inner.send_msg(&msg, peer, true, DEFAULT_STREAM).await
}
pub async fn send_stream(&self, msg: M, peer: SocketAddr, stream_id: u16) -> Result<(), Error>
where
M: Encode,
{
self.inner.send_msg(&msg, peer, true, stream_id).await
}
pub async fn send_unreliable(&self, msg: M, peer: SocketAddr) -> Result<(), Error>
where
M: Encode,
{
self.inner.send_msg(&msg, peer, false, DEFAULT_STREAM).await
}
pub async fn recv(&mut self) -> Result<Packet<M>, Error>
where
M: Decode,
{
loop {
let (bytes, from, stream) = self.rx.recv().await.ok_or(Error::ChannelClosed)?;
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: SocketAddr,
}
impl<M> ZudpConn<M> {
#[must_use]
pub fn peer(&self) -> SocketAddr {
self.peer
}
#[must_use = "the address is returned, not printed"]
pub fn local_addr(&self) -> Result<SocketAddr, Error> {
self.socket.local_addr()
}
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 = self.socket.recv().await?;
if pkt.from == self.peer {
return Ok(pkt);
}
tracing::debug!(
target: "zudp",
unexpected = %pkt.from,
expected = %self.peer,
"dropping message from unexpected peer"
);
}
}
}