Add support for OpenSSL 1.1.0

This commit is relatively major refactoring of the `openssl-sys` crate as well
as the `openssl` crate itself. The end goal here was to support OpenSSL 1.1.0,
and lots of other various tweaks happened along the way. The major new features
are:

* OpenSSL 1.1.0 is supported
* OpenSSL 0.9.8 is no longer supported (aka all OSX users by default)
* All FFI bindings are verified with the `ctest` crate (same way as the `libc`
  crate)
* CI matrixes are vastly expanded to include 32/64 of all platforms, more
  OpenSSL version coverage, as well as ARM coverage on Linux
* The `c_helpers` module is completely removed along with the `gcc` dependency.
* The `openssl-sys` build script was completely rewritten
  * Now uses `OPENSSL_DIR` to find the installation, not include/lib env vars.
  * Better error messages for mismatched versions.
  * Better error messages for failing to find OpenSSL on a platform (more can be
    done here)
  * Probing of OpenSSL build-time configuration to inform the API of the `*-sys`
    crate.
* Many Cargo features have been removed as they're now enabled by default.

As this is a breaking change to both the `openssl` and `openssl-sys` crates this
will necessitate a major version bump of both. There's still a few more API
questions remaining but let's hash that out on a PR!

Closes #452

1 files changed, 46 insertions, 10 deletions

diff --git a/openssl/src/crypto/dsa.rs b/openssl/src/crypto/dsa.rs
index 97ba7a97..bb4fe474 100644
--- a/openssl/src/crypto/dsa.rs
+++ b/openssl/src/crypto/dsa.rs
@@ -19,8 +19,13 @@ impl DSAParams {
         unsafe {
             // Wrap it so that if we panic we'll call the dtor
             let dsa = DSAParams(try_ssl_null!(ffi::DSA_new()));
-            try_ssl!(ffi::DSA_generate_parameters_ex(dsa.0, size as c_int, ptr::null(), 0,
-                                                 ptr::null_mut(), ptr::null_mut(), ptr::null()));
+            try_ssl!(ffi::DSA_generate_parameters_ex(dsa.0,
+                                                     size as c_int,
+                                                     ptr::null(),
+                                                     0,
+                                                     ptr::null_mut(),
+                                                     ptr::null_mut(),
+                                                     ptr::null_mut()));
             Ok(dsa)
         }
     }
@@ -190,43 +195,74 @@ impl DSA {
 
     pub fn p<'a>(&'a self) -> Option<BigNumRef<'a>> {
         unsafe {
-            let p = (*self.0).p;
+            let p = compat::pqg(self.0)[0];
             if p.is_null() {
                 None
             } else {
-                Some(BigNumRef::from_ptr((*self.0).p))
+                Some(BigNumRef::from_ptr(p as *mut _))
             }
         }
     }
 
     pub fn q<'a>(&'a self) -> Option<BigNumRef<'a>> {
         unsafe {
-            let q = (*self.0).q;
+            let q = compat::pqg(self.0)[1];
             if q.is_null() {
                 None
             } else {
-                Some(BigNumRef::from_ptr((*self.0).q))
+                Some(BigNumRef::from_ptr(q as *mut _))
             }
         }
     }
 
     pub fn g<'a>(&'a self) -> Option<BigNumRef<'a>> {
         unsafe {
-            let g = (*self.0).g;
+            let g = compat::pqg(self.0)[2];
             if g.is_null() {
                 None
             } else {
-                Some(BigNumRef::from_ptr((*self.0).g))
+                Some(BigNumRef::from_ptr(g as *mut _))
             }
         }
     }
 
     pub fn has_public_key(&self) -> bool {
-        unsafe { !(*self.0).pub_key.is_null() }
+        unsafe { !compat::keys(self.0)[0].is_null() }
     }
 
     pub fn has_private_key(&self) -> bool {
-        unsafe { !(*self.0).priv_key.is_null() }
+        unsafe { !compat::keys(self.0)[1].is_null() }
+    }
+}
+
+#[cfg(ossl110)]
+mod compat {
+    use std::ptr;
+    use ffi::{self, BIGNUM, DSA};
+
+    pub unsafe fn pqg(d: *const DSA) -> [*const BIGNUM; 3] {
+        let (mut p, mut q, mut g) = (ptr::null(), ptr::null(), ptr::null());
+        ffi::DSA_get0_pqg(d, &mut p, &mut q, &mut g);
+        [p, q, g]
+    }
+
+    pub unsafe fn keys(d: *const DSA) -> [*const BIGNUM; 2] {
+        let (mut pub_key, mut priv_key) = (ptr::null(), ptr::null());
+        ffi::DSA_get0_key(d, &mut pub_key, &mut priv_key);
+        [pub_key, priv_key]
+    }
+}
+
+#[cfg(ossl10x)]
+mod compat {
+    use ffi::{BIGNUM, DSA};
+
+    pub unsafe fn pqg(d: *const DSA) -> [*const BIGNUM; 3] {
+        [(*d).p, (*d).q, (*d).g]
+    }
+
+    pub unsafe fn keys(d: *const DSA) -> [*const BIGNUM; 2] {
+        [(*d).pub_key, (*d).priv_key]
     }
 }