Merge branch 'release-v0.7.9' into releasev0.7.9

6 files changed, 54 insertions, 44 deletions

diff --git a/openssl/Cargo.toml b/openssl/Cargo.toml
index 5bfd3edb..09f84433 100644
--- a/openssl/Cargo.toml
+++ b/openssl/Cargo.toml
@@ -1,11 +1,11 @@
 [package]
 name = "openssl"
-version = "0.7.8"
+version = "0.7.9"
 authors = ["Steven Fackler <[email protected]>"]
 license = "Apache-2.0"
 description = "OpenSSL bindings"
 repository = "https://github.com/sfackler/rust-openssl"
-documentation = "https://sfackler.github.io/rust-openssl/doc/v0.7.8/openssl"
+documentation = "https://sfackler.github.io/rust-openssl/doc/v0.7.9/openssl"
 readme = "../README.md"
 keywords = ["crypto", "tls", "ssl", "dtls"]
 build = "build.rs"
@@ -32,8 +32,8 @@ nightly = []
 bitflags = "0.4"
 lazy_static = "0.1"
 libc = "0.2"
-openssl-sys = { version = "0.7.8", path = "../openssl-sys" }
-openssl-sys-extras = { version = "0.7.8", path = "../openssl-sys-extras" }
+openssl-sys = { version = "0.7.9", path = "../openssl-sys" }
+openssl-sys-extras = { version = "0.7.9", path = "../openssl-sys-extras" }
 
 [build-dependencies]
 gcc = "0.3"
diff --git a/openssl/src/c_helpers.c b/openssl/src/c_helpers.c
index 1b48565e..e884bebd 100644
--- a/openssl/src/c_helpers.c
+++ b/openssl/src/c_helpers.c
@@ -8,10 +8,6 @@ void rust_SSL_CTX_clone(SSL_CTX *ctx) {
     CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
 }
 
-void rust_EVP_PKEY_clone(EVP_PKEY *pkey) {
-    CRYPTO_add(&pkey->references,1,CRYPTO_LOCK_EVP_PKEY);
-}
-
 void rust_X509_clone(X509 *x509) {
     CRYPTO_add(&x509->references,1,CRYPTO_LOCK_X509);
 }
diff --git a/openssl/src/crypto/pkey.rs b/openssl/src/crypto/pkey.rs
index cafd50ad..f945276d 100644
--- a/openssl/src/crypto/pkey.rs
+++ b/openssl/src/crypto/pkey.rs
@@ -53,10 +53,6 @@ fn openssl_hash_nid(hash: HashType) -> c_int {
     }
 }
 
-extern "C" {
-    fn rust_EVP_PKEY_clone(pkey: *mut ffi::EVP_PKEY);
-}
-
 pub struct PKey {
     evp: *mut ffi::EVP_PKEY,
     parts: Parts,
@@ -614,10 +610,10 @@ impl Drop for PKey {
 impl Clone for PKey {
     fn clone(&self) -> Self {
         unsafe {
-            rust_EVP_PKEY_clone(self.evp);
+            let new_evp = ffi::EVP_PKEY_new();
+            assert!(ffi::EVP_PKEY_copy_parameters(new_evp, self.evp) == 0);
+            PKey::from_handle(new_evp, self.parts)
         }
-
-        PKey::from_handle(self.evp, self.parts)
     }
 }
 
@@ -866,4 +862,16 @@ mod tests {
         pkey.load_pub(&[]);
         pkey.verify(&[], &[]);
     }
+
+    #[test]
+    fn test_pkey_clone_creates_copy() {
+        let mut pkey = super::PKey::new();
+        pkey.gen(512);
+        let old_pkey_n = pkey.get_rsa().n().unwrap();
+
+        let mut pkey2 = pkey.clone();
+        pkey2.gen(512);
+
+        assert!(old_pkey_n == pkey.get_rsa().n().unwrap());
+    }
 }
diff --git a/openssl/src/lib.rs b/openssl/src/lib.rs
index 9db1df92..ad982597 100644
--- a/openssl/src/lib.rs
+++ b/openssl/src/lib.rs
@@ -1,4 +1,4 @@
-#![doc(html_root_url="https://sfackler.github.io/rust-openssl/doc/v0.7.8")]
+#![doc(html_root_url="https://sfackler.github.io/rust-openssl/doc/v0.7.9")]
 #![cfg_attr(feature = "nightly", feature(const_fn, recover, panic_propagate))]
 
 #[macro_use]
diff --git a/openssl/src/ssl/bio.rs b/openssl/src/ssl/bio.rs
index 8d295928..4adbfbe2 100644
--- a/openssl/src/ssl/bio.rs
+++ b/openssl/src/ssl/bio.rs
@@ -1,5 +1,5 @@
 use libc::{c_char, c_int, c_long, c_void, strlen};
-use ffi::{BIO, BIO_METHOD, BIO_CTRL_FLUSH, BIO_TYPE_NONE, BIO_new};
+use ffi::{self, BIO, BIO_CTRL_FLUSH, BIO_TYPE_NONE, BIO_new};
 use ffi_extras::{BIO_clear_retry_flags, BIO_set_retry_read, BIO_set_retry_write};
 use std::any::Any;
 use std::io;
@@ -17,19 +17,30 @@ pub struct StreamState<S> {
     pub panic: Option<Box<Any + Send>>,
 }
 
-pub fn new<S: Read + Write>(stream: S) -> Result<(*mut BIO, Arc<BIO_METHOD>), SslError> {
-    let method = Arc::new(BIO_METHOD {
-        type_: BIO_TYPE_NONE,
-        name: b"rust\0".as_ptr() as *const _,
-        bwrite: Some(bwrite::<S>),
-        bread: Some(bread::<S>),
-        bputs: Some(bputs::<S>),
-        bgets: None,
-        ctrl: Some(ctrl::<S>),
-        create: Some(create),
-        destroy: Some(destroy::<S>),
-        callback_ctrl: None,
-    });
+/// Safe wrapper for BIO_METHOD
+pub struct BioMethod(ffi::BIO_METHOD);
+
+impl BioMethod {
+    pub fn new<S: Read + Write>() -> BioMethod {
+        BioMethod(ffi::BIO_METHOD {
+                type_: BIO_TYPE_NONE,
+                name: b"rust\0".as_ptr() as *const _,
+                bwrite: Some(bwrite::<S>),
+                bread: Some(bread::<S>),
+                bputs: Some(bputs::<S>),
+                bgets: None,
+                ctrl: Some(ctrl::<S>),
+                create: Some(create),
+                destroy: Some(destroy::<S>),
+                callback_ctrl: None,
+        })
+    }
+}
+
+unsafe impl Send for BioMethod {}
+
+pub fn new<S: Read + Write>(stream: S) -> Result<(*mut BIO, Arc<BioMethod>), SslError> {
+    let method = Arc::new(BioMethod::new::<S>());
 
     let state = Box::new(StreamState {
         stream: stream,
@@ -38,7 +49,7 @@ pub fn new<S: Read + Write>(stream: S) -> Result<(*mut BIO, Arc<BIO_METHOD>), Ss
     });
 
     unsafe {
-        let bio = try_ssl_null!(BIO_new(&*method));
+        let bio = try_ssl_null!(BIO_new(&method.0));
         (*bio).ptr = Box::into_raw(state) as *mut _;
         (*bio).init = 1;
 
@@ -72,7 +83,7 @@ unsafe fn state<'a, S: 'a>(bio: *mut BIO) -> &'a mut StreamState<S> {
 
 #[cfg(feature = "nightly")]
 fn recover<F, T>(f: F) -> Result<T, Box<Any + Send>> where F: FnOnce() -> T {
-    ::std::panic::recover(::std::panic::AssertRecoverSafe::new(f))
+    ::std::panic::recover(::std::panic::AssertRecoverSafe(f))
 }
 
 #[cfg(not(feature = "nightly"))]
@@ -86,9 +97,7 @@ unsafe extern "C" fn bwrite<S: Write>(bio: *mut BIO, buf: *const c_char, len: c_
     let state = state::<S>(bio);
     let buf = slice::from_raw_parts(buf as *const _, len as usize);
 
-    let result = recover(|| state.stream.write(buf));
-
-    match result {
+    match recover(|| state.stream.write(buf)) {
         Ok(Ok(len)) => len as c_int,
         Ok(Err(err)) => {
             if retriable_error(&err) {
@@ -110,9 +119,7 @@ unsafe extern "C" fn bread<S: Read>(bio: *mut BIO, buf: *mut c_char, len: c_int)
     let state = state::<S>(bio);
     let buf = slice::from_raw_parts_mut(buf as *mut _, len as usize);
 
-    let result = recover(|| state.stream.read(buf));
-
-    match result {
+    match recover(|| state.stream.read(buf)) {
         Ok(Ok(len)) => len as c_int,
         Ok(Err(err)) => {
             if retriable_error(&err) {
@@ -146,9 +153,8 @@ unsafe extern "C" fn ctrl<S: Write>(bio: *mut BIO,
                                     -> c_long {
     if cmd == BIO_CTRL_FLUSH {
         let state = state::<S>(bio);
-        let result = recover(|| state.stream.flush());
 
-        match result {
+        match recover(|| state.stream.flush()) {
             Ok(Ok(())) => 1,
             Ok(Err(err)) => {
                 state.error = Some(err);
diff --git a/openssl/src/ssl/mod.rs b/openssl/src/ssl/mod.rs
index 38527dc6..7b5cf492 100644
--- a/openssl/src/ssl/mod.rs
+++ b/openssl/src/ssl/mod.rs
@@ -35,6 +35,8 @@ mod bio;
 #[cfg(test)]
 mod tests;
 
+use self::bio::BioMethod;
+
 #[doc(inline)]
 pub use ssl::error::Error;
 
@@ -827,7 +829,7 @@ impl <'a> SslCipher<'a> {
             let desc_ptr = ffi::SSL_CIPHER_description(self.cipher, buf.as_mut_ptr(), 128);
 
             if !desc_ptr.is_null() {
-                String::from_utf8(CStr::from_ptr(desc_ptr).to_bytes().to_vec()).ok()
+                String::from_utf8(CStr::from_ptr(desc_ptr as *const _).to_bytes().to_vec()).ok()
             } else {
                 None
             }
@@ -1117,12 +1119,10 @@ make_LibSslError! {
 /// A stream wrapper which handles SSL encryption for an underlying stream.
 pub struct SslStream<S> {
     ssl: Ssl,
-    _method: Arc<ffi::BIO_METHOD>, // NOTE: this *must* be after the Ssl field so things drop right
+    _method: Arc<BioMethod>, // NOTE: this *must* be after the Ssl field so things drop right
     _p: PhantomData<S>,
 }
 
-unsafe impl<S: Send> Send for SslStream<S> {}
-
 /// # Deprecated
 ///
 /// This method does not behave as expected and will be removed in a future