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 }