Add deflate feature

Author: kazk

.travis.yml

@@ -10,5 +10,6 @@ before_script:
 
 script:
   - cargo test --release
+  - cargo test --release --features=deflate
   - echo "Running Autobahn TestSuite for client" && ./scripts/autobahn-client.sh
   - echo "Running Autobahn TestSuite for server" && ./scripts/autobahn-server.sh

Cargo.toml

@@ -23,12 +23,21 @@ native-tls-vendored = ["native-tls", "native-tls-crate/vendored"]
 rustls-tls-native-roots = ["__rustls-tls", "rustls-native-certs"]
 rustls-tls-webpki-roots = ["__rustls-tls", "webpki-roots"]
 __rustls-tls = ["rustls", "webpki"]
+deflate = ["flate2"]
+# deflate-zlib = ["flate2/zlib"]
+
+[[example]]
+name = "autobahn-client"
+required-features = ["deflate"]
+
+[[example]]
+name = "autobahn-server"
+required-features = ["deflate"]
 
 [dependencies]
 base64 = "0.13.0"
 byteorder = "1.3.2"
 bytes = "1.0"
-flate2 = "1.0"
 http = "0.2"
 httparse = "1.3.4"
 log = "0.4.8"
@@ -38,6 +47,10 @@ thiserror = "1.0.23"
 url = "2.1.0"
 utf-8 = "0.7.5"
 
+[dependencies.flate2]
+optional = true
+version = "1.0"
+
 [dependencies.native-tls-crate]
 optional = true
 package = "native-tls"

examples/srv_accept_unmasked_frames.rs

@@ -35,7 +35,8 @@ fn main() {
                 // rare cases where it is necessary to integrate with existing/legacy
                 // clients which are sending unmasked frames
                 accept_unmasked_frames: true,
-                ..WebSocketConfig::default()
+                #[cfg(feature = "deflate")]
+                compression: None,
             });
 
             let mut websocket = accept_hdr_with_config(stream.unwrap(), callback, config).unwrap();

scripts/autobahn-client.sh

@@ -32,5 +32,5 @@ docker run -d --rm \
     wstest -m fuzzingserver -s 'autobahn/fuzzingserver.json'
 
 sleep 3
-cargo run --release --example autobahn-client
+cargo run --release --example autobahn-client --features=deflate
 test_diff

scripts/autobahn-server.sh

@@ -22,7 +22,7 @@ function test_diff() {
     fi
 }
 
-cargo run --release --example autobahn-server & WSSERVER_PID=$!
+cargo run --release --example autobahn-server --features=deflate & WSSERVER_PID=$!
 sleep 3
 
 docker run --rm \

src/error.rs

@@ -2,10 +2,7 @@
 
 use std::{io, result, str, string};
 
-use crate::{
-    extensions,
-    protocol::{frame::coding::Data, Message},
-};
+use crate::protocol::{frame::coding::Data, Message};
 use http::Response;
 use thiserror::Error;
 
@@ -71,8 +68,9 @@ pub enum Error {
     #[error("HTTP format error: {0}")]
     HttpFormat(#[from] http::Error),
     /// Error from `permessage-deflate` extension.
+    #[cfg(feature = "deflate")]
     #[error("Deflate error: {0}")]
-    Deflate(#[from] extensions::DeflateError),
+    Deflate(#[from] crate::extensions::DeflateError),
 }
 
 impl From<str::Utf8Error> for Error {

src/extensions/mod.rs

@@ -1,15 +1,20 @@
 //! WebSocket extensions.
 // Only `permessage-deflate` is supported at the moment.
+use http::HeaderValue;
 
+#[cfg(feature = "deflate")]
 mod compression;
+#[cfg(feature = "deflate")]
 use compression::deflate::DeflateContext;
+#[cfg(feature = "deflate")]
 pub use compression::deflate::{DeflateConfig, DeflateError};
-use http::HeaderValue;
 
 /// Container for configured extensions.
 #[derive(Debug, Default)]
+#[allow(missing_copy_implementations)]
 pub struct Extensions {
     // Per-Message Compression. Only `permessage-deflate` is supported.
+    #[cfg(feature = "deflate")]
     pub(crate) compression: Option<DeflateContext>,
 }
 

src/handshake/client.rs

@@ -17,7 +17,7 @@ use super::{
 };
 use crate::{
     error::{Error, ProtocolError, Result, UrlError},
-    extensions::{self, Extensions},
+    extensions::Extensions,
     protocol::{Role, WebSocket, WebSocketConfig},
 };
 
@@ -161,7 +161,7 @@ impl VerifyData {
     pub fn verify_response(
         &self,
         response: Response,
-        config: &Option<WebSocketConfig>,
+        _config: &Option<WebSocketConfig>,
     ) -> Result<(Response, Option<Extensions>)> {
         // 1. If the status code received from the server is not 101, the
         // client handles the response per HTTP [RFC2616] procedures. (RFC 6455)
@@ -202,43 +202,58 @@ impl VerifyData {
         if !headers.get("Sec-WebSocket-Accept").map(|h| h == &self.accept_key).unwrap_or(false) {
             return Err(Error::Protocol(ProtocolError::SecWebSocketAcceptKeyMismatch));
         }
-        let mut extensions = None;
         // 5.  If the response includes a |Sec-WebSocket-Extensions| header
         // field and this header field indicates the use of an extension
         // that was not present in the client's handshake (the server has
         // indicated an extension not requested by the client), the client
         // MUST _Fail the WebSocket Connection_. (RFC 6455)
         let mut extensions_values = headers.get_all("Sec-WebSocket-Extensions").iter();
-        if let Some(value) = extensions_values.next() {
+        let extensions = if let Some(value) = extensions_values.next() {
             if extensions_values.next().is_some() {
                 return Err(Error::Protocol(ProtocolError::MultipleExtensionsHeaderInResponse));
             }
 
-            let mut exts = extensions::iter_all(std::iter::once(value));
-            if let Some(compression) = &config.and_then(|c| c.compression) {
-                for (name, params) in exts {
-                    if name != compression.name() {
-                        return Err(Error::Protocol(ProtocolError::InvalidExtension(
-                            name.to_string(),
-                        )));
-                    }
-
-                    // Already had PMCE configured
-                    if extensions.is_some() {
-                        return Err(Error::Protocol(ProtocolError::ExtensionConflict(
-                            name.to_string(),
-                        )));
+            let mut exts = crate::extensions::iter_all(std::iter::once(value));
+            #[cfg(feature = "deflate")]
+            {
+                let mut extensions = None;
+                if let Some(compression) = _config.and_then(|c| c.compression) {
+                    for (name, params) in exts {
+                        if name != compression.name() {
+                            return Err(Error::Protocol(ProtocolError::InvalidExtension(
+                                name.to_string(),
+                            )));
+                        }
+
+                        // Already had PMCE configured
+                        if extensions.is_some() {
+                            return Err(Error::Protocol(ProtocolError::ExtensionConflict(
+                                name.to_string(),
+                            )));
+                        }
+
+                        extensions = Some(Extensions {
+                            compression: Some(compression.accept_response(params)?),
+                        });
                     }
+                } else if let Some((name, _)) = exts.next() {
+                    // The client didn't request anything, but got something
+                    return Err(Error::Protocol(ProtocolError::InvalidExtension(name.to_string())));
+                }
+                extensions
+            }
 
-                    extensions = Some(Extensions {
-                        compression: Some(compression.accept_response(params)?),
-                    });
+            #[cfg(not(feature = "deflate"))]
+            {
+                if let Some((name, _)) = exts.next() {
+                    // The client didn't request anything, but got something
+                    return Err(Error::Protocol(ProtocolError::InvalidExtension(name.to_string())));
                 }
-            } else if let Some((name, _)) = exts.next() {
-                // The client didn't request anything, but got something
-                return Err(Error::Protocol(ProtocolError::InvalidExtension(name.to_string())));
+                None
             }
-        }
+        } else {
+            None
+        };
 
         // 6.  If the response includes a |Sec-WebSocket-Protocol| header field
         // and this header field indicates the use of a subprotocol that was
@@ -292,7 +307,9 @@ fn generate_key() -> String {
 #[cfg(test)]
 mod tests {
     use super::{super::machine::TryParse, generate_key, generate_request, Response};
-    use crate::{client::IntoClientRequest, extensions::DeflateConfig, protocol::WebSocketConfig};
+    use crate::client::IntoClientRequest;
+    #[cfg(feature = "deflate")]
+    use crate::{extensions::DeflateConfig, protocol::WebSocketConfig};
 
     #[test]
     fn random_keys() {
@@ -361,6 +378,7 @@ mod tests {
         assert_eq!(&request[..], &correct[..]);
     }
 
+    #[cfg(feature = "deflate")]
     #[test]
     fn request_with_compression() {
         let request = "ws://localhost/getCaseCount".into_client_request().unwrap();

src/protocol/frame/frame.rs

@@ -306,6 +306,7 @@ impl Frame {
 
     /// Create a new compressed data frame.
     #[inline]
+    #[cfg(feature = "deflate")]
     pub(crate) fn compressed_message(data: Vec<u8>, opcode: OpCode, is_final: bool) -> Frame {
         debug_assert!(matches!(opcode, OpCode::Data(_)), "Invalid opcode for data frame.");
 

src/protocol/message.rs

@@ -107,6 +107,7 @@ impl IncompleteMessage {
         }
     }
 
+    #[cfg(feature = "deflate")]
     pub fn compressed(&self) -> bool {
         self.compressed
     }