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

Comparing OpenSSL/OpenSSL.xs (file contents):
Revision 1.11 by root, Sat Oct 27 03:29:43 2001 UTC vs.
Revision 1.14 by root, Sun Oct 28 03:20:00 2001 UTC

… …
91 } 91 }
92 sv_setpv(sv, buf); 92 sv_setpv(sv, buf);
93 return sv; 93 return sv;
94} 94}
95 95
96long fuck_cb(struct bio_st *bm, int m, const char *ptr, int l, long x, long y) 96long 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
123static inline BIO *sv_bio_create_file(SV *filename) 123static 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
297static inline char *ol(X509_NAME *x) 296static inline SV *ol(X509_NAME *x)
298{ 297{
299 // if we can't fix it, pretend at least that it works 298 char *p;
300 static char buf[8192]; 299 SV *sv = newSVpvn("",0);
301 X509_NAME_oneline(x, buf, 8192); 300 X509_NAME_oneline(x, (p=SvGROW(sv,8192)), 8192);
301 SvCUR_set(sv, strlen(p));
302 return buf; 302 return sv;
303} 303}
304 304
305#if 0
305static void run_sha1(char *digest, const char *msg, int msglen) 306static void run_sha1(char *digest, const char *msg, int msglen)
306{ 307{
307 SHA_CTX ctx; 308 SHA_CTX ctx;
308 309
309 if(!digest || !msg || msglen < 0) 310 if(!digest || !msg || msglen < 0)
310 croak("run_sha1: null pointer or illegal message len"); 311 croak("run_sha1: null pointer or illegal message len");
311 SHA1_Init(&ctx); 312 SHA1_Init(&ctx);
312 SHA1_Update(&ctx, msg, msglen); 313 SHA1_Update(&ctx, msg, msglen);
313 SHA1_Final(digest, &ctx); 314 SHA1_Final(digest, &ctx);
314} 315}
315 316#endif
316static bool is_privkey(RSA *key) 317static bool is_privkey(RSA *key)
317{ 318{
318 return (key->n && key->e && key->d && key->p && key->q 319 return (key->n && key->e && key->d && key->p && key->q
319 && key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0; 320 && key->dmp1 && key->dmq1 && key->iqmp && key->d) ? 1 : 0;
320} 321}
… …
593void 594void
594STORABLE_freeze(key, cloning) 595STORABLE_freeze(key, cloning)
595 OpenSSL::RSA key 596 OpenSSL::RSA key
596 bool cloning 597 bool cloning
597PREINIT: 598PREINIT:
598 SV *sv;
599 STRLEN totlen; 599 STRLEN totlen;
600PPCODE: 600PPCODE:
601 if(cloning) 601 if(cloning)
602 return; 602 return;
603 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);
… …
893 ALIAS: 893 ALIAS:
894 new_from_file = 1 894 new_from_file = 1
895 PREINIT: 895 PREINIT:
896 BIO *bio; 896 BIO *bio;
897 STRLEN l; 897 STRLEN l;
898 char *p, *q = 0; 898 char *p;
899 CODE: 899 CODE:
900 p = SvPV (thing, l); 900 p = SvPV (thing, l);
901 if(ix == 1) { 901 if(ix == 1) {
902 bio = BIO_new_file(p, "r"); 902 bio = BIO_new_file(p, "r");
903 } else { 903 } else {
… …
955 RETVAL = X509_NAME_dup (X509_get_issuer_name(x509)); 955 RETVAL = X509_NAME_dup (X509_get_issuer_name(x509));
956 OUTPUT: 956 OUTPUT:
957 RETVAL 957 RETVAL
958 958
959 959
960char * 960SV *
961subject_txt(x509) 961subject_txt(x509)
962 OpenSSL::X509 x509 962 OpenSSL::X509 x509
963 CODE: 963 CODE:
964 RETVAL = ol(X509_get_subject_name(x509)); 964 RETVAL = ol(X509_get_subject_name(x509));
965 OUTPUT: 965 OUTPUT:
966 RETVAL 966 RETVAL
967 967
968 968
969char * 969SV *
970issuer_txt(x509) 970issuer_txt(x509)
971 OpenSSL::X509 x509 971 OpenSSL::X509 x509
972 CODE: 972 CODE:
973 RETVAL = ol(X509_get_issuer_name(x509)); 973 RETVAL = ol(X509_get_issuer_name(x509));
974 OUTPUT: 974 OUTPUT:
… …
1210{ 1210{
1211 mds_boot(); 1211 mds_boot();
1212} 1212}
1213 1213
1214SV * 1214SV *
1215md2(sv) 1215md2(...)
1216 SV *sv
1217 ALIAS: 1216 ALIAS:
1218 md4 = 0x1 1217 md4 = 0x1
1219 md5 = 0x2 1218 md5 = 0x2
1220 sha = 0x3 1219 sha = 0x3
1221 sha1 = 0x4 1220 sha1 = 0x4
… …
1239 sha1_base64 = 0x24 1238 sha1_base64 = 0x24
1240 dss_base64 = 0x25 1239 dss_base64 = 0x25
1241 dss1_base64 = 0x26 1240 dss1_base64 = 0x26
1242 mdc2_base64 = 0x27 1241 mdc2_base64 = 0x27
1243 ripemd160_base64 = 0x28 1242 ripemd160_base64 = 0x28
1244 PREINIT: 1243 CODE:
1245 EVP_MD_CTX ctx; 1244 EVP_MD_CTX ctx;
1246 STRLEN l; 1245 STRLEN l;
1247 char *p; 1246 char *p;
1248 unsigned char md[EVP_MAX_MD_SIZE]; 1247 unsigned char md[EVP_MAX_MD_SIZE];
1249 unsigned int md_len; 1248 unsigned int md_len;
1250 CODE: 1249 int i;
1250
1251 EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]); 1251 EVP_DigestInit(&ctx, _mds[NO_FLAGS(ix)]);
1252
1253 for (i = 0; i < items; i++)
1254 {
1252 p = SvPV(sv, l); 1255 p = SvPV(ST(i), l);
1253 EVP_DigestUpdate(&ctx, p, l); 1256 EVP_DigestUpdate(&ctx, p, l);
1257 }
1258
1254 EVP_DigestFinal(&ctx, md, &md_len); 1259 EVP_DigestFinal(&ctx, md, &md_len);
1255 switch(ix & ~15) { 1260 switch(ix & ~15) {
1256 case 0: 1261 case 0:
1257 RETVAL = newSVpvn(md, md_len); 1262 RETVAL = newSVpvn(md, md_len);
1258 break; 1263 break;
… …
1368 dss_base64 = 0x25 1373 dss_base64 = 0x25
1369 dss1_base64 = 0x26 1374 dss1_base64 = 0x26
1370 mdc2_base64 = 0x27 1375 mdc2_base64 = 0x27
1371 ripemd160_base64 = 0x28 1376 ripemd160_base64 = 0x28
1372 PREINIT: 1377 PREINIT:
1373 HMAC_CTX ctx;
1374 STRLEN l, keylen; 1378 STRLEN l, keylen;
1375 char *p; 1379 char *p;
1376 char *key; 1380 char *key;
1377 unsigned char md[EVP_MAX_MD_SIZE]; 1381 unsigned char md[EVP_MAX_MD_SIZE];
1378 unsigned int md_len; 1382 unsigned int md_len;
… …
1554 OpenSSL::PKCS12 p12 1558 OpenSSL::PKCS12 p12
1555 ALIAS: 1559 ALIAS:
1556 as_file = 1 1560 as_file = 1
1557 PROTOTYPE: $;$ 1561 PROTOTYPE: $;$
1558 PREINIT: 1562 PREINIT:
1559 SV *sv;
1560 BIO *bio; 1563 BIO *bio;
1561 CODE: 1564 CODE:
1562 if((ix != 1 && items > 1) || (ix == 1 && items != 2)) 1565 if((ix != 1 && items > 1) || (ix == 1 && items != 2))
1563 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");
1564 if(items > 1) { 1567 if(items > 1) {
… …
1587 1590
1588 1591
1589MODULE = OpenSSL PACKAGE = OpenSSL::CRL 1592MODULE = OpenSSL PACKAGE = OpenSSL::CRL
1590 1593
1591OpenSSL::CRL 1594OpenSSL::CRL
1592new_from_string(thing) 1595new_from_string(class,thing)
1596 SV *class
1593 SV *thing 1597 SV *thing
1594 ALIAS: 1598 ALIAS:
1595 new_from_file = 1 1599 new_from_file = 1
1596 PREINIT: 1600 PREINIT:
1597 BIO *bio; 1601 BIO *bio;
1598 STRLEN l; 1602 STRLEN l;
1599 char *p, *q = 0; 1603 char *p;
1600 CODE: 1604 CODE:
1601 p = SvPV(thing, l); 1605 p = SvPV(thing, l);
1602 if(ix == 1) { 1606 if(ix == 1) {
1603 bio = BIO_new_file(p, "r"); 1607 bio = BIO_new_file(p, "r");
1604 } else { 1608 } else {

Diff Legend

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