Commit 371acb22 authored by Ben Laurie's avatar Ben Laurie
Browse files

Typesafe Thought Police part 4.

parent 5de603ab

crypto/bio/bio.h

+3 −0
Original line number Diff line number Diff line
@@ -261,6 +261,8 @@ struct bio_st 
	CRYPTO_EX_DATA ex_data;

	};



DECLARE_STACK_OF(BIO)



typedef struct bio_f_buffer_ctx_struct

	{

	/* BIO *bio; */ /* this is now in the BIO struct */
@@ -507,6 +509,7 @@ BIO *BIO_new_fp(FILE *stream, int close_flag); 
BIO *	BIO_new(BIO_METHOD *type);

int	BIO_set(BIO *a,BIO_METHOD *type);

int	BIO_free(BIO *a);

void	BIO_vfree(BIO *a);

int	BIO_read(BIO *b, void *data, int len);

int	BIO_gets(BIO *bp,char *buf, int size);

int	BIO_write(BIO *b, const void *data, int len);

crypto/bio/bio_lib.c

+5 −0
Original line number Diff line number Diff line
@@ -137,6 +137,9 @@ int BIO_free(BIO *a) 
	return(1);

	}



void BIO_vfree(BIO *a)

    { BIO_free(a); }



int BIO_read(BIO *b, void *out, int outl)

	{

	int i;
@@ -532,3 +535,5 @@ unsigned long BIO_number_written(BIO *bio) 
	if(bio) return bio->num_write;

	return 0;

}



IMPLEMENT_STACK_OF(BIO)

crypto/evp/evp_pkey.c

+23 −22
Original line number Diff line number Diff line
@@ -76,7 +76,7 @@ EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8) 
	DSA *dsa = NULL;

	ASN1_INTEGER *privkey;

	ASN1_TYPE *t1, *t2, *param = NULL;

	STACK *ndsa = NULL;

	STACK_OF(ASN1_TYPE) *ndsa = NULL;

	BN_CTX *ctx = NULL;

	int plen;

#endif
@@ -119,13 +119,13 @@ EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8) 
	

		/* Check for broken DSA PKCS#8, UGH! */

		if(*p == (V_ASN1_SEQUENCE|V_ASN1_CONSTRUCTED)) {

		    if(!(ndsa = ASN1_seq_unpack(p, pkeylen, 

					(char *(*)())d2i_ASN1_TYPE,

		    if(!(ndsa = ASN1_seq_unpack_ASN1_TYPE(p, pkeylen, 

							  d2i_ASN1_TYPE,

							  ASN1_TYPE_free))) {

			EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);

			goto dsaerr;

		    }

		    if(sk_num(ndsa) != 2 ) {

		    if(sk_ASN1_TYPE_num(ndsa) != 2 ) {

			EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);

			goto dsaerr;

		    }
@@ -134,8 +134,8 @@ EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8) 
		     * SEQUENCE {pub_key, priv_key}

		     */



		    t1 = (ASN1_TYPE *)sk_value(ndsa, 0);

		    t2 = (ASN1_TYPE *)sk_value(ndsa, 1);

		    t1 = sk_ASN1_TYPE_value(ndsa, 0);

		    t2 = sk_ASN1_TYPE_value(ndsa, 1);

		    if(t1->type == V_ASN1_SEQUENCE) {

			p8->broken = PKCS8_EMBEDDED_PARAM;

			param = t1;
@@ -193,12 +193,12 @@ EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8) 


		EVP_PKEY_assign_DSA(pkey, dsa);

		BN_CTX_free (ctx);

		if(ndsa) sk_pop_free(ndsa, (void(*)(void *)) ASN1_TYPE_free);

		if(ndsa) sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);

		else ASN1_INTEGER_free(privkey);

		break;

		dsaerr:

		BN_CTX_free (ctx);

		sk_pop_free(ndsa, (void(*)(void *)) ASN1_TYPE_free);

		sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);

		DSA_free(dsa);

		EVP_PKEY_free(pkey);

		return NULL;
@@ -302,9 +302,10 @@ static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey) 
	ASN1_STRING *params;

	ASN1_INTEGER *prkey;

	ASN1_TYPE *ttmp;

	STACK *ndsa;

	STACK_OF(ASN1_TYPE) *ndsa;

	unsigned char *p, *q;

	int len;



	p8->pkeyalg->algorithm = OBJ_nid2obj(NID_dsa);

	len = i2d_DSAparams (pkey->pkey.dsa, NULL);

	if (!(p = Malloc(len))) {
@@ -345,7 +346,7 @@ static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey) 


		p8->pkeyalg->parameter->value.sequence = params;

		p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;

		ndsa = sk_new_null();

		ndsa = sk_ASN1_TYPE_new_null();

		ttmp = ASN1_TYPE_new();

		if (!(ttmp->value.integer = BN_to_ASN1_INTEGER (pkey->pkey.dsa->pub_key, NULL))) {

			EVPerr(EVP_F_EVP_PKEY2PKCS8,EVP_R_ENCODE_ERROR);
@@ -353,53 +354,53 @@ static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey) 
			return 0;

		}

		ttmp->type = V_ASN1_INTEGER;

		sk_push(ndsa, (char *)ttmp);

		sk_ASN1_TYPE_push(ndsa, ttmp);



		ttmp = ASN1_TYPE_new();

		ttmp->value.integer = prkey;

		ttmp->type = V_ASN1_INTEGER;

		sk_push(ndsa, (char *)ttmp);

		sk_ASN1_TYPE_push(ndsa, ttmp);



		p8->pkey->value.octet_string = ASN1_OCTET_STRING_new();



		if (!ASN1_seq_pack(ndsa, i2d_ASN1_TYPE,

		if (!ASN1_seq_pack_ASN1_TYPE(ndsa, i2d_ASN1_TYPE,

					 &p8->pkey->value.octet_string->data,

					 &p8->pkey->value.octet_string->length)) {



			EVPerr(EVP_F_EVP_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);

			sk_pop_free(ndsa, (void(*)(void *)) ASN1_TYPE_free);

			sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);

			M_ASN1_INTEGER_free(prkey);

			return 0;

		}

		sk_pop_free(ndsa, (void(*)(void *)) ASN1_TYPE_free);

		sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);

		break;



		case PKCS8_EMBEDDED_PARAM:



		p8->pkeyalg->parameter->type = V_ASN1_NULL;

		ndsa = sk_new_null();

		ndsa = sk_ASN1_TYPE_new_null();

		ttmp = ASN1_TYPE_new();

		ttmp->value.sequence = params;

		ttmp->type = V_ASN1_SEQUENCE;

		sk_push(ndsa, (char *)ttmp);

		sk_ASN1_TYPE_push(ndsa, ttmp);



		ttmp = ASN1_TYPE_new();

		ttmp->value.integer = prkey;

		ttmp->type = V_ASN1_INTEGER;

		sk_push(ndsa, (char *)ttmp);

		sk_ASN1_TYPE_push(ndsa, ttmp);



		p8->pkey->value.octet_string = ASN1_OCTET_STRING_new();



		if (!ASN1_seq_pack(ndsa, i2d_ASN1_TYPE,

		if (!ASN1_seq_pack_ASN1_TYPE(ndsa, i2d_ASN1_TYPE,

					 &p8->pkey->value.octet_string->data,

					 &p8->pkey->value.octet_string->length)) {



			EVPerr(EVP_F_EVP_PKEY2PKCS8,ERR_R_MALLOC_FAILURE);

			sk_pop_free(ndsa, (void(*)(void *)) ASN1_TYPE_free);

			sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);

			M_ASN1_INTEGER_free (prkey);

			return 0;

		}

		sk_pop_free(ndsa, (void(*)(void *)) ASN1_TYPE_free);

		sk_ASN1_TYPE_pop_free(ndsa, ASN1_TYPE_free);

		break;

	}

	return 1;

crypto/pkcs7/pk7_attr.c

+9 −7
Original line number Diff line number Diff line
@@ -14,19 +14,20 @@ 
#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,

	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);
@@ -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;

}

crypto/pkcs7/pk7_mime.c

+56 −50
Original line number Diff line number Diff line
@@ -69,17 +69,20 @@ 
 * parameter values. Quotes are stripped off

 */



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);

}