From 809e924b0ceda14722deaae701cea2d9ca6d9ff4 Mon Sep 17 00:00:00 2001
From: jsing <>
Date: Wed, 7 May 2014 17:42:51 +0000
Subject: KNF.

---
 src/lib/libcrypto/evp/pmeth_fn.c | 279 +++++++++++++++++++--------------------
 1 file changed, 136 insertions(+), 143 deletions(-)

(limited to 'src/lib/libcrypto/evp/pmeth_fn.c')

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);
-	}
-
+}
-- 
cgit v1.2.3-55-g6feb