Commit cf80af7d authored by Steven Fackler's avatar Steven Fackler
Browse files

Merge pull request #166 from Ryman/master 

Rustup
parents 19488f71 cb0e1688

openssl/src/bn/mod.rs

+5 −5
Original line number Diff line number Diff line 
use libc::{c_int, c_ulong, c_void};

use std::ffi::{CString, c_str_to_bytes};

use std::ffi::{CStr, CString};

use std::cmp::Ordering;

use std::{fmt, ptr};
@@ -88,7 +88,7 @@ impl BigNum { 


    pub fn from_dec_str(s: &str) -> Result<BigNum, SslError> {

        BigNum::new().and_then(|v| unsafe {

            let c_str = CString::from_slice(s.as_bytes());

            let c_str = CString::new(s.as_bytes()).unwrap();

            try_ssl!(ffi::BN_dec2bn(v.raw_ptr(), c_str.as_ptr()));

            Ok(v)

        })
@@ -96,7 +96,7 @@ impl BigNum { 


    pub fn from_hex_str(s: &str) -> Result<BigNum, SslError> {

        BigNum::new().and_then(|v| unsafe {

            let c_str = CString::from_slice(s.as_bytes());

            let c_str = CString::new(s.as_bytes()).unwrap();

            try_ssl!(ffi::BN_hex2bn(v.raw_ptr(), c_str.as_ptr()));

            Ok(v)

        })
@@ -421,7 +421,7 @@ impl BigNum { 
        unsafe {

            let buf = ffi::BN_bn2dec(self.raw());

            assert!(!buf.is_null());

            let str = String::from_utf8(c_str_to_bytes(&buf).to_vec()).unwrap();

            let str = String::from_utf8(CStr::from_ptr(buf).to_bytes().to_vec()).unwrap();

            ffi::CRYPTO_free(buf as *mut c_void);

            str

        }
@@ -431,7 +431,7 @@ impl BigNum { 
        unsafe {

            let buf = ffi::BN_bn2hex(self.raw());

            assert!(!buf.is_null());

            let str = String::from_utf8(c_str_to_bytes(&buf).to_vec()).unwrap();

            let str = String::from_utf8(CStr::from_ptr(buf).to_bytes().to_vec()).unwrap();

            ffi::CRYPTO_free(buf as *mut c_void);

            str

        }

openssl/src/crypto/hmac.rs

+3 −3
Original line number Diff line number Diff line
@@ -253,7 +253,7 @@ mod tests { 
        ];



        let mut h = HMAC::new(MD5, &*tests[0].0);

        for i in 0..100us {

        for i in 0..100usize {

            let test = &tests[i % 2];

            test_hmac_recycle(&mut h, test);

        }
@@ -351,7 +351,7 @@ mod tests { 
        ];



        let mut h = HMAC::new(SHA1, &*tests[0].0);

        for i in 0..100us {

        for i in 0..100usize {

            let test = &tests[i % 2];

            test_hmac_recycle(&mut h, test);

        }
@@ -382,7 +382,7 @@ mod tests { 


        // recycle test

        let mut h = HMAC::new(ty, &*tests[5].0);

        for i in 0..100us {

        for i in 0..100usize {

            let test = &tests[4 + i % 2];

            let tup = (test.0.clone(), test.1.clone(), results[4 + i % 2].clone());

            test_hmac_recycle(&mut h, &tup);

openssl/src/lib.rs

+1 −1
Original line number Diff line number Diff line 
#![feature(unsafe_destructor, core, old_io, std_misc, libc, hash, old_path)]

#![feature(unsafe_destructor, core, old_io, std_misc, libc, old_path)]

#![crate_name="openssl"]

#![crate_type="rlib"]

#![crate_type="dylib"]

openssl/src/ssl/error.rs

+4 −4
Original line number Diff line number Diff line
@@ -4,7 +4,7 @@ pub use self::OpensslError::*; 
use libc::c_ulong;

use std::error;

use std::fmt;

use std::ffi::c_str_to_bytes;

use std::ffi::CStr;

use std::old_io::IoError;



use ffi;
@@ -75,21 +75,21 @@ pub enum OpensslError { 


fn get_lib(err: c_ulong) -> String {

    unsafe {

        let bytes = c_str_to_bytes(&ffi::ERR_lib_error_string(err)).to_vec();

        let bytes = CStr::from_ptr(ffi::ERR_lib_error_string(err)).to_bytes().to_vec();

        String::from_utf8(bytes).unwrap()

    }

}



fn get_func(err: c_ulong) -> String {

    unsafe {

        let bytes = c_str_to_bytes(&ffi::ERR_func_error_string(err)).to_vec();

        let bytes = CStr::from_ptr(ffi::ERR_func_error_string(err)).to_bytes().to_vec();

        String::from_utf8(bytes).unwrap()

    }

}



fn get_reason(err: c_ulong) -> String {

    unsafe {

        let bytes = c_str_to_bytes(&ffi::ERR_reason_error_string(err)).to_vec();

        let bytes = CStr::from_ptr(ffi::ERR_reason_error_string(err)).to_bytes().to_vec();

        String::from_utf8(bytes).unwrap()

    }

}

openssl/src/ssl/mod.rs

+34 −33
Original line number Diff line number Diff line 
use libc::{c_int, c_void, c_long};

use std::ffi::{CString, c_str_to_bytes};

use std::ffi::{CStr, CString};

use std::old_io::{IoResult, IoError, EndOfFile, OtherIoError, Stream, Reader, Writer};

use std::mem;

use std::fmt;
@@ -186,7 +186,7 @@ impl fmt::Debug for SslContext { 


impl Drop for SslContext {

    fn drop(&mut self) {

        unsafe { ffi::SSL_CTX_free(self.ctx.ptr) }

        unsafe { ffi::SSL_CTX_free(*self.ctx) }

    }

}
@@ -200,18 +200,19 @@ impl SslContext { 
            return Err(SslError::get());

        }



        Ok(SslContext { ctx: ptr::Unique(ctx) })

        let ctx = unsafe { SslContext { ctx: ptr::Unique::new(ctx) } };

        Ok(ctx)

    }



    /// Configures the certificate verification method for new connections.

    pub fn set_verify(&mut self, mode: SslVerifyMode,

                      verify: Option<VerifyCallback>) {

        unsafe {

            ffi::SSL_CTX_set_ex_data(self.ctx.ptr, VERIFY_IDX,

            ffi::SSL_CTX_set_ex_data(*self.ctx, VERIFY_IDX,

                                     mem::transmute(verify));

            let f: extern fn(c_int, *mut ffi::X509_STORE_CTX) -> c_int =

                                raw_verify;

            ffi::SSL_CTX_set_verify(self.ctx.ptr, mode as c_int, Some(f));

            ffi::SSL_CTX_set_verify(*self.ctx, mode as c_int, Some(f));

        }

    }
@@ -224,20 +225,20 @@ impl SslContext { 
                                   data: T) {

        let data = Box::new(data);

        unsafe {

            ffi::SSL_CTX_set_ex_data(self.ctx.ptr, VERIFY_IDX,

            ffi::SSL_CTX_set_ex_data(*self.ctx, VERIFY_IDX,

                                     mem::transmute(Some(verify)));

            ffi::SSL_CTX_set_ex_data(self.ctx.ptr, get_verify_data_idx::<T>(),

            ffi::SSL_CTX_set_ex_data(*self.ctx, get_verify_data_idx::<T>(),

                                     mem::transmute(data));

            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.ptr, mode as c_int, Some(f));

            ffi::SSL_CTX_set_verify(*self.ctx, mode as c_int, Some(f));

        }

    }



    /// Sets verification depth

    pub fn set_verify_depth(&mut self, depth: u32) {

        unsafe {

            ffi::SSL_CTX_set_verify_depth(self.ctx.ptr, depth as c_int);

            ffi::SSL_CTX_set_verify_depth(*self.ctx, depth as c_int);

        }

    }
@@ -246,8 +247,8 @@ impl SslContext { 
    pub fn set_CA_file(&mut self, file: &Path) -> Option<SslError> {

        wrap_ssl_result(

            unsafe {

                let file = CString::from_slice(file.as_vec());

                ffi::SSL_CTX_load_verify_locations(self.ctx.ptr, file.as_ptr(), ptr::null())

                let file = CString::new(file.as_vec()).unwrap();

                ffi::SSL_CTX_load_verify_locations(*self.ctx, file.as_ptr(), ptr::null())

            })

    }
@@ -256,8 +257,8 @@ impl SslContext { 
                                file_type: X509FileType) -> Option<SslError> {

        wrap_ssl_result(

            unsafe {

                let file = CString::from_slice(file.as_vec());

                ffi::SSL_CTX_use_certificate_file(self.ctx.ptr, file.as_ptr(), file_type as c_int)

                let file = CString::new(file.as_vec()).unwrap();

                ffi::SSL_CTX_use_certificate_file(*self.ctx, file.as_ptr(), file_type as c_int)

            })

    }
@@ -266,16 +267,16 @@ impl SslContext { 
                                file_type: X509FileType) -> Option<SslError> {

        wrap_ssl_result(

            unsafe {

                let file = CString::from_slice(file.as_vec());

                ffi::SSL_CTX_use_PrivateKey_file(self.ctx.ptr, file.as_ptr(), file_type as c_int)

                let file = CString::new(file.as_vec()).unwrap();

                ffi::SSL_CTX_use_PrivateKey_file(*self.ctx, file.as_ptr(), file_type as c_int)

            })

    }



    pub fn set_cipher_list(&mut self, cipher_list: &str) -> Option<SslError> {

        wrap_ssl_result(

            unsafe {

                let cipher_list = CString::from_slice(cipher_list.as_bytes());

                ffi::SSL_CTX_set_cipher_list(self.ctx.ptr, cipher_list.as_ptr())

                let cipher_list = CString::new(cipher_list.as_bytes()).unwrap();

                ffi::SSL_CTX_set_cipher_list(*self.ctx, cipher_list.as_ptr())

            })

    }

}
@@ -309,31 +310,31 @@ impl fmt::Debug for Ssl { 


impl Drop for Ssl {

    fn drop(&mut self) {

        unsafe { ffi::SSL_free(self.ssl.ptr) }

        unsafe { ffi::SSL_free(*self.ssl) }

    }

}



impl Ssl {

    pub fn new(ctx: &SslContext) -> Result<Ssl, SslError> {

        let ssl = unsafe { ffi::SSL_new(ctx.ctx.ptr) };

        let ssl = unsafe { ffi::SSL_new(*ctx.ctx) };

        if ssl == ptr::null_mut() {

            return Err(SslError::get());

        }

        let ssl = Ssl { ssl: ptr::Unique(ssl) };

        let ssl = unsafe { Ssl { ssl: ptr::Unique::new(ssl) } };



        let rbio = try!(MemBio::new());

        let wbio = try!(MemBio::new());



        unsafe { ffi::SSL_set_bio(ssl.ssl.ptr, rbio.unwrap(), wbio.unwrap()) }

        unsafe { ffi::SSL_set_bio(*ssl.ssl, rbio.unwrap(), wbio.unwrap()) }

        Ok(ssl)

    }



    fn get_rbio<'a>(&'a self) -> MemBioRef<'a> {

        unsafe { self.wrap_bio(ffi::SSL_get_rbio(self.ssl.ptr)) }

        unsafe { self.wrap_bio(ffi::SSL_get_rbio(*self.ssl)) }

    }



    fn get_wbio<'a>(&'a self) -> MemBioRef<'a> {

        unsafe { self.wrap_bio(ffi::SSL_get_wbio(self.ssl.ptr)) }

        unsafe { self.wrap_bio(ffi::SSL_get_wbio(*self.ssl)) }

    }



    fn wrap_bio<'a>(&'a self, bio: *mut ffi::BIO) -> MemBioRef<'a> {
@@ -345,25 +346,25 @@ impl Ssl { 
    }



    fn connect(&self) -> c_int {

        unsafe { ffi::SSL_connect(self.ssl.ptr) }

        unsafe { ffi::SSL_connect(*self.ssl) }

    }



    fn accept(&self) -> c_int {

        unsafe { ffi::SSL_accept(self.ssl.ptr) }

        unsafe { ffi::SSL_accept(*self.ssl) }

    }



    fn read(&self, buf: &mut [u8]) -> c_int {

        unsafe { ffi::SSL_read(self.ssl.ptr, buf.as_ptr() as *mut c_void,

        unsafe { ffi::SSL_read(*self.ssl, buf.as_ptr() as *mut c_void,

                               buf.len() as c_int) }

    }



    fn write(&self, buf: &[u8]) -> c_int {

        unsafe { ffi::SSL_write(self.ssl.ptr, buf.as_ptr() as *const c_void,

        unsafe { ffi::SSL_write(*self.ssl, buf.as_ptr() as *const c_void,

                                buf.len() as c_int) }

    }



    fn get_error(&self, ret: c_int) -> LibSslError {

        let err = unsafe { ffi::SSL_get_error(self.ssl.ptr, ret) };

        let err = unsafe { ffi::SSL_get_error(*self.ssl, ret) };

        match FromPrimitive::from_int(err as isize) {

            Some(err) => err,

            None => unreachable!()
@@ -377,8 +378,8 @@ impl Ssl { 
                //      #define SSL_set_tlsext_host_name(s,name) \

                //          SSL_ctrl(s,SSL_CTRL_SET_TLSEXT_HOSTNAME,TLSEXT_NAMETYPE_host_name,(char *)name)



                let hostname = CString::from_slice(hostname.as_bytes());

                ffi::SSL_ctrl(self.ssl.ptr, ffi::SSL_CTRL_SET_TLSEXT_HOSTNAME,

                let hostname = CString::new(hostname.as_bytes()).unwrap();

                ffi::SSL_ctrl(*self.ssl, ffi::SSL_CTRL_SET_TLSEXT_HOSTNAME,

                              ffi::TLSEXT_NAMETYPE_host_name,

                              hostname.as_ptr() as *mut c_void)

        };
@@ -393,7 +394,7 @@ impl Ssl { 


    pub fn get_peer_certificate(&self) -> Option<X509> {

        unsafe {

            let ptr = ffi::SSL_get_peer_certificate(self.ssl.ptr);

            let ptr = ffi::SSL_get_peer_certificate(*self.ssl);

            if ptr.is_null() {

                None

            } else {
@@ -534,14 +535,14 @@ impl<S: Stream> SslStream<S> { 
    /// either None, indicating no compression is in use, or a string

    /// with the compression name.

    pub fn get_compression(&self) -> Option<String> {

        let ptr = unsafe { ffi::SSL_get_current_compression(self.ssl.ssl.ptr) };

        let ptr = unsafe { ffi::SSL_get_current_compression(*self.ssl.ssl) };

        if ptr == ptr::null() {

            return None;

        }



        let meth = unsafe { ffi::SSL_COMP_get_name(ptr) };

        let s = unsafe {

            String::from_utf8(c_str_to_bytes(&meth).to_vec()).unwrap()

            String::from_utf8(CStr::from_ptr(meth).to_bytes().to_vec()).unwrap()

        };



        Some(s)