use std::sync::Arc;
use std::time::Duration;
use tokio_tungstenite::tungstenite;
#[derive(Debug, Clone, thiserror::Error)]
#[non_exhaustive]
pub enum Error {
#[error(transparent)]
Protocol(#[from] crate::protocol::Error),
#[error("invalid URL: {0}")]
InvalidUrl(#[from] url::ParseError),
#[error("unsupported URL scheme `{0}` (expected http, https, ws or wss)")]
InvalidUrlScheme(String),
#[error("HTTP request failed: {0}")]
Http(#[source] Arc<reqwest::Error>),
#[error("server answered HTTP {status}{}", message.as_ref().map(|m| format!(": {m}")).unwrap_or_default())]
#[non_exhaustive]
HttpStatus {
status: u16,
message: Option<String>,
},
#[error("proxy: {0}")]
ProxyFailed(String),
#[error("the server closed the websocket (code {code}{})", if reason.is_empty() { String::new() } else { format!(": {reason}") })]
#[non_exhaustive]
WebsocketClosed {
code: u16,
reason: String,
},
#[error("websocket error: {0}")]
Websocket(#[source] Arc<tungstenite::Error>),
#[error("invalid engine.io handshake: {0}")]
InvalidHandshake(String),
#[error("the engine.io connection is not open")]
NotConnected,
#[error("the server does not offer a websocket upgrade")]
UpgradeUnavailable,
#[error("websocket upgrade probe failed: {0}")]
UpgradeFailed(&'static str),
#[error("no ping from the server within pingInterval + pingTimeout")]
PingTimeout,
#[error("timed out after {0:?}")]
Timeout(Duration),
#[error(
"`{0}` needs TLS, but socketio-next was built without the `rustls` or `native-tls` feature"
)]
TlsNotEnabled(String),
#[error(
"reqwest was built with rustls by another crate but has no crypto provider: enable the `rustls` feature of socketio-next or install a rustls CryptoProvider before connecting"
)]
TlsProviderMissing,
#[error("invalid TLS configuration: {0}")]
InvalidTlsConfig(String),
}
impl From<reqwest::Error> for Error {
fn from(err: reqwest::Error) -> Self {
Error::Http(Arc::new(err.without_url()))
}
}
impl From<tungstenite::Error> for Error {
fn from(err: tungstenite::Error) -> Self {
match err {
tungstenite::Error::Http(response) => Error::HttpStatus {
status: response.status().as_u16(),
message: None,
},
err => Error::Websocket(Arc::new(err)),
}
}
}
impl From<std::str::Utf8Error> for Error {
fn from(err: std::str::Utf8Error) -> Self {
Error::Protocol(err.into())
}
}
pub(crate) fn body_message(body: &[u8]) -> Option<String> {
let json: serde_json::Value = serde_json::from_slice(body).ok()?;
json.get("code")?.as_u64()?;
let message = json.get("message")?.as_str()?;
let text = message
.split_whitespace()
.map(|word| {
let lower = word.to_ascii_lowercase();
if word.contains("://") {
"<url>"
} else if word.starts_with('/')
|| word.starts_with('?')
|| ((lower.contains('?') || lower.contains('&')) && lower.contains('='))
{
"<redacted>"
} else {
word
}
})
.collect::<Vec<_>>()
.join(" ");
let text: String = text.chars().take(200).collect();
(!text.is_empty()).then_some(text)
}
pub type Result<T> = std::result::Result<T, Error>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn body_messages() {
for (body, kept) in [
(
&br#"{"code":1,"message":"Session ID unknown"}"#[..],
"Session ID unknown",
),
(br#"{"code":4,"message":"Forbidden"}"#, "Forbidden"),
(br#"{"code":4,"message":"token expired"}"#, "token expired"),
(
br#"{"code":4,"message":"denied by middleware: try again later"}"#,
"denied by middleware: try again later",
),
(
br#"{"code":3,"message":"Bad request ?sid=x&token=S see https://h/?t=S"}"#,
"Bad request <redacted> see <url>",
),
] {
assert_eq!(body_message(body).as_deref(), Some(kept), "{body:?}");
}
let long = format!(r#"{{"code":1,"message":"{}"}}"#, "a".repeat(500));
assert_eq!(body_message(long.as_bytes()).unwrap().len(), 200);
for body in [
&b"X-Auth-Token: S"[..],
b"access-token: S",
b"Authorization: Token S",
b"Authorization: ApiKey S",
b"Authorization: Digest username=\"u\", response=\"S\"",
br#"{"error":"denied","token":"S"}"#,
br#"{"message":"no code here","token":"S"}"#,
br#"{"code":"1","message":"string code"}"#,
b"token%3DS",
b"token = S",
b"password : S",
b"Cookie: a=b; sid=S",
b"eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.S",
b"<b>password</b> S",
b"Cannot GET /socket.io/?EIO=4&token=S",
b"<h1>Forbidden</h1>",
b" ",
] {
assert_eq!(body_message(body), None, "{body:?}");
}
let e = Error::HttpStatus {
status: 400,
message: Some("Session ID unknown".into()),
};
assert_eq!(
e.to_string(),
"server answered HTTP 400: Session ID unknown"
);
let e = Error::WebsocketClosed {
code: 4001,
reason: "bye".into(),
};
assert_eq!(
e.to_string(),
"the server closed the websocket (code 4001: bye)"
);
}
#[tokio::test]
async fn http_errors_drop_the_url() {
tokio::time::timeout(std::time::Duration::from_secs(90), async move {
let client = crate::engineio::tls::apply_reqwest_tls!(reqwest::Client::builder(), None)
.build()
.unwrap();
let err = client
.get("http://127.0.0.1:9/engine.io/?token=SECRET")
.send()
.await
.unwrap_err();
let err = Error::from(err);
let text = format!("{err} {err:?}");
assert!(!text.contains("SECRET"), "{text}");
})
.await
.expect("test `http_errors_drop_the_url` timed out")
}
}