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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.8 by root, Sat Oct 27 03:09:09 2001 UTC vs.
Revision 1.15 by root, Sun Oct 28 03:24:25 2001 UTC

…		…
91	}	91	}
92	sv_setpv(sv, buf);	92	sv_setpv(sv, buf);
93	return sv;	93	return sv;
94	}	94	}
95		95
96	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)
97	{	97	{
98	if(m == BIO_CB_WRITE) {	98	if(m == BIO_CB_WRITE) {
99	SV sv = (SV ) BIO_get_callback_arg(bm);	99	SV sv = (SV ) BIO_get_callback_arg(bm);
100	sv_catpvn(sv, ptr, l);	100	sv_catpvn(sv, ptr, l);
101	}	101	}
…		…
113	BIO *bio;	113	BIO *bio;
114	sv = newSVpvn("",0);	114	sv = newSVpvn("",0);
115	// mem is completely broken for write, so we use /dev/null	115	// mem is completely broken for write, so we use /dev/null
116	// and use callbacks-hooks	116	// and use callbacks-hooks
117	bio = BIO_new_file("/dev/null", "wb");	117	bio = BIO_new_file("/dev/null", "wb");
118	BIO_set_callback(bio, fuck_cb);	118	BIO_set_callback(bio, bio_write_cb);
119	BIO_set_callback_arg(bio, (void *)sv);	119	BIO_set_callback_arg(bio, (void *)sv);
120	return bio;	120	return bio;
121	}	121	}
122		122
123	static inline BIO sv_bio_create_file(SV filename)	123	static inline BIO sv_bio_create_file(SV filename)
124	{	124	{
125	char *fn;
126	STRLEN l;	125	STRLEN l;
127		126
128	return BIO_new_file(SvPV(filename, l), "wb");	127	return BIO_new_file(SvPV(filename, l), "wb");
129	}	128	}
130		129
…		…
292	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' : ':');
293	}	292	}
294	return s;	293	return s;
295	}	294	}
296		295
297	static inline char ol(X509_NAME x)	296	static inline SV ol(X509_NAME x)
298	{	297	{
299	static char buf[256];	298	char *p;
300	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));
301	return buf;	302	return sv;
302	}	303	}
303		304
		305	#if 0
304	static void run_sha1(char digest, const char msg, int msglen)	306	static void run_sha1(char digest, const char msg, int msglen)
305	{	307	{
306	SHA_CTX ctx;	308	SHA_CTX ctx;
307		309
308	if(!digest \|\| !msg \|\| msglen < 0)	310	if(!digest \|\| !msg \|\| msglen < 0)
309	croak("run_sha1: null pointer or illegal message len");	311	croak("run_sha1: null pointer or illegal message len");
310	SHA1_Init(&ctx);	312	SHA1_Init(&ctx);
311	SHA1_Update(&ctx, msg, msglen);	313	SHA1_Update(&ctx, msg, msglen);
312	SHA1_Final(digest, &ctx);	314	SHA1_Final(digest, &ctx);
313	}	315	}
314		316	#endif
315	static bool is_privkey(RSA *key)	317	static bool is_privkey(RSA *key)
316	{	318	{
317	return (key->n && key->e && key->d && key->p && key->q	319	return (key->n && key->e && key->d && key->p && key->q
318	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;	320	&& key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;
319	}	321	}
…		…
419	//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;
420	OUTPUT:	422	OUTPUT:
421	RETVAL	423	RETVAL
422		424
423		425
424	void	426	OpenSSL::RSA
425	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)	427	new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
426	char *n	428	char *n
427	char *e	429	char *e
428	char *p	430	char *p
429	char *q	431	char *q
430	char *dmp1	432	char *dmp1
431	char *dmq1	433	char *dmq1
432	char *iqmp	434	char *iqmp
433	char *d	435	char *d
434	PREINIT:	436	CODE:
435	RSA *key;
436	int rc;	437	int rc;
437	PPCODE:	438
438	EXTEND(sp, 1);
439	PUSHs(sv_newmortal());
440	key = RSA_new();	439	RETVAL = RSA_new();
441	if (!key)	440	if (!RETVAL)
442	croak("can't allocate key");	441	croak("can't allocate key");
443	if(!(key->n = BN_new()) \|\| !BN_dec2bn(&key->n, n)) {	442	if(!(RETVAL->n = BN_new()) \|\| !BN_dec2bn(&RETVAL->n, n)) {
444	RSA_free(key); croak("can't initialize n");	443	RSA_free(RETVAL); croak("can't initialize n");
445	}	444	}
446	if(!(key->e = BN_new()) \|\| !BN_dec2bn(&key->e, e)) {	445	if(!(RETVAL->e = BN_new()) \|\| !BN_dec2bn(&RETVAL->e, e)) {
447	RSA_free(key); croak("can't initialize e");	446	RSA_free(RETVAL); croak("can't initialize e");
448	}	447	}
449	if(!(key->p = BN_new()) \|\| !BN_dec2bn(&key->p, p)) {	448	if(!(RETVAL->p = BN_new()) \|\| !BN_dec2bn(&RETVAL->p, p)) {
450	RSA_free(key); croak("can't initialize p");	449	RSA_free(RETVAL); croak("can't initialize p");
451	}	450	}
452	if(!(key->q = BN_new()) \|\| !BN_dec2bn(&key->q, q)) {	451	if(!(RETVAL->q = BN_new()) \|\| !BN_dec2bn(&RETVAL->q, q)) {
453	RSA_free(key); croak("can't initialize q");	452	RSA_free(RETVAL); croak("can't initialize q");
454	}	453	}
455	if(!(key->dmp1 = BN_new()) \|\| !BN_dec2bn(&key->dmp1, dmp1)) {	454	if(!(RETVAL->dmp1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmp1, dmp1)) {
456	RSA_free(key); croak("can't initialize dmp1");	455	RSA_free(RETVAL); croak("can't initialize dmp1");
457	}	456	}
458	if(!(key->dmq1 = BN_new()) \|\| !BN_dec2bn(&key->dmq1, dmq1)) {	457	if(!(RETVAL->dmq1 = BN_new()) \|\| !BN_dec2bn(&RETVAL->dmq1, dmq1)) {
459	RSA_free(key); croak("can't initialize dmq1");	458	RSA_free(RETVAL); croak("can't initialize dmq1");
460	}	459	}
461	if(!(key->iqmp = BN_new()) \|\| !BN_dec2bn(&key->iqmp, iqmp)) {	460	if(!(RETVAL->iqmp = BN_new()) \|\| !BN_dec2bn(&RETVAL->iqmp, iqmp)) {
462	RSA_free(key); croak("can't initialize iqmp");	461	RSA_free(RETVAL); croak("can't initialize iqmp");
463	}	462	}
464	if(!(key->d = BN_new()) \|\| !BN_dec2bn(&key->d, d)) {	463	if(!(RETVAL->d = BN_new()) \|\| !BN_dec2bn(&RETVAL->d, d)) {
465	RSA_free(key); croak("can't initialize d");	464	RSA_free(RETVAL); croak("can't initialize d");
466	}	465	}
467	if((rc = RSA_check_key(key)) != 1) {	466	if((rc = RSA_check_key(RETVAL)) != 1) {
468	RSA_free(key); croak("RSA_check_key failed (%d).", rc);	467	RSA_free(RETVAL); croak("RSA_check_key failed (%d).", rc);
469	}	468	}
470	sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);	469	OUTPUT:
		470	RETVAL
471		471
472		472
473	void	473	void
474	DESTROY(key)	474	DESTROY(key)
475	OpenSSL::RSA key	475	OpenSSL::RSA key
…		…
594	void	594	void
595	STORABLE_freeze(key, cloning)	595	STORABLE_freeze(key, cloning)
596	OpenSSL::RSA key	596	OpenSSL::RSA key
597	bool cloning	597	bool cloning
598	PREINIT:	598	PREINIT:
599	SV *sv;
600	STRLEN totlen;	599	STRLEN totlen;
601	PPCODE:	600	PPCODE:
602	if(cloning)	601	if(cloning)
603	return;	602	return;
604	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);
…		…
885	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);	884	ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
886	OUTPUT:	885	OUTPUT:
887	RETVAL	886	RETVAL
888		887
889		888
890	void	889	OpenSSL::X509
891	new_from_string(class,thing)	890	new_from_string(class,thing)
892	SV *class	891	SV *class
893	SV *thing	892	SV *thing
894	ALIAS:	893	ALIAS:
895	new_from_file = 1	894	new_from_file = 1
896	PREINIT:	895	PREINIT:
897	BIO *bio;	896	BIO *bio;
898	X509 *x509;
899	STRLEN l;	897	STRLEN l;
900	char p, q = 0;	898	char *p;
901	PPCODE:	899	CODE:
902	p = SvPV (thing, l);	900	p = SvPV (thing, l);
903	if(ix == 1) {	901	if(ix == 1) {
904	bio = BIO_new_file(p, "r");	902	bio = BIO_new_file(p, "r");
905	} else {	903	} else {
906	bio = BIO_new_mem_buf (p, l);	904	bio = BIO_new_mem_buf (p, l);
907	}	905	}
908	if(!bio)	906	if(!bio)
909	croak(ssl_error());	907	croak(ssl_error());
910		908
911	x509 = PEM_read_bio_X509 (bio, 0, 0, 0);	909	RETVAL = PEM_read_bio_X509 (bio, 0, 0, 0);
912	BIO_free (bio);	910	BIO_free (bio);
913	if(!x509)	911	if(!RETVAL)
914	croak("PEM_read_bio_X509: %s", ssl_error());	912	croak("PEM_read_bio_X509: %s", ssl_error());
915		913
916	EXTEND(sp, 1);	914	OUTPUT:
917	PUSHs(sv_newmortal());	915	RETVAL
918	sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
919		916
920	void	917	void
921	DESTROY(x509)	918	DESTROY(x509)
922	OpenSSL::X509 x509	919	OpenSSL::X509 x509
923	CODE:	920	CODE:
…		…
945		942
946	OpenSSL::Name	943	OpenSSL::Name
947	subject(x509)	944	subject(x509)
948	OpenSSL::X509 x509	945	OpenSSL::X509 x509
949	CODE:	946	CODE:
950	RETVAL = X509_get_subject_name(x509);	947	RETVAL = X509_NAME_dup (X509_get_subject_name(x509));
951	OUTPUT:	948	OUTPUT:
952	RETVAL	949	RETVAL
953		950
954	OpenSSL::Name	951	OpenSSL::Name
955	issuer(x509)	952	issuer(x509)
956	OpenSSL::X509 x509	953	OpenSSL::X509 x509
957	CODE:	954	CODE:
958	RETVAL = X509_get_issuer_name(x509);	955	RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
959	OUTPUT:	956	OUTPUT:
960	RETVAL	957	RETVAL
961		958
962		959
963	char *	960	SV *
964	subject_txt(x509)	961	subject_txt(x509)
965	OpenSSL::X509 x509	962	OpenSSL::X509 x509
966	CODE:	963	CODE:
967	RETVAL = ol(X509_get_subject_name(x509));	964	RETVAL = ol(X509_get_subject_name(x509));
968	OUTPUT:	965	OUTPUT:
969	RETVAL	966	RETVAL
970		967
971		968
972	char *	969	SV *
973	issuer_txt(x509)	970	issuer_txt(x509)
974	OpenSSL::X509 x509	971	OpenSSL::X509 x509
975	CODE:	972	CODE:
976	RETVAL = ol(X509_get_issuer_name(x509));	973	RETVAL = ol(X509_get_issuer_name(x509));
977	OUTPUT:	974	OUTPUT:
…		…
1103	if(ctx) {	1100	if(ctx) {
1104	EVP_CIPHER_CTX_cleanup(ctx);	1101	EVP_CIPHER_CTX_cleanup(ctx);
1105	free(ctx);	1102	free(ctx);
1106	}	1103	}
1107		1104
1108	void	1105	OpenSSL::Cipher
1109	new_decrypt(...)	1106	new_decrypt(...)
1110	ALIAS:	1107	ALIAS:
1111	new_encrypt = 1	1108	new_encrypt = 1
1112	PREINIT:	1109	PREINIT:
1113	char *name;	1110	char *name;
1114	SV *svkey;	1111	SV *svkey;
1115	EVP_CIPHER *ci;	1112	EVP_CIPHER *ci;
1116	EVP_CIPHER_CTX *ctx;
1117	char *key;	1113	char *key;
1118	char iv[EVP_MAX_IV_LENGTH];	1114	char iv[EVP_MAX_IV_LENGTH];
1119	char k[EVP_MAX_KEY_LENGTH];	1115	char k[EVP_MAX_KEY_LENGTH];
1120	int rc;	1116	int rc;
1121	STRLEN keylen;	1117	STRLEN keylen;
1122	PPCODE:	1118	CODE:
1123	if(items < 2 \|\| items > 3) {	1119	if(items < 2 \|\| items > 3) {
1124	croak("usage: new_[en\|de]crypt(ciphname,key)");	1120	croak("usage: new_[en\|de]crypt(ciphname,key)");
1125	}	1121	}
1126	name = SvPV_nolen(ST(items -2));	1122	name = SvPV_nolen(ST(items -2));
1127	svkey = ST(items - 1);	1123	svkey = ST(items - 1);
1128	memset(iv, 0, EVP_MAX_IV_LENGTH);	1124	memset(iv, 0, EVP_MAX_IV_LENGTH);
1129	memset(k, 0, EVP_MAX_KEY_LENGTH);	1125	memset(k, 0, EVP_MAX_KEY_LENGTH);
1130		1126
1131	if(!(ci = lookup_cipher(name)))	1127	if(!(ci = lookup_cipher(name)))
1132	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);	1128	croak("OpenSSL::Cipher::new: no such cipher \"%s\"", name);
1133	ctx = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));	1129	RETVAL = (EVP_CIPHER_CTX *) malloc(sizeof(EVP_CIPHER_CTX));
1134	if(!ctx)	1130	if(!RETVAL)
1135	croak("malloc error");	1131	croak("malloc error");
1136	key = SvPV(svkey, keylen);	1132	key = SvPV(svkey, keylen);
1137	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);	1133	memcpy(k, key, (keylen <= ci->key_len) ? keylen : ci->key_len);
1138	rc = EVP_CipherInit(ctx, ci, k, iv, ix);	1134	rc = EVP_CipherInit(RETVAL, ci, k, iv, ix);
1139	memset(iv, 0, EVP_MAX_IV_LENGTH);	1135	memset(iv, 0, EVP_MAX_IV_LENGTH);
1140	memset(iv, 0, EVP_MAX_KEY_LENGTH);	1136	memset(iv, 0, EVP_MAX_KEY_LENGTH);
1141	if(!rc) {	1137	if(!rc) {
1142	free(ctx);	1138	free(RETVAL);
1143	croak("EVP_CipherInit");	1139	croak("EVP_CipherInit");
1144	}	1140	}
1145	EXTEND(sp, 1);	1141	OUTPUT:
1146	PUSHs(sv_newmortal());	1142	RETVAL
1147	sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1148		1143
1149		1144
1150	SV *	1145	SV *
1151	update(ctx,svin)	1146	update(ctx,svin)
1152	OpenSSL::Cipher ctx	1147	OpenSSL::Cipher ctx
…		…
1215	{	1210	{
1216	mds_boot();	1211	mds_boot();
1217	}	1212	}
1218		1213
1219	SV *	1214	SV *
1220	md2(sv)	1215	md2(...)
1221	SV *sv
1222	ALIAS:	1216	ALIAS:
1223	md4 = 0x1	1217	md4 = 0x1
1224	md5 = 0x2	1218	md5 = 0x2
1225	sha = 0x3	1219	sha = 0x3
1226	sha1 = 0x4	1220	sha1 = 0x4
…		…
1244	sha1_base64 = 0x24	1238	sha1_base64 = 0x24
1245	dss_base64 = 0x25	1239	dss_base64 = 0x25
1246	dss1_base64 = 0x26	1240	dss1_base64 = 0x26
1247	mdc2_base64 = 0x27	1241	mdc2_base64 = 0x27
1248	ripemd160_base64 = 0x28	1242	ripemd160_base64 = 0x28
1249	PREINIT:	1243	CODE:
1250	EVP_MD_CTX ctx;	1244	EVP_MD_CTX ctx;
1251	STRLEN l;	1245	STRLEN l;
1252	char *p;	1246	char *p;
1253	unsigned char md[EVP_MAX_MD_SIZE];	1247	unsigned char md[EVP_MAX_MD_SIZE];
1254	unsigned int md_len;	1248	unsigned int md_len;
1255	CODE:	1249	int i;
		1250
1256	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);	1251	EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
		1252
		1253	for (i = 0; i < items; i++)
		1254	{
1257	p = SvPV(sv, l);	1255	p = SvPV(ST(i), l);
1258	EVP_DigestUpdate(&ctx, p, l);	1256	EVP_DigestUpdate(&ctx, p, l);
		1257	}
		1258
1259	EVP_DigestFinal(&ctx, md, &md_len);	1259	EVP_DigestFinal(&ctx, md, &md_len);
1260	switch(ix & ~15) {	1260	switch(ix & ~15) {
1261	case 0:	1261	case 0:
1262	RETVAL = newSVpvn(md, md_len);	1262	RETVAL = newSVpvn(md, md_len);
1263	break;	1263	break;
…		…
1270	}	1270	}
1271	OUTPUT:	1271	OUTPUT:
1272	RETVAL	1272	RETVAL
1273		1273
1274		1274
1275	void	1275	OpenSSL::Digest
1276	new_md2()	1276	new_md2()
1277	ALIAS:	1277	ALIAS:
1278	new_md4 = 0x1	1278	new_md4 = 0x1
1279	new_md5 = 0x2	1279	new_md5 = 0x2
1280	mew_sha = 0x3	1280	mew_sha = 0x3
1281	new_sha1 = 0x4	1281	new_sha1 = 0x4
1282	new_dss = 0x5	1282	new_dss = 0x5
1283	new_dss1 = 0x6	1283	new_dss1 = 0x6
1284	new_mdc2 = 0x7	1284	new_mdc2 = 0x7
1285	new_ripemd160 = 0x8	1285	new_ripemd160 = 0x8
1286	PREINIT:
1287	EVP_MD_CTX *ctx;
1288	PPCODE:	1286	CODE:
1289	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1287	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1290	if(!ctx)	1288	if(!RETVAL)
1291	croak("out of memory.");	1289	croak("out of memory.");
1292	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1290	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1293	EXTEND(sp, 1);	1291	OUTPUT:
1294	PUSHs(sv_newmortal());	1292	RETVAL
1295	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1296
1297		1293
1298	void	1294	void
1299	DESTROY(ctx)	1295	DESTROY(ctx)
1300	OpenSSL::Digest ctx	1296	OpenSSL::Digest ctx
1301	CODE:	1297	CODE:
1302	if(ctx)	1298	if(ctx)
1303	free(ctx);	1299	free(ctx);
1304		1300
1305	void	1301	void
1306	update(ctx, sv)	1302	update(ctx, ...)
1307	OpenSSL::Digest ctx	1303	OpenSSL::Digest ctx
1308	SV *sv
1309	PREINIT:	1304	PREINIT:
1310	STRLEN l;	1305	STRLEN l;
1311	char *p;	1306	char *p;
		1307	int i;
1312	CODE:	1308	CODE:
1313	p = SvPV(sv, l);	1309	for (i = 1; i < items; i++)
1314	EVP_DigestUpdate(ctx, p, l);
1315		1310	{
		1311	p = SvPV(ST(i), l);
		1312	EVP_DigestUpdate(ctx, p, l);
		1313	}
1316		1314
1317	SV *	1315	SV *
1318	final(ctx)	1316	final(ctx)
1319	OpenSSL::Digest ctx	1317	OpenSSL::Digest ctx
1320	ALIAS:	1318	ALIAS:
…		…
1378	dss_base64 = 0x25	1376	dss_base64 = 0x25
1379	dss1_base64 = 0x26	1377	dss1_base64 = 0x26
1380	mdc2_base64 = 0x27	1378	mdc2_base64 = 0x27
1381	ripemd160_base64 = 0x28	1379	ripemd160_base64 = 0x28
1382	PREINIT:	1380	PREINIT:
1383	HMAC_CTX ctx;
1384	STRLEN l, keylen;	1381	STRLEN l, keylen;
1385	char *p;	1382	char *p;
1386	char *key;	1383	char *key;
1387	unsigned char md[EVP_MAX_MD_SIZE];	1384	unsigned char md[EVP_MAX_MD_SIZE];
1388	unsigned int md_len;	1385	unsigned int md_len;
…		…
1404	}	1401	}
1405	OUTPUT:	1402	OUTPUT:
1406	RETVAL	1403	RETVAL
1407		1404
1408		1405
1409	void	1406	OpenSSL::Digest
1410	new_md2(void)	1407	new_md2()
1411	ALIAS:	1408	ALIAS:
1412	new_md4 = 0x1	1409	new_md4 = 0x1
1413	new_md5 = 0x2	1410	new_md5 = 0x2
1414	mew_sha = 0x3	1411	mew_sha = 0x3
1415	new_sha1 = 0x4	1412	new_sha1 = 0x4
1416	new_dss = 0x5	1413	new_dss = 0x5
1417	new_dss1 = 0x6	1414	new_dss1 = 0x6
1418	new_mdc2 = 0x7	1415	new_mdc2 = 0x7
1419	new_ripemd160 = 0x8	1416	new_ripemd160 = 0x8
1420	PREINIT:
1421	EVP_MD_CTX *ctx;
1422	PPCODE:	1417	CODE:
1423	ctx = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));	1418	RETVAL = (EVP_MD_CTX *) malloc(sizeof(EVP_MD_CTX));
1424	if(!ctx)	1419	if(!RETVAL)
1425	croak("out of memory.");	1420	croak("out of memory.");
1426	EVP_DigestInit(ctx, _mds[NO_FLAGS(ix)]);	1421	EVP_DigestInit(RETVAL, _mds[NO_FLAGS(ix)]);
1427	EXTEND(sp, 1);	1422	OUTPUT:
1428	PUSHs(sv_newmortal());	1423	RETVAL
1429	sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1430
1431		1424
1432	void	1425	void
1433	DESTROY(ctx)	1426	DESTROY(ctx)
1434	OpenSSL::Digest ctx	1427	OpenSSL::Digest ctx
1435	CODE:	1428	CODE:
…		…
1506	croak("PKCS12_new");	1499	croak("PKCS12_new");
1507	}	1500	}
1508	OUTPUT:	1501	OUTPUT:
1509	RETVAL	1502	RETVAL
1510		1503
1511	void	1504	OpenSSL::PKCS12
1512	new_from_string(class,sv)	1505	new_from_string(class,sv)
1513	SV *class	1506	SV *class
1514	SV *sv	1507	SV *sv
1515	ALIAS:	1508	ALIAS:
1516	new_from_file = 1	1509	new_from_file = 1
1517	PREINIT:	1510	PREINIT:
1518	PKCS12 *p12;
1519	BIO *bio;	1511	BIO *bio;
1520	char *s;	1512	char *s;
1521	STRLEN len;	1513	STRLEN len;
1522	PPCODE:	1514	CODE:
1523	s = SvPV(sv, len);	1515	s = SvPV(sv, len);
1524	if(ix == 1) {	1516	if(ix == 1) {
1525	bio = BIO_new_file(s, "r");	1517	bio = BIO_new_file(s, "r");
1526	} else {	1518	} else {
1527	bio = BIO_new_mem_buf (s, len);	1519	bio = BIO_new_mem_buf (s, len);
1528	}	1520	}
1529	if(!bio)	1521	if(!bio)
1530	croak("BIO_new_mem_buf");	1522	croak("BIO_new_mem_buf");
1531	if(!(p12 = d2i_PKCS12_bio(bio, 0))) {	1523	if(!(RETVAL = d2i_PKCS12_bio(bio, 0))) {
1532	BIO_free(bio);	1524	BIO_free(bio);
1533	croak("d2i_PKCS12_BIO: %s", ssl_error());	1525	croak("d2i_PKCS12_BIO: %s", ssl_error());
1534	}	1526	}
1535	BIO_free(bio);	1527	BIO_free(bio);
1536	EXTEND(sp, 1);	1528	OUTPUT:
1537	PUSHs(sv_newmortal());	1529	RETVAL
1538	sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1539		1530
1540		1531
1541	SV*	1532	SV*
1542	mac_ok(p12, pwd)	1533	mac_ok(p12, pwd)
1543	OpenSSL::PKCS12 p12	1534	OpenSSL::PKCS12 p12
…		…
1570	OpenSSL::PKCS12 p12	1561	OpenSSL::PKCS12 p12
1571	ALIAS:	1562	ALIAS:
1572	as_file = 1	1563	as_file = 1
1573	PROTOTYPE: $;$	1564	PROTOTYPE: $;$
1574	PREINIT:	1565	PREINIT:
1575	SV *sv;
1576	BIO *bio;	1566	BIO *bio;
1577	CODE:	1567	CODE:
1578	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))	1568	if((ix != 1 && items > 1) \|\| (ix == 1 && items != 2))
1579	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");
1580	if(items > 1) {	1570	if(items > 1) {
…		…
1603		1593
1604		1594
1605	MODULE = OpenSSL PACKAGE = OpenSSL::CRL	1595	MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1606		1596
1607	OpenSSL::CRL	1597	OpenSSL::CRL
1608	new_from_string(thing)	1598	new_from_string(class,thing)
		1599	SV *class
1609	SV *thing	1600	SV *thing
1610	ALIAS:	1601	ALIAS:
1611	new_from_file = 1	1602	new_from_file = 1
1612	PREINIT:	1603	PREINIT:
1613	BIO *bio;	1604	BIO *bio;
1614	STRLEN l;	1605	STRLEN l;
1615	char p, q = 0;	1606	char *p;
1616	CODE:	1607	CODE:
1617	p = SvPV(thing, l);	1608	p = SvPV(thing, l);
1618	if(ix == 1) {	1609	if(ix == 1) {
1619	bio = BIO_new_file(p, "r");	1610	bio = BIO_new_file(p, "r");
1620	} else {	1611	} else {

Diff Legend

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

Comparing OpenSSL/OpenSSL.xs (file contents): Revision 1.8 by root, Sat Oct 27 03:09:09 2001 UTC vs. Revision 1.15 by root, Sun Oct 28 03:24:25 2001 UTC

Diff Legend

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.8 by root, Sat Oct 27 03:09:09 2001 UTC vs.
Revision 1.15 by root, Sun Oct 28 03:24:25 2001 UTC