lib

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

io.rs (11596B)


      1 use futures::{FutureExt, SinkExt, StreamExt, task::AtomicWaker};
      2 use radroots_transport::host::websocket::{Admission, Connector, Error, Frame, Socket};
      3 use radroots_transport_nostr_native::NativeConnector;
      4 use std::{
      5     net::IpAddr,
      6     num::NonZeroUsize,
      7     sync::{
      8         Arc,
      9         atomic::{AtomicBool, AtomicUsize, Ordering},
     10     },
     11     task::Context,
     12     time::Duration,
     13 };
     14 use tokio::{
     15     io::{AsyncReadExt, AsyncWriteExt},
     16     net::TcpListener,
     17     sync::oneshot,
     18 };
     19 use tokio_tungstenite::{accept_async, tungstenite::Message};
     20 
     21 const WATCHDOG: Duration = Duration::from_secs(5);
     22 
     23 struct Permit {
     24     open: AtomicBool,
     25     addresses: bool,
     26     bytes: AtomicUsize,
     27     limit: AtomicUsize,
     28     frames: AtomicUsize,
     29     reads: AtomicUsize,
     30     reader_seen: tokio::sync::Notify,
     31     reader: AtomicWaker,
     32     writer: AtomicWaker,
     33 }
     34 
     35 impl Permit {
     36     fn new(addresses: bool) -> Arc<Self> {
     37         Arc::new(Self {
     38             open: AtomicBool::new(true),
     39             addresses,
     40             bytes: AtomicUsize::new(0),
     41             limit: AtomicUsize::new(usize::MAX),
     42             frames: AtomicUsize::new(0),
     43             reads: AtomicUsize::new(0),
     44             reader_seen: tokio::sync::Notify::new(),
     45             reader: AtomicWaker::new(),
     46             writer: AtomicWaker::new(),
     47         })
     48     }
     49     fn revoke(&self) {
     50         self.open.store(false, Ordering::SeqCst);
     51         self.reader.wake();
     52         self.writer.wake();
     53     }
     54 }
     55 
     56 impl Admission for Permit {
     57     fn permits_address(&self, address: IpAddr) -> bool {
     58         self.addresses && address.is_loopback()
     59     }
     60     fn admitted_read(&self, context: &Context<'_>) -> bool {
     61         self.reader.register(context.waker());
     62         self.reads.fetch_add(1, Ordering::SeqCst);
     63         self.reader_seen.notify_waiters();
     64         self.open.load(Ordering::SeqCst)
     65     }
     66     fn admitted_write(&self, context: &Context<'_>) -> bool {
     67         self.writer.register(context.waker());
     68         self.open.load(Ordering::SeqCst)
     69     }
     70     fn charge(&self, bytes: usize, frames: usize, _: usize) -> bool {
     71         let prior = self.bytes.fetch_add(bytes, Ordering::SeqCst);
     72         self.frames.fetch_add(frames, Ordering::SeqCst);
     73         prior
     74             .checked_add(bytes)
     75             .is_some_and(|total| total <= self.limit.load(Ordering::SeqCst))
     76     }
     77 }
     78 
     79 async fn connect(url: &str, permit: Arc<Permit>, limit: usize) -> Arc<dyn Socket> {
     80     NativeConnector
     81         .connect(
     82             url,
     83             Duration::from_secs(1),
     84             NonZeroUsize::new(limit).unwrap(),
     85             permit,
     86         )
     87         .await
     88         .unwrap()
     89 }
     90 
     91 #[tokio::test]
     92 async fn construction_unpolled_connection_and_denied_authority_open_no_socket() {
     93     let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
     94     let url = format!("ws://{}", listener.local_addr().unwrap());
     95     let permit = Permit::new(true);
     96     let future = NativeConnector.connect(
     97         &url,
     98         Duration::from_secs(1),
     99         NonZeroUsize::new(1024).unwrap(),
    100         permit.clone(),
    101     );
    102     drop(future);
    103     assert!(listener.accept().now_or_never().is_none());
    104     permit.revoke();
    105     assert_eq!(
    106         NativeConnector
    107             .connect(
    108                 &url,
    109                 Duration::from_secs(1),
    110                 NonZeroUsize::new(1024).unwrap(),
    111                 permit
    112             )
    113             .await
    114             .err(),
    115         Some(Error::Policy)
    116     );
    117     assert_eq!(
    118         NativeConnector
    119             .connect(
    120                 &url,
    121                 Duration::from_secs(1),
    122                 NonZeroUsize::new(1024).unwrap(),
    123                 Permit::new(false)
    124             )
    125             .await
    126             .err(),
    127         Some(Error::Policy)
    128     );
    129     assert!(listener.accept().now_or_never().is_none());
    130     for url in [
    131         "https://127.0.0.1",
    132         "ws://user:secret@127.0.0.1",
    133         "ws://127.0.0.1/#fragment",
    134         "invalid",
    135     ] {
    136         assert_eq!(
    137             NativeConnector
    138                 .connect(
    139                     url,
    140                     Duration::from_secs(1),
    141                     NonZeroUsize::new(1024).unwrap(),
    142                     Permit::new(true)
    143                 )
    144                 .await
    145                 .err(),
    146             Some(Error::Policy)
    147         );
    148     }
    149 }
    150 
    151 #[tokio::test]
    152 async fn original_text_binary_and_control_frames_share_one_socket_then_close() {
    153     tokio::time::timeout(WATCHDOG, async {
    154         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    155         let url = format!("ws://{}", listener.local_addr().unwrap());
    156         let original = " \n[\"EVENT\", { \"z\":1, \"a\":2 }] \t";
    157         let server = tokio::spawn(async move {
    158             let (tcp, _) = listener.accept().await.unwrap();
    159             let mut socket = accept_async(tcp).await.unwrap();
    160             assert_eq!(
    161                 socket.next().await.unwrap().unwrap(),
    162                 Message::Text(original.into())
    163             );
    164             socket.send(Message::Text(original.into())).await.unwrap();
    165             let binary = vec![0, 255, 1];
    166             assert_eq!(
    167                 socket.next().await.unwrap().unwrap(),
    168                 Message::Binary(binary.clone().into())
    169             );
    170             socket.send(Message::Binary(binary.into())).await.unwrap();
    171             assert_eq!(
    172                 socket.next().await.unwrap().unwrap(),
    173                 Message::Ping(vec![7].into())
    174             );
    175             socket.flush().await.unwrap();
    176             assert_eq!(
    177                 socket.next().await.unwrap().unwrap(),
    178                 Message::Pong(vec![9].into())
    179             );
    180             assert!(matches!(
    181                 socket.next().await.unwrap().unwrap(),
    182                 Message::Close(_)
    183             ));
    184             socket.flush().await.unwrap();
    185         });
    186         let permit = Permit::new(true);
    187         let socket = connect(&url, permit.clone(), 1024).await;
    188         assert!(NativeConnector.supports_ping());
    189         socket.send(Frame::Text(original.to_owned())).await.unwrap();
    190         assert_eq!(
    191             socket.receive().await.unwrap(),
    192             Some(Frame::Text(original.to_owned()))
    193         );
    194         socket.send(Frame::Binary(vec![0, 255, 1])).await.unwrap();
    195         assert_eq!(
    196             socket.receive().await.unwrap(),
    197             Some(Frame::Binary(vec![0, 255, 1]))
    198         );
    199         socket.send(Frame::Ping(vec![7])).await.unwrap();
    200         assert_eq!(socket.receive().await.unwrap(), Some(Frame::Pong(vec![7])));
    201         socket.send(Frame::Pong(vec![9])).await.unwrap();
    202         assert!(permit.frames.load(Ordering::SeqCst) >= 3);
    203         socket.close().await.unwrap();
    204         server.await.unwrap();
    205     })
    206     .await
    207     .unwrap();
    208 }
    209 
    210 #[tokio::test]
    211 async fn secure_endpoint_sends_tls_and_refuses_a_plaintext_upgrade() {
    212     tokio::time::timeout(WATCHDOG, async {
    213         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    214         let url = format!("wss://{}", listener.local_addr().unwrap());
    215         let server = tokio::spawn(async move {
    216             let (mut socket, _) = listener.accept().await.unwrap();
    217             let mut prefix = [0; 5];
    218             socket.read_exact(&mut prefix).await.unwrap();
    219             socket
    220                 .write_all(b"HTTP/1.1 101 Switching Protocols\r\n\r\n")
    221                 .await
    222                 .unwrap();
    223             prefix
    224         });
    225         assert_eq!(
    226             NativeConnector
    227                 .connect(
    228                     &url,
    229                     Duration::from_secs(1),
    230                     NonZeroUsize::new(1024).unwrap(),
    231                     Permit::new(true)
    232                 )
    233                 .await
    234                 .err(),
    235             Some(Error::Unavailable)
    236         );
    237         let prefix = server.await.unwrap();
    238         assert_eq!(&prefix[..2], &[0x16, 0x03]);
    239     })
    240     .await
    241     .unwrap();
    242 }
    243 
    244 #[tokio::test]
    245 async fn handshake_deadline_disposes_the_original_tcp_connection() {
    246     tokio::time::timeout(WATCHDOG, async {
    247         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    248         let url = format!("ws://{}", listener.local_addr().unwrap());
    249         let server = tokio::spawn(async move {
    250             let (mut socket, _) = listener.accept().await.unwrap();
    251             let mut bytes = [0; 4096];
    252             loop {
    253                 if socket.read(&mut bytes).await.unwrap() == 0 {
    254                     break;
    255                 }
    256             }
    257         });
    258         assert_eq!(
    259             NativeConnector
    260                 .connect(
    261                     &url,
    262                     Duration::from_millis(50),
    263                     NonZeroUsize::new(1024).unwrap(),
    264                     Permit::new(true)
    265                 )
    266                 .await
    267                 .err(),
    268             Some(Error::Timeout)
    269         );
    270         server.await.unwrap();
    271     })
    272     .await
    273     .unwrap();
    274 }
    275 
    276 #[tokio::test]
    277 async fn revocation_wakes_a_pending_read_and_prevents_later_writes() {
    278     tokio::time::timeout(WATCHDOG, async {
    279         let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    280         let url = format!("ws://{}", listener.local_addr().unwrap());
    281         let server = tokio::spawn(async move {
    282             let (tcp, _) = listener.accept().await.unwrap();
    283             let mut socket = accept_async(tcp).await.unwrap();
    284             while let Some(message) = socket.next().await {
    285                 if message.is_err() {
    286                     break;
    287                 }
    288             }
    289         });
    290         let permit = Permit::new(true);
    291         let socket = connect(&url, permit.clone(), 1024).await;
    292         let before = permit.reads.load(Ordering::SeqCst);
    293         let reader = socket.clone();
    294         let receive = tokio::spawn(async move { reader.receive().await });
    295         loop {
    296             let observed = permit.reader_seen.notified();
    297             tokio::pin!(observed);
    298             observed.as_mut().enable();
    299             if permit.reads.load(Ordering::SeqCst) > before {
    300                 break;
    301             }
    302             observed.await;
    303         }
    304         permit.revoke();
    305         assert_eq!(receive.await.unwrap(), Err(Error::Unavailable));
    306         assert_eq!(
    307             socket.send(Frame::Text("denied".to_owned())).await,
    308             Err(Error::Unavailable)
    309         );
    310         drop(socket);
    311         server.await.unwrap();
    312     })
    313     .await
    314     .unwrap();
    315 }
    316 
    317 #[tokio::test]
    318 async fn oversized_frames_and_refused_raw_bytes_never_reach_the_message_reader() {
    319     for raw_budget in [false, true] {
    320         tokio::time::timeout(WATCHDOG, async {
    321             let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    322             let url = format!("ws://{}", listener.local_addr().unwrap());
    323             let (ready, wait) = oneshot::channel();
    324             let server = tokio::spawn(async move {
    325                 let (tcp, _) = listener.accept().await.unwrap();
    326                 let mut socket = accept_async(tcp).await.unwrap();
    327                 wait.await.unwrap();
    328                 socket
    329                     .send(Message::Binary(vec![1; 128].into()))
    330                     .await
    331                     .unwrap();
    332             });
    333             let permit = Permit::new(true);
    334             let socket = connect(&url, permit.clone(), if raw_budget { 1024 } else { 64 }).await;
    335             if raw_budget {
    336                 permit
    337                     .limit
    338                     .store(permit.bytes.load(Ordering::SeqCst), Ordering::SeqCst);
    339             }
    340             ready.send(()).unwrap();
    341             assert_eq!(socket.receive().await, Err(Error::Unavailable));
    342             drop(socket);
    343             server.await.unwrap();
    344         })
    345         .await
    346         .unwrap();
    347     }
    348 }