lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

session_socket.rs (11381B)


      1 //! One upstream protocol session over caller-selected byte I/O.
      2 
      3 use crate::{RelayEndpoint, RelayUrl, RelayUrlPolicy, relay::policy_error};
      4 use async_wsocket::Message;
      5 use futures::{Sink, future::BoxFuture, stream};
      6 use nostr_sdk::{
      7     error::Error as TransportError,
      8     transport::websocket::{WebSocketSink, WebSocketStream, WebSocketTransport},
      9 };
     10 use radroots_transport::host::websocket::{
     11     Admission, Connector, Error as HostError, Frame, Socket,
     12 };
     13 use std::{
     14     collections::BTreeMap,
     15     fmt,
     16     net::{IpAddr, SocketAddr},
     17     num::NonZeroUsize,
     18     pin::Pin,
     19     sync::Arc,
     20     task::{Context, Poll},
     21     time::Duration,
     22 };
     23 use url::Url;
     24 
     25 pub(crate) const MAX_WIRE_MESSAGE_BYTES: usize = 512 * 1024;
     26 
     27 #[derive(Clone, Debug)]
     28 pub(crate) struct SessionWebsocketTransport {
     29     host: Arc<dyn Connector>,
     30     policies: Arc<BTreeMap<String, RelayUrlPolicy>>,
     31     connect_timeout: Duration,
     32     pub(crate) writers: crate::socket_write::WriterRegistry,
     33     pub(crate) ingress: crate::source_ingress::IngressRegistry,
     34 }
     35 
     36 impl SessionWebsocketTransport {
     37     pub(crate) fn new(
     38         endpoints: &[RelayEndpoint],
     39         connect_timeout: Duration,
     40         host: Arc<dyn Connector>,
     41     ) -> Self {
     42         Self {
     43             host,
     44             connect_timeout,
     45             ingress: crate::source_ingress::IngressRegistry::new(
     46                 endpoints
     47                     .iter()
     48                     .map(|endpoint| endpoint.url().as_str().to_owned()),
     49             ),
     50             writers: crate::socket_write::WriterRegistry::new(
     51                 endpoints
     52                     .iter()
     53                     .map(|endpoint| endpoint.url().as_str().to_owned()),
     54             ),
     55             policies: Arc::new(
     56                 endpoints
     57                     .iter()
     58                     .map(|endpoint| (endpoint.url().as_str().to_owned(), endpoint.policy()))
     59                     .collect(),
     60             ),
     61         }
     62     }
     63 }
     64 
     65 impl WebSocketTransport for SessionWebsocketTransport {
     66     fn support_ping(&self) -> bool {
     67         self.host.supports_ping()
     68     }
     69 
     70     fn connect<'a>(
     71         &'a self,
     72         url: &'a Url,
     73         proxy: Option<SocketAddr>,
     74     ) -> BoxFuture<'a, Result<(WebSocketSink, WebSocketStream), TransportError>> {
     75         Box::pin(async move {
     76             if proxy.is_some() {
     77                 return Err(policy_error(
     78                     "proxy and Tor connection modes are not configured",
     79                 ));
     80             }
     81             let policy = self
     82                 .policies
     83                 .get(configured_policy_key(url))
     84                 .copied()
     85                 .ok_or_else(|| policy_error("relay URL is not configured"))?;
     86             let relay = RelayUrl::parse(url.as_str(), policy)
     87                 .map_err(|_| policy_error("relay URL is denied by network policy"))?;
     88             let ingress = self
     89                 .ingress
     90                 .connection(relay.as_str())
     91                 .ok_or_else(|| policy_error("relay ingress unavailable"))?;
     92             let originals = ingress.clone();
     93             let admission = Arc::new(ConnectionAdmission { policy, ingress });
     94             let limit = NonZeroUsize::new(MAX_WIRE_MESSAGE_BYTES)
     95                 .expect("the fixed wire limit is positive");
     96             let socket = crate::host_time::timeout(
     97                 self.connect_timeout,
     98                 self.host
     99                     .connect(relay.as_str(), self.connect_timeout, limit, admission),
    100             )
    101             .await
    102             .map_err(|_| policy_error("relay connection deadline elapsed"))?
    103             .map_err(host_error)?;
    104             let writer =
    105                 crate::socket_write::SocketWriter::new(Box::pin(HostSink::new(socket.clone())));
    106             self.writers.install(relay.as_str(), &writer)?;
    107             let sink: WebSocketSink = Box::pin(crate::socket_write::SharedSocketSink::new(writer));
    108             let receiver =
    109                 stream::try_unfold((socket, originals), |(socket, originals)| async move {
    110                     let frame = socket.receive().await.map_err(host_error)?;
    111                     let message = frame.map(from_host_frame).transpose()?.flatten();
    112                     if let Some(Message::Text(text)) = &message
    113                         && !originals.capture(text)
    114                     {
    115                         return Err(policy_error("original relay ingress unavailable"));
    116                     }
    117                     Ok(message.map(|message| (message, (socket, originals))))
    118                 });
    119             Ok((sink, Box::pin(receiver) as WebSocketStream))
    120         })
    121     }
    122 }
    123 
    124 struct ConnectionAdmission {
    125     policy: RelayUrlPolicy,
    126     ingress: crate::source_ingress::IngressConnection,
    127 }
    128 
    129 impl Admission for ConnectionAdmission {
    130     fn permits_address(&self, address: IpAddr) -> bool {
    131         self.policy.accepts_address(address)
    132     }
    133     fn admitted_read(&self, context: &Context<'_>) -> bool {
    134         self.ingress.admitted(context)
    135     }
    136     fn admitted_write(&self, context: &Context<'_>) -> bool {
    137         self.ingress.admitted_write(context)
    138     }
    139     fn charge(&self, bytes: usize, frames: usize, data: usize) -> bool {
    140         self.ingress.charge(bytes, frames, data)
    141     }
    142 }
    143 
    144 fn configured_policy_key(url: &Url) -> &str {
    145     if url.path() == "/" && url.query().is_none() && url.fragment().is_none() {
    146         url.as_str().strip_suffix('/').unwrap_or(url.as_str())
    147     } else {
    148         url.as_str()
    149     }
    150 }
    151 
    152 fn host_error(error: HostError) -> TransportError {
    153     match error {
    154         HostError::Policy => policy_error("relay socket policy rejected"),
    155         HostError::Timeout => TransportError::with_static_message(
    156             nostr_sdk::error::ErrorKind::Timeout,
    157             "relay connection timed out",
    158         ),
    159         other => TransportError::transport(other),
    160     }
    161 }
    162 
    163 fn from_host_frame(frame: Frame) -> Result<Option<Message>, TransportError> {
    164     Ok(Some(match frame {
    165         Frame::Text(text) => {
    166             validate_wire_identifiers(&text)?;
    167             Message::Text(text)
    168         }
    169         Frame::Binary(bytes) => {
    170             if bytes.len() > MAX_WIRE_MESSAGE_BYTES {
    171                 return Err(policy_error("relay message exceeds the wire limit"));
    172             }
    173             // Preserve the original host bytes. The upstream Nostr session
    174             // explicitly ignores binary messages; never promote them to text.
    175             Message::Binary(bytes)
    176         }
    177         #[cfg(not(target_arch = "wasm32"))]
    178         Frame::Ping(bytes) => Message::Ping(bytes),
    179         #[cfg(not(target_arch = "wasm32"))]
    180         Frame::Pong(bytes) => Message::Pong(bytes),
    181         #[cfg(not(target_arch = "wasm32"))]
    182         Frame::Close(frame) => {
    183             Message::Close(frame.map(|frame| async_wsocket::message::CloseFrame {
    184                 code: frame.code,
    185                 reason: frame.reason,
    186             }))
    187         }
    188         #[cfg(target_arch = "wasm32")]
    189         Frame::Close(_) => return Ok(None),
    190         _ => return Err(policy_error("unsupported host frame")),
    191     }))
    192 }
    193 
    194 fn validate_wire_identifiers(text: &str) -> Result<(), TransportError> {
    195     if text.len() > MAX_WIRE_MESSAGE_BYTES {
    196         return Err(policy_error("relay message exceeds the wire limit"));
    197     }
    198     // Inspect original identifiers before the upstream fixed-array decoder.
    199     // Never normalize or reserialize the accepted original message.
    200     let Ok(serde_json::Value::Array(fields)) = serde_json::from_str(text) else {
    201         return Ok(());
    202     };
    203     let canonical_hex = |value: Option<&serde_json::Value>, length| {
    204         value
    205             .and_then(serde_json::Value::as_str)
    206             .is_some_and(|value| {
    207                 value.len() == length
    208                     && value
    209                         .bytes()
    210                         .all(|byte| byte.is_ascii_digit() || matches!(byte, b'a'..=b'f'))
    211             })
    212     };
    213     let valid = match fields.first().and_then(serde_json::Value::as_str) {
    214         Some("OK") => canonical_hex(fields.get(1), 64),
    215         Some("EVENT") => fields.get(2).is_some_and(|event| {
    216             canonical_hex(event.get("id"), 64)
    217                 && canonical_hex(event.get("pubkey"), 64)
    218                 && canonical_hex(event.get("sig"), 128)
    219         }),
    220         _ => true,
    221     };
    222     if !valid {
    223         return Err(policy_error("relay message has a noncanonical identifier"));
    224     }
    225     Ok(())
    226 }
    227 
    228 fn to_host_frame(message: Message) -> Frame {
    229     match message {
    230         Message::Text(text) => Frame::Text(text),
    231         Message::Binary(bytes) => Frame::Binary(bytes),
    232         #[cfg(not(target_arch = "wasm32"))]
    233         Message::Ping(bytes) => Frame::Ping(bytes),
    234         #[cfg(not(target_arch = "wasm32"))]
    235         Message::Pong(bytes) => Frame::Pong(bytes),
    236         #[cfg(not(target_arch = "wasm32"))]
    237         Message::Close(frame) => {
    238             Frame::Close(
    239                 frame.map(|frame| radroots_transport::host::websocket::CloseFrame {
    240                     code: frame.code,
    241                     reason: frame.reason,
    242                 }),
    243             )
    244         }
    245     }
    246 }
    247 
    248 struct HostSink {
    249     socket: Arc<dyn Socket>,
    250     pending: Option<BoxFuture<'static, Result<(), TransportError>>>,
    251     closing: bool,
    252 }
    253 
    254 impl HostSink {
    255     fn new(socket: Arc<dyn Socket>) -> Self {
    256         Self {
    257             socket,
    258             pending: None,
    259             closing: false,
    260         }
    261     }
    262     fn poll_pending(&mut self, context: &mut Context<'_>) -> Poll<Result<(), TransportError>> {
    263         if let Some(pending) = &mut self.pending {
    264             let result = futures::ready!(pending.as_mut().poll(context));
    265             self.pending = None;
    266             return Poll::Ready(result);
    267         }
    268         Poll::Ready(Ok(()))
    269     }
    270 }
    271 
    272 impl Sink<Message> for HostSink {
    273     type Error = TransportError;
    274     fn poll_ready(
    275         mut self: Pin<&mut Self>,
    276         context: &mut Context<'_>,
    277     ) -> Poll<Result<(), TransportError>> {
    278         if self.closing {
    279             return Poll::Ready(Err(policy_error("host socket is closing")));
    280         }
    281         self.poll_pending(context)
    282     }
    283     fn start_send(mut self: Pin<&mut Self>, message: Message) -> Result<(), TransportError> {
    284         if self.closing || self.pending.is_some() {
    285             return Err(policy_error("host socket is not ready"));
    286         }
    287         let socket = self.socket.clone();
    288         let frame = to_host_frame(message);
    289         self.pending = Some(Box::pin(async move {
    290             socket.send(frame).await.map_err(host_error)
    291         }));
    292         Ok(())
    293     }
    294     fn poll_flush(
    295         mut self: Pin<&mut Self>,
    296         context: &mut Context<'_>,
    297     ) -> Poll<Result<(), TransportError>> {
    298         self.poll_pending(context)
    299     }
    300     fn poll_close(
    301         mut self: Pin<&mut Self>,
    302         context: &mut Context<'_>,
    303     ) -> Poll<Result<(), TransportError>> {
    304         futures::ready!(self.poll_pending(context))?;
    305         if !self.closing {
    306             self.closing = true;
    307             let socket = self.socket.clone();
    308             self.pending = Some(Box::pin(
    309                 async move { socket.close().await.map_err(host_error) },
    310             ));
    311         }
    312         self.poll_pending(context)
    313     }
    314 }
    315 
    316 impl fmt::Debug for ConnectionAdmission {
    317     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    318         formatter.write_str("ConnectionAdmission([redacted])")
    319     }
    320 }
    321 
    322 #[cfg(test)]
    323 #[path = "session_socket_tests.rs"]
    324 mod tests;