From 76145303a8345eadeb8eb36e46f50b090c9770b6 Mon Sep 17 00:00:00 2001
From: jsing <>
Date: Sun, 22 Jun 2014 12:05:09 +0000
Subject: KNF.

---
 src/lib/libcrypto/engine/eng_table.c | 258 ++++++++++++++++++-----------------
 1 file changed, 130 insertions(+), 128 deletions(-)

(limited to 'src/lib/libcrypto/engine/eng_table.c')

diff --git a/src/lib/libcrypto/engine/eng_table.c b/src/lib/libcrypto/engine/eng_table.c
index 5781af1eb9..44f3e892b8 100644
--- a/src/lib/libcrypto/engine/eng_table.c
+++ b/src/lib/libcrypto/engine/eng_table.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: eng_table.c,v 1.5 2014/06/12 15:49:29 deraadt Exp $ */
+/* $OpenBSD: eng_table.c,v 1.6 2014/06/22 12:05:09 jsing Exp $ */
 /* ====================================================================
  * Copyright (c) 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
@@ -59,8 +59,7 @@
 #include "eng_int.h"
 
 /* The type of the items in the table */
-typedef struct st_engine_pile
-	{
+typedef struct st_engine_pile {
 	/* The 'nid' of this algorithm/mode */
 	int nid;
 	/* ENGINEs that implement this algorithm/mode. */
@@ -69,284 +68,287 @@ typedef struct st_engine_pile
 	ENGINE *funct;
 	/* Zero if 'sk' is newer than the cached 'funct', non-zero otherwise */
 	int uptodate;
-	} ENGINE_PILE;
+} ENGINE_PILE;
 
 DECLARE_LHASH_OF(ENGINE_PILE);
 
 /* The type exposed in eng_int.h */
-struct st_engine_table
-	{
+struct st_engine_table {
 	LHASH_OF(ENGINE_PILE) piles;
-	}; /* ENGINE_TABLE */
+}; /* ENGINE_TABLE */
 
-
-typedef struct st_engine_pile_doall
-	{
+typedef struct st_engine_pile_doall {
 	engine_table_doall_cb *cb;
 	void *arg;
-	} ENGINE_PILE_DOALL;
-	
+} ENGINE_PILE_DOALL;
 
 /* Global flags (ENGINE_TABLE_FLAG_***). */
 static unsigned int table_flags = 0;
 
 /* API function manipulating 'table_flags' */
-unsigned int ENGINE_get_table_flags(void)
-	{
+unsigned int
+ENGINE_get_table_flags(void)
+{
 	return table_flags;
-	}
+}
 
-void ENGINE_set_table_flags(unsigned int flags)
-	{
+void
+ENGINE_set_table_flags(unsigned int flags)
+{
 	table_flags = flags;
-	}
+}
 
 /* Internal functions for the "piles" hash table */
-static unsigned long engine_pile_hash(const ENGINE_PILE *c)
-	{
+static unsigned long
+engine_pile_hash(const ENGINE_PILE *c)
+{
 	return c->nid;
-	}
+}
 
-static int engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
-	{
+static int
+engine_pile_cmp(const ENGINE_PILE *a, const ENGINE_PILE *b)
+{
 	return a->nid - b->nid;
-	}
+}
 static IMPLEMENT_LHASH_HASH_FN(engine_pile, ENGINE_PILE)
 static IMPLEMENT_LHASH_COMP_FN(engine_pile, ENGINE_PILE)
 
-static int int_table_check(ENGINE_TABLE **t, int create)
-	{
+static int
+int_table_check(ENGINE_TABLE **t, int create)
+{
 	LHASH_OF(ENGINE_PILE) *lh;
 
-	if(*t) return 1;
-	if(!create) return 0;
-	if((lh = lh_ENGINE_PILE_new()) == NULL)
+	if (*t)
+		return 1;
+	if (!create)
+		return 0;
+	if ((lh = lh_ENGINE_PILE_new()) == NULL)
 		return 0;
 	*t = (ENGINE_TABLE *)lh;
 	return 1;
-	}
+}
 
 /* Privately exposed (via eng_int.h) functions for adding and/or removing
  * ENGINEs from the implementation table */
-int engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
-		ENGINE *e, const int *nids, int num_nids, int setdefault)
-	{
+int
+engine_table_register(ENGINE_TABLE **table, ENGINE_CLEANUP_CB *cleanup,
+    ENGINE *e, const int *nids, int num_nids, int setdefault)
+{
 	int ret = 0, added = 0;
 	ENGINE_PILE tmplate, *fnd;
+
 	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-	if(!(*table))
+	if (!(*table))
 		added = 1;
-	if(!int_table_check(table, 1))
+	if (!int_table_check(table, 1))
 		goto end;
-	if(added)
+	if (added)
 		/* The cleanup callback needs to be added */
 		engine_cleanup_add_first(cleanup);
-	while(num_nids--)
-		{
+	while (num_nids--) {
 		tmplate.nid = *nids;
 		fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
-		if(!fnd)
-			{
+		if (!fnd) {
 			fnd = malloc(sizeof(ENGINE_PILE));
-			if(!fnd) goto end;
+			if (!fnd)
+				goto end;
 			fnd->uptodate = 1;
 			fnd->nid = *nids;
 			fnd->sk = sk_ENGINE_new_null();
-			if(!fnd->sk)
-				{
+			if (!fnd->sk) {
 				free(fnd);
 				goto end;
-				}
+			}
 			fnd->funct = NULL;
 			(void)lh_ENGINE_PILE_insert(&(*table)->piles, fnd);
-			}
+		}
 		/* A registration shouldn't add duplciate entries */
 		(void)sk_ENGINE_delete_ptr(fnd->sk, e);
 		/* if 'setdefault', this ENGINE goes to the head of the list */
-		if(!sk_ENGINE_push(fnd->sk, e))
+		if (!sk_ENGINE_push(fnd->sk, e))
 			goto end;
 		/* "touch" this ENGINE_PILE */
 		fnd->uptodate = 0;
-		if(setdefault)
-			{
-			if(!engine_unlocked_init(e))
-				{
+		if (setdefault) {
+			if (!engine_unlocked_init(e)) {
 				ENGINEerr(ENGINE_F_ENGINE_TABLE_REGISTER,
-						ENGINE_R_INIT_FAILED);
+				    ENGINE_R_INIT_FAILED);
 				goto end;
-				}
-			if(fnd->funct)
+			}
+			if (fnd->funct)
 				engine_unlocked_finish(fnd->funct, 0);
 			fnd->funct = e;
 			fnd->uptodate = 1;
-			}
-		nids++;
 		}
+		nids++;
+	}
 	ret = 1;
 end:
 	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 	return ret;
-	}
-static void int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e)
-	{
+}
+
+static void
+int_unregister_cb_doall_arg(ENGINE_PILE *pile, ENGINE *e)
+{
 	int n;
+
 	/* Iterate the 'c->sk' stack removing any occurance of 'e' */
-	while((n = sk_ENGINE_find(pile->sk, e)) >= 0)
-		{
+	while ((n = sk_ENGINE_find(pile->sk, e)) >= 0) {
 		(void)sk_ENGINE_delete(pile->sk, n);
 		pile->uptodate = 0;
-		}
-	if(pile->funct == e)
-		{
+	}
+	if (pile->funct == e) {
 		engine_unlocked_finish(e, 0);
 		pile->funct = NULL;
-		}
 	}
+}
 static IMPLEMENT_LHASH_DOALL_ARG_FN(int_unregister_cb, ENGINE_PILE, ENGINE)
 
-void engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
-	{
+void
+engine_table_unregister(ENGINE_TABLE **table, ENGINE *e)
+{
 	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-	if(int_table_check(table, 0))
+	if (int_table_check(table, 0))
 		lh_ENGINE_PILE_doall_arg(&(*table)->piles,
-					 LHASH_DOALL_ARG_FN(int_unregister_cb),
-					 ENGINE, e);
+		    LHASH_DOALL_ARG_FN(int_unregister_cb), ENGINE, e);
 	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
-	}
+}
 
-static void int_cleanup_cb_doall(ENGINE_PILE *p)
-	{
+static void
+int_cleanup_cb_doall(ENGINE_PILE *p)
+{
 	sk_ENGINE_free(p->sk);
-	if(p->funct)
+	if (p->funct)
 		engine_unlocked_finish(p->funct, 0);
 	free(p);
-	}
+}
 static IMPLEMENT_LHASH_DOALL_FN(int_cleanup_cb, ENGINE_PILE)
 
-void engine_table_cleanup(ENGINE_TABLE **table)
-	{
+void
+engine_table_cleanup(ENGINE_TABLE **table)
+{
 	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
-	if(*table)
-		{
+	if (*table) {
 		lh_ENGINE_PILE_doall(&(*table)->piles,
-				     LHASH_DOALL_FN(int_cleanup_cb));
+		    LHASH_DOALL_FN(int_cleanup_cb));
 		lh_ENGINE_PILE_free(&(*table)->piles);
 		*table = NULL;
-		}
-	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 	}
+	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
+}
 
 /* return a functional reference for a given 'nid' */
 #ifndef ENGINE_TABLE_DEBUG
-ENGINE *engine_table_select(ENGINE_TABLE **table, int nid)
+ENGINE *
+engine_table_select(ENGINE_TABLE **table, int nid)
 #else
-ENGINE *engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l)
+ENGINE *
+engine_table_select_tmp(ENGINE_TABLE **table, int nid, const char *f, int l)
 #endif
-	{
+{
 	ENGINE *ret = NULL;
-	ENGINE_PILE tmplate, *fnd=NULL;
+	ENGINE_PILE tmplate, *fnd = NULL;
 	int initres, loop = 0;
 
-	if(!(*table))
-		{
+	if (!(*table)) {
 #ifdef ENGINE_TABLE_DEBUG
 		fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, nothing "
-			"registered!\n", f, l, nid);
+		    "registered!\n", f, l, nid);
 #endif
 		return NULL;
-		}
+	}
 	ERR_set_mark();
 	CRYPTO_w_lock(CRYPTO_LOCK_ENGINE);
 	/* Check again inside the lock otherwise we could race against cleanup
 	 * operations. But don't worry about a fprintf(stderr). */
-	if(!int_table_check(table, 0)) goto end;
+	if (!int_table_check(table, 0))
+		goto end;
 	tmplate.nid = nid;
 	fnd = lh_ENGINE_PILE_retrieve(&(*table)->piles, &tmplate);
-	if(!fnd) goto end;
-	if(fnd->funct && engine_unlocked_init(fnd->funct))
-		{
+	if (!fnd)
+		goto end;
+	if (fnd->funct && engine_unlocked_init(fnd->funct)) {
 #ifdef ENGINE_TABLE_DEBUG
 		fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using "
-			"ENGINE '%s' cached\n", f, l, nid, fnd->funct->id);
+		    "ENGINE '%s' cached\n", f, l, nid, fnd->funct->id);
 #endif
 		ret = fnd->funct;
 		goto end;
-		}
-	if(fnd->uptodate)
-		{
+	}
+	if (fnd->uptodate) {
 		ret = fnd->funct;
 		goto end;
-		}
+	}
 trynext:
 	ret = sk_ENGINE_value(fnd->sk, loop++);
-	if(!ret)
-		{
+	if (!ret) {
 #ifdef ENGINE_TABLE_DEBUG
 		fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, no "
-				"registered implementations would initialise\n",
-				f, l, nid);
+		    "registered implementations would initialise\n", f, l, nid);
 #endif
 		goto end;
-		}
+	}
 	/* Try to initialise the ENGINE? */
-	if((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
+	if ((ret->funct_ref > 0) || !(table_flags & ENGINE_TABLE_FLAG_NOINIT))
 		initres = engine_unlocked_init(ret);
 	else
 		initres = 0;
-	if(initres)
-		{
+	if (initres) {
 		/* Update 'funct' */
-		if((fnd->funct != ret) && engine_unlocked_init(ret))
-			{
+		if ((fnd->funct != ret) && engine_unlocked_init(ret)) {
 			/* If there was a previous default we release it. */
-			if(fnd->funct)
+			if (fnd->funct)
 				engine_unlocked_finish(fnd->funct, 0);
 			fnd->funct = ret;
 #ifdef ENGINE_TABLE_DEBUG
 			fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, "
-				"setting default to '%s'\n", f, l, nid, ret->id);
+			    "setting default to '%s'\n", f, l, nid, ret->id);
 #endif
-			}
+		}
 #ifdef ENGINE_TABLE_DEBUG
 		fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, using "
-				"newly initialised '%s'\n", f, l, nid, ret->id);
+		    "newly initialised '%s'\n", f, l, nid, ret->id);
 #endif
 		goto end;
-		}
+	}
 	goto trynext;
 end:
 	/* If it failed, it is unlikely to succeed again until some future
 	 * registrations have taken place. In all cases, we cache. */
-	if(fnd) fnd->uptodate = 1;
+	if (fnd)
+		fnd->uptodate = 1;
 #ifdef ENGINE_TABLE_DEBUG
-	if(ret)
+	if (ret)
 		fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching "
-				"ENGINE '%s'\n", f, l, nid, ret->id);
+		    "ENGINE '%s'\n", f, l, nid, ret->id);
 	else
 		fprintf(stderr, "engine_table_dbg: %s:%d, nid=%d, caching "
-				"'no matching ENGINE'\n", f, l, nid);
+		    "'no matching ENGINE'\n", f, l, nid);
 #endif
 	CRYPTO_w_unlock(CRYPTO_LOCK_ENGINE);
 	/* Whatever happened, any failed init()s are not failures in this
 	 * context, so clear our error state. */
 	ERR_pop_to_mark();
 	return ret;
-	}
+}
 
 /* Table enumeration */
 
-static void int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
-	{
+static void
+int_cb_doall_arg(ENGINE_PILE *pile, ENGINE_PILE_DOALL *dall)
+{
 	dall->cb(pile->nid, pile->sk, pile->funct, dall->arg);
-	}
-static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE,ENGINE_PILE_DOALL)
+}
+static IMPLEMENT_LHASH_DOALL_ARG_FN(int_cb, ENGINE_PILE, ENGINE_PILE_DOALL)
 
-void engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb,
-								void *arg)
-	{
+void
+engine_table_doall(ENGINE_TABLE *table, engine_table_doall_cb *cb, void *arg)
+{
 	ENGINE_PILE_DOALL dall;
+
 	dall.cb = cb;
 	dall.arg = arg;
 	lh_ENGINE_PILE_doall_arg(&table->piles, LHASH_DOALL_ARG_FN(int_cb),
-				 ENGINE_PILE_DOALL, &dall);
-	}
+	    ENGINE_PILE_DOALL, &dall);
+}
-- 
cgit v1.2.3-55-g6feb