made openssl optional behind a feature gate

Author: illegalprime

Cargo.toml

@@ -19,12 +19,15 @@ license = "MIT"
 [dependencies]
 hyper = "^0.10"
 unicase = "^1.0"
-openssl = "^0.9.10"
 url = "^1.0"
 rustc-serialize = "^0.3"
 bitflags = "^0.8"
 rand = "^0.3"
 byteorder = "^1.0"
+sha1 = "^0.2"
+openssl = { version = "^0.9.10", optional = true }
 
 [features]
+default = ["ssl"]
+ssl = ["openssl"]
 nightly = ["hyper/nightly"]

src/client/builder.rs

@@ -23,14 +23,15 @@ use hyper::header::{
     ProtocolName,
 };
 use unicase::UniCase;
-use openssl::error::ErrorStack as SslError;
+#[cfg(feature="ssl")]
 use openssl::ssl::{
-    SslContext,
     SslMethod,
     SslStream,
     SslConnector,
     SslConnectorBuilder,
 };
+#[cfg(feature="ssl")]
+use stream::BoxedNetworkStream;
 use header::extensions::Extension;
 use header::{
     WebSocketAccept,
@@ -46,11 +47,7 @@ use result::{
     WebSocketError,
 };
 use stream::{
-    BoxedNetworkStream,
-    AsTcpStream,
     Stream,
-    Splittable,
-    Shutdown,
 };
 use super::Client;
 
@@ -201,6 +198,7 @@ impl<'u> ClientBuilder<'u> {
         Ok(tcp_stream)
     }
 
+    #[cfg(feature="ssl")]
     fn wrap_ssl(&self,
                 tcp_stream: TcpStream,
                 connector: Option<SslConnector>
@@ -218,6 +216,7 @@ impl<'u> ClientBuilder<'u> {
         Ok(ssl_stream)
     }
 
+    #[cfg(feature="ssl")]
     pub fn connect(&mut self,
                    ssl_config: Option<SslConnector>
     ) -> WebSocketResult<Client<BoxedNetworkStream>> {
@@ -238,6 +237,7 @@ impl<'u> ClientBuilder<'u> {
         self.connect_on(tcp_stream)
     }
 
+    #[cfg(feature="ssl")]
     pub fn connect_secure(&mut self,
                           ssl_config: Option<SslConnector>
     ) -> WebSocketResult<Client<SslStream<TcpStream>>> {
@@ -298,7 +298,7 @@ impl<'u> ClientBuilder<'u> {
             WebSocketError::RequestError("Request Sec-WebSocket-Key was invalid")
         ));
 
-        if response.headers.get() != Some(&(try!(WebSocketAccept::new(key)))) {
+        if response.headers.get() != Some(&(WebSocketAccept::new(key))) {
             return Err(WebSocketError::ResponseError("Sec-WebSocket-Accept is invalid"));
         }
 

src/client/mod.rs

@@ -7,34 +7,11 @@ use std::borrow::{
 use std::net::TcpStream;
 use std::net::SocketAddr;
 use std::io::Result as IoResult;
-use std::io::{
-    Write,
-};
 
 use self::url::{
     Url,
     ParseError,
-    Position,
-};
-use openssl::ssl::{
-    SslContext,
-    SslMethod,
-    SslStream,
 };
-use hyper::buffer::BufReader;
-use hyper::status::StatusCode;
-use hyper::http::h1::parse_response;
-use hyper::version::HttpVersion;
-use hyper::header::{
-    Headers,
-    Host,
-    Connection,
-    ConnectionOption,
-    Upgrade,
-    Protocol,
-    ProtocolName,
-};
-use unicase::UniCase;
 
 use ws;
 use ws::sender::Sender as SenderTrait;
@@ -43,22 +20,10 @@ use ws::receiver::{
     MessageIterator,
 };
 use ws::receiver::Receiver as ReceiverTrait;
-use header::extensions::Extension;
-use header::{
-    WebSocketAccept,
-    WebSocketKey,
-    WebSocketVersion,
-    WebSocketProtocol,
-    WebSocketExtensions,
-    Origin,
-};
 use result::{
-    WSUrlErrorKind,
     WebSocketResult,
-    WebSocketError,
 };
 use stream::{
-    BoxedNetworkStream,
     AsTcpStream,
     Stream,
     Splittable,

src/header/accept.rs

@@ -5,9 +5,8 @@ use std::fmt::{self, Debug};
 use std::str::FromStr;
 use serialize::base64::{ToBase64, FromBase64, STANDARD};
 use header::WebSocketKey;
-use openssl::hash::{self, hash};
-use openssl::error::ErrorStack as SslError;
 use result::{WebSocketResult, WebSocketError};
+use sha1::Sha1;
 
 static MAGIC_GUID: &'static str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
@@ -16,115 +15,112 @@ static MAGIC_GUID: &'static str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 pub struct WebSocketAccept([u8; 20]);
 
 impl Debug for WebSocketAccept {
-	fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-		write!(f, "WebSocketAccept({})", self.serialize())
-	}
+	  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+		    write!(f, "WebSocketAccept({})", self.serialize())
+	  }
 }
 
 impl FromStr for WebSocketAccept {
-	type Err = WebSocketError;
+	  type Err = WebSocketError;
 
-	fn from_str(accept: &str) -> WebSocketResult<WebSocketAccept> {
-		match accept.from_base64() {
-			Ok(vec) => {
-				if vec.len() != 20 {
-					return Err(WebSocketError::ProtocolError(
-						"Sec-WebSocket-Accept must be 20 bytes"
-					));
-				}
-				let mut array = [0u8; 20];
-				let mut iter = vec.into_iter();
-				for i in array.iter_mut() {
-					*i = iter.next().unwrap();
-				}
-				Ok(WebSocketAccept(array))
-			}
-			Err(_) => {
-				return Err(WebSocketError::ProtocolError(
-					"Invalid Sec-WebSocket-Accept "
-				));
-			}
-		}
-	}
+	  fn from_str(accept: &str) -> WebSocketResult<WebSocketAccept> {
+		    match accept.from_base64() {
+			      Ok(vec) => {
+				        if vec.len() != 20 {
+					          return Err(WebSocketError::ProtocolError(
+						            "Sec-WebSocket-Accept must be 20 bytes"
+					          ));
+				        }
+				        let mut array = [0u8; 20];
+				        let mut iter = vec.into_iter();
+				        for i in array.iter_mut() {
+					          *i = iter.next().unwrap();
+				        }
+				        Ok(WebSocketAccept(array))
+			      }
+			      Err(_) => {
+				        return Err(WebSocketError::ProtocolError(
+					          "Invalid Sec-WebSocket-Accept "
+				        ));
+			      }
+		    }
+	  }
 }
 
 impl WebSocketAccept {
-	/// Create a new WebSocketAccept from the given WebSocketKey
-	  pub fn new(key: &WebSocketKey) -> Result<WebSocketAccept, SslError> {
-		let serialized = key.serialize();
-		let mut concat_key = String::with_capacity(serialized.len() + 36);
-		concat_key.push_str(&serialized[..]);
-		concat_key.push_str(MAGIC_GUID);
-		let output = try!(hash(hash::MessageDigest::sha1(), concat_key.as_bytes()));
-		let mut iter = output.into_iter();
-		let mut bytes = [0u8; 20];
-		for i in bytes.iter_mut() {
-			*i = iter.next().unwrap();
-		}
-		Ok(WebSocketAccept(bytes))
-	}
-	/// Return the Base64 encoding of this WebSocketAccept
-	pub fn serialize(&self) -> String {
-		let WebSocketAccept(accept) = *self;
-		accept.to_base64(STANDARD)
-	}
+	  /// Create a new WebSocketAccept from the given WebSocketKey
+	  pub fn new(key: &WebSocketKey) -> WebSocketAccept {
+		    let serialized = key.serialize();
+		    let mut concat_key = String::with_capacity(serialized.len() + 36);
+		    concat_key.push_str(&serialized[..]);
+		    concat_key.push_str(MAGIC_GUID);
+        let mut sha1 = Sha1::new();
+        sha1.update(concat_key.as_bytes());
+        let bytes = sha1.digest().bytes();
+		    WebSocketAccept(bytes)
+	  }
+	  /// Return the Base64 encoding of this WebSocketAccept
+	  pub fn serialize(&self) -> String {
+		    let WebSocketAccept(accept) = *self;
+		    accept.to_base64(STANDARD)
+	  }
 }
 
 impl Header for WebSocketAccept {
-	fn header_name() -> &'static str {
-		"Sec-WebSocket-Accept"
-	}
+	  fn header_name() -> &'static str {
+		    "Sec-WebSocket-Accept"
+	  }
 
-	fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<WebSocketAccept> {
-		from_one_raw_str(raw)
-	}
+	  fn parse_header(raw: &[Vec<u8>]) -> hyper::Result<WebSocketAccept> {
+		    from_one_raw_str(raw)
+	  }
 }
 
 impl HeaderFormat for WebSocketAccept {
-	fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-		write!(fmt, "{}", self.serialize())
-	}
+	  fn fmt_header(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+		    write!(fmt, "{}", self.serialize())
+	  }
 }
 
 #[cfg(all(feature = "nightly", test))]
 mod tests {
-	use super::*;
-	use test;
-	use std::str::FromStr;
-	use header::{Headers, WebSocketKey};
-	use hyper::header::{Header, HeaderFormatter};
-	#[test]
-	fn test_header_accept() {
-		let key = FromStr::from_str("dGhlIHNhbXBsZSBub25jZQ==").unwrap();
-		let accept = WebSocketAccept::new(&key);
-		let mut headers = Headers::new();
-		headers.set(accept);
-		
-		assert_eq!(&headers.to_string()[..], "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n");
-	}
-	#[bench]
-	fn bench_header_accept_new(b: &mut test::Bencher) {
-		let key = WebSocketKey::new();
-		b.iter(|| {
-			let mut accept = WebSocketAccept::new(&key);
-			test::black_box(&mut accept);
-		});
-	}
-	#[bench]
-	fn bench_header_accept_parse(b: &mut test::Bencher) {
-		let value = vec![b"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=".to_vec()];
-		b.iter(|| {
-			let mut accept: WebSocketAccept = Header::parse_header(&value[..]).unwrap();
-			test::black_box(&mut accept);
-		});
-	}
-	#[bench]
-	fn bench_header_accept_format(b: &mut test::Bencher) {
-		let value = vec![b"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=".to_vec()];
-		let val: WebSocketAccept = Header::parse_header(&value[..]).unwrap();
-		let fmt = HeaderFormatter(&val);
-		b.iter(|| {
-			format!("{}", fmt);
-		});
-	}
+	  use super::*;
+	  use test;
+	  use std::str::FromStr;
+	  use header::{Headers, WebSocketKey};
+	  use hyper::header::{Header, HeaderFormatter};
+	  #[test]
+	  fn test_header_accept() {
+		    let key = FromStr::from_str("dGhlIHNhbXBsZSBub25jZQ==").unwrap();
+		    let accept = WebSocketAccept::new(&key);
+		    let mut headers = Headers::new();
+		    headers.set(accept);
+
+		    assert_eq!(&headers.to_string()[..], "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n");
+	  }
+	  #[bench]
+	  fn bench_header_accept_new(b: &mut test::Bencher) {
+		    let key = WebSocketKey::new();
+		    b.iter(|| {
+			      let mut accept = WebSocketAccept::new(&key);
+			      test::black_box(&mut accept);
+		    });
+	  }
+	  #[bench]
+	  fn bench_header_accept_parse(b: &mut test::Bencher) {
+		    let value = vec![b"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=".to_vec()];
+		    b.iter(|| {
+			      let mut accept: WebSocketAccept = Header::parse_header(&value[..]).unwrap();
+			      test::black_box(&mut accept);
+		    });
+	  }
+	  #[bench]
+	  fn bench_header_accept_format(b: &mut test::Bencher) {
+		    let value = vec![b"s3pPLMBiTxaQ9kYGzzhZRbK+xOo=".to_vec()];
+		    let val: WebSocketAccept = Header::parse_header(&value[..]).unwrap();
+		    let fmt = HeaderFormatter(&val);
+		    b.iter(|| {
+			      format!("{}", fmt);
+		    });
+	  }
 }

src/lib.rs

@@ -40,9 +40,11 @@ extern crate hyper;
 extern crate unicase;
 extern crate url;
 extern crate rustc_serialize as serialize;
-extern crate openssl;
 extern crate rand;
 extern crate byteorder;
+extern crate sha1;
+#[cfg(feature="ssl")]
+extern crate openssl;
 
 #[macro_use]
 extern crate bitflags;