Rustfmt

1 files changed, 742 insertions, 624 deletions

diff --git a/openssl-sys/src/lib.rs b/openssl-sys/src/lib.rs
index d57f4bb7..040bbabe 100644
--- a/openssl-sys/src/lib.rs
+++ b/openssl-sys/src/lib.rs
@@ -64,26 +64,34 @@ pub enum BN_BLINDING {}
 pub enum DSA_METHOD {}
 pub enum EVP_PKEY_ASN1_METHOD {}
 
-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>;
+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)]
@@ -1212,11 +1220,9 @@ pub const SSL_OP_SAFARI_ECDHE_ECDSA_BUG: c_ulong = 0x00000040;
 #[cfg(not(any(libressl, ossl110f)))]
 pub const SSL_OP_ALL: c_ulong = 0x80000BFF;
 #[cfg(ossl110f)]
-pub const SSL_OP_ALL: c_ulong = SSL_OP_CRYPTOPRO_TLSEXT_BUG |
-                            SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS |
-                            SSL_OP_LEGACY_SERVER_CONNECT |
-                            SSL_OP_TLSEXT_PADDING |
-                            SSL_OP_SAFARI_ECDHE_ECDSA_BUG;
+pub const SSL_OP_ALL: c_ulong = SSL_OP_CRYPTOPRO_TLSEXT_BUG | SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS |
+    SSL_OP_LEGACY_SERVER_CONNECT | SSL_OP_TLSEXT_PADDING |
+    SSL_OP_SAFARI_ECDHE_ECDSA_BUG;
 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;
@@ -1240,8 +1246,8 @@ pub const SSL_OP_NO_DTLSv1: c_ulong = 0x04000000;
 #[cfg(not(any(ossl101, libressl)))]
 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;
 
@@ -1357,21 +1363,25 @@ 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 {
@@ -1407,31 +1417,35 @@ pub unsafe fn SSL_CTX_set0_verify_cert_store(ctx: *mut SSL_CTX, st: *mut X509_ST
     SSL_CTX_ctrl(ctx, SSL_CTRL_SET_VERIFY_CERT_STORE, 0, st as *mut c_void)
 }
 
-pub unsafe fn SSL_CTX_set_tlsext_servername_callback(ctx: *mut SSL_CTX,
-                                                     cb: Option<extern "C" fn()>)
-                                                     -> c_long {
+pub unsafe fn SSL_CTX_set_tlsext_servername_callback(
+    ctx: *mut SSL_CTX,
+    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,
-             TLSEXT_NAMETYPE_host_name as c_long,
-             name as *mut c_void)
+    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 "C" fn(*mut SSL,
-                                                                           *mut c_void)
-                                                                           -> c_int>)
-                                           -> c_long {
+pub unsafe fn SSL_CTX_set_tlsext_status_cb(
+    ctx: *mut SSL_CTX,
+    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))
 }
 
@@ -1439,27 +1453,33 @@ 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 {
@@ -1477,12 +1497,14 @@ pub fn ERR_GET_REASON(l: c_ulong) -> c_int {
 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;
@@ -1519,54 +1541,62 @@ extern "C" {
     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;
@@ -1584,24 +1614,27 @@ extern "C" {
     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;
@@ -1646,82 +1679,93 @@ extern "C" {
     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;
@@ -1760,82 +1804,90 @@ extern "C" {
     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_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;
+    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;
     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;
 
-    pub fn EVP_DigestSignInit(ctx: *mut EVP_MD_CTX,
-                              pctx: *mut *mut EVP_PKEY_CTX,
-                              type_: *const EVP_MD,
-                              e: *mut ENGINE,
-                              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;
-    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;
+    pub fn EVP_DigestSignInit(
+        ctx: *mut EVP_MD_CTX,
+        pctx: *mut *mut EVP_PKEY_CTX,
+        type_: *const EVP_MD,
+        e: *mut ENGINE,
+        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;
+    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;
     #[cfg(any(ossl101, libressl))]
-    pub fn EVP_DigestVerifyFinal(ctx: *mut EVP_MD_CTX,
-                                 sigret: *mut c_uchar,
-                                 siglen: size_t)
-                                 -> c_int;
+    pub fn EVP_DigestVerifyFinal(
+        ctx: *mut EVP_MD_CTX,
+        sigret: *mut c_uchar,
+        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;
+    pub fn EVP_DigestVerifyFinal(
+        ctx: *mut EVP_MD_CTX,
+        sigret: *const c_uchar,
+        siglen: size_t,
+    ) -> c_int;
 
     pub fn EVP_MD_CTX_copy_ex(dst: *mut EVP_MD_CTX, src: *const EVP_MD_CTX) -> c_int;
 
@@ -1849,69 +1901,77 @@ extern "C" {
     pub fn EVP_PKEY_get1_DH(k: *mut EVP_PKEY) -> *mut DH;
     pub fn EVP_PKEY_get1_EC_KEY(k: *mut EVP_PKEY) -> *mut EC_KEY;
     pub fn EVP_PKEY_cmp(a: *const EVP_PKEY, b: *const EVP_PKEY) -> c_int;
-    pub fn EVP_PKEY_new_mac_key(type_: c_int,
-                                e: *mut ENGINE,
-                                key: *const c_uchar,
-                                keylen: c_int)
-                                -> *mut EVP_PKEY;
+    pub fn EVP_PKEY_new_mac_key(
+        type_: c_int,
+        e: *mut ENGINE,
+        key: *const c_uchar,
+        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;
@@ -1919,211 +1979,239 @@ extern "C" {
     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,
-                                    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;
+    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;
     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;
     pub fn PEM_write_bio_X509_REQ(bio: *mut BIO, x509: *mut X509_REQ) -> c_int;
 
-    pub fn PEM_write_bio_ECPrivateKey(bio: *mut BIO,
-                                      key: *mut EC_KEY,
-                                      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_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_write_bio_ECPrivateKey(
+        bio: *mut BIO,
+        key: *mut EC_KEY,
+        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_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;
@@ -2156,10 +2244,11 @@ extern "C" {
     pub fn SSL_get_version(ssl: *const SSL) -> *const c_char;
     pub fn SSL_state_string(ssl: *const SSL) -> *const c_char;
     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 "C" fn(c_int, *mut X509_STORE_CTX)
-                                                                -> c_int>);
+    pub fn SSL_set_verify(
+        ssl: *mut SSL,
+        mode: 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;
@@ -2174,11 +2263,10 @@ extern "C" {
     #[cfg(not(any(ossl101, libressl)))]
     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 "C" fn(ssl: *mut SSL,
-                                                            is_export: c_int,
-                                                            keylength: c_int)
-                                                            -> *mut DH);
+    pub fn SSL_set_tmp_dh_callback(
+        ctx: *mut SSL,
+        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;
@@ -2187,57 +2275,64 @@ extern "C" {
 
     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 "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_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_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_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_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(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 "C" fn(ssl: *mut SSL,
-                                                                is_export: c_int,
-                                                                keylength: c_int)
-                                                                -> *mut DH);
+    pub fn SSL_CTX_set_tmp_dh_callback(
+        ctx: *mut SSL_CTX,
+        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;
@@ -2246,41 +2341,52 @@ extern "C" {
 
     pub fn SSL_CTX_set_cipher_list(ssl: *mut SSL_CTX, s: *const c_char) -> c_int;
 
-    pub fn SSL_CTX_set_next_protos_advertised_cb(ssl: *mut SSL_CTX,
-                                                 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);
-    pub fn SSL_CTX_set_next_proto_select_cb(ssl: *mut SSL_CTX,
-                                            cb: extern "C" fn(ssl: *mut SSL,
-                                                              out: *mut *mut c_uchar,
-                                                              outlen: *mut c_uchar,
-                                                              inbuf: *const c_uchar,
-                                                              inlen: c_uint,
-                                                              arg: *mut c_void)
-                                                              -> c_int,
-                                            arg: *mut c_void);
+    pub fn SSL_CTX_set_next_protos_advertised_cb(
+        ssl: *mut SSL_CTX,
+        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,
+    );
+    pub fn SSL_CTX_set_next_proto_select_cb(
+        ssl: *mut SSL_CTX,
+        cb: extern "C" fn(ssl: *mut SSL,
+                          out: *mut *mut 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(osslconf = "OPENSSL_NO_PSK"))]
-    pub fn SSL_CTX_set_psk_client_callback(ssl: *mut SSL_CTX,
-                                           psk_client_cb: Option<extern "C" fn(*mut SSL,
-                                                                               *const c_char,
-                                                                               *mut c_char,
-                                                                               c_uint,
-                                                                               *mut c_uchar,
-                                                                               c_uint)
-                                                                               -> 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_CTX_set_psk_client_callback(
+        ssl: *mut SSL_CTX,
+        psk_client_cb: Option<
+            extern "C" fn(*mut SSL,
+                          *const c_char,
+                          *mut c_char,
+                          c_uint,
+                          *mut c_uchar,
+                          c_uint)
+                          -> 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, ossl110f)))]
@@ -2298,24 +2404,27 @@ extern "C" {
     pub fn SSL_set_alpn_protos(s: *mut SSL, data: *const c_uchar, len: c_uint) -> c_int;
 
     #[cfg(not(ossl101))]
-    pub fn SSL_CTX_set_alpn_select_cb(ssl: *mut SSL_CTX,
-                                      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);
+    pub fn SSL_CTX_set_alpn_select_cb(
+        ssl: *mut SSL_CTX,
+        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;
@@ -2339,14 +2448,15 @@ extern "C" {
 
     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);
@@ -2367,21 +2477,22 @@ extern "C" {
     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))]
@@ -2389,39 +2500,44 @@ extern "C" {
     #[cfg(not(any(ossl101, libressl)))]
     pub fn X509_VERIFY_PARAM_set_hostflags(param: *mut X509_VERIFY_PARAM, flags: c_uint);
     #[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;
+    pub fn X509_VERIFY_PARAM_set1_host(
+        param: *mut X509_VERIFY_PARAM,
+        name: *const c_char,
+        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;
     pub fn i2d_X509_REQ(x: *mut X509_REQ, buf: *mut *mut u8) -> c_int;
 
-    pub fn d2i_AutoPrivateKey(a: *mut *mut EVP_PKEY, pp: *mut *const c_uchar, length: c_long) -> *mut EVP_PKEY;
+    pub fn d2i_AutoPrivateKey(
+        a: *mut *mut EVP_PKEY,
+        pp: *mut *const c_uchar,
+        length: c_long,
+    ) -> *mut EVP_PKEY;
     pub fn d2i_PUBKEY(k: *mut *mut EVP_PKEY, buf: *mut *const u8, len: c_long) -> *mut EVP_PKEY;
     pub fn i2d_PUBKEY_bio(b: *mut BIO, x: *mut EVP_PKEY) -> c_int;
     pub fn i2d_PrivateKey_bio(b: *mut BIO, x: *mut EVP_PKEY) -> c_int;
@@ -2438,22 +2554,24 @@ extern "C" {
     pub fn i2d_PKCS12_bio(b: *mut BIO, a: *mut PKCS12) -> c_int;
     pub fn i2d_PKCS12(a: *mut PKCS12, buf: *mut *mut u8) -> c_int;
     pub fn d2i_PKCS12(a: *mut *mut PKCS12, pp: *mut *const u8, length: c_long) -> *mut PKCS12;
-    pub fn PKCS12_parse(p12: *mut PKCS12,
-                        pass: *const c_char,
-                        pkey: *mut *mut EVP_PKEY,
-                        cert: *mut *mut X509,
-                        ca: *mut *mut stack_st_X509)
-                        -> c_int;
+    pub fn PKCS12_parse(
+        p12: *mut PKCS12,
+        pass: *const c_char,
+        pkey: *mut *mut EVP_PKEY,
+        cert: *mut *mut X509,
+        ca: *mut *mut stack_st_X509,
+    ) -> c_int;
     pub fn PKCS12_free(p12: *mut PKCS12);
 
     pub fn GENERAL_NAME_free(name: *mut GENERAL_NAME);
 
-    pub fn HMAC_Init_ex(ctx: *mut HMAC_CTX,
-                        key: *const c_void,
-                        len: c_int,
-                        md: *const EVP_MD,
-                        impl_: *mut ENGINE)
-                        -> c_int;
+    pub fn HMAC_Init_ex(
+        ctx: *mut HMAC_CTX,
+        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;
 }