lib

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

socket.rs (5290B)


      1 use crate::wire::MeteredIo;
      2 use futures::{
      3     SinkExt, StreamExt,
      4     lock::Mutex,
      5     stream::{SplitSink, SplitStream},
      6 };
      7 use radroots_transport::host::websocket::{CloseFrame, Error, Frame, IoFuture, Socket};
      8 use tokio::net::TcpStream;
      9 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream, tungstenite::Message};
     10 
     11 type NativeStream = WebSocketStream<MeteredIo<MaybeTlsStream<TcpStream>>>;
     12 
     13 pub(crate) struct NativeSocket {
     14     sink: Mutex<SplitSink<NativeStream, Message>>,
     15     stream: Mutex<SplitStream<NativeStream>>,
     16     max_message_bytes: usize,
     17 }
     18 
     19 impl NativeSocket {
     20     pub(crate) fn new(
     21         sink: SplitSink<NativeStream, Message>,
     22         stream: SplitStream<NativeStream>,
     23         max_message_bytes: usize,
     24     ) -> Self {
     25         Self {
     26             sink: Mutex::new(sink),
     27             stream: Mutex::new(stream),
     28             max_message_bytes,
     29         }
     30     }
     31 }
     32 
     33 impl Socket for NativeSocket {
     34     fn send(&self, frame: Frame) -> IoFuture<'_, Result<(), Error>> {
     35         Box::pin(async move {
     36             let message = to_wire(frame, self.max_message_bytes)?;
     37             self.sink
     38                 .lock()
     39                 .await
     40                 .send(message)
     41                 .await
     42                 .map_err(|_| Error::Unavailable)
     43         })
     44     }
     45 
     46     fn receive(&self) -> IoFuture<'_, Result<Option<Frame>, Error>> {
     47         Box::pin(async move {
     48             self.stream
     49                 .lock()
     50                 .await
     51                 .next()
     52                 .await
     53                 .transpose()
     54                 .map_err(|_| Error::Unavailable)?
     55                 .map(from_wire)
     56                 .transpose()
     57         })
     58     }
     59 
     60     fn close(&self) -> IoFuture<'_, Result<(), Error>> {
     61         Box::pin(async move {
     62             self.sink
     63                 .lock()
     64                 .await
     65                 .close()
     66                 .await
     67                 .map_err(|_| Error::Unavailable)
     68         })
     69     }
     70 }
     71 
     72 fn to_wire(frame: Frame, limit: usize) -> Result<Message, Error> {
     73     Ok(match frame {
     74         Frame::Text(value) if value.len() <= limit => Message::Text(value.into()),
     75         Frame::Binary(value) if value.len() <= limit => Message::Binary(value.into()),
     76         Frame::Ping(value) if value.len() <= 125 => Message::Ping(value.into()),
     77         Frame::Pong(value) if value.len() <= 125 => Message::Pong(value.into()),
     78         Frame::Close(None) => Message::Close(None),
     79         Frame::Close(Some(value)) if value.reason.len() <= 123 => {
     80             Message::Close(Some(tokio_tungstenite::tungstenite::protocol::CloseFrame {
     81                 code: value.code.into(),
     82                 reason: value.reason.into(),
     83             }))
     84         }
     85         _ => return Err(Error::Protocol),
     86     })
     87 }
     88 
     89 fn from_wire(message: Message) -> Result<Frame, Error> {
     90     Ok(match message {
     91         Message::Text(value) => Frame::Text(value.to_string()),
     92         Message::Binary(value) => Frame::Binary(value.to_vec()),
     93         Message::Ping(value) => Frame::Ping(value.to_vec()),
     94         Message::Pong(value) => Frame::Pong(value.to_vec()),
     95         Message::Close(value) => Frame::Close(value.map(|value| CloseFrame {
     96             code: value.code.into(),
     97             reason: value.reason.to_string(),
     98         })),
     99         Message::Frame(_) => return Err(Error::Protocol),
    100     })
    101 }
    102 
    103 #[cfg(test)]
    104 mod tests {
    105     use super::*;
    106 
    107     #[test]
    108     fn data_control_and_original_close_information_round_trip_without_reencoding() {
    109         for frame in [
    110             Frame::Text(" \n{ \"z\":1, \"a\":2 } \t".into()),
    111             Frame::Binary(vec![0, 255]),
    112             Frame::Ping(vec![1]),
    113             Frame::Pong(vec![2]),
    114             Frame::Close(None),
    115             Frame::Close(Some(CloseFrame {
    116                 code: 1000,
    117                 reason: "complete".into(),
    118             })),
    119         ] {
    120             assert_eq!(
    121                 from_wire(to_wire(frame.clone(), 1024).unwrap()).unwrap(),
    122                 frame
    123             );
    124         }
    125     }
    126 
    127     #[test]
    128     fn every_outgoing_data_and_control_bound_is_checked_before_socket_io() {
    129         for frame in [Frame::Text("x".repeat(64)), Frame::Binary(vec![1; 64])] {
    130             assert!(to_wire(frame, 64).is_ok());
    131         }
    132         for frame in [
    133             Frame::Text("x".repeat(65)),
    134             Frame::Binary(vec![1; 65]),
    135             Frame::Ping(vec![1; 126]),
    136             Frame::Pong(vec![1; 126]),
    137             Frame::Close(Some(CloseFrame {
    138                 code: 1000,
    139                 reason: "x".repeat(124),
    140             })),
    141         ] {
    142             assert_eq!(to_wire(frame, 64).err(), Some(Error::Protocol));
    143         }
    144         for frame in [
    145             Frame::Ping(vec![1; 125]),
    146             Frame::Pong(vec![1; 125]),
    147             Frame::Close(Some(CloseFrame {
    148                 code: 1000,
    149                 reason: "x".repeat(123),
    150             })),
    151         ] {
    152             assert!(to_wire(frame, 64).is_ok());
    153         }
    154         let raw = tokio_tungstenite::tungstenite::protocol::frame::Frame::message(
    155             vec![1],
    156             tokio_tungstenite::tungstenite::protocol::frame::coding::OpCode::Data(
    157                 tokio_tungstenite::tungstenite::protocol::frame::coding::Data::Binary,
    158             ),
    159             true,
    160         );
    161         assert_eq!(from_wire(Message::Frame(raw)).err(), Some(Error::Protocol));
    162     }
    163 }