KNF.

1 files changed, 136 insertions, 143 deletions

diff --git a/src/lib/libcrypto/evp/pmeth_fn.c b/src/lib/libcrypto/evp/pmeth_fn.c
index c4676f2f8d..12dd9e26a1 100644
--- a/src/lib/libcrypto/evp/pmeth_fn.c
+++ b/src/lib/libcrypto/evp/pmeth_fn.c
@@ -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
@@ -79,15 +79,16 @@
                         } \
                 }
 
-int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
-        {
+int
+EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->sign)
-                {
+
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->sign) {
                 EVPerr(EVP_F_EVP_PKEY_SIGN_INIT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
+        }
         ctx->operation = EVP_PKEY_OP_SIGN;
         if (!ctx->pmeth->sign_init)
                 return 1;
@@ -95,36 +96,35 @@ int EVP_PKEY_sign_init(EVP_PKEY_CTX *ctx)
         if (ret <= 0)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
-        }
+}
 
-int EVP_PKEY_sign(EVP_PKEY_CTX *ctx,
-                        unsigned char *sig, size_t *siglen,
-                        const unsigned char *tbs, size_t tbslen)
-        {
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->sign)
-                {
+int
+EVP_PKEY_sign(EVP_PKEY_CTX *ctx, unsigned char *sig, size_t *siglen,
+    const unsigned char *tbs, size_t tbslen)
+{
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->sign) {
                 EVPerr(EVP_F_EVP_PKEY_SIGN,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_SIGN)
-                {
+        }
+        if (ctx->operation != EVP_PKEY_OP_SIGN) {
                 EVPerr(EVP_F_EVP_PKEY_SIGN, EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
+        }
         M_check_autoarg(ctx, sig, siglen, EVP_F_EVP_PKEY_SIGN)
         return ctx->pmeth->sign(ctx, sig, siglen, tbs, tbslen);
-        }
+}
 
-int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
-        {
+int
+EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify)
-                {
+
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify) {
                 EVPerr(EVP_F_EVP_PKEY_VERIFY_INIT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
+        }
         ctx->operation = EVP_PKEY_OP_VERIFY;
         if (!ctx->pmeth->verify_init)
                 return 1;
@@ -132,35 +132,34 @@ int EVP_PKEY_verify_init(EVP_PKEY_CTX *ctx)
         if (ret <= 0)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
-        }
+}
 
-int EVP_PKEY_verify(EVP_PKEY_CTX *ctx,
-                        const unsigned char *sig, size_t siglen,
-                        const unsigned char *tbs, size_t tbslen)
-        {
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify)
-                {
+int
+EVP_PKEY_verify(EVP_PKEY_CTX *ctx, const unsigned char *sig, size_t siglen,
+    const unsigned char *tbs, size_t tbslen)
+{
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify) {
                 EVPerr(EVP_F_EVP_PKEY_VERIFY,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_VERIFY)
-                {
+        }
+        if (ctx->operation != EVP_PKEY_OP_VERIFY) {
                 EVPerr(EVP_F_EVP_PKEY_VERIFY, EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
-        return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen);
         }
+        return ctx->pmeth->verify(ctx, sig, siglen, tbs, tbslen);
+}
 
-int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
-        {
+int
+EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover)
-                {
+
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover) {
                 EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER_INIT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
+        }
         ctx->operation = EVP_PKEY_OP_VERIFYRECOVER;
         if (!ctx->pmeth->verify_recover_init)
                 return 1;
@@ -168,36 +167,36 @@ int EVP_PKEY_verify_recover_init(EVP_PKEY_CTX *ctx)
         if (ret <= 0)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
-        }
+}
 
-int EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx,
-                        unsigned char *rout, size_t *routlen,
-                        const unsigned char *sig, size_t siglen)
-        {
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover)
-                {
+int
+EVP_PKEY_verify_recover(EVP_PKEY_CTX *ctx, unsigned char *rout, size_t *routlen,
+    const unsigned char *sig, size_t siglen)
+{
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->verify_recover) {
                 EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_VERIFYRECOVER)
-                {
-                EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER, EVP_R_OPERATON_NOT_INITIALIZED);
+        }
+        if (ctx->operation != EVP_PKEY_OP_VERIFYRECOVER) {
+                EVPerr(EVP_F_EVP_PKEY_VERIFY_RECOVER,
+                    EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
+        }
         M_check_autoarg(ctx, rout, routlen, EVP_F_EVP_PKEY_VERIFY_RECOVER)
         return ctx->pmeth->verify_recover(ctx, rout, routlen, sig, siglen);
-        }
+}
 
-int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
-        {
+int
+EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt)
-                {
+
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt) {
                 EVPerr(EVP_F_EVP_PKEY_ENCRYPT_INIT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
+        }
         ctx->operation = EVP_PKEY_OP_ENCRYPT;
         if (!ctx->pmeth->encrypt_init)
                 return 1;
@@ -205,36 +204,35 @@ int EVP_PKEY_encrypt_init(EVP_PKEY_CTX *ctx)
         if (ret <= 0)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
-        }
+}
 
-int EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx,
-                        unsigned char *out, size_t *outlen,
-                        const unsigned char *in, size_t inlen)
-        {
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt)
-                {
+int
+EVP_PKEY_encrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+    const unsigned char *in, size_t inlen)
+{
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->encrypt) {
                 EVPerr(EVP_F_EVP_PKEY_ENCRYPT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_ENCRYPT)
-                {
+        }
+        if (ctx->operation != EVP_PKEY_OP_ENCRYPT) {
                 EVPerr(EVP_F_EVP_PKEY_ENCRYPT, EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
+        }
         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_ENCRYPT)
         return ctx->pmeth->encrypt(ctx, out, outlen, in, inlen);
-        }
+}
 
-int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
-        {
+int
+EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt)
-                {
+
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt) {
                 EVPerr(EVP_F_EVP_PKEY_DECRYPT_INIT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
+        }
         ctx->operation = EVP_PKEY_OP_DECRYPT;
         if (!ctx->pmeth->decrypt_init)
                 return 1;
@@ -242,37 +240,35 @@ int EVP_PKEY_decrypt_init(EVP_PKEY_CTX *ctx)
         if (ret <= 0)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
-        }
+}
 
-int EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx,
-                        unsigned char *out, size_t *outlen,
-                        const unsigned char *in, size_t inlen)
-        {
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt)
-                {
+int
+EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, unsigned char *out, size_t *outlen,
+    const unsigned char *in, size_t inlen)
+{
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->decrypt) {
                 EVPerr(EVP_F_EVP_PKEY_DECRYPT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_DECRYPT)
-                {
+        }
+        if (ctx->operation != EVP_PKEY_OP_DECRYPT) {
                 EVPerr(EVP_F_EVP_PKEY_DECRYPT, EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
+        }
         M_check_autoarg(ctx, out, outlen, EVP_F_EVP_PKEY_DECRYPT)
         return ctx->pmeth->decrypt(ctx, out, outlen, in, inlen);
-        }
+}
 
-
-int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
-        {
+int
+EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->derive)
-                {
+
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->derive) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE_INIT,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
+        }
         ctx->operation = EVP_PKEY_OP_DERIVE;
         if (!ctx->pmeth->derive_init)
                 return 1;
@@ -280,23 +276,27 @@ int EVP_PKEY_derive_init(EVP_PKEY_CTX *ctx)
         if (ret <= 0)
                 ctx->operation = EVP_PKEY_OP_UNDEFINED;
         return ret;
-        }
+}
 
-int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
-        {
+int
+EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
+{
         int ret;
-        if (!ctx || !ctx->pmeth || !(ctx->pmeth->derive||ctx->pmeth->encrypt||ctx->pmeth->decrypt) || !ctx->pmeth->ctrl)
-                {
+
+        if (!ctx || !ctx->pmeth || !(ctx->pmeth->derive ||
+            ctx->pmeth->encrypt || ctx->pmeth->decrypt) ||
+            !ctx->pmeth->ctrl) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_DERIVE && ctx->operation != EVP_PKEY_OP_ENCRYPT && ctx->operation != EVP_PKEY_OP_DECRYPT)
-                {
+        }
+        if (ctx->operation != EVP_PKEY_OP_DERIVE &&
+            ctx->operation != EVP_PKEY_OP_ENCRYPT &&
+            ctx->operation != EVP_PKEY_OP_DECRYPT) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                                        EVP_R_OPERATON_NOT_INITIALIZED);
+                    EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
+        }
 
         ret = ctx->pmeth->ctrl(ctx, EVP_PKEY_CTRL_PEER_KEY, 0, peer);
 
@@ -306,18 +306,16 @@ int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
         if (ret == 2)
                 return 1;
 
-        if (!ctx->pkey)
-                {
+        if (!ctx->pkey) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER, EVP_R_NO_KEY_SET);
                 return -1;
-                }
+        }
 
-        if (ctx->pkey->type != peer->type)
-                {
+        if (ctx->pkey->type != peer->type) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                                                EVP_R_DIFFERENT_KEY_TYPES);
+                    EVP_R_DIFFERENT_KEY_TYPES);
                 return -1;
-                }
+        }
 
         /* ran@cryptocom.ru: For clarity.  The error is if parameters in peer are
          * present (!missing) but don't match.  EVP_PKEY_cmp_parameters may return
@@ -325,12 +323,11 @@ int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
          * (different key types) is impossible here because it is checked earlier.
          * -2 is OK for us here, as well as 1, so we can check for 0 only. */
         if (!EVP_PKEY_missing_parameters(peer) &&
-                !EVP_PKEY_cmp_parameters(ctx->pkey, peer))
-                {
+            !EVP_PKEY_cmp_parameters(ctx->pkey, peer)) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE_SET_PEER,
-                                                EVP_R_DIFFERENT_PARAMETERS);
+                    EVP_R_DIFFERENT_PARAMETERS);
                 return -1;
-                }
+        }
 
         if (ctx->peerkey)
                 EVP_PKEY_free(ctx->peerkey);
@@ -338,31 +335,27 @@ int EVP_PKEY_derive_set_peer(EVP_PKEY_CTX *ctx, EVP_PKEY *peer)
 
         ret = ctx->pmeth->ctrl(ctx, EVP_PKEY_CTRL_PEER_KEY, 1, peer);
 
-        if (ret <= 0)
-                {
+        if (ret <= 0) {
                 ctx->peerkey = NULL;
                 return ret;
-                }
-
-        CRYPTO_add(&peer->references,1,CRYPTO_LOCK_EVP_PKEY);
-        return 1;
         }
 
+        CRYPTO_add(&peer->references, 1, CRYPTO_LOCK_EVP_PKEY);
+        return 1;
+}
 
-int EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *pkeylen)
-        {
-        if (!ctx || !ctx->pmeth || !ctx->pmeth->derive)
-                {
+int
+EVP_PKEY_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *pkeylen)
+{
+        if (!ctx || !ctx->pmeth || !ctx->pmeth->derive) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE,
-                        EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
+                    EVP_R_OPERATION_NOT_SUPPORTED_FOR_THIS_KEYTYPE);
                 return -2;
-                }
-        if (ctx->operation != EVP_PKEY_OP_DERIVE)
-                {
+        }
+        if (ctx->operation != EVP_PKEY_OP_DERIVE) {
                 EVPerr(EVP_F_EVP_PKEY_DERIVE, EVP_R_OPERATON_NOT_INITIALIZED);
                 return -1;
-                }
+        }
         M_check_autoarg(ctx, key, pkeylen, EVP_F_EVP_PKEY_DERIVE)
         return ctx->pmeth->derive(ctx, key, pkeylen);
-        }
-
+}