[ViewVC] Diff of: cvs/OpenSSL/OpenSSL.xs

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.2 by root, Sat Oct 27 02:40:45 2001 UTC vs.
Revision 1.14 by root, Sun Oct 28 03:20:00 2001 UTC

…		…
32	#define XD(...)	32	#define XD(...)
33	#endif	33	#endif
34		34
35	static const char *ssl_error(void);	35	static const char *ssl_error(void);
36		36
37	#define GEN_INPUT(type,class) \
38	static inline type * input_##type(SV *sv) { \
39	XD("GEN_INPUT " class " sv=%p\n", sv); \
40	if(sv_derived_from(sv, class)) \
41	return (type *) SvIV(SvRV(sv)); \
42	croak("Not a reference to a " class " object"); \
43	return (type *) 0; }
44
45
46	#define GEN_OUTPUT(type,class) \
47	static inline SV* output_##type(type foobar, SV sv) { \
48	XD("GEN_OUTPUT " class " sv=%p\n", sv); \
49	return sv_setref_pv(sv, class, (void *) foobar); \
50	}
51
52
53	#define GEN_IO(type,class) \
54	GEN_INPUT(type,class) \
55	GEN_OUTPUT(type,class)
56
57
58	GEN_IO(X509,"OpenSSL::X509")
59	GEN_IO(X509_CRL,"OpenSSL::CRL")
60	GEN_IO(X509_NAME, "OpenSSL::Name")
61	GEN_IO(PKCS12, "OpenSSL::PKCS12")
62	GEN_IO(PKCS7, "OpenSSL::PKCS7")
63	GEN_IO(RSA, "OpenSSL::RSA")
64	GEN_IO(EVP_MD_CTX, "OpenSSL::Digest")
65	GEN_IO(EVP_CIPHER_CTX, "OpenSSL::Cipher")
66
67	typedef X509 *OpenSSL__X509;	37	typedef X509 *OpenSSL__X509;
		38	typedef X509_CRL *OpenSSL__CRL;
		39	typedef X509_NAME *OpenSSL__Name;
		40	typedef PKCS7 *OpenSSL__PKCS7;
		41	typedef PKCS12 *OpenSSL__PKCS12;
		42	typedef RSA *OpenSSL__RSA;
		43	typedef EVP_MD_CTX *OpenSSL__Digest;
		44	typedef EVP_CIPHER_CTX *OpenSSL__Cipher;
68		45
69	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)	46	static inline SV* output_ASN1_INTEGER(ASN1_INTEGER ai, SV sv)
70	{	47	{
71	if(!ai)	48	if(!ai)
72	croak("got 0-ptr");	49	croak("got 0-ptr");
…		…
114	}	91	}
115	sv_setpv(sv, buf);	92	sv_setpv(sv, buf);
116	return sv;	93	return sv;
117	}	94	}
118		95
119	long fuck_cb(struct bio_st bm, int m, const char ptr, int l, long x, long y)	96	long bio_write_cb(struct bio_st bm, int m, const char ptr, int l, long x, long y)
120	{	97	{
121	if(m == BIO_CB_WRITE) {	98	if(m == BIO_CB_WRITE) {
122	SV sv = (SV ) BIO_get_callback_arg(bm);	99	SV sv = (SV ) BIO_get_callback_arg(bm);
123	sv_catpvn(sv, ptr, l);	100	sv_catpvn(sv, ptr, l);
124	}	101	}
…		…
136	BIO *bio;	113	BIO *bio;
137	sv = newSVpvn("",0);	114	sv = newSVpvn("",0);
138	// mem is completely broken for write, so we use /dev/null	115	// mem is completely broken for write, so we use /dev/null
139	// and use callbacks-hooks	116	// and use callbacks-hooks
140	bio = BIO_new_file("/dev/null", "wb");	117	bio = BIO_new_file("/dev/null", "wb");
141	BIO_set_callback(bio, fuck_cb);	118	BIO_set_callback(bio, bio_write_cb);
142	BIO_set_callback_arg(bio, (void *)sv);	119	BIO_set_callback_arg(bio, (void *)sv);
143	return bio;	120	return bio;
144	}	121	}
145		122
146	static inline BIO sv_bio_create_file(SV filename)	123	static inline BIO sv_bio_create_file(SV filename)
147	{	124	{
148	char *fn;
149	STRLEN l;	125	STRLEN l;
150		126
151	return BIO_new_file(SvPV(filename, l), "wb");	127	return BIO_new_file(SvPV(filename, l), "wb");
152	}	128	}
153		129
…		…
315	sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');	291	sprintf(&s[i*3], "%02X%c", md[i], (i + 1 == (int) n) ? '\0' : ':');
316	}	292	}
317	return s;	293	return s;
318	}	294	}
319		295
320	static inline char ol(X509_NAME x)	296	static inline SV ol(X509_NAME x)
321	{	297	{
322	static char buf[256];	298	char *p;
323	X509_NAME_oneline(x, buf, 256);	299	SV *sv = newSVpvn("",0);
		300	X509_NAME_oneline(x, (p=SvGROW(sv,8192)), 8192);
		301	SvCUR_set(sv, strlen(p));
324	return buf;	302	return sv;
325	}	303	}
326		304
		305	#if 0
327	static void run_sha1(char digest, const char msg, int msglen)	306	static void run_sha1(char digest, const char msg, int msglen)
328	{	307	{
329	SHA_CTX ctx;	308	SHA_CTX ctx;
330		309
331	if(!digest \|\| !msg \|\| msglen < 0)	310	if(!digest \|\| !msg \|\| msglen < 0)
332	croak("run_sha1: null pointer or illegal message len");	311	croak("run_sha1: null pointer or illegal message len");
333	SHA1_Init(&ctx);	312	SHA1_Init(&ctx);
334	SHA1_Update(&ctx, msg, msglen);	313	SHA1_Update(&ctx, msg, msglen);
335	SHA1_Final(digest, &ctx);	314	SHA1_Final(digest, &ctx);
336	}	315	}
337		316	#endif
338	static bool is_privkey(RSA *key)	317	static bool is_privkey(RSA *key)
339	{	318	{
340	return (key->n && key->e && key->d && key->p && key->q	319	return (key->n && key->e && key->d && key->p && key->q
341	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;	320	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;
342	}	321	}
…		…
413	}	392	}
414		393
415		394
416	MODULE = OpenSSL PACKAGE = OpenSSL::RSA	395	MODULE = OpenSSL PACKAGE = OpenSSL::RSA
417		396
418	void	397	OpenSSL::RSA
419	new_keygen(bits = 128, e = 35)	398	new_keygen(bits = 128, e = 35)
420	IV bits	399	IV bits
421	IV e	400	IV e
422	PREINIT:
423	RSA *key;
424	PPCODE:	401	CODE:
425	if(!(key = RSA_generate_key(bits, e, NULL, NULL)))	402	if(!(RETVAL = RSA_generate_key(bits, e, NULL, NULL)))
426	croak("RSA_generate_key");	403	croak("RSA_generate_key");
427	EXTEND(sp, 1);	404	OUTPUT:
428	PUSHs(sv_newmortal());	405	RETVAL
429	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
430		406
431	void	407	OpenSSL::RSA
432	new_pubkey(n, e)	408	new_pubkey(n, e)
433	char *n	409	char *n
434	char *e	410	char *e
435	PREINIT:
436	RSA *key;
437	PPCODE:	411	CODE:
438	EXTEND(sp, 1);
439	PUSHs(sv_newmortal());
440	key = RSA_new();	412	RETVAL = RSA_new();
441	if (!key)	413	if (!RETVAL)
442	croak("can't allocate key");	414	croak("can't allocate key");
443	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	415	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
444	RSA_free(key); croak("can't initialize n");	416	RSA_free(RETVAL); croak("can't initialize n");
445	}	417	}
446	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	418	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
447	RSA_free(key); croak("can't initialize e");	419	RSA_free(RETVAL); croak("can't initialize e");
448	}	420	}
449	//key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0;	421	//key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0;
450	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	422	OUTPUT:
		423	RETVAL
451		424
452		425
453	void	426	OpenSSL::RSA
454	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)	427	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
455	char *n	428	char *n
456	char *e	429	char *e
457	char *p	430	char *p
458	char *q	431	char *q
459	char *dmp1	432	char *dmp1
460	char *dmq1	433	char *dmq1
461	char *iqmp	434	char *iqmp
462	char *d	435	char *d
463	PREINIT:	436	CODE:
464	RSA *key;
465	int rc;	437	int rc;
466	PPCODE:	438
467	EXTEND(sp, 1);
468	PUSHs(sv_newmortal());
469	key = RSA_new();	439	RETVAL = RSA_new();
470	if (!key)	440	if (!RETVAL)
471	croak("can't allocate key");	441	croak("can't allocate key");
472	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	442	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
473	RSA_free(key); croak("can't initialize n");	443	RSA_free(RETVAL); croak("can't initialize n");
474	}	444	}
475	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	445	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
476	RSA_free(key); croak("can't initialize e");	446	RSA_free(RETVAL); croak("can't initialize e");
477	}	447	}
478	if(!(key->p = BN_new()) \|\| !BN_dec2bn(&key->p, p)) {	448	if(!(RETVAL->p = BN_new()) \|\| !BN_dec2bn(&RETVAL->p, p)) {
479	RSA_free(key); croak("can't initialize p");	449	RSA_free(RETVAL); croak("can't initialize p");
480	}	450	}
481	if(!(key->q = BN_new()) \|\| !BN_dec2bn(&key->q, q)) {	451	if(!(RETVAL->q = BN_new()) \|\| !BN_dec2bn(&RETVAL->q, q)) {
482	RSA_free(key); croak("can't initialize q");	452	RSA_free(RETVAL); croak("can't initialize q");
483	}	453	}
484	if(!(key->dmp1 = BN_new()) \|\| !BN_dec2bn(&key->dmp1, dmp1)) {	454	if(!(RETVAL->dmp1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
485	RSA_free(key); croak("can't initialize dmp1");	455	RSA_free(RETVAL); croak("can't initialize dmp1");
486	}	456	}
487	if(!(key->dmq1 = BN_new()) \|\| !BN_dec2bn(&key->dmq1, dmq1)) {	457	if(!(RETVAL->dmq1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
488	RSA_free(key); croak("can't initialize dmq1");	458	RSA_free(RETVAL); croak("can't initialize dmq1");
489	}	459	}
490	if(!(key->iqmp = BN_new()) \|\| !BN_dec2bn(&key->iqmp, iqmp)) {	460	if(!(RETVAL->iqmp = BN_new()) \|\| !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
491	RSA_free(key); croak("can't initialize iqmp");	461	RSA_free(RETVAL); croak("can't initialize iqmp");
492	}	462	}
493	if(!(key->d = BN_new()) \|\| !BN_dec2bn(&key->d, d)) {	463	if(!(RETVAL->d = BN_new()) \|\| !BN_dec2bn(&RETVAL->d, d)) {
494	RSA_free(key); croak("can't initialize d");	464	RSA_free(RETVAL); croak("can't initialize d");
495	}	465	}
496	if((rc = RSA_check_key(key)) != 1) {	466	if((rc = RSA_check_key(RETVAL)) != 1) {
497	RSA_free(key); croak("RSA_check_key failed (%d).", rc);	467	RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
498	}	468	}
499	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	469	OUTPUT:
		470	RETVAL
500		471
501		472
502	void	473	void
503	DESTROY(key)	474	DESTROY(key)
504	RSA* key	475	OpenSSL::RSA key
505	CODE:	476	CODE:
506	if (key) {	477	if (key) {
507	XD("RSA_free(%p)\n", key);	478	XD("RSA_free(%p)\n", key);
508	RSA_free(key);	479	RSA_free(key);
509	}	480	}
510		481
511	IV	482	IV
512	keysize(key)	483	keysize(key)
513	RSA *key;	484	OpenSSL::RSA key;
514	CODE:	485	CODE:
515	if (!key \|\| !key->n)	486	if (!key \|\| !key->n)
516	croak("invalid key");	487	croak("invalid key");
517	RETVAL = BN_num_bits(key->n);	488	RETVAL = BN_num_bits(key->n);
518	OUTPUT:	489	OUTPUT:
519	RETVAL	490	RETVAL
520		491
521	bool	492	bool
522	check_key(key)	493	check_key(key)
523	RSA *key;	494	OpenSSL::RSA key;
524	PPCODE:	495	PPCODE:
525	if(!key)	496	if(!key)
526	XSRETURN_NO;	497	XSRETURN_NO;
527	if(RSA_check_key(key) == 1)	498	if(RSA_check_key(key) == 1)
528	XSRETURN_YES;	499	XSRETURN_YES;
529	XSRETURN_NO;	500	XSRETURN_NO;
530		501
531		502
532	BIGNUM *	503	BIGNUM *
533	n(key)	504	n(key)
534	RSA *key;	505	OpenSSL::RSA key;
535	ALIAS:	506	ALIAS:
536	e = 1	507	e = 1
537	d = 2	508	d = 2
538	p = 3	509	p = 3
539	q = 4	510	q = 4
…		…
564	RETVAL	535	RETVAL
565		536
566		537
567	bool	538	bool
568	is_privkey(key)	539	is_privkey(key)
569	RSA *key;	540	OpenSSL::RSA key;
570	CODE:	541	CODE:
571	RETVAL = is_privkey(key);	542	RETVAL = is_privkey(key);
572	OUTPUT:	543	OUTPUT:
573	RETVAL	544	RETVAL
574		545
…		…
620		591
621		592
622		593
623	void	594	void
624	STORABLE_freeze(key, cloning)	595	STORABLE_freeze(key, cloning)
625	RSA *key	596	OpenSSL::RSA key
626	bool cloning	597	bool cloning
627	PREINIT:	598	PREINIT:
628	SV *sv;
629	STRLEN totlen;	599	STRLEN totlen;
630	PPCODE:	600	PPCODE:
631	if(cloning)	601	if(cloning)
632	return;	602	return;
633	totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);	603	totlen = BN_num_bytes(key->n) + BN_num_bytes(key->e) + 3*sizeof(int);
…		…
677	}	647	}
678		648
679		649
680	SV *	650	SV *
681	public_encrypt(key, sv)	651	public_encrypt(key, sv)
682	RSA *key;	652	OpenSSL::RSA key;
683	SV *sv;	653	SV *sv;
684	ALIAS:	654	ALIAS:
685	encrypt = 4	655	encrypt = 4
686	public_decrypt = 1	656	public_decrypt = 1
687	verify = 5	657	verify = 5
…		…
720	RETVAL	690	RETVAL
721		691
722		692
723	void	693	void
724	fingerprint(key)	694	fingerprint(key)
725	RSA *key	695	OpenSSL::RSA key
726	PREINIT:	696	PREINIT:
727	char *x;	697	char *x;
728	char dig[SHA_DIGEST_LENGTH];	698	char dig[SHA_DIGEST_LENGTH];
729	int nlen, elen;	699	int nlen, elen;
730	PPCODE:	700	PPCODE:
…		…
741		711
742	MODULE = OpenSSL PACKAGE = OpenSSL::Name	712	MODULE = OpenSSL PACKAGE = OpenSSL::Name
743		713
744	PROTOTYPES: ENABLE	714	PROTOTYPES: ENABLE
745		715
746	void	716	OpenSSL::Name
747	new_name()	717	new(class)
748	PREINIT:	718	SV *class
749	X509_NAME *name;
750	PPCODE:	719	CODE:
751	if(!(name = X509_NAME_new())) {	720	if(!(RETVAL = X509_NAME_new())) {
752	croak("X509_NAME_new");	721	croak("X509_NAME_new");
753	}	722	}
754	EXTEND(sp, 1);	723	OUTPUT:
755	PUSHs(sv_newmortal());	724	RETVAL
756	sv_setref_pv(ST(0), "OpenSSL::Name", (void *) name);
757		725
758		726
759	void	727	void
760	add(name, key, string)	728	add(name, key, string)
761	X509_NAME *name	729	OpenSSL::Name name
762	SV *key	730	SV *key
763	SV *string	731	SV *string
764	PREINIT:	732	PREINIT:
765	STRLEN l, kl;	733	STRLEN l, kl;
766	char p, k;	734	char p, k;
…		…
776	if(!ok)	744	if(!ok)
777	croak("X509_NAME_add_entry_by_*: %s", ssl_error());	745	croak("X509_NAME_add_entry_by_*: %s", ssl_error());
778		746
779	IV	747	IV
780	count(name)	748	count(name)
781	X509_NAME *name	749	OpenSSL::Name name
782	CODE:	750	CODE:
783	RETVAL = X509_NAME_entry_count(name);	751	RETVAL = X509_NAME_entry_count(name);
784	OUTPUT:	752	OUTPUT:
785	RETVAL	753	RETVAL
786		754
787	void	755	void
788	getall(name)	756	getall(name)
789	X509_NAME *name	757	OpenSSL::Name name
790	PREINIT:	758	PREINIT:
791	int cnt, i;	759	int cnt, i;
792	X509_NAME_ENTRY *e;	760	X509_NAME_ENTRY *e;
793	int nid;	761	int nid;
794	ASN1_STRING *s;	762	ASN1_STRING *s;
…		…
803	s = X509_NAME_ENTRY_get_data(e);	771	s = X509_NAME_ENTRY_get_data(e);
804	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));	772	PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));
805	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));	773	PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));
806	}	774	}
807		775
808
809
810
811
812	void	776	void
813	DESTROY(name)	777	DESTROY(name)
814	X509_NAME *name	778	OpenSSL::Name name
815	CODE:	779	CODE:
816	if(name) {	780	if(name) {
817	XD("X509_NAME_free(%p)\n", name);	781	XD("X509_NAME_free(%p)\n", name);
818	X509_NAME_free(name);	782	X509_NAME_free(name);
819	}	783	}
…		…
902	ERR_load_DSA_strings();	866	ERR_load_DSA_strings();
903	ERR_load_RSA_strings();	867	ERR_load_RSA_strings();
904	}	868	}
905		869
906		870
907	void	871	OpenSSL::X509
908	new_X509()	872	new(class)
909	PREINIT:	873	SV *class
910	X509 *x509;	874	CODE:
911	PPCODE:
912	if((x509=X509_new()) == NULL)	875	if ((RETVAL = X509_new ()) == NULL)
913	croak("X509_new");	876	croak("X509_new");
		877
914	if(!X509_set_version(x509, 2)) {	878	if (!X509_set_version (RETVAL, 2))
915	X509_free(x509);	879	{
		880	X509_free (RETVAL);
916	croak("X509_set_version");	881	croak ("X509_set_version");
917	}	882	}
		883
918	ASN1_INTEGER_set(X509_get_serialNumber(x509),0L);	884	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
919	EXTEND(sp, 1);	885	OUTPUT:
920	PUSHs(sv_newmortal());	886	RETVAL
921	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
922		887
923		888
924	void	889	OpenSSL::X509
925	new_from_string(thing)	890	new_from_string(class,thing)
		891	SV *class
926	SV *thing	892	SV *thing
927	ALIAS:	893	ALIAS:
928	new_from_file = 1	894	new_from_file = 1
929	PREINIT:	895	PREINIT:
930	BIO *bio;	896	BIO *bio;
931	X509 *x509;
932	STRLEN l;	897	STRLEN l;
933	char p, q = 0;	898	char *p;
934	PPCODE:	899	CODE:
935	p = SvPV(thing, l);	900	p = SvPV (thing, l);
936	if(ix == 1) {	901	if(ix == 1) {
937	bio = BIO_new_file(p, "r");	902	bio = BIO_new_file(p, "r");
938	} else {	903	} else {
939	bio = BIO_new_mem_buf (p, l);	904	bio = BIO_new_mem_buf (p, l);
940	}	905	}
941	if(!bio)	906	if(!bio)
942	croak(ssl_error());	907	croak(ssl_error());
943		908
944	x509 = PEM_read_bio_X509 (bio, 0, 0, 0);	909	RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
945	BIO_free (bio);	910	BIO_free (bio);
946	if(!x509)	911	if(!RETVAL)
947	croak("PEM_read_bio_X509: %s", ssl_error());	912	croak("PEM_read_bio_X509: %s", ssl_error());
948		913
949	EXTEND(sp, 1);	914	OUTPUT:
950	PUSHs(sv_newmortal());	915	RETVAL
951	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
952		916
953	void	917	void
954	DESTROY(x509)	918	DESTROY(x509)
955	OpenSSL::X509 x509	919	OpenSSL::X509 x509
956	CODE:	920	CODE:
957	if (x509) {	921	if (x509) {
958	XD("X509_free(%p)\n", x509);	922	XD("X509_free(%p)\n", x509);
959	X509_free(x509);	923	X509_free (x509);
960	x509 = 0;	924	x509 = 0;
961	}	925	}
962		926
963		927
964	char *	928	char *
…		…
974	RETVAL = dofp(x509, mds[ix]);	938	RETVAL = dofp(x509, mds[ix]);
975	OUTPUT:	939	OUTPUT:
976	RETVAL	940	RETVAL
977		941
978		942
979	X509_NAME *	943	OpenSSL::Name
980	subject(x509)	944	subject(x509)
981	OpenSSL::X509 x509	945	OpenSSL::X509 x509
982	CODE:	946	CODE:
983	RETVAL = X509_get_subject_name(x509);	947	RETVAL = X509_NAME_dup (X509_get_subject_name(x509));
984	OUTPUT:	948	OUTPUT:
985	RETVAL	949	RETVAL
986		950
987	X509_NAME *	951	OpenSSL::Name
988	issuer(x509)	952	issuer(x509)
989	OpenSSL::X509 x509	953	OpenSSL::X509 x509
990	CODE:	954	CODE:
991	RETVAL = X509_get_issuer_name(x509);	955	RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
992	OUTPUT:	956	OUTPUT:
993	RETVAL	957	RETVAL
994		958
995		959
996	char *	960	SV *
997	subject_txt(x509)	961	subject_txt(x509)
998	OpenSSL::X509 x509	962	OpenSSL::X509 x509
999	CODE:	963	CODE:
1000	RETVAL = ol(X509_get_subject_name(x509));	964	RETVAL = ol(X509_get_subject_name(x509));
1001	OUTPUT:	965	OUTPUT:
1002	RETVAL	966	RETVAL
1003		967
1004		968
1005	char *	969	SV *
1006	issuer_txt(x509)	970	issuer_txt(x509)
1007	OpenSSL::X509 x509	971	OpenSSL::X509 x509
1008	CODE:	972	CODE:
1009	RETVAL = ol(X509_get_issuer_name(x509));	973	RETVAL = ol(X509_get_issuer_name(x509));
1010	OUTPUT:	974	OUTPUT:
…		…
1092	OUTPUT:	1056	OUTPUT:
1093	RETVAL	1057	RETVAL
1094		1058
1095	void	1059	void
1096	set_issuer(x509,name)	1060	set_issuer(x509,name)
1097	X509 *x509	1061	OpenSSL::X509 x509
1098	X509_NAME *name	1062	OpenSSL::Name name
1099	CODE:	1063	CODE:
1100	X509_set_issuer_name(x509, X509_NAME_dup(name));	1064	X509_set_issuer_name(x509, X509_NAME_dup(name));
1101		1065
1102	void	1066	void
1103	set_subject(x509,name)	1067	set_subject(x509,name)
1104	X509 *x509	1068	OpenSSL::X509 x509
1105	X509_NAME *name	1069	OpenSSL::Name name
1106	CODE:	1070	CODE:
1107	X509_set_subject_name(x509, X509_NAME_dup(name));	1071	X509_set_subject_name(x509, X509_NAME_dup(name));
1108		1072
1109	SV *	1073	SV *
1110	errstring(x509)	1074	errstring(x509)
…		…
1129	cipher_boot();	1093	cipher_boot();
1130	}	1094	}
1131		1095
1132	void	1096	void
1133	DESTROY(ctx)	1097	DESTROY(ctx)
1134	EVP_CIPHER_CTX *ctx	1098	OpenSSL::Cipher ctx
1135	CODE:	1099	CODE:
1136	if(ctx) {	1100	if(ctx) {
1137	EVP_CIPHER_CTX_cleanup(ctx);	1101	EVP_CIPHER_CTX_cleanup(ctx);
1138	free(ctx);	1102	free(ctx);
1139	}	1103	}
1140		1104
1141	void	1105	OpenSSL::Cipher
1142	new_decrypt(...)	1106	new_decrypt(...)
1143	ALIAS:	1107	ALIAS:
1144	new_encrypt = 1	1108	new_encrypt = 1
1145	PREINIT:	1109	PREINIT:
1146	char *name;	1110	char *name;
1147	SV *svkey;	1111	SV *svkey;
1148	EVP_CIPHER *ci;	1112	EVP_CIPHER *ci;
1149	EVP_CIPHER_CTX *ctx;
1150	char *key;	1113	char *key;
1151	char iv[EVP_MAX_IV_LENGTH];	1114	char iv[EVP_MAX_IV_LENGTH];
1152	char k[EVP_MAX_KEY_LENGTH];	1115	char k[EVP_MAX_KEY_LENGTH];
1153	int rc;	1116	int rc;
1154	STRLEN keylen;	1117	STRLEN keylen;
1155	PPCODE:	1118	CODE:
1156	if(items < 2 \|\| items > 3) {	1119	if(items < 2 \|\| items > 3) {
1157	croak("usage: new_[en\|de]crypt(ciphname,key)");	1120	croak("usage: new_[en\|de]crypt(ciphname,key)");
1158	}	1121	}
1159	name = SvPV_nolen(ST(items -2));	1122	name = SvPV_nolen(ST(items -2));
1160	svkey = ST(items - 1);	1123	svkey = ST(items - 1);
1161	memset(iv, 0, EVP_MAX_IV_LENGTH);	1124	memset(iv, 0, EVP_MAX_IV_LENGTH);
1162	memset(k, 0, EVP_MAX_KEY_LENGTH);	1125	memset(k, 0, EVP_MAX_KEY_LENGTH);
1163		1126
1164	if(!(ci = lookup_cipher(name)))	1127	if(!(ci = lookup_cipher(name)))
1165	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);	1128	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1166	ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));	1129	RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1167	if(!ctx)	1130	if(!RETVAL)
1168	croak("malloc error");	1131	croak("malloc error");
1169	key = SvPV(svkey, keylen);	1132	key = SvPV(svkey, keylen);
1170	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);	1133	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1171	rc = EVP_CipherInit(ctx, ci, k, iv, ix);	1134	rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1172	memset(iv, 0, EVP_MAX_IV_LENGTH);	1135	memset(iv, 0, EVP_MAX_IV_LENGTH);
1173	memset(iv, 0, EVP_MAX_KEY_LENGTH);	1136	memset(iv, 0, EVP_MAX_KEY_LENGTH);
1174	if(!rc) {	1137	if(!rc) {
1175	free(ctx);	1138	free(RETVAL);
1176	croak("EVP_CipherInit");	1139	croak("EVP_CipherInit");
1177	}	1140	}
1178	EXTEND(sp, 1);	1141	OUTPUT:
1179	PUSHs(sv_newmortal());	1142	RETVAL
1180	sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1181		1143
1182		1144
1183	SV *	1145	SV *
1184	update(ctx,svin)	1146	update(ctx,svin)
1185	EVP_CIPHER_CTX *ctx	1147	OpenSSL::Cipher ctx
1186	SV *svin	1148	SV *svin
1187	PREINIT:	1149	PREINIT:
1188	unsigned char in, out;	1150	unsigned char in, out;
1189	STRLEN il, ol;	1151	STRLEN il, ol;
1190	CODE:	1152	CODE:
…		…
1204	OUTPUT:	1166	OUTPUT:
1205	RETVAL	1167	RETVAL
1206		1168
1207	SV *	1169	SV *
1208	final(ctx)	1170	final(ctx)
1209	EVP_CIPHER_CTX *ctx	1171	OpenSSL::Cipher ctx
1210	PREINIT:	1172	PREINIT:
1211	STRLEN ol;	1173	STRLEN ol;
1212	unsigned char *out;	1174	unsigned char *out;
1213	CODE:	1175	CODE:
1214	ol = 256;	1176	ol = 256;
…		…
1248	{	1210	{
1249	mds_boot();	1211	mds_boot();
1250	}	1212	}
1251		1213
1252	SV *	1214	SV *
1253	md2(sv)	1215	md2(...)
1254	SV *sv
1255	ALIAS:	1216	ALIAS:
1256	md4 = 0x1	1217	md4 = 0x1
1257	md5 = 0x2	1218	md5 = 0x2
1258	sha = 0x3	1219	sha = 0x3
1259	sha1 = 0x4	1220	sha1 = 0x4
…		…
1277	sha1_base64 = 0x24	1238	sha1_base64 = 0x24
1278	dss_base64 = 0x25	1239	dss_base64 = 0x25
1279	dss1_base64 = 0x26	1240	dss1_base64 = 0x26
1280	mdc2_base64 = 0x27	1241	mdc2_base64 = 0x27
1281	ripemd160_base64 = 0x28	1242	ripemd160_base64 = 0x28
1282	PREINIT:	1243	CODE:
1283	EVP_MD_CTX ctx;	1244	EVP_MD_CTX ctx;
1284	STRLEN l;	1245	STRLEN l;
1285	char *p;	1246	char *p;
1286	unsigned char md[EVP_MAX_MD_SIZE];	1247	unsigned char md[EVP_MAX_MD_SIZE];
1287	unsigned int md_len;	1248	unsigned int md_len;
1288	CODE:	1249	int i;
		1250
1289	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);	1251	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
		1252
		1253	for (i = 0; i < items; i++)
		1254	{
1290	p = SvPV(sv, l);	1255	p = SvPV(ST(i), l);
1291	EVP_DigestUpdate(&ctx, p, l);	1256	EVP_DigestUpdate(&ctx, p, l);
		1257	}
		1258
1292	EVP_DigestFinal(&ctx, md, &md_len);	1259	EVP_DigestFinal(&ctx, md, &md_len);
1293	switch(ix & ~15) {	1260	switch(ix & ~15) {
1294	case 0:	1261	case 0:
1295	RETVAL = newSVpvn(md, md_len);	1262	RETVAL = newSVpvn(md, md_len);
1296	break;	1263	break;
…		…
1303	}	1270	}
1304	OUTPUT:	1271	OUTPUT:
1305	RETVAL	1272	RETVAL
1306		1273
1307		1274
1308	void	1275	OpenSSL::Digest
1309	new_md2()	1276	new_md2()
1310	ALIAS:	1277	ALIAS:
1311	new_md4 = 0x1	1278	new_md4 = 0x1
1312	new_md5 = 0x2	1279	new_md5 = 0x2
1313	mew_sha = 0x3	1280	mew_sha = 0x3
1314	new_sha1 = 0x4	1281	new_sha1 = 0x4
1315	new_dss = 0x5	1282	new_dss = 0x5
1316	new_dss1 = 0x6	1283	new_dss1 = 0x6
1317	new_mdc2 = 0x7	1284	new_mdc2 = 0x7
1318	new_ripemd160 = 0x8	1285	new_ripemd160 = 0x8
1319	PREINIT:
1320	EVP_MD_CTX *ctx;
1321	PPCODE:	1286	CODE:
1322	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1287	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1323	if(!ctx)	1288	if(!RETVAL)
1324	croak("out of memory.");	1289	croak("out of memory.");
1325	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1290	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1326	EXTEND(sp, 1);	1291	OUTPUT:
1327	PUSHs(sv_newmortal());	1292	RETVAL
1328	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1329
1330		1293
1331	void	1294	void
1332	DESTROY(ctx)	1295	DESTROY(ctx)
1333	EVP_MD_CTX *ctx	1296	OpenSSL::Digest ctx
1334	CODE:	1297	CODE:
1335	if(ctx)	1298	if(ctx)
1336	free(ctx);	1299	free(ctx);
1337		1300
1338	void	1301	void
1339	update(ctx, sv)	1302	update(ctx, sv)
1340	EVP_MD_CTX *ctx	1303	OpenSSL::Digest ctx
1341	SV *sv	1304	SV *sv
1342	PREINIT:	1305	PREINIT:
1343	STRLEN l;	1306	STRLEN l;
1344	char *p;	1307	char *p;
1345	CODE:	1308	CODE:
1346	p = SvPV(sv, l);	1309	p = SvPV(sv, l);
1347	EVP_DigestUpdate(ctx, p, l);	1310	EVP_DigestUpdate(ctx, p, l);
1348
1349		1311
1350	SV *	1312	SV *
1351	final(ctx)	1313	final(ctx)
1352	EVP_MD_CTX *ctx	1314	OpenSSL::Digest ctx
1353	ALIAS:	1315	ALIAS:
1354	final_hex = 1	1316	final_hex = 1
1355	final_base64 = 2	1317	final_base64 = 2
1356	PREINIT:	1318	PREINIT:
1357	unsigned char md[EVP_MAX_MD_SIZE];	1319	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1411	dss_base64 = 0x25	1373	dss_base64 = 0x25
1412	dss1_base64 = 0x26	1374	dss1_base64 = 0x26
1413	mdc2_base64 = 0x27	1375	mdc2_base64 = 0x27
1414	ripemd160_base64 = 0x28	1376	ripemd160_base64 = 0x28
1415	PREINIT:	1377	PREINIT:
1416	HMAC_CTX ctx;
1417	STRLEN l, keylen;	1378	STRLEN l, keylen;
1418	char *p;	1379	char *p;
1419	char *key;	1380	char *key;
1420	unsigned char md[EVP_MAX_MD_SIZE];	1381	unsigned char md[EVP_MAX_MD_SIZE];
1421	unsigned int md_len;	1382	unsigned int md_len;
…		…
1437	}	1398	}
1438	OUTPUT:	1399	OUTPUT:
1439	RETVAL	1400	RETVAL
1440		1401
1441		1402
1442	void	1403	OpenSSL::Digest
1443	new_md2(void)	1404	new_md2()
1444	ALIAS:	1405	ALIAS:
1445	new_md4 = 0x1	1406	new_md4 = 0x1
1446	new_md5 = 0x2	1407	new_md5 = 0x2
1447	mew_sha = 0x3	1408	mew_sha = 0x3
1448	new_sha1 = 0x4	1409	new_sha1 = 0x4
1449	new_dss = 0x5	1410	new_dss = 0x5
1450	new_dss1 = 0x6	1411	new_dss1 = 0x6
1451	new_mdc2 = 0x7	1412	new_mdc2 = 0x7
1452	new_ripemd160 = 0x8	1413	new_ripemd160 = 0x8
1453	PREINIT:
1454	EVP_MD_CTX *ctx;
1455	PPCODE:	1414	CODE:
1456	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1415	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1457	if(!ctx)	1416	if(!RETVAL)
1458	croak("out of memory.");	1417	croak("out of memory.");
1459	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1418	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1460	EXTEND(sp, 1);	1419	OUTPUT:
1461	PUSHs(sv_newmortal());	1420	RETVAL
1462	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1463
1464		1421
1465	void	1422	void
1466	DESTROY(ctx)	1423	DESTROY(ctx)
1467	EVP_MD_CTX *ctx	1424	OpenSSL::Digest ctx
1468	CODE:	1425	CODE:
1469	if(ctx)	1426	if(ctx)
1470	free(ctx);	1427	free(ctx);
1471		1428
1472	void	1429	void
1473	update(ctx, sv)	1430	update(ctx, sv)
1474	EVP_MD_CTX *ctx	1431	OpenSSL::Digest ctx
1475	SV *sv	1432	SV *sv
1476	PREINIT:	1433	PREINIT:
1477	STRLEN l;	1434	STRLEN l;
1478	char *p;	1435	char *p;
1479	CODE:	1436	CODE:
…		…
1481	EVP_DigestUpdate(ctx, p, l);	1438	EVP_DigestUpdate(ctx, p, l);
1482		1439
1483		1440
1484	SV *	1441	SV *
1485	final(ctx)	1442	final(ctx)
1486	EVP_MD_CTX *ctx	1443	OpenSSL::Digest ctx
1487	ALIAS:	1444	ALIAS:
1488	final_hex = 1	1445	final_hex = 1
1489	final_base64 = 2	1446	final_base64 = 2
1490	PREINIT:	1447	PREINIT:
1491	unsigned char md[EVP_MAX_MD_SIZE];	1448	unsigned char md[EVP_MAX_MD_SIZE];
…		…
1507	RETVAL	1464	RETVAL
1508		1465
1509		1466
1510	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7	1467	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1511		1468
1512	void	1469	OpenSSL::PKCS7
1513	new()	1470	new()
1514	PREINIT:
1515	PKCS7 *p7;
1516	PPCODE:	1471	CODE:
1517	if(!(p7 = PKCS7_new())) {	1472	if(!(RETVAL = PKCS7_new())) {
1518	croak("PKCS7_new");	1473	croak("PKCS7_new");
1519	}	1474	}
1520	EXTEND(sp, 1);	1475	OUTPUT:
1521	PUSHs(sv_newmortal());	1476	RETVAL
1522	sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1523		1477
1524		1478
1525	void	1479	void
1526	DESTROY(p7)	1480	DESTROY(p7)
1527	PKCS7 *p7;	1481	OpenSSL::PKCS7 p7;
1528	CODE:	1482	CODE:
1529	if(p7) {	1483	if(p7) {
1530	XD("PKCS7_free(%p)\n", p7);	1484	XD("PKCS7_free(%p)\n", p7);
1531	PKCS7_free(p7);	1485	PKCS7_free(p7);
1532	}	1486	}
1533		1487
1534		1488
1535	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12	1489	MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1536		1490
1537	void	1491	OpenSSL::PKCS12
1538	new()	1492	new(class)
1539	PREINIT:	1493	SV *class
1540	PKCS12 *p12;
1541	PPCODE:	1494	CODE:
1542	if(!(p12 = PKCS12_new())) {	1495	if(!(RETVAL = PKCS12_new())) {
1543	croak("PKCS12_new");	1496	croak("PKCS12_new");
1544	}	1497	}
1545	EXTEND(sp, 1);	1498	OUTPUT:
1546	PUSHs(sv_newmortal());	1499	RETVAL
1547	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1548		1500
1549	void	1501	OpenSSL::PKCS12
1550	new_from_string(sv)	1502	new_from_string(class,sv)
		1503	SV *class
1551	SV *sv	1504	SV *sv
1552	ALIAS:	1505	ALIAS:
1553	new_from_file = 1	1506	new_from_file = 1
1554	PREINIT:	1507	PREINIT:
1555	PKCS12 *p12;
1556	BIO *bio;	1508	BIO *bio;
1557	char *s;	1509	char *s;
1558	STRLEN len;	1510	STRLEN len;
1559	PPCODE:	1511	CODE:
1560	s = SvPV(sv, len);	1512	s = SvPV(sv, len);
1561	if(ix == 1) {	1513	if(ix == 1) {
1562	bio = BIO_new_file(s, "r");	1514	bio = BIO_new_file(s, "r");
1563	} else {	1515	} else {
1564	bio = BIO_new_mem_buf (s, len);	1516	bio = BIO_new_mem_buf (s, len);
1565	}	1517	}
1566	if(!bio)	1518	if(!bio)
1567	croak("BIO_new_mem_buf");	1519	croak("BIO_new_mem_buf");
1568	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1520	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1569	BIO_free(bio);	1521	BIO_free(bio);
1570	croak("d2i_PKCS12_BIO: %s", ssl_error());	1522	croak("d2i_PKCS12_BIO: %s", ssl_error());
1571	}	1523	}
1572	BIO_free(bio);	1524	BIO_free(bio);
1573	EXTEND(sp, 1);	1525	OUTPUT:
1574	PUSHs(sv_newmortal());	1526	RETVAL
1575	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1576		1527
1577		1528
1578	SV*	1529	SV*
1579	mac_ok(p12, pwd)	1530	mac_ok(p12, pwd)
1580	PKCS12 *p12	1531	OpenSSL::PKCS12 p12
1581	char *pwd	1532	char *pwd
1582	CODE:	1533	CODE:
1583		1534
1584	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;	1535	RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
1585	OUTPUT:	1536	OUTPUT:
1586	RETVAL	1537	RETVAL
1587		1538
1588	void	1539	void
1589	changepass(p12, oldpwd, newpwd)	1540	changepass(p12, oldpwd, newpwd)
1590	PKCS12 *p12	1541	OpenSSL::PKCS12 p12
1591	SV *oldpwd	1542	SV *oldpwd
1592	SV *newpwd	1543	SV *newpwd
1593	PREINIT:	1544	PREINIT:
1594	char *op = 0;	1545	char *op = 0;
1595	char *np = 0;	1546	char *np = 0;
…		…
1602	croak("PKCS12_newpass: %s", ssl_error());	1553	croak("PKCS12_newpass: %s", ssl_error());
1603	}	1554	}
1604		1555
1605	SV*	1556	SV*
1606	as_string(p12,...)	1557	as_string(p12,...)
1607	PKCS12 *p12	1558	OpenSSL::PKCS12 p12
1608	ALIAS:	1559	ALIAS:
1609	as_file = 1	1560	as_file = 1
1610	PROTOTYPE: $;$	1561	PROTOTYPE: $;$
1611	PREINIT:	1562	PREINIT:
1612	SV *sv;
1613	BIO *bio;	1563	BIO *bio;
1614	CODE:	1564	CODE:
1615	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))	1565	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))
1616	croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");	1566	croak("OpenSSL::PKCS12::%s: illegal/missing args", (ix == 1) ? "as_file" : "as_string");
1617	if(items > 1) {	1567	if(items > 1) {
…		…
1629	OUTPUT:	1579	OUTPUT:
1630	RETVAL	1580	RETVAL
1631		1581
1632	void	1582	void
1633	DESTROY(p12)	1583	DESTROY(p12)
1634	PKCS12 *p12;	1584	OpenSSL::PKCS12 p12;
1635	CODE:	1585	CODE:
1636	if(p12) {	1586	if(p12) {
1637	XD("PKCS12_free(%p)\n", p12);	1587	XD("PKCS12_free(%p)\n", p12);
1638	PKCS12_free(p12);	1588	PKCS12_free(p12);
1639	}	1589	}
1640		1590
1641		1591
1642	MODULE = OpenSSL PACKAGE = OpenSSL::CRL	1592	MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1643		1593
1644	void	1594	OpenSSL::CRL
1645	new_from_string(thing)	1595	new_from_string(class,thing)
		1596	SV *class
1646	SV *thing	1597	SV *thing
1647	ALIAS:	1598	ALIAS:
1648	new_from_file = 1	1599	new_from_file = 1
1649	PREINIT:	1600	PREINIT:
1650	BIO *bio;	1601	BIO *bio;
1651	X509_CRL *crl;
1652	STRLEN l;	1602	STRLEN l;
1653	char p, q = 0;	1603	char *p;
1654	PPCODE:	1604	CODE:
1655	p = SvPV(thing, l);	1605	p = SvPV(thing, l);
1656	if(ix == 1) {	1606	if(ix == 1) {
1657	bio = BIO_new_file(p, "r");	1607	bio = BIO_new_file(p, "r");
1658	} else {	1608	} else {
1659	bio = BIO_new_mem_buf (p, l);	1609	bio = BIO_new_mem_buf (p, l);
1660	}	1610	}
1661	if(!bio)	1611	if(!bio)
1662	croak(ssl_error());	1612	croak(ssl_error());
1663		1613
1664	crl = PEM_read_bio_X509_CRL (bio, 0, 0, 0);	1614	RETVAL = PEM_read_bio_X509_CRL (bio, 0, 0, 0);
1665	BIO_free (bio);	1615	BIO_free (bio);
1666	if(!crl)	1616	if(!RETVAL)
1667	croak("PEM_read_bio_X509_CRL: %s", ssl_error());	1617	croak("PEM_read_bio_X509_CRL: %s", ssl_error());
1668		1618
1669	EXTEND(sp, 1);	1619	OUTPUT:
1670	PUSHs(sv_newmortal());	1620	RETVAL
1671	sv_setref_pv(ST(0), "OpenSSL::CRL", (void *) crl);
1672		1621
1673	void	1622	void
1674	DESTROY(crl)	1623	DESTROY(crl)
1675	X509_CRL *crl	1624	OpenSSL::CRL crl
1676	CODE:	1625	CODE:
1677	if (crl) {	1626	if (crl) {
1678	XD("X509_CRL_free (%p)\n", crl);	1627	XD("X509_CRL_free (%p)\n", crl);
1679	X509_CRL_free(crl);	1628	X509_CRL_free(crl);
1680	crl = 0;	1629	crl = 0;
1681	}	1630	}
1682		1631
1683	SV*	1632	SV*
1684	info(crl)	1633	info(crl)
1685	X509_CRL *crl	1634	OpenSSL::CRL crl
1686	PREINIT:	1635	PREINIT:
1687	BIO *bio;	1636	BIO *bio;
1688	CODE:	1637	CODE:
1689	bio = sv_bio_create();	1638	bio = sv_bio_create();
1690	if(!X509_CRL_print(bio,crl)) {	1639	if(!X509_CRL_print(bio,crl)) {

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing OpenSSL/OpenSSL.xs (file contents): Revision 1.2 by root, Sat Oct 27 02:40:45 2001 UTC vs. Revision 1.14 by root, Sun Oct 28 03:20:00 2001 UTC

Diff Legend

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.2 by root, Sat Oct 27 02:40:45 2001 UTC vs.
Revision 1.14 by root, Sun Oct 28 03:20:00 2001 UTC