1use std::collections::BTreeMap;
4use std::time::{Duration, SystemTime, UNIX_EPOCH};
5
6use serde::{Deserialize, Serialize};
7use serde_json::Value;
8use std::sync::{Arc, Mutex};
9
10use socketio_next::{
11 ClientBuilder, ConnectParams, ConnectionState, LinkInfo, Payload, TransportType,
12};
13
14use crate::error::ErrorPayload;
15
16#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
18#[serde(rename_all = "camelCase")]
19pub enum Access {
20 Full,
22 ReadOnly,
25}
26
27#[derive(Debug, Clone, Copy, Default, Deserialize)]
29#[serde(rename_all = "kebab-case")]
30pub(crate) enum Transports {
31 #[default]
33 Any,
34 Polling,
35 Websocket,
36 WebsocketUpgrade,
38}
39
40#[derive(Default, Deserialize)]
42#[serde(rename_all = "camelCase", deny_unknown_fields)]
43pub(crate) struct ConnectOptions {
44 pub url: String,
45 pub namespace: Option<String>,
46 pub path: Option<String>,
47 #[serde(default)]
48 pub query: BTreeMap<String, String>,
49 #[serde(default)]
50 pub headers: BTreeMap<String, String>,
51 pub auth: Option<Value>,
52 #[serde(default)]
53 pub transports: Transports,
54 pub timeout: Option<u64>,
55 pub reconnection: Option<bool>,
56 pub reconnection_attempts: Option<u32>,
57 pub reconnection_delay: Option<u64>,
58 pub reconnection_delay_max: Option<u64>,
59 pub randomization_factor: Option<f64>,
60 pub reconnect_on_disconnect: Option<bool>,
61 pub buffer_while_disconnected: Option<bool>,
62 pub ca: Option<String>,
64}
65
66impl std::fmt::Debug for ConnectOptions {
68 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
69 f.debug_struct("ConnectOptions")
70 .field("namespace", &self.namespace)
71 .field("path", &self.path)
72 .field("query_keys", &self.query.keys().collect::<Vec<_>>())
73 .field("header_keys", &self.headers.keys().collect::<Vec<_>>())
74 .field("auth", &self.auth.as_ref().map(|_| "***"))
75 .field("transports", &self.transports)
76 .field("ca", &self.ca.is_some())
77 .finish_non_exhaustive()
78 }
79}
80
81pub(crate) fn invalid(err: &serde_json::Error) -> crate::Error {
83 let text = err.to_string();
84 let mut out = String::with_capacity(text.len());
85 let mut quoted = false;
86 for c in text.chars() {
87 match c {
88 '"' if !quoted => {
89 quoted = true;
90 out.push_str("\"***");
91 }
92 '"' => {
93 quoted = false;
94 out.push('"');
95 }
96 _ if quoted => {}
97 c => out.push(c),
98 }
99 }
100 crate::Error::InvalidOptions(out)
101}
102
103impl ConnectOptions {
104 pub(crate) fn parse(value: Value) -> crate::Result<Self> {
106 let options: Self = serde_json::from_value(value).map_err(|e| invalid(&e))?;
107 check_headers(&options.headers)?;
108 Ok(options)
109 }
110
111 pub(crate) fn into_builder(self) -> crate::Result<(ClientBuilder, Arc<Mutex<Dynamic>>)> {
114 let ms = Duration::from_millis;
115 let dynamic = Arc::new(Mutex::new(Dynamic {
116 auth: self.auth,
117 headers: self.headers,
118 query: self.query,
119 }));
120 let mut b = ClientBuilder::new(self.url).transport_type(match self.transports {
121 Transports::Any => TransportType::Any,
122 Transports::Polling => TransportType::Polling,
123 Transports::Websocket => TransportType::Websocket,
124 Transports::WebsocketUpgrade => TransportType::WebsocketUpgrade,
125 });
126 if let Some(v) = self.namespace {
127 b = b.namespace(v);
128 }
129 if let Some(v) = self.path {
130 b = b.path(v);
131 }
132 let (auth, params) = (Arc::clone(&dynamic), Arc::clone(&dynamic));
133 b = b
134 .auth_with(move || {
135 let auth = lock(&auth).auth.clone();
136 async move { auth.unwrap_or_else(|| Value::Object(Default::default())) }
137 })
138 .connect_params_with(move || {
139 let d = lock(¶ms);
140 let mut p = ConnectParams::new();
141 for (k, v) in &d.query {
142 p = p.query(k, v);
143 }
144 for (k, v) in &d.headers {
145 p = p.header(k, v);
146 }
147 async move { p }
148 });
149 if let Some(pem) = self.ca {
150 let tls = socketio_next::TlsConfig::with_root_certificates_pem(pem.as_bytes())
151 .map_err(|e| crate::Error::SocketIo(e.into()))?;
152 #[cfg(any(feature = "rustls", feature = "native-tls"))]
153 {
154 b = b.tls_config(tls);
155 }
156 #[cfg(not(any(feature = "rustls", feature = "native-tls")))]
157 let _ = tls; }
159 if let Some(v) = self.timeout {
160 b = b.timeout(ms(v));
161 }
162 if let Some(v) = self.reconnection {
163 b = b.reconnection(v);
164 }
165 if let Some(v) = self.reconnection_attempts {
166 b = b.reconnection_attempts(v);
167 }
168 if let Some(v) = self.reconnection_delay {
169 b = b.reconnection_delay(ms(v));
170 }
171 if let Some(v) = self.reconnection_delay_max {
172 b = b.reconnection_delay_max(ms(v));
173 }
174 if let Some(v) = self.randomization_factor {
175 b = b.randomization_factor(v);
176 }
177 if let Some(v) = self.reconnect_on_disconnect {
178 b = b.reconnect_on_disconnect(v);
179 }
180 if let Some(v) = self.buffer_while_disconnected {
181 b = b.buffer_while_disconnected(v);
182 }
183 Ok((b, dynamic))
184 }
185}
186
187const FORBIDDEN_HEADERS: &[&str] = &[
190 "host",
191 "connection",
192 "upgrade",
193 "content-length",
194 "transfer-encoding",
195 "cookie",
196];
197
198pub(crate) fn check_headers(headers: &BTreeMap<String, String>) -> crate::Result<()> {
200 for name in headers.keys() {
201 let lower = name.to_ascii_lowercase();
202 if FORBIDDEN_HEADERS.contains(&lower.as_str())
203 || lower.starts_with("sec-websocket-")
204 || lower.starts_with("proxy-")
205 {
206 return Err(crate::Error::InvalidOptions(format!(
207 "the header `{name}` may not be set from the webview"
208 )));
209 }
210 }
211 Ok(())
212}
213
214#[derive(Default)]
216pub(crate) struct Dynamic {
217 pub auth: Option<Value>,
218 pub headers: BTreeMap<String, String>,
219 pub query: BTreeMap<String, String>,
220}
221
222pub(crate) fn lock<T>(m: &Mutex<T>) -> std::sync::MutexGuard<'_, T> {
223 m.lock().unwrap_or_else(std::sync::PoisonError::into_inner)
224}
225
226#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
230pub struct Args {
231 #[serde(default)]
233 pub args: Vec<Value>,
234 #[serde(default, skip_serializing_if = "Vec::is_empty")]
236 pub binary: Vec<Vec<u8>>,
237}
238
239impl From<Payload> for Args {
240 fn from(payload: Payload) -> Self {
241 match payload {
242 Payload::Text(args) => Args {
243 args,
244 binary: Vec::new(),
245 },
246 Payload::Binary(bytes) => Args {
247 args: vec![Payload::placeholder(0)],
248 binary: vec![bytes.to_vec()],
249 },
250 Payload::Mixed { args, attachments } => Args {
251 args,
252 binary: attachments.into_iter().map(|b| b.to_vec()).collect(),
253 },
254 other => Args {
256 args: other.args().to_vec(),
257 binary: other.binary().iter().map(|b| b.to_vec()).collect(),
258 },
259 }
260 }
261}
262
263impl From<Args> for Payload {
264 fn from(args: Args) -> Self {
266 if args.binary.is_empty() {
267 Payload::Text(args.args)
268 } else {
269 Payload::Mixed {
270 args: args.args,
271 attachments: args.binary.into_iter().map(Into::into).collect(),
272 }
273 }
274 }
275}
276
277#[derive(Debug, Clone, PartialEq, Serialize)]
280#[serde(tag = "status", rename_all = "camelCase")]
281#[non_exhaustive]
282pub enum State {
283 #[non_exhaustive]
285 Connecting {
286 attempt: u32,
288 },
289 #[non_exhaustive]
291 Connected {
292 sid: String,
294 recovered: bool,
296 },
297 #[non_exhaustive]
299 Disconnected {
300 reason: String,
302 #[serde(skip_serializing_if = "Option::is_none")]
304 error: Option<ErrorPayload>,
305 },
306 #[non_exhaustive]
308 Reconnecting {
309 attempt: u32,
311 delay: u64,
313 #[serde(skip_serializing_if = "Option::is_none")]
315 error: Option<ErrorPayload>,
316 },
317 #[non_exhaustive]
319 Closed {
320 reason: String,
322 #[serde(skip_serializing_if = "Option::is_none")]
324 error: Option<ErrorPayload>,
325 },
326}
327
328impl From<&ConnectionState> for State {
329 fn from(state: &ConnectionState) -> Self {
330 let err = |e: &Option<socketio_next::Error>| e.as_ref().map(ErrorPayload::from_core);
331 match state {
332 ConnectionState::Connecting { attempt, .. } => State::Connecting { attempt: *attempt },
333 ConnectionState::Connected { sid, recovered, .. } => State::Connected {
334 sid: sid.clone(),
335 recovered: *recovered,
336 },
337 ConnectionState::Disconnected { reason, error, .. } => State::Disconnected {
338 reason: reason.as_str().to_owned(),
339 error: err(error),
340 },
341 ConnectionState::Reconnecting {
342 attempt,
343 delay,
344 error,
345 ..
346 } => State::Reconnecting {
347 attempt: *attempt,
348 delay: millis(*delay),
349 error: err(error),
350 },
351 ConnectionState::Closed { reason, error, .. } => State::Closed {
352 reason: reason.as_str().to_owned(),
353 error: err(error),
354 },
355 _ => State::Connecting { attempt: 0 },
357 }
358 }
359}
360
361fn millis(d: Duration) -> u64 {
362 u64::try_from(d.as_millis()).unwrap_or(u64::MAX)
363}
364
365#[derive(Debug, Clone, Serialize)]
367#[serde(rename_all = "camelCase")]
368pub struct Link {
369 pub sid: Option<String>,
371 pub engine_sid: Option<String>,
373 pub transport: Option<&'static str>,
375 pub ping_interval: Option<u64>,
377 pub ping_timeout: Option<u64>,
379 pub max_payload: Option<u64>,
381 pub connected_at: Option<u64>,
383 pub last_packet_at: Option<u64>,
385 pub last_ping_at: Option<u64>,
387 pub last_attempt_at: Option<u64>,
389 pub reconnect_attempts: u32,
391 pub pending_acks: usize,
393 pub buffered_emits: usize,
395 pub packets_out: u64,
397 pub packets_in: u64,
399 pub bytes_out: u64,
401 pub bytes_in: u64,
403 pub sessions: u32,
405}
406
407impl From<&LinkInfo> for Link {
408 fn from(l: &LinkInfo) -> Self {
409 let now = tokio::time::Instant::now();
410 let wall = SystemTime::now();
411 let epoch = |i: Option<tokio::time::Instant>| {
412 i.and_then(|i| wall.checked_sub(now.saturating_duration_since(i)))
413 .and_then(|t| t.duration_since(UNIX_EPOCH).ok())
414 .map(millis)
415 };
416 Link {
417 sid: l.sid.clone(),
418 engine_sid: l.engine_sid.clone(),
419 transport: l.transport.map(|t| t.as_str()),
420 ping_interval: l.ping_interval.map(millis),
421 ping_timeout: l.ping_timeout.map(millis),
422 max_payload: l.max_payload,
423 connected_at: epoch(l.connected_at),
424 last_packet_at: epoch(l.last_packet_at),
425 last_ping_at: epoch(l.last_ping_at),
426 last_attempt_at: epoch(l.last_attempt_at),
427 reconnect_attempts: l.reconnect_attempts,
428 pending_acks: l.pending_acks,
429 buffered_emits: l.buffered_emits,
430 packets_out: l.packets_out,
431 packets_in: l.packets_in,
432 bytes_out: l.bytes_out,
433 bytes_in: l.bytes_in,
434 sessions: l.sessions,
435 }
436 }
437}
438
439#[derive(Debug, Clone, Serialize)]
441#[serde(rename_all = "camelCase")]
442pub struct ClientInfo {
443 pub id: String,
445 pub access: Access,
447 pub namespace: String,
449 pub state: State,
451}
452
453#[derive(Debug, Clone, Serialize)]
455#[serde(rename_all = "camelCase")]
456pub(crate) struct Subscribed {
457 pub subscription: u64,
458 pub state: State,
460}
461
462#[derive(Debug, Clone, Serialize)]
464#[serde(tag = "type", rename_all = "camelCase")]
465#[non_exhaustive]
466pub enum Message {
467 #[non_exhaustive]
469 State {
470 state: State,
472 #[serde(skip_serializing_if = "std::ops::Not::not")]
475 snapshot: bool,
476 },
477 #[non_exhaustive]
479 Event {
480 event: String,
482 #[serde(flatten)]
484 args: Args,
485 #[serde(rename = "ackId", skip_serializing_if = "Option::is_none")]
487 ack_id: Option<u64>,
488 },
489}
490
491#[cfg(test)]
492mod tests {
493 use super::*;
494 use serde_json::json;
495
496 #[test]
497 fn payload_shapes_round_trip() {
498 let text: Args = Payload::Text(vec![json!(1), json!("a")]).into();
499 assert_eq!(
500 serde_json::to_value(&text).unwrap(),
501 json!({ "args": [1, "a"] })
502 );
503 let bin: Args = Payload::Binary(vec![1u8, 2].into()).into();
504 assert_eq!(
505 serde_json::to_value(&bin).unwrap(),
506 json!({ "args": [{ "_placeholder": true, "num": 0 }], "binary": [[1, 2]] })
507 );
508 let back: Payload = bin.into();
509 assert!(
510 matches!(back, Payload::Mixed { ref attachments, .. } if attachments[0].as_ref() == [1, 2])
511 );
512 let plain: Payload =
513 serde_json::from_value::<Args>(json!({ "args": [{ "_placeholder": true, "num": 0 }] }))
514 .unwrap()
515 .into();
516 assert!(
517 matches!(plain, Payload::Text(_)),
518 "no attachments: placeholders stay JSON"
519 );
520 }
521
522 #[test]
525 fn states_serialize_with_js_reasons() {
526 let s = State::Disconnected {
527 reason: "transport close".into(),
528 error: None,
529 };
530 assert_eq!(
531 serde_json::to_value(s).unwrap(),
532 json!({ "status": "disconnected", "reason": "transport close" })
533 );
534 let s = State::Reconnecting {
535 attempt: 2,
536 delay: 1500,
537 error: Some(ErrorPayload {
538 kind: "NotConnected",
539 message: "x".into(),
540 data: None,
541 }),
542 };
543 let v = serde_json::to_value(s).unwrap();
544 assert_eq!(v["delay"], 1500);
545 assert_eq!(v["error"]["kind"], "NotConnected");
546 }
547
548 #[test]
549 fn event_message_shape() {
550 let m = Message::Event {
551 event: "e".into(),
552 args: Args {
553 args: vec![json!(1)],
554 binary: vec![],
555 },
556 ack_id: Some(7),
557 };
558 assert_eq!(
559 serde_json::to_value(m).unwrap(),
560 json!({ "type": "event", "event": "e", "args": [1], "ackId": 7 })
561 );
562 }
563
564 #[test]
565 fn options_errors_are_typed_and_hide_values() {
566 let err =
567 ConnectOptions::parse(json!({ "url": "http://x", "timeout": "s3cr3t" })).unwrap_err();
568 let crate::Error::InvalidOptions(text) = &err else {
569 panic!("{err:?}")
570 };
571 assert!(!text.contains("s3cr3t") && text.contains("u64"), "{text}");
572 assert!(ConnectOptions::parse(json!({ "url": "http://x", "timeout": 1.5 })).is_err());
573 let opts = ConnectOptions::parse(json!({
574 "url": "http://x?token=q", "auth": { "token": "a" }, "query": { "k": "qv" }, "headers": { "h": "hv" }
575 }))
576 .unwrap();
577 let dbg = format!("{opts:?}");
578 for secret in ["token=q", "\"a\"", "qv", "hv"] {
579 assert!(!dbg.contains(secret), "{dbg}");
580 }
581 }
582
583 #[test]
584 fn webview_headers_are_limited() {
585 for name in [
586 "Host",
587 "cookie",
588 "Sec-WebSocket-Key",
589 "Proxy-Authorization",
590 "Upgrade",
591 ] {
592 let err =
593 ConnectOptions::parse(json!({ "url": "http://x", "headers": { name: "s3cr3t" } }))
594 .err()
595 .unwrap_or_else(|| panic!("{name} accepted"));
596 let text = err.to_string();
597 assert!(text.contains(name) && !text.contains("s3cr3t"), "{text}");
598 }
599 assert!(
600 ConnectOptions::parse(
601 json!({ "url": "http://x", "headers": { "authorization": "Bearer x" } })
602 )
603 .is_ok()
604 );
605 }
606
607 #[test]
608 fn options_reject_unknown_fields() {
609 let err = serde_json::from_value::<ConnectOptions>(
610 json!({ "url": "http://x", "reconection": true }),
611 )
612 .unwrap_err();
613 assert!(err.to_string().contains("reconection"));
614 let ok: ConnectOptions =
615 serde_json::from_value(json!({ "url": "http://x", "transports": "websocket-upgrade" }))
616 .unwrap();
617 assert!(matches!(ok.transports, Transports::WebsocketUpgrade));
618 }
619}