Fix deprecation warnings

openssl/src/bn/mod.rs

@@ -579,7 +579,7 @@ mod tests {
     fn test_to_from_slice() {
         let v0 = BigNum::new_from(10203004_u64).unwrap();
         let vec = v0.to_vec();
-        let v1 = BigNum::new_from_slice(vec.as_slice()).unwrap();
+        let v1 = BigNum::new_from_slice(&vec).unwrap();
 
         assert!(v0 == v1);
     }

openssl/src/crypto/pkey.rs

@@ -342,7 +342,7 @@ mod tests {
         let mut k0 = super::PKey::new();
         let mut k1 = super::PKey::new();
         k0.gen(512);
-        k1.load_pub(k0.save_pub().as_slice());
+        k1.load_pub(&k0.save_pub());
         assert_eq!(k0.save_pub(), k1.save_pub());
         assert_eq!(k0.size(), k1.size());
         assert!(k0.can(super::Role::Encrypt));
@@ -360,7 +360,7 @@ mod tests {
         let mut k0 = super::PKey::new();
         let mut k1 = super::PKey::new();
         k0.gen(512);
-        k1.load_priv(k0.save_priv().as_slice());
+        k1.load_priv(&k0.save_priv());
         assert_eq!(k0.save_priv(), k1.save_priv());
         assert_eq!(k0.size(), k1.size());
         assert!(k0.can(super::Role::Encrypt));
@@ -379,9 +379,9 @@ mod tests {
         let mut k1 = super::PKey::new();
         let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
         k0.gen(512);
-        k1.load_pub(k0.save_pub().as_slice());
+        k1.load_pub(&k0.save_pub());
-        let emsg = k1.encrypt(msg.as_slice());
+        let emsg = k1.encrypt(&msg);
-        let dmsg = k0.decrypt(emsg.as_slice());
+        let dmsg = k0.decrypt(&emsg);
         assert!(msg == dmsg);
     }
 
@@ -391,9 +391,9 @@ mod tests {
         let mut k1 = super::PKey::new();
         let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
         k0.gen(512);
-        k1.load_pub(k0.save_pub().as_slice());
+        k1.load_pub(&k0.save_pub());
-        let emsg = k1.encrypt_with_padding(msg.as_slice(), super::EncryptionPadding::PKCS1v15);
+        let emsg = k1.encrypt_with_padding(&msg, super::EncryptionPadding::PKCS1v15);
-        let dmsg = k0.decrypt_with_padding(emsg.as_slice(), super::EncryptionPadding::PKCS1v15);
+        let dmsg = k0.decrypt_with_padding(&emsg, super::EncryptionPadding::PKCS1v15);
         assert!(msg == dmsg);
     }
 
@@ -403,9 +403,9 @@ mod tests {
         let mut k1 = super::PKey::new();
         let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
         k0.gen(512);
-        k1.load_pub(k0.save_pub().as_slice());
+        k1.load_pub(&k0.save_pub());
-        let sig = k0.sign(msg.as_slice());
+        let sig = k0.sign(&msg);
-        let rv = k1.verify(msg.as_slice(), sig.as_slice());
+        let rv = k1.verify(&msg, &sig);
         assert!(rv == true);
     }
 
@@ -415,11 +415,11 @@ mod tests {
         let mut k1 = super::PKey::new();
         let msg = vec!(0xdeu8, 0xadu8, 0xd0u8, 0x0du8);
         k0.gen(512);
-        k1.load_pub(k0.save_pub().as_slice());
+        k1.load_pub(&k0.save_pub());
 
-        let sig = k0.sign_with_hash(msg.as_slice(), MD5);
+        let sig = k0.sign_with_hash(&msg, MD5);
 
-        assert!(k1.verify_with_hash(msg.as_slice(), sig.as_slice(), MD5));
+        assert!(k1.verify_with_hash(&msg, &sig, MD5));
-        assert!(!k1.verify_with_hash(msg.as_slice(), sig.as_slice(), SHA1));
+        assert!(!k1.verify_with_hash(&msg, &sig, SHA1));
     }
 }

openssl/src/crypto/symm.rs

@@ -199,14 +199,14 @@ mod tests {
            vec!(0x8eu8, 0xa2u8, 0xb7u8, 0xcau8, 0x51u8, 0x67u8, 0x45u8, 0xbfu8,
               0xeau8, 0xfcu8, 0x49u8, 0x90u8, 0x4bu8, 0x49u8, 0x60u8, 0x89u8);
         let c = super::Crypter::new(super::Type::AES_256_ECB);
-        c.init(super::Mode::Encrypt, k0.as_slice(), vec![]);
+        c.init(super::Mode::Encrypt, &k0, vec![]);
         c.pad(false);
-        let mut r0 = c.update(p0.as_slice());
+        let mut r0 = c.update(&p0);
         r0.extend(c.finalize().into_iter());
         assert!(r0 == c0);
-        c.init(super::Mode::Decrypt, k0.as_slice(), vec![]);
+        c.init(super::Mode::Decrypt, &k0, vec![]);
         c.pad(false);
-        let mut p1 = c.update(r0.as_slice());
+        let mut p1 = c.update(&r0);
         p1.extend(c.finalize().into_iter());
         assert!(p1 == p0);
     }
@@ -239,25 +239,22 @@ mod tests {
 
         assert!(unciphered_data_2.len() == 0);
 
-        assert_eq!(
+        assert_eq!(&unciphered_data_1, expected_unciphered_data);
-            unciphered_data_1.as_slice(),
-            expected_unciphered_data
-        );
     }
 
     fn cipher_test(ciphertype: super::Type, pt: &str, ct: &str, key: &str, iv: &str) {
         use serialize::hex::ToHex;
 
         let cipher = super::Crypter::new(ciphertype);
-        cipher.init(super::Mode::Encrypt, key.from_hex().unwrap().as_slice(), iv.from_hex().unwrap());
+        cipher.init(super::Mode::Encrypt, &key.from_hex().unwrap(), iv.from_hex().unwrap());
 
-        let expected = ct.from_hex().unwrap().as_slice().to_vec();
+        let expected = ct.from_hex().unwrap();
-        let mut computed = cipher.update(pt.from_hex().unwrap().as_slice());
+        let mut computed = cipher.update(&pt.from_hex().unwrap());
         computed.extend(cipher.finalize().into_iter());
 
         if computed != expected {
-            println!("Computed: {}", computed.as_slice().to_hex());
+            println!("Computed: {}", computed.to_hex());
-            println!("Expected: {}", expected.as_slice().to_hex());
+            println!("Expected: {}", expected.to_hex());
             if computed.len() != expected.len() {
                 println!("Lengths differ: {} in computed vs {} expected",
                          computed.len(), expected.len());

openssl/src/ssl/error.rs

@@ -132,7 +132,7 @@ fn test_uknown_error_should_have_correct_messages() {
 
     let UnknownError { ref library, ref function, ref reason } = errs[0];
 
-    assert_eq!(library.as_slice(), "SSL routines");
+    assert_eq!(&library[..], "SSL routines");
-    assert_eq!(function.as_slice(), "SSL23_GET_SERVER_HELLO");
+    assert_eq!(&function[..], "SSL23_GET_SERVER_HELLO");
-    assert_eq!(reason.as_slice(), "sslv3 alert handshake failure");
+    assert_eq!(&reason[..], "sslv3 alert handshake failure");
 }

openssl/src/ssl/mod.rs

@@ -1,4 +1,4 @@
-use libc::{c_int, c_void, c_long, c_uint, c_uchar};
+use libc::{c_int, c_void, c_long};
 use std::ffi::{CStr, CString};
 use std::fmt;
 use std::io;
@@ -6,7 +6,6 @@ use std::io::prelude::*;
 use std::ffi::AsOsStr;
 use std::mem;
 use std::net;
-use std::slice;
 use std::num::FromPrimitive;
 use std::num::Int;
 use std::path::Path;

openssl/src/ssl/tests.rs

@@ -1,16 +1,15 @@
 use serialize::hex::FromHex;
-use std::net::{TcpStream, TcpListener};
+use std::net::TcpStream;
 use std::io;
 use std::io::prelude::*;
 use std::path::Path;
-use std::thread;
 
 use crypto::hash::Type::{SHA256};
 use ssl;
 use ssl::SslMethod::Sslv23;
 use ssl::{SslContext, SslStream, VerifyCallback};
 use ssl::SslVerifyMode::SslVerifyPeer;
-use x509::{X509StoreContext, X509FileType};
+use x509::X509StoreContext;
 
 #[test]
 fn test_new_ctx() {
@@ -155,7 +154,7 @@ fn test_verify_callback_data() {
             None => false,
             Some(cert) => {
                 let fingerprint = cert.fingerprint(SHA256).unwrap();
-                fingerprint.as_slice() == node_id.as_slice()
+                &fingerprint == node_id
             }
         }
     }

openssl/src/x509/mod.rs

@@ -332,17 +332,17 @@ impl X509Generator {
             let name = ffi::X509_get_subject_name(x509.handle);
             try_ssl_null!(name);
 
-            try!(X509Generator::add_name(name, "CN", self.CN.as_slice()));
+            try!(X509Generator::add_name(name, "CN", &self.CN));
             ffi::X509_set_issuer_name(x509.handle, name);
 
             if self.key_usage.len() > 0 {
                 try!(X509Generator::add_extension(x509.handle, ffi::NID_key_usage,
-                                                  self.key_usage.to_str().as_slice()));
+                                                  &self.key_usage.to_str()));
             }
 
             if self.ext_key_usage.len() > 0 {
                 try!(X509Generator::add_extension(x509.handle, ffi::NID_ext_key_usage,
-                                                  self.ext_key_usage.to_str().as_slice()));
+                                                  &self.ext_key_usage.to_str()));
             }
 
             let hash_fn = self.hash_type.evp_md();

openssl/src/x509/tests.rs

@@ -47,5 +47,5 @@ fn test_cert_loading() {
     let hash_str = "46e3f1a6d17a41ce70d0c66ef51cee2ab4ba67cac8940e23f10c1f944b49fb5c";
     let hash_vec = hash_str.from_hex().unwrap();
 
-    assert_eq!(fingerprint.as_slice(), hash_vec.as_slice());
+    assert_eq!(fingerprint, hash_vec);
 }