Make openssl an optional dependency

Author: sfackler

Cargo.toml

@@ -25,12 +25,13 @@ phf_codegen = "0.7"
 
 [dependencies]
 phf = "0.7"
-openssl = "0.6"
 log = "0.3"
 rustc-serialize = "0.3"
 byteorder = "0.3"
 debug-builders = "0.1"
 bufstream = "0.1"
+rust-crypto = "0.2"
+openssl = { version = "0.6", optional = true }
 uuid = { version = "0.1", optional = true }
 unix_socket = { version = "0.3", optional = true }
 time = { version = "0.1.14", optional = true }

src/io.rs src/io/mod.rssrc/io.rs renamed to src/io/mod.rs

@@ -1,11 +1,12 @@
 //! Types and traits for SSL adaptors.
-
 pub use priv_io::Stream;
 
-use openssl::ssl::{SslStream, SslContext};
 use std::error::Error;
 use std::io::prelude::*;
 
+#[cfg(feature = "openssl")]
+mod openssl;
+
 /// A trait implemented by SSL adaptors.
 pub trait StreamWrapper: Read+Write+Send {
     /// Returns a reference to the underlying `Stream`.
@@ -15,16 +16,6 @@ pub trait StreamWrapper: Read+Write+Send {
     fn get_mut(&mut self) -> &mut Stream;
 }
 
-impl StreamWrapper for SslStream<Stream> {
-    fn get_ref(&self) -> &Stream {
-        self.get_ref()
-    }
-
-    fn get_mut(&mut self) -> &mut Stream {
-        self.get_mut()
-    }
-}
-
 /// A trait implemented by types that can negotiate SSL over a Postgres stream.
 pub trait NegotiateSsl {
     /// Negotiates an SSL session, returning a wrapper around the provided
@@ -36,14 +27,6 @@ pub trait NegotiateSsl {
                      -> Result<Box<StreamWrapper>, Box<Error>>;
 }
 
-impl NegotiateSsl for SslContext {
-    fn negotiate_ssl(&mut self, _: &str, stream: Stream)
-                     -> Result<Box<StreamWrapper>, Box<Error>> {
-        let stream = try!(SslStream::new(self, stream));
-        Ok(Box::new(stream))
-    }
-}
-
 /// An uninhabited type implementing `NegotiateSsl`.
 ///
 /// `NoSsl` cannot be instantiated, so the only `SslMode<NoSslMode>` value that

src/io/openssl.rs

@@ -0,0 +1,24 @@
+extern crate openssl;
+
+use std::error::Error;
+
+use self::openssl::ssl::{SslContext, SslStream};
+use io::{StreamWrapper, Stream, NegotiateSsl};
+
+impl StreamWrapper for SslStream<Stream> {
+    fn get_ref(&self) -> &Stream {
+        self.get_ref()
+    }
+
+    fn get_mut(&mut self) -> &mut Stream {
+        self.get_mut()
+    }
+}
+
+impl NegotiateSsl for SslContext {
+    fn negotiate_ssl(&mut self, _: &str, stream: Stream)
+                     -> Result<Box<StreamWrapper>, Box<Error>> {
+        let stream = try!(SslStream::new(self, stream));
+        Ok(Box::new(stream))
+    }
+}

src/lib.rs

@@ -47,19 +47,19 @@
 
 extern crate bufstream;
 extern crate byteorder;
+extern crate crypto;
 #[macro_use]
 extern crate log;
-extern crate openssl;
 extern crate phf;
 extern crate rustc_serialize as serialize;
 #[cfg(feature = "unix_socket")]
 extern crate unix_socket;
 extern crate debug_builders;
 
 use bufstream::BufStream;
+use crypto::digest::Digest;
+use crypto::md5::Md5;
 use debug_builders::DebugStruct;
-use openssl::crypto::hash::{self, Hasher};
-use serialize::hex::ToHex;
 use std::ascii::AsciiExt;
 use std::borrow::{ToOwned, Cow};
 use std::cell::{Cell, RefCell};
@@ -640,13 +640,14 @@ impl InnerConnection {
             }
             AuthenticationMD5Password { salt } => {
                 let pass = try!(user.password.ok_or(ConnectError::MissingPassword));
-                let mut hasher = Hasher::new(hash::Type::MD5);
-                let _ = hasher.write_all(pass.as_bytes());
-                let _ = hasher.write_all(user.user.as_bytes());
-                let output = hasher.finish().to_hex();
-                let _ = hasher.write_all(output.as_bytes());
-                let _ = hasher.write_all(&salt);
-                let output = format!("md5{}", hasher.finish().to_hex());
+                let mut hasher = Md5::new();
+                let _ = hasher.input(pass.as_bytes());
+                let _ = hasher.input(user.user.as_bytes());
+                let output = hasher.result_str();
+                hasher.reset();
+                let _ = hasher.input(output.as_bytes());
+                let _ = hasher.input(&salt);
+                let output = format!("md5{}", hasher.result_str());
                 try!(self.write_messages(&[PasswordMessage {
                         password: &output
                     }]));

tests/test.rs

@@ -1,10 +1,11 @@
 extern crate postgres;
 extern crate rustc_serialize as serialize;
 extern crate url;
+#[cfg(feature = "openssl")]
 extern crate openssl;
 
-use openssl::ssl::SslContext;
-use openssl::ssl::SslMethod;
+#[cfg(feature = "openssl")]
+use openssl::ssl::{SslContext, SslMethod};
 use std::thread;
 
 use postgres::{HandleNotice,
@@ -670,6 +671,7 @@ fn test_cancel_query() {
 }
 
 #[test]
+#[cfg(feature = "openssl")]
 fn test_require_ssl_conn() {
     let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",
@@ -678,6 +680,7 @@ fn test_require_ssl_conn() {
 }
 
 #[test]
+#[cfg(feature = "openssl")]
 fn test_prefer_ssl_conn() {
     let ctx = SslContext::new(SslMethod::Sslv23).unwrap();
     let conn = or_panic!(Connection::connect("postgres://postgres@localhost",