torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! BEP 29 uTP packet header + selective-ACK extension codec.

use crate::error::{Error, Result};

pub const HEADER_LEN: usize = 20;
pub const VERSION: u8 = 1;
/// Selective ACK extension type (BEP 29).
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,
    /// Selective ACK bitmask (extension type 1). Bit `i` means `ack_nr + 2 + i` received.
    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); // next extension
            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());
            }
            // Skip unknown extensions by length.
            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(),
        })
    }
}

/// Build a selective-ACK bitmask for out-of-order seqs relative to `ack_nr`.
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; // ack_nr itself or ack_nr+1 (next expected) — not in sack
        }
        let bit_index = (delta - 2) as usize;
        let byte = bit_index / 8;
        let bit = bit_index % 8;
        if byte >= 32 {
            continue; // cap sack size
        }
        if bits.len() <= byte {
            bits.resize(byte + 1, 0);
        }
        bits[byte] |= 1 << bit;
    }
    if bits.is_empty() {
        None
    } else {
        Some(bits)
    }
}

/// Iterate sequence numbers marked present in a selective-ACK bitmask.
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();
        // 12 -> bit0, 13 -> bit1, 15 -> bit3
        assert_eq!(sack[0] & 0b1011, 0b1011);
    }
}