Merge remote-tracking branch 'upstream/master'

Conflicts:
	openssl-sys/src/lib.rs

2 files changed, 24 insertions, 9 deletions

diff --git a/openssl-sys/src/build.rs b/openssl-sys/src/build.rs
index 53c047b2..ca71f791 100644
--- a/openssl-sys/src/build.rs
+++ b/openssl-sys/src/build.rs
@@ -9,9 +9,14 @@ fn main() {
 
 
     if pkg_config::find_library("openssl").is_err() {
-        let mut flags = " -l crypto -l ssl".to_string();
-
         let target = os::getenv("TARGET").unwrap();
+        let is_android = target.find_str("android").is_some();
+
+        let mut flags = if is_android {
+            " -l crypto:static -l ssl:static"
+        } else {
+            " -l crypto -l ssl"
+        }.to_string();
 
         let win_pos = target.find_str("windows")
                             .or(target.find_str("win32"))
@@ -23,7 +28,7 @@ fn main() {
            flags.push_str(" -l gdi32 -l wsock32");
         }
 
-        if target.find_str("android").is_some() {
+        if is_android {
             let path = os::getenv("OPENSSL_PATH").expect("Android does not provide openssl libraries, please \
                                                           build them yourselves (instructions in the README) \
                                                           and provide their location through $OPENSSL_PATH.");
diff --git a/openssl-sys/src/lib.rs b/openssl-sys/src/lib.rs
index 68d2d6dc..48fac1d2 100644
--- a/openssl-sys/src/lib.rs
+++ b/openssl-sys/src/lib.rs
@@ -2,7 +2,6 @@
 #![allow(dead_code)]
 
 extern crate libc;
-extern crate rustrt;
 
 #[cfg(feature = "libressl-pnacl-sys")]
 extern crate "libressl-pnacl-sys" as _for_linkage;
@@ -10,7 +9,7 @@ extern crate "libressl-pnacl-sys" as _for_linkage;
 use libc::{c_void, c_int, c_char, c_ulong, c_long, c_uint, c_uchar, size_t};
 use std::mem;
 use std::ptr;
-use rustrt::mutex::NativeMutex;
+use std::sync::{StaticMutex, StaticMutexGuard, MUTEX_INIT};
 use std::sync::{Once, ONCE_INIT};
 
 pub type ASN1_INTEGER = c_void;
@@ -49,6 +48,8 @@ pub struct EVP_MD_CTX {
     update: *mut c_void
 }
 
+impl Copy for EVP_MD_CTX {}
+
 #[repr(C)]
 pub struct HMAC_CTX {
     md: *mut EVP_MD,
@@ -59,6 +60,8 @@ pub struct HMAC_CTX {
     key: [c_uchar, ..128]
 }
 
+impl Copy for HMAC_CTX {}
+
 #[repr(C)]
 pub struct X509V3_CTX {
     flags: c_int,
@@ -72,6 +75,8 @@ pub struct X509V3_CTX {
     // Maybe more here
 }
 
+impl Copy for X509V3_CTX {}
+
 #[repr(C)]
 pub struct BIGNUM {
     pub d: *mut c_void,
@@ -81,6 +86,8 @@ pub struct BIGNUM {
     pub flags: c_int,
 }
 
+impl Copy for BIGNUM {}
+
 #[repr(C)]
 pub struct BIGNUM_PTR {
     pub ptr: *mut BIGNUM,
@@ -189,7 +196,8 @@ pub const X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE: c_int = 45;
 pub const X509_V_ERR_UNSUPPORTED_NAME_SYNTAX: c_int = 53;
 pub const X509_V_OK: c_int = 0;
 
-static mut MUTEXES: *mut Vec<NativeMutex> = 0 as *mut Vec<NativeMutex>;
+static mut MUTEXES: *mut Vec<StaticMutex> = 0 as *mut Vec<StaticMutex>;
+static mut GUARDS: *mut Vec<Option<StaticMutexGuard>> = 0 as *mut Vec<Option<StaticMutexGuard>>;
 
 extern fn locking_function(mode: c_int, n: c_int, _file: *const c_char,
                                _line: c_int) {
@@ -197,9 +205,9 @@ extern fn locking_function(mode: c_int, n: c_int, _file: *const c_char,
         let mutex = &(*MUTEXES)[n as uint];
 
         if mode & CRYPTO_LOCK != 0 {
-            mutex.lock_noguard();
+            (*GUARDS)[n as uint] = Some(mutex.lock());
         } else {
-            mutex.unlock_noguard();
+            &(*GUARDS)[n as uint].take();
         }
     }
 }
@@ -213,8 +221,10 @@ pub fn init() {
             SSL_load_error_strings();
 
             let num_locks = CRYPTO_num_locks();
-            let mutexes = box Vec::from_fn(num_locks as uint, |_| NativeMutex::new());
+            let mutexes = box Vec::from_fn(num_locks as uint, |_| MUTEX_INIT);
             MUTEXES = mem::transmute(mutexes);
+            let guards: Box<Vec<Option<StaticMutexGuard>>> = box Vec::from_fn(num_locks as uint, |_| None);
+            GUARDS = mem::transmute(guards);
 
             CRYPTO_set_locking_callback(locking_function);
         })