Fix deprecation warnings (2f24d8e7) · Commits · Public Repositories / Rust Openssl

openssl-sys/src/lib.rs

+4 −3

Original line number	Diff line number	Diff line
		@@ -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::<Vec<_>>();
		MUTEXES = mem::transmute(mutexes);
		let guards: Box<Vec<Option<MutexGuard<()>>>> = box Vec::from_fn(num_locks as uint, \|_\| None);
		let guards: Box<Vec<Option<MutexGuard<()>>>> =
		box range(0, num_locks).map(\|_\| None).collect();
		GUARDS = mem::transmute(guards);

		CRYPTO_set_locking_callback(locking_function);

src/crypto/hash.rs

+2 −1

Original line number	Diff line number	Diff line
		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<u8>, HasherContext) {
		let mut res = Vec::from_elem(self.len, 0u8);
		let mut res = repeat(0u8).take(self.len).collect::<Vec<_>>();
		unsafe {
		ffi::EVP_DigestFinal_ex(self.ctx.ptr, res.as_mut_ptr(), ptr::null_mut())
		};

src/crypto/hmac.rs

+20 −18

Original line number	Diff line number	Diff line
		@@ -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<u8> {
		unsafe {
		let mut res = Vec::from_elem(self.len, 0u8);
		let mut res: Vec<u8> = 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<u8>, Vec<u8>, Vec<u8>); 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<u8>, Vec<u8>, Vec<u8>); 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<u8>]) {
		// test vectors from RFC 4231
		let tests: [(Vec<u8>, Vec<u8>); 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())

src/crypto/pkey.rs

+5 −4

Original line number	Diff line number	Diff line
		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::<Vec<_>>();

		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::<Vec<_>>();

		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::<Vec<_>>();

		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::<Vec<_>>();

		let rv = ffi::RSA_sign(
		openssl_hash_nid(hash),

src/crypto/symm.rs

+3 −2

Original line number	Diff line number	Diff line
		use std::iter::repeat;
		use libc::{c_int};

		use ffi;
		@@ -109,7 +110,7 @@ impl Crypter {
		*/
		pub fn update(&self, data: &[u8]) -> Vec<u8> {
		unsafe {
		let mut res = Vec::from_elem(data.len() + self.blocksize, 0u8);
		let mut res = repeat(0u8).take(data.len() + self.blocksize).collect::<Vec<_>>();
		let mut reslen = (data.len() + self.blocksize) as u32;

		ffi::EVP_CipherUpdate(
		@@ -130,7 +131,7 @@ impl Crypter {
		*/
		pub fn finalize(&self) -> Vec<u8> {
		unsafe {
		let mut res = Vec::from_elem(self.blocksize, 0u8);
		let mut res = repeat(0u8).take(self.blocksize).collect::<Vec<_>>();
		let mut reslen = self.blocksize as c_int;

		ffi::EVP_CipherFinal(self.ctx,