use crate::error::{Error, Result};
pub const HEADER_LEN: usize = 20;
pub const VERSION: u8 = 1;
pub const EXT_SELECTIVE_ACK: u8 = 1;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u8)]
pub enum PacketType {
Data = 0,
Fin = 1,
State = 2,
Reset = 3,
Syn = 4,
}
impl PacketType {
pub fn from_u4(value: u8) -> Result<Self> {
match value {
0 => Ok(Self::Data),
1 => Ok(Self::Fin),
2 => Ok(Self::State),
3 => Ok(Self::Reset),
4 => Ok(Self::Syn),
other => Err(Error::Peer(format!("uTP unknown packet type {other}"))),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Packet {
pub ty: PacketType,
pub connection_id: u16,
pub timestamp_microseconds: u32,
pub timestamp_difference_microseconds: u32,
pub wnd_size: u32,
pub seq_nr: u16,
pub ack_nr: u16,
pub selective_ack: Option<Vec<u8>>,
pub payload: Vec<u8>,
}
impl Packet {
pub fn encode(&self) -> Vec<u8> {
let has_sack = self
.selective_ack
.as_ref()
.is_some_and(|b| !b.is_empty());
let mut out = Vec::with_capacity(
HEADER_LEN
+ self.payload.len()
+ if has_sack {
2 + self.selective_ack.as_ref().map_or(0, Vec::len)
} else {
0
},
);
let ver_type = ((self.ty as u8) << 4) | (VERSION & 0x0f);
out.push(ver_type);
out.push(if has_sack { EXT_SELECTIVE_ACK } else { 0 });
out.extend_from_slice(&self.connection_id.to_be_bytes());
out.extend_from_slice(&self.timestamp_microseconds.to_be_bytes());
out.extend_from_slice(&self.timestamp_difference_microseconds.to_be_bytes());
out.extend_from_slice(&self.wnd_size.to_be_bytes());
out.extend_from_slice(&self.seq_nr.to_be_bytes());
out.extend_from_slice(&self.ack_nr.to_be_bytes());
if has_sack {
let sack = self.selective_ack.as_ref().expect("sack");
out.push(0); out.push(sack.len() as u8);
out.extend_from_slice(sack);
}
out.extend_from_slice(&self.payload);
out
}
pub fn decode(bytes: &[u8]) -> Result<Self> {
if bytes.len() < HEADER_LEN {
return Err(Error::Peer("uTP packet too short".into()));
}
let ver_type = bytes[0];
let version = ver_type & 0x0f;
if version != VERSION {
return Err(Error::Peer(format!("uTP unsupported version {version}")));
}
let ty = PacketType::from_u4(ver_type >> 4)?;
let mut extension = bytes[1];
let mut offset = HEADER_LEN;
let mut selective_ack = None;
while extension != 0 {
if bytes.len() < offset + 2 {
return Err(Error::Peer("uTP truncated extension header".into()));
}
let next = bytes[offset];
let len = bytes[offset + 1] as usize;
offset += 2;
if bytes.len() < offset + len {
return Err(Error::Peer("uTP truncated extension body".into()));
}
if extension == EXT_SELECTIVE_ACK {
selective_ack = Some(bytes[offset..offset + len].to_vec());
}
offset += len;
extension = next;
}
Ok(Self {
ty,
connection_id: u16::from_be_bytes([bytes[2], bytes[3]]),
timestamp_microseconds: u32::from_be_bytes(bytes[4..8].try_into().unwrap()),
timestamp_difference_microseconds: u32::from_be_bytes(bytes[8..12].try_into().unwrap()),
wnd_size: u32::from_be_bytes(bytes[12..16].try_into().unwrap()),
seq_nr: u16::from_be_bytes([bytes[16], bytes[17]]),
ack_nr: u16::from_be_bytes([bytes[18], bytes[19]]),
selective_ack,
payload: bytes[offset..].to_vec(),
})
}
}
pub fn build_selective_ack(ack_nr: u16, received: impl Iterator<Item = u16>) -> Option<Vec<u8>> {
let mut bits = Vec::new();
for seq in received {
let delta = seq.wrapping_sub(ack_nr);
if delta < 2 {
continue; }
let bit_index = (delta - 2) as usize;
let byte = bit_index / 8;
let bit = bit_index % 8;
if byte >= 32 {
continue; }
if bits.len() <= byte {
bits.resize(byte + 1, 0);
}
bits[byte] |= 1 << bit;
}
if bits.is_empty() {
None
} else {
Some(bits)
}
}
pub fn iter_selective_ack(ack_nr: u16, bitmask: &[u8]) -> impl Iterator<Item = u16> + '_ {
bitmask.iter().enumerate().flat_map(move |(byte_i, byte)| {
(0..8).filter_map(move |bit| {
if byte & (1 << bit) != 0 {
let delta = (byte_i * 8 + bit) as u16;
Some(ack_nr.wrapping_add(2).wrapping_add(delta))
} else {
None
}
})
})
}
pub fn now_micros() -> u32 {
use std::time::{SystemTime, UNIX_EPOCH};
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.subsec_micros().wrapping_add((d.as_secs() as u32).wrapping_mul(1_000_000)))
.unwrap_or(0)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn header_roundtrip_with_sack() {
let p = Packet {
ty: PacketType::State,
connection_id: 0x1234,
timestamp_microseconds: 99,
timestamp_difference_microseconds: 0,
wnd_size: 1_048_576,
seq_nr: 1,
ack_nr: 5,
selective_ack: Some(vec![0b0000_0101]),
payload: vec![],
};
let enc = p.encode();
let dec = Packet::decode(&enc).expect("decode");
assert_eq!(dec, p);
let marked: Vec<_> = iter_selective_ack(5, dec.selective_ack.as_ref().unwrap()).collect();
assert_eq!(marked, vec![7, 9]);
}
#[test]
fn build_sack_bits() {
let sack = build_selective_ack(10, [12u16, 13, 15].into_iter()).unwrap();
assert_eq!(sack[0] & 0b1011, 0b1011);
}
}