make extensions owned

client/src/utils.rs

@@ -204,7 +204,7 @@ pub async fn make_mux(
         .await
         .map_err(|_| WispError::WsImplSocketClosed)?;
     wtx.wait_for_open().await;
-    let mux = ClientMux::new(wrx, wtx, Some(&[&UdpProtocolExtensionBuilder()])).await?;
+    let mux = ClientMux::new(wrx, wtx, Some(&[Box::new(UdpProtocolExtensionBuilder())])).await?;
 
     Ok(mux)
 }

server/src/main.rs

@@ -22,7 +22,7 @@ use tokio_util::either::Either;
 use wisp_mux::{
     extensions::{
         password::{PasswordProtocolExtension, PasswordProtocolExtensionBuilder},
-        udp::UdpProtocolExtensionBuilder,
+        udp::UdpProtocolExtensionBuilder, ProtocolExtensionBuilder,
     },
     CloseReason, ConnectPacket, MuxStream, ServerMux, StreamType, WispError,
 };
@@ -72,7 +72,7 @@ struct MuxOptions {
     pub block_udp: bool,
     pub block_non_http: bool,
     pub enforce_auth: bool,
-    pub auth: Arc<PasswordProtocolExtensionBuilder>,
+    pub auth: Arc<Vec<Box<(dyn ProtocolExtensionBuilder + Send + Sync)>>>,
 }
 
 #[cfg(not(unix))]
@@ -176,13 +176,13 @@ async fn main() -> Result<(), Error> {
             auth.insert(username.to_string(), password.to_string());
         }
     }
-    let pw_ext = Arc::new(PasswordProtocolExtensionBuilder::new_server(auth));
+    let pw_ext = PasswordProtocolExtensionBuilder::new_server(auth);
 
     let mux_options = MuxOptions {
         block_local: opt.block_local,
         block_non_http: opt.block_non_http,
         block_udp: opt.block_udp,
-        auth: pw_ext,
+        auth: Arc::new(vec![Box::new(UdpProtocolExtensionBuilder()), Box::new(pw_ext)]),
         enforce_auth,
     };
 
@@ -314,7 +314,7 @@ async fn accept_ws(
             rx,
             tx,
             u32::MAX,
-            Some(&[&UdpProtocolExtensionBuilder(), mux_options.auth.as_ref()]),
+            Some(mux_options.auth.as_slice()),
         )
         .await?;
         if !mux
@@ -331,7 +331,7 @@ async fn accept_ws(
         }
         (mux, fut)
     } else {
-        ServerMux::new(rx, tx, u32::MAX, Some(&[&UdpProtocolExtensionBuilder()])).await?
+        ServerMux::new(rx, tx, u32::MAX, Some(&[Box::new(UdpProtocolExtensionBuilder())])).await?
     };
 
     println!(

simple-wisp-client/src/main.rs

@@ -152,7 +152,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     let (rx, tx) = ws.split(tokio::io::split);
     let rx = FragmentCollectorRead::new(rx);
 
-    let mut extensions: Vec<Box<(dyn ProtocolExtensionBuilder + Sync)>> = Vec::new();
+    let mut extensions: Vec<Box<(dyn ProtocolExtensionBuilder + Send + Sync)>> = Vec::new();
     if opts.udp {
         extensions.push(Box::new(UdpProtocolExtensionBuilder()));
     }
@@ -160,10 +160,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     if let Some(auth) = auth {
         extensions.push(Box::new(auth));
     }
-    let extensions_mapped: Vec<&(dyn ProtocolExtensionBuilder + Sync)> =
-        extensions.iter().map(|x| x.as_ref()).collect();
 
-    let (mut mux, fut) = ClientMux::new(rx, tx, Some(&extensions_mapped)).await?;
+    let (mut mux, fut) = ClientMux::new(rx, tx, Some(extensions.as_slice())).await?;
     if opts.udp
         && !mux
             .supported_extension_ids

wisp/src/extensions.rs

@@ -112,7 +112,7 @@ pub mod udp {
     //!     rx,
     //!     tx,
     //!     128,
-    //!     Some(&[&UdpProtocolExtensionBuilder()])
+    //!     Some(&[Box::new(UdpProtocolExtensionBuilder())])
     //! );
     //! ```
     //! See [the docs](https://github.com/MercuryWorkshop/wisp-protocol/blob/main/protocol.md#0x01---udp)
@@ -213,7 +213,7 @@ pub mod password {
     //!     rx,
     //!     tx,
     //!     128,
-    //!     Some(&[&PasswordProtocolExtensionBuilder::new_server(passwords)])
+    //!     Some(&[Box::new(PasswordProtocolExtensionBuilder::new_server(passwords))])
     //! );
     //! ```
     //!
@@ -224,10 +224,10 @@ pub mod password {
     //!     tx,
     //!     128,
     //!     Some(&[
-    //!         &PasswordProtocolExtensionBuilder::new_client(
+    //!          Box::new(PasswordProtocolExtensionBuilder::new_client(
     //!             "user1".to_string(),
     //!             "pw".to_string()
-    //!         )
+    //!         ))
     //!     ])
     //! );
     //! ```

wisp/src/lib.rs

@@ -445,7 +445,7 @@ impl MuxInner {
 /// ```
 /// use wisp_mux::ServerMux;
 ///
-/// let (mux, fut) = ServerMux::new(rx, tx, 128, Some(vec![]), Some([]));
+/// let (mux, fut) = ServerMux::new(rx, tx, 128, Some([]));
 /// tokio::spawn(async move {
 ///     if let Err(e) = fut.await {
 ///         println!("error in multiplexor: {:?}", e);
@@ -472,14 +472,14 @@ pub struct ServerMux {
 impl ServerMux {
     /// Create a new server-side multiplexor.
     ///
-    /// If extension_builders is None a Wisp v1 connection is created otherwise a Wisp v2 connection is created.
+    /// If `extension_builders` is None a Wisp v1 connection is created otherwise a Wisp v2 connection is created.
     /// **It is not guaranteed that all extensions you specify are available.** You must manually check
     /// if the extensions you need are available after the multiplexor has been created.
     pub async fn new<R, W>(
         mut read: R,
         write: W,
         buffer_size: u32,
-        extension_builders: Option<&[&(dyn ProtocolExtensionBuilder + Sync)]>,
+        extension_builders: Option<&[Box<dyn ProtocolExtensionBuilder + Send + Sync>]>,
     ) -> Result<(Self, impl Future<Output = Result<(), WispError>> + Send), WispError>
     where
         R: ws::WebSocketRead + Send,
@@ -581,7 +581,7 @@ impl ServerMux {
 /// ```
 /// use wisp_mux::{ClientMux, StreamType};
 ///
-/// let (mux, fut) = ClientMux::new(rx, tx, Some(vec![]), []).await?;
+/// let (mux, fut) = ClientMux::new(rx, tx, Some([])).await?;
 /// tokio::spawn(async move {
 ///     if let Err(e) = fut.await {
 ///         println!("error in multiplexor: {:?}", e);
@@ -602,13 +602,13 @@ pub struct ClientMux {
 impl ClientMux {
     /// Create a new client side multiplexor.
     ///
-    /// If extension_builders is None a Wisp v1 connection is created otherwise a Wisp v2 connection is created.
+    /// If `extension_builders` is None a Wisp v1 connection is created otherwise a Wisp v2 connection is created.
     /// **It is not guaranteed that all extensions you specify are available.** You must manually check
     /// if the extensions you need are available after the multiplexor has been created.
     pub async fn new<R, W>(
         mut read: R,
         write: W,
-        extension_builders: Option<&[&(dyn ProtocolExtensionBuilder + Sync)]>,
+        extension_builders: Option<&[Box<dyn ProtocolExtensionBuilder + Send + Sync>]>,
     ) -> Result<(Self, impl Future<Output = Result<(), WispError>> + Send), WispError>
     where
         R: ws::WebSocketRead + Send,

wisp/src/packet.rs

@@ -380,7 +380,7 @@ impl Packet {
     pub(crate) fn maybe_parse_info(
         frame: Frame,
         role: Role,
-        extension_builders: &[&(dyn ProtocolExtensionBuilder + Sync)],
+        extension_builders: &[Box<(dyn ProtocolExtensionBuilder + Send + Sync)>],
     ) -> Result<Self, WispError> {
         if !frame.finished {
             return Err(WispError::WsFrameNotFinished);
@@ -431,7 +431,7 @@ impl Packet {
     fn parse_info(
         mut bytes: Bytes,
         role: Role,
-        extension_builders: &[&(dyn ProtocolExtensionBuilder + Sync)],
+        extension_builders: &[Box<(dyn ProtocolExtensionBuilder + Send + Sync)>],
     ) -> Result<Self, WispError> {
         // packet type is already read by code that calls this
         if bytes.remaining() < 4 + 2 {