KNF.

1 files changed, 50 insertions, 35 deletions

diff --git a/src/lib/libcrypto/pkcs12/p12_decr.c b/src/lib/libcrypto/pkcs12/p12_decr.c
index 01fe24835f..577bb06f80 100644
--- a/src/lib/libcrypto/pkcs12/p12_decr.c
+++ b/src/lib/libcrypto/pkcs12/p12_decr.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_decr.c,v 1.10 2014/06/12 15:49:30 deraadt Exp $ */
+/* $OpenBSD: p12_decr.c,v 1.11 2014/07/08 09:24:53 jsing Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -10,7 +10,7 @@
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer. 
+ *    notice, this list of conditions and the following disclaimer.
  *
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in
@@ -68,9 +68,9 @@
  * malloc'ed buffer
  */
 
-unsigned char * PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass,
-             int passlen, unsigned char *in, int inlen, unsigned char **data,
-             int *datalen, int en_de)
+unsigned char *
+PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass, int passlen,
+    unsigned char *in, int inlen, unsigned char **data, int *datalen, int en_de)
 {
         unsigned char *out;
         int outlen, i;
@@ -78,47 +78,52 @@ unsigned char * PKCS12_pbe_crypt(X509_ALGOR *algor, const char *pass,
 
         EVP_CIPHER_CTX_init(&ctx);
         /* Decrypt data */
-        if (!EVP_PBE_CipherInit(algor->algorithm, pass, passlen,
-                                         algor->parameter, &ctx, en_de)) {
-                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR);
+        if (!EVP_PBE_CipherInit(algor->algorithm, pass, passlen,
+            algor->parameter, &ctx, en_de)) {
+                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,
+                    PKCS12_R_PKCS12_ALGOR_CIPHERINIT_ERROR);
                 return NULL;
         }
 
-        if(!(out = malloc(inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
-                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,ERR_R_MALLOC_FAILURE);
+        if (!(out = malloc(inlen + EVP_CIPHER_CTX_block_size(&ctx)))) {
+                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT, ERR_R_MALLOC_FAILURE);
                 goto err;
         }
 
-        if (!EVP_CipherUpdate(&ctx, out, &i, in, inlen))
-                {
+        if (!EVP_CipherUpdate(&ctx, out, &i, in, inlen)) {
                 free(out);
                 out = NULL;
-                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,ERR_R_EVP_LIB);
+                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT, ERR_R_EVP_LIB);
                 goto err;
-                }
+        }
 
         outlen = i;
-        if(!EVP_CipherFinal_ex(&ctx, out + i, &i)) {
+        if (!EVP_CipherFinal_ex(&ctx, out + i, &i)) {
                 free(out);
                 out = NULL;
-                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,PKCS12_R_PKCS12_CIPHERFINAL_ERROR);
+                PKCS12err(PKCS12_F_PKCS12_PBE_CRYPT,
+                    PKCS12_R_PKCS12_CIPHERFINAL_ERROR);
                 goto err;
         }
         outlen += i;
-        if (datalen) *datalen = outlen;
-        if (data) *data = out;
-        err:
+        if (datalen)
+                *datalen = outlen;
+        if (data)
+                *data = out;
+
+err:
         EVP_CIPHER_CTX_cleanup(&ctx);
         return out;
 
 }
 
-/* Decrypt an OCTET STRING and decode ASN1 structure 
+/* Decrypt an OCTET STRING and decode ASN1 structure
  * if zbuf set zero buffer after use.
  */
 
-void * PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it,
-             const char *pass, int passlen, ASN1_OCTET_STRING *oct, int zbuf)
+void *
+PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it,
+    const char *pass, int passlen, ASN1_OCTET_STRING *oct, int zbuf)
 {
         unsigned char *out;
         const unsigned char *p;
@@ -126,8 +131,9 @@ void * PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it,
         int outlen;
 
         if (!PKCS12_pbe_crypt(algor, pass, passlen, oct->data, oct->length,
-                               &out, &outlen, 0)) {
-                PKCS12err(PKCS12_F_PKCS12_ITEM_DECRYPT_D2I,PKCS12_R_PKCS12_PBE_CRYPT_ERROR);
+            &out, &outlen, 0)) {
+                PKCS12err(PKCS12_F_PKCS12_ITEM_DECRYPT_D2I,
+                    PKCS12_R_PKCS12_PBE_CRYPT_ERROR);
                 return NULL;
         }
         p = out;
@@ -144,39 +150,48 @@ void * PKCS12_item_decrypt_d2i(X509_ALGOR *algor, const ASN1_ITEM *it,
         }
 #endif
         ret = ASN1_item_d2i(NULL, &p, outlen, it);
-        if (zbuf) OPENSSL_cleanse(out, outlen);
-        if(!ret) PKCS12err(PKCS12_F_PKCS12_ITEM_DECRYPT_D2I,PKCS12_R_DECODE_ERROR);
+        if (zbuf)
+                OPENSSL_cleanse(out, outlen);
+        if (!ret)
+                PKCS12err(PKCS12_F_PKCS12_ITEM_DECRYPT_D2I,
+                    PKCS12_R_DECODE_ERROR);
         free(out);
         return ret;
 }
 
-/* Encode ASN1 structure and encrypt, return OCTET STRING 
+/* Encode ASN1 structure and encrypt, return OCTET STRING
  * if zbuf set zero encoding.
  */
 
-ASN1_OCTET_STRING *PKCS12_item_i2d_encrypt(X509_ALGOR *algor, const ASN1_ITEM *it,
-                                       const char *pass, int passlen,
-                                       void *obj, int zbuf)
+ASN1_OCTET_STRING *
+PKCS12_item_i2d_encrypt(X509_ALGOR *algor, const ASN1_ITEM *it,
+    const char *pass, int passlen,
+    void *obj, int zbuf)
 {
         ASN1_OCTET_STRING *oct;
         unsigned char *in = NULL;
         int inlen;
+
         if (!(oct = M_ASN1_OCTET_STRING_new ())) {
-                PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,ERR_R_MALLOC_FAILURE);
+                PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,
+                    ERR_R_MALLOC_FAILURE);
                 return NULL;
         }
         inlen = ASN1_item_i2d(obj, &in, it);
         if (!in) {
-                PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,PKCS12_R_ENCODE_ERROR);
+                PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,
+                    PKCS12_R_ENCODE_ERROR);
                 return NULL;
         }
         if (!PKCS12_pbe_crypt(algor, pass, passlen, in, inlen, &oct->data,
-                                 &oct->length, 1)) {
-                PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,PKCS12_R_ENCRYPT_ERROR);
+            &oct->length, 1)) {
+                PKCS12err(PKCS12_F_PKCS12_ITEM_I2D_ENCRYPT,
+                    PKCS12_R_ENCRYPT_ERROR);
                 free(in);
                 return NULL;
         }
-        if (zbuf) OPENSSL_cleanse(in, inlen);
+        if (zbuf)
+                OPENSSL_cleanse(in, inlen);
         free(in);
         return oct;
 }