Typesafe Thought Police part 4.

4 files changed, 72 insertions, 63 deletions

diff --git a/crypto/pkcs7/pk7_attr.c b/crypto/pkcs7/pk7_attr.c
index 3b9c0fe3f2..edea2359b3 100644
--- a/crypto/pkcs7/pk7_attr.c
+++ b/crypto/pkcs7/pk7_attr.c
@@ -14,20 +14,21 @@
 #include <openssl/pkcs7.h>
 #include <openssl/err.h>
 
-int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, STACK *cap)
+int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, STACK_OF(X509_ALGOR) *cap)
 {
 	ASN1_STRING *seq;
 	unsigned char *p, *pp;
 	int len;
-	len=i2d_ASN1_SET(cap,NULL,i2d_X509_ALGOR, V_ASN1_SEQUENCE,
-						V_ASN1_UNIVERSAL, IS_SEQUENCE);
+	len=i2d_ASN1_SET_OF_X509_ALGOR(cap,NULL,i2d_X509_ALGOR,
+				       V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL,
+				       IS_SEQUENCE);
 	if(!(pp=(unsigned char *)Malloc(len))) {
 		PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE);
 		return 0;
 	}
 	p=pp;
-	i2d_ASN1_SET(cap,&p,i2d_X509_ALGOR, V_ASN1_SEQUENCE,
-						V_ASN1_UNIVERSAL, IS_SEQUENCE);
+	i2d_ASN1_SET_OF_X509_ALGOR(cap,&p,i2d_X509_ALGOR, V_ASN1_SEQUENCE,
+				   V_ASN1_UNIVERSAL, IS_SEQUENCE);
 	if(!(seq = ASN1_STRING_new())) {
 		PKCS7err(PKCS7_F_PKCS7_ADD_ATTRIB_SMIMECAP,ERR_R_MALLOC_FAILURE);
 		return 0;
@@ -54,9 +55,10 @@ STACK *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si)
 }
 
 /* Basic smime-capabilities OID and optional integer arg */
-int PKCS7_simple_smimecap(STACK *sk, int nid, int arg)
+int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg)
 {
 	X509_ALGOR *alg;
+
 	if(!(alg = X509_ALGOR_new())) {
 		PKCS7err(PKCS7_F_PKCS7_SIMPLE_SMIMECAP,ERR_R_MALLOC_FAILURE);
 		return 0;
@@ -80,6 +82,6 @@ int PKCS7_simple_smimecap(STACK *sk, int nid, int arg)
 		alg->parameter->value.integer = nbit;
 		alg->parameter->type = V_ASN1_INTEGER;
 	}
-	sk_push (sk, (char *)alg);
+	sk_X509_ALGOR_push (sk, alg);
 	return 1;
 }
diff --git a/crypto/pkcs7/pk7_mime.c b/crypto/pkcs7/pk7_mime.c
index 8981f9f213..3049e0adb1 100644
--- a/crypto/pkcs7/pk7_mime.c
+++ b/crypto/pkcs7/pk7_mime.c
@@ -70,16 +70,19 @@
  */
 
 typedef struct {
-char *name;				/* Name of line e.g. "content-type" */
-char *value;				/* Value of line e.g. "text/plain" */
-STACK /* MIME_PARAM */ *params;		/* Zero or more parameters */
-} MIME_HEADER;
-
-typedef struct {
 char *param_name;			/* Param name e.g. "micalg" */
 char *param_value;			/* Param value e.g. "sha1" */
 } MIME_PARAM;
 
+IMPLEMENT_STACK_OF(MIME_PARAM)
+
+typedef struct {
+char *name;				/* Name of line e.g. "content-type" */
+char *value;				/* Value of line e.g. "text/plain" */
+STACK_OF(MIME_PARAM) *params;		/* Zero or more parameters */
+} MIME_HEADER;
+
+IMPLEMENT_STACK_OF(MIME_HEADER)
 
 static int B64_write_PKCS7(BIO *bio, PKCS7 *p7);
 static PKCS7 *B64_read_PKCS7(BIO *bio);
@@ -88,14 +91,14 @@ static char * strip_start(char *name);
 static char * strip_end(char *name);
 static MIME_HEADER *mime_hdr_new(char *name, char *value);
 static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value);
-static STACK *mime_parse_hdr(BIO *bio);
+static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio);
 static int mime_hdr_cmp(MIME_HEADER **a, MIME_HEADER **b);
 static int mime_param_cmp(MIME_PARAM **a, MIME_PARAM **b);
 static void mime_param_free(MIME_PARAM *param);
 static int mime_bound_check(char *line, int linelen, char *bound, int blen);
-static int multi_split(BIO *bio, char *bound, STACK **ret);
+static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret);
 static int iscrlf(char c);
-static MIME_HEADER *mime_hdr_find(STACK *hdrs, char *name);
+static MIME_HEADER *mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name);
 static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name);
 static void mime_hdr_free(MIME_HEADER *hdr);
 
@@ -196,8 +199,8 @@ int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags)
 PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont)
 {
 	BIO *p7in;
-	STACK *headers = NULL;
-	STACK *parts = NULL;
+	STACK_OF(MIME_HEADER) *headers = NULL;
+	STACK_OF(BIO) *parts = NULL;
 	MIME_HEADER *hdr;
 	MIME_PARAM *prm;
 	PKCS7 *p7;
@@ -211,7 +214,7 @@ PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont)
 	}
 
 	if(!(hdr = mime_hdr_find(headers, "content-type")) || !hdr->value) {
-		sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+		sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 		PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_CONTENT_TYPE);
 		return NULL;
 	}
@@ -222,24 +225,24 @@ PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont)
 		/* Split into two parts */
 		prm = mime_param_find(hdr, "boundary");
 		if(!prm || !prm->param_value) {
-			sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+			sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 			PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_MULTIPART_BOUNDARY);
 			return NULL;
 		}
 		ret = multi_split(bio, prm->param_value, &parts);
-		sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
-		if(!ret || (sk_num(parts) != 2) ) {
+		sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
+		if(!ret || (sk_BIO_num(parts) != 2) ) {
 			PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_MULTIPART_BODY_FAILURE);
-			sk_pop_free(parts, (void(*)(void *)) BIO_free);
+			sk_BIO_pop_free(parts, BIO_vfree);
 			return NULL;
 		}
 
 		/* Parse the signature piece */
-		p7in = (BIO *)sk_value(parts, 1);
+		p7in = sk_BIO_value(parts, 1);
 
 		if (!(headers = mime_parse_hdr(p7in))) {
 			PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_MIME_SIG_PARSE_ERROR);
-			sk_pop_free(parts, (void(*)(void *)) BIO_free);
+			sk_BIO_pop_free(parts, BIO_vfree);
 			return NULL;
 		}
 
@@ -247,32 +250,32 @@ PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont)
 
 		if(!(hdr = mime_hdr_find(headers, "content-type")) ||
 								 !hdr->value) {
-			sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+			sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 			PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_NO_SIG_CONTENT_TYPE);
 			return NULL;
 		}
 
 		if(strcmp(hdr->value, "application/x-pkcs7-signature") &&
 			strcmp(hdr->value, "application/pkcs7-signature")) {
-			sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+			sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 			PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_SIG_INVALID_MIME_TYPE);
 			ERR_add_error_data(2, "type: ", hdr->value);
-			sk_pop_free(parts, (void(*)(void *))BIO_free);
+			sk_BIO_pop_free(parts, BIO_vfree);
 			return NULL;
 		}
-		sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+		sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 		/* Read in PKCS#7 */
 		if(!(p7 = B64_read_PKCS7(p7in))) {
 			PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_PKCS7_SIG_PARSE_ERROR);
-			sk_pop_free(parts, (void(*)(void *))BIO_free);
+			sk_BIO_pop_free(parts, BIO_vfree);
 			return NULL;
 		}
 
 		if(bcont) {
-			*bcont = (BIO *)sk_value(parts, 0);
+			*bcont = sk_BIO_value(parts, 0);
 			BIO_free(p7in);
-			sk_free(parts);
-		} else sk_pop_free(parts, (stkfree)BIO_free);
+			sk_BIO_free(parts);
+		} else sk_BIO_pop_free(parts, BIO_vfree);
 		return p7;
 	}
 		
@@ -282,11 +285,11 @@ PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont)
 	    strcmp (hdr->value, "application/pkcs7-mime")) {
 		PKCS7err(PKCS7_F_SMIME_READ_PKCS7,PKCS7_R_INVALID_MIME_TYPE);
 		ERR_add_error_data(2, "type: ", hdr->value);
-		sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+		sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 		return NULL;
 	}
 
-	sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+	sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 	
 	if(!(p7 = B64_read_PKCS7(bio))) {
 		PKCS7err(PKCS7_F_SMIME_READ_PKCS7, PKCS7_R_PKCS7_PARSE_ERROR);
@@ -325,24 +328,25 @@ int SMIME_text(BIO *in, BIO *out)
 {
 	char iobuf[4096];
 	int len;
-	STACK *headers;
+	STACK_OF(MIME_HEADER) *headers;
 	MIME_HEADER *hdr;
+
 	if (!(headers = mime_parse_hdr(in))) {
 		PKCS7err(PKCS7_F_SMIME_TEXT,PKCS7_R_MIME_PARSE_ERROR);
 		return 0;
 	}
 	if(!(hdr = mime_hdr_find(headers, "content-type")) || !hdr->value) {
 		PKCS7err(PKCS7_F_SMIME_TEXT,PKCS7_R_MIME_NO_CONTENT_TYPE);
-		sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+		sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 		return 0;
 	}
 	if (strcmp (hdr->value, "text/plain")) {
 		PKCS7err(PKCS7_F_SMIME_TEXT,PKCS7_R_INVALID_MIME_TYPE);
 		ERR_add_error_data(2, "type: ", hdr->value);
-		sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+		sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 		return 0;
 	}
-	sk_pop_free(headers, (void(*)(void *)) mime_hdr_free);
+	sk_MIME_HEADER_pop_free(headers, mime_hdr_free);
 	while ((len = BIO_read(in, iobuf, sizeof(iobuf))) > 0)
 						BIO_write(out, iobuf, len);
 	return 1;
@@ -352,18 +356,19 @@ int SMIME_text(BIO *in, BIO *out)
  * canonical parts in a STACK of bios
  */
 
-static int multi_split(BIO *bio, char *bound, STACK **ret)
+static int multi_split(BIO *bio, char *bound, STACK_OF(BIO) **ret)
 {
 	char linebuf[MAX_SMLEN];
 	int len, blen;
 	BIO *bpart = NULL;
-	STACK *parts;
+	STACK_OF(BIO) *parts;
 	char state, part, first;
+
 	blen = strlen(bound);
 	part = 0;
 	state = 0;
 	first = 1;
-	parts = sk_new(NULL);
+	parts = sk_BIO_new(NULL);
 	*ret = parts;
 	while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) {
 		state = mime_bound_check(linebuf, len, bound, blen);
@@ -371,12 +376,12 @@ static int multi_split(BIO *bio, char *bound, STACK **ret)
 			first = 1;
 			part++;
 		} else if(state == 2) {
-			sk_push(parts, (char *)bpart);
+			sk_BIO_push(parts, bpart);
 			return 1;
 		} else if(part) {
 			if(first) {
 				first = 0;
-				if(bpart) sk_push(parts, (char *)bpart);
+				if(bpart) sk_BIO_push(parts, bpart);
 				bpart = BIO_new(BIO_s_mem());
 				
 			} else BIO_write(bpart, "\r\n", 2);
@@ -405,15 +410,16 @@ static int iscrlf(char c)
 #define MIME_COMMENT	6
 
 
-static STACK *mime_parse_hdr(BIO *bio)
+static STACK_OF(MIME_HEADER) *mime_parse_hdr(BIO *bio)
 {
 	char *p, *q, c;
 	char *ntmp;
 	char linebuf[MAX_SMLEN];
 	MIME_HEADER *mhdr = NULL;
-	STACK *headers;
+	STACK_OF(MIME_HEADER) *headers;
 	int len, state, save_state = 0;
-	headers = sk_new((int (*)(const void *, const void *))mime_hdr_cmp);
+
+	headers = sk_MIME_HEADER_new(mime_hdr_cmp);
 	while ((len = BIO_gets(bio, linebuf, MAX_SMLEN)) > 0) {
 	/* If whitespace at line start then continuation line */
 	if(mhdr && isspace((unsigned char)linebuf[0])) state = MIME_NAME;
@@ -441,7 +447,7 @@ static STACK *mime_parse_hdr(BIO *bio)
 				mime_debug("Found End Value\n");
 				*p = 0;
 				mhdr = mime_hdr_new(ntmp, strip_ends(q));
-				sk_push(headers, (char *)mhdr);
+				sk_MIME_HEADER_push(headers, mhdr);
 				ntmp = NULL;
 				q = p + 1;
 				state = MIME_NAME;
@@ -493,7 +499,7 @@ static STACK *mime_parse_hdr(BIO *bio)
 
 	if(state == MIME_TYPE) {
 		mhdr = mime_hdr_new(ntmp, strip_ends(q));
-		sk_push(headers, (char *)mhdr);
+		sk_MIME_HEADER_push(headers, mhdr);
 	} else if(state == MIME_VALUE)
 			 mime_hdr_addparam(mhdr, ntmp, strip_ends(q));
 	if(p == linebuf) break;	/* Blank line means end of headers */
@@ -573,7 +579,7 @@ static MIME_HEADER *mime_hdr_new(char *name, char *value)
 	if(!mhdr) return NULL;
 	mhdr->name = tmpname;
 	mhdr->value = tmpval;
-	if(!(mhdr->params = sk_new((int (*)(const void *, const void *)) mime_param_cmp))) return NULL;
+	if(!(mhdr->params = sk_MIME_PARAM_new(mime_param_cmp))) return NULL;
 	return mhdr;
 }
 		
@@ -602,7 +608,7 @@ static int mime_hdr_addparam(MIME_HEADER *mhdr, char *name, char *value)
 	if(!mparam) return 0;
 	mparam->param_name = tmpname;
 	mparam->param_value = tmpval;
-	sk_push(mhdr->params, (char *)mparam);
+	sk_MIME_PARAM_push(mhdr->params, mparam);
 	return 1;
 }
 
@@ -618,14 +624,14 @@ static int mime_param_cmp(MIME_PARAM **a, MIME_PARAM **b)
 
 /* Find a header with a given name (if possible) */
 
-static MIME_HEADER *mime_hdr_find(STACK *hdrs, char *name)
+static MIME_HEADER *mime_hdr_find(STACK_OF(MIME_HEADER) *hdrs, char *name)
 {
 	MIME_HEADER htmp;
 	int idx;
 	htmp.name = name;
-	idx = sk_find(hdrs, (char *)&htmp);
+	idx = sk_MIME_HEADER_find(hdrs, &htmp);
 	if(idx < 0) return NULL;
-	return (MIME_HEADER *)sk_value(hdrs, idx);
+	return sk_MIME_HEADER_value(hdrs, idx);
 }
 
 static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name)
@@ -633,16 +639,16 @@ static MIME_PARAM *mime_param_find(MIME_HEADER *hdr, char *name)
 	MIME_PARAM param;
 	int idx;
 	param.param_name = name;
-	idx = sk_find(hdr->params, (char *)&param);
+	idx = sk_MIME_PARAM_find(hdr->params, &param);
 	if(idx < 0) return NULL;
-	return (MIME_PARAM *)sk_value(hdr->params, idx);
+	return sk_MIME_PARAM_value(hdr->params, idx);
 }
 
 static void mime_hdr_free(MIME_HEADER *hdr)
 {
 	if(hdr->name) Free(hdr->name);
 	if(hdr->value) Free(hdr->value);
-	if(hdr->params) sk_pop_free(hdr->params, (void(*)(void *)) mime_param_free);
+	if(hdr->params) sk_MIME_PARAM_pop_free(hdr->params, mime_param_free);
 	Free(hdr);
 }
 
diff --git a/crypto/pkcs7/pk7_smime.c b/crypto/pkcs7/pk7_smime.c
index 0a9f5a86ae..225fc63da0 100644
--- a/crypto/pkcs7/pk7_smime.c
+++ b/crypto/pkcs7/pk7_smime.c
@@ -64,12 +64,12 @@
 #include <openssl/x509v3.h>
 
 PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
-							BIO *data, int flags)
+		  BIO *data, int flags)
 {
 	PKCS7 *p7;
 	PKCS7_SIGNER_INFO *si;
 	BIO *p7bio;
-	STACK *smcap;
+	STACK_OF(X509_ALGOR) *smcap;
 	int i;
 
 	if(!X509_check_private_key(signcert, pkey)) {
@@ -109,7 +109,7 @@ PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
 		PKCS7_add_signed_attribute(si, NID_pkcs9_contentType,
 				V_ASN1_OBJECT, OBJ_nid2obj(NID_pkcs7_data));
 		/* Add SMIMECapabilities */
-		if(!(smcap = sk_new(NULL))) {
+		if(!(smcap = sk_X509_ALGOR_new(NULL))) {
 			PKCS7err(PKCS7_F_PKCS7_SIGN,ERR_R_MALLOC_FAILURE);
 			return NULL;
 		}
@@ -127,7 +127,7 @@ PKCS7 *PKCS7_sign(X509 *signcert, EVP_PKEY *pkey, STACK_OF(X509) *certs,
 		PKCS7_simple_smimecap (smcap, NID_rc2_cbc, 40);
 #endif
 		PKCS7_add_attrib_smimecap (si, smcap);
-		sk_pop_free(smcap, (void(*)(void *)) X509_ALGOR_free);
+		sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
 	}
 
 	if(flags & PKCS7_DETACHED)PKCS7_set_detached(p7, 1);
diff --git a/crypto/pkcs7/pkcs7.h b/crypto/pkcs7/pkcs7.h
index a220440e5c..bc761a054f 100644
--- a/crypto/pkcs7/pkcs7.h
+++ b/crypto/pkcs7/pkcs7.h
@@ -406,9 +406,10 @@ PKCS7 *PKCS7_encrypt(STACK_OF(X509) *certs, BIO *in, EVP_CIPHER *cipher,
 								int flags);
 int PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags);
 
-int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, STACK *cap);
+int PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si,
+			      STACK_OF(X509_ALGOR) *cap);
 STACK *PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si);
-int PKCS7_simple_smimecap(STACK *sk, int nid, int arg);
+int PKCS7_simple_smimecap(STACK_OF(X509_ALGOR) *sk, int nid, int arg);
 
 int SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags);
 PKCS7 *SMIME_read_PKCS7(BIO *bio, BIO **bcont);