qualia_core_db/net/peer/fabric/
relay.rs1#![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 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 pub fn addr(&self) -> Result<SocketAddr, FabricError> {
41 self.sock.local_addr().map_err(|_| FabricError::Capacity)
42 }
43
44 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 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
99pub 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
125pub 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}