don't hide ws errors and ignore host header because it'll result in errors anyway

Cargo.lock

@@ -683,7 +683,7 @@ dependencies = [
 
 [[package]]
 name = "epoxy-client"
-version = "2.1.14"
+version = "2.1.15"
 dependencies = [
  "async-compression",
  "async-trait",

client/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "epoxy-client"
-version = "2.1.14"
+version = "2.1.15"
 edition = "2021"
 
 [lib]

client/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mercuryworkshop/epoxy-tls",
-	"version": "2.1.14-1",
+	"version": "2.1.15-1",
 	"description": "A wasm library for using raw encrypted tls/ssl/tcp/udp/https/websocket streams on the browser",
 	"scripts": {
 		"build": "./build.sh"

client/src/lib.rs

@@ -641,6 +641,9 @@ impl EpoxyClient {
 
 		if let Some(headers) = headers {
 			for hdr in headers {
+				if ["host"].contains(&hdr[0].to_lowercase().as_str()) {
+					continue;
+				}
 				headers_map.insert(
 					HeaderName::from_str(&hdr[0])?,
 					HeaderValue::from_str(&hdr[1])?,

client/src/ws_wrapper.rs

@@ -10,7 +10,8 @@ use flume::Receiver;
 use futures_util::FutureExt;
 use js_sys::{Array, ArrayBuffer, Uint8Array};
 use send_wrapper::SendWrapper;
-use wasm_bindgen::{closure::Closure, JsCast};
+use thiserror::Error;
+use wasm_bindgen::{closure::Closure, JsCast, JsValue};
 use web_sys::{BinaryType, MessageEvent, WebSocket};
 use wisp_mux::{
 	ws::{Frame, LockedWebSocketWrite, Payload, WebSocketRead, WebSocketWrite},
@@ -19,26 +20,16 @@ use wisp_mux::{
 
 use crate::EpoxyError;
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 pub enum WebSocketError {
-	Unknown,
-	SendFailed,
-	CloseFailed,
+	#[error("Unknown JS WebSocket wrapper error: {0:?}")]
+	Unknown(String),
+	#[error("Failed to call WebSocket.send: {0:?}")]
+	SendFailed(String),
+	#[error("Failed to call WebSocket.close: {0:?}")]
+	CloseFailed(String),
 }
 
-impl std::fmt::Display for WebSocketError {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-		use WebSocketError::*;
-		match self {
-			Unknown => write!(f, "Unknown error"),
-			SendFailed => write!(f, "Send failed"),
-			CloseFailed => write!(f, "Close failed"),
-		}
-	}
-}
-
-impl std::error::Error for WebSocketError {}
-
 impl From<WebSocketError> for WispError {
 	fn from(err: WebSocketError) -> Self {
 		Self::WsImplError(Box::new(err))
@@ -47,7 +38,7 @@ impl From<WebSocketError> for WispError {
 
 pub enum WebSocketMessage {
 	Closed,
-	Error,
+	Error(WebSocketError),
 	Message(Vec<u8>),
 }
 
@@ -64,7 +55,7 @@ pub struct WebSocketWrapper {
 	#[allow(dead_code)]
 	onclose: SendWrapper<Closure<dyn Fn()>>,
 	#[allow(dead_code)]
-	onerror: SendWrapper<Closure<dyn Fn()>>,
+	onerror: SendWrapper<Closure<dyn Fn(JsValue)>>,
 	#[allow(dead_code)]
 	onmessage: SendWrapper<Closure<dyn Fn(MessageEvent)>>,
 }
@@ -81,20 +72,20 @@ impl WebSocketRead for WebSocketReader {
 		&mut self,
 		_: &LockedWebSocketWrite,
 	) -> Result<Frame<'static>, WispError> {
-		use WebSocketMessage::*;
+		use WebSocketMessage as M;
 		if self.closed.load(Ordering::Acquire) {
 			return Err(WispError::WsImplSocketClosed);
 		}
 		let res = futures_util::select! {
 			data = self.read_rx.recv_async() => data.ok(),
-			_ = self.close_event.listen().fuse() => Some(Closed),
+			_ = self.close_event.listen().fuse() => Some(M::Closed),
 		};
 		match res.ok_or(WispError::WsImplSocketClosed)? {
-			Message(bin) => Ok(Frame::binary(Payload::Bytes(BytesMut::from(
+			M::Message(bin) => Ok(Frame::binary(Payload::Bytes(BytesMut::from(
 				bin.as_slice(),
 			)))),
-			Error => Err(WebSocketError::Unknown.into()),
-			Closed => Err(WispError::WsImplSocketClosed),
+			M::Error(x) => Err(x.into()),
+			M::Closed => Err(WispError::WsImplSocketClosed),
 		}
 	}
 }
@@ -132,12 +123,12 @@ impl WebSocketWrapper {
 		let onerror_closed = closed.clone();
 		let onerror_close = close_event.clone();
 		let onerror_event = error_event.clone();
-		let onerror = Closure::wrap(Box::new(move || {
-			let _ = onerror_tx.send(WebSocketMessage::Error);
+		let onerror = Closure::wrap(Box::new(move |e| {
+			let _ = onerror_tx.send(WebSocketMessage::Error(WebSocketError::Unknown(format!("{:?}", e))));
 			onerror_closed.store(true, Ordering::Release);
 			onerror_close.notify(usize::MAX);
 			onerror_event.notify(usize::MAX);
-		}) as Box<dyn Fn()>);
+		}) as Box<dyn Fn(JsValue)>);
 
 		let ws = if protocols.is_empty() {
 			WebSocket::new(url)
@@ -202,7 +193,7 @@ impl WebSocketWrite for WebSocketWrapper {
 			Binary | Text => self
 				.inner
 				.send_with_u8_array(&frame.payload)
-				.map_err(|_| WebSocketError::SendFailed.into()),
+				.map_err(|x| WebSocketError::SendFailed(format!("{:?}", x)).into()),
 			Close => {
 				let _ = self.inner.close();
 				Ok(())
@@ -214,7 +205,7 @@ impl WebSocketWrite for WebSocketWrapper {
 	async fn wisp_close(&mut self) -> Result<(), WispError> {
 		self.inner
 			.close()
-			.map_err(|_| WebSocketError::CloseFailed.into())
+			.map_err(|x| WebSocketError::CloseFailed(format!("{:?}", x)).into())
 	}
 }