Skip to main content

qualia_core_db/net/peer/fabric/
relay.rs

1//! Local bound-UDP relay. Topology of two outbound clients; not MASQUE HTTP/3.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use std::net::{SocketAddr, UdpSocket};
6use std::time::Duration;
7
8use super::carrier::PathClass;
9use super::evidence::TransportWitness;
10use super::intent::PeerId;
11use super::kernel::FabricError;
12use super::lease::RelayLease;
13
14pub const MAGIC: &[u8; 4] = b"QBD1";
15pub const MAX_PAYLOAD: usize = 1152;
16
17#[derive(Debug)]
18pub struct BoundUdpRelay {
19    sock: UdpSocket,
20    pub lease: RelayLease,
21    endpoints: [Option<SocketAddr>; 2],
22    pub forwarded: u64,
23}
24
25impl BoundUdpRelay {
26    /// Binds a UDP socket from `lease`.
27    pub fn bind(lease: RelayLease) -> Result<Self, FabricError> {
28        let sock = UdpSocket::bind("127.0.0.1:0").map_err(|_| FabricError::Capacity)?;
29        sock.set_read_timeout(Some(Duration::from_millis(250)))
30            .map_err(|_| FabricError::Capacity)?;
31        Ok(Self {
32            sock,
33            lease,
34            endpoints: [None, None],
35            forwarded: 0,
36        })
37    }
38
39    /// Bound local address.
40    pub fn addr(&self) -> Result<SocketAddr, FabricError> {
41        self.sock.local_addr().map_err(|_| FabricError::Capacity)
42    }
43
44    /// Forward one datagram if the lease still admits it.
45    pub fn forward_once(&mut self, now_ms: u64) -> Result<usize, FabricError> {
46        let mut buf = [0u8; 8 + MAX_PAYLOAD];
47        let (n, src) = match self.sock.recv_from(&mut buf) {
48            Ok(v) => v,
49            Err(_) => return Ok(0),
50        };
51        if n < 19 || &buf[..4] != MAGIC {
52            return Err(FabricError::Illegal);
53        }
54        let mut idb = [0u8; 8];
55        idb.copy_from_slice(&buf[4..12]);
56        let lease_id = u64::from_be_bytes(idb);
57        let mut genb = [0u8; 4];
58        genb.copy_from_slice(&buf[12..16]);
59        let generation = u32::from_be_bytes(genb);
60        let slot = buf[16] as usize;
61        let len = u16::from_be_bytes([buf[17], buf[18]]) as usize;
62        if lease_id != self.lease.lease_id || generation != self.lease.generation {
63            return Err(FabricError::LeaseDead);
64        }
65        if !self.lease.live(now_ms) {
66            return Err(FabricError::LeaseDead);
67        }
68        if slot > 1 || 19 + len > n || len > MAX_PAYLOAD {
69            return Err(FabricError::Illegal);
70        }
71        self.endpoints[slot] = Some(src);
72        let other = 1 - slot;
73        let dest = match self.endpoints[other] {
74            Some(d) => d,
75            None => return Ok(0),
76        };
77        self.lease
78            .charge(len as u64, now_ms)
79            .map_err(|_| FabricError::LeaseDead)?;
80        self.sock
81            .send_to(&buf[..19 + len], dest)
82            .map_err(|_| FabricError::Capacity)?;
83        self.forwarded = self.forwarded.saturating_add(len as u64);
84        Ok(len)
85    }
86
87    /// Transport witness at `now_ms`.
88    pub fn witness(&self, now_ms: u64) -> TransportWitness {
89        TransportWitness::from_local(
90            PathClass::Relayed,
91            self.lease.generation,
92            MAX_PAYLOAD as u16,
93            1,
94            now_ms,
95        )
96    }
97}
98
99/// Encodes a relay frame.
100pub fn encode(
101    lease: &RelayLease,
102    from: &PeerId,
103    payload: &[u8],
104    out: &mut [u8],
105) -> Result<usize, FabricError> {
106    if payload.len() > MAX_PAYLOAD || out.len() < 19 + payload.len() {
107        return Err(FabricError::Capacity);
108    }
109    let slot = if from == &lease.participants[0] {
110        0u8
111    } else if from == &lease.participants[1] {
112        1u8
113    } else {
114        return Err(FabricError::PolicyDenied);
115    };
116    out[..4].copy_from_slice(MAGIC);
117    out[4..12].copy_from_slice(&lease.lease_id.to_be_bytes());
118    out[12..16].copy_from_slice(&lease.generation.to_be_bytes());
119    out[16] = slot;
120    out[17..19].copy_from_slice(&(payload.len() as u16).to_be_bytes());
121    out[19..19 + payload.len()].copy_from_slice(payload);
122    Ok(19 + payload.len())
123}
124
125/// Decodes a relay payload slice; fails closed on malformed input.
126pub fn decode_payload(buf: &[u8]) -> Result<&[u8], FabricError> {
127    if buf.len() < 19 || &buf[..4] != MAGIC {
128        return Err(FabricError::Illegal);
129    }
130    let len = u16::from_be_bytes([buf[17], buf[18]]) as usize;
131    if 19 + len > buf.len() {
132        return Err(FabricError::Illegal);
133    }
134    Ok(&buf[19..19 + len])
135}
136
137#[cfg(test)]
138mod tests {
139    use super::*;
140
141    #[test]
142    fn lease_expiry_stops_forward() {
143        use std::net::UdpSocket;
144        let a = [1u8; 32];
145        let b = [2u8; 32];
146        let lease = RelayLease::grant(7, 1, a, b, 64, 0, 1, false);
147        let mut r = BoundUdpRelay::bind(lease).unwrap();
148        let addr = r.addr().unwrap();
149        let s = UdpSocket::bind("127.0.0.1:0").unwrap();
150        let mut pkt = [0u8; 64];
151        let n = encode(&r.lease, &a, b"x", &mut pkt).unwrap();
152        s.send_to(&pkt[..n], addr).unwrap();
153        assert_eq!(r.forward_once(100), Err(FabricError::LeaseDead));
154        assert_eq!(r.forwarded, 0);
155    }
156}