Attachment #231019 for bug #304427

Lines 218-225 Link Here

(-)ext/openssl/ossl_x509attr.c (-2 / +3 lines)
218	ossl_str_adjust(str, p);	218	ossl_str_adjust(str, p);
219	}	219	}
220	else{	220	else{
221	length = i2d_ASN1_SET_OF_ASN1_TYPE(attr->value.set, NULL,	221	length = i2d_ASN1_SET_OF_ASN1_TYPE(attr->value.set,
222	i2d_ASN1_TYPE, V_ASN1_SET, V_ASN1_UNIVERSAL, 0);	222	(unsigned char **) NULL, i2d_ASN1_TYPE,
		223	V_ASN1_SET, V_ASN1_UNIVERSAL, 0);
223	str = rb_str_new(0, length);	224	str = rb_str_new(0, length);
224	p = (unsigned char *)RSTRING_PTR(str);	225	p = (unsigned char *)RSTRING_PTR(str);
225	i2d_ASN1_SET_OF_ASN1_TYPE(attr->value.set, &p,	226	i2d_ASN1_SET_OF_ASN1_TYPE(attr->value.set, &p,

Lines 1291-1300 Link Here

(-)ext/openssl/ossl_ssl.c (-2 / +2 lines)
1291	}	1291	}
1292	chain = SSL_get_peer_cert_chain(ssl);	1292	chain = SSL_get_peer_cert_chain(ssl);
1293	if(!chain) return Qnil;	1293	if(!chain) return Qnil;
1294	num = sk_num(chain);	1294	num = sk_X509_num(chain);
1295	ary = rb_ary_new2(num);	1295	ary = rb_ary_new2(num);
1296	for (i = 0; i < num; i++){	1296	for (i = 0; i < num; i++){
1297	cert = (X509*)sk_value(chain, i);	1297	cert = sk_X509_value(chain, i);
1298	rb_ary_push(ary, ossl_x509_new(cert));	1298	rb_ary_push(ary, ossl_x509_new(cert));
1299	}	1299	}
1300		1300





#define OSSL_IMPL_SK2ARY(name, type)	        \
VALUE						\
ossl_##name##_sk2ary(STACK_OF(type) *sk)	\
{						\
    type *t;					\
    int i, num;					\

	OSSL_Debug("empty sk!");		\
	return Qnil;				\
    }						\
    num = sk_##type##_num(sk);			\
    if (num < 0) {				\
	OSSL_Debug("items in sk < -1???");	\
	return rb_ary_new();			\

    ary = rb_ary_new2(num);			\
						\
    for (i=0; i<num; i++) {			\
	t = sk_##type##_value(sk, i);		\
	rb_ary_push(ary, ossl_##name##_new(t));	\
    }						\
    return ary;					\

Lines 108-113 Link Here

(-)ext/openssl/ossl.h (+7 lines)
108	} while (0)	108	} while (0)
109		109
110	/*	110	/*
		111	* Compatibility
		112	*/
		113	#if OPENSSL_VERSION_NUMBER >= 0x10000000L
		114	#define STACK _STACK
		115	#endif
		116
		117	/*
111	* String to HEXString conversion	118	* String to HEXString conversion
112	*/	119	*/
113	int string2hex(const unsigned char , int, char , int );	120	int string2hex(const unsigned char , int, char , int );

Lines 264-270 Link Here

(-)ext/openssl/ossl_x509crl.c (-2 / +2 lines)
264	VALUE ary, revoked;	264	VALUE ary, revoked;
265		265
266	GetX509CRL(self, crl);	266	GetX509CRL(self, crl);
267	num = sk_X509_CRL_num(X509_CRL_get_REVOKED(crl));	267	num = sk_X509_REVOKED_num(X509_CRL_get_REVOKED(crl));
268	if (num < 0) {	268	if (num < 0) {
269	OSSL_Debug("num < 0???");	269	OSSL_Debug("num < 0???");
270	return rb_ary_new();	270	return rb_ary_new();
Lines 272-278 Link Here
272	ary = rb_ary_new2(num);	272	ary = rb_ary_new2(num);
273	for(i=0; i<num; i++) {	273	for(i=0; i<num; i++) {
274	/* NO DUP - don't free! */	274	/* NO DUP - don't free! */
275	rev = (X509_REVOKED *)sk_X509_CRL_value(X509_CRL_get_REVOKED(crl), i);	275	rev = sk_X509_REVOKED_value(X509_CRL_get_REVOKED(crl), i);
276	revoked = ossl_x509revoked_new(rev);	276	revoked = ossl_x509revoked_new(rev);
277	rb_ary_push(ary, revoked);	277	rb_ary_push(ary, revoked);
278	}	278	}




    return self;
}

static STACK_OF(X509) *
pkcs7_get_certs(VALUE self)
{
    PKCS7 *pkcs7;
    STACK_OF(X509) *certs;
    int i;

    GetPKCS7(self, pkcs7);
    i = OBJ_obj2nid(pkcs7->type);
    switch(i){
    case NID_pkcs7_signed:
        certs = pkcs7->d.sign->cert;
        break;
    case NID_pkcs7_signedAndEnveloped:
        certs = pkcs7->d.signed_and_enveloped->cert;
        break;
    default:
        certs = NULL;
    }

    return certs;
}

static STACK_OF(X509_CRL) *
pkcs7_get_crls(VALUE self)
{
    PKCS7 *pkcs7;
    STACK_OF(X509_CRL) *crls;
    int i;


    i = OBJ_obj2nid(pkcs7->type);
    switch(i){
    case NID_pkcs7_signed:
        certs = pkcs7->d.sign->cert;
        crls = pkcs7->d.sign->crl;
        break;
    case NID_pkcs7_signedAndEnveloped:
        certs = pkcs7->d.signed_and_enveloped->cert;
        crls = pkcs7->d.signed_and_enveloped->crl;
        break;
    default:
        crls = NULL;
    }

    return crls;
}

static VALUE

    STACK_OF(X509) *certs;
    X509 *cert;

    certs = pkcs7_get_certs(self);
    while((cert = sk_X509_pop(certs))) X509_free(cert);
    rb_block_call(ary, rb_intern("each"), 0, 0, ossl_pkcs7_set_certs_i, self);


static VALUE
ossl_pkcs7_get_certificates(VALUE self)
{
    return ossl_x509_sk2ary(pkcs7_get_certs(self));
}

static VALUE

    STACK_OF(X509_CRL) *crls;
    X509_CRL *crl;

    crls = pkcs7_get_crls(self);
    while((crl = sk_X509_CRL_pop(crls))) X509_CRL_free(crl);
    rb_block_call(ary, rb_intern("each"), 0, 0, ossl_pkcs7_set_crls_i, self);


static VALUE
ossl_pkcs7_get_crls(VALUE self)
{
    return ossl_x509crl_sk2ary(pkcs7_get_crls(self));
}

static VALUE

Return to bug 304427

Lines 572-582 Link Here

(-)ext/openssl/ossl_pkcs7.c (-10 / +30 lines)
572	return self;	572	return self;
573	}	573	}
574		574
575	static STACK *	575	static STACK_OF(X509) *
576	pkcs7_get_certs_or_crls(VALUE self, int want_certs)	576	pkcs7_get_certs(VALUE self)
577	{	577	{
578	PKCS7 *pkcs7;	578	PKCS7 *pkcs7;
579	STACK_OF(X509) *certs;	579	STACK_OF(X509) *certs;
		580	int i;
		581
		582	GetPKCS7(self, pkcs7);
		583	i = OBJ_obj2nid(pkcs7->type);
		584	switch(i){
		585	case NID_pkcs7_signed:
		586	certs = pkcs7->d.sign->cert;
		587	break;
		588	case NID_pkcs7_signedAndEnveloped:
		589	certs = pkcs7->d.signed_and_enveloped->cert;
		590	break;
		591	default:
		592	certs = NULL;
		593	}
		594
		595	return certs;
		596	}
		597
		598	static STACK_OF(X509_CRL) *
		599	pkcs7_get_crls(VALUE self)
		600	{
		601	PKCS7 *pkcs7;
580	STACK_OF(X509_CRL) *crls;	602	STACK_OF(X509_CRL) *crls;
581	int i;	603	int i;
582		604
Lines 584-601 Link Here
584	i = OBJ_obj2nid(pkcs7->type);	606	i = OBJ_obj2nid(pkcs7->type);
585	switch(i){	607	switch(i){
586	case NID_pkcs7_signed:	608	case NID_pkcs7_signed:
587	certs = pkcs7->d.sign->cert;
588	crls = pkcs7->d.sign->crl;	609	crls = pkcs7->d.sign->crl;
589	break;	610	break;
590	case NID_pkcs7_signedAndEnveloped:	611	case NID_pkcs7_signedAndEnveloped:
591	certs = pkcs7->d.signed_and_enveloped->cert;
592	crls = pkcs7->d.signed_and_enveloped->crl;	612	crls = pkcs7->d.signed_and_enveloped->crl;
593	break;	613	break;
594	default:	614	default:
595	certs = crls = NULL;	615	crls = NULL;
596	}	616	}
597		617
598	return want_certs ? certs : crls;	618	return crls;
599	}	619	}
600		620
601	static VALUE	621	static VALUE
Lines 610-616 Link Here
610	STACK_OF(X509) *certs;	630	STACK_OF(X509) *certs;
611	X509 *cert;	631	X509 *cert;
612		632
613	certs = pkcs7_get_certs_or_crls(self, 1);	633	certs = pkcs7_get_certs(self);
614	while((cert = sk_X509_pop(certs))) X509_free(cert);	634	while((cert = sk_X509_pop(certs))) X509_free(cert);
615	rb_block_call(ary, rb_intern("each"), 0, 0, ossl_pkcs7_set_certs_i, self);	635	rb_block_call(ary, rb_intern("each"), 0, 0, ossl_pkcs7_set_certs_i, self);
616		636
Lines 620-626 Link Here
620	static VALUE	640	static VALUE
621	ossl_pkcs7_get_certificates(VALUE self)	641	ossl_pkcs7_get_certificates(VALUE self)
622	{	642	{
623	return ossl_x509_sk2ary(pkcs7_get_certs_or_crls(self, 1));	643	return ossl_x509_sk2ary(pkcs7_get_certs(self));
624	}	644	}
625		645
626	static VALUE	646	static VALUE
Lines 650-656 Link Here
650	STACK_OF(X509_CRL) *crls;	670	STACK_OF(X509_CRL) *crls;
651	X509_CRL *crl;	671	X509_CRL *crl;
652		672
653	crls = pkcs7_get_certs_or_crls(self, 0);	673	crls = pkcs7_get_crls(self);
654	while((crl = sk_X509_CRL_pop(crls))) X509_CRL_free(crl);	674	while((crl = sk_X509_CRL_pop(crls))) X509_CRL_free(crl);
655	rb_block_call(ary, rb_intern("each"), 0, 0, ossl_pkcs7_set_crls_i, self);	675	rb_block_call(ary, rb_intern("each"), 0, 0, ossl_pkcs7_set_crls_i, self);
656		676
Lines 660-666 Link Here
660	static VALUE	680	static VALUE
661	ossl_pkcs7_get_crls(VALUE self)	681	ossl_pkcs7_get_crls(VALUE self)
662	{	682	{
663	return ossl_x509crl_sk2ary(pkcs7_get_certs_or_crls(self, 0));	683	return ossl_x509crl_sk2ary(pkcs7_get_crls(self));
664	}	684	}
665		685
666	static VALUE	686	static VALUE

Lines 92-98 Link Here

(-)ext/openssl/ossl.c (-3 / +3 lines)
92		92
93	#define OSSL_IMPL_SK2ARY(name, type) \	93	#define OSSL_IMPL_SK2ARY(name, type) \
94	VALUE \	94	VALUE \
95	ossl_##name##_sk2ary(STACK *sk) \	95	ossl_##name##_sk2ary(STACK_OF(type) *sk) \
96	{ \	96	{ \
97	type *t; \	97	type *t; \
98	int i, num; \	98	int i, num; \
Lines 102-108 Link Here
102	OSSL_Debug("empty sk!"); \	102	OSSL_Debug("empty sk!"); \
103	return Qnil; \	103	return Qnil; \
104	} \	104	} \
105	num = sk_num(sk); \	105	num = sk_##type##_num(sk); \
106	if (num < 0) { \	106	if (num < 0) { \
107	OSSL_Debug("items in sk < -1???"); \	107	OSSL_Debug("items in sk < -1???"); \
108	return rb_ary_new(); \	108	return rb_ary_new(); \
Lines 110-116 Link Here
110	ary = rb_ary_new2(num); \	110	ary = rb_ary_new2(num); \
111	\	111	\
112	for (i=0; i<num; i++) { \	112	for (i=0; i<num; i++) { \
113	t = (type *)sk_value(sk, i); \	113	t = sk_##type##_value(sk, i); \
114	rb_ary_push(ary, ossl_##name##_new(t)); \	114	rb_ary_push(ary, ossl_##name##_new(t)); \
115	} \	115	} \
116	return ary; \	116	return ary; \