KNF.

1 files changed, 77 insertions, 80 deletions

diff --git a/src/lib/libcrypto/engine/eng_pkey.c b/src/lib/libcrypto/engine/eng_pkey.c
index 410a9c3373..dc832450a6 100644
--- a/src/lib/libcrypto/engine/eng_pkey.c
+++ b/src/lib/libcrypto/engine/eng_pkey.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: eng_pkey.c,v 1.4 2014/06/12 15:49:29 deraadt Exp $ */
+/* $OpenBSD: eng_pkey.c,v 1.5 2014/06/22 12:05:09 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2001 The OpenSSL Project.  All rights reserved.
  *
@@ -7,7 +7,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
@@ -57,140 +57,137 @@
 
 /* Basic get/set stuff */
 
-int ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f)
-        {
+int
+ENGINE_set_load_privkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpriv_f)
+{
         e->load_privkey = loadpriv_f;
         return 1;
-        }
+}
 
-int ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f)
-        {
+int
+ENGINE_set_load_pubkey_function(ENGINE *e, ENGINE_LOAD_KEY_PTR loadpub_f)
+{
         e->load_pubkey = loadpub_f;
         return 1;
-        }
+}
 
-int ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
-                                ENGINE_SSL_CLIENT_CERT_PTR loadssl_f)
-        {
+int
+ENGINE_set_load_ssl_client_cert_function(ENGINE *e,
+    ENGINE_SSL_CLIENT_CERT_PTR loadssl_f)
+{
         e->load_ssl_client_cert = loadssl_f;
         return 1;
-        }
+}
 
-ENGINE_LOAD_KEY_PTR ENGINE_get_load_privkey_function(const ENGINE *e)
-        {
+ENGINE_LOAD_KEY_PTR
+ENGINE_get_load_privkey_function(const ENGINE *e)
+{
         return e->load_privkey;
-        }
+}
 
-ENGINE_LOAD_KEY_PTR ENGINE_get_load_pubkey_function(const ENGINE *e)
-        {
+ENGINE_LOAD_KEY_PTR
+ENGINE_get_load_pubkey_function(const ENGINE *e)
+{
         return e->load_pubkey;
-        }
+}
 
-ENGINE_SSL_CLIENT_CERT_PTR ENGINE_get_ssl_client_cert_function(const ENGINE *e)
-        {
+ENGINE_SSL_CLIENT_CERT_PTR
+ENGINE_get_ssl_client_cert_function(const ENGINE *e)
+{
         return e->load_ssl_client_cert;
-        }
+}
 
 /* API functions to load public/private keys */
 
-EVP_PKEY *ENGINE_load_private_key(ENGINE *e, const char *key_id,
-        UI_METHOD *ui_method, void *callback_data)
-        {
+EVP_PKEY *
+ENGINE_load_private_key(ENGINE *e, const char *key_id, UI_METHOD *ui_method,
+    void *callback_data)
+{
         EVP_PKEY *pkey;
 
-        if(e == NULL)
-                {
+        if (e == NULL) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
-                        ERR_R_PASSED_NULL_PARAMETER);
+                    ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
-                }
+        }
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-        if(e->funct_ref == 0)
-                {
+        if (e->funct_ref == 0) {
                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
-                        ENGINE_R_NOT_INITIALISED);
+                    ENGINE_R_NOT_INITIALISED);
                 return 0;
-                }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
-        if (!e->load_privkey)
-                {
+        if (!e->load_privkey) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
-                        ENGINE_R_NO_LOAD_FUNCTION);
+                    ENGINE_R_NO_LOAD_FUNCTION);
                 return 0;
-                }
+        }
         pkey = e->load_privkey(e, key_id, ui_method, callback_data);
-        if (!pkey)
-                {
+        if (!pkey) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PRIVATE_KEY,
-                        ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
+                    ENGINE_R_FAILED_LOADING_PRIVATE_KEY);
                 return 0;
-                }
-        return pkey;
         }
+        return pkey;
+}
 
-EVP_PKEY *ENGINE_load_public_key(ENGINE *e, const char *key_id,
-        UI_METHOD *ui_method, void *callback_data)
-        {
+EVP_PKEY *
+ENGINE_load_public_key(ENGINE *e, const char *key_id, UI_METHOD *ui_method,
+    void *callback_data)
+{
         EVP_PKEY *pkey;
 
-        if(e == NULL)
-                {
+        if (e == NULL) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
-                        ERR_R_PASSED_NULL_PARAMETER);
+                    ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
-                }
+        }
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-        if(e->funct_ref == 0)
-                {
+        if (e->funct_ref == 0) {
                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
-                        ENGINE_R_NOT_INITIALISED);
+                    ENGINE_R_NOT_INITIALISED);
                 return 0;
-                }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
-        if (!e->load_pubkey)
-                {
+        if (!e->load_pubkey) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
-                        ENGINE_R_NO_LOAD_FUNCTION);
+                    ENGINE_R_NO_LOAD_FUNCTION);
                 return 0;
-                }
+        }
         pkey = e->load_pubkey(e, key_id, ui_method, callback_data);
-        if (!pkey)
-                {
+        if (!pkey) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_PUBLIC_KEY,
-                        ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
+                    ENGINE_R_FAILED_LOADING_PUBLIC_KEY);
                 return 0;
-                }
-        return pkey;
         }
+        return pkey;
+}
 
-int ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s,
-        STACK_OF(X509_NAME) *ca_dn, X509 **pcert, EVP_PKEY **ppkey,
-        STACK_OF(X509) **pother, UI_METHOD *ui_method, void *callback_data)
-        {
-
-        if(e == NULL)
-                {
+int
+ENGINE_load_ssl_client_cert(ENGINE *e, SSL *s, STACK_OF(X509_NAME) *ca_dn,
+    X509 **pcert, EVP_PKEY **ppkey, STACK_OF(X509) **pother,
+    UI_METHOD *ui_method, void *callback_data)
+{
+        if (e == NULL) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT,
-                        ERR_R_PASSED_NULL_PARAMETER);
+                    ERR_R_PASSED_NULL_PARAMETER);
                 return 0;
-                }
+        }
         CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-        if(e->funct_ref == 0)
-                {
+        if (e->funct_ref == 0) {
                 CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT,
-                        ENGINE_R_NOT_INITIALISED);
+                    ENGINE_R_NOT_INITIALISED);
                 return 0;
-                }
+        }
         CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
-        if (!e->load_ssl_client_cert)
-                {
+        if (!e->load_ssl_client_cert) {
                 ENGINEerr(ENGINE_F_ENGINE_LOAD_SSL_CLIENT_CERT,
-                        ENGINE_R_NO_LOAD_FUNCTION);
+                    ENGINE_R_NO_LOAD_FUNCTION);
                 return 0;
-                }
-        return e->load_ssl_client_cert(e, s, ca_dn, pcert, ppkey, pother,
-                                        ui_method, callback_data);
         }
+        return e->load_ssl_client_cert(e, s, ca_dn, pcert, ppkey, pother,
+            ui_method, callback_data);
+}