From 2f24d8e771cfc140e53e6afe58994aafd455b701 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 3 Jan 2015 08:31:57 -0800 Subject: [PATCH] Fix deprecation warnings --- openssl-sys/src/lib.rs | 7 ++++--- src/crypto/hash.rs | 3 ++- src/crypto/hmac.rs | 38 ++++++++++++++++++++------------------ src/crypto/pkey.rs | 9 +++++---- src/crypto/symm.rs | 5 +++-- src/ssl/mod.rs | 4 ++-- src/x509/mod.rs | 3 ++- 7 files changed, 38 insertions(+), 31 deletions(-) diff --git a/openssl-sys/src/lib.rs b/openssl-sys/src/lib.rs index 1fdd5580..923863f3 100644 --- a/openssl-sys/src/lib.rs +++ b/openssl-sys/src/lib.rs @@ -211,14 +211,15 @@ pub fn init() { static mut INIT: Once = ONCE_INIT; unsafe { - INIT.doit(|| { + INIT.call_once(|| { SSL_library_init(); SSL_load_error_strings(); let num_locks = CRYPTO_num_locks(); - let mutexes = box Vec::from_fn(num_locks as uint, |_| MUTEX_INIT); + let mutexes = box range(0, num_locks).map(|_| MUTEX_INIT).collect::>(); MUTEXES = mem::transmute(mutexes); - let guards: Box>>> = box Vec::from_fn(num_locks as uint, |_| None); + let guards: Box>>> = + box range(0, num_locks).map(|_| None).collect(); GUARDS = mem::transmute(guards); CRYPTO_set_locking_callback(locking_function); diff --git a/src/crypto/hash.rs b/src/crypto/hash.rs index a9711e92..1f8a3936 100644 --- a/src/crypto/hash.rs +++ b/src/crypto/hash.rs @@ -1,6 +1,7 @@ use libc::c_uint; use std::ptr; use std::io; +use std::iter::repeat; use ffi; @@ -101,7 +102,7 @@ impl Hasher { * initialization and its context for reuse */ pub fn finalize_reuse(self) -> (Vec, HasherContext) { - let mut res = Vec::from_elem(self.len, 0u8); + let mut res = repeat(0u8).take(self.len).collect::>(); unsafe { ffi::EVP_DigestFinal_ex(self.ctx.ptr, res.as_mut_ptr(), ptr::null_mut()) }; diff --git a/src/crypto/hmac.rs b/src/crypto/hmac.rs index 03e59c6f..6de0b1e7 100644 --- a/src/crypto/hmac.rs +++ b/src/crypto/hmac.rs @@ -15,6 +15,7 @@ */ use libc::{c_int, c_uint}; +use std::iter::repeat; use crypto::hash; use ffi; @@ -52,7 +53,7 @@ impl HMAC { pub fn finalize(&mut self) -> Vec { unsafe { - let mut res = Vec::from_elem(self.len, 0u8); + let mut res: Vec = repeat(0).take(self.len).collect(); let mut outlen = 0; ffi::HMAC_Final(&mut self.ctx, res.as_mut_ptr(), &mut outlen); assert!(self.len == outlen as uint); @@ -71,6 +72,7 @@ impl Drop for HMAC { #[cfg(test)] mod tests { + use std::iter::repeat; use serialize::hex::FromHex; use crypto::hash::HashType::{self, MD5, SHA1, SHA224, SHA256, SHA384, SHA512}; use super::HMAC; @@ -79,23 +81,23 @@ mod tests { fn test_hmac_md5() { // test vectors from RFC 2202 let tests: [(Vec, Vec, Vec); 7] = [ - (Vec::from_elem(16, 0x0b_u8), b"Hi There".to_vec(), + (repeat(0x0b_u8).take(16).collect(), b"Hi There".to_vec(), "9294727a3638bb1c13f48ef8158bfc9d".from_hex().unwrap()), (b"Jefe".to_vec(), b"what do ya want for nothing?".to_vec(), "750c783e6ab0b503eaa86e310a5db738".from_hex().unwrap()), - (Vec::from_elem(16, 0xaa_u8), Vec::from_elem(50, 0xdd_u8), + (repeat(0xaa_u8).take(16).collect(), repeat(0xdd_u8).take(50).collect(), "56be34521d144c88dbb8c733f0e8b3f6".from_hex().unwrap()), ("0102030405060708090a0b0c0d0e0f10111213141516171819".from_hex().unwrap(), - Vec::from_elem(50, 0xcd_u8), + repeat(0xcd_u8).take(50).collect(), "697eaf0aca3a3aea3a75164746ffaa79".from_hex().unwrap()), - (Vec::from_elem(16, 0x0c_u8), + (repeat(0x0c_u8).take(16).collect(), b"Test With Truncation".to_vec(), "56461ef2342edc00f9bab995690efd4c".from_hex().unwrap()), - (Vec::from_elem(80, 0xaa_u8), + (repeat(0xaa_u8).take(80).collect(), b"Test Using Larger Than Block-Size Key - Hash Key First".to_vec(), "6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd".from_hex().unwrap()), - (Vec::from_elem(80, 0xaa_u8), + (repeat(0xaa_u8).take(80).collect(), b"Test Using Larger Than Block-Size Key \ and Larger Than One Block-Size Data".to_vec(), "6f630fad67cda0ee1fb1f562db3aa53e".from_hex().unwrap()) @@ -112,23 +114,23 @@ mod tests { fn test_hmac_sha1() { // test vectors from RFC 2202 let tests: [(Vec, Vec, Vec); 7] = [ - (Vec::from_elem(20, 0x0b_u8), b"Hi There".to_vec(), + (repeat(0x0b_u8).take(20).collect(), b"Hi There".to_vec(), "b617318655057264e28bc0b6fb378c8ef146be00".from_hex().unwrap()), (b"Jefe".to_vec(), b"what do ya want for nothing?".to_vec(), "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79".from_hex().unwrap()), - (Vec::from_elem(20, 0xaa_u8), Vec::from_elem(50, 0xdd_u8), + (repeat(0xaa_u8).take(20).collect(), repeat(0xdd_u8).take(50).collect(), "125d7342b9ac11cd91a39af48aa17b4f63f175d3".from_hex().unwrap()), ("0102030405060708090a0b0c0d0e0f10111213141516171819".from_hex().unwrap(), - Vec::from_elem(50, 0xcd_u8), + repeat(0xcd_u8).take(50).collect(), "4c9007f4026250c6bc8414f9bf50c86c2d7235da".from_hex().unwrap()), - (Vec::from_elem(20, 0x0c_u8), + (repeat(0x0c_u8).take(20).collect(), b"Test With Truncation".to_vec(), "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04".from_hex().unwrap()), - (Vec::from_elem(80, 0xaa_u8), + (repeat(0xaa_u8).take(80).collect(), b"Test Using Larger Than Block-Size Key - Hash Key First".to_vec(), "aa4ae5e15272d00e95705637ce8a3b55ed402112".from_hex().unwrap()), - (Vec::from_elem(80, 0xaa_u8), + (repeat(0xaa_u8).take(80).collect(), b"Test Using Larger Than Block-Size Key \ and Larger Than One Block-Size Data".to_vec(), "e8e99d0f45237d786d6bbaa7965c7808bbff1a91".from_hex().unwrap()) @@ -144,15 +146,15 @@ mod tests { fn test_sha2(ty: HashType, results: &[Vec]) { // test vectors from RFC 4231 let tests: [(Vec, Vec); 6] = [ - (Vec::from_elem(20, 0x0b_u8), b"Hi There".to_vec()), + (repeat(0xb_u8).take(20).collect(), b"Hi There".to_vec()), (b"Jefe".to_vec(), b"what do ya want for nothing?".to_vec()), - (Vec::from_elem(20, 0xaa_u8), Vec::from_elem(50, 0xdd_u8)), + (repeat(0xaa_u8).take(20).collect(), repeat(0xdd_u8).take(50).collect()), ("0102030405060708090a0b0c0d0e0f10111213141516171819".from_hex().unwrap(), - Vec::from_elem(50, 0xcd_u8)), - (Vec::from_elem(131, 0xaa_u8), + repeat(0xcd_u8).take(50).collect()), + (repeat(0xaa_u8).take(131).collect(), b"Test Using Larger Than Block-Size Key - Hash Key First".to_vec()), - (Vec::from_elem(131, 0xaa_u8), + (repeat(0xaa_u8).take(131).collect(), b"This is a test using a larger than block-size key and a \ larger than block-size data. The key needs to be hashed \ before being used by the HMAC algorithm.".to_vec()) diff --git a/src/crypto/pkey.rs b/src/crypto/pkey.rs index ac3a407e..2264e192 100644 --- a/src/crypto/pkey.rs +++ b/src/crypto/pkey.rs @@ -1,4 +1,5 @@ use libc::{c_int, c_uint}; +use std::iter::repeat; use std::mem; use std::ptr; use bio::{MemBio}; @@ -71,7 +72,7 @@ impl PKey { let rsa = ffi::EVP_PKEY_get1_RSA(self.evp); let len = f(rsa, ptr::null()); if len < 0 as c_int { return vec!(); } - let mut s = Vec::from_elem(len as uint, 0u8); + let mut s = repeat(0u8).take(len as uint).collect::>(); let r = f(rsa, &s.as_mut_ptr()); @@ -209,7 +210,7 @@ impl PKey { assert!(s.len() < self.max_data()); - let mut r = Vec::from_elem(len as uint + 1u, 0u8); + let mut r = repeat(0u8).take(len as uint + 1).collect::>(); let rv = ffi::RSA_public_encrypt( s.len() as c_uint, @@ -234,7 +235,7 @@ impl PKey { assert_eq!(s.len() as c_uint, ffi::RSA_size(rsa)); - let mut r = Vec::from_elem(len as uint + 1u, 0u8); + let mut r = repeat(0u8).take(len as uint + 1).collect::>(); let rv = ffi::RSA_private_decrypt( s.len() as c_uint, @@ -279,7 +280,7 @@ impl PKey { unsafe { let rsa = ffi::EVP_PKEY_get1_RSA(self.evp); let mut len = ffi::RSA_size(rsa); - let mut r = Vec::from_elem(len as uint + 1u, 0u8); + let mut r = repeat(0u8).take(len as uint + 1).collect::>(); let rv = ffi::RSA_sign( openssl_hash_nid(hash), diff --git a/src/crypto/symm.rs b/src/crypto/symm.rs index d1021b37..9478bc4a 100644 --- a/src/crypto/symm.rs +++ b/src/crypto/symm.rs @@ -1,3 +1,4 @@ +use std::iter::repeat; use libc::{c_int}; use ffi; @@ -109,7 +110,7 @@ impl Crypter { */ pub fn update(&self, data: &[u8]) -> Vec { unsafe { - let mut res = Vec::from_elem(data.len() + self.blocksize, 0u8); + let mut res = repeat(0u8).take(data.len() + self.blocksize).collect::>(); let mut reslen = (data.len() + self.blocksize) as u32; ffi::EVP_CipherUpdate( @@ -130,7 +131,7 @@ impl Crypter { */ pub fn finalize(&self) -> Vec { unsafe { - let mut res = Vec::from_elem(self.blocksize, 0u8); + let mut res = repeat(0u8).take(self.blocksize).collect::>(); let mut reslen = self.blocksize as c_int; ffi::EVP_CipherFinal(self.ctx, diff --git a/src/ssl/mod.rs b/src/ssl/mod.rs index 3a19f643..9b320c49 100644 --- a/src/ssl/mod.rs +++ b/src/ssl/mod.rs @@ -21,7 +21,7 @@ fn init() { static mut INIT: Once = ONCE_INIT; unsafe { - INIT.doit(|| { + INIT.call_once(|| { ffi::init(); let verify_idx = ffi::SSL_CTX_get_ex_new_index(0, ptr::null(), None, @@ -94,7 +94,7 @@ fn get_verify_data_idx() -> c_int { } unsafe { - INIT.doit(|| { + INIT.call_once(|| { let f: ffi::CRYPTO_EX_free = free_data_box::; let idx = ffi::SSL_CTX_get_ex_new_index(0, ptr::null(), None, None, Some(f)); diff --git a/src/x509/mod.rs b/src/x509/mod.rs index ed8fb77d..4537e553 100644 --- a/src/x509/mod.rs +++ b/src/x509/mod.rs @@ -1,6 +1,7 @@ use libc::{c_int, c_long, c_uint}; use std::c_str::ToCStr; use std::cmp::Ordering; +use std::iter::repeat; use std::mem; use std::num::SignedInt; use std::ptr; @@ -385,7 +386,7 @@ impl<'ctx> X509<'ctx> { /// Returns certificate fingerprint calculated using provided hash pub fn fingerprint(&self, hash_type: HashType) -> Option> { let (evp, len) = evpmd(hash_type); - let v: Vec = Vec::from_elem(len, 0); + let v: Vec = repeat(0).take(len).collect(); let act_len: c_uint = 0; let res = unsafe { ffi::X509_digest(self.handle, evp, mem::transmute(v.as_ptr()),