git.maemo.org Git - dh-make-perl/blob - dev/i386/libnet-ssleay-perl/libnet-ssleay-perl-1.35/SSLeay.xs

   1 /* SSLeay.xs - Perl module for using Eric Young's implementation of SSL
   2  *
   3  * Copyright (c) 1996-2002 Sampo Kellomaki <sampo@iki.fi>
   4  * Copyright (C) 2005 Florian Ragwitz <rafl@debian.org>
   5  * Copyright (C) 2005 Mike McCauley <mikem@open.com.au>
   6  *
   7  * All Rights Reserved.
   8  *
   9  * 19.6.1998, Maintenance release to sync with SSLeay-0.9.0, --Sampo
  10  * 24.6.1998, added write_partial to support ssl_write_all in more
  11  *            memory efficient way. --Sampo
  12  * 8.7.1998,  Added SSL_(CTX)?_set_options and associated constants.
  13  * 31.3.1999, Tracking OpenSSL-0.9.2b changes, dropping support for
  14  *            earlier versions
  15  * 30.7.1999, Tracking OpenSSL-0.9.3a changes, --Sampo
  16  * 7.4.2001,  OpenSSL-0.9.6a update, --Sampo
  17  * 18.4.2001, added TLSv1 support by Stephen C. Koehler
  18  *            <koehler@securecomputing.com>, version 1.07, --Sampo
  19  * 25.4.2001, applied 64 bit fixes by Marko Asplund <aspa@kronodoc.fi> --Sampo
  20  * 16.7.2001, applied Win filehandle patch from aspa, added
  21  *            SSL_*_methods --Sampo
  22  * 25.9.2001, added a big pile of methods by automatically grepping and diffing
  23  *            openssl headers and my module --Sampo
  24  * 17.4.2002, applied patch to fix CTX_set_default_passwd_cb() contributed
  25  *            by Timo Kujala <timo.kujala@@intellitel_.com>, --Sampo
  26  * 17.5.2002, Added BIO_s_mem, BIO_new, BIO_free, BIO_write, BIO_read ,
  27  *            BIO_eof, BIO_pending, BIO_wpending, X509_NAME_get_text_by_NID,
  28  *            RSA_generate_key, BIO_new_file
  29  *            Fixed problem with return value from verify callback being
  30  *            ignored.
  31  *            Fixed a problem with CTX_set_tmp_rsa and CTX_set_tmp_dh
  32  *            args incorrect
  33  *            --mikem@open.com_.au
  34  * 10.8.2002, Added SSL_peek patch to ssl_read_until from
  35  *            Peter Behroozi <peter@@fhpwireless_.com> --Sampo
  36  * 21.8.2002, Added SESSION_get_master_key, SSL_get_client_random, SSL_get_server_random
  37  *            --mikem@open.com_.au
  38  * 2.9.2002,  Added SSL_CTX_get_cert_store, X509_STORE_add_cert, X509_STORE_add_crl
  39  *            X509_STORE_set_flags, X509_load_cert_file, X509_load_crl_file
  40  *            X509_load_cert_crl_file, PEM_read_bio_X509_CRL
  41  *            constants for X509_V_FLAG_*
  42  *            --mikem@open.com_.au
  43  * 6.9.2002,  applied Mike's patch and fixed X509_STORE_* to X509_STORE_CTX_*
  44  *            --Sampo
  45  * 18.2.2003, RAND patch from Toni Andjelkovic <toni@soth._at>
  46  * 13.6.2003, applied SSL_X509_LOOKUP patch by Marian Jancar <mjancar@suse._cz>
  47  * 18.8.2003, fixed some const char pointer warnings --Sampo
  48  * 01.12.2005 fixed a thread safety problem with SvSetSV that could cause crashes
  49  *            if SSL_CTX_set_default_passwd_cb and friends were called multiple
  50  *            times in different threads.
  51  *            Reintroduced X509_STORE_set_flags, also added
  52  *            X509_STORE_set_purpose and X509_STORE_set_trust
  53  *            Added X509_get_subjectAltNames and a number of other openssl
  54  *            X509 functions: X509_get_ext_by_NID X509_get_ext
  55  *            X509V3_EXT_d2i
  56  *            X509_verify_cert_error_string
  57  *            --mikem@open.com_.au
  58  * 13.12.2005 Reinstated the thread safety fix from 01.12.2005 due memory leaks
  59  *            It is better to reset the callback with undef after use to prevent
  60  *            leaks and thread safety problems.
  61  * 28.7.2006  Use New and Safefree insted of malloc/free. Use OPENSSL_free
  62  *            instead of free to release memory allocated by X509_NAME_oneline.
  63  *            These changes to deal with thread safety issues.
  64  * 01.08.2006 set_*fd nw woork with filehandles as well as filenos on Windows
  65  *
  66  * $Id$
  67  *
  68  * The distribution and use of this module are subject to the conditions
  69  * listed in LICENSE file at the root of OpenSSL-0.9.6b
  70  * distribution (i.e. free, but mandatory attribution and NO WARRANTY).
  71  */
  72
  73 /* Prevent warnings about strncpy from Windows compilers */
  74 #define _CRT_SECURE_NO_DEPRECATE
  75
  76 #ifdef __cplusplus
  77 extern "C" {
  78 #endif
  79 #include "EXTERN.h"
  80 #include "perl.h"
  81 #include "XSUB.h"
  82 #include "ppport.h"
  83 #ifdef __cplusplus
  84 }
  85 #endif
  86
  87 /* OpenSSL-0.9.3a has some strange warning about this in
  88  *    openssl/des.h
  89  */
  90 #undef _
  91
  92 #include <openssl/err.h>
  93 #include <openssl/lhash.h>
  94 #include <openssl/rand.h>
  95 #include <openssl/buffer.h>
  96 #include <openssl/ssl.h>
  97 #include <openssl/comp.h>    /* openssl-0.9.6a forgets to include this */
  98 #include <openssl/md2.h>
  99 #include <openssl/md4.h>
 100 #include <openssl/md5.h>     /* openssl-SNAP-20020227 does not automatically include this */
 101 #include <openssl/x509.h>
 102 #include <openssl/x509v3.h>
 103 #include <openssl/engine.h>
 104
 105 /* Debugging output */
 106
 107 #if 0
 108 #define PR(s) printf(s);
 109 #define PRN(s,n) printf("'%s' (%d)\n",s,n);
 110 #define SEX_DEBUG 1
 111 #else
 112 #define PR(s)
 113 #define PRN(s,n)
 114 #undef  SEX_DEBUG
 115 #endif
 116
 117 #include "constants.c"
 118
 119 /* ============= typedefs to agument TYPEMAP ============== */
 120
 121 typedef void callback_no_ret(void);
 122 typedef void cb_ssl_int_int_ret_void(const SSL *ssl,int,int);
 123 typedef RSA * cb_ssl_int_int_ret_RSA(SSL * ssl,int is_export, int keylength);
 124 typedef DH * cb_ssl_int_int_ret_DH(SSL * ssl,int is_export, int keylength);
 125
 126 typedef STACK_OF(X509_NAME) X509_NAME_STACK;
 127
 128 typedef int perl_filehandle_t;
 129
 130 /* ============= callback stuff ============== */
 131
 132 static HV* ssleay_ctx_verify_callbacks = (HV*)NULL;
 133
 134 static int
 135 ssleay_verify_callback_invoke (int ok, X509_STORE_CTX* x509_store) {
 136         SSL* ssl;
 137         SV* key;
 138         char* key_str;
 139         STRLEN key_len;
 140         SV** callback;
 141         int count, res;
 142         dSP;
 143
 144         ssl = X509_STORE_CTX_get_ex_data( x509_store, SSL_get_ex_data_X509_STORE_CTX_idx() );
 145         key = sv_2mortal(newSViv( (IV)ssl ));
 146         key_str = SvPV(key, key_len);
 147
 148         callback = hv_fetch( ssleay_ctx_verify_callbacks, key_str, key_len, 0 );
 149
 150         if (callback == NULL) {
 151                 SSL_CTX* ssl_ctx = SSL_get_SSL_CTX(ssl);
 152                 key = sv_2mortal(newSViv( (IV)ssl_ctx ));
 153                 key_str = SvPV(key, key_len);
 154
 155                 callback = hv_fetch( ssleay_ctx_verify_callbacks, key_str, key_len, 0 );
 156
 157                 if (callback == NULL) {
 158                         croak ("Net::SSLeay: verify_callback called, but not "
 159                                 "set to point to any perl function.\n");
 160                 }
 161         }
 162
 163
 164         ENTER;
 165         SAVETMPS;
 166
 167         PRN("verify callback glue", ok);
 168
 169         PUSHMARK(sp);
 170         EXTEND( sp, 2 );
 171         PUSHs( sv_2mortal(newSViv(ok)) );
 172         PUSHs( sv_2mortal(newSViv((unsigned long int)x509_store)) );
 173         PUTBACK;
 174
 175         PR("About to call verify callback.\n");
 176         count = call_sv(*callback, G_SCALAR);
 177         PR("Returned from verify callback.\n");
 178
 179         SPAGAIN;
 180
 181         if (count != 1) {
 182                 croak ( "Net::SSLeay: verify_callback "
 183                         "perl function did not return a scalar.\n");
 184         }
 185
 186         res = POPi;
 187
 188         PUTBACK;
 189         FREETMPS;
 190         LEAVE;
 191
 192         return res;
 193 }
 194
 195 static HV* ssleay_ctx_passwd_cbs = (HV*)NULL;
 196
 197 struct _ssleay_cb_t {
 198         SV* func;
 199         SV* data;
 200 };
 201 typedef struct _ssleay_cb_t ssleay_ctx_passwd_cb_t;
 202 typedef struct _ssleay_cb_t ssleay_ctx_cert_verify_cb_t;
 203 typedef struct _ssleay_cb_t ssleay_session_secret_cb_t;
 204 typedef struct _ssleay_cb_t ssleay_RSA_generate_key_cb_t;
 205
 206 ssleay_ctx_passwd_cb_t*
 207 ssleay_ctx_passwd_cb_new(SSL_CTX* ctx) {
 208         ssleay_ctx_passwd_cb_t* cb;
 209         SV* hash_value;
 210         SV* key;
 211         char* key_str;
 212         STRLEN key_len;
 213
 214         New(0, cb, 1, ssleay_ctx_passwd_cb_t);
 215         cb->func = NULL;
 216         cb->data = NULL;
 217
 218         if (ctx == NULL)
 219                 croak( "Net::SSLeay: ctx == NULL in ssleay_ctx_passwd_cb_new" );
 220
 221         hash_value = sv_2mortal(newSViv( (IV)cb ));
 222
 223         key = sv_2mortal(newSViv( (IV)ctx ));
 224         key_str = SvPV(key, key_len);
 225
 226         if (ssleay_ctx_passwd_cbs == (HV*)NULL)
 227                 ssleay_ctx_passwd_cbs = newHV();
 228
 229         SvREFCNT_inc(hash_value);
 230         hv_store( ssleay_ctx_passwd_cbs, key_str, key_len, hash_value, 0 );
 231
 232         return cb;
 233 }
 234
 235 ssleay_ctx_passwd_cb_t*
 236 ssleay_ctx_passwd_cb_get(SSL_CTX* ctx) {
 237         SV* key;
 238         char* key_str;
 239         STRLEN key_len;
 240         SV** hash_value;
 241         ssleay_ctx_passwd_cb_t* cb;
 242
 243         key = sv_2mortal(newSViv( (IV)ctx ));
 244         key_str = SvPV(key, key_len);
 245
 246         hash_value = hv_fetch( ssleay_ctx_passwd_cbs, key_str, key_len, 0 );
 247
 248         if (hash_value == NULL || *hash_value == NULL) {
 249                 cb = ssleay_ctx_passwd_cb_new(ctx);
 250         } else {
 251                 cb = (ssleay_ctx_passwd_cb_t*)SvIV( *hash_value );
 252         }
 253
 254         return cb;
 255 }
 256
 257 void
 258 ssleay_ctx_passwd_cb_func_set(SSL_CTX* ctx, SV* func) {
 259         ssleay_ctx_passwd_cb_t* cb;
 260
 261         cb = ssleay_ctx_passwd_cb_get(ctx);
 262
 263         if (cb->func)
 264                 SvREFCNT_dec(cb->func);
 265
 266         SvREFCNT_inc(func);
 267         cb->func = func;
 268 }
 269
 270 void
 271 ssleay_ctx_passwd_cb_userdata_set(SSL_CTX* ctx, SV* data) {
 272         ssleay_ctx_passwd_cb_t* cb;
 273
 274         cb = ssleay_ctx_passwd_cb_get(ctx);
 275
 276         if (cb->data)
 277                 SvREFCNT_dec(cb->data);
 278
 279         SvREFCNT_inc(data);
 280         cb->data = data;
 281 }
 282
 283 void
 284 ssleay_ctx_passwd_cb_free_func(SSL_CTX* ctx) {
 285         ssleay_ctx_passwd_cb_t* cb;
 286
 287         cb = ssleay_ctx_passwd_cb_get(ctx);
 288
 289         if (cb && cb->func) {
 290                 SvREFCNT_dec(cb->func);
 291                 cb->func = NULL;
 292         }
 293 }
 294
 295 void
 296 ssleay_ctx_passwd_cb_free_userdata(SSL_CTX* ctx) {
 297         ssleay_ctx_passwd_cb_t* cb;
 298
 299         cb = ssleay_ctx_passwd_cb_get(ctx);
 300
 301         if (cb && cb->data) {
 302                 SvREFCNT_dec(cb->data);
 303                 cb->data = NULL;
 304         }
 305 }
 306
 307 /* pem_password_cb function */
 308
 309 static int
 310 ssleay_ctx_passwd_cb_invoke(char *buf, int size, int rwflag, void *userdata) {
 311         dSP;
 312
 313         int count;
 314         char *res;
 315         ssleay_ctx_passwd_cb_t* cb = (ssleay_ctx_passwd_cb_t*)userdata;
 316
 317         ENTER;
 318         SAVETMPS;
 319
 320         PUSHMARK(sp);
 321         XPUSHs( sv_2mortal( newSViv(rwflag)) );
 322         if (cb->data)
 323                 XPUSHs( cb->data );
 324         PUTBACK;
 325
 326         if (cb->func == NULL)
 327                 croak ("Net::SSLeay: ssleay_ctx_passwd_cb_invoke called, but not "
 328                            "set to point to any perl function.\n");
 329
 330         count = call_sv( cb->func, G_SCALAR );
 331
 332         SPAGAIN;
 333
 334         if (count != 1)
 335                 croak ("Net::SSLeay: ssleay_ctx_passwd_cb_invoke "
 336                            "perl function did not return a scalar.\n");
 337
 338         res = POPp;
 339
 340         if (res == NULL) {
 341                 *buf = '\0';
 342         } else {
 343                 strncpy(buf, res, size);
 344                 buf[size - 1] = '\0';
 345         }
 346
 347         PUTBACK;
 348         FREETMPS;
 349         LEAVE;
 350
 351         return strlen(buf);
 352 }
 353
 354 static HV* ssleay_ctx_cert_verify_cbs = (HV*)NULL;
 355
 356 ssleay_ctx_cert_verify_cb_t*
 357 ssleay_ctx_cert_verify_cb_new(SSL_CTX* ctx, SV* func, SV* data) {
 358         ssleay_ctx_cert_verify_cb_t* cb;
 359         SV* hash_value;
 360         SV* key;
 361         char* key_str;
 362         STRLEN key_len;
 363
 364         cb = New(0, cb, 1, ssleay_ctx_cert_verify_cb_t);
 365
 366         SvREFCNT_inc(func);
 367         SvREFCNT_inc(data);
 368         cb->func = func;
 369         cb->data = data;
 370
 371         if (ctx == NULL) {
 372                 croak( "Net::SSLeay: ctx == NULL in ssleay_ctx_cert_verify_cb_new" );
 373         }
 374
 375         hash_value = sv_2mortal(newSViv( (IV)cb ));
 376
 377         key = sv_2mortal(newSViv( (IV)ctx ));
 378         key_str = SvPV(key, key_len);
 379
 380         if (ssleay_ctx_cert_verify_cbs == (HV*)NULL)
 381                 ssleay_ctx_cert_verify_cbs = newHV();
 382
 383         SvREFCNT_inc(hash_value);
 384         hv_store( ssleay_ctx_cert_verify_cbs, key_str, key_len, hash_value, 0 );
 385
 386         return cb;
 387 }
 388
 389 ssleay_ctx_cert_verify_cb_t*
 390 ssleay_ctx_cert_verify_cb_get(SSL_CTX* ctx) {
 391         SV* key;
 392         char* key_str;
 393         STRLEN key_len;
 394         SV** hash_value;
 395         ssleay_ctx_cert_verify_cb_t* cb;
 396
 397         key = sv_2mortal(newSViv( (IV)ctx ));
 398         key_str = SvPV(key, key_len);
 399
 400         hash_value = hv_fetch( ssleay_ctx_cert_verify_cbs, key_str, key_len, 0 );
 401
 402         if (hash_value == NULL || *hash_value == NULL) {
 403                 cb = NULL;
 404         } else {
 405                 cb = (ssleay_ctx_cert_verify_cb_t*)SvIV( *hash_value );
 406         }
 407
 408         return cb;
 409 }
 410
 411 void
 412 ssleay_ctx_cert_verify_cb_free(SSL_CTX* ctx) {
 413         ssleay_ctx_passwd_cb_t* cb;
 414
 415         cb = ssleay_ctx_cert_verify_cb_get(ctx);
 416
 417         if (cb) {
 418                 if (cb->func) {
 419                         SvREFCNT_dec(cb->func);
 420                         cb->func = NULL;
 421                 }
 422
 423                 if (cb->data) {
 424                         SvREFCNT_dec(cb->data);
 425                         cb->data = NULL;
 426                 }
 427         }
 428
 429         Safefree(cb);
 430 }
 431
 432 int
 433 ssleay_ctx_cert_verify_cb_invoke(X509_STORE_CTX* x509_store_ctx, void* data) {
 434         dSP;
 435
 436         int count;
 437         int res;
 438         ssleay_ctx_cert_verify_cb_t* cb = (ssleay_ctx_cert_verify_cb_t*)data;
 439
 440         ENTER;
 441         SAVETMPS;
 442
 443         PUSHMARK(SP);
 444         XPUSHs(sv_2mortal(newSViv( (IV)x509_store_ctx )));
 445         if (cb->data) {
 446                 XPUSHs( cb->data );
 447         }
 448         PUTBACK;
 449
 450         if (cb->func == NULL) {
 451                 croak ("Net::SSLeay: ssleay_ctx_cert_verify_cb_invoke called, but not "
 452                                 "set to point to any perl function.\n");
 453         }
 454
 455         count = call_sv( cb->func, G_SCALAR );
 456
 457         SPAGAIN;
 458
 459         if (count != 1) {
 460                 croak ("Net::SSLeay: ssleay_ctx_cert_verify_cb_invoke "
 461                                 "perl function did not return a scalar.\n");
 462         }
 463
 464         res = POPi;
 465
 466         PUTBACK;
 467         FREETMPS;
 468         LEAVE;
 469
 470         return res;
 471 }
 472
 473 #ifdef SSL_F_SSL_SET_HELLO_EXTENSION
 474 static HV* ssleay_session_secret_cbs = (HV*)NULL;
 475
 476 ssleay_session_secret_cb_t*
 477 ssleay_session_secret_cb_new(SSL* s, SV* func, SV* data) {
 478         ssleay_session_secret_cb_t* cb;
 479         SV* hash_value;
 480         SV* key;
 481         char* key_str;
 482         STRLEN key_len;
 483
 484         cb = New(0, cb, 1, ssleay_session_secret_cb_t);
 485
 486         SvREFCNT_inc(func);
 487         SvREFCNT_inc(data);
 488         cb->func = func;
 489         cb->data = data;
 490
 491         if (s == NULL) {
 492                 croak( "Net::SSLeay: s == NULL in ssleay_session_secret_cb_new" );
 493         }
 494
 495         hash_value = sv_2mortal(newSViv( (IV)cb ));
 496
 497         key = sv_2mortal(newSViv( (IV)s ));
 498         key_str = SvPV(key, key_len);
 499
 500         if (ssleay_session_secret_cbs == (HV*)NULL)
 501                 ssleay_session_secret_cbs = newHV();
 502
 503         SvREFCNT_inc(hash_value);
 504         hv_store( ssleay_session_secret_cbs, key_str, key_len, hash_value, 0 );
 505
 506         return cb;
 507 }
 508
 509 ssleay_session_secret_cb_t*
 510 ssleay_session_secret_cb_get(SSL* s) {
 511         SV* key;
 512         char* key_str;
 513         STRLEN key_len;
 514         SV** hash_value;
 515         ssleay_session_secret_cb_t* cb;
 516
 517         key = sv_2mortal(newSViv( (IV)s ));
 518         key_str = SvPV(key, key_len);
 519
 520         hash_value = hv_fetch( ssleay_session_secret_cbs, key_str, key_len, 0 );
 521
 522         if (hash_value == NULL || *hash_value == NULL) {
 523                 cb = NULL;
 524         } else {
 525                 cb = (ssleay_session_secret_cb_t*)SvIV( *hash_value );
 526         }
 527
 528         return cb;
 529 }
 530
 531 void
 532 ssleay_session_secret_cb_free(SSL* s) {
 533         ssleay_session_secret_cb_t* cb;
 534
 535         cb = ssleay_session_secret_cb_get(s);
 536
 537         if (cb) {
 538                 if (cb->func) {
 539                         SvREFCNT_dec(cb->func);
 540                         cb->func = NULL;
 541                 }
 542
 543                 if (cb->data) {
 544                         SvREFCNT_dec(cb->data);
 545                         cb->data = NULL;
 546                 }
 547         }
 548
 549         Safefree(cb);
 550 }
 551
 552 int
 553 ssleay_session_secret_cb_invoke(SSL* s, void* secret, int *secret_len,
 554                            STACK_OF(SSL_CIPHER) *peer_ciphers,
 555                            SSL_CIPHER **cipher, void *arg)
 556 {
 557         dSP;
 558
 559         int count;
 560         int res;
 561         int i;
 562         AV *ciphers = newAV();
 563         SV *pref_cipher = sv_newmortal();
 564         ssleay_session_secret_cb_t* cb = (ssleay_session_secret_cb_t*)arg;
 565
 566         ENTER;
 567         SAVETMPS;
 568
 569         PUSHMARK(SP);
 570         XPUSHs( sv_2mortal( newSVpv(secret, *secret_len)) );
 571         for (i=0; i<sk_SSL_CIPHER_num(peer_ciphers); i++)
 572         {
 573             SSL_CIPHER *c = sk_SSL_CIPHER_value(peer_ciphers,i);
 574             av_store(ciphers, i, sv_2mortal(newSVpv(SSL_CIPHER_get_name(c), 0)));
 575         }
 576         XPUSHs(sv_2mortal(newRV((SV*)ciphers)));
 577         XPUSHs(sv_2mortal(newRV(pref_cipher)));
 578         if (cb->data) {
 579                 XPUSHs( cb->data );
 580         }
 581         PUTBACK;
 582
 583         if (cb->func == NULL) {
 584                 croak ("Net::SSLeay: ssleay_session_secret_cb_invoke called, but not "
 585                                 "set to point to any perl function.\n");
 586         }
 587
 588         count = call_sv( cb->func, G_SCALAR );
 589
 590         SPAGAIN;
 591
 592         if (count != 1) {
 593                 croak ("Net::SSLeay: ssleay_session_secret_cb_invoke "
 594                                 "perl function did not return a scalar.\n");
 595         }
 596
 597         res = POPi;
 598         if (res)
 599         {
 600             /* See if there is a preferred cipher selected, if so
 601                it is an index into the stack */
 602             if (SvIOK(pref_cipher))
 603             {
 604                 *cipher = sk_SSL_CIPHER_value(peer_ciphers, SvIV(pref_cipher));
 605             }
 606         }
 607
 608         PUTBACK;
 609         FREETMPS;
 610         LEAVE;
 611
 612         return res;
 613 }
 614
 615 #endif
 616
 617 ssleay_RSA_generate_key_cb_t*
 618 ssleay_RSA_generate_key_cb_new(SV* func, SV* data) {
 619         ssleay_RSA_generate_key_cb_t* cb;
 620
 621         New(0, cb, 1, ssleay_RSA_generate_key_cb_t);
 622         cb->func = NULL;
 623         cb->data = NULL;
 624
 625         if (func) {
 626                 SvREFCNT_inc(func);
 627                 cb->func = func;
 628         }
 629
 630         if (data) {
 631                 SvREFCNT_inc(data);
 632                 cb->data = data;
 633         }
 634
 635         return cb;
 636 }
 637
 638 void
 639 ssleay_RSA_generate_key_cb_free(ssleay_RSA_generate_key_cb_t* cb) {
 640         if (cb) {
 641                 if (cb->func) {
 642                         SvREFCNT_dec(cb->func);
 643                         cb->func = NULL;
 644                 }
 645
 646                 if (cb->data) {
 647                         SvREFCNT_dec(cb->data);
 648                         cb->data = NULL;
 649                 }
 650         }
 651
 652         Safefree(cb);
 653 }
 654
 655 void
 656 ssleay_RSA_generate_key_cb_invoke(int i, int n, void* data) {
 657         dSP;
 658
 659         ssleay_RSA_generate_key_cb_t* cb = (ssleay_RSA_generate_key_cb_t*)data;
 660
 661         if (cb->func) {
 662                 int count;
 663
 664                 ENTER;
 665                 SAVETMPS;
 666
 667                 PUSHMARK(sp);
 668
 669                 XPUSHs(sv_2mortal( newSViv(i) ));
 670                 XPUSHs(sv_2mortal( newSViv(n) ));
 671
 672                 if (cb->data)
 673                         XPUSHs( cb->data );
 674
 675                 PUTBACK;
 676
 677                 count = call_sv( cb->func, G_VOID|G_DISCARD );
 678
 679                 if (count != 0)
 680                         croak ("Net::SSLeay: ssleay_RSA_generate_key_cb_invoke "
 681                                         "perl function did return something in void context.\n");
 682
 683                 PUTBACK;
 684                 FREETMPS;
 685                 LEAVE;
 686         }
 687 }
 688
 689
 690 MODULE = Net::SSLeay            PACKAGE = Net::SSLeay          PREFIX = SSL_
 691
 692 PROTOTYPES: ENABLE
 693
 694 double
 695 constant(name)
 696      char *             name
 697
 698 int
 699 hello()
 700         CODE:
 701         PR("\tSSLeay Hello World!\n");
 702         RETVAL = 1;
 703         OUTPUT:
 704         RETVAL
 705
 706 #define REM1 "============= SSL CONTEXT functions =============="
 707
 708 SSL_CTX *
 709 SSL_CTX_new()
 710      CODE:
 711      RETVAL = SSL_CTX_new (SSLv23_method());
 712      OUTPUT:
 713      RETVAL
 714
 715 SSL_CTX *
 716 SSL_CTX_v2_new()
 717      CODE:
 718      RETVAL = SSL_CTX_new (SSLv2_method());
 719      OUTPUT:
 720      RETVAL
 721
 722 SSL_CTX *
 723 SSL_CTX_v3_new()
 724      CODE:
 725      RETVAL = SSL_CTX_new (SSLv3_method());
 726      OUTPUT:
 727      RETVAL
 728
 729 SSL_CTX *
 730 SSL_CTX_v23_new()
 731      CODE:
 732      RETVAL = SSL_CTX_new (SSLv23_method());
 733      OUTPUT:
 734      RETVAL
 735
 736 SSL_CTX *
 737 SSL_CTX_tlsv1_new()
 738      CODE:
 739      RETVAL = SSL_CTX_new (TLSv1_method());
 740      OUTPUT:
 741      RETVAL
 742
 743 SSL_CTX *
 744 SSL_CTX_new_with_method(meth)
 745      CODE:
 746      RETVAL = SSL_CTX_new (SSLv23_method());
 747      OUTPUT:
 748      RETVAL
 749
 750 void
 751 SSL_CTX_free(ctx)
 752      SSL_CTX *          ctx
 753
 754 int
 755 SSL_CTX_add_session(ctx,ses)
 756      SSL_CTX *          ctx
 757      SSL_SESSION *      ses
 758
 759 int
 760 SSL_CTX_remove_session(ctx,ses)
 761      SSL_CTX *          ctx
 762      SSL_SESSION *      ses
 763
 764 void
 765 SSL_CTX_flush_sessions(ctx,tm)
 766      SSL_CTX *          ctx
 767      long               tm
 768
 769 int
 770 SSL_CTX_set_default_verify_paths(ctx)
 771      SSL_CTX *          ctx
 772
 773 int
 774 SSL_CTX_load_verify_locations(ctx,CAfile,CApath)
 775      SSL_CTX * ctx
 776      char * CAfile
 777      char * CApath
 778      CODE:
 779      RETVAL = SSL_CTX_load_verify_locations (ctx,
 780                                              CAfile?(*CAfile?CAfile:NULL):NULL,
 781                                              CApath?(*CApath?CApath:NULL):NULL
 782                                              );
 783      OUTPUT:
 784      RETVAL
 785
 786 void
 787 SSL_CTX_set_verify(ctx,mode,callback=NULL)
 788         SSL_CTX * ctx
 789         int                mode
 790         SV *               callback
 791         PREINIT:
 792         SV* key;
 793         char* key_str;
 794         STRLEN key_len;
 795         CODE:
 796
 797         if (ssleay_ctx_verify_callbacks == (HV*)NULL)
 798                 ssleay_ctx_verify_callbacks = newHV();
 799
 800         key = sv_2mortal(newSViv( (IV)ctx ));
 801         key_str = SvPV(key, key_len);
 802
 803         /* Former versions of SSLeay checked if the callback was a true boolean value
 804          * and didn't call it if it was false. Therefor some people set the callback
 805          * to '0' if they don't want to use it (IO::Socket::SSL for example). Therefor
 806          * we don't execute the callback if it's value isn't something true to retain
 807          * backwards compatibility.
 808          */
 809
 810         if (callback == NULL || !SvTRUE(callback)) {
 811                 hv_delete( ssleay_ctx_verify_callbacks, key_str, key_len, G_DISCARD );
 812                 SSL_CTX_set_verify( ctx, mode, NULL );
 813         } else {
 814                 hv_store( ssleay_ctx_verify_callbacks, key_str, key_len, newSVsv(callback), 0 );
 815                 SSL_CTX_set_verify( ctx, mode, &ssleay_verify_callback_invoke );
 816         }
 817
 818 int
 819 SSL_get_error(s,ret)
 820      SSL *              s
 821      int ret
 822
 823 #define REM10 "============= SSL functions =============="
 824
 825 SSL *
 826 SSL_new(ctx)
 827      SSL_CTX *          ctx
 828
 829 void
 830 SSL_free(s)
 831      SSL *              s
 832
 833 #if 0 /* this seems to be gone in 0.9.0 */
 834 void
 835 SSL_debug(file)
 836        char *  file
 837
 838 #endif
 839
 840 int
 841 SSL_accept(s)
 842      SSL *   s
 843
 844 void
 845 SSL_clear(s)
 846      SSL *   s
 847
 848 int
 849 SSL_connect(s)
 850      SSL *   s
 851
 852
 853 #if defined(WIN32)
 854
 855 int
 856 SSL_set_fd(s,fd)
 857      SSL *   s
 858      perl_filehandle_t     fd
 859      CODE:
 860      RETVAL = SSL_set_fd(s,_get_osfhandle(fd));
 861      OUTPUT:
 862      RETVAL
 863
 864 int
 865 SSL_set_rfd(s,fd)
 866      SSL *   s
 867      perl_filehandle_t     fd
 868      CODE:
 869      RETVAL = SSL_set_rfd(s,_get_osfhandle(fd));
 870      OUTPUT:
 871      RETVAL
 872
 873 int
 874 SSL_set_wfd(s,fd)
 875      SSL *   s
 876      perl_filehandle_t     fd
 877      CODE:
 878      RETVAL = SSL_set_wfd(s,_get_osfhandle(fd));
 879      OUTPUT:
 880      RETVAL
 881
 882 #else
 883
 884 int
 885 SSL_set_fd(s,fd)
 886      SSL *   s
 887      perl_filehandle_t     fd
 888
 889 int
 890 SSL_set_rfd(s,fd)
 891      SSL *   s
 892      perl_filehandle_t     fd
 893
 894 int
 895 SSL_set_wfd(s,fd)
 896      SSL *   s
 897      perl_filehandle_t     fd
 898
 899 #endif
 900
 901 int
 902 SSL_get_fd(s)
 903      SSL *   s
 904
 905 void
 906 SSL_read(s,max=32768)
 907         SSL *   s
 908         int     max
 909         PREINIT:
 910         char *buf;
 911         int got;
 912         CODE:
 913         New(0, buf, max, char);
 914         ST(0) = sv_newmortal();   /* Undefined to start with */
 915         if ((got = SSL_read(s, buf, max)) >= 0)
 916                 sv_setpvn( ST(0), buf, got);
 917         Safefree(buf);
 918
 919 void
 920 SSL_peek(s,max=32768)
 921         SSL *   s
 922         int     max
 923         PREINIT:
 924         char *buf;
 925         int got;
 926         CODE:
 927         New(0, buf, max, char);
 928         ST(0) = sv_newmortal();   /* Undefined to start with */
 929         if ((got = SSL_peek(s, buf, max)) >= 0)
 930                 sv_setpvn( ST(0), buf, got);
 931         Safefree(buf);
 932
 933 int
 934 SSL_write(s,buf)
 935      SSL *   s
 936      PREINIT:
 937      STRLEN len;
 938      INPUT:
 939      char *  buf = SvPV( ST(1), len);
 940      CODE:
 941      RETVAL = SSL_write (s, buf, (int)len);
 942      OUTPUT:
 943      RETVAL
 944
 945 int
 946 SSL_write_partial(s,from,count,buf)
 947      SSL *   s
 948      int     from
 949      int     count
 950      PREINIT:
 951      STRLEN len;
 952      INPUT:
 953      char *  buf = SvPV( ST(3), len);
 954      CODE:
 955       /*
 956      if (SvROK( ST(3) )) {
 957        SV* t = SvRV( ST(3) );
 958        buf = SvPV( t, len);
 959      } else
 960        buf = SvPV( ST(3), len);
 961        */
 962      PRN("write_partial from",from);
 963      PRN(&buf[from],len);
 964      PRN("write_partial count",count);
 965      len -= from;
 966      if (len < 0) {
 967        croak("from beyound end of buffer");
 968        RETVAL = -1;
 969      } else
 970        RETVAL = SSL_write (s, &(buf[from]), ((STRLEN)count<=len)?count:len);
 971      OUTPUT:
 972      RETVAL
 973
 974 int
 975 SSL_use_RSAPrivateKey(s,rsa)
 976      SSL *              s
 977      RSA *              rsa
 978
 979 int
 980 SSL_use_RSAPrivateKey_ASN1(s,d,len)
 981      SSL *              s
 982      unsigned char *    d
 983      long               len
 984
 985 int
 986 SSL_use_RSAPrivateKey_file(s,file,type)
 987      SSL *              s
 988      char *             file
 989      int                type
 990
 991 int
 992 SSL_CTX_use_RSAPrivateKey_file(ctx,file,type)
 993      SSL_CTX *          ctx
 994      char *             file
 995      int                type
 996
 997 int
 998 SSL_use_PrivateKey(s,pkey)
 999      SSL *              s
1000      EVP_PKEY *         pkey
1001
1002 int
1003 SSL_use_PrivateKey_ASN1(pk,s,d,len)
1004      int                pk
1005      SSL *              s
1006      unsigned char *    d
1007      long               len
1008
1009 int
1010 SSL_use_PrivateKey_file(s,file,type)
1011      SSL *              s
1012      char *             file
1013      int                type
1014
1015 int
1016 SSL_CTX_use_PrivateKey_file(ctx,file,type)
1017      SSL_CTX *          ctx
1018      char *             file
1019      int                type
1020
1021 int
1022 SSL_use_certificate(s,x)
1023      SSL *              s
1024      X509 *             x
1025
1026 int
1027 SSL_use_certificate_ASN1(s,d,len)
1028      SSL *              s
1029      unsigned char *    d
1030      long               len
1031
1032 int
1033 SSL_use_certificate_file(s,file,type)
1034      SSL *              s
1035      char *             file
1036      int                type
1037
1038 int
1039 SSL_CTX_use_certificate_file(ctx,file,type)
1040      SSL_CTX *          ctx
1041      char *             file
1042      int                type
1043
1044 const char *
1045 SSL_state_string(s)
1046      SSL *              s
1047
1048 const char *
1049 SSL_rstate_string(s)
1050      SSL *              s
1051
1052 const char *
1053 SSL_state_string_long(s)
1054      SSL *              s
1055
1056 const char *
1057 SSL_rstate_string_long(s)
1058      SSL *              s
1059
1060
1061 long
1062 SSL_get_time(ses)
1063      SSL_SESSION *      ses
1064
1065 long
1066 SSL_set_time(ses,t)
1067      SSL_SESSION *      ses
1068      long               t
1069
1070 long
1071 SSL_get_timeout(ses)
1072      SSL_SESSION *      ses
1073
1074 long
1075 SSL_set_timeout(ses,t)
1076      SSL_SESSION *      ses
1077      long               t
1078
1079 void
1080 SSL_copy_session_id(to,from)
1081      SSL *              to
1082      SSL *              from
1083
1084 void
1085 SSL_set_read_ahead(s,yes=1)
1086      SSL *              s
1087      int                yes
1088
1089 int
1090 SSL_get_read_ahead(s)
1091      SSL *              s
1092
1093 int
1094 SSL_pending(s)
1095      SSL *              s
1096
1097 int
1098 SSL_CTX_set_cipher_list(s,str)
1099      SSL_CTX *              s
1100      char *             str
1101
1102 const char *
1103 SSL_get_cipher_list(s,n)
1104      SSL *              s
1105      int                n
1106
1107 int
1108 SSL_set_cipher_list(s,str)
1109      SSL *              s
1110      char *       str
1111
1112 const char *
1113 SSL_get_cipher(s)
1114      SSL *              s
1115
1116 char *
1117 SSL_get_shared_ciphers(s,buf,len)
1118      SSL *              s
1119      char *             buf
1120      int                len
1121
1122 X509 *
1123 SSL_get_peer_certificate(s)
1124      SSL *              s
1125
1126 void
1127 SSL_set_verify(s,mode,callback)
1128     SSL *              s
1129     int                mode
1130     SV *               callback
1131         PREINIT:
1132         SV* key;
1133         char* key_str;
1134         STRLEN key_len;
1135     CODE:
1136
1137         if (ssleay_ctx_verify_callbacks == (HV*)NULL)
1138                 ssleay_ctx_verify_callbacks = newHV();
1139
1140         key = sv_2mortal(newSViv( (IV)s ));
1141         key_str = SvPV(key, key_len);
1142
1143         if (callback == NULL) {
1144                 hv_delete( ssleay_ctx_verify_callbacks, key_str, key_len, G_DISCARD );
1145                 SSL_set_verify( s, mode, NULL );
1146         } else {
1147                 hv_store( ssleay_ctx_verify_callbacks, key_str, key_len, newSVsv(callback), 0 );
1148                 SSL_set_verify( s, mode, &ssleay_verify_callback_invoke );
1149         }
1150
1151 void
1152 SSL_set_bio(s,rbio,wbio)
1153      SSL *              s
1154      BIO *              rbio
1155      BIO *              wbio
1156
1157 BIO *
1158 SSL_get_rbio(s)
1159      SSL *              s
1160
1161 BIO *
1162 SSL_get_wbio(s)
1163      SSL *              s
1164
1165
1166 SSL_SESSION *
1167 SSL_SESSION_new()
1168
1169 int
1170 SSL_SESSION_print(fp,ses)
1171      BIO *              fp
1172      SSL_SESSION *      ses
1173
1174 void
1175 SSL_SESSION_free(ses)
1176      SSL_SESSION *      ses
1177
1178 int
1179 i2d_SSL_SESSION(in,pp)
1180      SSL_SESSION *      in
1181      unsigned char *    &pp
1182
1183 int
1184 SSL_set_session(to,ses)
1185      SSL *              to
1186      SSL_SESSION *      ses
1187
1188 SSL_SESSION *
1189 d2i_SSL_SESSION(a,pp,length)
1190      SSL_SESSION *      &a
1191      const unsigned char *    &pp
1192      long               length
1193
1194 #define REM30 "SSLeay-0.9.0 defines these as macros. I expand them here for safety's sake"
1195
1196 SSL_SESSION *
1197 SSL_get_session(s)
1198         SSL *              s
1199         ALIAS:
1200                 SSL_get0_session = 1
1201
1202 SSL_SESSION *
1203 SSL_get1_session(s)
1204      SSL *              s
1205
1206 X509 *
1207 SSL_get_certificate(s)
1208      SSL *              s
1209
1210 SSL_CTX *
1211 SSL_get_SSL_CTX(s)
1212      SSL *              s
1213
1214 long
1215 SSL_ctrl(ssl,cmd,larg,parg)
1216          SSL * ssl
1217          int cmd
1218          long larg
1219          char * parg
1220
1221 long
1222 SSL_CTX_ctrl(ctx,cmd,larg,parg)
1223     SSL_CTX * ctx
1224     int cmd
1225     long larg
1226     char * parg
1227
1228 long
1229 SSL_get_options(ssl)
1230      SSL *          ssl
1231
1232 void
1233 SSL_set_options(ssl,op)
1234      SSL *          ssl
1235      long           op
1236
1237 long
1238 SSL_CTX_get_options(ctx)
1239      SSL_CTX *      ctx
1240
1241 void
1242 SSL_CTX_set_options(ctx,op)
1243      SSL_CTX *      ctx
1244      long           op
1245
1246 LHASH *
1247 SSL_CTX_sessions(ctx)
1248      SSL_CTX *          ctx
1249      CODE:
1250     /* NOTE: This should be deprecated. Corresponding macro was removed from ssl.h as of 0.9.2 */
1251      if (ctx == NULL) croak("NULL SSL context passed as argument.");
1252      RETVAL = ctx -> sessions;
1253      OUTPUT:
1254      RETVAL
1255
1256 unsigned long
1257 SSL_CTX_sess_number(ctx)
1258      SSL_CTX *          ctx
1259
1260 int
1261 SSL_CTX_sess_connect(ctx)
1262      SSL_CTX *          ctx
1263
1264 int
1265 SSL_CTX_sess_connect_good(ctx)
1266      SSL_CTX *          ctx
1267
1268 int
1269 SSL_CTX_sess_connect_renegotiate(ctx)
1270      SSL_CTX *          ctx
1271
1272 int
1273 SSL_CTX_sess_accept(ctx)
1274      SSL_CTX *          ctx
1275
1276 int
1277 SSL_CTX_sess_accept_renegotiate(ctx)
1278      SSL_CTX *          ctx
1279
1280 int
1281 SSL_CTX_sess_accept_good(ctx)
1282      SSL_CTX *          ctx
1283
1284 int
1285 SSL_CTX_sess_hits(ctx)
1286      SSL_CTX *          ctx
1287
1288 int
1289 SSL_CTX_sess_cb_hits(ctx)
1290      SSL_CTX *          ctx
1291
1292 int
1293 SSL_CTX_sess_misses(ctx)
1294      SSL_CTX *          ctx
1295
1296 int
1297 SSL_CTX_sess_timeouts(ctx)
1298      SSL_CTX *          ctx
1299
1300 int
1301 SSL_CTX_sess_cache_full(ctx)
1302      SSL_CTX *          ctx
1303
1304 int
1305 SSL_CTX_sess_get_cache_size(ctx)
1306      SSL_CTX *          ctx
1307
1308 void
1309 SSL_CTX_sess_set_cache_size(ctx,size)
1310      SSL_CTX *          ctx
1311      int                size
1312
1313 int
1314 SSL_want(s)
1315      SSL *              s
1316
1317 int
1318 SSL_state(s)
1319      SSL *              s
1320
1321 BIO_METHOD *
1322 BIO_f_ssl()
1323
1324 BIO_METHOD *
1325 BIO_s_mem()
1326
1327 unsigned long
1328 ERR_get_error()
1329
1330 unsigned long
1331 ERR_peek_error()
1332
1333 void
1334 ERR_put_error(lib,func,reason,file,line)
1335      int                lib
1336      int                func
1337      int                reason
1338      char *             file
1339      int                line
1340
1341 void
1342 ERR_clear_error()
1343
1344 char *
1345 ERR_error_string(error,buf=NULL)
1346      unsigned long      error
1347      char *             buf
1348      CODE:
1349      RETVAL = ERR_error_string(error,buf);
1350      OUTPUT:
1351      RETVAL
1352
1353 void
1354 SSL_load_error_strings()
1355
1356 void
1357 ERR_load_crypto_strings()
1358
1359 int
1360 SSL_library_init()
1361         ALIAS:
1362                 SSLeay_add_ssl_algorithms  = 1
1363                 OpenSSL_add_ssl_algorithms = 2
1364                 add_ssl_algorithms         = 3
1365
1366 void
1367 ENGINE_load_builtin_engines()
1368
1369 void
1370 ENGINE_register_all_complete()
1371
1372 ENGINE*
1373 ENGINE_by_id(id)
1374         char * id
1375
1376 int
1377 ENGINE_set_default(e, flags)
1378         ENGINE * e
1379         int flags
1380
1381 void
1382 ERR_load_SSL_strings()
1383
1384 void
1385 ERR_load_RAND_strings()
1386
1387 int
1388 RAND_bytes(buf, num)
1389     SV *buf
1390     int num
1391     PREINIT:
1392         int rc;
1393         unsigned char *random;
1394     CODE:
1395         New(0, random, num, unsigned char);
1396         rc = RAND_bytes(random, num);
1397         sv_setpvn(buf, (const char*)random, num);
1398         Safefree(random);
1399         RETVAL = rc;
1400     OUTPUT:
1401         RETVAL
1402
1403 int
1404 RAND_pseudo_bytes(buf, num)
1405     SV *buf
1406     int num
1407     PREINIT:
1408         int rc;
1409         unsigned char *random;
1410     CODE:
1411         New(0, random, num, unsigned char);
1412         rc = RAND_pseudo_bytes(random, num);
1413         sv_setpvn(buf, (const char*)random, num);
1414         Safefree(random);
1415         RETVAL = rc;
1416     OUTPUT:
1417         RETVAL
1418
1419 void
1420 RAND_add(buf, num, entropy)
1421     SV *buf
1422     int num
1423     double entropy
1424     PREINIT:
1425         STRLEN len;
1426     CODE:
1427         RAND_add((const void *)SvPV(buf, len), num, entropy);
1428
1429 int
1430 RAND_poll()
1431
1432 int
1433 RAND_status()
1434
1435 int
1436 RAND_egd_bytes(path, bytes)
1437     const char *path
1438     int bytes
1439
1440 SV *
1441 RAND_file_name(num)
1442     size_t num
1443     PREINIT:
1444         char *buf;
1445     CODE:
1446         New(0, buf, num, char);
1447         if (!RAND_file_name(buf, num)) {
1448             Safefree(buf);
1449             XSRETURN_UNDEF;
1450         }
1451         RETVAL = newSVpv(buf, 0);
1452         Safefree(buf);
1453     OUTPUT:
1454         RETVAL
1455
1456 void
1457 RAND_seed(buf)
1458      PREINIT:
1459      STRLEN len;
1460      INPUT:
1461      char *  buf = SvPV( ST(1), len);
1462      CODE:
1463      RAND_seed (buf, (int)len);
1464
1465 void
1466 RAND_cleanup()
1467
1468 int
1469 RAND_load_file(file_name, how_much)
1470      char *  file_name
1471      int     how_much
1472
1473 int
1474 RAND_write_file(file_name)
1475      char *  file_name
1476
1477 int
1478 RAND_egd(path)
1479      char *  path
1480
1481 #define REM40 "Minimal X509 stuff..., this is a bit ugly and should be put in its own modules Net::SSLeay::X509.pm"
1482
1483 X509_NAME*
1484 X509_get_issuer_name(cert)
1485      X509 *      cert
1486
1487 X509_NAME*
1488 X509_get_subject_name(cert)
1489      X509 *      cert
1490
1491 void
1492 X509_NAME_oneline(name)
1493         X509_NAME *    name
1494         PREINIT:
1495         char * buf;
1496         CODE:
1497         ST(0) = sv_newmortal();   /* Undefined to start with */
1498         if (buf = X509_NAME_oneline(name, NULL, 0))
1499                 sv_setpvn( ST(0), buf, strlen(buf));
1500         OPENSSL_free(buf); /* mem was allocated by openssl */
1501
1502 # WTF is the point of this function?
1503 # The NID_* constants aren't bound anyway and no one can remember
1504 # those undocumented numbers anyway.
1505 void
1506 X509_NAME_get_text_by_NID(name,nid)
1507         X509_NAME *    name
1508         int nid
1509         PREINIT:
1510         char* buf;
1511         int length;
1512         CODE:
1513         ST(0) = sv_newmortal();   /* Undefined to start with */
1514         length = X509_NAME_get_text_by_NID(name, nid, NULL, 0);
1515
1516         New(0, buf, length+1, char);
1517         if (X509_NAME_get_text_by_NID(name, nid, buf, length + 1))
1518                 sv_setpvn( ST(0), buf, length + 1);
1519         Safefree(buf);
1520
1521 X509 *
1522 X509_STORE_CTX_get_current_cert(x509_store_ctx)
1523      X509_STORE_CTX *   x509_store_ctx
1524
1525 void *
1526 X509_STORE_CTX_get_ex_data(x509_store_ctx,idx)
1527      X509_STORE_CTX * x509_store_ctx
1528      int idx
1529
1530 void
1531 X509_get_subjectAltNames(cert)
1532         X509 *      cert
1533         PPCODE:
1534         int                    i, j, count = 0;
1535         X509_EXTENSION         *subjAltNameExt = NULL;
1536         STACK_OF(GENERAL_NAME) *subjAltNameDNs = NULL;
1537         GENERAL_NAME           *subjAltNameDN  = NULL;
1538         int                    num_gnames;
1539         if (  (i = X509_get_ext_by_NID(cert, NID_subject_alt_name, -1)) >= 0
1540                 && (subjAltNameExt = X509_get_ext(cert, i))
1541                 && (subjAltNameDNs = X509V3_EXT_d2i(subjAltNameExt)))
1542         {
1543                 num_gnames = sk_GENERAL_NAME_num(subjAltNameDNs);
1544
1545                 for (j = 0; j < num_gnames; j++)
1546                 {
1547                      subjAltNameDN = sk_GENERAL_NAME_value(subjAltNameDNs, j);
1548
1549                      switch (subjAltNameDN->type)
1550                      {
1551                      case GEN_OTHERNAME:
1552                          EXTEND(SP, 2);
1553                          count++;
1554                          PUSHs(sv_2mortal(newSViv(subjAltNameDN->type)));
1555                          PUSHs(sv_2mortal(newSVpv((const char*)ASN1_STRING_data(subjAltNameDN->d.otherName->value->value.utf8string), ASN1_STRING_length(subjAltNameDN->d.otherName->value->value.utf8string))));
1556                          break;
1557
1558                      case GEN_EMAIL:
1559                      case GEN_DNS:
1560                      case GEN_URI:
1561                          EXTEND(SP, 2);
1562                          count++;
1563                          PUSHs(sv_2mortal(newSViv(subjAltNameDN->type)));
1564                          PUSHs(sv_2mortal(newSVpv((const char*)ASN1_STRING_data(subjAltNameDN->d.ia5), ASN1_STRING_length(subjAltNameDN->d.ia5))));
1565                          break;
1566
1567                      case GEN_DIRNAME:
1568                          {
1569                          char * buf = X509_NAME_oneline(subjAltNameDN->d.dirn, NULL, 0);
1570                          EXTEND(SP, 2);
1571                          count++;
1572                          PUSHs(sv_2mortal(newSViv(subjAltNameDN->type)));
1573                          PUSHs(sv_2mortal(newSVpv((buf), strlen((buf)))));
1574                          break;
1575                          }
1576
1577                      case GEN_IPADD:
1578                          EXTEND(SP, 2);
1579                          count++;
1580                          PUSHs(sv_2mortal(newSViv(subjAltNameDN->type)));
1581                          PUSHs(sv_2mortal(newSVpv((const char*)subjAltNameDN->d.ip->data, subjAltNameDN->d.ip->length)));
1582                          break;
1583
1584                      }
1585                 }
1586         }
1587         XSRETURN(count * 2);
1588
1589 int
1590 X509_get_ext_by_NID(x,nid,loc)
1591         X509* x
1592         int nid
1593         int loc
1594
1595 X509_EXTENSION *
1596 X509_get_ext(x,loc)
1597         X509* x
1598         int loc
1599
1600 void *
1601 X509V3_EXT_d2i(ext)
1602         X509_EXTENSION *ext
1603
1604 int
1605 X509_STORE_CTX_get_error(x509_store_ctx)
1606      X509_STORE_CTX *   x509_store_ctx
1607
1608 int
1609 X509_STORE_CTX_get_error_depth(x509_store_ctx)
1610      X509_STORE_CTX *   x509_store_ctx
1611
1612 int
1613 X509_STORE_CTX_set_ex_data(x509_store_ctx,idx,data)
1614      X509_STORE_CTX *   x509_store_ctx
1615      int idx
1616      void * data
1617
1618 void
1619 X509_STORE_CTX_set_error(x509_store_ctx,s)
1620      X509_STORE_CTX * x509_store_ctx
1621      int s
1622
1623 void
1624 X509_STORE_CTX_set_cert(x509_store_ctx,x)
1625      X509_STORE_CTX * x509_store_ctx
1626      X509 * x
1627
1628 int
1629 X509_STORE_add_cert(ctx, x)
1630     X509_STORE *ctx
1631     X509 *x
1632
1633 int
1634 X509_STORE_add_crl(ctx, x)
1635     X509_STORE *ctx
1636     X509_CRL *x
1637
1638 void
1639 X509_STORE_CTX_set_flags(ctx, flags)
1640     X509_STORE_CTX *ctx
1641     long flags
1642
1643 #if OPENSSL_VERSION_NUMBER >= 0x0090800fL
1644
1645 void
1646 X509_STORE_set_flags(ctx, flags)
1647     X509_STORE *ctx
1648     long flags
1649
1650 void
1651 X509_STORE_set_purpose(ctx, purpose)
1652     X509_STORE *ctx
1653     int purpose
1654
1655 void
1656 X509_STORE_set_trust(ctx, trust)
1657     X509_STORE *ctx
1658     int trust
1659
1660 #endif
1661
1662 int
1663 X509_load_cert_file(ctx, file, type)
1664     X509_LOOKUP *ctx
1665     char *file
1666     int type
1667
1668 int
1669 X509_load_crl_file(ctx, file, type)
1670     X509_LOOKUP *ctx
1671     char *file
1672     int type
1673
1674 int
1675 X509_load_cert_crl_file(ctx, file, type)
1676     X509_LOOKUP *ctx
1677     char *file
1678     int type
1679
1680 const char *
1681 X509_verify_cert_error_string(n)
1682     long n
1683
1684
1685 ASN1_UTCTIME *
1686 X509_get_notBefore(cert)
1687      X509 *     cert
1688
1689 ASN1_UTCTIME *
1690 X509_get_notAfter(cert)
1691      X509 *     cert
1692
1693 void
1694 P_ASN1_UTCTIME_put2string(tm)
1695      ASN1_UTCTIME *     tm
1696      PREINIT:
1697      BIO *bp;
1698      int i;
1699      char buffer[256];
1700      CODE:
1701      bp = BIO_new(BIO_s_mem());
1702      ASN1_UTCTIME_print(bp,tm);
1703      i = BIO_read(bp,buffer,255);
1704      buffer[i] = '\0';
1705      ST(0) = sv_newmortal();   /* Undefined to start with */
1706      if ( i > 0 )
1707          sv_setpvn( ST(0), buffer, i );
1708      BIO_free(bp);
1709
1710 int
1711 EVP_PKEY_copy_parameters(to,from)
1712      EVP_PKEY *         to
1713      EVP_PKEY *         from
1714
1715 void
1716 PEM_get_string_X509(x509)
1717      X509 *     x509
1718      PREINIT:
1719      BIO *bp;
1720      int i;
1721      char buffer[8196];
1722      CODE:
1723      bp = BIO_new(BIO_s_mem());
1724      PEM_write_bio_X509(bp,x509);
1725      i = BIO_read(bp,buffer,8195);
1726      buffer[i] = '\0';
1727      ST(0) = sv_newmortal();   /* Undefined to start with */
1728      if ( i > 0 )
1729          sv_setpvn( ST(0), buffer, i );
1730      BIO_free(bp);
1731
1732 void
1733 MD2(data)
1734         PREINIT:
1735         STRLEN len;
1736         unsigned char md[MD2_DIGEST_LENGTH];
1737         unsigned char * ret;
1738         INPUT:
1739         unsigned char* data = (unsigned char *) SvPV( ST(0), len);
1740         CODE:
1741         ret = MD2(data,len,md);
1742         if (ret!=NULL) {
1743                 XSRETURN_PVN((char *) md, MD2_DIGEST_LENGTH);
1744         } else {
1745                 XSRETURN_UNDEF;
1746         }
1747
1748 void
1749 MD4(data)
1750         PREINIT:
1751         STRLEN len;
1752         unsigned char md[MD4_DIGEST_LENGTH];
1753         unsigned char * ret;
1754         INPUT:
1755         unsigned char* data = (unsigned char *) SvPV( ST(0), len );
1756         CODE:
1757         ret = MD4(data,len,md);
1758         if (ret!=NULL) {
1759                 XSRETURN_PVN((char *) md, MD4_DIGEST_LENGTH);
1760         } else {
1761                 XSRETURN_UNDEF;
1762         }
1763
1764 void
1765 MD5(data)
1766      PREINIT:
1767      STRLEN len;
1768      unsigned char md[MD5_DIGEST_LENGTH];
1769      unsigned char * ret;
1770      INPUT:
1771      unsigned char *  data = (unsigned char *) SvPV( ST(0), len);
1772      CODE:
1773      ret = MD5(data,len,md);
1774      if (ret!=NULL) {
1775           XSRETURN_PVN((char *) md, MD5_DIGEST_LENGTH);
1776      } else {
1777           XSRETURN_UNDEF;
1778      }
1779
1780 SSL_METHOD *
1781 SSLv2_method()
1782
1783 SSL_METHOD *
1784 SSLv3_method()
1785
1786 SSL_METHOD *
1787 TLSv1_method()
1788
1789 int
1790 SSL_set_ssl_method(ssl, method)
1791      SSL *          ssl
1792      SSL_METHOD *   method
1793
1794 SSL_METHOD *
1795 SSL_get_ssl_method(ssl)
1796      SSL *          ssl
1797
1798 #define REM_AUTOMATICALLY_GENERATED_1_09
1799
1800 BIO *
1801 BIO_new_buffer_ssl_connect(ctx)
1802      SSL_CTX *  ctx
1803
1804 BIO *
1805 BIO_new_file(filename,mode)
1806      char * filename
1807      char * mode
1808
1809 BIO *
1810 BIO_new_ssl(ctx,client)
1811      SSL_CTX *  ctx
1812      int        client
1813
1814 BIO *
1815 BIO_new_ssl_connect(ctx)
1816      SSL_CTX *  ctx
1817
1818 BIO *
1819 BIO_new(type)
1820      BIO_METHOD * type;
1821
1822 int
1823 BIO_free(bio)
1824      BIO * bio;
1825
1826 void
1827 BIO_read(s,max=32768)
1828         BIO *   s
1829         int max
1830         PREINIT:
1831         char *buf = NULL;
1832         int got;
1833         CODE:
1834         New(0, buf, max, char);
1835         ST(0) = sv_newmortal();   /* Undefined to start with */
1836         if ((got = BIO_read(s, buf, max)) >= 0)
1837                 sv_setpvn( ST(0), buf, got);
1838         Safefree(buf);
1839
1840 int
1841 BIO_write(s,buf)
1842      BIO *   s
1843      PREINIT:
1844      STRLEN len;
1845      INPUT:
1846      char *  buf = SvPV( ST(1), len);
1847      CODE:
1848      RETVAL = BIO_write (s, buf, (int)len);
1849      OUTPUT:
1850      RETVAL
1851
1852 int
1853 BIO_eof(s)
1854      BIO *   s
1855
1856 int
1857 BIO_pending(s)
1858      BIO *   s
1859
1860 int
1861 BIO_wpending(s)
1862      BIO *   s
1863
1864 int
1865 BIO_ssl_copy_session_id(to,from)
1866      BIO *      to
1867      BIO *      from
1868
1869 void
1870 BIO_ssl_shutdown(ssl_bio)
1871      BIO *      ssl_bio
1872
1873 int
1874 SSL_add_client_CA(ssl,x)
1875      SSL *      ssl
1876      X509 *     x
1877
1878 const char *
1879 SSL_alert_desc_string(value)
1880      int        value
1881
1882 const char *
1883 SSL_alert_desc_string_long(value)
1884      int        value
1885
1886 const char *
1887 SSL_alert_type_string(value)
1888      int        value
1889
1890 const char *
1891 SSL_alert_type_string_long(value)
1892      int        value
1893
1894 long
1895 SSL_callback_ctrl(ssl,i,fp)
1896      SSL *  ssl
1897      int    i
1898      callback_no_ret * fp
1899
1900 int
1901 SSL_check_private_key(ctx)
1902      SSL *      ctx
1903
1904 char *
1905 SSL_CIPHER_description(cipher,buf,size)
1906      SSL_CIPHER *  cipher
1907      char *     buf
1908      int        size
1909
1910 int
1911 SSL_CIPHER_get_bits(c,alg_bits)
1912      SSL_CIPHER *       c
1913      int *      alg_bits
1914
1915 int
1916 SSL_COMP_add_compression_method(id,cm)
1917      int        id
1918      COMP_METHOD *      cm
1919
1920 int
1921 SSL_CTX_add_client_CA(ctx,x)
1922      SSL_CTX *  ctx
1923      X509 *     x
1924
1925 long
1926 SSL_CTX_callback_ctrl(ctx,i,fp)
1927      SSL_CTX *  ctx
1928      int        i
1929      callback_no_ret * fp
1930
1931 int
1932 SSL_CTX_check_private_key(ctx)
1933      SSL_CTX *  ctx
1934
1935 void *
1936 SSL_CTX_get_ex_data(ssl,idx)
1937      SSL_CTX *  ssl
1938      int        idx
1939
1940 int
1941 SSL_CTX_get_quiet_shutdown(ctx)
1942      SSL_CTX *  ctx
1943
1944 long
1945 SSL_CTX_get_timeout(ctx)
1946      SSL_CTX *  ctx
1947
1948 int
1949 SSL_CTX_get_verify_depth(ctx)
1950      SSL_CTX *  ctx
1951
1952 int
1953 SSL_CTX_get_verify_mode(ctx)
1954      SSL_CTX *  ctx
1955
1956 void
1957 SSL_CTX_set_cert_store(ctx,store)
1958      SSL_CTX *     ctx
1959      X509_STORE *  store
1960
1961 X509_STORE *
1962 SSL_CTX_get_cert_store(ctx)
1963      SSL_CTX *     ctx
1964
1965 void
1966 SSL_CTX_set_cert_verify_callback(ctx,func,data=NULL)
1967         SSL_CTX* ctx
1968         SV* func
1969         SV*     data
1970         PREINIT:
1971         ssleay_ctx_cert_verify_cb_t* cb;
1972         CODE:
1973         if (func == NULL || func == &PL_sv_undef) {
1974                 ssleay_ctx_cert_verify_cb_free(ctx);
1975                 SSL_CTX_set_cert_verify_callback(ctx, NULL, NULL);
1976         } else {
1977                 cb = ssleay_ctx_cert_verify_cb_new(ctx, func, data);
1978                 SSL_CTX_set_cert_verify_callback(ctx, ssleay_ctx_cert_verify_cb_invoke, cb);
1979         }
1980
1981 void
1982 SSL_CTX_set_client_CA_list(ctx,list)
1983      SSL_CTX *  ctx
1984      X509_NAME_STACK * list
1985
1986 void
1987 SSL_CTX_set_default_passwd_cb(ctx,func=NULL)
1988         SSL_CTX *       ctx
1989         SV * func
1990         PREINIT:
1991         ssleay_ctx_passwd_cb_t* cb;
1992         CODE:
1993         if (func == NULL || func == &PL_sv_undef) {
1994                 ssleay_ctx_passwd_cb_free_func(ctx);
1995                 SSL_CTX_set_default_passwd_cb(ctx, NULL);
1996         } else {
1997                 cb = ssleay_ctx_passwd_cb_get(ctx);
1998                 ssleay_ctx_passwd_cb_func_set(ctx, func);
1999                 SSL_CTX_set_default_passwd_cb(ctx, &ssleay_ctx_passwd_cb_invoke);
2000                 SSL_CTX_set_default_passwd_cb_userdata(ctx, (void*)cb);
2001         }
2002
2003 void
2004 SSL_CTX_set_default_passwd_cb_userdata(ctx,u=NULL)
2005         SSL_CTX *       ctx
2006         SV*     u
2007         CODE:
2008         if (u == NULL) {
2009                 ssleay_ctx_passwd_cb_free_userdata(ctx);
2010         } else {
2011                 ssleay_ctx_passwd_cb_userdata_set(ctx, u);
2012         }
2013
2014 int
2015 SSL_CTX_set_ex_data(ssl,idx,data)
2016      SSL_CTX *  ssl
2017      int        idx
2018      void *     data
2019
2020 int
2021 SSL_CTX_set_purpose(s,purpose)
2022      SSL_CTX *  s
2023      int        purpose
2024
2025 void
2026 SSL_CTX_set_quiet_shutdown(ctx,mode)
2027      SSL_CTX *  ctx
2028      int        mode
2029
2030 int
2031 SSL_CTX_set_ssl_version(ctx,meth)
2032      SSL_CTX *  ctx
2033      SSL_METHOD *       meth
2034
2035 long
2036 SSL_CTX_set_timeout(ctx,t)
2037      SSL_CTX *  ctx
2038      long       t
2039
2040 int
2041 SSL_CTX_set_trust(s,trust)
2042      SSL_CTX *  s
2043      int        trust
2044
2045 void
2046 SSL_CTX_set_verify_depth(ctx,depth)
2047      SSL_CTX *  ctx
2048      int        depth
2049
2050 int
2051 SSL_CTX_use_certificate(ctx,x)
2052      SSL_CTX *  ctx
2053      X509 *     x
2054
2055 int
2056 SSL_CTX_use_certificate_chain_file(ctx,file)
2057      SSL_CTX *  ctx
2058      const char * file
2059
2060 int
2061 SSL_CTX_use_PrivateKey(ctx,pkey)
2062      SSL_CTX *  ctx
2063      EVP_PKEY * pkey
2064
2065 int
2066 SSL_CTX_use_RSAPrivateKey(ctx,rsa)
2067      SSL_CTX *  ctx
2068      RSA *      rsa
2069
2070 int
2071 SSL_do_handshake(s)
2072      SSL *      s
2073
2074 SSL *
2075 SSL_dup(ssl)
2076      SSL *      ssl
2077
2078 SSL_CIPHER *
2079 SSL_get_current_cipher(s)
2080      SSL *      s
2081
2082 long
2083 SSL_get_default_timeout(s)
2084      SSL *      s
2085
2086 void *
2087 SSL_get_ex_data(ssl,idx)
2088      SSL *      ssl
2089      int        idx
2090
2091 size_t
2092 SSL_get_finished(s,buf,count)
2093      SSL *      s
2094      void *     buf
2095      size_t     count
2096
2097 size_t
2098 SSL_get_peer_finished(s,buf,count)
2099      SSL *      s
2100      void *     buf
2101      size_t     count
2102
2103 int
2104 SSL_get_quiet_shutdown(ssl)
2105      SSL *      ssl
2106
2107 int
2108 SSL_get_shutdown(ssl)
2109      SSL *      ssl
2110
2111 int
2112 SSL_get_verify_depth(s)
2113      SSL *      s
2114
2115 int
2116 SSL_get_verify_mode(s)
2117      SSL *      s
2118
2119 long
2120 SSL_get_verify_result(ssl)
2121      SSL *      ssl
2122
2123 int
2124 SSL_renegotiate(s)
2125      SSL *      s
2126
2127 int
2128 SSL_SESSION_cmp(a,b)
2129      SSL_SESSION *      a
2130      SSL_SESSION *      b
2131
2132 void *
2133 SSL_SESSION_get_ex_data(ss,idx)
2134      SSL_SESSION *      ss
2135      int        idx
2136
2137 long
2138 SSL_SESSION_get_time(s)
2139      SSL_SESSION *      s
2140
2141 long
2142 SSL_SESSION_get_timeout(s)
2143      SSL_SESSION *      s
2144
2145 int
2146 SSL_SESSION_print_fp(fp,ses)
2147      FILE *     fp
2148      SSL_SESSION *      ses
2149
2150 int
2151 SSL_SESSION_set_ex_data(ss,idx,data)
2152      SSL_SESSION *      ss
2153      int        idx
2154      void *     data
2155
2156 long
2157 SSL_SESSION_set_time(s,t)
2158      SSL_SESSION *      s
2159      long       t
2160
2161 long
2162 SSL_SESSION_set_timeout(s,t)
2163      SSL_SESSION *      s
2164      long       t
2165
2166 void
2167 SSL_set_accept_state(s)
2168      SSL *      s
2169
2170 void
2171 SSL_set_client_CA_list(s,list)
2172      SSL *      s
2173      X509_NAME_STACK *  list
2174
2175 void
2176 SSL_set_connect_state(s)
2177      SSL *      s
2178
2179 int
2180 SSL_set_ex_data(ssl,idx,data)
2181      SSL *      ssl
2182      int        idx
2183      void *     data
2184
2185 void
2186 SSL_set_info_callback(ssl,cb)
2187      SSL *      ssl
2188      cb_ssl_int_int_ret_void *  cb
2189
2190 int
2191 SSL_set_purpose(s,purpose)
2192      SSL *      s
2193      int        purpose
2194
2195 void
2196 SSL_set_quiet_shutdown(ssl,mode)
2197      SSL *      ssl
2198      int        mode
2199
2200 void
2201 SSL_set_shutdown(ssl,mode)
2202      SSL *      ssl
2203      int        mode
2204
2205 int
2206 SSL_set_trust(s,trust)
2207      SSL *      s
2208      int        trust
2209
2210 void
2211 SSL_set_verify_depth(s,depth)
2212      SSL *      s
2213      int        depth
2214
2215 void
2216 SSL_set_verify_result(ssl,v)
2217      SSL *      ssl
2218      long       v
2219
2220 int
2221 SSL_shutdown(s)
2222      SSL *      s
2223
2224 int
2225 SSL_version(ssl)
2226      SSL *      ssl
2227
2228 #define REM_MANUALLY_ADDED_1_09
2229
2230 X509_NAME_STACK *
2231 SSL_load_client_CA_file(file)
2232      const char * file
2233
2234 int
2235 SSL_add_file_cert_subjects_to_stack(stackCAs,file)
2236      X509_NAME_STACK * stackCAs
2237      const char * file
2238
2239 #ifndef WIN32
2240 #ifndef VMS
2241 #ifndef MAC_OS_pre_X
2242
2243 int
2244 SSL_add_dir_cert_subjects_to_stack(stackCAs,dir)
2245      X509_NAME_STACK * stackCAs
2246      const char * dir
2247
2248 #endif
2249 #endif
2250 #endif
2251
2252 int
2253 SSL_CTX_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
2254      long argl
2255      void *  argp
2256      CRYPTO_EX_new *   new_func
2257      CRYPTO_EX_dup *   dup_func
2258      CRYPTO_EX_free *  free_func
2259
2260 int
2261 SSL_CTX_set_session_id_context(ctx,sid_ctx,sid_ctx_len)
2262      SSL_CTX *   ctx
2263      const unsigned char *   sid_ctx
2264      unsigned int sid_ctx_len
2265
2266 int
2267 SSL_set_session_id_context(ssl,sid_ctx,sid_ctx_len)
2268      SSL *   ssl
2269      const unsigned char *   sid_ctx
2270      unsigned int sid_ctx_len
2271
2272 void
2273 SSL_CTX_set_tmp_rsa_callback(ctx, cb)
2274      SSL_CTX *   ctx
2275      cb_ssl_int_int_ret_RSA *   cb
2276
2277 void
2278 SSL_set_tmp_rsa_callback(ssl, cb)
2279      SSL *   ssl
2280      cb_ssl_int_int_ret_RSA *  cb
2281
2282 void
2283 SSL_CTX_set_tmp_dh_callback(ctx, dh)
2284      SSL_CTX *   ctx
2285      cb_ssl_int_int_ret_DH *  dh
2286
2287 void
2288 SSL_set_tmp_dh_callback(ssl,dh)
2289      SSL *  ssl
2290      cb_ssl_int_int_ret_DH *  dh
2291
2292 int
2293 SSL_get_ex_new_index(argl, argp, new_func, dup_func, free_func)
2294      long argl
2295      void *   argp
2296      CRYPTO_EX_new *  new_func
2297      CRYPTO_EX_dup *  dup_func
2298      CRYPTO_EX_free * free_func
2299
2300 int
2301 SSL_SESSION_get_ex_new_index(argl, argp, new_func, dup_func, free_func)
2302      long argl
2303      void *   argp
2304      CRYPTO_EX_new *  new_func
2305      CRYPTO_EX_dup *  dup_func
2306      CRYPTO_EX_free * free_func
2307
2308 #define REM_SEMIAUTOMATIC_MACRO_GEN_1_09
2309
2310 long
2311 SSL_clear_num_renegotiations(ssl)
2312   SSL *  ssl
2313   CODE:
2314   RETVAL = SSL_ctrl(ssl,SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL);
2315   OUTPUT:
2316   RETVAL
2317
2318 long
2319 SSL_CTX_add_extra_chain_cert(ctx,x509)
2320      SSL_CTX *  ctx
2321      X509 *     x509
2322   CODE:
2323   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char*)x509);
2324   OUTPUT:
2325   RETVAL
2326
2327 void *
2328 SSL_CTX_get_app_data(ctx)
2329      SSL_CTX *  ctx
2330   CODE:
2331   RETVAL = SSL_CTX_get_ex_data(ctx,0);
2332   OUTPUT:
2333   RETVAL
2334
2335 long
2336 SSL_CTX_get_mode(ctx)
2337      SSL_CTX *  ctx
2338   CODE:
2339   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_MODE,0,NULL);
2340   OUTPUT:
2341   RETVAL
2342
2343 long
2344 SSL_CTX_get_read_ahead(ctx)
2345      SSL_CTX *  ctx
2346   CODE:
2347   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL);
2348   OUTPUT:
2349   RETVAL
2350
2351 long
2352 SSL_CTX_get_session_cache_mode(ctx)
2353      SSL_CTX *  ctx
2354   CODE:
2355   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL);
2356   OUTPUT:
2357   RETVAL
2358
2359 long
2360 SSL_CTX_need_tmp_RSA(ctx)
2361      SSL_CTX *  ctx
2362   CODE:
2363   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_NEED_TMP_RSA,0,NULL);
2364   OUTPUT:
2365   RETVAL
2366
2367 int
2368 SSL_CTX_set_app_data(ctx,arg)
2369      SSL_CTX *  ctx
2370      char *     arg
2371   CODE:
2372   RETVAL = SSL_CTX_set_ex_data(ctx,0,arg);
2373   OUTPUT:
2374   RETVAL
2375
2376 long
2377 SSL_CTX_set_mode(ctx,op)
2378      SSL_CTX *  ctx
2379      long       op
2380   CODE:
2381   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_MODE,op,NULL);
2382   OUTPUT:
2383   RETVAL
2384
2385 long
2386 SSL_CTX_set_read_ahead(ctx,m)
2387      SSL_CTX *  ctx
2388      long       m
2389   CODE:
2390   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL);
2391   OUTPUT:
2392   RETVAL
2393
2394 long
2395 SSL_CTX_set_session_cache_mode(ctx,m)
2396      SSL_CTX *  ctx
2397      long       m
2398   CODE:
2399   RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL);
2400   OUTPUT:
2401   RETVAL
2402
2403 long
2404 SSL_CTX_set_tmp_dh(ctx,dh)
2405      SSL_CTX *  ctx
2406      DH *       dh
2407
2408 long
2409 SSL_CTX_set_tmp_rsa(ctx,rsa)
2410      SSL_CTX *  ctx
2411      RSA *      rsa
2412
2413 void *
2414 SSL_get_app_data(s)
2415      SSL *      s
2416   CODE:
2417   RETVAL = SSL_get_ex_data(s,0);
2418   OUTPUT:
2419   RETVAL
2420
2421 int
2422 SSL_get_cipher_bits(s,np)
2423      SSL *      s
2424      int *      np
2425   CODE:
2426   RETVAL = SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np);
2427   OUTPUT:
2428   RETVAL
2429
2430 long
2431 SSL_get_mode(ssl)
2432      SSL *      ssl
2433   CODE:
2434   RETVAL = SSL_ctrl(ssl,SSL_CTRL_MODE,0,NULL);
2435   OUTPUT:
2436   RETVAL
2437
2438 int
2439 SSL_get_state(ssl)
2440      SSL *      ssl
2441   CODE:
2442   RETVAL = SSL_state(ssl);
2443   OUTPUT:
2444   RETVAL
2445
2446 long
2447 SSL_need_tmp_RSA(ssl)
2448      SSL *      ssl
2449   CODE:
2450   RETVAL = SSL_ctrl(ssl,SSL_CTRL_NEED_TMP_RSA,0,NULL);
2451   OUTPUT:
2452   RETVAL
2453
2454 long
2455 SSL_num_renegotiations(ssl)
2456      SSL *      ssl
2457   CODE:
2458   RETVAL = SSL_ctrl(ssl,SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL);
2459   OUTPUT:
2460   RETVAL
2461
2462 void *
2463 SSL_SESSION_get_app_data(ses)
2464      SSL_SESSION *      ses
2465   CODE:
2466   RETVAL = SSL_SESSION_get_ex_data(ses,0);
2467   OUTPUT:
2468   RETVAL
2469
2470 long
2471 SSL_session_reused(ssl)
2472      SSL *      ssl
2473   CODE:
2474   RETVAL = SSL_ctrl(ssl,SSL_CTRL_GET_SESSION_REUSED,0,NULL);
2475   OUTPUT:
2476   RETVAL
2477
2478 int
2479 SSL_SESSION_set_app_data(s,a)
2480      SSL_SESSION *      s
2481      void *     a
2482   CODE:
2483   RETVAL = SSL_SESSION_set_ex_data(s,0,(char *)a);
2484   OUTPUT:
2485   RETVAL
2486
2487 int
2488 SSL_set_app_data(s,arg)
2489      SSL *      s
2490      void *     arg
2491   CODE:
2492   RETVAL = SSL_set_ex_data(s,0,(char *)arg);
2493   OUTPUT:
2494   RETVAL
2495
2496 long
2497 SSL_set_mode(ssl,op)
2498      SSL *      ssl
2499      long       op
2500   CODE:
2501   RETVAL = SSL_ctrl(ssl,SSL_CTRL_MODE,op,NULL);
2502   OUTPUT:
2503   RETVAL
2504
2505 int
2506 SSL_set_pref_cipher(s,n)
2507      SSL *      s
2508      const char * n
2509   CODE:
2510   RETVAL = SSL_set_cipher_list(s,n);
2511   OUTPUT:
2512   RETVAL
2513
2514 long
2515 SSL_set_tmp_dh(ssl,dh)
2516      SSL *      ssl
2517      DH *       dh
2518
2519 long
2520 SSL_set_tmp_rsa(ssl,rsa)
2521      SSL *      ssl
2522      char *     rsa
2523   CODE:
2524   RETVAL = SSL_ctrl(ssl,SSL_CTRL_SET_TMP_RSA,0,(char *)rsa);
2525   OUTPUT:
2526   RETVAL
2527
2528 RSA *
2529 RSA_generate_key(bits,e,perl_cb=NULL,perl_cb_arg=NULL)
2530                 int bits
2531                 unsigned long e
2532                 SV* perl_cb
2533                 SV* perl_cb_arg
2534         PREINIT:
2535                 ssleay_RSA_generate_key_cb_t* cb = NULL;
2536         CODE:
2537                 cb = ssleay_RSA_generate_key_cb_new(perl_cb, perl_cb_arg);
2538                 RETVAL = RSA_generate_key(bits, e, ssleay_RSA_generate_key_cb_invoke, cb);
2539                 ssleay_RSA_generate_key_cb_free(cb);
2540         OUTPUT:
2541                 RETVAL
2542
2543 void
2544 RSA_free(r)
2545     RSA * r
2546
2547 void
2548 X509_free(a)
2549     X509 * a
2550
2551 DH *
2552 PEM_read_bio_DHparams(bio,x=NULL,cb=NULL,u=NULL)
2553         BIO  * bio
2554         void * x
2555         pem_password_cb * cb
2556         void * u
2557
2558 X509_CRL *
2559 PEM_read_bio_X509_CRL(bio,x=NULL,cb=NULL,u=NULL)
2560         BIO  * bio
2561         void * x
2562         pem_password_cb * cb
2563         void * u
2564
2565 void
2566 DH_free(dh)
2567         DH * dh
2568
2569 long
2570 SSL_total_renegotiations(ssl)
2571      SSL *      ssl
2572   CODE:
2573   RETVAL = SSL_ctrl(ssl,SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL);
2574   OUTPUT:
2575   RETVAL
2576
2577 void
2578 SSL_SESSION_get_master_key(s)
2579      SSL_SESSION *   s
2580      CODE:
2581      ST(0) = sv_newmortal();   /* Undefined to start with */
2582      sv_setpvn(ST(0), (const char*)s->master_key, s->master_key_length);
2583
2584 void
2585 SSL_SESSION_set_master_key(s,key)
2586      SSL_SESSION *   s
2587      PREINIT:
2588      STRLEN len;
2589      INPUT:
2590      char * key = SvPV(ST(1), len);
2591      CODE:
2592      memcpy(s->master_key, key, len);
2593      s->master_key_length = len;
2594
2595 void
2596 SSL_get_client_random(s)
2597      SSL *   s
2598      CODE:
2599      ST(0) = sv_newmortal();   /* Undefined to start with */
2600      sv_setpvn(ST(0), (const char*)s->s3->client_random, SSL3_RANDOM_SIZE);
2601
2602 void
2603 SSL_get_server_random(s)
2604      SSL *   s
2605      CODE:
2606      ST(0) = sv_newmortal();   /* Undefined to start with */
2607      sv_setpvn(ST(0), (const char*)s->s3->server_random, SSL3_RANDOM_SIZE);
2608
2609 int
2610 SSL_get_keyblock_size(s)
2611      SSL *   s
2612      CODE:
2613      if (s == NULL ||
2614          s->enc_read_ctx == NULL ||
2615          s->enc_read_ctx->cipher == NULL ||
2616          s->read_hash == NULL)
2617      {
2618         RETVAL = -1;
2619      }
2620      else
2621      {
2622         const EVP_CIPHER *c;
2623         const EVP_MD *h;
2624         c = s->enc_read_ctx->cipher;
2625 #if OPENSSL_VERSION_NUMBER >= 0x00909000L
2626         h = EVP_MD_CTX_md(s->read_hash);
2627 #else
2628         h = s->read_hash;
2629 #endif
2630
2631         RETVAL = 2 * (EVP_CIPHER_key_length(c) +
2632                     EVP_MD_size(h) +
2633                     EVP_CIPHER_iv_length(c));
2634      }
2635      OUTPUT:
2636      RETVAL
2637
2638
2639
2640 #ifdef SSL_F_SSL_SET_HELLO_EXTENSION
2641 int
2642 SSL_set_hello_extension(s, type, data)
2643      SSL *   s
2644      int     type
2645      PREINIT:
2646      STRLEN len;
2647      INPUT:
2648      char *  data = SvPV( ST(2), len);
2649      CODE:
2650      RETVAL = SSL_set_hello_extension(s, type, data, len);
2651      OUTPUT:
2652      RETVAL
2653
2654 void
2655 SSL_set_session_secret_cb(s,func,data=NULL)
2656         SSL * s
2657         SV* func
2658         SV*     data
2659         PREINIT:
2660         ssleay_session_secret_cb_t* cb;
2661         CODE:
2662         if (func == NULL || func == &PL_sv_undef) {
2663                 ssleay_session_secret_cb_free(s);
2664                 SSL_set_session_secret_cb(s, NULL, NULL);
2665         } else {
2666                 cb = ssleay_session_secret_cb_new(s, func, data);
2667                 SSL_set_session_secret_cb(s, (int (*)(SSL *s, void *secret, int *secret_len,
2668                            STACK_OF(SSL_CIPHER) *peer_ciphers,
2669                            SSL_CIPHER **cipher, void *arg))&ssleay_session_secret_cb_invoke, cb);
2670         }
2671
2672 #endif
2673
2674 #define REM_EOF "/* EOF - SSLeay.xs */"