Switch to real mutex for init.

use std::cast;

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

use std::ptr;

use std::task;

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

                         INIT_ATOMIC_UINT, Acquire, Release, SeqCst};

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

use std::sync::atomics::{AtomicUint, INIT_ATOMIC_UINT, Acquire, Release, SeqCst};

use std::unstable::finally::Finally;

use std::unstable::mutex::{Mutex, MUTEX_INIT};

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

use std::vec;

#[cfg(test)]

mod tests;

static mut STARTED_INIT: AtomicBool = INIT_ATOMIC_BOOL;

static mut FINISHED_INIT: AtomicBool = INIT_ATOMIC_BOOL;

static mut INIT_LOCK: Mutex = MUTEX_INIT;

static mut INITIALIZED: bool = false;

static mut VERIFY_IDX: AtomicUint = INIT_ATOMIC_UINT;

fn init() {

    unsafe {

        if STARTED_INIT.swap(true, Acquire) {

            while !FINISHED_INIT.load(Release) {

                task::deschedule();

            }

        INIT_LOCK.lock();

        (|| {

            if INITIALIZED {

                return;

            }

            ffi::CRYPTO_set_locking_callback(locking_function);

        FINISHED_INIT.store(true, Release);

            INITIALIZED = true;

        }).finally(|| {

            INIT_LOCK.unlock();

        })

    }

}