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

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

Diff Legend

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

Comparing OpenSSL/OpenSSL.xs (file contents): Revision 1.3 by root, Sat Oct 27 02:43:28 2001 UTC vs. Revision 1.17 by root, Sun Oct 28 03:29:11 2001 UTC

Diff Legend

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.3 by root, Sat Oct 27 02:43:28 2001 UTC vs.
Revision 1.17 by root, Sun Oct 28 03:29:11 2001 UTC