Merge remote-tracking branch 'upstream/master'

Conflicts:
	openssl-sys/src/lib.rs

8 files changed, 62 insertions, 45 deletions

diff --git a/src/bn/mod.rs b/src/bn/mod.rs
index 7605fee0..a4d23302 100644
--- a/src/bn/mod.rs
+++ b/src/bn/mod.rs
@@ -7,6 +7,7 @@ use ssl::error::SslError;
 
 pub struct BigNum(*mut ffi::BIGNUM);
 
+#[deriving(Copy)]
 #[repr(C)]
 pub enum RNGProperty {
     MsbMaybeZero = -1,
@@ -25,7 +26,7 @@ macro_rules! with_ctx(
             r
         }
     });
-)
+);
 
 macro_rules! with_bn(
     ($name:ident, $action:block) => ({
@@ -41,7 +42,7 @@ macro_rules! with_bn(
             Err(err) => Err(err),
         }
     });
-)
+);
 
 macro_rules! with_bn_in_ctx(
     ($name:ident, $ctx_name:ident, $action:block) => ({
@@ -65,7 +66,7 @@ macro_rules! with_bn_in_ctx(
             Err(err) => Err(err),
         }
     });
-)
+);
 
 impl BigNum {
     pub fn new() -> Result<BigNum, SslError> {
@@ -441,45 +442,45 @@ pub mod unchecked {
     use ffi;
     use super::{BigNum};
 
-    impl Add<BigNum, BigNum> for BigNum {
-        fn add(&self, oth: &BigNum) -> BigNum {
+    impl<'a> Add<&'a BigNum, BigNum> for &'a BigNum {
+        fn add(self, oth: &'a BigNum) -> BigNum {
             self.checked_add(oth).unwrap()
         }
     }
 
-    impl Sub<BigNum, BigNum> for BigNum {
-        fn sub(&self, oth: &BigNum) -> BigNum {
+    impl<'a> Sub<&'a BigNum, BigNum> for &'a BigNum {
+        fn sub(self, oth: &'a BigNum) -> BigNum {
             self.checked_sub(oth).unwrap()
         }
     }
 
-    impl Mul<BigNum, BigNum> for BigNum {
-        fn mul(&self, oth: &BigNum) -> BigNum {
+    impl<'a> Mul<&'a BigNum, BigNum> for &'a BigNum {
+        fn mul(self, oth: &'a BigNum) -> BigNum {
             self.checked_mul(oth).unwrap()
         }
     }
 
-    impl Div<BigNum, BigNum> for BigNum {
-        fn div(&self, oth: &BigNum) -> BigNum {
+    impl<'a> Div<&'a BigNum, BigNum> for &'a BigNum {
+        fn div(self, oth: &'a BigNum) -> BigNum {
             self.checked_div(oth).unwrap()
         }
     }
 
-    impl Rem<BigNum, BigNum> for BigNum {
-        fn rem(&self, oth: &BigNum) -> BigNum {
+    impl<'a> Rem<&'a BigNum, BigNum> for &'a BigNum {
+        fn rem(self, oth: &'a BigNum) -> BigNum {
             self.checked_mod(oth).unwrap()
         }
     }
 
-    impl Shl<i32, BigNum> for BigNum {
-        fn shl(&self, n: &i32) -> BigNum {
-            self.checked_shl(n).unwrap()
+    impl<'a> Shl<i32, BigNum> for &'a BigNum {
+        fn shl(self, n: i32) -> BigNum {
+            self.checked_shl(&n).unwrap()
         }
     }
 
-    impl Shr<i32, BigNum> for BigNum {
-        fn shr(&self, n: &i32) -> BigNum {
-            self.checked_shr(n).unwrap()
+    impl<'a> Shr<i32, BigNum> for &'a BigNum {
+        fn shr(self, n: i32) -> BigNum {
+            self.checked_shr(&n).unwrap()
         }
     }
 
@@ -497,7 +498,7 @@ pub mod unchecked {
     }
 
     impl Neg<BigNum> for BigNum {
-        fn neg(&self) -> BigNum {
+        fn neg(self) -> BigNum {
             let mut n = self.clone();
             n.negate();
             n
diff --git a/src/crypto/hash.rs b/src/crypto/hash.rs
index b5d0eab5..2a181526 100644
--- a/src/crypto/hash.rs
+++ b/src/crypto/hash.rs
@@ -4,6 +4,7 @@ use std::io;
 
 use ffi;
 
+#[deriving(Copy)]
 pub enum HashType {
     MD5,
     SHA1,
@@ -134,7 +135,7 @@ mod tests {
     }
 
     fn compare(calced_raw: Vec<u8>, hashtest: &HashTest) {
-        let calced = calced_raw.as_slice().to_hex().into_string();
+        let calced = calced_raw.as_slice().to_hex().to_string();
 
         if calced != hashtest.expected_output {
             println!("Test failed - {} != {}", calced, hashtest.expected_output);
diff --git a/src/crypto/hmac.rs b/src/crypto/hmac.rs
index 8096a948..aab0c014 100644
--- a/src/crypto/hmac.rs
+++ b/src/crypto/hmac.rs
@@ -55,7 +55,7 @@ impl HMAC {
             let mut res = Vec::from_elem(self.len, 0u8);
             let mut outlen = 0;
             ffi::HMAC_Final(&mut self.ctx, res.as_mut_ptr(), &mut outlen);
-            assert!(self.len == outlen as uint)
+            assert!(self.len == outlen as uint);
             res
         }
     }
diff --git a/src/crypto/pkey.rs b/src/crypto/pkey.rs
index 146d2aa3..bab7addc 100644
--- a/src/crypto/pkey.rs
+++ b/src/crypto/pkey.rs
@@ -6,7 +6,7 @@ use crypto::hash::HashType;
 use ffi;
 use ssl::error::{SslError, StreamError};
 
-
+#[deriving(Copy)]
 enum Parts {
     Neither,
     Public,
@@ -14,6 +14,7 @@ enum Parts {
 }
 
 /// Represents a role an asymmetric key might be appropriate for.
+#[deriving(Copy)]
 pub enum Role {
     Encrypt,
     Decrypt,
@@ -22,6 +23,7 @@ pub enum Role {
 }
 
 /// Type of encryption padding to use.
+#[deriving(Copy)]
 pub enum EncryptionPadding {
     OAEP,
     PKCS1v15
diff --git a/src/crypto/symm.rs b/src/crypto/symm.rs
index 998d351c..61365f2e 100644
--- a/src/crypto/symm.rs
+++ b/src/crypto/symm.rs
@@ -2,12 +2,14 @@ use libc::{c_int};
 
 use ffi;
 
+#[deriving(Copy)]
 pub enum Mode {
     Encrypt,
     Decrypt,
 }
 
 #[allow(non_camel_case_types)]
+#[deriving(Copy)]
 pub enum Type {
     AES_128_ECB,
     AES_128_CBC,
diff --git a/src/ssl/mod.rs b/src/ssl/mod.rs
index 6112bc8d..43673596 100644
--- a/src/ssl/mod.rs
+++ b/src/ssl/mod.rs
@@ -33,6 +33,7 @@ fn init() {
 /// Determines the SSL method supported
 #[deriving(Show, Hash, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
+#[deriving(Copy)]
 pub enum SslMethod {
     #[cfg(feature = "sslv2")]
     /// Only support the SSLv2 protocol, requires `feature="sslv2"`
@@ -68,6 +69,7 @@ impl SslMethod {
 }
 
 /// Determines the type of certificate verification used
+#[deriving(Copy)]
 #[repr(i32)]
 pub enum SslVerifyMode {
     /// Verify that the server's certificate is trusted
@@ -91,8 +93,9 @@ fn get_verify_data_idx<T>() -> c_int {
 
     unsafe {
         INIT.doit(|| {
+            let f: ffi::CRYPTO_EX_free = free_data_box::<T>;
             let idx = ffi::SSL_CTX_get_ex_new_index(0, ptr::null(), None,
-                                                    None, Some(free_data_box::<T>));
+                                                    None, Some(f));
             assert!(idx >= 0);
             VERIFY_DATA_IDX = idx;
         });
@@ -197,7 +200,9 @@ impl SslContext {
         unsafe {
             ffi::SSL_CTX_set_ex_data(self.ctx, VERIFY_IDX,
                                      mem::transmute(verify));
-            ffi::SSL_CTX_set_verify(self.ctx, mode as c_int, Some(raw_verify));
+            let f: extern fn(c_int, *mut ffi::X509_STORE_CTX) -> c_int =
+                                raw_verify;
+            ffi::SSL_CTX_set_verify(self.ctx, mode as c_int, Some(f));
         }
     }
 
@@ -214,7 +219,9 @@ impl SslContext {
                                      mem::transmute(Some(verify)));
             ffi::SSL_CTX_set_ex_data(self.ctx, get_verify_data_idx::<T>(),
                                      mem::transmute(data));
-            ffi::SSL_CTX_set_verify(self.ctx, mode as c_int, Some(raw_verify_with_data::<T>));
+            let f: extern fn(c_int, *mut ffi::X509_STORE_CTX) -> c_int =
+                                raw_verify_with_data::<T>;
+            ffi::SSL_CTX_set_verify(self.ctx, mode as c_int, Some(f));
         }
     }
 
@@ -382,7 +389,7 @@ impl Ssl {
 
 }
 
-#[deriving(FromPrimitive)]
+#[deriving(FromPrimitive, Show)]
 #[repr(i32)]
 enum LibSslError {
     ErrorNone = ffi::SSL_ERROR_NONE,
@@ -487,7 +494,7 @@ impl<S: Stream> SslStream<S> {
                 LibSslError::ErrorWantWrite => { try_ssl_stream!(self.flush()) }
                 LibSslError::ErrorZeroReturn => return Err(SslSessionClosed),
                 LibSslError::ErrorSsl => return Err(SslError::get()),
-                _ => unreachable!()
+                err => panic!("unexpected error {}", err),
             }
         }
     }
@@ -539,7 +546,7 @@ impl<S: Stream> Writer for SslStream<S> {
         let mut start = 0;
         while start < buf.len() {
             let ret = self.in_retry_wrapper(|ssl| {
-                ssl.write(buf.split_at(start).val1())
+                ssl.write(buf.split_at(start).1)
             });
             match ret {
                 Ok(len) => start += len as uint,
diff --git a/src/ssl/tests.rs b/src/ssl/tests.rs
index e4414f84..6723fa58 100644
--- a/src/ssl/tests.rs
+++ b/src/ssl/tests.rs
@@ -1,10 +1,11 @@
 use serialize::hex::FromHex;
-use std::io::{Writer};
 use std::io::net::tcp::TcpStream;
+use std::io::{Writer};
+use std::thread::Thread;
 
 use crypto::hash::HashType::{SHA256};
 use ssl::SslMethod::Sslv23;
-use ssl::{SslContext, SslStream};
+use ssl::{SslContext, SslStream, VerifyCallback};
 use ssl::SslVerifyMode::SslVerifyPeer;
 use x509::{X509StoreContext};
 
@@ -52,7 +53,7 @@ fn test_verify_untrusted_callback_override_ok() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     match SslStream::new(&ctx, stream) {
         Ok(_) => (),
         Err(err) => panic!("Expected success, got {}", err)
@@ -66,7 +67,7 @@ fn test_verify_untrusted_callback_override_bad() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     assert!(SslStream::new(&ctx, stream).is_err());
 }
 
@@ -77,7 +78,7 @@ fn test_verify_trusted_callback_override_ok() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     match ctx.set_CA_file(&Path::new("test/cert.pem")) {
         None => {}
         Some(err) => panic!("Unexpected error {}", err)
@@ -95,7 +96,7 @@ fn test_verify_trusted_callback_override_bad() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     match ctx.set_CA_file(&Path::new("test/cert.pem")) {
         None => {}
         Some(err) => panic!("Unexpected error {}", err)
@@ -111,7 +112,7 @@ fn test_verify_callback_load_certs() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     assert!(SslStream::new(&ctx, stream).is_ok());
 }
 
@@ -123,7 +124,7 @@ fn test_verify_trusted_get_error_ok() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     match ctx.set_CA_file(&Path::new("test/cert.pem")) {
         None => {}
         Some(err) => panic!("Unexpected error {}", err)
@@ -139,7 +140,7 @@ fn test_verify_trusted_get_error_err() {
     }
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut ctx = SslContext::new(Sslv23).unwrap();
-    ctx.set_verify(SslVerifyPeer, Some(callback));
+    ctx.set_verify(SslVerifyPeer, Some(callback as VerifyCallback));
     assert!(SslStream::new(&ctx, stream).is_err());
 }
 
@@ -198,7 +199,7 @@ fn test_clone() {
     let stream = TcpStream::connect("127.0.0.1:15418").unwrap();
     let mut stream = SslStream::new(&SslContext::new(Sslv23).unwrap(), stream).unwrap();
     let mut stream2 = stream.clone();
-    spawn(proc() {
+    let _t = Thread::spawn(move || {
         stream2.write("GET /\r\n\r\n".as_bytes()).unwrap();
         stream2.flush().unwrap();
     });
diff --git a/src/x509/mod.rs b/src/x509/mod.rs
index a06fe4e1..c82eab11 100644
--- a/src/x509/mod.rs
+++ b/src/x509/mod.rs
@@ -15,6 +15,7 @@ use ssl::error::{SslError, StreamError};
 #[cfg(test)]
 mod tests;
 
+#[deriving(Copy)]
 #[repr(i32)]
 pub enum X509FileType {
     PEM = ffi::X509_FILETYPE_PEM,
@@ -22,6 +23,7 @@ pub enum X509FileType {
     Default = ffi::X509_FILETYPE_DEFAULT
 }
 
+#[allow(missing_copy_implementations)]
 pub struct X509StoreContext {
     ctx: *mut ffi::X509_STORE_CTX
 }
@@ -54,7 +56,7 @@ trait AsStr<'a> {
     fn as_str(&self) -> &'a str;
 }
 
-#[deriving(Clone)]
+#[deriving(Clone, Copy)]
 pub enum KeyUsage {
     DigitalSignature,
     NonRepudiation,
@@ -84,7 +86,7 @@ impl AsStr<'static> for KeyUsage {
 }
 
 
-#[deriving(Clone)]
+#[deriving(Clone, Copy)]
 pub enum ExtKeyUsage {
     ServerAuth,
     ClientAuth,
@@ -360,7 +362,7 @@ impl<'ctx> X509<'ctx> {
     }
 
     /// Reads certificate from PEM, takes ownership of handle
-    pub fn from_pem(reader: &mut Reader) -> Result<X509<'ctx>, SslError> {
+    pub fn from_pem<R>(reader: &mut R) -> Result<X509<'ctx>, SslError> where R: Reader {
         let mut mem_bio = try!(MemBio::new());
         let buf = try!(reader.read_to_end().map_err(StreamError));
         try!(mem_bio.write(buf.as_slice()).map_err(StreamError));
@@ -402,7 +404,7 @@ impl<'ctx> X509<'ctx> {
     }
 
     /// Writes certificate as PEM
-    pub fn write_pem(&self, writer: &mut Writer) -> Result<(), SslError> {
+    pub fn write_pem<W>(&self, writer: &mut W) -> Result<(), SslError> where W: Writer{
         let mut mem_bio = try!(MemBio::new());
         unsafe {
             try_ssl!(ffi::PEM_write_bio_X509(mem_bio.get_handle(),
@@ -430,6 +432,7 @@ pub struct X509Name<'x> {
 
 macro_rules! make_validation_error(
     ($ok_val:ident, $($name:ident = $val:ident,)+) => (
+        #[deriving(Copy)]
         pub enum X509ValidationError {
             $($name,)+
             X509UnknownError(c_int)
@@ -446,7 +449,7 @@ macro_rules! make_validation_error(
             }
         }
     )
-)
+);
 
 make_validation_error!(X509_V_OK,
     X509UnableToGetIssuerCert = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT,
@@ -502,7 +505,7 @@ make_validation_error!(X509_V_OK,
     X509UnsupportedNameSyntax = X509_V_ERR_UNSUPPORTED_NAME_SYNTAX,
     X509CrlPathValidationError= X509_V_ERR_CRL_PATH_VALIDATION_ERROR,
     X509ApplicationVerification = X509_V_ERR_APPLICATION_VERIFICATION,
-)
+);
 
 
 #[test]