ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/OpenSSL/OpenSSL.xs
(Generate patch)

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

… …
32#define XD(...) 32#define XD(...)
33#endif 33#endif
34 34
35static const char *ssl_error(void); 35static 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
66typedef X509 *OpenSSL__X509; 37typedef X509 *OpenSSL__X509;
38typedef X509_CRL *OpenSSL__CRL;
39typedef X509_NAME *OpenSSL__Name;
40typedef PKCS7 *OpenSSL__PKCS7;
41typedef PKCS12 *OpenSSL__PKCS12;
42typedef RSA *OpenSSL__RSA;
43typedef EVP_MD_CTX *OpenSSL__Digest;
44typedef EVP_CIPHER_CTX *OpenSSL__Cipher;
67 45
68static inline SV* output_ASN1_INTEGER(ASN1_INTEGER *ai, SV *sv) 46static 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");
… …
412} 390}
413 391
414 392
415MODULE = OpenSSL PACKAGE = OpenSSL::RSA 393MODULE = OpenSSL PACKAGE = OpenSSL::RSA
416 394
417void 395OpenSSL::RSA
418new_keygen(bits = 128, e = 35) 396new_keygen(bits = 128, e = 35)
419 IV bits 397 IV bits
420 IV e 398 IV e
421 PREINIT:
422 RSA *key;
423 PPCODE: 399 CODE:
424 if(!(key = RSA_generate_key(bits, e, NULL, NULL))) 400 if(!(RETVAL = RSA_generate_key(bits, e, NULL, NULL)))
425 croak("RSA_generate_key"); 401 croak("RSA_generate_key");
426 EXTEND(sp, 1); 402 OUTPUT:
427 PUSHs(sv_newmortal()); 403 RETVAL
428 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
429 404
430void 405OpenSSL::RSA
431new_pubkey(n, e) 406new_pubkey(n, e)
432 char *n 407 char *n
433 char *e 408 char *e
434 PREINIT:
435 RSA *key;
436 PPCODE: 409 CODE:
437 EXTEND(sp, 1);
438 PUSHs(sv_newmortal());
439 key = RSA_new(); 410 RETVAL = RSA_new();
440 if (!key) 411 if (!RETVAL)
441 croak("can't allocate key"); 412 croak("can't allocate key");
442 if(!(key->n = BN_new()) || !BN_dec2bn(&key->n, n)) { 413 if(!(RETVAL->n = BN_new()) || !BN_dec2bn(&RETVAL->n, n)) {
443 RSA_free(key); croak("can't initialize n"); 414 RSA_free(RETVAL); croak("can't initialize n");
444 } 415 }
445 if(!(key->e = BN_new()) || !BN_dec2bn(&key->e, e)) { 416 if(!(RETVAL->e = BN_new()) || !BN_dec2bn(&RETVAL->e, e)) {
446 RSA_free(key); croak("can't initialize e"); 417 RSA_free(RETVAL); croak("can't initialize e");
447 } 418 }
448 //key->p = 0, key->q = 0, key->dmp1 = 0, key->dmq1 = 0, key->iqmp = 0; 419 //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); 420 OUTPUT:
421 RETVAL
450 422
451 423
452void 424void
453new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d) 425new_privkey(n, e, p, q, dmp1, dmq1, iqmp, d)
454 char *n 426 char *n
… …
498 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key); 470 sv_setref_pv(ST(0), "OpenSSL::RSA", (void *) key);
499 471
500 472
501void 473void
502DESTROY(key) 474DESTROY(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
510IV 482IV
511keysize(key) 483keysize(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);
517OUTPUT: 489OUTPUT:
518 RETVAL 490 RETVAL
519 491
520bool 492bool
521check_key(key) 493check_key(key)
522 RSA *key; 494 OpenSSL::RSA key;
523PPCODE: 495PPCODE:
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
531BIGNUM * 503BIGNUM *
532n(key) 504n(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
566bool 538bool
567is_privkey(key) 539is_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
622void 594void
623STORABLE_freeze(key, cloning) 595STORABLE_freeze(key, cloning)
624 RSA *key 596 OpenSSL::RSA key
625 bool cloning 597 bool cloning
626PREINIT: 598PREINIT:
627 SV *sv; 599 SV *sv;
628 STRLEN totlen; 600 STRLEN totlen;
629PPCODE: 601PPCODE:
… …
676 } 648 }
677 649
678 650
679SV * 651SV *
680public_encrypt(key, sv) 652public_encrypt(key, sv)
681 RSA *key; 653 OpenSSL::RSA key;
682 SV *sv; 654 SV *sv;
683 ALIAS: 655 ALIAS:
684 encrypt = 4 656 encrypt = 4
685 public_decrypt = 1 657 public_decrypt = 1
686 verify = 5 658 verify = 5
… …
719 RETVAL 691 RETVAL
720 692
721 693
722void 694void
723fingerprint(key) 695fingerprint(key)
724 RSA *key 696 OpenSSL::RSA key
725 PREINIT: 697 PREINIT:
726 char *x; 698 char *x;
727 char dig[SHA_DIGEST_LENGTH]; 699 char dig[SHA_DIGEST_LENGTH];
728 int nlen, elen; 700 int nlen, elen;
729 PPCODE: 701 PPCODE:
… …
740 712
741MODULE = OpenSSL PACKAGE = OpenSSL::Name 713MODULE = OpenSSL PACKAGE = OpenSSL::Name
742 714
743PROTOTYPES: ENABLE 715PROTOTYPES: ENABLE
744 716
745void 717OpenSSL::Name
746new_name() 718new(class)
747 PREINIT: 719 SV *class
748 X509_NAME *name;
749 PPCODE: 720 CODE:
750 if(!(name = X509_NAME_new())) { 721 if(!(RETVAL = X509_NAME_new())) {
751 croak("X509_NAME_new"); 722 croak("X509_NAME_new");
752 } 723 }
753 EXTEND(sp, 1); 724 OUTPUT:
754 PUSHs(sv_newmortal()); 725 RETVAL
755 sv_setref_pv(ST(0), "OpenSSL::Name", (void *) name);
756 726
757 727
758void 728void
759add(name, key, string) 729add(name, key, string)
760 X509_NAME *name 730 OpenSSL::Name name
761 SV *key 731 SV *key
762 SV *string 732 SV *string
763 PREINIT: 733 PREINIT:
764 STRLEN l, kl; 734 STRLEN l, kl;
765 char *p, *k; 735 char *p, *k;
… …
775 if(!ok) 745 if(!ok)
776 croak("X509_NAME_add_entry_by_*: %s", ssl_error()); 746 croak("X509_NAME_add_entry_by_*: %s", ssl_error());
777 747
778IV 748IV
779count(name) 749count(name)
780 X509_NAME *name 750 OpenSSL::Name name
781 CODE: 751 CODE:
782 RETVAL = X509_NAME_entry_count(name); 752 RETVAL = X509_NAME_entry_count(name);
783 OUTPUT: 753 OUTPUT:
784 RETVAL 754 RETVAL
785 755
786void 756void
787getall(name) 757getall(name)
788 X509_NAME *name 758 OpenSSL::Name name
789 PREINIT: 759 PREINIT:
790 int cnt, i; 760 int cnt, i;
791 X509_NAME_ENTRY *e; 761 X509_NAME_ENTRY *e;
792 int nid; 762 int nid;
793 ASN1_STRING *s; 763 ASN1_STRING *s;
… …
802 s = X509_NAME_ENTRY_get_data(e); 772 s = X509_NAME_ENTRY_get_data(e);
803 PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0))); 773 PUSHs(sv_2mortal(newSVpv(OBJ_nid2ln(nid),0)));
804 PUSHs(sv_2mortal(newSVpvn(s->data, s->length))); 774 PUSHs(sv_2mortal(newSVpvn(s->data, s->length)));
805 } 775 }
806 776
807
808
809
810
811void 777void
812DESTROY(name) 778DESTROY(name)
813 X509_NAME *name 779 OpenSSL::Name name
814 CODE: 780 CODE:
815 if(name) { 781 if(name) {
816 XD("X509_NAME_free(%p)\n", name); 782 XD("X509_NAME_free(%p)\n", name);
817 X509_NAME_free(name); 783 X509_NAME_free(name);
818 } 784 }
… …
901 ERR_load_DSA_strings(); 867 ERR_load_DSA_strings();
902 ERR_load_RSA_strings(); 868 ERR_load_RSA_strings();
903} 869}
904 870
905 871
906void 872OpenSSL::X509
907new_X509() 873new(class)
908 PREINIT: 874 SV *class
909 X509 *x509; 875 CODE:
910 PPCODE:
911 if((x509=X509_new()) == NULL) 876 if ((RETVAL = X509_new ()) == NULL)
912 croak("X509_new"); 877 croak("X509_new");
878
913 if(!X509_set_version(x509, 2)) { 879 if (!X509_set_version (RETVAL, 2))
914 X509_free(x509); 880 {
881 X509_free (RETVAL);
915 croak("X509_set_version"); 882 croak ("X509_set_version");
916 } 883 }
884
917 ASN1_INTEGER_set(X509_get_serialNumber(x509),0L); 885 ASN1_INTEGER_set (X509_get_serialNumber (RETVAL), 0L);
918 EXTEND(sp, 1); 886 OUTPUT:
919 PUSHs(sv_newmortal()); 887 RETVAL
920 sv_setref_pv(ST(0), "OpenSSL::X509", (void *) x509);
921 888
922 889
923void 890void
924new_from_string(thing) 891new_from_string(class,thing)
892 SV *class
925 SV *thing 893 SV *thing
926 ALIAS: 894 ALIAS:
927 new_from_file = 1 895 new_from_file = 1
928 PREINIT: 896 PREINIT:
929 BIO *bio; 897 BIO *bio;
930 X509 *x509; 898 X509 *x509;
931 STRLEN l; 899 STRLEN l;
932 char *p, *q = 0; 900 char *p, *q = 0;
933 PPCODE: 901 PPCODE:
934 p = SvPV(thing, l); 902 p = SvPV (thing, l);
935 if(ix == 1) { 903 if(ix == 1) {
936 bio = BIO_new_file(p, "r"); 904 bio = BIO_new_file(p, "r");
937 } else { 905 } else {
938 bio = BIO_new_mem_buf (p, l); 906 bio = BIO_new_mem_buf (p, l);
939 } 907 }
… …
953DESTROY(x509) 921DESTROY(x509)
954 OpenSSL::X509 x509 922 OpenSSL::X509 x509
955 CODE: 923 CODE:
956 if (x509) { 924 if (x509) {
957 XD("X509_free(%p)\n", x509); 925 XD("X509_free(%p)\n", x509);
958 X509_free(x509); 926 X509_free (x509);
959 x509 = 0; 927 x509 = 0;
960 } 928 }
961 929
962 930
963char * 931char *
… …
973 RETVAL = dofp(x509, mds[ix]); 941 RETVAL = dofp(x509, mds[ix]);
974 OUTPUT: 942 OUTPUT:
975 RETVAL 943 RETVAL
976 944
977 945
978X509_NAME * 946OpenSSL::Name
979subject(x509) 947subject(x509)
980 OpenSSL::X509 x509 948 OpenSSL::X509 x509
981 CODE: 949 CODE:
982 RETVAL = X509_get_subject_name(x509); 950 RETVAL = X509_get_subject_name(x509);
983 OUTPUT: 951 OUTPUT:
984 RETVAL 952 RETVAL
985 953
986X509_NAME * 954OpenSSL::Name
987issuer(x509) 955issuer(x509)
988 OpenSSL::X509 x509 956 OpenSSL::X509 x509
989 CODE: 957 CODE:
990 RETVAL = X509_get_issuer_name(x509); 958 RETVAL = X509_get_issuer_name(x509);
991 OUTPUT: 959 OUTPUT:
… …
1092 RETVAL 1060 RETVAL
1093 1061
1094void 1062void
1095set_issuer(x509,name) 1063set_issuer(x509,name)
1096 OpenSSL::X509 x509 1064 OpenSSL::X509 x509
1097 X509_NAME *name 1065 OpenSSL::Name name
1098 CODE: 1066 CODE:
1099 X509_set_issuer_name(x509, X509_NAME_dup(name)); 1067 X509_set_issuer_name(x509, X509_NAME_dup(name));
1100 1068
1101void 1069void
1102set_subject(x509,name) 1070set_subject(x509,name)
1103 OpenSSL::X509 x509 1071 OpenSSL::X509 x509
1104 X509_NAME *name 1072 OpenSSL::Name name
1105 CODE: 1073 CODE:
1106 X509_set_subject_name(x509, X509_NAME_dup(name)); 1074 X509_set_subject_name(x509, X509_NAME_dup(name));
1107 1075
1108SV * 1076SV *
1109errstring(x509) 1077errstring(x509)
… …
1128 cipher_boot(); 1096 cipher_boot();
1129} 1097}
1130 1098
1131void 1099void
1132DESTROY(ctx) 1100DESTROY(ctx)
1133 EVP_CIPHER_CTX *ctx 1101 OpenSSL::Cipher ctx
1134 CODE: 1102 CODE:
1135 if(ctx) { 1103 if(ctx) {
1136 EVP_CIPHER_CTX_cleanup(ctx); 1104 EVP_CIPHER_CTX_cleanup(ctx);
1137 free(ctx); 1105 free(ctx);
1138 } 1106 }
… …
1179 sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx); 1147 sv_setref_pv(ST(0), "OpenSSL::Cipher", (void *) ctx);
1180 1148
1181 1149
1182SV * 1150SV *
1183update(ctx,svin) 1151update(ctx,svin)
1184 EVP_CIPHER_CTX *ctx 1152 OpenSSL::Cipher ctx
1185 SV *svin 1153 SV *svin
1186 PREINIT: 1154 PREINIT:
1187 unsigned char *in, *out; 1155 unsigned char *in, *out;
1188 STRLEN il, ol; 1156 STRLEN il, ol;
1189 CODE: 1157 CODE:
… …
1203 OUTPUT: 1171 OUTPUT:
1204 RETVAL 1172 RETVAL
1205 1173
1206SV * 1174SV *
1207final(ctx) 1175final(ctx)
1208 EVP_CIPHER_CTX *ctx 1176 OpenSSL::Cipher ctx
1209 PREINIT: 1177 PREINIT:
1210 STRLEN ol; 1178 STRLEN ol;
1211 unsigned char *out; 1179 unsigned char *out;
1212 CODE: 1180 CODE:
1213 ol = 256; 1181 ol = 256;
… …
1327 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx); 1295 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1328 1296
1329 1297
1330void 1298void
1331DESTROY(ctx) 1299DESTROY(ctx)
1332 EVP_MD_CTX *ctx 1300 OpenSSL::Digest ctx
1333 CODE: 1301 CODE:
1334 if(ctx) 1302 if(ctx)
1335 free(ctx); 1303 free(ctx);
1336 1304
1337void 1305void
1338update(ctx, sv) 1306update(ctx, sv)
1339 EVP_MD_CTX *ctx 1307 OpenSSL::Digest ctx
1340 SV *sv 1308 SV *sv
1341 PREINIT: 1309 PREINIT:
1342 STRLEN l; 1310 STRLEN l;
1343 char *p; 1311 char *p;
1344 CODE: 1312 CODE:
… …
1346 EVP_DigestUpdate(ctx, p, l); 1314 EVP_DigestUpdate(ctx, p, l);
1347 1315
1348 1316
1349SV * 1317SV *
1350final(ctx) 1318final(ctx)
1351 EVP_MD_CTX *ctx 1319 OpenSSL::Digest ctx
1352 ALIAS: 1320 ALIAS:
1353 final_hex = 1 1321 final_hex = 1
1354 final_base64 = 2 1322 final_base64 = 2
1355 PREINIT: 1323 PREINIT:
1356 unsigned char md[EVP_MAX_MD_SIZE]; 1324 unsigned char md[EVP_MAX_MD_SIZE];
… …
1461 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx); 1429 sv_setref_pv(ST(0), "OpenSSL::Digest", (void *) ctx);
1462 1430
1463 1431
1464void 1432void
1465DESTROY(ctx) 1433DESTROY(ctx)
1466 EVP_MD_CTX *ctx 1434 OpenSSL::Digest ctx
1467 CODE: 1435 CODE:
1468 if(ctx) 1436 if(ctx)
1469 free(ctx); 1437 free(ctx);
1470 1438
1471void 1439void
1472update(ctx, sv) 1440update(ctx, sv)
1473 EVP_MD_CTX *ctx 1441 OpenSSL::Digest ctx
1474 SV *sv 1442 SV *sv
1475 PREINIT: 1443 PREINIT:
1476 STRLEN l; 1444 STRLEN l;
1477 char *p; 1445 char *p;
1478 CODE: 1446 CODE:
… …
1480 EVP_DigestUpdate(ctx, p, l); 1448 EVP_DigestUpdate(ctx, p, l);
1481 1449
1482 1450
1483SV * 1451SV *
1484final(ctx) 1452final(ctx)
1485 EVP_MD_CTX *ctx 1453 OpenSSL::Digest ctx
1486 ALIAS: 1454 ALIAS:
1487 final_hex = 1 1455 final_hex = 1
1488 final_base64 = 2 1456 final_base64 = 2
1489 PREINIT: 1457 PREINIT:
1490 unsigned char md[EVP_MAX_MD_SIZE]; 1458 unsigned char md[EVP_MAX_MD_SIZE];
… …
1506 RETVAL 1474 RETVAL
1507 1475
1508 1476
1509MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7 1477MODULE = OpenSSL PACKAGE = OpenSSL::PKCS7
1510 1478
1511void 1479OpenSSL::PKCS7
1512new() 1480new()
1513 PREINIT:
1514 PKCS7 *p7;
1515 PPCODE: 1481 CODE:
1516 if(!(p7 = PKCS7_new())) { 1482 if(!(RETVAL = PKCS7_new())) {
1517 croak("PKCS7_new"); 1483 croak("PKCS7_new");
1518 } 1484 }
1519 EXTEND(sp, 1); 1485 OUTPUT:
1520 PUSHs(sv_newmortal()); 1486 RETVAL
1521 sv_setref_pv(ST(0), "OpenSSL::PKCS7", (void *) p7);
1522 1487
1523 1488
1524void 1489void
1525DESTROY(p7) 1490DESTROY(p7)
1526 PKCS7 *p7; 1491 OpenSSL::PKCS7 p7;
1527 CODE: 1492 CODE:
1528 if(p7) { 1493 if(p7) {
1529 XD("PKCS7_free(%p)\n", p7); 1494 XD("PKCS7_free(%p)\n", p7);
1530 PKCS7_free(p7); 1495 PKCS7_free(p7);
1531 } 1496 }
1532 1497
1533 1498
1534MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12 1499MODULE = OpenSSL PACKAGE = OpenSSL::PKCS12
1535 1500
1536void 1501OpenSSL::PKCS12
1537new() 1502new(class)
1538 PREINIT: 1503 SV *class
1539 PKCS12 *p12;
1540 PPCODE: 1504 CODE:
1541 if(!(p12 = PKCS12_new())) { 1505 if(!(RETVAL = PKCS12_new())) {
1542 croak("PKCS12_new"); 1506 croak("PKCS12_new");
1543 } 1507 }
1544 EXTEND(sp, 1); 1508 OUTPUT:
1545 PUSHs(sv_newmortal()); 1509 RETVAL
1546 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1547 1510
1548void 1511void
1549new_from_string(sv) 1512new_from_string(class,sv)
1513 SV *class
1550 SV *sv 1514 SV *sv
1551 ALIAS: 1515 ALIAS:
1552 new_from_file = 1 1516 new_from_file = 1
1553 PREINIT: 1517 PREINIT:
1554 PKCS12 *p12; 1518 PKCS12 *p12;
… …
1574 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12); 1538 sv_setref_pv(ST(0), "OpenSSL::PKCS12", (void *) p12);
1575 1539
1576 1540
1577SV* 1541SV*
1578mac_ok(p12, pwd) 1542mac_ok(p12, pwd)
1579 PKCS12 *p12 1543 OpenSSL::PKCS12 p12
1580 char *pwd 1544 char *pwd
1581 CODE: 1545 CODE:
1582 1546
1583 RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no; 1547 RETVAL = (PKCS12_verify_mac(p12, pwd, strlen(pwd))) ? &PL_sv_yes : &PL_sv_no;
1584 OUTPUT: 1548 OUTPUT:
1585 RETVAL 1549 RETVAL
1586 1550
1587void 1551void
1588changepass(p12, oldpwd, newpwd) 1552changepass(p12, oldpwd, newpwd)
1589 PKCS12 *p12 1553 OpenSSL::PKCS12 p12
1590 SV *oldpwd 1554 SV *oldpwd
1591 SV *newpwd 1555 SV *newpwd
1592 PREINIT: 1556 PREINIT:
1593 char *op = 0; 1557 char *op = 0;
1594 char *np = 0; 1558 char *np = 0;
… …
1601 croak("PKCS12_newpass: %s", ssl_error()); 1565 croak("PKCS12_newpass: %s", ssl_error());
1602 } 1566 }
1603 1567
1604SV* 1568SV*
1605as_string(p12,...) 1569as_string(p12,...)
1606 PKCS12 *p12 1570 OpenSSL::PKCS12 p12
1607 ALIAS: 1571 ALIAS:
1608 as_file = 1 1572 as_file = 1
1609 PROTOTYPE: $;$ 1573 PROTOTYPE: $;$
1610 PREINIT: 1574 PREINIT:
1611 SV *sv; 1575 SV *sv;
… …
1628 OUTPUT: 1592 OUTPUT:
1629 RETVAL 1593 RETVAL
1630 1594
1631void 1595void
1632DESTROY(p12) 1596DESTROY(p12)
1633 PKCS12 *p12; 1597 OpenSSL::PKCS12 p12;
1634 CODE: 1598 CODE:
1635 if(p12) { 1599 if(p12) {
1636 XD("PKCS12_free(%p)\n", p12); 1600 XD("PKCS12_free(%p)\n", p12);
1637 PKCS12_free(p12); 1601 PKCS12_free(p12);
1638 } 1602 }
1639 1603
1640 1604
1641MODULE = OpenSSL PACKAGE = OpenSSL::CRL 1605MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1642 1606
1643void 1607OpenSSL::CRL
1644new_from_string(thing) 1608new_from_string(thing)
1645 SV *thing 1609 SV *thing
1646 ALIAS: 1610 ALIAS:
1647 new_from_file = 1 1611 new_from_file = 1
1648 PREINIT: 1612 PREINIT:
1649 BIO *bio; 1613 BIO *bio;
1650 X509_CRL *crl;
1651 STRLEN l; 1614 STRLEN l;
1652 char *p, *q = 0; 1615 char *p, *q = 0;
1653 PPCODE: 1616 CODE:
1654 p = SvPV(thing, l); 1617 p = SvPV(thing, l);
1655 if(ix == 1) { 1618 if(ix == 1) {
1656 bio = BIO_new_file(p, "r"); 1619 bio = BIO_new_file(p, "r");
1657 } else { 1620 } else {
1658 bio = BIO_new_mem_buf (p, l); 1621 bio = BIO_new_mem_buf (p, l);
1659 } 1622 }
1660 if(!bio) 1623 if(!bio)
1661 croak(ssl_error()); 1624 croak(ssl_error());
1662 1625
1663 crl = PEM_read_bio_X509_CRL (bio, 0, 0, 0); 1626 RETVAL = PEM_read_bio_X509_CRL (bio, 0, 0, 0);
1664 BIO_free (bio); 1627 BIO_free (bio);
1665 if(!crl) 1628 if(!RETVAL)
1666 croak("PEM_read_bio_X509_CRL: %s", ssl_error()); 1629 croak("PEM_read_bio_X509_CRL: %s", ssl_error());
1667 1630
1668 EXTEND(sp, 1); 1631 OUTPUT:
1669 PUSHs(sv_newmortal()); 1632 RETVAL
1670 sv_setref_pv(ST(0), "OpenSSL::CRL", (void *) crl);
1671 1633
1672void 1634void
1673DESTROY(crl) 1635DESTROY(crl)
1674 X509_CRL *crl 1636 OpenSSL::CRL crl
1675 CODE: 1637 CODE:
1676 if (crl) { 1638 if (crl) {
1677 XD("X509_CRL_free (%p)\n", crl); 1639 XD("X509_CRL_free (%p)\n", crl);
1678 X509_CRL_free(crl); 1640 X509_CRL_free(crl);
1679 crl = 0; 1641 crl = 0;
1680 } 1642 }
1681 1643
1682SV* 1644SV*
1683info(crl) 1645info(crl)
1684 X509_CRL *crl 1646 OpenSSL::CRL crl
1685 PREINIT: 1647 PREINIT:
1686 BIO *bio; 1648 BIO *bio;
1687 CODE: 1649 CODE:
1688 bio = sv_bio_create(); 1650 bio = sv_bio_create();
1689 if(!X509_CRL_print(bio,crl)) { 1651 if(!X509_CRL_print(bio,crl)) {

Diff Legend

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