Skip to main content

qualia_core_db/p2p/connectivity/
wss_bearer.rs

1//! QSession Bearer over an already-upgraded WSS stream.
2
3#![cfg(not(target_arch = "wasm32"))]
4
5use std::io::{Read, Write};
6
7use crate::net::qdnf::bearer::contract::{check_frame_mtu, Bearer, RecvMeta};
8use crate::net::qdnf::bearer::mtu::MIN_QDNF_MTU;
9use crate::net::qdnf::errors::QdnfError;
10use crate::net::qdnf::registries::BearerProfile;
11use crate::net::qdnf::types::{ObservedLocator, ScopeEpoch};
12
13use super::wss::{
14    map_io, recv_checked, seal_close, seal_datagram, FrameType, ReadCursor, WriteCursor,
15};
16
17pub struct WssBearer<S> {
18    stream: S,
19    write: WriteCursor,
20    read: ReadCursor,
21    _local: ObservedLocator,
22    remote: ObservedLocator,
23    scope: ScopeEpoch,
24    circuit: u32,
25    gen: u32,
26    client: bool,
27    closing: bool,
28}
29
30impl<S> WssBearer<S> {
31    /// Creates a default `WssBearer` bound to circuit/generation `(1, 1)`.
32    pub fn new(
33        stream: S,
34        local: ObservedLocator,
35        remote: ObservedLocator,
36        scope: ScopeEpoch,
37        client: bool,
38    ) -> Self {
39        Self {
40            stream,
41            write: WriteCursor::new(),
42            read: ReadCursor::new(),
43            _local: local,
44            remote,
45            scope,
46            circuit: 1,
47            gen: 1,
48            client,
49            closing: false,
50        }
51    }
52}
53
54impl<S: Read + Write> Bearer for WssBearer<S> {
55    fn profile(&self) -> BearerProfile {
56        BearerProfile::TlsWssTransitionV1
57    }
58
59    fn mtu(&self) -> u16 {
60        MIN_QDNF_MTU
61    }
62
63    fn scope(&self) -> ScopeEpoch {
64        self.scope
65    }
66
67    fn send(&mut self, dest: &ObservedLocator, frame: &[u8]) -> Result<usize, QdnfError> {
68        check_frame_mtu(frame.len(), self.mtu())?;
69        if dest.as_slice() != self.remote.as_slice() {
70            return Err(QdnfError::Unauthorized);
71        }
72        if self.closing {
73            return Err(QdnfError::Closed);
74        }
75        seal_datagram(&mut self.write, self.circuit, self.gen, frame, self.client)?;
76        self.write.flush(&mut self.stream)?;
77        self.stream.flush().map_err(map_io)?;
78        Ok(frame.len())
79    }
80
81    fn recv(&mut self, out: &mut [u8]) -> Result<(usize, RecvMeta), QdnfError> {
82        let (typ, n) = recv_checked(
83            &mut self.stream,
84            &mut self.read,
85            self.circuit,
86            self.gen,
87            Some(!self.client),
88            out,
89        )?;
90        match typ {
91            FrameType::Datagram => Ok((
92                n,
93                RecvMeta {
94                    observed_source: self.remote,
95                    scope: self.scope,
96                    mtu: self.mtu(),
97                },
98            )),
99            FrameType::Close => Err(QdnfError::Closed),
100            FrameType::Auth => Err(QdnfError::Malformed),
101        }
102    }
103
104    fn shutdown(&mut self) -> Result<(), QdnfError> {
105        self.closing = true;
106        seal_close(&mut self.write, self.circuit, self.gen, self.client)?;
107        self.write.flush(&mut self.stream)?;
108        self.stream.flush().map_err(map_io)?;
109        Ok(())
110    }
111}