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, 9 insertions, 13 deletions

diff --git a/openssl/src/crypto/hash.rs b/openssl/src/crypto/hash.rs
index 207a55f5..d87c43c5 100644
--- a/openssl/src/crypto/hash.rs
+++ b/openssl/src/crypto/hash.rs
@@ -1,8 +1,6 @@
-use libc::c_uint;
 use std::io::prelude::*;
 use std::io;
 use std::ptr;
-use std::cmp;
 use ffi;
 
 use HashTypeInternals;
@@ -102,7 +100,7 @@ impl Hasher {
     pub fn new(ty: Type) -> Result<Hasher, ErrorStack> {
         ffi::init();
 
-        let ctx = unsafe { try_ssl_null!(ffi::EVP_MD_CTX_create()) };
+        let ctx = unsafe { try_ssl_null!(ffi::EVP_MD_CTX_new()) };
         let md = ty.evp_md();
 
         let mut h = Hasher {
@@ -123,22 +121,20 @@ impl Hasher {
             }
             Finalized => (),
         }
-        unsafe { try_ssl!(ffi::EVP_DigestInit_ex(self.ctx, self.md, 0 as *const _)); }
+        unsafe { try_ssl!(ffi::EVP_DigestInit_ex(self.ctx, self.md, 0 as *mut _)); }
         self.state = Reset;
         Ok(())
     }
 
     /// Feeds data into the hasher.
-    pub fn update(&mut self, mut data: &[u8]) -> Result<(), ErrorStack> {
+    pub fn update(&mut self, data: &[u8]) -> Result<(), ErrorStack> {
         if self.state == Finalized {
             try!(self.init());
         }
-        while !data.is_empty() {
-            let len = cmp::min(data.len(), c_uint::max_value() as usize);
-            unsafe {
-                try_ssl!(ffi::EVP_DigestUpdate(self.ctx, data.as_ptr(), len as c_uint));
-            }
-            data = &data[len..];
+        unsafe {
+            try_ssl!(ffi::EVP_DigestUpdate(self.ctx,
+                                           data.as_ptr() as *mut _,
+                                           data.len()));
         }
         self.state = Updated;
         Ok(())
@@ -176,7 +172,7 @@ impl Write for Hasher {
 impl Clone for Hasher {
     fn clone(&self) -> Hasher {
         let ctx = unsafe {
-            let ctx = ffi::EVP_MD_CTX_create();
+            let ctx = ffi::EVP_MD_CTX_new();
             assert!(!ctx.is_null());
             let r = ffi::EVP_MD_CTX_copy_ex(ctx, self.ctx);
             assert_eq!(r, 1);
@@ -197,7 +193,7 @@ impl Drop for Hasher {
             if self.state != Finalized {
                 drop(self.finish());
             }
-            ffi::EVP_MD_CTX_destroy(self.ctx);
+            ffi::EVP_MD_CTX_free(self.ctx);
         }
     }
 }