Style the code
authorIaroslav Gridin <voker57@gmail.com>
Sat, 29 Oct 2016 13:56:31 +0000 (16:56 +0300)
committerRichard Levitte <levitte@openssl.org>
Tue, 10 Jan 2017 07:21:45 +0000 (08:21 +0100)
Reviewed-by: Rich Salz <rsalz@openssl.org>
Reviewed-by: Richard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1784)

crypto/engine/eng_cryptodev.c

index ad872fd..e336151 100644 (file)
@@ -166,46 +166,22 @@ static struct {
     int ivmax;
     int keylen;
 } ciphers[] = {
-    {
-        CRYPTO_ARC4, NID_rc4, 0, 16,
-    },
-    {
-        CRYPTO_DES_CBC, NID_des_cbc, 8, 8,
-    },
-    {
-        CRYPTO_3DES_CBC, NID_des_ede3_cbc, 8, 24,
-    },
-    {
-        CRYPTO_AES_CBC, NID_aes_128_cbc, 16, 16,
-    },
-    {
-        CRYPTO_AES_CBC, NID_aes_192_cbc, 16, 24,
-    },
-    {
-        CRYPTO_AES_CBC, NID_aes_256_cbc, 16, 32,
-    },
-    {
-        CRYPTO_AES_CTR, NID_aes_128_ctr, 14, 16,
-    },
-    {
-        CRYPTO_AES_CTR, NID_aes_192_ctr, 14, 24,
-    },
-    {
-        CRYPTO_AES_CTR, NID_aes_256_ctr, 14, 32,
-    },
-    {
-        CRYPTO_BLF_CBC, NID_bf_cbc, 8, 16,
-    },
-    {
-        CRYPTO_CAST_CBC, NID_cast5_cbc, 8, 16,
-    },
-    {
-        CRYPTO_SKIPJACK_CBC, NID_undef, 0, 0,
-    },
+    {CRYPTO_ARC4, NID_rc4, 0, 16},
+    {CRYPTO_DES_CBC, NID_des_cbc, 8, 8},
+    {CRYPTO_3DES_CBC, NID_des_ede3_cbc, 8, 24},
     {CRYPTO_3DES_ECB, NID_des_ede3_ecb, 0, 24},
+    {CRYPTO_AES_CBC, NID_aes_128_cbc, 16, 16},
+    {CRYPTO_AES_CBC, NID_aes_192_cbc, 16, 24},
+    {CRYPTO_AES_CBC, NID_aes_256_cbc, 16, 32},
+    {CRYPTO_AES_CTR, NID_aes_128_ctr, 14, 16},
+    {CRYPTO_AES_CTR, NID_aes_192_ctr, 14, 24},
+    {CRYPTO_AES_CTR, NID_aes_256_ctr, 14, 32},
     {CRYPTO_AES_ECB, NID_aes_128_ecb, 0, 16},
     {CRYPTO_AES_ECB, NID_aes_192_ecb, 0, 24},
     {CRYPTO_AES_ECB, NID_aes_256_ecb, 0, 32},
+    {CRYPTO_BLF_CBC, NID_bf_cbc, 8, 16},
+    {CRYPTO_CAST_CBC, NID_cast5_cbc, 8, 16},
+    {CRYPTO_SKIPJACK_CBC, NID_undef, 0, 0},
     {0, NID_undef, 0, 0},
 };
 
@@ -213,44 +189,19 @@ static struct {
 static struct {
     int id;
     int nid;
-    int  digestlen;
+    int digestlen;
 } digests[] = {
 #  if 0
-    /* HMAC is not supported */
-    {
-        CRYPTO_MD5_HMAC, NID_hmacWithMD5, 16
-    },
-    {
-        CRYPTO_SHA1_HMAC, NID_hmacWithSHA1, 20
-    },
-    {
-        CRYPTO_SHA2_256_HMAC, NID_hmacWithSHA256, 32
-    },
-    {
-        CRYPTO_SHA2_384_HMAC, NID_hmacWithSHA384, 48
-    },
-    {
-        CRYPTO_SHA2_512_HMAC, NID_hmacWithSHA512, 64
-    },
+        /* HMAC is not supported */
+    {CRYPTO_MD5_HMAC, NID_hmacWithMD5, 16},
+    {CRYPTO_SHA1_HMAC, NID_hmacWithSHA1, 20},
 #  endif
-    {
-        CRYPTO_MD5, NID_md5, 16
-    },
-    {
-        CRYPTO_SHA1, NID_sha1, 20
-    },
-    {
-        CRYPTO_SHA2_256, NID_sha256, 32
-    },
-    {
-        CRYPTO_SHA2_384, NID_sha384, 48
-    },
-    {
-        CRYPTO_SHA2_512, NID_sha512, 64
-    },
-    {
-        0, NID_undef, 0
-    },
+    {CRYPTO_MD5, NID_md5, 16},
+    {CRYPTO_SHA1, NID_sha1, 20},
+    {CRYPTO_SHA2_256, NID_sha256, 32},
+    {CRYPTO_SHA2_384, NID_sha384, 48},
+    {CRYPTO_SHA2_512, NID_sha512, 64},
+    {0, NID_undef, 0},
 };
 # endif
 
@@ -370,12 +321,12 @@ static int get_cryptodev_digests(const int **cnids)
         return (0);
     }
     memset(&sess, 0, sizeof(sess));
-    sess.mackey = (void *)fake_key;
+    sess.mackey = fake_key;
     for (i = 0; digests[i].id && count < CRYPTO_ALGORITHM_MAX; i++) {
         if (digests[i].nid == NID_undef)
             continue;
         sess.mac = digests[i].id;
-        sess.mackeylen = digests[i].digestlen;
+        sess.mackeylen = 8;
         sess.cipher = 0;
         if (ioctl(fd, CIOCGSESSION, &sess) != -1 &&
             ioctl(fd, CIOCFSESSION, &sess.ses) != -1)
@@ -461,14 +412,14 @@ cryptodev_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
     cryp.ses = sess->ses;
     cryp.flags = 0;
     cryp.len = inl;
-    cryp.src = (void *) in;
-    cryp.dst = (void *) out;
+    cryp.src = (void *)in;
+    cryp.dst = (void *)out;
     cryp.mac = 0;
 
     cryp.op = EVP_CIPHER_CTX_encrypting(ctx) ? COP_ENCRYPT : COP_DECRYPT;
 
     if (EVP_CIPHER_CTX_iv_length(ctx) > 0) {
-        cryp.iv = (void *) EVP_CIPHER_CTX_iv(ctx);
+        cryp.iv = (void *)EVP_CIPHER_CTX_iv(ctx);
         if (!EVP_CIPHER_CTX_encrypting(ctx)) {
             iiv = in + inl - EVP_CIPHER_CTX_iv_length(ctx);
             memcpy(save_iv, iiv, EVP_CIPHER_CTX_iv_length(ctx));
@@ -521,7 +472,7 @@ cryptodev_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
     if ((state->d_fd = get_dev_crypto()) < 0)
         return (0);
 
-    sess->key = (void *) key;
+    sess->key = (void *)key;
     sess->keylen = EVP_CIPHER_CTX_key_length(ctx);
     sess->cipher = cipher;
 
@@ -590,9 +541,9 @@ static EVP_CIPHER *rc4_cipher = NULL;
 static const EVP_CIPHER *cryptodev_rc4(void)
 {
     if (rc4_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_rc4, 1, 16);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_rc4, 1, 16)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 0)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_VARIABLE_LENGTH
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -600,7 +551,9 @@ static const EVP_CIPHER *cryptodev_rc4(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -614,9 +567,9 @@ static EVP_CIPHER *des_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_des_cbc(void)
 {
     if (des_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_des_cbc, 8, 8);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_des_cbc, 8, 8)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 8)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -624,9 +577,13 @@ static const EVP_CIPHER *cryptodev_des_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -640,9 +597,9 @@ static EVP_CIPHER *des3_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_3des_cbc(void)
 {
     if (des3_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_des_ede3_cbc, 8, 24);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_des_ede3_cbc, 8, 24)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 8)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -650,9 +607,13 @@ static const EVP_CIPHER *cryptodev_3des_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -689,9 +650,9 @@ static EVP_CIPHER *bf_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_bf_cbc(void)
 {
     if (bf_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_bf_cbc, 8, 16);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_bf_cbc, 8, 16)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 8)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -699,9 +660,13 @@ static const EVP_CIPHER *cryptodev_bf_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -714,9 +679,9 @@ static EVP_CIPHER *cast_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_cast_cbc(void)
 {
     if (cast_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_cast5_cbc, 8, 16);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_cast5_cbc, 8, 16)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 8)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -724,9 +689,13 @@ static const EVP_CIPHER *cryptodev_cast_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -739,9 +708,9 @@ static EVP_CIPHER *aes_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_aes_cbc(void)
 {
     if (aes_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_aes_128_cbc, 16, 16);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_aes_128_cbc, 16, 16)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 16)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -749,9 +718,13 @@ static const EVP_CIPHER *cryptodev_aes_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -764,9 +737,9 @@ static EVP_CIPHER *aes_192_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_aes_192_cbc(void)
 {
     if (aes_192_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_aes_192_cbc, 16, 24);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_aes_192_cbc, 16, 24)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 16)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -774,9 +747,13 @@ static const EVP_CIPHER *cryptodev_aes_192_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -789,9 +766,9 @@ static EVP_CIPHER *aes_256_cbc_cipher = NULL;
 static const EVP_CIPHER *cryptodev_aes_256_cbc(void)
 {
     if (aes_256_cbc_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_aes_256_cbc, 16, 32);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_aes_256_cbc, 16, 32)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 16)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CBC_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -799,9 +776,13 @@ static const EVP_CIPHER *cryptodev_aes_256_cbc(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -814,9 +795,9 @@ static EVP_CIPHER *aes_ctr_cipher = NULL;
 static const EVP_CIPHER *cryptodev_aes_ctr(void)
 {
     if (aes_ctr_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_aes_128_ctr, 16, 16);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_aes_128_ctr, 16, 16)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 14)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CTR_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -824,9 +805,13 @@ static const EVP_CIPHER *cryptodev_aes_ctr(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -839,9 +824,9 @@ static EVP_CIPHER *aes_192_ctr_cipher = NULL;
 static const EVP_CIPHER *cryptodev_aes_192_ctr(void)
 {
     if (aes_192_ctr_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_aes_192_ctr, 16, 24);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_aes_192_ctr, 16, 24)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 14)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CTR_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -849,9 +834,13 @@ static const EVP_CIPHER *cryptodev_aes_192_ctr(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -864,9 +853,9 @@ static EVP_CIPHER *aes_256_ctr_cipher = NULL;
 static const EVP_CIPHER *cryptodev_aes_256_ctr(void)
 {
     if (aes_256_ctr_cipher == NULL) {
-        EVP_CIPHER *cipher;
+        EVP_CIPHER *cipher = EVP_CIPHER_meth_new(NID_aes_256_ctr, 16, 32);
 
-        if ((cipher = EVP_CIPHER_meth_new(NID_aes_256_ctr, 16, 32)) == NULL
+        if (cipher == NULL
             || !EVP_CIPHER_meth_set_iv_length(cipher, 14)
             || !EVP_CIPHER_meth_set_flags(cipher, EVP_CIPH_CTR_MODE
                                           | EVP_CIPH_CUSTOM_COPY)
@@ -874,9 +863,13 @@ static const EVP_CIPHER *cryptodev_aes_256_ctr(void)
             || !EVP_CIPHER_meth_set_do_cipher(cipher, cryptodev_cipher)
             || !EVP_CIPHER_meth_set_cleanup(cipher, cryptodev_cleanup)
             || !EVP_CIPHER_meth_set_ctrl(cipher, cryptodev_cipher_ctrl)
-            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher, sizeof(struct dev_crypto_state))
-            || !EVP_CIPHER_meth_set_set_asn1_params(cipher, EVP_CIPHER_set_asn1_iv)
-            || !EVP_CIPHER_meth_set_get_asn1_params(cipher, EVP_CIPHER_get_asn1_iv)) {
+            || !EVP_CIPHER_meth_set_impl_ctx_size(cipher,
+                                                  sizeof(struct
+                                                         dev_crypto_state))
+            || !EVP_CIPHER_meth_set_set_asn1_params(cipher,
+                                                    EVP_CIPHER_set_asn1_iv)
+            || !EVP_CIPHER_meth_set_get_asn1_params(cipher,
+                                                    EVP_CIPHER_get_asn1_iv)) {
             EVP_CIPHER_meth_free(cipher);
             cipher = NULL;
         }
@@ -1095,8 +1088,7 @@ static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data,
 
     if (!EVP_MD_CTX_test_flags(ctx, EVP_MD_CTX_FLAG_ONESHOT)) {
         /* if application doesn't support one buffer */
-        new_mac_data =
-            OPENSSL_realloc(state->mac_data, state->mac_len + count);
+        new_mac_data = OPENSSL_realloc(state->mac_data, state->mac_len + count);
 
         if (!new_mac_data) {
             printf("cryptodev_digest_update: realloc failed\n");
@@ -1115,9 +1107,9 @@ static int cryptodev_digest_update(EVP_MD_CTX *ctx, const void *data,
     cryp.ses = sess->ses;
     cryp.flags = 0;
     cryp.len = count;
-    cryp.src = (void *) data;
+    cryp.src = (void *)data;
     cryp.dst = NULL;
-    cryp.mac = (void *) state->digest_res;
+    cryp.mac = (void *)state->digest_res;
     if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
         printf("cryptodev_digest_update: digest failed\n");
         return (0);
@@ -1144,7 +1136,7 @@ static int cryptodev_digest_final(EVP_MD_CTX *ctx, unsigned char *md)
         cryp.len = state->mac_len;
         cryp.src = state->mac_data;
         cryp.dst = NULL;
-        cryp.mac = (void *) md;
+        cryp.mac = (void *)md;
         if (ioctl(state->d_fd, CIOCCRYPT, &cryp) < 0) {
             printf("cryptodev_digest_final: digest failed\n");
             return (0);
@@ -1236,9 +1228,9 @@ static EVP_MD *sha1_md = NULL;
 static const EVP_MD *cryptodev_sha1(void)
 {
     if (sha1_md == NULL) {
-        EVP_MD *md;
+        EVP_MD *md = EVP_MD_meth_new(NID_sha1, NID_undef);
 
-        if ((md = EVP_MD_meth_new(NID_sha1, NID_undef)) == NULL
+        if (md == NULL
             || !EVP_MD_meth_set_result_size(md, SHA_DIGEST_LENGTH)
             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_ONESHOT)
             || !EVP_MD_meth_set_input_blocksize(md, SHA_CBLOCK)
@@ -1261,12 +1253,12 @@ static EVP_MD *sha256_md = NULL;
 static const EVP_MD *cryptodev_sha256(void)
 {
     if (sha256_md == NULL) {
-        EVP_MD *md;
+        EVP_MD *md = EVP_MD_meth_new(NID_sha256, NID_undef);
 
-        if ((md = EVP_MD_meth_new(NID_sha256, NID_undef)) == NULL
-            || !EVP_MD_meth_set_result_size(md, SHA_DIGEST_LENGTH)
+        if (md == NULL
+            || !EVP_MD_meth_set_result_size(md, SHA256_DIGEST_LENGTH)
             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_ONESHOT)
-            || !EVP_MD_meth_set_input_blocksize(md, SHA_CBLOCK)
+            || !EVP_MD_meth_set_input_blocksize(md, SHA256_CBLOCK)
             || !EVP_MD_meth_set_app_datasize(md,
                                              sizeof(struct dev_crypto_state))
             || !EVP_MD_meth_set_init(md, cryptodev_digest_init)
@@ -1286,12 +1278,12 @@ static EVP_MD *sha224_md = NULL;
 static const EVP_MD *cryptodev_sha224(void)
 {
     if (sha224_md == NULL) {
-        EVP_MD *md;
+        EVP_MD *md = EVP_MD_meth_new(NID_sha224, NID_undef);
 
-        if ((md = EVP_MD_meth_new(NID_sha224, NID_undef)) == NULL
-            || !EVP_MD_meth_set_result_size(md, SHA_DIGEST_LENGTH)
+        if (md == NULL
+            || !EVP_MD_meth_set_result_size(md, SHA224_DIGEST_LENGTH)
             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_ONESHOT)
-            || !EVP_MD_meth_set_input_blocksize(md, SHA_CBLOCK)
+            || !EVP_MD_meth_set_input_blocksize(md, SHA256_CBLOCK)
             || !EVP_MD_meth_set_app_datasize(md,
                                              sizeof(struct dev_crypto_state))
             || !EVP_MD_meth_set_init(md, cryptodev_digest_init)
@@ -1311,12 +1303,12 @@ static EVP_MD *sha384_md = NULL;
 static const EVP_MD *cryptodev_sha384(void)
 {
     if (sha384_md == NULL) {
-        EVP_MD *md;
+        EVP_MD *md = EVP_MD_meth_new(NID_sha384, NID_undef);
 
-        if ((md = EVP_MD_meth_new(NID_sha384, NID_undef)) == NULL
-            || !EVP_MD_meth_set_result_size(md, SHA_DIGEST_LENGTH)
+        if (md == NULL
+            || !EVP_MD_meth_set_result_size(md, SHA384_DIGEST_LENGTH)
             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_ONESHOT)
-            || !EVP_MD_meth_set_input_blocksize(md, SHA_CBLOCK)
+            || !EVP_MD_meth_set_input_blocksize(md, SHA512_CBLOCK)
             || !EVP_MD_meth_set_app_datasize(md,
                                              sizeof(struct dev_crypto_state))
             || !EVP_MD_meth_set_init(md, cryptodev_digest_init)
@@ -1336,12 +1328,12 @@ static EVP_MD *sha512_md = NULL;
 static const EVP_MD *cryptodev_sha512(void)
 {
     if (sha512_md == NULL) {
-        EVP_MD *md;
+        EVP_MD *md = EVP_MD_meth_new(NID_sha512, NID_undef);
 
-        if ((md = EVP_MD_meth_new(NID_sha512, NID_undef)) == NULL
-            || !EVP_MD_meth_set_result_size(md, SHA_DIGEST_LENGTH)
+        if (md == NULL
+            || !EVP_MD_meth_set_result_size(md, SHA512_DIGEST_LENGTH)
             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_ONESHOT)
-            || !EVP_MD_meth_set_input_blocksize(md, SHA_CBLOCK)
+            || !EVP_MD_meth_set_input_blocksize(md, SHA512_CBLOCK)
             || !EVP_MD_meth_set_app_datasize(md,
                                              sizeof(struct dev_crypto_state))
             || !EVP_MD_meth_set_init(md, cryptodev_digest_init)
@@ -1361,12 +1353,12 @@ static EVP_MD *md5_md = NULL;
 static const EVP_MD *cryptodev_md5(void)
 {
     if (md5_md == NULL) {
-        EVP_MD *md;
+        EVP_MD *md = EVP_MD_meth_new(NID_md5, NID_undef);
 
-        if ((md = EVP_MD_meth_new(NID_md5, NID_undef)) == NULL
-            || !EVP_MD_meth_set_result_size(md, 16 /* MD5_DIGEST_LENGTH */)
+        if (md == NULL
+            || !EVP_MD_meth_set_result_size(md, 16 /* MD5_DIGEST_LENGTH */ )
             || !EVP_MD_meth_set_flags(md, EVP_MD_FLAG_ONESHOT)
-            || !EVP_MD_meth_set_input_blocksize(md, 64 /* MD5_CBLOCK */)
+            || !EVP_MD_meth_set_input_blocksize(md, 64 /* MD5_CBLOCK */ )
             || !EVP_MD_meth_set_app_datasize(md,
                                              sizeof(struct dev_crypto_state))
             || !EVP_MD_meth_set_init(md, cryptodev_digest_init)
@@ -1498,7 +1490,7 @@ static int bn2crparam(const BIGNUM *a, struct crparam *crp)
     if (b == NULL)
         return (1);
 
-    crp->crp_p = (void *) b;
+    crp->crp_p = (void *)b;
     crp->crp_nbits = bits;
 
     BN_bn2bin(a, b);
@@ -1540,8 +1532,7 @@ static void zapparams(struct crypt_kop *kop)
 }
 
 static int
-cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM *r, int slen,
-               BIGNUM *s)
+cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM *r, int slen, BIGNUM *s)
 {
     int fd, ret = -1;
 
@@ -1556,13 +1547,12 @@ cryptodev_asym(struct crypt_kop *kop, int rlen, BIGNUM *r, int slen,
         kop->crk_oparams++;
     }
     if (s) {
-        kop->crk_param[kop->crk_iparams + 1].crp_p =
-            OPENSSL_zalloc(slen);
+        kop->crk_param[kop->crk_iparams + 1].crp_p = OPENSSL_zalloc(slen);
         /* No need to free the kop->crk_iparams parameter if it was allocated,
          * callers of this routine have to free allocated parameters through
          * zapparams both in case of success and failure
          */
-        if (kop->crk_param[kop->crk_iparams+1].crp_p == NULL)
+        if (kop->crk_param[kop->crk_iparams + 1].crp_p == NULL)
             return ret;
         kop->crk_param[kop->crk_iparams + 1].crp_nbits = slen * 8;
         kop->crk_oparams++;
@@ -1610,12 +1600,12 @@ cryptodev_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
     if (cryptodev_asym(&kop, BN_num_bytes(m), r, 0, NULL)) {
         const RSA_METHOD *meth = RSA_PKCS1_OpenSSL();
         printf("OCF asym process failed, Running in software\n");
-        ret = RSA_meth_get_bn_mod_exp(meth)(r, a, p, m, ctx, in_mont);
+        ret = RSA_meth_get_bn_mod_exp(meth) (r, a, p, m, ctx, in_mont);
 
     } else if (ECANCELED == kop.crk_status) {
         const RSA_METHOD *meth = RSA_PKCS1_OpenSSL();
         printf("OCF hardware operation cancelled. Running in Software\n");
-        ret = RSA_meth_get_bn_mod_exp(meth)(r, a, p, m, ctx, in_mont);
+        ret = RSA_meth_get_bn_mod_exp(meth) (r, a, p, m, ctx, in_mont);
     }
     /* else cryptodev operation worked ok ==> ret = 1 */
 
@@ -1625,8 +1615,7 @@ cryptodev_bn_mod_exp(BIGNUM *r, const BIGNUM *a, const BIGNUM *p,
 }
 
 static int
-cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa,
-                            BN_CTX *ctx)
+cryptodev_rsa_nocrt_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
 {
     int r;
     const BIGNUM *n = NULL;
@@ -1680,12 +1669,12 @@ cryptodev_rsa_mod_exp(BIGNUM *r0, const BIGNUM *I, RSA *rsa, BN_CTX *ctx)
     if (cryptodev_asym(&kop, BN_num_bytes(n), r0, 0, NULL)) {
         const RSA_METHOD *meth = RSA_PKCS1_OpenSSL();
         printf("OCF asym process failed, running in Software\n");
-        ret = RSA_meth_get_mod_exp(meth)(r0, I, rsa, ctx);
+        ret = RSA_meth_get_mod_exp(meth) (r0, I, rsa, ctx);
 
     } else if (ECANCELED == kop.crk_status) {
         const RSA_METHOD *meth = RSA_PKCS1_OpenSSL();
         printf("OCF hardware operation cancelled. Running in Software\n");
-        ret = RSA_meth_get_mod_exp(meth)(r0, I, rsa, ctx);
+        ret = RSA_meth_get_mod_exp(meth) (r0, I, rsa, ctx);
     }
     /* else cryptodev operation worked ok ==> ret = 1 */
 
@@ -1712,8 +1701,8 @@ cryptodev_dsa_dsa_mod_exp(DSA *dsa, BIGNUM *t1, const BIGNUM *g,
     BIGNUM *t2;
     int ret = 0;
     const DSA_METHOD *meth;
-    int (*bn_mod_exp)(DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *, const BIGNUM *,
-                      BN_CTX *, BN_MONT_CTX *);
+    int (*bn_mod_exp) (DSA *, BIGNUM *, const BIGNUM *, const BIGNUM *,
+                       const BIGNUM *, BN_CTX *, BN_MONT_CTX *);
 
     t2 = BN_new();
     if (t2 == NULL)
@@ -1766,7 +1755,7 @@ static DSA_SIG *cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen,
     kop.crk_op = CRK_DSA_SIGN;
 
     /* inputs: dgst dsa->p dsa->q dsa->g dsa->priv_key */
-    kop.crk_param[0].crp_p = (void *) dgst;
+    kop.crk_param[0].crp_p = (void *)dgst;
     kop.crk_param[0].crp_nbits = dlen * 8;
     DSA_get0_pqg(dsa, &dsap, &dsaq, &dsag);
     DSA_get0_key(dsa, NULL, &priv_key);
@@ -1786,8 +1775,7 @@ static DSA_SIG *cryptodev_dsa_do_sign(const unsigned char *dgst, int dlen,
     s = BN_new();
     if (s == NULL)
         goto err;
-    if (cryptodev_asym(&kop, BN_num_bytes(dsaq), r,
-                       BN_num_bytes(dsaq), s) == 0) {
+    if (cryptodev_asym(&kop, BN_num_bytes(dsaq), r, BN_num_bytes(dsaq), s) == 0) {
         DSA_SIG_set0(dsasig, r, s);
         dsaret = dsasig;
     } else {
@@ -1813,7 +1801,7 @@ cryptodev_dsa_verify(const unsigned char *dgst, int dlen,
     kop.crk_op = CRK_DSA_VERIFY;
 
     /* inputs: dgst dsa->p dsa->q dsa->g dsa->pub_key sig->r sig->s */
-    kop.crk_param[0].crp_p = (void *) dgst;
+    kop.crk_param[0].crp_p = (void *)dgst;
     kop.crk_param[0].crp_nbits = dlen * 8;
     DSA_get0_pqg(dsa, &p, &q, &g);
     if (bn2crparam(p, &kop.crk_param[1]))
@@ -1869,7 +1857,7 @@ cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
     if ((fd = get_asym_dev_crypto()) < 0) {
         const DH_METHOD *meth = DH_OpenSSL();
 
-        return DH_meth_get_compute_key(meth)(key, pub_key, dh);
+        return DH_meth_get_compute_key(meth) (key, pub_key, dh);
     }
 
     DH_get0_pqg(dh, &p, NULL, NULL);
@@ -1889,14 +1877,14 @@ cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
         goto err;
     kop.crk_iparams = 3;
 
-    kop.crk_param[3].crp_p = (void *) key;
-    kop.crk_param[3].crp_nbits = keylen * 8;
+    kop.crk_param[3].crp_p = (void *)key;
+    kop.crk_param[3].crp_nbits = keylen;
     kop.crk_oparams = 1;
 
     if (ioctl(fd, CIOCKEY, &kop) == -1) {
         const DH_METHOD *meth = DH_OpenSSL();
 
-        dhret = DH_meth_get_compute_key(meth)(key, pub_key, dh);
+        dhret = DH_meth_get_compute_key(meth) (key, pub_key, dh);
     }
  err:
     kop.crk_param[3].crp_p = NULL;
@@ -1904,14 +1892,13 @@ cryptodev_dh_compute_key(unsigned char *key, const BIGNUM *pub_key, DH *dh)
     return (dhret);
 }
 
-# endif /* ndef OPENSSL_NO_DH */
+# endif                         /* ndef OPENSSL_NO_DH */
 
 /*
  * ctrl right now is just a wrapper that doesn't do much
  * but I expect we'll want some options soon.
  */
-static int
-cryptodev_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
+static int cryptodev_ctrl(ENGINE *e, int cmd, long i, void *p, void (*f) (void))
 {
 # ifdef HAVE_SYSLOG_R
     struct syslog_data sd = SYSLOG_DATA_INIT;