updated all dependencies to the latest and greatest

Author: illegalprime

Cargo.toml

@@ -2,7 +2,7 @@
 
 name = "websocket"
 version = "0.17.2"
-authors = ["cyderize <admin@cyderize.org>"]
+authors = ["cyderize <admin@cyderize.org>", "Michael Eden <themichaeleden@gmail.com>"]
 
 description = "A WebSocket (RFC6455) library for Rust."
 
@@ -17,16 +17,14 @@ keywords = ["websocket", "websockets", "rfc6455"]
 license = "MIT"
 
 [dependencies]
-hyper = ">=0.7, <0.10"
-mio = "0.5.1"
-unicase = "1.0.1"
-openssl = "0.7.6"
-url = "1.0"
-rustc-serialize = "0.3.16"
-bitflags = "0.7"
-rand = "0.3.12"
-byteorder = "1.0"
-net2 = "0.2.17"
+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"
 
 [features]
 nightly = ["hyper/nightly"]

src/client/builder.rs

@@ -23,11 +23,13 @@ use hyper::header::{
     ProtocolName,
 };
 use unicase::UniCase;
-use openssl::ssl::error::SslError;
+use openssl::error::ErrorStack as SslError;
 use openssl::ssl::{
     SslContext,
     SslMethod,
     SslStream,
+    SslConnector,
+    SslConnectorBuilder,
 };
 use header::extensions::Extension;
 use header::{
@@ -73,23 +75,21 @@ macro_rules! upsert_header {
 
 /// Build clients with a builder-style API
 #[derive(Clone, Debug)]
-pub struct ClientBuilder<'u, 's> {
+pub struct ClientBuilder<'u> {
     url: Cow<'u, Url>,
     version: HttpVersion,
     headers: Headers,
     version_set: bool,
     key_set: bool,
-    ssl_context: Option<Cow<'s, SslContext>>,
 }
 
-impl<'u, 's> ClientBuilder<'u, 's> {
+impl<'u> ClientBuilder<'u> {
     pub fn new(url: Cow<'u, Url>) -> Self {
         ClientBuilder {
             url: url,
             version: HttpVersion::Http11,
             version_set: false,
             key_set: false,
-            ssl_context: None,
             headers: Headers::new(),
         }
     }
@@ -184,11 +184,6 @@ impl<'u, 's> ClientBuilder<'u, 's> {
         self
     }
 
-    pub fn ssl_context(mut self, context: &'s SslContext) -> Self {
-        self.ssl_context = Some(Cow::Borrowed(context));
-        self
-    }
-
     fn establish_tcp(&mut self, secure: Option<bool>) -> WebSocketResult<TcpStream> {
         let port = match (self.url.port(), secure) {
             (Some(port), _) => port,
@@ -206,20 +201,30 @@ impl<'u, 's> ClientBuilder<'u, 's> {
         Ok(tcp_stream)
     }
 
-    fn wrap_ssl(&self, tcp_stream: TcpStream) -> Result<SslStream<TcpStream>, SslError> {
-        let context = match self.ssl_context {
-            Some(ref ctx) => Cow::Borrowed(ctx.as_ref()),
-            None => Cow::Owned(try!(SslContext::new(SslMethod::Tlsv1))),
+    fn wrap_ssl(&self,
+                tcp_stream: TcpStream,
+                connector: Option<SslConnector>
+    ) -> WebSocketResult<SslStream<TcpStream>> {
+        let host = match self.url.host_str() {
+            Some(h) => h,
+            None => return Err(WebSocketError::WebSocketUrlError(WSUrlErrorKind::NoHostName)),
+        };
+        let connector = match connector {
+            Some(c) => c,
+            None => try!(SslConnectorBuilder::new(SslMethod::tls())).build(),
         };
 
-        SslStream::connect(&*context, tcp_stream)
+        let ssl_stream = try!(connector.connect(host, tcp_stream));
+        Ok(ssl_stream)
     }
 
-    pub fn connect(&mut self) -> WebSocketResult<Client<BoxedNetworkStream>> {
+    pub fn connect(&mut self,
+                   ssl_config: Option<SslConnector>
+    ) -> WebSocketResult<Client<BoxedNetworkStream>> {
         let tcp_stream = try!(self.establish_tcp(None));
 
         let boxed_stream = if self.url.scheme() == "wss" {
-            BoxedNetworkStream(Box::new(try!(self.wrap_ssl(tcp_stream))))
+            BoxedNetworkStream(Box::new(try!(self.wrap_ssl(tcp_stream, ssl_config))))
         } else {
             BoxedNetworkStream(Box::new(tcp_stream))
         };
@@ -233,10 +238,12 @@ impl<'u, 's> ClientBuilder<'u, 's> {
         self.connect_on(tcp_stream)
     }
 
-    pub fn connect_secure(&mut self) -> WebSocketResult<Client<SslStream<TcpStream>>> {
+    pub fn connect_secure(&mut self,
+                          ssl_config: Option<SslConnector>
+    ) -> WebSocketResult<Client<SslStream<TcpStream>>> {
         let tcp_stream = try!(self.establish_tcp(Some(true)));
 
-        let ssl_stream = try!(self.wrap_ssl(tcp_stream));
+        let ssl_stream = try!(self.wrap_ssl(tcp_stream, ssl_config));
 
         self.connect_on(ssl_stream)
     }
@@ -291,7 +298,7 @@ impl<'u, 's> ClientBuilder<'u, 's> {
             WebSocketError::RequestError("Request Sec-WebSocket-Key was invalid")
         ));
 
-        if response.headers.get() != Some(&(WebSocketAccept::new(key))) {
+        if response.headers.get() != Some(&(try!(WebSocketAccept::new(key)))) {
             return Err(WebSocketError::ResponseError("Sec-WebSocket-Accept is invalid"));
         }
 

src/client/mod.rs

@@ -1,6 +1,5 @@
 //! Contains the WebSocket client.
 extern crate url;
-extern crate net2;
 
 use std::borrow::{
     Cow,
@@ -22,7 +21,6 @@ use openssl::ssl::{
     SslMethod,
     SslStream,
 };
-use openssl::ssl::error::SslError;
 use hyper::buffer::BufReader;
 use hyper::status::StatusCode;
 use hyper::http::h1::parse_response;
@@ -37,7 +35,6 @@ use hyper::header::{
     ProtocolName,
 };
 use unicase::UniCase;
-use self::net2::TcpStreamExt;
 
 use ws;
 use ws::sender::Sender as SenderTrait;
@@ -157,25 +154,20 @@ impl<S> Client<S>
         self.stream.as_tcp().set_nodelay(nodelay)
 	  }
 
-	  /// See `TcpStream.set_keepalive()`.
-	  pub fn set_keepalive(&mut self, delay_in_ms: Option<u32>) -> IoResult<()> {
-        TcpStreamExt::set_keepalive_ms(self.stream.as_tcp(), delay_in_ms)
-	  }
-
     /// Changes whether the stream is in nonblocking mode.
     pub fn set_nonblocking(&self, nonblocking: bool) -> IoResult<()> {
         self.stream.as_tcp().set_nonblocking(nonblocking)
     }
 }
 
-impl<'u, 'p, 'e, 's, S> Client<S>
+impl<'u, S> Client<S>
     where S: Stream,
 {
-    pub fn from_url(address: &'u Url) -> ClientBuilder<'u, 's> {
+    pub fn from_url(address: &'u Url) -> ClientBuilder<'u> {
         ClientBuilder::new(Cow::Borrowed(address))
     }
 
-    pub fn build(address: &str) -> Result<ClientBuilder<'u, 's>, ParseError> {
+    pub fn build(address: &str) -> Result<ClientBuilder<'u>, ParseError> {
         let url = try!(Url::parse(address));
         Ok(ClientBuilder::new(Cow::Owned(url)))
     }

src/header/accept.rs

@@ -5,7 +5,8 @@ use std::fmt::{self, Debug};
 use std::str::FromStr;
 use serialize::base64::{ToBase64, FromBase64, STANDARD};
 use header::WebSocketKey;
-use openssl::crypto::hash::{self, hash};
+use openssl::hash::{self, hash};
+use openssl::error::ErrorStack as SslError;
 use result::{WebSocketResult, WebSocketError};
 
 static MAGIC_GUID: &'static str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
@@ -49,18 +50,18 @@ impl FromStr for WebSocketAccept {
 
 impl WebSocketAccept {
 	/// Create a new WebSocketAccept from the given WebSocketKey
-	pub fn new(key: &WebSocketKey) -> WebSocketAccept {
+	  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 = hash(hash::Type::SHA1, concat_key.as_bytes());
+		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();
 		}
-		WebSocketAccept(bytes)
+		Ok(WebSocketAccept(bytes))
 	}
 	/// Return the Base64 encoding of this WebSocketAccept
 	pub fn serialize(&self) -> String {