Rustfmt

1 files changed, 595 insertions, 212 deletions

diff --git a/openssl-sys/src/lib.rs b/openssl-sys/src/lib.rs
index 455195d2..8f5003a3 100644
--- a/openssl-sys/src/lib.rs
+++ b/openssl-sys/src/lib.rs
@@ -64,10 +64,26 @@ pub enum BN_BLINDING {}
 pub enum DSA_METHOD {}
 pub enum EVP_PKEY_ASN1_METHOD {}
 
-pub type bio_info_cb = Option<unsafe extern fn(*mut BIO, c_int, *const c_char, c_int, c_long, c_long)>;
-pub type GEN_SESSION_CB = Option<unsafe extern fn(*const SSL, *mut c_uchar, *mut c_uint) -> c_int>;
-pub type tls_session_ticket_ext_cb_fn = Option<unsafe extern fn(*mut SSL, *const c_uchar, c_int, *mut c_void) -> c_int>;
-pub type tls_session_secret_cb_fn = Option<unsafe extern fn(*mut SSL, *mut c_void, *mut c_int, *mut stack_st_SSL_CIPHER, *mut *mut SSL_CIPHER, *mut c_void) -> c_int>;
+pub type bio_info_cb = Option<unsafe extern "C" fn(*mut BIO,
+                                                   c_int,
+                                                   *const c_char,
+                                                   c_int,
+                                                   c_long,
+                                                   c_long)>;
+pub type GEN_SESSION_CB = Option<unsafe extern "C" fn(*const SSL, *mut c_uchar, *mut c_uint)
+                                                      -> c_int>;
+pub type tls_session_ticket_ext_cb_fn = Option<unsafe extern "C" fn(*mut SSL,
+                                                                    *const c_uchar,
+                                                                    c_int,
+                                                                    *mut c_void)
+                                                                    -> c_int>;
+pub type tls_session_secret_cb_fn = Option<unsafe extern "C" fn(*mut SSL,
+                                                                *mut c_void,
+                                                                *mut c_int,
+                                                                *mut stack_st_SSL_CIPHER,
+                                                                *mut *mut SSL_CIPHER,
+                                                                *mut c_void)
+                                                                -> c_int>;
 
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -108,19 +124,31 @@ pub type BN_ULONG = libc::c_ulonglong;
 #[cfg(target_pointer_width = "32")]
 pub type BN_ULONG = c_uint;
 
-pub type CRYPTO_EX_new = unsafe extern fn(parent: *mut c_void, ptr: *mut c_void,
-                                          ad: *const CRYPTO_EX_DATA, idx: c_int,
-                                          argl: c_long, argp: *const c_void) -> c_int;
-pub type CRYPTO_EX_dup = unsafe extern fn(to: *mut CRYPTO_EX_DATA,
-                                          from: *mut CRYPTO_EX_DATA, from_d: *mut c_void,
-                                          idx: c_int, argl: c_long, argp: *mut c_void)
-                                          -> c_int;
-pub type CRYPTO_EX_free = unsafe extern fn(parent: *mut c_void, ptr: *mut c_void,
-                                           ad: *mut CRYPTO_EX_DATA, idx: c_int,
-                                           argl: c_long, argp: *mut c_void);
-pub type PasswordCallback = unsafe extern fn(buf: *mut c_char, size: c_int,
-                                             rwflag: c_int, user_data: *mut c_void)
-                                             -> c_int;
+pub type CRYPTO_EX_new = unsafe extern "C" fn(parent: *mut c_void,
+                                              ptr: *mut c_void,
+                                              ad: *const CRYPTO_EX_DATA,
+                                              idx: c_int,
+                                              argl: c_long,
+                                              argp: *const c_void)
+                                              -> c_int;
+pub type CRYPTO_EX_dup = unsafe extern "C" fn(to: *mut CRYPTO_EX_DATA,
+                                              from: *mut CRYPTO_EX_DATA,
+                                              from_d: *mut c_void,
+                                              idx: c_int,
+                                              argl: c_long,
+                                              argp: *mut c_void)
+                                              -> c_int;
+pub type CRYPTO_EX_free = unsafe extern "C" fn(parent: *mut c_void,
+                                               ptr: *mut c_void,
+                                               ad: *mut CRYPTO_EX_DATA,
+                                               idx: c_int,
+                                               argl: c_long,
+                                               argp: *mut c_void);
+pub type PasswordCallback = unsafe extern "C" fn(buf: *mut c_char,
+                                                 size: c_int,
+                                                 rwflag: c_int,
+                                                 user_data: *mut c_void)
+                                                 -> c_int;
 
 pub const AES_ENCRYPT: c_int = 1;
 pub const AES_DECRYPT: c_int = 0;
@@ -166,8 +194,8 @@ pub const EVP_CTRL_GCM_SET_IVLEN: c_int = 0x9;
 pub const EVP_CTRL_GCM_GET_TAG: c_int = 0x10;
 pub const EVP_CTRL_GCM_SET_TAG: c_int = 0x11;
 
-pub const MBSTRING_ASC:  c_int = MBSTRING_FLAG | 1;
-pub const MBSTRING_BMP:  c_int = MBSTRING_FLAG | 2;
+pub const MBSTRING_ASC: c_int = MBSTRING_FLAG | 1;
+pub const MBSTRING_BMP: c_int = MBSTRING_FLAG | 2;
 pub const MBSTRING_FLAG: c_int = 0x1000;
 pub const MBSTRING_UNIV: c_int = MBSTRING_FLAG | 4;
 pub const MBSTRING_UTF8: c_int = MBSTRING_FLAG;
@@ -1137,7 +1165,7 @@ pub const SSL_CTRL_SET_TMP_ECDH: c_int = 4;
 pub const SSL_CTRL_EXTRA_CHAIN_CERT: c_int = 14;
 pub const SSL_CTRL_MODE: c_int = 33;
 pub const SSL_CTRL_SET_READ_AHEAD: c_int = 41;
-pub const SSL_CTRL_SET_TLSEXT_SERVERNAME_CB:  c_int = 53;
+pub const SSL_CTRL_SET_TLSEXT_SERVERNAME_CB: c_int = 53;
 pub const SSL_CTRL_SET_TLSEXT_SERVERNAME_ARG: c_int = 54;
 pub const SSL_CTRL_SET_TLSEXT_HOSTNAME: c_int = 55;
 pub const SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB: c_int = 63;
@@ -1175,35 +1203,35 @@ pub const SSL_VERIFY_PEER: c_int = 1;
 pub const SSL_VERIFY_FAIL_IF_NO_PEER_CERT: c_int = 2;
 
 #[cfg(not(ossl101))]
-pub const SSL_OP_TLSEXT_PADDING: c_ulong =                          0x00000010;
-pub const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: c_ulong =             0x00000800;
+pub const SSL_OP_TLSEXT_PADDING: c_ulong = 0x00000010;
+pub const SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS: c_ulong = 0x00000800;
 #[cfg(not(libressl))]
-pub const SSL_OP_ALL: c_ulong =                                     0x80000BFF;
-pub const SSL_OP_NO_QUERY_MTU: c_ulong =                            0x00001000;
-pub const SSL_OP_COOKIE_EXCHANGE: c_ulong =                         0x00002000;
-pub const SSL_OP_NO_TICKET: c_ulong =                               0x00004000;
+pub const SSL_OP_ALL: c_ulong = 0x80000BFF;
+pub const SSL_OP_NO_QUERY_MTU: c_ulong = 0x00001000;
+pub const SSL_OP_COOKIE_EXCHANGE: c_ulong = 0x00002000;
+pub const SSL_OP_NO_TICKET: c_ulong = 0x00004000;
 #[cfg(not(libressl))]
-pub const SSL_OP_CISCO_ANYCONNECT: c_ulong =                        0x00008000;
-pub const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: c_ulong =  0x00010000;
+pub const SSL_OP_CISCO_ANYCONNECT: c_ulong = 0x00008000;
+pub const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: c_ulong = 0x00010000;
 #[cfg(not(libressl))]
-pub const SSL_OP_NO_COMPRESSION: c_ulong =                          0x00020000;
+pub const SSL_OP_NO_COMPRESSION: c_ulong = 0x00020000;
 #[cfg(not(libressl))]
-pub const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: c_ulong =       0x00040000;
-pub const SSL_OP_CIPHER_SERVER_PREFERENCE: c_ulong =                0x00400000;
-pub const SSL_OP_TLS_ROLLBACK_BUG: c_ulong =                        0x00800000;
+pub const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: c_ulong = 0x00040000;
+pub const SSL_OP_CIPHER_SERVER_PREFERENCE: c_ulong = 0x00400000;
+pub const SSL_OP_TLS_ROLLBACK_BUG: c_ulong = 0x00800000;
 #[cfg(not(libressl))]
-pub const SSL_OP_NO_SSLv3: c_ulong =                                0x02000000;
-pub const SSL_OP_NO_TLSv1: c_ulong =                                0x04000000;
-pub const SSL_OP_NO_TLSv1_2: c_ulong =                              0x08000000;
-pub const SSL_OP_NO_TLSv1_1: c_ulong =                              0x10000000;
+pub const SSL_OP_NO_SSLv3: c_ulong = 0x02000000;
+pub const SSL_OP_NO_TLSv1: c_ulong = 0x04000000;
+pub const SSL_OP_NO_TLSv1_2: c_ulong = 0x08000000;
+pub const SSL_OP_NO_TLSv1_1: c_ulong = 0x10000000;
 
 #[cfg(not(any(ossl101, libressl)))]
-pub const SSL_OP_NO_DTLSv1: c_ulong =                               0x04000000;
+pub const SSL_OP_NO_DTLSv1: c_ulong = 0x04000000;
 #[cfg(not(any(ossl101, libressl)))]
-pub const SSL_OP_NO_DTLSv1_2: c_ulong =                             0x08000000;
+pub const SSL_OP_NO_DTLSv1_2: c_ulong = 0x08000000;
 #[cfg(not(any(ossl101, libressl)))]
-pub const SSL_OP_NO_SSL_MASK: c_ulong = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 |
-    SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2;
+pub const SSL_OP_NO_SSL_MASK: c_ulong =
+    SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 | SSL_OP_NO_TLSv1_1 | SSL_OP_NO_TLSv1_2;
 
 pub const TLSEXT_NAMETYPE_host_name: c_int = 0;
 
@@ -1219,7 +1247,7 @@ pub const OPENSSL_NPN_NEGOTIATED: c_int = 1;
 pub const OPENSSL_NPN_NO_OVERLAP: c_int = 2;
 
 pub const V_ASN1_GENERALIZEDTIME: c_int = 24;
-pub const V_ASN1_UTCTIME:         c_int = 23;
+pub const V_ASN1_UTCTIME: c_int = 23;
 
 pub const X509_FILETYPE_ASN1: c_int = 2;
 pub const X509_FILETYPE_DEFAULT: c_int = 3;
@@ -1319,11 +1347,21 @@ pub unsafe fn BIO_set_retry_write(b: *mut BIO) {
 
 // EVP_PKEY_CTX_ctrl macros
 pub unsafe fn EVP_PKEY_CTX_set_rsa_padding(ctx: *mut EVP_PKEY_CTX, pad: c_int) -> c_int {
-    EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, EVP_PKEY_CTRL_RSA_PADDING, pad, ptr::null_mut())
+    EVP_PKEY_CTX_ctrl(ctx,
+                      EVP_PKEY_RSA,
+                      -1,
+                      EVP_PKEY_CTRL_RSA_PADDING,
+                      pad,
+                      ptr::null_mut())
 }
 
 pub unsafe fn EVP_PKEY_CTX_get_rsa_padding(ctx: *mut EVP_PKEY_CTX, ppad: *mut c_int) -> c_int {
-    EVP_PKEY_CTX_ctrl(ctx, EVP_PKEY_RSA, -1, EVP_PKEY_CTRL_GET_RSA_PADDING, 0, ppad as *mut c_void)
+    EVP_PKEY_CTX_ctrl(ctx,
+                      EVP_PKEY_RSA,
+                      -1,
+                      EVP_PKEY_CTRL_GET_RSA_PADDING,
+                      0,
+                      ppad as *mut c_void)
 }
 
 pub unsafe fn SSL_CTX_set_mode(ctx: *mut SSL_CTX, op: c_long) -> c_long {
@@ -1360,23 +1398,29 @@ pub unsafe fn SSL_CTX_set0_verify_cert_store(ctx: *mut SSL_CTX, st: *mut X509_ST
 }
 
 pub unsafe fn SSL_CTX_set_tlsext_servername_callback(ctx: *mut SSL_CTX,
-                                                     cb: Option<extern fn()>)
+                                                     cb: Option<extern "C" fn()>)
                                                      -> c_long {
     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TLSEXT_SERVERNAME_CB, cb)
 }
 
 pub unsafe fn SSL_set_tlsext_host_name(s: *mut SSL, name: *mut c_char) -> c_long {
-    SSL_ctrl(s, SSL_CTRL_SET_TLSEXT_HOSTNAME,
+    SSL_ctrl(s,
+             SSL_CTRL_SET_TLSEXT_HOSTNAME,
              TLSEXT_NAMETYPE_host_name as c_long,
              name as *mut c_void)
 }
 
 pub unsafe fn SSL_set_tlsext_status_type(s: *mut SSL, type_: c_int) -> c_long {
-    SSL_ctrl(s, SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE, type_ as c_long, ptr::null_mut())
+    SSL_ctrl(s,
+             SSL_CTRL_SET_TLSEXT_STATUS_REQ_TYPE,
+             type_ as c_long,
+             ptr::null_mut())
 }
 
 pub unsafe fn SSL_CTX_set_tlsext_status_cb(ctx: *mut SSL_CTX,
-                                           cb: Option<unsafe extern fn(*mut SSL, *mut c_void) -> c_int>)
+                                           cb: Option<unsafe extern "C" fn(*mut SSL,
+                                                                           *mut c_void)
+                                                                           -> c_int>)
                                            -> c_long {
     SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB, mem::transmute(cb))
 }
@@ -1385,16 +1429,27 @@ pub unsafe fn SSL_CTX_set_tlsext_status_arg(ctx: *mut SSL_CTX, arg: *mut c_void)
     SSL_CTX_ctrl(ctx, SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB_ARG, 0, arg)
 }
 
-pub unsafe fn SSL_CTX_get_extra_chain_certs(ctx: *mut SSL_CTX, chain: *mut *mut stack_st_X509) -> c_long {
+pub unsafe fn SSL_CTX_get_extra_chain_certs(ctx: *mut SSL_CTX,
+                                            chain: *mut *mut stack_st_X509)
+                                            -> c_long {
     SSL_CTX_ctrl(ctx, SSL_CTRL_GET_EXTRA_CHAIN_CERTS, 0, chain as *mut c_void)
 }
 
 pub unsafe fn SSL_get_tlsext_status_ocsp_resp(ssl: *mut SSL, resp: *mut *mut c_uchar) -> c_long {
-    SSL_ctrl(ssl, SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP, 0, resp as *mut c_void)
+    SSL_ctrl(ssl,
+             SSL_CTRL_GET_TLSEXT_STATUS_REQ_OCSP_RESP,
+             0,
+             resp as *mut c_void)
 }
 
-pub unsafe fn SSL_set_tlsext_status_ocsp_resp(ssl: *mut SSL, resp: *mut c_uchar, len: c_long) -> c_long {
-    SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP, len, resp as *mut c_void)
+pub unsafe fn SSL_set_tlsext_status_ocsp_resp(ssl: *mut SSL,
+                                              resp: *mut c_uchar,
+                                              len: c_long)
+                                              -> c_long {
+    SSL_ctrl(ssl,
+             SSL_CTRL_SET_TLSEXT_STATUS_REQ_OCSP_RESP,
+             len,
+             resp as *mut c_void)
 }
 
 pub fn ERR_GET_LIB(l: c_ulong) -> c_int {
@@ -1409,10 +1464,15 @@ pub fn ERR_GET_REASON(l: c_ulong) -> c_int {
     (l & 0xFFF) as c_int
 }
 
-extern {
+extern "C" {
     pub fn AES_set_encrypt_key(userKey: *const c_uchar, bits: c_int, key: *mut AES_KEY) -> c_int;
     pub fn AES_set_decrypt_key(userKey: *const c_uchar, bits: c_int, key: *mut AES_KEY) -> c_int;
-    pub fn AES_ige_encrypt(in_: *const c_uchar, out: *mut c_uchar, length: size_t, key: *const AES_KEY, ivec: *mut c_uchar, enc: c_int);
+    pub fn AES_ige_encrypt(in_: *const c_uchar,
+                           out: *mut c_uchar,
+                           length: size_t,
+                           key: *const AES_KEY,
+                           ivec: *mut c_uchar,
+                           enc: c_int);
 
     pub fn ASN1_INTEGER_get(dest: *const ASN1_INTEGER) -> c_long;
     pub fn ASN1_INTEGER_set(dest: *mut ASN1_INTEGER, value: c_long) -> c_int;
@@ -1449,17 +1509,54 @@ extern {
     pub fn BN_set_negative(bn: *mut BIGNUM, n: c_int);
     pub fn BN_set_word(bn: *mut BIGNUM, n: BN_ULONG) -> c_int;
     pub fn BN_add(r: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM) -> c_int;
-    pub fn BN_div(dv: *mut BIGNUM, rem: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn BN_div(dv: *mut BIGNUM,
+                  rem: *mut BIGNUM,
+                  a: *const BIGNUM,
+                  b: *const BIGNUM,
+                  ctx: *mut BN_CTX)
+                  -> c_int;
     pub fn BN_exp(r: *mut BIGNUM, a: *const BIGNUM, p: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
     pub fn BN_gcd(r: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
-    pub fn BN_mod_add(r: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
-    pub fn BN_mod_exp(r: *mut BIGNUM, a: *const BIGNUM, p: *const BIGNUM, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
-    pub fn BN_mod_inverse(r: *mut BIGNUM, a: *const BIGNUM, n: *const BIGNUM, ctx: *mut BN_CTX) -> *mut BIGNUM;
-    pub fn BN_mod_mul(r: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
-    pub fn BN_mod_sqr(r: *mut BIGNUM, a: *const BIGNUM, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
-    pub fn BN_mod_sub(r: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn BN_mod_add(r: *mut BIGNUM,
+                      a: *const BIGNUM,
+                      b: *const BIGNUM,
+                      m: *const BIGNUM,
+                      ctx: *mut BN_CTX)
+                      -> c_int;
+    pub fn BN_mod_exp(r: *mut BIGNUM,
+                      a: *const BIGNUM,
+                      p: *const BIGNUM,
+                      m: *const BIGNUM,
+                      ctx: *mut BN_CTX)
+                      -> c_int;
+    pub fn BN_mod_inverse(r: *mut BIGNUM,
+                          a: *const BIGNUM,
+                          n: *const BIGNUM,
+                          ctx: *mut BN_CTX)
+                          -> *mut BIGNUM;
+    pub fn BN_mod_mul(r: *mut BIGNUM,
+                      a: *const BIGNUM,
+                      b: *const BIGNUM,
+                      m: *const BIGNUM,
+                      ctx: *mut BN_CTX)
+                      -> c_int;
+    pub fn BN_mod_sqr(r: *mut BIGNUM,
+                      a: *const BIGNUM,
+                      m: *const BIGNUM,
+                      ctx: *mut BN_CTX)
+                      -> c_int;
+    pub fn BN_mod_sub(r: *mut BIGNUM,
+                      a: *const BIGNUM,
+                      b: *const BIGNUM,
+                      m: *const BIGNUM,
+                      ctx: *mut BN_CTX)
+                      -> c_int;
     pub fn BN_mul(r: *mut BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
-    pub fn BN_nnmod(rem: *mut BIGNUM, a: *const BIGNUM, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn BN_nnmod(rem: *mut BIGNUM,
+                    a: *const BIGNUM,
+                    m: *const BIGNUM,
+                    ctx: *mut BN_CTX)
+                    -> c_int;
     pub fn BN_add_word(r: *mut BIGNUM, w: BN_ULONG) -> c_int;
     pub fn BN_sub_word(r: *mut BIGNUM, w: BN_ULONG) -> c_int;
     pub fn BN_mul_word(r: *mut BIGNUM, w: BN_ULONG) -> c_int;
@@ -1477,9 +1574,24 @@ extern {
     pub fn BN_rshift1(r: *mut BIGNUM, a: *const BIGNUM) -> c_int;
     pub fn BN_cmp(a: *const BIGNUM, b: *const BIGNUM) -> c_int;
     pub fn BN_ucmp(a: *const BIGNUM, b: *const BIGNUM) -> c_int;
-    pub fn BN_generate_prime_ex(r: *mut BIGNUM, bits: c_int, safe: c_int, add: *const BIGNUM, rem: *const BIGNUM, cb: *mut BN_GENCB) -> c_int;
-    pub fn BN_is_prime_ex(p: *const BIGNUM, checks: c_int, ctx: *mut BN_CTX, cb: *mut BN_GENCB) -> c_int;
-    pub fn BN_is_prime_fasttest_ex(p: *const BIGNUM, checks: c_int, ctx: *mut BN_CTX, do_trial_division: c_int, cb: *mut BN_GENCB) -> c_int;
+    pub fn BN_generate_prime_ex(r: *mut BIGNUM,
+                                bits: c_int,
+                                safe: c_int,
+                                add: *const BIGNUM,
+                                rem: *const BIGNUM,
+                                cb: *mut BN_GENCB)
+                                -> c_int;
+    pub fn BN_is_prime_ex(p: *const BIGNUM,
+                          checks: c_int,
+                          ctx: *mut BN_CTX,
+                          cb: *mut BN_GENCB)
+                          -> c_int;
+    pub fn BN_is_prime_fasttest_ex(p: *const BIGNUM,
+                                   checks: c_int,
+                                   ctx: *mut BN_CTX,
+                                   do_trial_division: c_int,
+                                   cb: *mut BN_GENCB)
+                                   -> c_int;
     pub fn BN_rand(r: *mut BIGNUM, bits: c_int, top: c_int, bottom: c_int) -> c_int;
     pub fn BN_pseudo_rand(r: *mut BIGNUM, bits: c_int, top: c_int, bottom: c_int) -> c_int;
     pub fn BN_rand_range(r: *mut BIGNUM, range: *const BIGNUM) -> c_int;
@@ -1496,8 +1608,7 @@ extern {
     pub fn NCONF_new(meth: *mut CONF_METHOD) -> *mut CONF;
     pub fn NCONF_free(conf: *mut CONF);
 
-    pub fn CRYPTO_memcmp(a: *const c_void, b: *const c_void,
-                         len: size_t) -> c_int;
+    pub fn CRYPTO_memcmp(a: *const c_void, b: *const c_void, len: size_t) -> c_int;
 
     pub fn DH_new() -> *mut DH;
     pub fn DH_free(dh: *mut DH);
@@ -1525,31 +1636,82 @@ extern {
     pub fn EC_GF2m_simple_method() -> *const EC_METHOD;
 
     pub fn EC_GROUP_new(meth: *const EC_METHOD) -> *mut EC_GROUP;
-    pub fn EC_GROUP_new_curve_GFp(p: *const BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> *mut EC_GROUP;
+    pub fn EC_GROUP_new_curve_GFp(p: *const BIGNUM,
+                                  a: *const BIGNUM,
+                                  b: *const BIGNUM,
+                                  ctx: *mut BN_CTX)
+                                  -> *mut EC_GROUP;
     #[cfg(not(osslconf = "OPENSSL_NO_EC2M"))]
-    pub fn EC_GROUP_new_curve_GF2m(p: *const BIGNUM, a: *const BIGNUM, b: *const BIGNUM, ctx: *mut BN_CTX) -> *mut EC_GROUP;
+    pub fn EC_GROUP_new_curve_GF2m(p: *const BIGNUM,
+                                   a: *const BIGNUM,
+                                   b: *const BIGNUM,
+                                   ctx: *mut BN_CTX)
+                                   -> *mut EC_GROUP;
     pub fn EC_GROUP_new_by_curve_name(nid: c_int) -> *mut EC_GROUP;
-    pub fn EC_GROUP_get_curve_GFp(group: *const EC_GROUP, p: *mut BIGNUM, a: *mut BIGNUM, b: *mut BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_GROUP_get_curve_GFp(group: *const EC_GROUP,
+                                  p: *mut BIGNUM,
+                                  a: *mut BIGNUM,
+                                  b: *mut BIGNUM,
+                                  ctx: *mut BN_CTX)
+                                  -> c_int;
     #[cfg(not(osslconf = "OPENSSL_NO_EC2M"))]
-    pub fn EC_GROUP_get_curve_GF2m(group: *const EC_GROUP, p: *mut BIGNUM, a: *mut BIGNUM, b: *mut BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_GROUP_get_curve_GF2m(group: *const EC_GROUP,
+                                   p: *mut BIGNUM,
+                                   a: *mut BIGNUM,
+                                   b: *mut BIGNUM,
+                                   ctx: *mut BN_CTX)
+                                   -> c_int;
     pub fn EC_GROUP_get_degree(group: *const EC_GROUP) -> c_int;
-    pub fn EC_GROUP_get_order(group: *const EC_GROUP, order: *mut BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_GROUP_get_order(group: *const EC_GROUP,
+                              order: *mut BIGNUM,
+                              ctx: *mut BN_CTX)
+                              -> c_int;
     pub fn EC_GROUP_set_asn1_flag(key: *mut EC_GROUP, flag: c_int);
 
     pub fn EC_GROUP_free(group: *mut EC_GROUP);
 
     pub fn EC_POINT_new(group: *const EC_GROUP) -> *mut EC_POINT;
-    pub fn EC_POINT_add(group: *const EC_GROUP, r: *mut EC_POINT, a: *const EC_POINT, b: *const EC_POINT, ctx: *mut BN_CTX) -> c_int;
-    pub fn EC_POINT_mul(group: *const EC_GROUP, r: *mut EC_POINT, n: *const BIGNUM, q: *const EC_POINT, m: *const BIGNUM, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_POINT_add(group: *const EC_GROUP,
+                        r: *mut EC_POINT,
+                        a: *const EC_POINT,
+                        b: *const EC_POINT,
+                        ctx: *mut BN_CTX)
+                        -> c_int;
+    pub fn EC_POINT_mul(group: *const EC_GROUP,
+                        r: *mut EC_POINT,
+                        n: *const BIGNUM,
+                        q: *const EC_POINT,
+                        m: *const BIGNUM,
+                        ctx: *mut BN_CTX)
+                        -> c_int;
     pub fn EC_POINT_invert(group: *const EC_GROUP, r: *mut EC_POINT, ctx: *mut BN_CTX) -> c_int;
-    pub fn EC_POINT_point2oct(group: *const EC_GROUP, p: *const EC_POINT, form: point_conversion_form_t, buf: *mut c_uchar, len: size_t, ctx: *mut BN_CTX) -> size_t;
-    pub fn EC_POINT_oct2point(group: *const EC_GROUP, p: *mut EC_POINT, buf: *const c_uchar, len: size_t, ctx: *mut BN_CTX) -> c_int;
-    pub fn EC_POINT_cmp(group: *const EC_GROUP, a: *const EC_POINT, b: *const EC_POINT, ctx: *mut BN_CTX) -> c_int;
+    pub fn EC_POINT_point2oct(group: *const EC_GROUP,
+                              p: *const EC_POINT,
+                              form: point_conversion_form_t,
+                              buf: *mut c_uchar,
+                              len: size_t,
+                              ctx: *mut BN_CTX)
+                              -> size_t;
+    pub fn EC_POINT_oct2point(group: *const EC_GROUP,
+                              p: *mut EC_POINT,
+                              buf: *const c_uchar,
+                              len: size_t,
+                              ctx: *mut BN_CTX)
+                              -> c_int;
+    pub fn EC_POINT_cmp(group: *const EC_GROUP,
+                        a: *const EC_POINT,
+                        b: *const EC_POINT,
+                        ctx: *mut BN_CTX)
+                        -> c_int;
     pub fn EC_POINT_free(point: *mut EC_POINT);
 
     pub fn ERR_peek_last_error() -> c_ulong;
     pub fn ERR_get_error() -> c_ulong;
-    pub fn ERR_get_error_line_data(file: *mut *const c_char, line: *mut c_int, data: *mut *const c_char, flags: *mut c_int) -> c_ulong;
+    pub fn ERR_get_error_line_data(file: *mut *const c_char,
+                                   line: *mut c_int,
+                                   data: *mut *const c_char,
+                                   flags: *mut c_int)
+                                   -> c_ulong;
     pub fn ERR_lib_error_string(err: c_ulong) -> *const c_char;
     pub fn ERR_func_error_string(err: c_ulong) -> *const c_char;
     pub fn ERR_reason_error_string(err: c_ulong) -> *const c_char;
@@ -1588,30 +1750,52 @@ extern {
     pub fn EVP_des_cbc() -> *const EVP_CIPHER;
     pub fn EVP_des_ecb() -> *const EVP_CIPHER;
 
-    pub fn EVP_BytesToKey(typ: *const EVP_CIPHER, md: *const EVP_MD,
-                          salt: *const u8, data: *const u8, datalen: c_int,
-                          count: c_int, key: *mut u8, iv: *mut u8) -> c_int;
+    pub fn EVP_BytesToKey(typ: *const EVP_CIPHER,
+                          md: *const EVP_MD,
+                          salt: *const u8,
+                          data: *const u8,
+                          datalen: c_int,
+                          count: c_int,
+                          key: *mut u8,
+                          iv: *mut u8)
+                          -> c_int;
 
     pub fn EVP_CIPHER_CTX_new() -> *mut EVP_CIPHER_CTX;
     pub fn EVP_CIPHER_CTX_set_padding(ctx: *mut EVP_CIPHER_CTX, padding: c_int) -> c_int;
     pub fn EVP_CIPHER_CTX_set_key_length(ctx: *mut EVP_CIPHER_CTX, keylen: c_int) -> c_int;
-    pub fn EVP_CIPHER_CTX_ctrl(ctx: *mut EVP_CIPHER_CTX, type_: c_int, arg: c_int, ptr: *mut c_void) -> c_int;
+    pub fn EVP_CIPHER_CTX_ctrl(ctx: *mut EVP_CIPHER_CTX,
+                               type_: c_int,
+                               arg: c_int,
+                               ptr: *mut c_void)
+                               -> c_int;
     pub fn EVP_CIPHER_CTX_free(ctx: *mut EVP_CIPHER_CTX);
 
-    pub fn EVP_CipherInit(ctx: *mut EVP_CIPHER_CTX, evp: *const EVP_CIPHER,
-                          key: *const u8, iv: *const u8, mode: c_int) -> c_int;
+    pub fn EVP_CipherInit(ctx: *mut EVP_CIPHER_CTX,
+                          evp: *const EVP_CIPHER,
+                          key: *const u8,
+                          iv: *const u8,
+                          mode: c_int)
+                          -> c_int;
     pub fn EVP_CipherInit_ex(ctx: *mut EVP_CIPHER_CTX,
                              type_: *const EVP_CIPHER,
                              impl_: *mut ENGINE,
                              key: *const c_uchar,
                              iv: *const c_uchar,
-                             enc: c_int) -> c_int;
-    pub fn EVP_CipherUpdate(ctx: *mut EVP_CIPHER_CTX, outbuf: *mut u8,
-                            outlen: *mut c_int, inbuf: *const u8, inlen: c_int) -> c_int;
+                             enc: c_int)
+                             -> c_int;
+    pub fn EVP_CipherUpdate(ctx: *mut EVP_CIPHER_CTX,
+                            outbuf: *mut u8,
+                            outlen: *mut c_int,
+                            inbuf: *const u8,
+                            inlen: c_int)
+                            -> c_int;
     pub fn EVP_CipherFinal(ctx: *mut EVP_CIPHER_CTX, res: *mut u8, len: *mut c_int) -> c_int;
 
     pub fn EVP_DigestInit(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD) -> c_int;
-    pub fn EVP_DigestInit_ex(ctx: *mut EVP_MD_CTX, typ: *const EVP_MD, imple: *mut ENGINE) -> c_int;
+    pub fn EVP_DigestInit_ex(ctx: *mut EVP_MD_CTX,
+                             typ: *const EVP_MD,
+                             imple: *mut ENGINE)
+                             -> c_int;
     pub fn EVP_DigestUpdate(ctx: *mut EVP_MD_CTX, data: *const c_void, n: size_t) -> c_int;
     pub fn EVP_DigestFinal(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32) -> c_int;
     pub fn EVP_DigestFinal_ex(ctx: *mut EVP_MD_CTX, res: *mut u8, n: *mut u32) -> c_int;
@@ -1620,23 +1804,28 @@ extern {
                               pctx: *mut *mut EVP_PKEY_CTX,
                               type_: *const EVP_MD,
                               e: *mut ENGINE,
-                              pkey: *mut EVP_PKEY) -> c_int;
+                              pkey: *mut EVP_PKEY)
+                              -> c_int;
     pub fn EVP_DigestSignFinal(ctx: *mut EVP_MD_CTX,
                                sig: *mut c_uchar,
-                               siglen: *mut size_t) -> c_int;
+                               siglen: *mut size_t)
+                               -> c_int;
     pub fn EVP_DigestVerifyInit(ctx: *mut EVP_MD_CTX,
                                 pctx: *mut *mut EVP_PKEY_CTX,
                                 type_: *const EVP_MD,
                                 e: *mut ENGINE,
-                                pkey: *mut EVP_PKEY) -> c_int;
+                                pkey: *mut EVP_PKEY)
+                                -> c_int;
     #[cfg(any(ossl101, libressl))]
     pub fn EVP_DigestVerifyFinal(ctx: *mut EVP_MD_CTX,
                                  sigret: *mut c_uchar,
-                                 siglen: size_t) -> c_int;
+                                 siglen: size_t)
+                                 -> c_int;
     #[cfg(not(any(ossl101, libressl)))]
     pub fn EVP_DigestVerifyFinal(ctx: *mut EVP_MD_CTX,
                                  sigret: *const c_uchar,
-                                 siglen: size_t) -> c_int;
+                                 siglen: size_t)
+                                 -> c_int;
 
     pub fn EVP_MD_CTX_copy_ex(dst: *mut EVP_MD_CTX, src: *const EVP_MD_CTX) -> c_int;
 
@@ -1653,33 +1842,66 @@ extern {
     pub fn EVP_PKEY_new_mac_key(type_: c_int,
                                 e: *mut ENGINE,
                                 key: *const c_uchar,
-                                keylen: c_int) -> *mut EVP_PKEY;
+                                keylen: c_int)
+                                -> *mut EVP_PKEY;
     pub fn EVP_PKEY_derive_init(ctx: *mut EVP_PKEY_CTX) -> c_int;
     pub fn EVP_PKEY_derive_set_peer(ctx: *mut EVP_PKEY_CTX, peer: *mut EVP_PKEY) -> c_int;
     pub fn EVP_PKEY_derive(ctx: *mut EVP_PKEY_CTX, key: *mut c_uchar, size: *mut size_t) -> c_int;
-    pub fn d2i_PKCS8PrivateKey_bio(bp: *mut BIO, x: *mut *mut EVP_PKEY, cb: Option<PasswordCallback>, u: *mut c_void) -> *mut EVP_PKEY;
+    pub fn d2i_PKCS8PrivateKey_bio(bp: *mut BIO,
+                                   x: *mut *mut EVP_PKEY,
+                                   cb: Option<PasswordCallback>,
+                                   u: *mut c_void)
+                                   -> *mut EVP_PKEY;
 
     pub fn EVP_PKEY_CTX_new(k: *mut EVP_PKEY, e: *mut ENGINE) -> *mut EVP_PKEY_CTX;
     pub fn EVP_PKEY_CTX_free(ctx: *mut EVP_PKEY_CTX);
-    pub fn EVP_PKEY_CTX_ctrl(ctx: *mut EVP_PKEY_CTX, keytype: c_int, optype: c_int, cmd: c_int, p1: c_int, p2: *mut c_void) -> c_int;
+    pub fn EVP_PKEY_CTX_ctrl(ctx: *mut EVP_PKEY_CTX,
+                             keytype: c_int,
+                             optype: c_int,
+                             cmd: c_int,
+                             p1: c_int,
+                             p2: *mut c_void)
+                             -> c_int;
 
     pub fn HMAC_CTX_copy(dst: *mut HMAC_CTX, src: *mut HMAC_CTX) -> c_int;
 
     pub fn OBJ_obj2nid(o: *const ASN1_OBJECT) -> c_int;
-    pub fn OBJ_obj2txt(buf: *mut c_char, buf_len: c_int, a: *const ASN1_OBJECT, no_name: c_int) -> c_int;
+    pub fn OBJ_obj2txt(buf: *mut c_char,
+                       buf_len: c_int,
+                       a: *const ASN1_OBJECT,
+                       no_name: c_int)
+                       -> c_int;
 
     pub fn OCSP_BASICRESP_new() -> *mut OCSP_BASICRESP;
     pub fn OCSP_BASICRESP_free(r: *mut OCSP_BASICRESP);
-    pub fn OCSP_basic_verify(bs: *mut OCSP_BASICRESP, certs: *mut stack_st_X509, st: *mut X509_STORE, flags: c_ulong) -> c_int;
-    pub fn OCSP_resp_find_status(bs: *mut OCSP_BASICRESP, id: *mut OCSP_CERTID, status: *mut c_int, reason: *mut c_int, revtime: *mut *mut ASN1_GENERALIZEDTIME, thisupd: *mut *mut ASN1_GENERALIZEDTIME, nextupd: *mut *mut ASN1_GENERALIZEDTIME) -> c_int;
-    pub fn OCSP_check_validity(thisupd: *mut ASN1_GENERALIZEDTIME, nextupd: *mut ASN1_GENERALIZEDTIME, sec: c_long, maxsec: c_long) -> c_int;
+    pub fn OCSP_basic_verify(bs: *mut OCSP_BASICRESP,
+                             certs: *mut stack_st_X509,
+                             st: *mut X509_STORE,
+                             flags: c_ulong)
+                             -> c_int;
+    pub fn OCSP_resp_find_status(bs: *mut OCSP_BASICRESP,
+                                 id: *mut OCSP_CERTID,
+                                 status: *mut c_int,
+                                 reason: *mut c_int,
+                                 revtime: *mut *mut ASN1_GENERALIZEDTIME,
+                                 thisupd: *mut *mut ASN1_GENERALIZEDTIME,
+                                 nextupd: *mut *mut ASN1_GENERALIZEDTIME)
+                                 -> c_int;
+    pub fn OCSP_check_validity(thisupd: *mut ASN1_GENERALIZEDTIME,
+                               nextupd: *mut ASN1_GENERALIZEDTIME,
+                               sec: c_long,
+                               maxsec: c_long)
+                               -> c_int;
 
     pub fn OCSP_CERTID_free(id: *mut OCSP_CERTID);
 
     pub fn OCSP_RESPONSE_new() -> *mut OCSP_RESPONSE;
     pub fn OCSP_RESPONSE_free(r: *mut OCSP_RESPONSE);
     pub fn i2d_OCSP_RESPONSE(a: *mut OCSP_RESPONSE, pp: *mut *mut c_uchar) -> c_int;
-    pub fn d2i_OCSP_RESPONSE(a: *mut *mut OCSP_RESPONSE, pp: *mut *const c_uchar, length: c_long) -> *mut OCSP_RESPONSE;
+    pub fn d2i_OCSP_RESPONSE(a: *mut *mut OCSP_RESPONSE,
+                             pp: *mut *const c_uchar,
+                             length: c_long)
+                             -> *mut OCSP_RESPONSE;
     pub fn OCSP_response_create(status: c_int, bs: *mut OCSP_BASICRESP) -> *mut OCSP_RESPONSE;
     pub fn OCSP_response_status(resp: *mut OCSP_RESPONSE) -> c_int;
     pub fn OCSP_response_get1_basic(resp: *mut OCSP_RESPONSE) -> *mut OCSP_BASICRESP;
@@ -1687,49 +1909,98 @@ extern {
     pub fn OCSP_REQUEST_new() -> *mut OCSP_REQUEST;
     pub fn OCSP_REQUEST_free(r: *mut OCSP_REQUEST);
     pub fn i2d_OCSP_REQUEST(a: *mut OCSP_REQUEST, pp: *mut *mut c_uchar) -> c_int;
-    pub fn d2i_OCSP_REQUEST(a: *mut *mut OCSP_REQUEST, pp: *mut *const c_uchar, length: c_long) -> *mut OCSP_REQUEST;
+    pub fn d2i_OCSP_REQUEST(a: *mut *mut OCSP_REQUEST,
+                            pp: *mut *const c_uchar,
+                            length: c_long)
+                            -> *mut OCSP_REQUEST;
     pub fn OCSP_request_add0_id(r: *mut OCSP_REQUEST, id: *mut OCSP_CERTID) -> *mut OCSP_ONEREQ;
 
     pub fn OCSP_ONEREQ_free(r: *mut OCSP_ONEREQ);
 
-    pub fn PEM_read_bio_DHparams(bio: *mut BIO, out: *mut *mut DH, callback: Option<PasswordCallback>,
-                             user_data: *mut c_void) -> *mut DH;
-    pub fn PEM_read_bio_X509(bio: *mut BIO, out: *mut *mut X509, callback: Option<PasswordCallback>,
-                             user_data: *mut c_void) -> *mut X509;
-    pub fn PEM_read_bio_X509_REQ(bio: *mut BIO, out: *mut *mut X509_REQ, callback: Option<PasswordCallback>,
-                             user_data: *mut c_void) -> *mut X509_REQ;
-    pub fn PEM_read_bio_PrivateKey(bio: *mut BIO, out: *mut *mut EVP_PKEY, callback: Option<PasswordCallback>,
-                             user_data: *mut c_void) -> *mut EVP_PKEY;
-    pub fn PEM_read_bio_PUBKEY(bio: *mut BIO, out: *mut *mut EVP_PKEY, callback: Option<PasswordCallback>,
-                             user_data: *mut c_void) -> *mut EVP_PKEY;
-
-    pub fn PEM_read_bio_RSAPrivateKey(bio: *mut BIO, rsa: *mut *mut RSA, callback: Option<PasswordCallback>, user_data: *mut c_void) -> *mut RSA;
-    pub fn PEM_read_bio_RSA_PUBKEY(bio:    *mut BIO, rsa: *mut *mut RSA, callback: Option<PasswordCallback>, user_data: *mut c_void) -> *mut RSA;
+    pub fn PEM_read_bio_DHparams(bio: *mut BIO,
+                                 out: *mut *mut DH,
+                                 callback: Option<PasswordCallback>,
+                                 user_data: *mut c_void)
+                                 -> *mut DH;
+    pub fn PEM_read_bio_X509(bio: *mut BIO,
+                             out: *mut *mut X509,
+                             callback: Option<PasswordCallback>,
+                             user_data: *mut c_void)
+                             -> *mut X509;
+    pub fn PEM_read_bio_X509_REQ(bio: *mut BIO,
+                                 out: *mut *mut X509_REQ,
+                                 callback: Option<PasswordCallback>,
+                                 user_data: *mut c_void)
+                                 -> *mut X509_REQ;
+    pub fn PEM_read_bio_PrivateKey(bio: *mut BIO,
+                                   out: *mut *mut EVP_PKEY,
+                                   callback: Option<PasswordCallback>,
+                                   user_data: *mut c_void)
+                                   -> *mut EVP_PKEY;
+    pub fn PEM_read_bio_PUBKEY(bio: *mut BIO,
+                               out: *mut *mut EVP_PKEY,
+                               callback: Option<PasswordCallback>,
+                               user_data: *mut c_void)
+                               -> *mut EVP_PKEY;
+
+    pub fn PEM_read_bio_RSAPrivateKey(bio: *mut BIO,
+                                      rsa: *mut *mut RSA,
+                                      callback: Option<PasswordCallback>,
+                                      user_data: *mut c_void)
+                                      -> *mut RSA;
+    pub fn PEM_read_bio_RSA_PUBKEY(bio: *mut BIO,
+                                   rsa: *mut *mut RSA,
+                                   callback: Option<PasswordCallback>,
+                                   user_data: *mut c_void)
+                                   -> *mut RSA;
 
     pub fn PEM_write_bio_DHparams(bio: *mut BIO, x: *const DH) -> c_int;
-    pub fn PEM_write_bio_PrivateKey(bio: *mut BIO, pkey: *mut EVP_PKEY, cipher: *const EVP_CIPHER,
-                                    kstr: *mut c_uchar, klen: c_int,
+    pub fn PEM_write_bio_PrivateKey(bio: *mut BIO,
+                                    pkey: *mut EVP_PKEY,
+                                    cipher: *const EVP_CIPHER,
+                                    kstr: *mut c_uchar,
+                                    klen: c_int,
                                     callback: Option<PasswordCallback>,
-                                    user_data: *mut c_void) -> c_int;
-    pub fn PEM_write_bio_PKCS8PrivateKey(bio: *mut BIO, pkey: *mut EVP_PKEY, cipher: *const EVP_CIPHER,
-                                        kstr: *mut c_char, klen: c_int,
-                                        callback: Option<PasswordCallback>,
-                                        user_data: *mut c_void) -> c_int;
+                                    user_data: *mut c_void)
+                                    -> c_int;
+    pub fn PEM_write_bio_PKCS8PrivateKey(bio: *mut BIO,
+                                         pkey: *mut EVP_PKEY,
+                                         cipher: *const EVP_CIPHER,
+                                         kstr: *mut c_char,
+                                         klen: c_int,
+                                         callback: Option<PasswordCallback>,
+                                         user_data: *mut c_void)
+                                         -> c_int;
     pub fn PEM_write_bio_PUBKEY(bp: *mut BIO, x: *mut EVP_PKEY) -> c_int;
-    pub fn PEM_write_bio_RSAPrivateKey(bp: *mut BIO, rsa: *mut RSA, cipher: *const EVP_CIPHER,
-                                        kstr: *mut c_uchar, klen: c_int,
-                                        callback: Option<PasswordCallback>,
-                                        user_data: *mut c_void) -> c_int;
+    pub fn PEM_write_bio_RSAPrivateKey(bp: *mut BIO,
+                                       rsa: *mut RSA,
+                                       cipher: *const EVP_CIPHER,
+                                       kstr: *mut c_uchar,
+                                       klen: c_int,
+                                       callback: Option<PasswordCallback>,
+                                       user_data: *mut c_void)
+                                       -> c_int;
     pub fn PEM_write_bio_RSAPublicKey(bp: *mut BIO, rsa: *const RSA) -> c_int;
     pub fn PEM_write_bio_RSA_PUBKEY(bp: *mut BIO, rsa: *mut RSA) -> c_int;
 
-    pub fn PEM_read_bio_DSAPrivateKey(bp: *mut BIO, dsa: *mut *mut DSA, callback: Option<PasswordCallback>,
-                                      user_data: *mut c_void) -> *mut DSA;
-    pub fn PEM_read_bio_DSA_PUBKEY(bp: *mut BIO, dsa: *mut *mut DSA, callback: Option<PasswordCallback>,
-                                   user_data: *mut c_void) -> *mut DSA;
-    pub fn PEM_write_bio_DSAPrivateKey(bp: *mut BIO, dsa: *mut DSA, cipher: *const EVP_CIPHER,
-                                       kstr: *mut c_uchar, klen: c_int, callback: Option<PasswordCallback>,
-                                       user_data: *mut c_void) -> c_int;
+    pub fn PEM_read_bio_DSAPrivateKey(bp: *mut BIO,
+                                      dsa: *mut *mut DSA,
+                                      callback: Option<PasswordCallback>,
+                                      user_data: *mut c_void)
+                                      -> *mut DSA;
+    pub fn PEM_read_bio_DSA_PUBKEY(bp: *mut BIO,
+                                   dsa: *mut *mut DSA,
+                                   callback: Option<PasswordCallback>,
+                                   user_data: *mut c_void)
+                                   -> *mut DSA;
+    pub fn PEM_write_bio_DSAPrivateKey(bp: *mut BIO,
+                                       dsa: *mut DSA,
+                                       cipher: *const EVP_CIPHER,
+                                       kstr: *mut c_uchar,
+                                       klen: c_int,
+                                       callback: Option<PasswordCallback>,
+                                       user_data: *mut c_void)
+                                       -> c_int;
     pub fn PEM_write_bio_DSA_PUBKEY(bp: *mut BIO, dsa: *mut DSA) -> c_int;
 
     pub fn PEM_write_bio_X509(bio: *mut BIO, x509: *mut X509) -> c_int;
@@ -1743,48 +2014,106 @@ extern {
                                       callback: Option<PasswordCallback>,
                                       user_data: *mut c_void)
                                       -> c_int;
-    pub fn PEM_read_bio_ECPrivateKey(bio: *mut BIO, key: *mut *mut EC_KEY, callback: Option<PasswordCallback>, user_data: *mut c_void) -> *mut EC_KEY;
-
-    pub fn PKCS5_PBKDF2_HMAC_SHA1(pass: *const c_char, passlen: c_int,
-                                  salt: *const u8, saltlen: c_int,
-                                  iter: c_int, keylen: c_int,
-                                  out: *mut u8) -> c_int;
-    pub fn PKCS5_PBKDF2_HMAC(pass: *const c_char, passlen: c_int,
-                             salt: *const c_uchar, saltlen: c_int,
-                             iter: c_int, digest: *const EVP_MD, keylen: c_int,
-                             out: *mut u8) -> c_int;
+    pub fn PEM_read_bio_ECPrivateKey(bio: *mut BIO,
+                                     key: *mut *mut EC_KEY,
+                                     callback: Option<PasswordCallback>,
+                                     user_data: *mut c_void)
+                                     -> *mut EC_KEY;
+
+    pub fn PKCS5_PBKDF2_HMAC_SHA1(pass: *const c_char,
+                                  passlen: c_int,
+                                  salt: *const u8,
+                                  saltlen: c_int,
+                                  iter: c_int,
+                                  keylen: c_int,
+                                  out: *mut u8)
+                                  -> c_int;
+    pub fn PKCS5_PBKDF2_HMAC(pass: *const c_char,
+                             passlen: c_int,
+                             salt: *const c_uchar,
+                             saltlen: c_int,
+                             iter: c_int,
+                             digest: *const EVP_MD,
+                             keylen: c_int,
+                             out: *mut u8)
+                             -> c_int;
 
     pub fn RAND_bytes(buf: *mut u8, num: c_int) -> c_int;
     pub fn RAND_status() -> c_int;
 
     pub fn RSA_new() -> *mut RSA;
     pub fn RSA_free(rsa: *mut RSA);
-    pub fn RSA_generate_key_ex(rsa: *mut RSA, bits: c_int, e: *mut BIGNUM, cb: *mut BN_GENCB) -> c_int;
-    pub fn RSA_private_decrypt(flen: c_int, from: *const u8, to: *mut u8, k: *mut RSA,
-                               pad: c_int) -> c_int;
-    pub fn RSA_public_decrypt(flen: c_int, from: *const u8, to: *mut u8, k: *mut RSA,
-                               pad: c_int) -> c_int;
-    pub fn RSA_private_encrypt(flen: c_int, from: *const u8, to: *mut u8, k: *mut RSA,
-                              pad: c_int) -> c_int;
-    pub fn RSA_public_encrypt(flen: c_int, from: *const u8, to: *mut u8, k: *mut RSA,
-                              pad: c_int) -> c_int;
-    pub fn RSA_sign(t: c_int, m: *const u8, mlen: c_uint, sig: *mut u8, siglen: *mut c_uint,
-                    k: *mut RSA) -> c_int;
+    pub fn RSA_generate_key_ex(rsa: *mut RSA,
+                               bits: c_int,
+                               e: *mut BIGNUM,
+                               cb: *mut BN_GENCB)
+                               -> c_int;
+    pub fn RSA_private_decrypt(flen: c_int,
+                               from: *const u8,
+                               to: *mut u8,
+                               k: *mut RSA,
+                               pad: c_int)
+                               -> c_int;
+    pub fn RSA_public_decrypt(flen: c_int,
+                              from: *const u8,
+                              to: *mut u8,
+                              k: *mut RSA,
+                              pad: c_int)
+                              -> c_int;
+    pub fn RSA_private_encrypt(flen: c_int,
+                               from: *const u8,
+                               to: *mut u8,
+                               k: *mut RSA,
+                               pad: c_int)
+                               -> c_int;
+    pub fn RSA_public_encrypt(flen: c_int,
+                              from: *const u8,
+                              to: *mut u8,
+                              k: *mut RSA,
+                              pad: c_int)
+                              -> c_int;
+    pub fn RSA_sign(t: c_int,
+                    m: *const u8,
+                    mlen: c_uint,
+                    sig: *mut u8,
+                    siglen: *mut c_uint,
+                    k: *mut RSA)
+                    -> c_int;
     pub fn RSA_size(k: *const RSA) -> c_int;
-    pub fn RSA_verify(t: c_int, m: *const u8, mlen: c_uint, sig: *const u8, siglen: c_uint,
-                      k: *mut RSA) -> c_int;
+    pub fn RSA_verify(t: c_int,
+                      m: *const u8,
+                      mlen: c_uint,
+                      sig: *const u8,
+                      siglen: c_uint,
+                      k: *mut RSA)
+                      -> c_int;
 
     pub fn DSA_new() -> *mut DSA;
     pub fn DSA_free(dsa: *mut DSA);
     pub fn DSA_size(dsa: *const DSA) -> c_int;
-    pub fn DSA_generate_parameters_ex(dsa: *mut DSA, bits: c_int, seed: *const c_uchar, seed_len: c_int,
-                                      counter_ref: *mut c_int, h_ret: *mut c_ulong,
-                                      cb: *mut BN_GENCB) -> c_int;
+    pub fn DSA_generate_parameters_ex(dsa: *mut DSA,
+                                      bits: c_int,
+                                      seed: *const c_uchar,
+                                      seed_len: c_int,
+                                      counter_ref: *mut c_int,
+                                      h_ret: *mut c_ulong,
+                                      cb: *mut BN_GENCB)
+                                      -> c_int;
     pub fn DSA_generate_key(dsa: *mut DSA) -> c_int;
-    pub fn DSA_sign(dummy: c_int, dgst: *const c_uchar, len: c_int, sigret: *mut c_uchar,
-                    siglen: *mut c_uint, dsa: *mut DSA) -> c_int;
-    pub fn DSA_verify(dummy: c_int, dgst: *const c_uchar, len: c_int, sigbuf: *const c_uchar,
-                      siglen: c_int, dsa: *mut DSA) -> c_int;
+    pub fn DSA_sign(dummy: c_int,
+                    dgst: *const c_uchar,
+                    len: c_int,
+                    sigret: *mut c_uchar,
+                    siglen: *mut c_uint,
+                    dsa: *mut DSA)
+                    -> c_int;
+    pub fn DSA_verify(dummy: c_int,
+                      dgst: *const c_uchar,
+                      len: c_int,
+                      sigbuf: *const c_uchar,
+                      siglen: c_int,
+                      dsa: *mut DSA)
+                      -> c_int;
 
     pub fn SHA1(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
     pub fn SHA224(d: *const c_uchar, n: size_t, md: *mut c_uchar) -> *mut c_uchar;
@@ -1801,8 +2130,7 @@ extern {
     pub fn SSL_accept(ssl: *mut SSL) -> c_int;
     pub fn SSL_connect(ssl: *mut SSL) -> c_int;
     pub fn SSL_do_handshake(ssl: *mut SSL) -> c_int;
-    pub fn SSL_ctrl(ssl: *mut SSL, cmd: c_int, larg: c_long,
-                    parg: *mut c_void) -> c_long;
+    pub fn SSL_ctrl(ssl: *mut SSL, cmd: c_int, larg: c_long, parg: *mut c_void) -> c_long;
     pub fn SSL_get_error(ssl: *const SSL, ret: c_int) -> c_int;
     pub fn SSL_read(ssl: *mut SSL, buf: *mut c_void, num: c_int) -> c_int;
     pub fn SSL_write(ssl: *mut SSL, buf: *const c_void, num: c_int) -> c_int;
@@ -1820,7 +2148,8 @@ extern {
     pub fn SSL_state_string_long(ssl: *const SSL) -> *const c_char;
     pub fn SSL_set_verify(ssl: *mut SSL,
                           mode: c_int,
-                          verify_callback: Option<extern fn(c_int, *mut X509_STORE_CTX) -> c_int>);
+                          verify_callback: Option<extern "C" fn(c_int, *mut X509_STORE_CTX)
+                                                                -> c_int>);
     pub fn SSL_set_ex_data(ssl: *mut SSL, idx: c_int, data: *mut c_void) -> c_int;
     pub fn SSL_get_ex_data(ssl: *const SSL, idx: c_int) -> *mut c_void;
     pub fn SSL_get_servername(ssl: *const SSL, name_type: c_int) -> *const c_char;
@@ -1836,10 +2165,10 @@ extern {
     pub fn SSL_get_privatekey(ssl: *const SSL) -> *mut EVP_PKEY;
     pub fn SSL_load_client_CA_file(file: *const c_char) -> *mut stack_st_X509_NAME;
     pub fn SSL_set_tmp_dh_callback(ctx: *mut SSL,
-                                   dh: unsafe extern fn(ssl: *mut SSL,
-                                                        is_export: c_int,
-                                                        keylength: c_int)
-                                                        -> *mut DH);
+                                   dh: unsafe extern "C" fn(ssl: *mut SSL,
+                                                            is_export: c_int,
+                                                            keylength: c_int)
+                                                            -> *mut DH);
 
     #[cfg(not(any(osslconf = "OPENSSL_NO_COMP", libressl)))]
     pub fn SSL_COMP_get_name(comp: *const COMP_METHOD) -> *const c_char;
@@ -1848,37 +2177,57 @@ extern {
 
     pub fn SSL_CIPHER_get_name(cipher: *const SSL_CIPHER) -> *const c_char;
     pub fn SSL_CIPHER_get_bits(cipher: *const SSL_CIPHER, alg_bits: *mut c_int) -> c_int;
-    pub fn SSL_CIPHER_description(cipher: *const SSL_CIPHER, buf: *mut c_char, size: c_int) -> *mut c_char;
+    pub fn SSL_CIPHER_description(cipher: *const SSL_CIPHER,
+                                  buf: *mut c_char,
+                                  size: c_int)
+                                  -> *mut c_char;
 
     pub fn SSL_CTX_new(method: *const SSL_METHOD) -> *mut SSL_CTX;
     pub fn SSL_CTX_free(ctx: *mut SSL_CTX);
     pub fn SSL_CTX_ctrl(ctx: *mut SSL_CTX, cmd: c_int, larg: c_long, parg: *mut c_void) -> c_long;
-    pub fn SSL_CTX_callback_ctrl(ctx: *mut SSL_CTX, cmd: c_int, fp: Option<extern fn()>) -> c_long;
-    pub fn SSL_CTX_set_verify(ctx: *mut SSL_CTX, mode: c_int,
-                              verify_callback: Option<extern fn(c_int, *mut X509_STORE_CTX) -> c_int>);
+    pub fn SSL_CTX_callback_ctrl(ctx: *mut SSL_CTX,
+                                 cmd: c_int,
+                                 fp: Option<extern "C" fn()>)
+                                 -> c_long;
+    pub fn SSL_CTX_set_verify(ctx: *mut SSL_CTX,
+                              mode: c_int,
+                              verify_callback: Option<extern "C" fn(c_int, *mut X509_STORE_CTX)
+                                                                    -> c_int>);
     pub fn SSL_CTX_set_verify_depth(ctx: *mut SSL_CTX, depth: c_int);
-    pub fn SSL_CTX_load_verify_locations(ctx: *mut SSL_CTX, CAfile: *const c_char,
-                                         CApath: *const c_char) -> c_int;
+    pub fn SSL_CTX_load_verify_locations(ctx: *mut SSL_CTX,
+                                         CAfile: *const c_char,
+                                         CApath: *const c_char)
+                                         -> c_int;
     pub fn SSL_CTX_set_default_verify_paths(ctx: *mut SSL_CTX) -> c_int;
-    pub fn SSL_CTX_set_ex_data(ctx: *mut SSL_CTX, idx: c_int, data: *mut c_void)
-                               -> c_int;
+    pub fn SSL_CTX_set_ex_data(ctx: *mut SSL_CTX, idx: c_int, data: *mut c_void) -> c_int;
     pub fn SSL_CTX_get_ex_data(ctx: *const SSL_CTX, idx: c_int) -> *mut c_void;
-    pub fn SSL_CTX_set_session_id_context(ssl: *mut SSL_CTX, sid_ctx: *const c_uchar, sid_ctx_len: c_uint) -> c_int;
+    pub fn SSL_CTX_set_session_id_context(ssl: *mut SSL_CTX,
+                                          sid_ctx: *const c_uchar,
+                                          sid_ctx_len: c_uint)
+                                          -> c_int;
 
-    pub fn SSL_CTX_use_certificate_file(ctx: *mut SSL_CTX, cert_file: *const c_char, file_type: c_int) -> c_int;
-    pub fn SSL_CTX_use_certificate_chain_file(ctx: *mut SSL_CTX, cert_chain_file: *const c_char) -> c_int;
+    pub fn SSL_CTX_use_certificate_file(ctx: *mut SSL_CTX,
+                                        cert_file: *const c_char,
+                                        file_type: c_int)
+                                        -> c_int;
+    pub fn SSL_CTX_use_certificate_chain_file(ctx: *mut SSL_CTX,
+                                              cert_chain_file: *const c_char)
+                                              -> c_int;
     pub fn SSL_CTX_use_certificate(ctx: *mut SSL_CTX, cert: *mut X509) -> c_int;
 
-    pub fn SSL_CTX_use_PrivateKey_file(ctx: *mut SSL_CTX, key_file: *const c_char, file_type: c_int) -> c_int;
+    pub fn SSL_CTX_use_PrivateKey_file(ctx: *mut SSL_CTX,
+                                       key_file: *const c_char,
+                                       file_type: c_int)
+                                       -> c_int;
     pub fn SSL_CTX_use_PrivateKey(ctx: *mut SSL_CTX, key: *mut EVP_PKEY) -> c_int;
     pub fn SSL_CTX_check_private_key(ctx: *const SSL_CTX) -> c_int;
     pub fn SSL_CTX_set_client_CA_list(ctx: *mut SSL_CTX, list: *mut stack_st_X509_NAME);
     pub fn SSL_CTX_get_cert_store(ctx: *const SSL_CTX) -> *mut X509_STORE;
     pub fn SSL_CTX_set_tmp_dh_callback(ctx: *mut SSL_CTX,
-                                       dh: unsafe extern fn(ssl: *mut SSL,
-                                                            is_export: c_int,
-                                                            keylength: c_int)
-                                                            -> *mut DH);
+                                       dh: unsafe extern "C" fn(ssl: *mut SSL,
+                                                                is_export: c_int,
+                                                                keylength: c_int)
+                                                                -> *mut DH);
 
     #[cfg(not(any(ossl101, libressl)))]
     pub fn SSL_CTX_get0_certificate(ctx: *const SSL_CTX) -> *mut X509;
@@ -1891,7 +2240,8 @@ extern {
                                                  cb: extern "C" fn(ssl: *mut SSL,
                                                                    out: *mut *const c_uchar,
                                                                    outlen: *mut c_uint,
-                                                                   arg: *mut c_void) -> c_int,
+                                                                   arg: *mut c_void)
+                                                                   -> c_int,
                                                  arg: *mut c_void);
     pub fn SSL_CTX_set_next_proto_select_cb(ssl: *mut SSL_CTX,
                                             cb: extern "C" fn(ssl: *mut SSL,
@@ -1899,12 +2249,19 @@ extern {
                                                               outlen: *mut c_uchar,
                                                               inbuf: *const c_uchar,
                                                               inlen: c_uint,
-                                                              arg: *mut c_void) -> c_int,
+                                                              arg: *mut c_void)
+                                                              -> c_int,
                                             arg: *mut c_void);
-    pub fn SSL_select_next_proto(out: *mut *mut c_uchar, outlen: *mut c_uchar,
-                                 inbuf: *const c_uchar, inlen: c_uint,
-                                 client: *const c_uchar, client_len: c_uint) -> c_int;
-    pub fn SSL_get0_next_proto_negotiated(s: *const SSL, data: *mut *const c_uchar, len: *mut c_uint);
+    pub fn SSL_select_next_proto(out: *mut *mut c_uchar,
+                                 outlen: *mut c_uchar,
+                                 inbuf: *const c_uchar,
+                                 inlen: c_uint,
+                                 client: *const c_uchar,
+                                 client_len: c_uint)
+                                 -> c_int;
+    pub fn SSL_get0_next_proto_negotiated(s: *const SSL,
+                                          data: *mut *const c_uchar,
+                                          len: *mut c_uint);
     pub fn SSL_get_session(s: *const SSL) -> *mut SSL_SESSION;
     pub fn SSL_set_session(ssl: *mut SSL, session: *mut SSL_SESSION) -> c_int;
     #[cfg(not(any(ossl101, libressl)))]
@@ -1921,18 +2278,23 @@ extern {
 
     #[cfg(not(ossl101))]
     pub fn SSL_CTX_set_alpn_select_cb(ssl: *mut SSL_CTX,
-                                      cb: extern fn(ssl: *mut SSL,
-                                                    out: *mut *const c_uchar,
-                                                    outlen: *mut c_uchar,
-                                                    inbuf: *const c_uchar,
-                                                    inlen: c_uint,
-                                                    arg: *mut c_void) -> c_int,
+                                      cb: extern "C" fn(ssl: *mut SSL,
+                                                        out: *mut *const c_uchar,
+                                                        outlen: *mut c_uchar,
+                                                        inbuf: *const c_uchar,
+                                                        inlen: c_uint,
+                                                        arg: *mut c_void)
+                                                        -> c_int,
                                       arg: *mut c_void);
     #[cfg(not(ossl101))]
     pub fn SSL_get0_alpn_selected(s: *const SSL, data: *mut *const c_uchar, len: *mut c_uint);
 
     pub fn X509_add_ext(x: *mut X509, ext: *mut X509_EXTENSION, loc: c_int) -> c_int;
-    pub fn X509_digest(x: *const X509, digest: *const EVP_MD, buf: *mut c_uchar, len: *mut c_uint) -> c_int;
+    pub fn X509_digest(x: *const X509,
+                       digest: *const EVP_MD,
+                       buf: *mut c_uchar,
+                       len: *mut c_uint)
+                       -> c_int;
     pub fn X509_free(x: *mut X509);
     pub fn X509_REQ_free(x: *mut X509_REQ);
     pub fn X509_get_serialNumber(x: *mut X509) -> *mut ASN1_INTEGER;
@@ -1956,7 +2318,14 @@ extern {
 
     pub fn X509_NAME_new() -> *mut X509_NAME;
     pub fn X509_NAME_free(x: *mut X509_NAME);
-    pub fn X509_NAME_add_entry_by_txt(x: *mut X509_NAME, field: *const c_char, ty: c_int, bytes: *const c_uchar, len: c_int, loc: c_int, set: c_int) -> c_int;
+    pub fn X509_NAME_add_entry_by_txt(x: *mut X509_NAME,
+                                      field: *const c_char,
+                                      ty: c_int,
+                                      bytes: *const c_uchar,
+                                      len: c_int,
+                                      loc: c_int,
+                                      set: c_int)
+                                      -> c_int;
     pub fn X509_NAME_get_index_by_NID(n: *mut X509_NAME, nid: c_int, last_pos: c_int) -> c_int;
 
     pub fn X509_NAME_ENTRY_free(x: *mut X509_NAME_ENTRY);
@@ -1977,14 +2346,21 @@ extern {
     pub fn X509_STORE_CTX_get_ex_data(ctx: *mut X509_STORE_CTX, idx: c_int) -> *mut c_void;
     pub fn X509_STORE_CTX_get_error_depth(ctx: *mut X509_STORE_CTX) -> c_int;
 
-    pub fn X509V3_set_ctx(ctx: *mut X509V3_CTX, issuer: *mut X509, subject: *mut X509, req: *mut X509_REQ, crl: *mut X509_CRL, flags: c_int);
+    pub fn X509V3_set_ctx(ctx: *mut X509V3_CTX,
+                          issuer: *mut X509,
+                          subject: *mut X509,
+                          req: *mut X509_REQ,
+                          crl: *mut X509_CRL,
+                          flags: c_int);
     pub fn X509V3_set_nconf(ctx: *mut X509V3_CTX, conf: *mut CONF);
 
     pub fn X509_REQ_new() -> *mut X509_REQ;
     pub fn X509_REQ_set_version(req: *mut X509_REQ, version: c_long) -> c_int;
     pub fn X509_REQ_set_subject_name(req: *mut X509_REQ, name: *mut X509_NAME) -> c_int;
     pub fn X509_REQ_set_pubkey(req: *mut X509_REQ, pkey: *mut EVP_PKEY) -> c_int;
-    pub fn X509_REQ_add_extensions(req: *mut X509_REQ, exts: *mut stack_st_X509_EXTENSION) -> c_int;
+    pub fn X509_REQ_add_extensions(req: *mut X509_REQ,
+                                   exts: *mut stack_st_X509_EXTENSION)
+                                   -> c_int;
     pub fn X509_REQ_sign(x: *mut X509_REQ, pkey: *mut EVP_PKEY, md: *const EVP_MD) -> c_int;
 
     #[cfg(not(ossl101))]
@@ -1994,21 +2370,31 @@ extern {
     #[cfg(not(any(ossl101, libressl)))]
     pub fn X509_VERIFY_PARAM_set1_host(param: *mut X509_VERIFY_PARAM,
                                        name: *const c_char,
-                                       namelen: size_t) -> c_int;
+                                       namelen: size_t)
+                                       -> c_int;
 
     pub fn d2i_DHparams(k: *mut *mut DH, pp: *mut *const c_uchar, length: c_long) -> *mut DH;
     pub fn i2d_DHparams(dh: *const DH, pp: *mut *mut c_uchar) -> c_int;
 
     pub fn d2i_DSAPublicKey(a: *mut *mut DSA, pp: *mut *const c_uchar, length: c_long) -> *mut DSA;
     pub fn i2d_DSAPublicKey(a: *const DSA, pp: *mut *mut c_uchar) -> c_int;
-    pub fn d2i_DSAPrivateKey(a: *mut *mut DSA, pp: *mut *const c_uchar, length: c_long) -> *mut DSA;
+    pub fn d2i_DSAPrivateKey(a: *mut *mut DSA,
+                             pp: *mut *const c_uchar,
+                             length: c_long)
+                             -> *mut DSA;
     pub fn i2d_DSAPrivateKey(a: *const DSA, pp: *mut *mut c_uchar) -> c_int;
 
-    pub fn d2i_ECPrivateKey(k: *mut *mut EC_KEY, pp: *mut *const c_uchar, length: c_long) -> *mut EC_KEY;
+    pub fn d2i_ECPrivateKey(k: *mut *mut EC_KEY,
+                            pp: *mut *const c_uchar,
+                            length: c_long)
+                            -> *mut EC_KEY;
     pub fn i2d_ECPrivateKey(ec_key: *mut EC_KEY, pp: *mut *mut c_uchar) -> c_int;
 
     pub fn d2i_X509(a: *mut *mut X509, pp: *mut *const c_uchar, length: c_long) -> *mut X509;
-    pub fn d2i_X509_REQ(a: *mut *mut X509_REQ, pp: *mut *const c_uchar, length: c_long) -> *mut X509_REQ;
+    pub fn d2i_X509_REQ(a: *mut *mut X509_REQ,
+                        pp: *mut *const c_uchar,
+                        length: c_long)
+                        -> *mut X509_REQ;
     pub fn i2d_X509_bio(b: *mut BIO, x: *mut X509) -> c_int;
     pub fn i2d_X509(x: *mut X509, buf: *mut *mut u8) -> c_int;
     pub fn i2d_X509_REQ_bio(b: *mut BIO, x: *mut X509_REQ) -> c_int;
@@ -2042,11 +2428,8 @@ extern {
                         key: *const c_void,
                         len: c_int,
                         md: *const EVP_MD,
-                        impl_: *mut ENGINE) -> c_int;
-    pub fn HMAC_Update(ctx: *mut HMAC_CTX,
-                       data: *const c_uchar,
-                       len: size_t) -> c_int;
-    pub fn HMAC_Final(ctx: *mut HMAC_CTX,
-                      md: *mut c_uchar,
-                      len: *mut c_uint) -> c_int;
+                        impl_: *mut ENGINE)
+                        -> c_int;
+    pub fn HMAC_Update(ctx: *mut HMAC_CTX, data: *const c_uchar, len: size_t) -> c_int;
+    pub fn HMAC_Final(ctx: *mut HMAC_CTX, md: *mut c_uchar, len: *mut c_uint) -> c_int;
 }