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

Fix locking

parent 0b287710

.travis.yml

+1 −1
Original line number Diff line number Diff line
@@ -7,4 +7,4 @@ before_script: 
  - openssl s_server -accept 15418 -www -cert test/cert.pem -key test/key.pem >/dev/null &

script:

  - rustpkg build

  - env RUST_TEST_TASKS=1 rustpkg test
 
  - rustpkg test

ffi.rs

+8 −0
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ pub type CRYPTO_EX_free = extern "C" fn(parent: *c_void, ptr: *c_void, 
                                        ad: *CRYPTO_EX_DATA, idx: c_int,

                                        argl: c_long, argp: *c_void);



pub static CRYPTO_LOCK: c_int = 1;



pub static SSL_ERROR_NONE: c_int = 0;

pub static SSL_ERROR_SSL: c_int = 1;

pub static SSL_ERROR_WANT_READ: c_int = 2;
@@ -101,6 +103,12 @@ pub static X509_V_ERR_APPLICATION_VERIFICATION: c_int = 50; 


#[link_args = "-lssl -lcrypto"]

extern "C" {

    pub fn CRYPTO_num_locks() -> c_int;

    pub fn CRYPTO_set_locking_callback(func: extern "C" fn(mode: c_int,

                                                           n: c_int,

                                                           file: *c_char,

                                                           line: c_int));



    pub fn ERR_get_error() -> c_ulong;



    pub fn SSL_library_init() -> c_int;

lib.rs

+30 −6
Original line number Diff line number Diff line
@@ -6,11 +6,12 @@ 
#[doc(html_root_url="http://sfackler.com/doc/rust-ssl/")];



use std::cast;

use std::libc::{c_int, c_void};

use std::libc::{c_int, c_void, c_char};

use std::ptr;

use std::task;

use std::unstable::atomics::{AtomicBool, INIT_ATOMIC_BOOL, AtomicInt,

                             INIT_ATOMIC_INT, Acquire, Release, SeqCst};

use std::unstable::atomics::{AtomicBool, INIT_ATOMIC_BOOL, AtomicUint,

                             INIT_ATOMIC_UINT, Acquire, Release, SeqCst};

use std::unstable::mutex::Mutex;

use std::io::{Stream, Reader, Writer, Decorator};

use std::vec;
@@ -24,7 +25,10 @@ mod ffi; 
static mut STARTED_INIT: AtomicBool = INIT_ATOMIC_BOOL;

static mut FINISHED_INIT: AtomicBool = INIT_ATOMIC_BOOL;



static mut VERIFY_IDX: AtomicInt = INIT_ATOMIC_INT;

static mut VERIFY_IDX: AtomicUint = INIT_ATOMIC_UINT;



// actually a *~[Mutex]

static mut MUTEXES: AtomicUint = INIT_ATOMIC_UINT;



fn init() {

    unsafe {
@@ -39,7 +43,13 @@ fn init() { 
        let verify_idx = ffi::SSL_CTX_get_ex_new_index(0, ptr::null(), None,

                                                       None, None);

        assert!(verify_idx >= 0);

        VERIFY_IDX.store(verify_idx as int, SeqCst);

        VERIFY_IDX.store(verify_idx as uint, Release);



        let num_locks = ffi::CRYPTO_num_locks();

        let mutexes = ~vec::from_fn(num_locks as uint, |_| Mutex::new());

        MUTEXES.store(cast::transmute(mutexes), Release);



        ffi::CRYPTO_set_locking_callback(locking_function);



        FINISHED_INIT.store(true, Release);

    }
@@ -73,13 +83,27 @@ pub enum SslVerifyMode { 
    SslVerifyNone = ffi::SSL_VERIFY_NONE

}



extern "C" fn locking_function(mode: c_int, n: c_int, _file: *c_char,

                               _line: c_int) {

    unsafe {

        let mutexes: *mut ~[Mutex] = cast::transmute(MUTEXES.load(Acquire));

        let mutex = &mut (*mutexes)[n as uint];



        if mode & ffi::CRYPTO_LOCK != 0 {

            mutex.lock();

        } else {

            mutex.unlock();

        }

    }

}



extern "C" fn raw_verify(preverify_ok: c_int, x509_ctx: *ffi::X509_STORE_CTX)

        -> c_int {

    unsafe {

        let idx = ffi::SSL_get_ex_data_X509_STORE_CTX_idx();

        let ssl = ffi::X509_STORE_CTX_get_ex_data(x509_ctx, idx);

        let ssl_ctx = ffi::SSL_get_SSL_CTX(ssl);

        let idx = VERIFY_IDX.load(SeqCst) as c_int;

        let idx = VERIFY_IDX.load(Acquire) as c_int;

        let verify = ffi::SSL_CTX_get_ex_data(ssl_ctx, idx);

        let verify: Option<VerifyCallback> = cast::transmute(verify);