Change the trust and purpose code so it doesn't need init

either and has a static and dynamic mix.

3 files changed, 82 insertions, 67 deletions

diff --git a/crypto/x509/x509.h b/crypto/x509/x509.h
index ed95058a74..5e4da0f7c4 100644
--- a/crypto/x509/x509.h
+++ b/crypto/x509/x509.h
@@ -280,10 +280,10 @@ DECLARE_ASN1_SET_OF(X509)
 /* This is used for a table of trust checking functions */
 
 typedef struct x509_trust_st {
-	int trust_id;
-	int trust_flags;
+	int trust;
+	int flags;
 	int (*check_trust)(struct x509_trust_st *, X509 *, int);
-	char *trust_name;
+	char *name;
 	int arg1;
 	void *arg2;
 } X509_TRUST;
@@ -298,6 +298,11 @@ DECLARE_STACK_OF(X509_TRUST)
 #define X509_TRUST_EMAIL	4
 #define X509_TRUST_OBJECT_SIGN	5
 
+/* Keep these up to date! */
+#define X509_TRUST_MIN		1
+#define X509_TRUST_MAX		5
+
+
 /* trust_flags values */
 #define	X509_TRUST_DYNAMIC 	1
 #define	X509_TRUST_DYNAMIC_NAME	2
@@ -1015,8 +1020,6 @@ int		X509_EXTENSION_set_data(X509_EXTENSION *ex,
 ASN1_OBJECT *	X509_EXTENSION_get_object(X509_EXTENSION *ex);
 ASN1_OCTET_STRING *X509_EXTENSION_get_data(X509_EXTENSION *ne);
 int		X509_EXTENSION_get_critical(X509_EXTENSION *ex);
-void		X509_init(void);
-void		X509_cleanup(void);
 
 int		X509_verify_cert(X509_STORE_CTX *ctx);
 
@@ -1059,10 +1062,10 @@ int X509_check_trust(X509 *x, int id, int flags);
 int X509_TRUST_get_count(void);
 X509_TRUST * X509_TRUST_iget(int idx);
 int X509_TRUST_get_by_id(int id);
-int X509_TRUST_add(X509_TRUST *xp);
+int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
+					char *name, int arg1, void *arg2);
 void X509_TRUST_cleanup(void);
-void X509_TRUST_add_standard(void);
-int X509_TRUST_get_id(X509_TRUST *xp);
+int X509_TRUST_get_flags(X509_TRUST *xp);
 char *X509_TRUST_iget_name(X509_TRUST *xp);
 int X509_TRUST_get_trust(X509_TRUST *xp);
 
diff --git a/crypto/x509/x509_trs.c b/crypto/x509/x509_trs.c
index 94c64a1bcf..f96f5f9b26 100644
--- a/crypto/x509/x509_trs.c
+++ b/crypto/x509/x509_trs.c
@@ -67,72 +67,110 @@ static void trtable_free(X509_TRUST *p);
 static int trust_1bit(X509_TRUST *trust, X509 *x, int flags);
 static int trust_any(X509_TRUST *trust, X509 *x, int flags);
 
+/* WARNING: the following table should be kept in order of trust
+ * and without any gaps so we can just subtract the minimum trust
+ * value to get an index into the table
+ */
+
 static X509_TRUST trstandard[] = {
 {X509_TRUST_ANY, 0, trust_any, "Any", 0, NULL},
 {X509_TRUST_SSL_CLIENT, 0, trust_1bit, "SSL Client", X509_TRUST_BIT_SSL_CLIENT, NULL},
 {X509_TRUST_SSL_SERVER, 0, trust_1bit, "SSL Client", X509_TRUST_BIT_SSL_SERVER, NULL},
 {X509_TRUST_EMAIL, 0, trust_1bit, "S/MIME email", X509_TRUST_BIT_EMAIL, NULL},
 {X509_TRUST_OBJECT_SIGN, 0, trust_1bit, "Object Signing", X509_TRUST_BIT_OBJECT_SIGN, NULL},
-{0, 0, NULL, NULL, 0, NULL}
 };
 
+#define X509_TRUST_COUNT	(sizeof(trstandard)/sizeof(X509_TRUST))
+
 IMPLEMENT_STACK_OF(X509_TRUST)
 
 static STACK_OF(X509_TRUST) *trtable = NULL;
 
 static int tr_cmp(X509_TRUST **a, X509_TRUST **b)
 {
-	return (*a)->trust_id - (*b)->trust_id;
+	return (*a)->trust - (*b)->trust;
 }
 
 int X509_check_trust(X509 *x, int id, int flags)
 {
-	int idx;
 	X509_TRUST *pt;
+	int idx;
 	if(id == -1) return 1;
-	idx = X509_TRUST_get_by_id(id);
-	if(idx == -1) return -1;
-	pt = sk_X509_TRUST_value(trtable, idx);
+	if(!(idx = X509_TRUST_get_by_id(id))) return 0;
+	pt = X509_TRUST_iget(idx);
 	return pt->check_trust(pt, x, flags);
 }
 
 int X509_TRUST_get_count(void)
 {
-	return sk_X509_TRUST_num(trtable);
+	if(!trtable) return X509_TRUST_COUNT;
+	return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT;
 }
 
 X509_TRUST * X509_TRUST_iget(int idx)
 {
-	return sk_X509_TRUST_value(trtable, idx);
+	if(idx < 0) return NULL;
+	if(idx < X509_TRUST_COUNT) return trstandard + idx;
+	return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT);
 }
 
 int X509_TRUST_get_by_id(int id)
 {
 	X509_TRUST tmp;
-	tmp.trust_id = id;
+	int idx;
+	if((id >= X509_TRUST_MIN) && (id <= X509_TRUST_MAX))
+				 return id - X509_TRUST_MIN;
+	tmp.trust = id;
 	if(!trtable) return -1;
-	return sk_X509_TRUST_find(trtable, &tmp);
+	idx = sk_X509_TRUST_find(trtable, &tmp);
+	if(idx == -1) return -1;
+	return idx + X509_TRUST_COUNT;
 }
 
-int X509_TRUST_add(X509_TRUST *xp)
+int X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
+					char *name, int arg1, void *arg2)
 {
 	int idx;
-	if(!trtable)
-		{
-		trtable = sk_X509_TRUST_new(tr_cmp);
-		if (!trtable) 
-			{
+	X509_TRUST *trtmp;
+	/* This is set according to what we change: application can't set it */
+	flags &= ~X509_TRUST_DYNAMIC;
+	/* This will always be set for application modified trust entries */
+	flags |= X509_TRUST_DYNAMIC_NAME;
+	/* Get existing entry if any */
+	idx = X509_TRUST_get_by_id(id);
+	/* Need a new entry */
+	if(idx == -1) {
+		if(!(trtmp = Malloc(sizeof(X509_TRUST)))) {
 			X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
 			return 0;
-			}
 		}
-			
-	idx = X509_TRUST_get_by_id(xp->trust_id);
-	if(idx != -1) {
-		trtable_free(sk_X509_TRUST_value(trtable, idx));
-		sk_X509_TRUST_set(trtable, idx, xp);
-	} else {
-		if (!sk_X509_TRUST_push(trtable, xp)) {
+		trtmp->flags = X509_TRUST_DYNAMIC;
+	} else trtmp = X509_TRUST_iget(idx);
+
+	/* Free existing name if dynamic */
+	if(trtmp->flags & X509_TRUST_DYNAMIC_NAME) Free(trtmp->name);
+	/* dup supplied name */
+	if(!(trtmp->name = BUF_strdup(name))) {
+		X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
+		return 0;
+	}
+	/* Keep the dynamic flag of existing entry */
+	trtmp->flags &= X509_TRUST_DYNAMIC;
+	/* Set all other flags */
+	trtmp->flags |= flags;
+
+	trtmp->trust = id;
+	trtmp->check_trust = ck;
+	trtmp->arg1 = arg1;
+	trtmp->arg2 = arg2;
+
+	/* If its a new entry manage the dynamic table */
+	if(idx == -1) {
+		if(!trtable && !(trtable = sk_X509_TRUST_new(tr_cmp))) {
+			X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
+			return 0;
+		}
+		if (!sk_X509_TRUST_push(trtable, trtmp)) {
 			X509err(X509_F_X509_TRUST_ADD,ERR_R_MALLOC_FAILURE);
 			return 0;
 		}
@@ -143,40 +181,35 @@ int X509_TRUST_add(X509_TRUST *xp)
 static void trtable_free(X509_TRUST *p)
 	{
 	if(!p) return;
-	if (p->trust_flags & X509_TRUST_DYNAMIC) 
+	if (p->flags & X509_TRUST_DYNAMIC) 
 		{
-		if (p->trust_flags & X509_TRUST_DYNAMIC_NAME)
-			Free(p->trust_name);
+		if (p->flags & X509_TRUST_DYNAMIC_NAME)
+			Free(p->name);
 		Free(p);
 		}
 	}
 
 void X509_TRUST_cleanup(void)
 {
+	int i;
+	for(i = 0; i < X509_TRUST_COUNT; i++) trtable_free(trstandard + i);
 	sk_X509_TRUST_pop_free(trtable, trtable_free);
 	trtable = NULL;
 }
 
-void X509_TRUST_add_standard(void)
-{
-	X509_TRUST *xp;
-	for(xp = trstandard; xp->trust_name; xp++)
-		X509_TRUST_add(xp);
-}
-
-int X509_TRUST_get_id(X509_TRUST *xp)
+int X509_TRUST_get_flags(X509_TRUST *xp)
 {
-	return xp->trust_id;
+	return xp->flags;
 }
 
 char *X509_TRUST_iget_name(X509_TRUST *xp)
 {
-	return xp->trust_name;
+	return xp->name;
 }
 
 int X509_TRUST_get_trust(X509_TRUST *xp)
 {
-	return xp->trust_id;
+	return xp->trust;
 }
 
 static int trust_1bit(X509_TRUST *trust, X509 *x, int flags)
diff --git a/crypto/x509/x509_v3.c b/crypto/x509/x509_v3.c
index 100b08773c..52887986fe 100644
--- a/crypto/x509/x509_v3.c
+++ b/crypto/x509/x509_v3.c
@@ -265,24 +265,3 @@ int X509_EXTENSION_get_critical(X509_EXTENSION *ex)
 	if (ex == NULL) return(0);
 	return(ex->critical);
 	}
-
-/* Initialisation routine: used to initialise the X509 and X509v3 tables */
-
-static int init_done = 0;
-
-void X509_init(void)
-{
-	if(init_done) return;
-	X509V3_add_standard_extensions();
-	X509_PURPOSE_add_standard();
-	X509_TRUST_add_standard();
-	init_done = 1;
-}
-
-void X509_cleanup(void)
-{
-	X509V3_EXT_cleanup();
-	X509_PURPOSE_cleanup();
-	X509_TRUST_cleanup();
-	init_done = 0;
-}