Skip to main content

qualia_core_db/net/peer/fabric/
lease_protocol.rs

1//! Apply CSCP RelayLease bytes. Custody cannot forward. Relay-only cannot export observations.
2
3use super::kernel::FabricError;
4use super::lease::{CustodyLease, RelayLease};
5use super::wire::{decode_custody, decode_relay_lease, encode_relay_lease};
6use crate::net::peer::connectivity::policy::Disclosure;
7
8/// Decodes and applies a relay lease under `disclosure`.
9pub fn apply_relay_lease(bytes: &[u8], disclosure: Disclosure) -> Result<RelayLease, FabricError> {
10    let mut lease = decode_relay_lease(bytes)?;
11    if !matches!(disclosure, Disclosure::DirectPermitted) {
12        lease.export_observations = false;
13    }
14    Ok(lease)
15}
16
17/// Asserts a custody lease cannot forward.
18pub fn custody_cannot_forward(bytes: &[u8]) -> Result<CustodyLease, FabricError> {
19    decode_custody(bytes).map_err(FabricError::from)
20}
21
22/// Charge fails closed. Does not enlarge remaining_bytes.
23pub fn charge_lease(lease: &mut RelayLease, n: u64, now_ms: u64) -> Result<(), FabricError> {
24    lease.charge(n, now_ms).map_err(|_| FabricError::LeaseDead)
25}
26
27/// Encodes `forced-relay-only`.
28pub fn encode_forced_relay_only(lease: &RelayLease, out: &mut [u8]) -> Result<usize, FabricError> {
29    let mut copy = *lease;
30    copy.export_observations = false;
31    encode_relay_lease(&copy, out).map_err(FabricError::from)
32}
33
34#[cfg(test)]
35mod tests {
36    use super::*;
37    use crate::net::peer::fabric::wire::encode_relay_lease;
38
39    #[test]
40    fn relay_only_clears_export_bit() {
41        let l = RelayLease::grant(1, 9, [1u8; 32], [2u8; 32], 20, 100, 1, true);
42        let mut buf = [0u8; 256];
43        let n = encode_relay_lease(&l, &mut buf).unwrap();
44        let got = apply_relay_lease(&buf[..n], Disclosure::ApprovedRelaysOnly).unwrap();
45        assert!(!got.export_observations);
46        let open = apply_relay_lease(&buf[..n], Disclosure::DirectPermitted).unwrap();
47        assert!(open.export_observations);
48        let mut live = got;
49        charge_lease(&mut live, 8, 10).unwrap();
50        assert!(charge_lease(&mut live, 20, 10).is_err());
51        live.expiry_ms = 0;
52        assert!(charge_lease(&mut live, 1, 10).is_err());
53    }
54
55    #[test]
56    fn custody_is_not_a_forwarding_lease() {
57        let c = CustodyLease::grant(4, 1, 50, 2);
58        let mut buf = [0u8; 256];
59        let n = super::super::wire::encode_custody(&c, &mut buf).unwrap();
60        let back = custody_cannot_forward(&buf[..n]).unwrap();
61        assert_eq!(back.max_objects, 2);
62        assert!(encode_forced_relay_only(
63            &RelayLease::grant(1, 1, [1u8; 32], [2u8; 32], 8, 9, 1, true),
64            &mut buf
65        )
66        .is_ok());
67    }
68
69    #[cfg(not(target_arch = "wasm32"))]
70    #[test]
71    fn two_local_peers_exchange_under_cscp_lease() {
72        use std::net::UdpSocket;
73
74        use crate::net::peer::fabric::relay::{decode_payload, encode, BoundUdpRelay};
75
76        let a = [1u8; 32];
77        let b = [2u8; 32];
78        let mut wire = [0u8; 256];
79        let n = encode_forced_relay_only(
80            &RelayLease::grant(11, 1, a, b, 64, 10_000, 1, true),
81            &mut wire,
82        )
83        .unwrap();
84        let lease = apply_relay_lease(&wire[..n], Disclosure::ApprovedRelaysOnly).unwrap();
85        assert!(!lease.export_observations);
86        let mut relay = BoundUdpRelay::bind(lease).unwrap();
87        let addr = relay.addr().unwrap();
88        let sa = UdpSocket::bind("127.0.0.1:0").unwrap();
89        let sb = UdpSocket::bind("127.0.0.1:0").unwrap();
90        sa.set_read_timeout(Some(std::time::Duration::from_millis(250)))
91            .unwrap();
92        sb.set_read_timeout(Some(std::time::Duration::from_millis(250)))
93            .unwrap();
94        let mut pkt = [0u8; 64];
95        let na = encode(&relay.lease, &a, b"ping", &mut pkt).unwrap();
96        sa.send_to(&pkt[..na], addr).unwrap();
97        assert_eq!(relay.forward_once(10).unwrap(), 0);
98        let nb = encode(&relay.lease, &b, b"pong", &mut pkt).unwrap();
99        sb.send_to(&pkt[..nb], addr).unwrap();
100        assert_eq!(relay.forward_once(10).unwrap(), 4);
101        let mut got = [0u8; 64];
102        let (n, _) = sa.recv_from(&mut got).unwrap();
103        assert_eq!(decode_payload(&got[..n]).unwrap(), b"pong");
104        assert_eq!(relay.forwarded, 4);
105    }
106}