/*
 * This file was generated automatically by xsubpp version 1.9508 from the
 * contents of SSLeay.xs. Do not edit this file, edit SSLeay.xs instead.
 *
 *	ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "SSLeay.xs"
/* SSLeay.xs - Perl module for using Eric Young's implementation of SSL
 *
 * Copyright (c) 1996-2002 Sampo Kellomaki <sampo@iki.fi>
 * All Rights Reserved.
 *
 * 19.6.1998, Maintenance release to sync with SSLeay-0.9.0, --Sampo
 * 24.6.1998, added write_partial to support ssl_write_all in more
 *            memory efficient way. --Sampo
 * 8.7.1998,  Added SSL_(CTX)?_set_options and associated constants.
 * 31.3.1999, Tracking OpenSSL-0.9.2b changes, dropping support for
 *            earlier versions
 * 30.7.1999, Tracking OpenSSL-0.9.3a changes, --Sampo
 * 7.4.2001,  OpenSSL-0.9.6a update, --Sampo
 * 18.4.2001, added TLSv1 support by Stephen C. Koehler
 *            <koehler@securecomputing.com>, version 1.07, --Sampo
 * 25.4.2001, applied 64 bit fixes by Marko Asplund <aspa@kronodoc.fi> --Sampo
 * 16.7.2001, applied Win filehandle patch from aspa, added
 *            SSL_*_methods --Sampo
 * 25.9.2001, added a big pile of methods by automatically grepping and diffing
 *            openssl headers and my module --Sampo
 * 17.4.2002, applied patch to fix CTX_set_default_passwd_cb() contributed
 *            by Timo Kujala <timo.kujala@@intellitel_.com>, --Sampo
 * 17.5.2002, Added BIO_s_mem, BIO_new, BIO_free, BIO_write, BIO_read ,
 *            BIO_eof, BIO_pending, BIO_wpending, X509_NAME_get_text_by_NID,
 *            RSA_generate_key, BIO_new_file
 *            Fixed problem with return value from verify callback being
 *            ignored.
 *            Fixed a problem with CTX_set_tmp_rsa and CTX_set_tmp_dh
 *            args incorrect
 *            --mikem@open.com_.au
 * 10.8.2002, Added SSL_peek patch to ssl_read_until from 
 *            Peter Behroozi <peter@@fhpwireless_.com> --Sampo
 * 21.8.2002, Added SESSION_get_master_key, SSL_get_client_random, SSL_get_server_random
 *            --mikem@open.com_.au
 * 2.9.2002,  Added SSL_CTX_get_cert_store, X509_STORE_add_cert, X509_STORE_add_crl
 *            X509_STORE_set_flags, X509_load_cert_file, X509_load_crl_file
 *            X509_load_cert_crl_file, PEM_read_bio_X509_CRL
 *            constants for X509_V_FLAG_*
 *            --mikem@open.com_.au
 * 6.9.2002,  applied Mike's patch and fixed X509_STORE_* to X509_STORE_CTX_*
 *	      --Sampo
 *
 * $Id: SSLeay.xs,v 1.12 2002/11/05 05:39:02 sampo Exp $
 * 
 * The distribution and use of this module are subject to the conditions
 * listed in LICENSE file at the root of OpenSSL-0.9.6b
 * distribution (i.e. free, but mandatory attribution and NO WARRANTY).

Removed, perhaps permanently?

int
SSL_add_session(ctx,ses)
     SSL_CTX *          ctx
     SSL_SESSION *      ses

int
SSL_remove_session(ctx,ses)
     SSL_CTX *          ctx
     SSL_SESSION *      ses

void
SSL_flush_sessions(ctx,tm)
     SSL_CTX *          ctx
     long               tm

 */

#ifdef __cplusplus
extern "C" {
#endif
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#ifdef __cplusplus
}
#endif

/* OpenSSL-0.9.3a has some strange warning about this in
 *    openssl/des.h
 */
#undef _

#include <openssl/err.h>
#include <openssl/lhash.h>
#include <openssl/rand.h>
#include <openssl/buffer.h>
#include <openssl/ssl.h>
#include <openssl/comp.h>    /* openssl-0.9.6a forgets to include this */
#include <openssl/md5.h>     /* openssl-SNAP-20020227 does not automatically include this */
/* Debugging output */

#if 0
#define PR(s) printf(s);
#define PRN(s,n) printf("'%s' (%d)\n",s,n);
#define SEX_DEBUG 1
#else
#define PR(s)
#define PRN(s,n)
#undef  SEX_DEBUG
#endif

static int
not_here(s)
char *s;
{
    croak("%s not implemented on this architecture", s);
    return -1;
}

/* xsub automagically generated constant evaluator function */

static double
constant(char* name)
{
    errno = 0;
    switch (*name) {
    case 'A':
	if (strEQ(name, "AT_MD5_WITH_RSA_ENCRYPTION"))
#ifdef SSL_AT_MD5_WITH_RSA_ENCRYPTION
	    return SSL_AT_MD5_WITH_RSA_ENCRYPTION;
#else
	    goto not_there;
#endif
	break;
    case 'B':
	break;
    case 'C':
	if (strEQ(name, "CB_ACCEPT_EXIT"))
#ifdef SSL_CB_ACCEPT_EXIT
	    return SSL_CB_ACCEPT_EXIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CB_ACCEPT_LOOP"))
#ifdef SSL_CB_ACCEPT_LOOP
	    return SSL_CB_ACCEPT_LOOP;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CB_CONNECT_EXIT"))
#ifdef SSL_CB_CONNECT_EXIT
	    return SSL_CB_CONNECT_EXIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CB_CONNECT_LOOP"))
#ifdef SSL_CB_CONNECT_LOOP
	    return SSL_CB_CONNECT_LOOP;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_DES_192_EDE3_CBC_WITH_MD5"))
#ifdef SSL_CK_DES_192_EDE3_CBC_WITH_MD5
	    return SSL_CK_DES_192_EDE3_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_DES_192_EDE3_CBC_WITH_SHA"))
#ifdef SSL_CK_DES_192_EDE3_CBC_WITH_SHA
	    return SSL_CK_DES_192_EDE3_CBC_WITH_SHA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_DES_64_CBC_WITH_MD5"))
#ifdef SSL_CK_DES_64_CBC_WITH_MD5
	    return SSL_CK_DES_64_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_DES_64_CBC_WITH_SHA"))
#ifdef SSL_CK_DES_64_CBC_WITH_SHA
	    return SSL_CK_DES_64_CBC_WITH_SHA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_DES_64_CFB64_WITH_MD5_1"))
#ifdef SSL_CK_DES_64_CFB64_WITH_MD5_1
	    return SSL_CK_DES_64_CFB64_WITH_MD5_1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_IDEA_128_CBC_WITH_MD5"))
#ifdef SSL_CK_IDEA_128_CBC_WITH_MD5
	    return SSL_CK_IDEA_128_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_NULL"))
#ifdef SSL_CK_NULL
	    return SSL_CK_NULL;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_NULL_WITH_MD5"))
#ifdef SSL_CK_NULL_WITH_MD5
	    return SSL_CK_NULL_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_RC2_128_CBC_EXPORT40_WITH_MD5"))
#ifdef SSL_CK_RC2_128_CBC_EXPORT40_WITH_MD5
	    return SSL_CK_RC2_128_CBC_EXPORT40_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_RC2_128_CBC_WITH_MD5"))
#ifdef SSL_CK_RC2_128_CBC_WITH_MD5
	    return SSL_CK_RC2_128_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_RC4_128_EXPORT40_WITH_MD5"))
#ifdef SSL_CK_RC4_128_EXPORT40_WITH_MD5
	    return SSL_CK_RC4_128_EXPORT40_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CK_RC4_128_WITH_MD5"))
#ifdef SSL_CK_RC4_128_WITH_MD5
	    return SSL_CK_RC4_128_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CLIENT_VERSION"))
#ifdef SSL_CLIENT_VERSION
	    return SSL_CLIENT_VERSION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "CT_X509_CERTIFICATE"))
#ifdef SSL_CT_X509_CERTIFICATE
	    return SSL_CT_X509_CERTIFICATE;
#else
	    goto not_there;
#endif
	break;
    case 'D':
	break;
    case 'E':
      if (strEQ(name, "ERROR_NONE"))
#ifdef SSL_ERROR_NONE
      return SSL_ERROR_NONE;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_SSL"))
#ifdef SSL_ERROR_SSL
      return SSL_ERROR_SSL;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_SYSCALL"))
#ifdef SSL_ERROR_SYSCALL
      return SSL_ERROR_SYSCALL;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_WANT_CONNECT"))
#ifdef SSL_ERROR_WANT_CONNECT
      return SSL_ERROR_WANT_CONNECT;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_WANT_READ"))
#ifdef SSL_ERROR_WANT_READ
      return SSL_ERROR_WANT_READ;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_WANT_WRITE"))
#ifdef SSL_ERROR_WANT_WRITE
      return SSL_ERROR_WANT_WRITE;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_WANT_X509_LOOKUP"))
#ifdef SSL_ERROR_WANT_X509_LOOKUP
      return SSL_ERROR_WANT_X509_LOOKUP;
#else
      goto not_there;
#endif
      if (strEQ(name, "ERROR_ZERO_RETURN"))
#ifdef SSL_ERROR_ZERO_RETURN
      return SSL_ERROR_ZERO_RETURN;
#else
      goto not_there;
#endif
      break;
    case 'F':
	if (strEQ(name, "FILETYPE_ASN1"))
#ifdef SSL_FILETYPE_ASN1
	    return SSL_FILETYPE_ASN1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "FILETYPE_PEM"))
#ifdef SSL_FILETYPE_PEM
	    return SSL_FILETYPE_PEM;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_CLIENT_CERTIFICATE"))
#ifdef SSL_F_CLIENT_CERTIFICATE
	    return SSL_F_CLIENT_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_CLIENT_HELLO"))
#ifdef SSL_F_CLIENT_HELLO
	    return SSL_F_CLIENT_HELLO;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_CLIENT_MASTER_KEY"))
#ifdef SSL_F_CLIENT_MASTER_KEY
	    return SSL_F_CLIENT_MASTER_KEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_D2I_SSL_SESSION"))
#ifdef SSL_F_D2I_SSL_SESSION
	    return SSL_F_D2I_SSL_SESSION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_GET_CLIENT_FINISHED"))
#ifdef SSL_F_GET_CLIENT_FINISHED
	    return SSL_F_GET_CLIENT_FINISHED;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_GET_CLIENT_HELLO"))
#ifdef SSL_F_GET_CLIENT_HELLO
	    return SSL_F_GET_CLIENT_HELLO;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_GET_CLIENT_MASTER_KEY"))
#ifdef SSL_F_GET_CLIENT_MASTER_KEY
	    return SSL_F_GET_CLIENT_MASTER_KEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_GET_SERVER_FINISHED"))
#ifdef SSL_F_GET_SERVER_FINISHED
	    return SSL_F_GET_SERVER_FINISHED;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_GET_SERVER_HELLO"))
#ifdef SSL_F_GET_SERVER_HELLO
	    return SSL_F_GET_SERVER_HELLO;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_GET_SERVER_VERIFY"))
#ifdef SSL_F_GET_SERVER_VERIFY
	    return SSL_F_GET_SERVER_VERIFY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_I2D_SSL_SESSION"))
#ifdef SSL_F_I2D_SSL_SESSION
	    return SSL_F_I2D_SSL_SESSION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_READ_N"))
#ifdef SSL_F_READ_N
	    return SSL_F_READ_N;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_REQUEST_CERTIFICATE"))
#ifdef SSL_F_REQUEST_CERTIFICATE
	    return SSL_F_REQUEST_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SERVER_HELLO"))
#ifdef SSL_F_SERVER_HELLO
	    return SSL_F_SERVER_HELLO;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ACCEPT"))
#ifdef SSL_F_SSL_ACCEPT
	    return SSL_F_SSL_ACCEPT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_CERT_NEW"))
#ifdef SSL_F_SSL_CERT_NEW
	    return SSL_F_SSL_CERT_NEW;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_CONNECT"))
#ifdef SSL_F_SSL_CONNECT
	    return SSL_F_SSL_CONNECT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_DES_CBC_INIT"))
#ifdef SSL_F_SSL_ENC_DES_CBC_INIT
	    return SSL_F_SSL_ENC_DES_CBC_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_DES_CFB_INIT"))
#ifdef SSL_F_SSL_ENC_DES_CFB_INIT
	    return SSL_F_SSL_ENC_DES_CFB_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_DES_EDE3_CBC_INIT"))
#ifdef SSL_F_SSL_ENC_DES_EDE3_CBC_INIT
	    return SSL_F_SSL_ENC_DES_EDE3_CBC_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_IDEA_CBC_INIT"))
#ifdef SSL_F_SSL_ENC_IDEA_CBC_INIT
	    return SSL_F_SSL_ENC_IDEA_CBC_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_NULL_INIT"))
#ifdef SSL_F_SSL_ENC_NULL_INIT
	    return SSL_F_SSL_ENC_NULL_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_RC2_CBC_INIT"))
#ifdef SSL_F_SSL_ENC_RC2_CBC_INIT
	    return SSL_F_SSL_ENC_RC2_CBC_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_ENC_RC4_INIT"))
#ifdef SSL_F_SSL_ENC_RC4_INIT
	    return SSL_F_SSL_ENC_RC4_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_GET_NEW_SESSION"))
#ifdef SSL_F_SSL_GET_NEW_SESSION
	    return SSL_F_SSL_GET_NEW_SESSION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_MAKE_CIPHER_LIST"))
#ifdef SSL_F_SSL_MAKE_CIPHER_LIST
	    return SSL_F_SSL_MAKE_CIPHER_LIST;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_NEW"))
#ifdef SSL_F_SSL_NEW
	    return SSL_F_SSL_NEW;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_READ"))
#ifdef SSL_F_SSL_READ
	    return SSL_F_SSL_READ;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_RSA_PRIVATE_DECRYPT"))
#ifdef SSL_F_SSL_RSA_PRIVATE_DECRYPT
	    return SSL_F_SSL_RSA_PRIVATE_DECRYPT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_RSA_PUBLIC_ENCRYPT"))
#ifdef SSL_F_SSL_RSA_PUBLIC_ENCRYPT
	    return SSL_F_SSL_RSA_PUBLIC_ENCRYPT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_SESSION_NEW"))
#ifdef SSL_F_SSL_SESSION_NEW
	    return SSL_F_SSL_SESSION_NEW;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_SESSION_PRINT_FP"))
#ifdef SSL_F_SSL_SESSION_PRINT_FP
	    return SSL_F_SSL_SESSION_PRINT_FP;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_SET_CERTIFICATE"))
#ifdef SSL_F_SSL_SET_CERTIFICATE
	    return SSL_F_SSL_SET_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_SET_FD"))
#ifdef SSL_F_SSL_SET_FD
	    return SSL_F_SSL_SET_FD;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_SET_RFD"))
#ifdef SSL_F_SSL_SET_RFD
	    return SSL_F_SSL_SET_RFD;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_SET_WFD"))
#ifdef SSL_F_SSL_SET_WFD
	    return SSL_F_SSL_SET_WFD;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_STARTUP"))
#ifdef SSL_F_SSL_STARTUP
	    return SSL_F_SSL_STARTUP;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_CERTIFICATE"))
#ifdef SSL_F_SSL_USE_CERTIFICATE
	    return SSL_F_SSL_USE_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_CERTIFICATE_ASN1"))
#ifdef SSL_F_SSL_USE_CERTIFICATE_ASN1
	    return SSL_F_SSL_USE_CERTIFICATE_ASN1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_CERTIFICATE_FILE"))
#ifdef SSL_F_SSL_USE_CERTIFICATE_FILE
	    return SSL_F_SSL_USE_CERTIFICATE_FILE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_PRIVATEKEY"))
#ifdef SSL_F_SSL_USE_PRIVATEKEY
	    return SSL_F_SSL_USE_PRIVATEKEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_PRIVATEKEY_ASN1"))
#ifdef SSL_F_SSL_USE_PRIVATEKEY_ASN1
	    return SSL_F_SSL_USE_PRIVATEKEY_ASN1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_PRIVATEKEY_FILE"))
#ifdef SSL_F_SSL_USE_PRIVATEKEY_FILE
	    return SSL_F_SSL_USE_PRIVATEKEY_FILE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_RSAPRIVATEKEY"))
#ifdef SSL_F_SSL_USE_RSAPRIVATEKEY
	    return SSL_F_SSL_USE_RSAPRIVATEKEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_RSAPRIVATEKEY_ASN1"))
#ifdef SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1
	    return SSL_F_SSL_USE_RSAPRIVATEKEY_ASN1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_SSL_USE_RSAPRIVATEKEY_FILE"))
#ifdef SSL_F_SSL_USE_RSAPRIVATEKEY_FILE
	    return SSL_F_SSL_USE_RSAPRIVATEKEY_FILE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "F_WRITE_PENDING"))
#ifdef SSL_F_WRITE_PENDING
	    return SSL_F_WRITE_PENDING;
#else
	    goto not_there;
#endif
	break;
    case 'G':
	break;
    case 'H':
	break;
    case 'I':
	break;
    case 'J':
	break;
    case 'K':
	break;
    case 'L':
	break;
    case 'M':
	if (strEQ(name, "MAX_MASTER_KEY_LENGTH_IN_BITS"))
#ifdef SSL_MAX_MASTER_KEY_LENGTH_IN_BITS
	    return SSL_MAX_MASTER_KEY_LENGTH_IN_BITS;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MAX_RECORD_LENGTH_2_BYTE_HEADER"))
#ifdef SSL_MAX_RECORD_LENGTH_2_BYTE_HEADER
	    return SSL_MAX_RECORD_LENGTH_2_BYTE_HEADER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MAX_RECORD_LENGTH_3_BYTE_HEADER"))
#ifdef SSL_MAX_RECORD_LENGTH_3_BYTE_HEADER
	    return SSL_MAX_RECORD_LENGTH_3_BYTE_HEADER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MAX_SSL_SESSION_ID_LENGTH_IN_BYTES"))
#ifdef SSL_MAX_SSL_SESSION_ID_LENGTH_IN_BYTES
	    return SSL_MAX_SSL_SESSION_ID_LENGTH_IN_BYTES;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MIN_RSA_MODULUS_LENGTH_IN_BYTES"))
#ifdef SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES
	    return SSL_MIN_RSA_MODULUS_LENGTH_IN_BYTES;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_CLIENT_CERTIFICATE"))
#ifdef SSL_MT_CLIENT_CERTIFICATE
	    return SSL_MT_CLIENT_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_CLIENT_FINISHED"))
#ifdef SSL_MT_CLIENT_FINISHED
	    return SSL_MT_CLIENT_FINISHED;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_CLIENT_HELLO"))
#ifdef SSL_MT_CLIENT_HELLO
	    return SSL_MT_CLIENT_HELLO;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_CLIENT_MASTER_KEY"))
#ifdef SSL_MT_CLIENT_MASTER_KEY
	    return SSL_MT_CLIENT_MASTER_KEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_ERROR"))
#ifdef SSL_MT_ERROR
	    return SSL_MT_ERROR;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_REQUEST_CERTIFICATE"))
#ifdef SSL_MT_REQUEST_CERTIFICATE
	    return SSL_MT_REQUEST_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_SERVER_FINISHED"))
#ifdef SSL_MT_SERVER_FINISHED
	    return SSL_MT_SERVER_FINISHED;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_SERVER_HELLO"))
#ifdef SSL_MT_SERVER_HELLO
	    return SSL_MT_SERVER_HELLO;
#else
	    goto not_there;
#endif
	if (strEQ(name, "MT_SERVER_VERIFY"))
#ifdef SSL_MT_SERVER_VERIFY
	    return SSL_MT_SERVER_VERIFY;
#else
	    goto not_there;
#endif
	break;
    case 'N':
	if (strEQ(name, "NOTHING"))
#ifdef SSL_NOTHING
	    return SSL_NOTHING;
#else
	    goto not_there;
#endif
	break;
    case 'O':
	if (strEQ(name, "OPENSSL_VERSION_NUMBER"))
#ifdef OPENSSL_VERSION_NUMBER
            return OPENSSL_VERSION_NUMBER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_MICROSOFT_SESS_ID_BUG"))
#ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
	    return SSL_OP_MICROSOFT_SESS_ID_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NETSCAPE_CHALLENGE_BUG"))
#ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
	    return SSL_OP_NETSCAPE_CHALLENGE_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG"))
#ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
	    return SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_SSLREF2_REUSE_CERT_TYPE_BUG"))
#ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
	    return SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_MICROSOFT_BIG_SSLV3_BUFFER"))
#ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
	    return SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_MSIE_SSLV2_RSA_PADDING"))
#ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
	    return SSL_OP_MSIE_SSLV2_RSA_PADDING;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_SSLEAY_080_CLIENT_DH_BUG"))
#ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
	    return SSL_OP_SSLEAY_080_CLIENT_DH_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_TLS_D5_BUG"))
#ifdef SSL_OP_TLS_D5_BUG
	    return SSL_OP_TLS_D5_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_SINGLE_DH_USE"))
#ifdef SSL_OP_SINGLE_DH_USE
	    return SSL_OP_SINGLE_DH_USE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_EPHEMERAL_RSA"))
#ifdef SSL_OP_EPHEMERAL_RSA
	    return SSL_OP_EPHEMERAL_RSA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NETSCAPE_CA_DN_BUG"))
#ifdef SSL_OP_NETSCAPE_CA_DN_BUG
	    return SSL_OP_NETSCAPE_CA_DN_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NON_EXPORT_FIRST"))
#ifdef SSL_OP_NON_EXPORT_FIRST
	    return SSL_OP_NON_EXPORT_FIRST;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG"))
#ifdef SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG
	    return SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NO_SSLv2"))
#ifdef SSL_OP_NO_SSLv2
	    return SSL_OP_NO_SSLv2;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NO_SSLv3"))
#ifdef SSL_OP_NO_SSLv3
	    return SSL_OP_NO_SSLv3;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_NO_TLSv1"))
#ifdef SSL_OP_NO_TLSv1
	    return SSL_OP_NO_TLSv1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "OP_ALL"))
#ifdef SSL_OP_ALL
	    return SSL_OP_ALL;
#else
	    goto not_there;
#endif

    case 'P':
	if (strEQ(name, "PE_BAD_CERTIFICATE"))
#ifdef SSL_PE_BAD_CERTIFICATE
	    return SSL_PE_BAD_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "PE_NO_CERTIFICATE"))
#ifdef SSL_PE_NO_CERTIFICATE
	    return SSL_PE_NO_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "PE_NO_CIPHER"))
#ifdef SSL_PE_NO_CIPHER
	    return SSL_PE_NO_CIPHER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "PE_UNSUPPORTED_CERTIFICATE_TYPE"))
#ifdef SSL_PE_UNSUPPORTED_CERTIFICATE_TYPE
	    return SSL_PE_UNSUPPORTED_CERTIFICATE_TYPE;
#else
	    goto not_there;
#endif
	break;
    case 'Q':
	break;
    case 'R':
	if (strEQ(name, "READING"))
#ifdef SSL_READING
	    return SSL_READING;
#else
	    goto not_there;
#endif
	if (strEQ(name, "RWERR_BAD_MAC_DECODE"))
#ifdef SSL_RWERR_BAD_MAC_DECODE
	    return SSL_RWERR_BAD_MAC_DECODE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "RWERR_BAD_WRITE_RETRY"))
#ifdef SSL_RWERR_BAD_WRITE_RETRY
	    return SSL_RWERR_BAD_WRITE_RETRY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "RWERR_INTERNAL_ERROR"))
#ifdef SSL_RWERR_INTERNAL_ERROR
	    return SSL_RWERR_INTERNAL_ERROR;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_AUTHENTICATION_TYPE"))
#ifdef SSL_R_BAD_AUTHENTICATION_TYPE
	    return SSL_R_BAD_AUTHENTICATION_TYPE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_CHECKSUM"))
#ifdef SSL_R_BAD_CHECKSUM
	    return SSL_R_BAD_CHECKSUM;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_MAC_DECODE"))
#ifdef SSL_R_BAD_MAC_DECODE
	    return SSL_R_BAD_MAC_DECODE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_RESPONSE_ARGUMENT"))
#ifdef SSL_R_BAD_RESPONSE_ARGUMENT
	    return SSL_R_BAD_RESPONSE_ARGUMENT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_SSL_FILETYPE"))
#ifdef SSL_R_BAD_SSL_FILETYPE
	    return SSL_R_BAD_SSL_FILETYPE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_SSL_SESSION_ID_LENGTH"))
#ifdef SSL_R_BAD_SSL_SESSION_ID_LENGTH
	    return SSL_R_BAD_SSL_SESSION_ID_LENGTH;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_STATE"))
#ifdef SSL_R_BAD_STATE
	    return SSL_R_BAD_STATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_BAD_WRITE_RETRY"))
#ifdef SSL_R_BAD_WRITE_RETRY
	    return SSL_R_BAD_WRITE_RETRY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_CHALLENGE_IS_DIFFERENT"))
#ifdef SSL_R_CHALLENGE_IS_DIFFERENT
	    return SSL_R_CHALLENGE_IS_DIFFERENT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_CIPHER_CODE_TOO_LONG"))
#ifdef SSL_R_CIPHER_CODE_TOO_LONG
	    return SSL_R_CIPHER_CODE_TOO_LONG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_CIPHER_TABLE_SRC_ERROR"))
#ifdef SSL_R_CIPHER_TABLE_SRC_ERROR
	    return SSL_R_CIPHER_TABLE_SRC_ERROR;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_CONECTION_ID_IS_DIFFERENT"))
#ifdef SSL_R_CONECTION_ID_IS_DIFFERENT
	    return SSL_R_CONECTION_ID_IS_DIFFERENT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_INVALID_CHALLENGE_LENGTH"))
#ifdef SSL_R_INVALID_CHALLENGE_LENGTH
	    return SSL_R_INVALID_CHALLENGE_LENGTH;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_CERTIFICATE_SET"))
#ifdef SSL_R_NO_CERTIFICATE_SET
	    return SSL_R_NO_CERTIFICATE_SET;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_CERTIFICATE_SPECIFIED"))
#ifdef SSL_R_NO_CERTIFICATE_SPECIFIED
	    return SSL_R_NO_CERTIFICATE_SPECIFIED;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_CIPHER_LIST"))
#ifdef SSL_R_NO_CIPHER_LIST
	    return SSL_R_NO_CIPHER_LIST;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_CIPHER_MATCH"))
#ifdef SSL_R_NO_CIPHER_MATCH
	    return SSL_R_NO_CIPHER_MATCH;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_CIPHER_WE_TRUST"))
#ifdef SSL_R_NO_CIPHER_WE_TRUST
	    return SSL_R_NO_CIPHER_WE_TRUST;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_PRIVATEKEY"))
#ifdef SSL_R_NO_PRIVATEKEY
	    return SSL_R_NO_PRIVATEKEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_PUBLICKEY"))
#ifdef SSL_R_NO_PUBLICKEY
	    return SSL_R_NO_PUBLICKEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_READ_METHOD_SET"))
#ifdef SSL_R_NO_READ_METHOD_SET
	    return SSL_R_NO_READ_METHOD_SET;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NO_WRITE_METHOD_SET"))
#ifdef SSL_R_NO_WRITE_METHOD_SET
	    return SSL_R_NO_WRITE_METHOD_SET;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_NULL_SSL_CTX"))
#ifdef SSL_R_NULL_SSL_CTX
	    return SSL_R_NULL_SSL_CTX;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PEER_DID_NOT_RETURN_A_CERTIFICATE"))
#ifdef SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE
	    return SSL_R_PEER_DID_NOT_RETURN_A_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PEER_ERROR"))
#ifdef SSL_R_PEER_ERROR
	    return SSL_R_PEER_ERROR;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PEER_ERROR_CERTIFICATE"))
#ifdef SSL_R_PEER_ERROR_CERTIFICATE
	    return SSL_R_PEER_ERROR_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PEER_ERROR_NO_CIPHER"))
#ifdef SSL_R_PEER_ERROR_NO_CIPHER
	    return SSL_R_PEER_ERROR_NO_CIPHER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE"))
#ifdef SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE
	    return SSL_R_PEER_ERROR_UNSUPPORTED_CERTIFICATE_TYPE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PERR_ERROR_NO_CERTIFICATE"))
#ifdef SSL_R_PERR_ERROR_NO_CERTIFICATE
	    return SSL_R_PERR_ERROR_NO_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PUBLIC_KEY_ENCRYPT_ERROR"))
#ifdef SSL_R_PUBLIC_KEY_ENCRYPT_ERROR
	    return SSL_R_PUBLIC_KEY_ENCRYPT_ERROR;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PUBLIC_KEY_IS_NOT_RSA"))
#ifdef SSL_R_PUBLIC_KEY_IS_NOT_RSA
	    return SSL_R_PUBLIC_KEY_IS_NOT_RSA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_PUBLIC_KEY_NO_RSA"))
#ifdef SSL_R_PUBLIC_KEY_NO_RSA
	    return SSL_R_PUBLIC_KEY_NO_RSA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_READ_WRONG_PACKET_TYPE"))
#ifdef SSL_R_READ_WRONG_PACKET_TYPE
	    return SSL_R_READ_WRONG_PACKET_TYPE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_REVERSE_KEY_ARG_LENGTH_IS_WRONG"))
#ifdef SSL_R_REVERSE_KEY_ARG_LENGTH_IS_WRONG
	    return SSL_R_REVERSE_KEY_ARG_LENGTH_IS_WRONG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_REVERSE_MASTER_KEY_LENGTH_IS_WRONG"))
#ifdef SSL_R_REVERSE_MASTER_KEY_LENGTH_IS_WRONG
	    return SSL_R_REVERSE_MASTER_KEY_LENGTH_IS_WRONG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_REVERSE_SSL_SESSION_ID_LENGTH_IS_WRONG"))
#ifdef SSL_R_REVERSE_SSL_SESSION_ID_LENGTH_IS_WRONG
	    return SSL_R_REVERSE_SSL_SESSION_ID_LENGTH_IS_WRONG;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_SHORT_READ"))
#ifdef SSL_R_SHORT_READ
	    return SSL_R_SHORT_READ;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_SSL_SESSION_ID_IS_DIFFERENT"))
#ifdef SSL_R_SSL_SESSION_ID_IS_DIFFERENT
	    return SSL_R_SSL_SESSION_ID_IS_DIFFERENT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_UNABLE_TO_EXTRACT_PUBLIC_KEY"))
#ifdef SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY
	    return SSL_R_UNABLE_TO_EXTRACT_PUBLIC_KEY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_UNDEFINED_INIT_STATE"))
#ifdef SSL_R_UNDEFINED_INIT_STATE
	    return SSL_R_UNDEFINED_INIT_STATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_UNKNOWN_REMOTE_ERROR_TYPE"))
#ifdef SSL_R_UNKNOWN_REMOTE_ERROR_TYPE
	    return SSL_R_UNKNOWN_REMOTE_ERROR_TYPE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_UNKNOWN_STATE"))
#ifdef SSL_R_UNKNOWN_STATE
	    return SSL_R_UNKNOWN_STATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_UNSUPORTED_CIPHER"))
#ifdef SSL_R_UNSUPORTED_CIPHER
	    return SSL_R_UNSUPORTED_CIPHER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_WRONG_PUBLIC_KEY_TYPE"))
#ifdef SSL_R_WRONG_PUBLIC_KEY_TYPE
	    return SSL_R_WRONG_PUBLIC_KEY_TYPE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "R_X509_LIB"))
#ifdef SSL_R_X509_LIB
	    return SSL_R_X509_LIB;
#else
	    goto not_there;
#endif
	break;
    case 'S':
	if (strEQ(name, "SERVER_VERSION"))
#ifdef SSL_SERVER_VERSION
	    return SSL_SERVER_VERSION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "SESSION_ASN1_VERSION"))
#ifdef SSL_SESSION_ASN1_VERSION
	    return SSL_SESSION_ASN1_VERSION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_ACCEPT"))
#ifdef SSL_ST_ACCEPT
	    return SSL_ST_ACCEPT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_BEFORE"))
#ifdef SSL_ST_BEFORE
	    return SSL_ST_BEFORE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_CLIENT_START_ENCRYPTION"))
#ifdef SSL_ST_CLIENT_START_ENCRYPTION
	    return SSL_ST_CLIENT_START_ENCRYPTION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_CONNECT"))
#ifdef SSL_ST_CONNECT
	    return SSL_ST_CONNECT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_CLIENT_FINISHED_A"))
#ifdef SSL_ST_GET_CLIENT_FINISHED_A
	    return SSL_ST_GET_CLIENT_FINISHED_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_CLIENT_FINISHED_B"))
#ifdef SSL_ST_GET_CLIENT_FINISHED_B
	    return SSL_ST_GET_CLIENT_FINISHED_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_CLIENT_HELLO_A"))
#ifdef SSL_ST_GET_CLIENT_HELLO_A
	    return SSL_ST_GET_CLIENT_HELLO_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_CLIENT_HELLO_B"))
#ifdef SSL_ST_GET_CLIENT_HELLO_B
	    return SSL_ST_GET_CLIENT_HELLO_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_CLIENT_MASTER_KEY_A"))
#ifdef SSL_ST_GET_CLIENT_MASTER_KEY_A
	    return SSL_ST_GET_CLIENT_MASTER_KEY_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_CLIENT_MASTER_KEY_B"))
#ifdef SSL_ST_GET_CLIENT_MASTER_KEY_B
	    return SSL_ST_GET_CLIENT_MASTER_KEY_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_SERVER_FINISHED_A"))
#ifdef SSL_ST_GET_SERVER_FINISHED_A
	    return SSL_ST_GET_SERVER_FINISHED_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_SERVER_FINISHED_B"))
#ifdef SSL_ST_GET_SERVER_FINISHED_B
	    return SSL_ST_GET_SERVER_FINISHED_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_SERVER_HELLO_A"))
#ifdef SSL_ST_GET_SERVER_HELLO_A
	    return SSL_ST_GET_SERVER_HELLO_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_SERVER_HELLO_B"))
#ifdef SSL_ST_GET_SERVER_HELLO_B
	    return SSL_ST_GET_SERVER_HELLO_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_SERVER_VERIFY_A"))
#ifdef SSL_ST_GET_SERVER_VERIFY_A
	    return SSL_ST_GET_SERVER_VERIFY_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_GET_SERVER_VERIFY_B"))
#ifdef SSL_ST_GET_SERVER_VERIFY_B
	    return SSL_ST_GET_SERVER_VERIFY_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_INIT"))
#ifdef SSL_ST_INIT
	    return SSL_ST_INIT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_OK"))
#ifdef SSL_ST_OK
	    return SSL_ST_OK;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_READ_BODY"))
#ifdef SSL_ST_READ_BODY
	    return SSL_ST_READ_BODY;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_READ_HEADER"))
#ifdef SSL_ST_READ_HEADER
	    return SSL_ST_READ_HEADER;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_CERTIFICATE_A"))
#ifdef SSL_ST_SEND_CLIENT_CERTIFICATE_A
	    return SSL_ST_SEND_CLIENT_CERTIFICATE_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_CERTIFICATE_B"))
#ifdef SSL_ST_SEND_CLIENT_CERTIFICATE_B
	    return SSL_ST_SEND_CLIENT_CERTIFICATE_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_CERTIFICATE_C"))
#ifdef SSL_ST_SEND_CLIENT_CERTIFICATE_C
	    return SSL_ST_SEND_CLIENT_CERTIFICATE_C;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_CERTIFICATE_D"))
#ifdef SSL_ST_SEND_CLIENT_CERTIFICATE_D
	    return SSL_ST_SEND_CLIENT_CERTIFICATE_D;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_FINISHED_A"))
#ifdef SSL_ST_SEND_CLIENT_FINISHED_A
	    return SSL_ST_SEND_CLIENT_FINISHED_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_FINISHED_B"))
#ifdef SSL_ST_SEND_CLIENT_FINISHED_B
	    return SSL_ST_SEND_CLIENT_FINISHED_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_HELLO_A"))
#ifdef SSL_ST_SEND_CLIENT_HELLO_A
	    return SSL_ST_SEND_CLIENT_HELLO_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_HELLO_B"))
#ifdef SSL_ST_SEND_CLIENT_HELLO_B
	    return SSL_ST_SEND_CLIENT_HELLO_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_MASTER_KEY_A"))
#ifdef SSL_ST_SEND_CLIENT_MASTER_KEY_A
	    return SSL_ST_SEND_CLIENT_MASTER_KEY_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_CLIENT_MASTER_KEY_B"))
#ifdef SSL_ST_SEND_CLIENT_MASTER_KEY_B
	    return SSL_ST_SEND_CLIENT_MASTER_KEY_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_REQUEST_CERTIFICATE_A"))
#ifdef SSL_ST_SEND_REQUEST_CERTIFICATE_A
	    return SSL_ST_SEND_REQUEST_CERTIFICATE_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_REQUEST_CERTIFICATE_B"))
#ifdef SSL_ST_SEND_REQUEST_CERTIFICATE_B
	    return SSL_ST_SEND_REQUEST_CERTIFICATE_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_REQUEST_CERTIFICATE_C"))
#ifdef SSL_ST_SEND_REQUEST_CERTIFICATE_C
	    return SSL_ST_SEND_REQUEST_CERTIFICATE_C;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_REQUEST_CERTIFICATE_D"))
#ifdef SSL_ST_SEND_REQUEST_CERTIFICATE_D
	    return SSL_ST_SEND_REQUEST_CERTIFICATE_D;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_SERVER_FINISHED_A"))
#ifdef SSL_ST_SEND_SERVER_FINISHED_A
	    return SSL_ST_SEND_SERVER_FINISHED_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_SERVER_FINISHED_B"))
#ifdef SSL_ST_SEND_SERVER_FINISHED_B
	    return SSL_ST_SEND_SERVER_FINISHED_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_SERVER_HELLO_A"))
#ifdef SSL_ST_SEND_SERVER_HELLO_A
	    return SSL_ST_SEND_SERVER_HELLO_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_SERVER_HELLO_B"))
#ifdef SSL_ST_SEND_SERVER_HELLO_B
	    return SSL_ST_SEND_SERVER_HELLO_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_SERVER_VERIFY_A"))
#ifdef SSL_ST_SEND_SERVER_VERIFY_A
	    return SSL_ST_SEND_SERVER_VERIFY_A;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SEND_SERVER_VERIFY_B"))
#ifdef SSL_ST_SEND_SERVER_VERIFY_B
	    return SSL_ST_SEND_SERVER_VERIFY_B;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_SERVER_START_ENCRYPTION"))
#ifdef SSL_ST_SERVER_START_ENCRYPTION
	    return SSL_ST_SERVER_START_ENCRYPTION;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_X509_GET_CLIENT_CERTIFICATE"))
#ifdef SSL_ST_X509_GET_CLIENT_CERTIFICATE
	    return SSL_ST_X509_GET_CLIENT_CERTIFICATE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "ST_X509_GET_SERVER_CERTIFICATE"))
#ifdef SSL_ST_X509_GET_SERVER_CERTIFICATE
	    return SSL_ST_X509_GET_SERVER_CERTIFICATE;
#else
	    goto not_there;
#endif
	break;
    case 'T':
#if 0
	if (strEQ(name, "TXT_DES_192_EDE3_CBC_WITH_MD5"))
#ifdef SSL_TXT_DES_192_EDE3_CBC_WITH_MD5
	    return SSL_TXT_DES_192_EDE3_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_DES_192_EDE3_CBC_WITH_SHA"))
#ifdef SSL_TXT_DES_192_EDE3_CBC_WITH_SHA
	    return SSL_TXT_DES_192_EDE3_CBC_WITH_SHA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_DES_64_CBC_WITH_MD5"))
#ifdef SSL_TXT_DES_64_CBC_WITH_MD5
	    return SSL_TXT_DES_64_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_DES_64_CBC_WITH_SHA"))
#ifdef SSL_TXT_DES_64_CBC_WITH_SHA
	    return SSL_TXT_DES_64_CBC_WITH_SHA;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_DES_64_CFB64_WITH_MD5_1"))
#ifdef SSL_TXT_DES_64_CFB64_WITH_MD5_1
	    return SSL_TXT_DES_64_CFB64_WITH_MD5_1;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_IDEA_128_CBC_WITH_MD5"))
#ifdef SSL_TXT_IDEA_128_CBC_WITH_MD5
	    return SSL_TXT_IDEA_128_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_NULL"))
#ifdef SSL_TXT_NULL
	    return SSL_TXT_NULL;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_NULL_WITH_MD5"))
#ifdef SSL_TXT_NULL_WITH_MD5
	    return SSL_TXT_NULL_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_RC2_128_CBC_EXPORT40_WITH_MD5"))
#ifdef SSL_TXT_RC2_128_CBC_EXPORT40_WITH_MD5
	    return SSL_TXT_RC2_128_CBC_EXPORT40_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_RC2_128_CBC_WITH_MD5"))
#ifdef SSL_TXT_RC2_128_CBC_WITH_MD5
	    return SSL_TXT_RC2_128_CBC_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_RC4_128_EXPORT40_WITH_MD5"))
#ifdef SSL_TXT_RC4_128_EXPORT40_WITH_MD5
	    return SSL_TXT_RC4_128_EXPORT40_WITH_MD5;
#else
	    goto not_there;
#endif
	if (strEQ(name, "TXT_RC4_128_WITH_MD5"))
#ifdef SSL_TXT_RC4_128_WITH_MD5
	    return SSL_TXT_RC4_128_WITH_MD5;
#else
	    goto not_there;
#endif
#endif
	break;
    case 'U':
	break;
    case 'V':
	if (strEQ(name, "VERIFY_CLIENT_ONCE"))
#ifdef SSL_VERIFY_CLIENT_ONCE
	    return SSL_VERIFY_CLIENT_ONCE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "VERIFY_FAIL_IF_NO_PEER_CERT"))
#ifdef SSL_VERIFY_FAIL_IF_NO_PEER_CERT
	    return SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
#else
	    goto not_there;
#endif
	if (strEQ(name, "VERIFY_NONE"))
#ifdef SSL_VERIFY_NONE
	    return SSL_VERIFY_NONE;
#else
	    goto not_there;
#endif
	if (strEQ(name, "VERIFY_PEER"))
#ifdef SSL_VERIFY_PEER
	    return SSL_VERIFY_PEER;
#else
	    goto not_there;
#endif
	break;
    case 'W':
	if (strEQ(name, "WRITING"))
#ifdef SSL_WRITING
	    return SSL_WRITING;
#else
	    goto not_there;
#endif
	break;
    case 'X':
	if (strEQ(name, "X509_LOOKUP"))
#ifdef SSL_X509_LOOKUP
	    return SSL_X509_LOOKUP;
#else
	    goto not_there;
#endif

	if (strEQ(name, "X509_V_FLAG_CB_ISSUER_CHECK"))
#ifdef X509_V_FLAG_CB_ISSUER_CHECK
	    return X509_V_FLAG_CB_ISSUER_CHECK;
#else
	    goto not_there;
#endif

	if (strEQ(name, "X509_V_FLAG_USE_CHECK_TIME"))
#ifdef X509_V_FLAG_USE_CHECK_TIME
	    return X509_V_FLAG_USE_CHECK_TIME;
#else
	    goto not_there;
#endif
	if (strEQ(name, "X509_V_FLAG_CRL_CHECK"))
#ifdef X509_V_FLAG_CRL_CHECK
	    return X509_V_FLAG_CRL_CHECK;
#else
	    goto not_there;
#endif
	if (strEQ(name, "X509_V_FLAG_CRL_CHECK_ALL"))
#ifdef X509_V_FLAG_CRL_CHECK_ALL
	    return X509_V_FLAG_CRL_CHECK_ALL;
#else
	    goto not_there;
#endif
	if (strEQ(name, "X509_V_FLAG_IGNORE_CRITICAL"))
#ifdef X509_V_FLAG_IGNORE_CRITICAL
	    return X509_V_FLAG_IGNORE_CRITICAL;
#else
	    goto not_there;
#endif
	if (strEQ(name, ""))
#ifdef SSL_X509_LOOKUP
	    return ;
#else
	    goto not_there;
#endif
	break;
    case 'Y':
	break;
    case 'Z':
	break;
    }
    errno = EINVAL;
    return 0;

not_there:
    errno = ENOENT;
    return 0;
}

/* ============= typedefs to agument TYPEMAP ============== */

typedef int callback_ret_int();
typedef void callback_no_ret();
typedef RSA * cb_ssl_int_int_ret_RSA(SSL * ssl,int is_export, int keylength);
typedef DH * cb_ssl_int_int_ret_DH(SSL * ssl,int is_export, int keylength);

typedef STACK_OF(X509_NAME) X509_NAME_STACK;

/* ============= callback stuff ============== */

static SV * ssleay_verify_callback = (SV*)NULL;

static int
ssleay_verify_callback_glue (int ok, X509_STORE_CTX* ctx)
{
	dSP ;
	int count,res;
	
	ENTER ;
	SAVETMPS;

	PRN("verify callback glue", ok);

	PUSHMARK(sp);
	XPUSHs(sv_2mortal(newSViv(ok)));
	XPUSHs(sv_2mortal(newSViv((unsigned long int)ctx)));
	PUTBACK ;
	
	if (ssleay_verify_callback == NULL)
		croak ("Net::SSLeay: verify_callback called, but not "
			"set to point to any perl function.\n");

	PR("About to call verify callback.\n");	
	count = perl_call_sv(ssleay_verify_callback, G_SCALAR);
	PR("Returned from verify callback.\n");	

	SPAGAIN;
	
	if (count != 1)
		croak ( "Net::SSLeay: verify_callback "
			"perl function did not return a scalar.\n");
	res = POPi ;

	PUTBACK ;
	FREETMPS ;
	LEAVE ;

	return res;
}

static SV * ssleay_ctx_verify_callback = (SV*)NULL;

static int
ssleay_ctx_verify_callback_glue (int ok, X509_STORE_CTX* ctx)
{
	dSP ;
	int count,res;
	
	ENTER ;
	SAVETMPS;
	
	PRN("ctx verify callback glue", ok);

	PUSHMARK(sp);
	XPUSHs(sv_2mortal(newSViv(ok)));
	XPUSHs(sv_2mortal(newSViv((unsigned long int)ctx)));
	PUTBACK ;
	
	if (ssleay_ctx_verify_callback == NULL)
		croak ("Net::SSLeay: ctx_verify_callback called, but not "
			"set to point to any perl function.\n");

	PR("About to call ctx verify callback.\n");	
	count = perl_call_sv(ssleay_ctx_verify_callback, G_SCALAR);
	PR("Returned from ctx verify callback.\n");	

	SPAGAIN;
	
	if (count != 1)
		croak ( "Net::SSLeay: ctx_verify_callback "
			"perl function did not return a scalar.\n");
	res = POPi ;

	PUTBACK ;
	FREETMPS ;
	LEAVE ;
	
	return res;
}

static SV * ssleay_ctx_set_default_passwd_cb_callback = (SV*)NULL;

/* pem_password_cb function */

static int
ssleay_ctx_set_default_passwd_cb_callback_glue (char *buf, int size,
				 		int rwflag, void *userdata)
{
      dSP;
      int count;
      char *res;

      ENTER;
      SAVETMPS;

      PUSHMARK(sp);
      XPUSHs(sv_2mortal(newSViv(rwflag)));
      XPUSHs(sv_2mortal(newSViv((unsigned long)userdata)));
      PUTBACK;

      if (ssleay_ctx_set_default_passwd_cb_callback == NULL)
              croak ("Net::SSLeay: ctx_passwd_callback called, but not "
                     "set to point to any perl function.\n");

      PR("About to call passwd callback.\n");
      count = perl_call_sv(ssleay_ctx_set_default_passwd_cb_callback, G_SCALAR);
      PR("Returned from ctx passwd callback.\n");

      SPAGAIN;

      if (count != 1)
              croak ("Net::SSLeay: ctx_passwd_callback "
                     "perl function did not return a scalar.\n");
      res = POPp;
      
      if (res == NULL) {
              *buf = '\0';
      } else {
              strncpy(buf, res, size);
              buf[size - 1] = '\0';
      }

      PUTBACK;
      FREETMPS;
      LEAVE;

      return strlen(buf);
}

#line 1718 "SSLeay.c"
XS(XS_Net__SSLeay_constant); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_constant)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::constant(name)");
    {
	char *	name = (char *)SvPV_nolen(ST(0));
	double	RETVAL;
	dXSTARG;

	RETVAL = constant(name);
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_hello); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_hello)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::hello()");
    {
	int	RETVAL;
	dXSTARG;
#line 1719 "SSLeay.xs"
        PR("\tSSLeay Hello World!\n");
        RETVAL = 1;
#line 1748 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM1 "============= SSL CONTEXT functions =============="
XS(XS_Net__SSLeay_CTX_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_new)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_new()");
    {
	SSL_CTX *	RETVAL;
	dXSTARG;
#line 1729 "SSLeay.xs"
     RETVAL = SSL_CTX_new (SSLv23_method());
#line 1766 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_v2_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_v2_new)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_v2_new()");
    {
	SSL_CTX *	RETVAL;
	dXSTARG;
#line 1736 "SSLeay.xs"
     RETVAL = SSL_CTX_new (SSLv2_method());
#line 1783 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_v3_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_v3_new)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_v3_new()");
    {
	SSL_CTX *	RETVAL;
	dXSTARG;
#line 1743 "SSLeay.xs"
     RETVAL = SSL_CTX_new (SSLv3_method());
#line 1800 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_v23_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_v23_new)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_v23_new()");
    {
	SSL_CTX *	RETVAL;
	dXSTARG;
#line 1750 "SSLeay.xs"
     RETVAL = SSL_CTX_new (SSLv23_method());
#line 1817 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_tlsv1_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_tlsv1_new)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_tlsv1_new()");
    {
	SSL_CTX *	RETVAL;
	dXSTARG;
#line 1757 "SSLeay.xs"
     RETVAL = SSL_CTX_new (TLSv1_method());
#line 1834 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_new_with_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_new_with_method)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_new_with_method(meth)");
    {
	SSL_METHOD *	meth = (SSL_METHOD *)SvIV(ST(0));
	SSL_CTX *	RETVAL;
	dXSTARG;
#line 1765 "SSLeay.xs"
     RETVAL = SSL_CTX_new (SSLv23_method());
#line 1852 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_free(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));

	SSL_CTX_free(ctx);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_add_session); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_add_session)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_add_session(ctx, ses)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_add_session(ctx, ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_remove_session); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_remove_session)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_remove_session(ctx, ses)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_remove_session(ctx, ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_flush_sessions); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_flush_sessions)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_flush_sessions(ctx, tm)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	tm = (long)SvIV(ST(1));

	SSL_CTX_flush_sessions(ctx, tm);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_default_verify_paths); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_default_verify_paths)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_default_verify_paths(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_default_verify_paths(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_load_verify_locations); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_load_verify_locations)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_load_verify_locations(ctx, CAfile, CApath)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	char *	CAfile = (char *)SvPV_nolen(ST(1));
	char *	CApath = (char *)SvPV_nolen(ST(2));
	int	RETVAL;
	dXSTARG;
#line 1798 "SSLeay.xs"
     RETVAL = SSL_CTX_load_verify_locations (ctx,
					     CAfile?(*CAfile?CAfile:NULL):NULL,
					     CApath?(*CApath?CApath:NULL):NULL
					     );
#line 1957 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_verify); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_verify)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_verify(ctx, mode, callback)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	mode = (int)SvIV(ST(1));
	SV *	callback = ST(2);
#line 1811 "SSLeay.xs"
     if (ssleay_ctx_verify_callback == (SV*)NULL) {
        ssleay_ctx_verify_callback = newSVsv(callback);
     } else {
         SvSetSV (ssleay_ctx_verify_callback, callback);
     }
     if (SvTRUE(ssleay_ctx_verify_callback)) {
         SSL_CTX_set_verify(ctx,mode,&ssleay_ctx_verify_callback_glue);
     } else {
         SSL_CTX_set_verify(ctx,mode,NULL);
     }
#line 1984 "SSLeay.c"
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_get_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_error)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_error(s, ret)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	ret = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_error(s, ret);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM10 "============= SSL functions =============="
XS(XS_Net__SSLeay_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_new)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::new(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	SSL *	RETVAL;
	dXSTARG;

	RETVAL = SSL_new(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::free(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));

	SSL_free(s);
    }
    XSRETURN_EMPTY;
}

#if 0 /* this seems to be gone in 0.9.0 */
#define XSubPPtmpAAAA 1

XS(XS_Net__SSLeay_debug); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_debug)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::debug(file)");
    {
	char *	file = (char *)SvPV_nolen(ST(0));

	SSL_debug(file);
    }
    XSRETURN_EMPTY;
}

#endif
XS(XS_Net__SSLeay_accept); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_accept)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::accept(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_accept(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_clear); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_clear)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::clear(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));

	SSL_clear(s);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_connect); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_connect)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::connect(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_connect(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#if defined(WIN32)
#define XSubPPtmpAAAB 1

XS(XS_Net__SSLeay_set_fd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_fd)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_fd(s, fd)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	fd = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;
#line 1864 "SSLeay.xs"
     RETVAL = SSL_set_fd(s,_get_osfhandle(fd));
#line 2121 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_rfd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_rfd)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_rfd(s, fd)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	fd = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;
#line 1873 "SSLeay.xs"
     RETVAL = SSL_set_rfd(s,_get_osfhandle(fd));
#line 2140 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_wfd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_wfd)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_wfd(s, fd)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	fd = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;
#line 1882 "SSLeay.xs"
     RETVAL = SSL_set_wfd(s,_get_osfhandle(fd));
#line 2159 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#else
#define XSubPPtmpAAAC 1

XS(XS_Net__SSLeay_set_fd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_fd)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_fd(s, fd)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	fd = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_fd(s, fd);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_rfd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_rfd)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_rfd(s, fd)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	fd = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_rfd(s, fd);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_wfd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_wfd)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_wfd(s, fd)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	fd = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_wfd(s, fd);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#endif
XS(XS_Net__SSLeay_get_fd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_fd)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_fd(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_fd(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_read); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_read)
{
    dXSARGS;
    if (items < 1 || items > 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::read(s, max=sizeof(buf))");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
#line 1913 "SSLeay.xs"
     char buf[32768];
#line 2250 "SSLeay.c"
	int	max;
#line 1917 "SSLeay.xs"
     int got;
#line 2254 "SSLeay.c"

	if (items < 2)
	    max = sizeof(buf);
	else {
	    max = (int)SvIV(ST(1));
	}
#line 1919 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if ((got = SSL_read(s, buf, max)) >= 0)
         sv_setpvn( ST(0), buf, got);
#line 2265 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_peek); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_peek)
{
    dXSARGS;
    if (items < 1 || items > 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::peek(s, max=sizeof(buf))");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
#line 1927 "SSLeay.xs"
     char buf[32768];
#line 2280 "SSLeay.c"
	int	max;
#line 1931 "SSLeay.xs"
     int got;
#line 2284 "SSLeay.c"

	if (items < 2)
	    max = sizeof(buf);
	else {
	    max = (int)SvIV(ST(1));
	}
#line 1933 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if ((got = SSL_peek(s, buf, max)) >= 0)
         sv_setpvn( ST(0), buf, got);
#line 2295 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_write); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_write)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::write(s, buf)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
#line 1941 "SSLeay.xs"
     STRLEN len;
#line 2310 "SSLeay.c"
	char *	buf = SvPV( ST(1), len);
	int	RETVAL;
	dXSTARG;
#line 1945 "SSLeay.xs"
     RETVAL = SSL_write (s, buf, (int)len);
#line 2316 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_write_partial); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_write_partial)
{
    dXSARGS;
    if (items != 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::write_partial(s, from, count, buf)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	from = (int)SvIV(ST(1));
	int	count = (int)SvIV(ST(2));
#line 1955 "SSLeay.xs"
     STRLEN len;
#line 2334 "SSLeay.c"
	char *	buf = SvPV( ST(3), len);
	int	RETVAL;
	dXSTARG;
#line 1959 "SSLeay.xs"
      /*
     if (SvROK( ST(3) )) {
       SV* t = SvRV( ST(3) );
       buf = SvPV( t, len);
     } else
       buf = SvPV( ST(3), len);
       */
     PRN("write_partial from",from);
     PRN(&buf[from],len);
     PRN("write_partial count",count);
     len -= from;
     if (len < 0) {
       croak("from beyound end of buffer");
       RETVAL = -1;
     } else
       RETVAL = SSL_write (s, &(buf[from]), (count<=len)?count:len);
#line 2355 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_RSAPrivateKey); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_RSAPrivateKey)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_RSAPrivateKey(s, rsa)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	RSA *	rsa = (RSA *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_RSAPrivateKey(s, rsa);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_RSAPrivateKey_ASN1); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_RSAPrivateKey_ASN1)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_RSAPrivateKey_ASN1(s, d, len)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	unsigned char *	d = (unsigned char *)SvPV_nolen(ST(1));
	long	len = (long)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_RSAPrivateKey_ASN1(s, d, len);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_RSAPrivateKey_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_RSAPrivateKey_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_RSAPrivateKey_file(s, file, type)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_RSAPrivateKey_file(s, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_use_RSAPrivateKey_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_RSAPrivateKey_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_RSAPrivateKey_file(ctx, file, type)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_RSAPrivateKey_file(ctx, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_PrivateKey); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_PrivateKey)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_PrivateKey(s, pkey)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	EVP_PKEY *	pkey = (EVP_PKEY *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_PrivateKey(s, pkey);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_PrivateKey_ASN1); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_PrivateKey_ASN1)
{
    dXSARGS;
    if (items != 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_PrivateKey_ASN1(pk, s, d, len)");
    {
	int	pk = (int)SvIV(ST(0));
	SSL *	s = (SSL *)SvIV(ST(1));
	unsigned char *	d = (unsigned char *)SvPV_nolen(ST(2));
	long	len = (long)SvIV(ST(3));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_PrivateKey_ASN1(pk, s, d, len);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_PrivateKey_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_PrivateKey_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_PrivateKey_file(s, file, type)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_PrivateKey_file(s, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_use_PrivateKey_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_PrivateKey_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_PrivateKey_file(ctx, file, type)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_PrivateKey_file(ctx, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_certificate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_certificate)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_certificate(s, x)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	X509 *	x = (X509 *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_certificate(s, x);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_certificate_ASN1); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_certificate_ASN1)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_certificate_ASN1(s, d, len)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	unsigned char *	d = (unsigned char *)SvPV_nolen(ST(1));
	long	len = (long)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_certificate_ASN1(s, d, len);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_use_certificate_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_use_certificate_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::use_certificate_file(s, file, type)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_use_certificate_file(s, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_use_certificate_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_certificate_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_certificate_file(ctx, file, type)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_certificate_file(ctx, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_state_string); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_state_string)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::state_string(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_state_string(s);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_rstate_string); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_rstate_string)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::rstate_string(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_rstate_string(s);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_state_string_long); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_state_string_long)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::state_string_long(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_state_string_long(s);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_rstate_string_long); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_rstate_string_long)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::rstate_string_long(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_rstate_string_long(s);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_time); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_time)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_time(ses)");
    {
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_time(ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_time); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_time)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_time(ses, t)");
    {
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(0));
	long	t = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_time(ses, t);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_timeout)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_timeout(ses)");
    {
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_timeout(ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_timeout)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_timeout(ses, t)");
    {
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(0));
	long	t = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_timeout(ses, t);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_copy_session_id); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_copy_session_id)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::copy_session_id(to, from)");
    {
	SSL *	to = (SSL *)SvIV(ST(0));
	SSL *	from = (SSL *)SvIV(ST(1));

	SSL_copy_session_id(to, from);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_read_ahead); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_read_ahead)
{
    dXSARGS;
    if (items < 1 || items > 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_read_ahead(s, yes=1)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	yes;

	if (items < 2)
	    yes = 1;
	else {
	    yes = (int)SvIV(ST(1));
	}

	SSL_set_read_ahead(s, yes);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_get_read_ahead); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_read_ahead)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_read_ahead(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_read_ahead(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_pending); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_pending)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::pending(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_pending(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_cipher_list); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_cipher_list)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_cipher_list(s, str)");
    {
	SSL_CTX *	s = (SSL_CTX *)SvIV(ST(0));
	char *	str = (char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_cipher_list(s, str);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_cipher_list); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_cipher_list)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_cipher_list(s, n)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	n = (int)SvIV(ST(1));
	const char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_cipher_list(s, n);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_cipher_list); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_cipher_list)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_cipher_list(s, str)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	str = (char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_cipher_list(s, str);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_cipher); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_cipher)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_cipher(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	const char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_cipher(s);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_shared_ciphers); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_shared_ciphers)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_shared_ciphers(s, buf, len)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	char *	buf = (char *)SvPV_nolen(ST(1));
	int	len = (int)SvIV(ST(2));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_shared_ciphers(s, buf, len);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_peer_certificate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_peer_certificate)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_peer_certificate(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	X509 *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_peer_certificate(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_verify); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_verify)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_verify(s, mode, callback)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	mode = (int)SvIV(ST(1));
	SV *	callback = ST(2);
#line 2136 "SSLeay.xs"
     if (ssleay_verify_callback == (SV*)NULL)
         ssleay_verify_callback = newSVsv(callback);
     else
         SvSetSV (ssleay_verify_callback, callback);
     if (SvTRUE(ssleay_verify_callback)) {
         SSL_set_verify(s,mode,&ssleay_verify_callback_glue);
     } else {
         SSL_set_verify(s,mode,NULL);
     }
#line 2922 "SSLeay.c"
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_bio); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_bio)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_bio(s, rbio, wbio)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	BIO *	rbio = (BIO *)SvIV(ST(1));
	BIO *	wbio = (BIO *)SvIV(ST(2));

	SSL_set_bio(s, rbio, wbio);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_get_rbio); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_rbio)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_rbio(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_rbio(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_wbio); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_wbio)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_wbio(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_wbio(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_new)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_new()");
    {
	SSL_SESSION *	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_new();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_print); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_print)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_print(fp, ses)");
    {
	BIO *	fp = (BIO *)SvIV(ST(0));
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_print(fp, ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_free(ses)");
    {
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(0));

	SSL_SESSION_free(ses);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_i2d_SSL_SESSION); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_i2d_SSL_SESSION)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::i2d_SSL_SESSION(in, pp)");
    {
	SSL_SESSION *	in = (SSL_SESSION *)SvIV(ST(0));
	unsigned char *	pp = (unsigned char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = i2d_SSL_SESSION(in, &pp);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_session); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_session)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_session(to, ses)");
    {
	SSL *	to = (SSL *)SvIV(ST(0));
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_session(to, ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_d2i_SSL_SESSION); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_d2i_SSL_SESSION)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::d2i_SSL_SESSION(a, pp, length)");
    {
	SSL_SESSION *	a = (SSL_SESSION *)SvIV(ST(0));
	unsigned char *	pp = (unsigned char *)SvPV_nolen(ST(1));
	long	length = (long)SvIV(ST(2));
	SSL_SESSION *	RETVAL;
	dXSTARG;

	RETVAL = d2i_SSL_SESSION(&a, &pp, length);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM30 "SSLeay-0.9.0 defines these as macros. I expand them here for safety's sake"
XS(XS_Net__SSLeay_get_session); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_session)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_session(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	SSL_SESSION *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_session(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_certificate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_certificate)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_certificate(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	X509 *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_certificate(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_SSL_CTX); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_SSL_CTX)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_SSL_CTX(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	SSL_CTX *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_SSL_CTX(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_ctrl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ctrl)
{
    dXSARGS;
    if (items != 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ctrl(ssl, cmd, larg, parg)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	cmd = (int)SvIV(ST(1));
	long	larg = (long)SvIV(ST(2));
	char *	parg = (char *)SvPV_nolen(ST(3));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_ctrl(ssl, cmd, larg, parg);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_ctrl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_ctrl)
{
    dXSARGS;
    if (items != 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_ctrl(ctx, cmd, larg, parg)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	cmd = (int)SvIV(ST(1));
	long	larg = (long)SvIV(ST(2));
	char *	parg = (char *)SvPV_nolen(ST(3));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_ctrl(ctx, cmd, larg, parg);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_options); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_options)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_options(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_options(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_options); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_options)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_options(ssl, op)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	unsigned long	op = (unsigned long)SvUV(ST(1));

	SSL_set_options(ssl, op);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_get_options); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_options)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_options(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_options(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_options); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_options)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_options(ctx, op)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	unsigned long	op = (unsigned long)SvUV(ST(1));

	SSL_CTX_set_options(ctx, op);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_sessions); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sessions)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sessions(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	LHASH *	RETVAL;
	dXSTARG;
#line 2239 "SSLeay.xs"
    /* NOTE: This should be deprecated. Corresponding macro was removed from ssl.h as of 0.9.2 */
     if (ctx == NULL) croak("NULL SSL context passed as argument.");
     RETVAL = ctx -> sessions;
#line 3250 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_number); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_number)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_number(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	unsigned long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_number(ctx);
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_connect); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_connect)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_connect(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_connect(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_connect_good); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_connect_good)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_connect_good(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_connect_good(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_connect_renegotiate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_connect_renegotiate)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_connect_renegotiate(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_connect_renegotiate(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_accept); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_accept)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_accept(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_accept(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_accept_renegotiate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_accept_renegotiate)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_accept_renegotiate(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_accept_renegotiate(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_accept_good); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_accept_good)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_accept_good(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_accept_good(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_hits); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_hits)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_hits(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_hits(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_cb_hits); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_cb_hits)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_cb_hits(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_cb_hits(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_misses); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_misses)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_misses(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_misses(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_timeouts); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_timeouts)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_timeouts(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_timeouts(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_cache_full); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_cache_full)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_cache_full(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_cache_full(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_get_cache_size); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_get_cache_size)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_get_cache_size(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_sess_get_cache_size(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_sess_set_cache_size); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_sess_set_cache_size)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_sess_set_cache_size(ctx, size)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	size = (int)SvIV(ST(1));

	SSL_CTX_sess_set_cache_size(ctx, size);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_want); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_want)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::want(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_want(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_state); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_state)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::state(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_state(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_f_ssl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_f_ssl)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_f_ssl()");
    {
	BIO_METHOD *	RETVAL;
	dXSTARG;

	RETVAL = BIO_f_ssl();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_s_mem); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_s_mem)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_s_mem()");
    {
	BIO_METHOD *	RETVAL;
	dXSTARG;

	RETVAL = BIO_s_mem();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_ERR_get_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_get_error)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_get_error()");
    {
	unsigned long	RETVAL;
	dXSTARG;

	RETVAL = ERR_get_error();
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_ERR_peek_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_peek_error)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_peek_error()");
    {
	unsigned long	RETVAL;
	dXSTARG;

	RETVAL = ERR_peek_error();
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_ERR_put_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_put_error)
{
    dXSARGS;
    if (items != 5)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_put_error(lib, func, reason, file, line)");
    {
	int	lib = (int)SvIV(ST(0));
	int	func = (int)SvIV(ST(1));
	int	reason = (int)SvIV(ST(2));
	char *	file = (char *)SvPV_nolen(ST(3));
	int	line = (int)SvIV(ST(4));

	ERR_put_error(lib, func, reason, file, line);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_ERR_clear_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_clear_error)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_clear_error()");
    {

	ERR_clear_error();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_ERR_error_string); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_error_string)
{
    dXSARGS;
    if (items < 1 || items > 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_error_string(error, buf=NULL)");
    {
	unsigned long	error = (unsigned long)SvUV(ST(0));
	char *	buf;
	char *	RETVAL;
	dXSTARG;

	if (items < 2)
	    buf = NULL;
	else {
	    buf = (char *)SvPV_nolen(ST(1));
	}
#line 2338 "SSLeay.xs"
     RETVAL = ERR_error_string(error,buf);
#line 3640 "SSLeay.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_load_error_strings); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_load_error_strings)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::load_error_strings()");
    {

	SSL_load_error_strings();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_ERR_load_crypto_strings); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_load_crypto_strings)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_load_crypto_strings()");
    {

	ERR_load_crypto_strings();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_SSLeay_add_ssl_algorithms); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SSLeay_add_ssl_algorithms)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SSLeay_add_ssl_algorithms()");
    {

	SSLeay_add_ssl_algorithms();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_ERR_load_SSL_strings); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_load_SSL_strings)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_load_SSL_strings()");
    {

	ERR_load_SSL_strings();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_ERR_load_RAND_strings); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_ERR_load_RAND_strings)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::ERR_load_RAND_strings()");
    {

	ERR_load_RAND_strings();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_RAND_bytes); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_bytes)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_bytes(buf, num)");
    {
	SV *	buf = ST(0);
	int	num = (int)SvIV(ST(1));
#line 2362 "SSLeay.xs"
        int rc;
        unsigned char *random;
#line 3723 "SSLeay.c"
	int	RETVAL;
	dXSTARG;
#line 2365 "SSLeay.xs"
        New(0, random, num, unsigned char);
        rc = RAND_bytes(random, num);
        sv_setpvn(buf, random, num);
        Safefree(random);
        RETVAL = rc;
#line 3732 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_pseudo_bytes); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_pseudo_bytes)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_pseudo_bytes(buf, num)");
    {
	SV *	buf = ST(0);
	int	num = (int)SvIV(ST(1));
#line 2378 "SSLeay.xs"
        int rc;
        unsigned char *random;
#line 3750 "SSLeay.c"
	int	RETVAL;
	dXSTARG;
#line 2381 "SSLeay.xs"
        New(0, random, num, unsigned char);
        rc = RAND_pseudo_bytes(random, num);
        sv_setpvn(buf, random, num);
        Safefree(random);
        RETVAL = rc;
#line 3759 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_add); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_add)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_add(buf, num, entropy)");
    {
	SV *	buf = ST(0);
	int	num = (int)SvIV(ST(1));
	double	entropy = (double)SvNV(ST(2));
#line 2395 "SSLeay.xs"
        STRLEN len;
#line 3777 "SSLeay.c"
#line 2397 "SSLeay.xs"
        RAND_add((const void *)SvPV(buf, len), num, entropy);
#line 3780 "SSLeay.c"
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_RAND_poll); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_poll)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_poll()");
    {
	int	RETVAL;
	dXSTARG;

	RETVAL = RAND_poll();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_status); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_status)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_status()");
    {
	int	RETVAL;
	dXSTARG;

	RETVAL = RAND_status();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_egd_bytes); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_egd_bytes)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_egd_bytes(path, bytes)");
    {
	const char *	path = (const char *)SvPV_nolen(ST(0));
	int	bytes = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = RAND_egd_bytes(path, bytes);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_file_name); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_file_name)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_file_name(num)");
    {
	size_t	num = (size_t)SvUV(ST(0));
#line 2414 "SSLeay.xs"
        char *buf;
#line 3845 "SSLeay.c"
	SV *	RETVAL;
#line 2416 "SSLeay.xs"
        New(0, buf, num, char);
        if (!RAND_file_name(buf, num)) {
            Safefree(buf);
            XSRETURN_UNDEF;
        }
        RETVAL = newSVpv(buf, 0);
        Safefree(buf);
#line 3855 "SSLeay.c"
	ST(0) = RETVAL;
	sv_2mortal(ST(0));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_seed); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_seed)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_seed(buf)");
    {
#line 2429 "SSLeay.xs"
     STRLEN len;
#line 3871 "SSLeay.c"
	char *	buf = SvPV( ST(1), len);
#line 2433 "SSLeay.xs"
     RAND_seed (buf, (int)len);
#line 3875 "SSLeay.c"
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_RAND_cleanup); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_cleanup)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_cleanup()");
    {

	RAND_cleanup();
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_RAND_load_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_load_file)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_load_file(file_name, how_much)");
    {
	char *	file_name = (char *)SvPV_nolen(ST(0));
	int	how_much = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = RAND_load_file(file_name, how_much);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_write_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_write_file)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_write_file(file_name)");
    {
	char *	file_name = (char *)SvPV_nolen(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = RAND_write_file(file_name);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RAND_egd); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RAND_egd)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RAND_egd(path)");
    {
	char *	path = (char *)SvPV_nolen(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = RAND_egd(path);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM40 "Minimal X509 stuff..., this is a bit ugly and should be put in its own modules Net::SSLeay::X509.pm"
XS(XS_Net__SSLeay_X509_get_issuer_name); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_get_issuer_name)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_get_issuer_name(cert)");
    {
	X509 *	cert = (X509 *)SvIV(ST(0));
	X509_NAME *	RETVAL;
	dXSTARG;

	RETVAL = X509_get_issuer_name(cert);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_get_subject_name); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_get_subject_name)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_get_subject_name(cert)");
    {
	X509 *	cert = (X509 *)SvIV(ST(0));
	X509_NAME *	RETVAL;
	dXSTARG;

	RETVAL = X509_get_subject_name(cert);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_NAME_oneline); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_NAME_oneline)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_NAME_oneline(name)");
    {
	X509_NAME *	name = (X509_NAME *)SvIV(ST(0));
#line 2465 "SSLeay.xs"
     char buf[32768];
#line 3990 "SSLeay.c"
#line 2467 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if (X509_NAME_oneline(name, buf, sizeof(buf)))
         sv_setpvn( ST(0), buf, strlen(buf));
#line 3995 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_NAME_get_text_by_NID); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_NAME_get_text_by_NID)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_NAME_get_text_by_NID(name, nid)");
    {
	X509_NAME *	name = (X509_NAME *)SvIV(ST(0));
	int	nid = (int)SvIV(ST(1));
#line 2476 "SSLeay.xs"
     char buf[32768];
#line 4011 "SSLeay.c"
#line 2478 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if (X509_NAME_get_text_by_NID(name, nid, buf, sizeof(buf)))
         sv_setpvn( ST(0), buf, strlen(buf));
#line 4016 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_get_current_cert); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_get_current_cert)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_get_current_cert(x509_store_ctx)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	X509 *	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_CTX_get_current_cert(x509_store_ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_get_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_get_ex_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_get_ex_data(x509_store_ctx, idx)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_CTX_get_ex_data(x509_store_ctx, idx);
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_get_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_get_error)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_get_error(x509_store_ctx)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_CTX_get_error(x509_store_ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_get_error_depth); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_get_error_depth)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_get_error_depth(x509_store_ctx)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_CTX_get_error_depth(x509_store_ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_set_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_set_ex_data)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_set_ex_data(x509_store_ctx, idx, data)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	data = INT2PTR(void *,SvIV(ST(2)));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_CTX_set_ex_data(x509_store_ctx, idx, data);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_set_error); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_set_error)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_set_error(x509_store_ctx, s)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	int	s = (int)SvIV(ST(1));

	X509_STORE_CTX_set_error(x509_store_ctx, s);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_X509_STORE_CTX_set_cert); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_set_cert)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_set_cert(x509_store_ctx, x)");
    {
	X509_STORE_CTX *	x509_store_ctx = (X509_STORE_CTX *)SvIV(ST(0));
	X509 *	x = (X509 *)SvIV(ST(1));

	X509_STORE_CTX_set_cert(x509_store_ctx, x);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_X509_STORE_add_cert); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_add_cert)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_add_cert(ctx, x)");
    {
	X509_STORE *	ctx = (X509_STORE *)SvIV(ST(0));
	X509 *	x = (X509 *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_add_cert(ctx, x);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_add_crl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_add_crl)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_add_crl(ctx, x)");
    {
	X509_STORE *	ctx = (X509_STORE *)SvIV(ST(0));
	X509_CRL *	x = (X509_CRL *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_STORE_add_crl(ctx, x);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_STORE_CTX_set_flags); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_STORE_CTX_set_flags)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_STORE_CTX_set_flags(ctx, flags)");
    {
	X509_STORE_CTX *	ctx = (X509_STORE_CTX *)SvIV(ST(0));
	long	flags = (long)SvIV(ST(1));

	X509_STORE_CTX_set_flags(ctx, flags);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_X509_load_cert_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_load_cert_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_load_cert_file(ctx, file, type)");
    {
	X509_LOOKUP *	ctx = (X509_LOOKUP *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_load_cert_file(ctx, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_load_crl_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_load_crl_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_load_crl_file(ctx, file, type)");
    {
	X509_LOOKUP *	ctx = (X509_LOOKUP *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_load_crl_file(ctx, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_load_cert_crl_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_load_cert_crl_file)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_load_cert_crl_file(ctx, file, type)");
    {
	X509_LOOKUP *	ctx = (X509_LOOKUP *)SvIV(ST(0));
	char *	file = (char *)SvPV_nolen(ST(1));
	int	type = (int)SvIV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = X509_load_cert_crl_file(ctx, file, type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_get_notBefore); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_get_notBefore)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_get_notBefore(cert)");
    {
	X509 *	cert = (X509 *)SvIV(ST(0));
	ASN1_UTCTIME *	RETVAL;
	dXSTARG;

	RETVAL = X509_get_notBefore(cert);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_X509_get_notAfter); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_get_notAfter)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_get_notAfter(cert)");
    {
	X509 *	cert = (X509 *)SvIV(ST(0));
	ASN1_UTCTIME *	RETVAL;
	dXSTARG;

	RETVAL = X509_get_notAfter(cert);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_P_ASN1_UTCTIME_put2string); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_P_ASN1_UTCTIME_put2string)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::P_ASN1_UTCTIME_put2string(tm)");
    {
	ASN1_UTCTIME *	tm = (ASN1_UTCTIME *)SvIV(ST(0));
#line 2561 "SSLeay.xs"
     BIO *bp;
     int i;
     char buffer[256];
#line 4293 "SSLeay.c"
#line 2565 "SSLeay.xs"
     bp = BIO_new(BIO_s_mem());
     ASN1_UTCTIME_print(bp,tm);
     i = BIO_read(bp,buffer,255);
     buffer[i] = '\0';
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if ( i > 0 )
         sv_setpvn( ST(0), buffer, i );
     BIO_free(bp);
#line 4303 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_EVP_PKEY_copy_parameters); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_EVP_PKEY_copy_parameters)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::EVP_PKEY_copy_parameters(to, from)");
    {
	EVP_PKEY *	to = (EVP_PKEY *)SvIV(ST(0));
	EVP_PKEY *	from = (EVP_PKEY *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = EVP_PKEY_copy_parameters(to, from);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_PEM_get_string_X509); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_PEM_get_string_X509)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::PEM_get_string_X509(x509)");
    {
	X509 *	x509 = (X509 *)SvIV(ST(0));
#line 2583 "SSLeay.xs"
     BIO *bp;
     int i;
     char buffer[8196];
#line 4338 "SSLeay.c"
#line 2587 "SSLeay.xs"
     bp = BIO_new(BIO_s_mem());
     PEM_write_bio_X509(bp,x509);
     i = BIO_read(bp,buffer,8195);
     buffer[i] = '\0';
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if ( i > 0 )
         sv_setpvn( ST(0), buffer, i );
     BIO_free(bp);
#line 4348 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_MD5); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_MD5)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::MD5(data)");
    {
#line 2599 "SSLeay.xs"
     STRLEN len;
     unsigned char md[MD5_DIGEST_LENGTH];
     unsigned char * ret;
#line 4364 "SSLeay.c"
	unsigned char *	data = (unsigned char *) SvPV( ST(0), len);
#line 2605 "SSLeay.xs"
     ret = MD5(data,len,md);
     if (ret!=NULL) {
	  XSRETURN_PV((char *) md);
     } else {
	  XSRETURN_UNDEF;
     }
#line 4373 "SSLeay.c"
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_SSLv2_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SSLv2_method)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SSLv2_method()");
    {
	SSL_METHOD *	RETVAL;
	dXSTARG;

	RETVAL = SSLv2_method();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SSLv3_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SSLv3_method)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SSLv3_method()");
    {
	SSL_METHOD *	RETVAL;
	dXSTARG;

	RETVAL = SSLv3_method();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_TLSv1_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_TLSv1_method)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::TLSv1_method()");
    {
	SSL_METHOD *	RETVAL;
	dXSTARG;

	RETVAL = TLSv1_method();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_ssl_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_ssl_method)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_ssl_method(ssl, method)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	SSL_METHOD *	method = (SSL_METHOD *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_ssl_method(ssl, method);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_ssl_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_ssl_method)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_ssl_method(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	SSL_METHOD *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_ssl_method(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM_AUTOMATICALLY_GENERATED_1_09
XS(XS_Net__SSLeay_BIO_new_buffer_ssl_connect); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_new_buffer_ssl_connect)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_new_buffer_ssl_connect(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = BIO_new_buffer_ssl_connect(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_new_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_new_file)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_new_file(filename, mode)");
    {
	char *	filename = (char *)SvPV_nolen(ST(0));
	char *	mode = (char *)SvPV_nolen(ST(1));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = BIO_new_file(filename, mode);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_new_ssl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_new_ssl)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_new_ssl(ctx, client)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	client = (int)SvIV(ST(1));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = BIO_new_ssl(ctx, client);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_new_ssl_connect); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_new_ssl_connect)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_new_ssl_connect(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = BIO_new_ssl_connect(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_new); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_new)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_new(type)");
    {
	BIO_METHOD *	type = (BIO_METHOD *)SvIV(ST(0));
	BIO *	RETVAL;
	dXSTARG;

	RETVAL = BIO_new(type);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_free(bio)");
    {
	BIO *	bio = (BIO *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = BIO_free(bio);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_read); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_read)
{
    dXSARGS;
    if (items < 1 || items > 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_read(s, max=sizeof(buf))");
    {
	BIO *	s = (BIO *)SvIV(ST(0));
#line 2662 "SSLeay.xs"
     char buf[32768];
#line 4576 "SSLeay.c"
	int	max;
#line 2666 "SSLeay.xs"
     int got;
#line 4580 "SSLeay.c"

	if (items < 2)
	    max = sizeof(buf);
	else {
	    max = (int)SvIV(ST(1));
	}
#line 2668 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     if ((got = BIO_read(s, buf, max)) >= 0)
         sv_setpvn( ST(0), buf, got);
#line 4591 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_write); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_write)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_write(s, buf)");
    {
	BIO *	s = (BIO *)SvIV(ST(0));
#line 2677 "SSLeay.xs"
     STRLEN len;
#line 4606 "SSLeay.c"
	char *	buf = SvPV( ST(1), len);
	int	RETVAL;
	dXSTARG;
#line 2681 "SSLeay.xs"
     RETVAL = BIO_write (s, buf, (int)len);
#line 4612 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_eof); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_eof)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_eof(s)");
    {
	BIO *	s = (BIO *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = BIO_eof(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_pending); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_pending)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_pending(s)");
    {
	BIO *	s = (BIO *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = BIO_pending(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_wpending); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_wpending)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_wpending(s)");
    {
	BIO *	s = (BIO *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = BIO_wpending(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_ssl_copy_session_id); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_ssl_copy_session_id)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_ssl_copy_session_id(to, from)");
    {
	BIO *	to = (BIO *)SvIV(ST(0));
	BIO *	from = (BIO *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = BIO_ssl_copy_session_id(to, from);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_BIO_ssl_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_BIO_ssl_shutdown)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::BIO_ssl_shutdown(ssl_bio)");
    {
	BIO *	ssl_bio = (BIO *)SvIV(ST(0));

	BIO_ssl_shutdown(ssl_bio);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_add_client_CA); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_add_client_CA)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::add_client_CA(ssl, x)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	X509 *	x = (X509 *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_add_client_CA(ssl, x);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_alert_desc_string); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_alert_desc_string)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::alert_desc_string(value)");
    {
	int	value = (int)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_alert_desc_string(value);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_alert_desc_string_long); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_alert_desc_string_long)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::alert_desc_string_long(value)");
    {
	int	value = (int)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_alert_desc_string_long(value);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_alert_type_string); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_alert_type_string)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::alert_type_string(value)");
    {
	int	value = (int)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_alert_type_string(value);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_alert_type_string_long); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_alert_type_string_long)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::alert_type_string_long(value)");
    {
	int	value = (int)SvIV(ST(0));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_alert_type_string_long(value);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_callback_ctrl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_callback_ctrl)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::callback_ctrl(ssl, i, fp)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	i = (int)SvIV(ST(1));
	callback_no_ret *	fp = (callback_no_ret *)SvIV(ST(2));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_callback_ctrl(ssl, i, fp);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_check_private_key); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_check_private_key)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::check_private_key(ctx)");
    {
	SSL *	ctx = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_check_private_key(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CIPHER_description); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CIPHER_description)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CIPHER_description(cipher, buf, size)");
    {
	SSL_CIPHER *	cipher = (SSL_CIPHER *)SvIV(ST(0));
	char *	buf = (char *)SvPV_nolen(ST(1));
	int	size = (int)SvIV(ST(2));
	char *	RETVAL;
	dXSTARG;

	RETVAL = SSL_CIPHER_description(cipher, buf, size);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CIPHER_get_bits); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CIPHER_get_bits)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CIPHER_get_bits(c, alg_bits)");
    {
	SSL_CIPHER *	c = (SSL_CIPHER *)SvIV(ST(0));
	int *	alg_bits = (int *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CIPHER_get_bits(c, alg_bits);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_COMP_add_compression_method); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_COMP_add_compression_method)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::COMP_add_compression_method(id, cm)");
    {
	int	id = (int)SvIV(ST(0));
	COMP_METHOD *	cm = (COMP_METHOD *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_COMP_add_compression_method(id, cm);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_add_client_CA); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_add_client_CA)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_add_client_CA(ctx, x)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	X509 *	x = (X509 *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_add_client_CA(ctx, x);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_callback_ctrl); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_callback_ctrl)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_callback_ctrl(ctx, i, fp)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	i = (int)SvIV(ST(1));
	callback_no_ret *	fp = (callback_no_ret *)SvIV(ST(2));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_callback_ctrl(ctx, i, fp);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_check_private_key); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_check_private_key)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_check_private_key(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_check_private_key(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_ex_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_ex_data(ssl, idx)");
    {
	SSL_CTX *	ssl = (SSL_CTX *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_ex_data(ssl, idx);
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_quiet_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_quiet_shutdown)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_quiet_shutdown(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_quiet_shutdown(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_timeout)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_timeout(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_timeout(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_verify_depth); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_verify_depth)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_verify_depth(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_verify_depth(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_verify_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_verify_mode)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_verify_mode(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_verify_mode(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_cert_store); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_cert_store)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_cert_store(ctx, store)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	X509_STORE *	store = (X509_STORE *)SvIV(ST(1));

	SSL_CTX_set_cert_store(ctx, store);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_get_cert_store); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_cert_store)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_cert_store(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	X509_STORE *	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_cert_store(ctx);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_cert_verify_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_cert_verify_callback)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_cert_verify_callback(ctx, cb, arg)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	callback_ret_int *	cb = (callback_ret_int *)SvIV(ST(1));
	char *	arg = (char *)SvPV_nolen(ST(2));

	SSL_CTX_set_cert_verify_callback(ctx, cb, arg);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_client_CA_list); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_client_CA_list)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_client_CA_list(ctx, list)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	X509_NAME_STACK *	list = (X509_NAME_STACK *)SvIV(ST(1));

	SSL_CTX_set_client_CA_list(ctx, list);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_default_passwd_cb); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_default_passwd_cb)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_default_passwd_cb(ctx, cb)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	SV *	cb = ST(1);
#line 2814 "SSLeay.xs"
     if (ssleay_ctx_set_default_passwd_cb_callback == (SV*)NULL) {
        ssleay_ctx_set_default_passwd_cb_callback = newSVsv(cb);
     } else {
         SvSetSV (ssleay_ctx_set_default_passwd_cb_callback, cb);
     }
     if (SvTRUE(ssleay_ctx_set_default_passwd_cb_callback)) {
         SSL_CTX_set_default_passwd_cb(ctx,&ssleay_ctx_set_default_passwd_cb_callback_glue);
     } else {
         SSL_CTX_set_default_passwd_cb(ctx,NULL);
     }
#line 5101 "SSLeay.c"
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_default_passwd_cb_userdata); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_default_passwd_cb_userdata)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_default_passwd_cb_userdata(ctx, u)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	void *	u = INT2PTR(void *,SvIV(ST(1)));

	SSL_CTX_set_default_passwd_cb_userdata(ctx, u);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_ex_data)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_ex_data(ssl, idx, data)");
    {
	SSL_CTX *	ssl = (SSL_CTX *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	data = INT2PTR(void *,SvIV(ST(2)));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_ex_data(ssl, idx, data);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_purpose); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_purpose)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_purpose(s, purpose)");
    {
	SSL_CTX *	s = (SSL_CTX *)SvIV(ST(0));
	int	purpose = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_purpose(s, purpose);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_quiet_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_quiet_shutdown)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_quiet_shutdown(ctx, mode)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	mode = (int)SvIV(ST(1));

	SSL_CTX_set_quiet_shutdown(ctx, mode);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_ssl_version); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_ssl_version)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_ssl_version(ctx, meth)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	SSL_METHOD *	meth = (SSL_METHOD *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_ssl_version(ctx, meth);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_timeout)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_timeout(ctx, t)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	t = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_timeout(ctx, t);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_trust); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_trust)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_trust(s, trust)");
    {
	SSL_CTX *	s = (SSL_CTX *)SvIV(ST(0));
	int	trust = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_trust(s, trust);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_verify_depth); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_verify_depth)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_verify_depth(ctx, depth)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	int	depth = (int)SvIV(ST(1));

	SSL_CTX_set_verify_depth(ctx, depth);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_use_certificate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_certificate)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_certificate(ctx, x)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	X509 *	x = (X509 *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_certificate(ctx, x);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_use_certificate_chain_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_certificate_chain_file)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_certificate_chain_file(ctx, file)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	const char *	file = (const char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_certificate_chain_file(ctx, file);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_use_PrivateKey); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_PrivateKey)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_PrivateKey(ctx, pkey)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	EVP_PKEY *	pkey = (EVP_PKEY *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_PrivateKey(ctx, pkey);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_use_RSAPrivateKey); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_use_RSAPrivateKey)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_use_RSAPrivateKey(ctx, rsa)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	RSA *	rsa = (RSA *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_use_RSAPrivateKey(ctx, rsa);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_do_handshake); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_do_handshake)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::do_handshake(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_do_handshake(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_dup); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_dup)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::dup(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	SSL *	RETVAL;
	dXSTARG;

	RETVAL = SSL_dup(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_current_cipher); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_current_cipher)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_current_cipher(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	SSL_CIPHER *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_current_cipher(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_default_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_default_timeout)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_default_timeout(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_default_timeout(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_ex_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_ex_data(ssl, idx)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_ex_data(ssl, idx);
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_finished); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_finished)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_finished(s, buf, count)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	void *	buf = INT2PTR(void *,SvIV(ST(1)));
	size_t	count = (size_t)SvUV(ST(2));
	size_t	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_finished(s, buf, count);
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_peer_finished); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_peer_finished)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_peer_finished(s, buf, count)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	void *	buf = INT2PTR(void *,SvIV(ST(1)));
	size_t	count = (size_t)SvUV(ST(2));
	size_t	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_peer_finished(s, buf, count);
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_quiet_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_quiet_shutdown)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_quiet_shutdown(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_quiet_shutdown(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_shutdown)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_shutdown(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_shutdown(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_verify_depth); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_verify_depth)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_verify_depth(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_verify_depth(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_verify_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_verify_mode)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_verify_mode(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_verify_mode(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_verify_result); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_verify_result)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_verify_result(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_verify_result(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_library_init); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_library_init)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::library_init()");
    {
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_library_init();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_renegotiate); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_renegotiate)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::renegotiate(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_renegotiate(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_cmp); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_cmp)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_cmp(a, b)");
    {
	SSL_SESSION *	a = (SSL_SESSION *)SvIV(ST(0));
	SSL_SESSION *	b = (SSL_SESSION *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_cmp(a, b);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_get_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_get_ex_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_get_ex_data(ss, idx)");
    {
	SSL_SESSION *	ss = (SSL_SESSION *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_get_ex_data(ss, idx);
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_get_time); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_get_time)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_get_time(s)");
    {
	SSL_SESSION *	s = (SSL_SESSION *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_get_time(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_get_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_get_timeout)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_get_timeout(s)");
    {
	SSL_SESSION *	s = (SSL_SESSION *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_get_timeout(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_print_fp); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_print_fp)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_print_fp(fp, ses)");
    {
	FILE *	fp = PerlIO_findFILE(IoIFP(sv_2io(ST(0))));
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_print_fp(fp, ses);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_set_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_set_ex_data)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_set_ex_data(ss, idx, data)");
    {
	SSL_SESSION *	ss = (SSL_SESSION *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	data = INT2PTR(void *,SvIV(ST(2)));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_set_ex_data(ss, idx, data);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_set_time); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_set_time)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_set_time(s, t)");
    {
	SSL_SESSION *	s = (SSL_SESSION *)SvIV(ST(0));
	long	t = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_set_time(s, t);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_set_timeout); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_set_timeout)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_set_timeout(s, t)");
    {
	SSL_SESSION *	s = (SSL_SESSION *)SvIV(ST(0));
	long	t = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_set_timeout(s, t);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_accept_state); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_accept_state)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_accept_state(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));

	SSL_set_accept_state(s);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_client_CA_list); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_client_CA_list)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_client_CA_list(s, list)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	X509_NAME_STACK *	list = (X509_NAME_STACK *)SvIV(ST(1));

	SSL_set_client_CA_list(s, list);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_connect_state); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_connect_state)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_connect_state(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));

	SSL_set_connect_state(s);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_ex_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_ex_data)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_ex_data(ssl, idx, data)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	idx = (int)SvIV(ST(1));
	void *	data = INT2PTR(void *,SvIV(ST(2)));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_ex_data(ssl, idx, data);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_info_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_info_callback)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_info_callback(ssl, cb)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	callback_no_ret *	cb = (callback_no_ret *)SvIV(ST(1));

	SSL_set_info_callback(ssl, cb);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_purpose); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_purpose)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_purpose(s, purpose)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	purpose = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_purpose(s, purpose);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_quiet_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_quiet_shutdown)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_quiet_shutdown(ssl, mode)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	mode = (int)SvIV(ST(1));

	SSL_set_quiet_shutdown(ssl, mode);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_shutdown)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_shutdown(ssl, mode)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	mode = (int)SvIV(ST(1));

	SSL_set_shutdown(ssl, mode);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_trust); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_trust)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_trust(s, trust)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	trust = (int)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_trust(s, trust);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_verify_depth); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_verify_depth)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_verify_depth(s, depth)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	depth = (int)SvIV(ST(1));

	SSL_set_verify_depth(s, depth);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_verify_result); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_verify_result)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_verify_result(ssl, v)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	v = (long)SvIV(ST(1));

	SSL_set_verify_result(ssl, v);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_shutdown); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_shutdown)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::shutdown(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_shutdown(s);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_version); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_version)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::version(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_version(ssl);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM_MANUALLY_ADDED_1_09
XS(XS_Net__SSLeay_load_client_CA_file); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_load_client_CA_file)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::load_client_CA_file(file)");
    {
	const char *	file = (const char *)SvPV_nolen(ST(0));
	X509_NAME_STACK *	RETVAL;
	dXSTARG;

	RETVAL = SSL_load_client_CA_file(file);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_add_file_cert_subjects_to_stack); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_add_file_cert_subjects_to_stack)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::add_file_cert_subjects_to_stack(stackCAs, file)");
    {
	X509_NAME_STACK *	stackCAs = (X509_NAME_STACK *)SvIV(ST(0));
	const char *	file = (const char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_add_file_cert_subjects_to_stack(stackCAs, file);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#ifndef WIN32
#ifndef VMS
#ifndef MAC_OS_pre_X
#define XSubPPtmpAAAD 1

XS(XS_Net__SSLeay_add_dir_cert_subjects_to_stack); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_add_dir_cert_subjects_to_stack)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::add_dir_cert_subjects_to_stack(stackCAs, dir)");
    {
	X509_NAME_STACK *	stackCAs = (X509_NAME_STACK *)SvIV(ST(0));
	const char *	dir = (const char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_add_dir_cert_subjects_to_stack(stackCAs, dir);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#endif
#endif
#endif
XS(XS_Net__SSLeay_CTX_get_ex_new_index); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_ex_new_index)
{
    dXSARGS;
    if (items != 5)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_ex_new_index(argl, argp, new_func, dup_func, free_func)");
    {
	long	argl = (long)SvIV(ST(0));
	void *	argp = INT2PTR(void *,SvIV(ST(1)));
	CRYPTO_EX_new *	new_func = (CRYPTO_EX_new *)SvIV(ST(2));
	CRYPTO_EX_dup *	dup_func = (CRYPTO_EX_dup *)SvIV(ST(3));
	CRYPTO_EX_free *	free_func = (CRYPTO_EX_free *)SvIV(ST(4));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_get_ex_new_index(argl, argp, new_func, dup_func, free_func);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_session_id_context); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_session_id_context)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_session_id_context(ctx, sid_ctx, sid_ctx_len)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	const unsigned char *	sid_ctx = (const unsigned char *)SvPV_nolen(ST(1));
	unsigned int	sid_ctx_len = (unsigned int)SvUV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_session_id_context(ctx, sid_ctx, sid_ctx_len);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_session_id_context); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_session_id_context)
{
    dXSARGS;
    if (items != 3)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_session_id_context(ssl, sid_ctx, sid_ctx_len)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	const unsigned char *	sid_ctx = (const unsigned char *)SvPV_nolen(ST(1));
	unsigned int	sid_ctx_len = (unsigned int)SvUV(ST(2));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_set_session_id_context(ssl, sid_ctx, sid_ctx_len);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_tmp_rsa_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_tmp_rsa_callback)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_tmp_rsa_callback(ctx, cb)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	cb_ssl_int_int_ret_RSA *	cb = (cb_ssl_int_int_ret_RSA *)SvIV(ST(1));

	SSL_CTX_set_tmp_rsa_callback(ctx, cb);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_tmp_rsa_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_tmp_rsa_callback)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_tmp_rsa_callback(ssl, cb)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	cb_ssl_int_int_ret_RSA *	cb = (cb_ssl_int_int_ret_RSA *)SvIV(ST(1));

	SSL_set_tmp_rsa_callback(ssl, cb);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_CTX_set_tmp_dh_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_tmp_dh_callback)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_tmp_dh_callback(ctx, dh)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	cb_ssl_int_int_ret_DH *	dh = (cb_ssl_int_int_ret_DH *)SvIV(ST(1));

	SSL_CTX_set_tmp_dh_callback(ctx, dh);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_set_tmp_dh_callback); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_tmp_dh_callback)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_tmp_dh_callback(ssl, dh)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	cb_ssl_int_int_ret_DH *	dh = (cb_ssl_int_int_ret_DH *)SvIV(ST(1));

	SSL_set_tmp_dh_callback(ssl, dh);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_get_ex_new_index); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_ex_new_index)
{
    dXSARGS;
    if (items != 5)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_ex_new_index(argl, argp, new_func, dup_func, free_func)");
    {
	long	argl = (long)SvIV(ST(0));
	void *	argp = INT2PTR(void *,SvIV(ST(1)));
	CRYPTO_EX_new *	new_func = (CRYPTO_EX_new *)SvIV(ST(2));
	CRYPTO_EX_dup *	dup_func = (CRYPTO_EX_dup *)SvIV(ST(3));
	CRYPTO_EX_free *	free_func = (CRYPTO_EX_free *)SvIV(ST(4));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_get_ex_new_index(argl, argp, new_func, dup_func, free_func);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_get_ex_new_index); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_get_ex_new_index)
{
    dXSARGS;
    if (items != 5)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_get_ex_new_index(argl, argp, new_func, dup_func, free_func)");
    {
	long	argl = (long)SvIV(ST(0));
	void *	argp = INT2PTR(void *,SvIV(ST(1)));
	CRYPTO_EX_new *	new_func = (CRYPTO_EX_new *)SvIV(ST(2));
	CRYPTO_EX_dup *	dup_func = (CRYPTO_EX_dup *)SvIV(ST(3));
	CRYPTO_EX_free *	free_func = (CRYPTO_EX_free *)SvIV(ST(4));
	int	RETVAL;
	dXSTARG;

	RETVAL = SSL_SESSION_get_ex_new_index(argl, argp, new_func, dup_func, free_func);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#define REM_SEMIAUTOMATIC_MACRO_GEN_1_09
XS(XS_Net__SSLeay_OpenSSL_add_ssl_algorithms); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_OpenSSL_add_ssl_algorithms)
{
    dXSARGS;
    if (items != 0)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::OpenSSL_add_ssl_algorithms()");
    {
	int	RETVAL;
	dXSTARG;
#line 3132 "SSLeay.xs"
  RETVAL = SSL_library_init();
#line 6141 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_clear_num_renegotiations); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_clear_num_renegotiations)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::clear_num_renegotiations(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3140 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_CLEAR_NUM_RENEGOTIATIONS,0,NULL);
#line 6159 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_add_extra_chain_cert); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_add_extra_chain_cert)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_add_extra_chain_cert(ctx, x509)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	X509 *	x509 = (X509 *)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3149 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_EXTRA_CHAIN_CERT,0,(char*)x509);
#line 6178 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_app_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_app_data)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_app_data(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	void *	RETVAL;
	dXSTARG;
#line 3157 "SSLeay.xs"
  RETVAL = SSL_CTX_get_ex_data(ctx,0);
#line 6196 "SSLeay.c"
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_mode)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_mode(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3165 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_MODE,0,NULL);
#line 6214 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_read_ahead); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_read_ahead)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_read_ahead(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3173 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_GET_READ_AHEAD,0,NULL);
#line 6232 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_get_session_cache_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_get_session_cache_mode)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_get_session_cache_mode(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3181 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_GET_SESS_CACHE_MODE,0,NULL);
#line 6250 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_need_tmp_RSA); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_need_tmp_RSA)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_need_tmp_RSA(ctx)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3189 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_NEED_TMP_RSA,0,NULL);
#line 6268 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_app_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_app_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_app_data(ctx, arg)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	char *	arg = (char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;
#line 3198 "SSLeay.xs"
  RETVAL = SSL_CTX_set_ex_data(ctx,0,arg);
#line 6287 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_mode)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_mode(ctx, op)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	op = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3207 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_MODE,op,NULL);
#line 6306 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_read_ahead); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_read_ahead)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_read_ahead(ctx, m)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	m = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3216 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_SET_READ_AHEAD,m,NULL);
#line 6325 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_session_cache_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_session_cache_mode)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_session_cache_mode(ctx, m)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	long	m = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3225 "SSLeay.xs"
  RETVAL = SSL_CTX_ctrl(ctx,SSL_CTRL_SET_SESS_CACHE_MODE,m,NULL);
#line 6344 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_tmp_dh); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_tmp_dh)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_tmp_dh(ctx, dh)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	DH *	dh = (DH *)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_tmp_dh(ctx, dh);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_CTX_set_tmp_rsa); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_CTX_set_tmp_rsa)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::CTX_set_tmp_rsa(ctx, rsa)");
    {
	SSL_CTX *	ctx = (SSL_CTX *)SvIV(ST(0));
	RSA *	rsa = (RSA *)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;

	RETVAL = SSL_CTX_set_tmp_rsa(ctx, rsa);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_app_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_app_data)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_app_data(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	void *	RETVAL;
	dXSTARG;
#line 3243 "SSLeay.xs"
  RETVAL = SSL_get_ex_data(s,0);
#line 6398 "SSLeay.c"
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_cipher_bits); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_cipher_bits)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_cipher_bits(s, np)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	int *	np = (int *)SvIV(ST(1));
	int	RETVAL;
	dXSTARG;
#line 3252 "SSLeay.xs"
  RETVAL = SSL_CIPHER_get_bits(SSL_get_current_cipher(s),np);
#line 6417 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_mode)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_mode(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3260 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_MODE,0,NULL);
#line 6435 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_state); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_state)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_state(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	int	RETVAL;
	dXSTARG;
#line 3268 "SSLeay.xs"
  RETVAL = SSL_state(ssl);
#line 6453 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_need_tmp_RSA); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_need_tmp_RSA)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::need_tmp_RSA(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3276 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_NEED_TMP_RSA,0,NULL);
#line 6471 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_num_renegotiations); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_num_renegotiations)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::num_renegotiations(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3284 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_GET_NUM_RENEGOTIATIONS,0,NULL);
#line 6489 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_get_app_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_get_app_data)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_get_app_data(ses)");
    {
	SSL_SESSION *	ses = (SSL_SESSION *)SvIV(ST(0));
	void *	RETVAL;
	dXSTARG;
#line 3292 "SSLeay.xs"
  RETVAL = SSL_SESSION_get_ex_data(ses,0);
#line 6507 "SSLeay.c"
	XSprePUSH; PUSHi(PTR2IV(RETVAL));
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_session_reused); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_session_reused)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::session_reused(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3300 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_GET_SESSION_REUSED,0,NULL);
#line 6525 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_set_app_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_set_app_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_set_app_data(s, a)");
    {
	SSL_SESSION *	s = (SSL_SESSION *)SvIV(ST(0));
	void *	a = INT2PTR(void *,SvIV(ST(1)));
	int	RETVAL;
	dXSTARG;
#line 3309 "SSLeay.xs"
  RETVAL = SSL_SESSION_set_ex_data(s,0,(char *)a);
#line 6544 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_app_data); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_app_data)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_app_data(s, arg)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	void *	arg = INT2PTR(void *,SvIV(ST(1)));
	int	RETVAL;
	dXSTARG;
#line 3318 "SSLeay.xs"
  RETVAL = SSL_set_ex_data(s,0,(char *)arg);
#line 6563 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_mode); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_mode)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_mode(ssl, op)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	op = (long)SvIV(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3327 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_MODE,op,NULL);
#line 6582 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_pref_cipher); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_pref_cipher)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_pref_cipher(s, n)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
	const char *	n = (const char *)SvPV_nolen(ST(1));
	int	RETVAL;
	dXSTARG;
#line 3336 "SSLeay.xs"
  RETVAL = SSL_set_cipher_list(s,n);
#line 6601 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_tmp_dh); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_tmp_dh)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_tmp_dh(ssl, dh)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	char *	dh = (char *)SvPV_nolen(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3345 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH,0,(char *)dh);
#line 6620 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_set_tmp_rsa); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_set_tmp_rsa)
{
    dXSARGS;
    if (items != 2)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::set_tmp_rsa(ssl, rsa)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	char *	rsa = (char *)SvPV_nolen(ST(1));
	long	RETVAL;
	dXSTARG;
#line 3354 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_SET_TMP_RSA,0,(char *)rsa);
#line 6639 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RSA_generate_key); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RSA_generate_key)
{
    dXSARGS;
    if (items < 2 || items > 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RSA_generate_key(bits, e, callback=NULL, cb_arg=NULL)");
    {
	int	bits = (int)SvIV(ST(0));
	unsigned long	e = (unsigned long)SvUV(ST(1));
	void *	callback;
	void *	cb_arg;
	RSA *	RETVAL;
	dXSTARG;

	if (items < 3)
	    callback = NULL;
	else {
	    callback = INT2PTR(void *,SvIV(ST(2)));
	}

	if (items < 4)
	    cb_arg = NULL;
	else {
	    cb_arg = INT2PTR(void *,SvIV(ST(3)));
	}

	RETVAL = RSA_generate_key(bits, e, callback, cb_arg);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_RSA_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_RSA_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::RSA_free(r)");
    {
	RSA *	r = (RSA *)SvIV(ST(0));

	RSA_free(r);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_X509_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_X509_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::X509_free(a)");
    {
	X509 *	a = (X509 *)SvIV(ST(0));

	X509_free(a);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_PEM_read_bio_DHparams); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_PEM_read_bio_DHparams)
{
    dXSARGS;
    if (items < 1 || items > 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::PEM_read_bio_DHparams(bio, x=NULL, cb=NULL, u=NULL)");
    {
	BIO *	bio = (BIO *)SvIV(ST(0));
	void *	x;
	void *	cb;
	void *	u;
	DH *	RETVAL;
	dXSTARG;

	if (items < 2)
	    x = NULL;
	else {
	    x = INT2PTR(void *,SvIV(ST(1)));
	}

	if (items < 3)
	    cb = NULL;
	else {
	    cb = INT2PTR(void *,SvIV(ST(2)));
	}

	if (items < 4)
	    u = NULL;
	else {
	    u = INT2PTR(void *,SvIV(ST(3)));
	}

	RETVAL = PEM_read_bio_DHparams(bio, x, cb, u);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_PEM_read_bio_X509_CRL); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_PEM_read_bio_X509_CRL)
{
    dXSARGS;
    if (items < 1 || items > 4)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::PEM_read_bio_X509_CRL(bio, x=NULL, cb=NULL, u=NULL)");
    {
	BIO *	bio = (BIO *)SvIV(ST(0));
	void *	x;
	void *	cb;
	void *	u;
	X509_CRL *	RETVAL;
	dXSTARG;

	if (items < 2)
	    x = NULL;
	else {
	    x = INT2PTR(void *,SvIV(ST(1)));
	}

	if (items < 3)
	    cb = NULL;
	else {
	    cb = INT2PTR(void *,SvIV(ST(2)));
	}

	if (items < 4)
	    u = NULL;
	else {
	    u = INT2PTR(void *,SvIV(ST(3)));
	}

	RETVAL = PEM_read_bio_X509_CRL(bio, x, cb, u);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_DH_free); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_DH_free)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::DH_free(dh)");
    {
	DH *	dh = (DH *)SvIV(ST(0));

	DH_free(dh);
    }
    XSRETURN_EMPTY;
}

XS(XS_Net__SSLeay_total_renegotiations); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_total_renegotiations)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::total_renegotiations(ssl)");
    {
	SSL *	ssl = (SSL *)SvIV(ST(0));
	long	RETVAL;
	dXSTARG;
#line 3395 "SSLeay.xs"
  RETVAL = SSL_ctrl(ssl,SSL_CTRL_GET_TOTAL_RENEGOTIATIONS,0,NULL);
#line 6807 "SSLeay.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_SESSION_get_master_key); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_SESSION_get_master_key)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::SESSION_get_master_key(s)");
    {
	SSL_SESSION *	s = (SSL_SESSION *)SvIV(ST(0));
#line 3403 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     sv_setpvn(ST(0), s->master_key, s->master_key_length);
#line 6824 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_client_random); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_client_random)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_client_random(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
#line 3410 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     sv_setpvn(ST(0), s->s3->client_random, SSL3_RANDOM_SIZE);
#line 6840 "SSLeay.c"
    }
    XSRETURN(1);
}

XS(XS_Net__SSLeay_get_server_random); /* prototype to pass -Wmissing-prototypes */
XS(XS_Net__SSLeay_get_server_random)
{
    dXSARGS;
    if (items != 1)
	Perl_croak(aTHX_ "Usage: Net::SSLeay::get_server_random(s)");
    {
	SSL *	s = (SSL *)SvIV(ST(0));
#line 3417 "SSLeay.xs"
     ST(0) = sv_newmortal();   /* Undefined to start with */
     sv_setpvn(ST(0), s->s3->server_random, SSL3_RANDOM_SIZE);
#line 6856 "SSLeay.c"
    }
    XSRETURN(1);
}

#define REM_EOF "/* EOF - SSLeay.xs */"
#ifdef __cplusplus
extern "C"
#endif
XS(boot_Net__SSLeay); /* prototype to pass -Wmissing-prototypes */
XS(boot_Net__SSLeay)
{
    dXSARGS;
    char* file = __FILE__;

    XS_VERSION_BOOTCHECK ;

        newXSproto("Net::SSLeay::constant", XS_Net__SSLeay_constant, file, "$");
        newXSproto("Net::SSLeay::hello", XS_Net__SSLeay_hello, file, "");
        newXSproto("Net::SSLeay::CTX_new", XS_Net__SSLeay_CTX_new, file, "");
        newXSproto("Net::SSLeay::CTX_v2_new", XS_Net__SSLeay_CTX_v2_new, file, "");
        newXSproto("Net::SSLeay::CTX_v3_new", XS_Net__SSLeay_CTX_v3_new, file, "");
        newXSproto("Net::SSLeay::CTX_v23_new", XS_Net__SSLeay_CTX_v23_new, file, "");
        newXSproto("Net::SSLeay::CTX_tlsv1_new", XS_Net__SSLeay_CTX_tlsv1_new, file, "");
        newXSproto("Net::SSLeay::CTX_new_with_method", XS_Net__SSLeay_CTX_new_with_method, file, "$");
        newXSproto("Net::SSLeay::CTX_free", XS_Net__SSLeay_CTX_free, file, "$");
        newXSproto("Net::SSLeay::CTX_add_session", XS_Net__SSLeay_CTX_add_session, file, "$$");
        newXSproto("Net::SSLeay::CTX_remove_session", XS_Net__SSLeay_CTX_remove_session, file, "$$");
        newXSproto("Net::SSLeay::CTX_flush_sessions", XS_Net__SSLeay_CTX_flush_sessions, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_default_verify_paths", XS_Net__SSLeay_CTX_set_default_verify_paths, file, "$");
        newXSproto("Net::SSLeay::CTX_load_verify_locations", XS_Net__SSLeay_CTX_load_verify_locations, file, "$$$");
        newXSproto("Net::SSLeay::CTX_set_verify", XS_Net__SSLeay_CTX_set_verify, file, "$$$");
        newXSproto("Net::SSLeay::get_error", XS_Net__SSLeay_get_error, file, "$$");
        newXSproto("Net::SSLeay::new", XS_Net__SSLeay_new, file, "$");
        newXSproto("Net::SSLeay::free", XS_Net__SSLeay_free, file, "$");
#if XSubPPtmpAAAA
        newXSproto("Net::SSLeay::debug", XS_Net__SSLeay_debug, file, "$");
#endif
        newXSproto("Net::SSLeay::accept", XS_Net__SSLeay_accept, file, "$");
        newXSproto("Net::SSLeay::clear", XS_Net__SSLeay_clear, file, "$");
        newXSproto("Net::SSLeay::connect", XS_Net__SSLeay_connect, file, "$");
#if XSubPPtmpAAAB
        newXSproto("Net::SSLeay::set_fd", XS_Net__SSLeay_set_fd, file, "$$");
        newXSproto("Net::SSLeay::set_rfd", XS_Net__SSLeay_set_rfd, file, "$$");
        newXSproto("Net::SSLeay::set_wfd", XS_Net__SSLeay_set_wfd, file, "$$");
#endif
#if XSubPPtmpAAAC
        newXSproto("Net::SSLeay::set_fd", XS_Net__SSLeay_set_fd, file, "$$");
        newXSproto("Net::SSLeay::set_rfd", XS_Net__SSLeay_set_rfd, file, "$$");
        newXSproto("Net::SSLeay::set_wfd", XS_Net__SSLeay_set_wfd, file, "$$");
#endif
        newXSproto("Net::SSLeay::get_fd", XS_Net__SSLeay_get_fd, file, "$");
        newXSproto("Net::SSLeay::read", XS_Net__SSLeay_read, file, "$;$");
        newXSproto("Net::SSLeay::peek", XS_Net__SSLeay_peek, file, "$;$");
        newXSproto("Net::SSLeay::write", XS_Net__SSLeay_write, file, "$$");
        newXSproto("Net::SSLeay::write_partial", XS_Net__SSLeay_write_partial, file, "$$$$");
        newXSproto("Net::SSLeay::use_RSAPrivateKey", XS_Net__SSLeay_use_RSAPrivateKey, file, "$$");
        newXSproto("Net::SSLeay::use_RSAPrivateKey_ASN1", XS_Net__SSLeay_use_RSAPrivateKey_ASN1, file, "$$$");
        newXSproto("Net::SSLeay::use_RSAPrivateKey_file", XS_Net__SSLeay_use_RSAPrivateKey_file, file, "$$$");
        newXSproto("Net::SSLeay::CTX_use_RSAPrivateKey_file", XS_Net__SSLeay_CTX_use_RSAPrivateKey_file, file, "$$$");
        newXSproto("Net::SSLeay::use_PrivateKey", XS_Net__SSLeay_use_PrivateKey, file, "$$");
        newXSproto("Net::SSLeay::use_PrivateKey_ASN1", XS_Net__SSLeay_use_PrivateKey_ASN1, file, "$$$$");
        newXSproto("Net::SSLeay::use_PrivateKey_file", XS_Net__SSLeay_use_PrivateKey_file, file, "$$$");
        newXSproto("Net::SSLeay::CTX_use_PrivateKey_file", XS_Net__SSLeay_CTX_use_PrivateKey_file, file, "$$$");
        newXSproto("Net::SSLeay::use_certificate", XS_Net__SSLeay_use_certificate, file, "$$");
        newXSproto("Net::SSLeay::use_certificate_ASN1", XS_Net__SSLeay_use_certificate_ASN1, file, "$$$");
        newXSproto("Net::SSLeay::use_certificate_file", XS_Net__SSLeay_use_certificate_file, file, "$$$");
        newXSproto("Net::SSLeay::CTX_use_certificate_file", XS_Net__SSLeay_CTX_use_certificate_file, file, "$$$");
        newXSproto("Net::SSLeay::state_string", XS_Net__SSLeay_state_string, file, "$");
        newXSproto("Net::SSLeay::rstate_string", XS_Net__SSLeay_rstate_string, file, "$");
        newXSproto("Net::SSLeay::state_string_long", XS_Net__SSLeay_state_string_long, file, "$");
        newXSproto("Net::SSLeay::rstate_string_long", XS_Net__SSLeay_rstate_string_long, file, "$");
        newXSproto("Net::SSLeay::get_time", XS_Net__SSLeay_get_time, file, "$");
        newXSproto("Net::SSLeay::set_time", XS_Net__SSLeay_set_time, file, "$$");
        newXSproto("Net::SSLeay::get_timeout", XS_Net__SSLeay_get_timeout, file, "$");
        newXSproto("Net::SSLeay::set_timeout", XS_Net__SSLeay_set_timeout, file, "$$");
        newXSproto("Net::SSLeay::copy_session_id", XS_Net__SSLeay_copy_session_id, file, "$$");
        newXSproto("Net::SSLeay::set_read_ahead", XS_Net__SSLeay_set_read_ahead, file, "$;$");
        newXSproto("Net::SSLeay::get_read_ahead", XS_Net__SSLeay_get_read_ahead, file, "$");
        newXSproto("Net::SSLeay::pending", XS_Net__SSLeay_pending, file, "$");
        newXSproto("Net::SSLeay::CTX_set_cipher_list", XS_Net__SSLeay_CTX_set_cipher_list, file, "$$");
        newXSproto("Net::SSLeay::get_cipher_list", XS_Net__SSLeay_get_cipher_list, file, "$$");
        newXSproto("Net::SSLeay::set_cipher_list", XS_Net__SSLeay_set_cipher_list, file, "$$");
        newXSproto("Net::SSLeay::get_cipher", XS_Net__SSLeay_get_cipher, file, "$");
        newXSproto("Net::SSLeay::get_shared_ciphers", XS_Net__SSLeay_get_shared_ciphers, file, "$$$");
        newXSproto("Net::SSLeay::get_peer_certificate", XS_Net__SSLeay_get_peer_certificate, file, "$");
        newXSproto("Net::SSLeay::set_verify", XS_Net__SSLeay_set_verify, file, "$$$");
        newXSproto("Net::SSLeay::set_bio", XS_Net__SSLeay_set_bio, file, "$$$");
        newXSproto("Net::SSLeay::get_rbio", XS_Net__SSLeay_get_rbio, file, "$");
        newXSproto("Net::SSLeay::get_wbio", XS_Net__SSLeay_get_wbio, file, "$");
        newXSproto("Net::SSLeay::SESSION_new", XS_Net__SSLeay_SESSION_new, file, "");
        newXSproto("Net::SSLeay::SESSION_print", XS_Net__SSLeay_SESSION_print, file, "$$");
        newXSproto("Net::SSLeay::SESSION_free", XS_Net__SSLeay_SESSION_free, file, "$");
        newXSproto("Net::SSLeay::i2d_SSL_SESSION", XS_Net__SSLeay_i2d_SSL_SESSION, file, "$$");
        newXSproto("Net::SSLeay::set_session", XS_Net__SSLeay_set_session, file, "$$");
        newXSproto("Net::SSLeay::d2i_SSL_SESSION", XS_Net__SSLeay_d2i_SSL_SESSION, file, "$$$");
        newXSproto("Net::SSLeay::get_session", XS_Net__SSLeay_get_session, file, "$");
        newXSproto("Net::SSLeay::get_certificate", XS_Net__SSLeay_get_certificate, file, "$");
        newXSproto("Net::SSLeay::get_SSL_CTX", XS_Net__SSLeay_get_SSL_CTX, file, "$");
        newXSproto("Net::SSLeay::ctrl", XS_Net__SSLeay_ctrl, file, "$$$$");
        newXSproto("Net::SSLeay::CTX_ctrl", XS_Net__SSLeay_CTX_ctrl, file, "$$$$");
        newXSproto("Net::SSLeay::get_options", XS_Net__SSLeay_get_options, file, "$");
        newXSproto("Net::SSLeay::set_options", XS_Net__SSLeay_set_options, file, "$$");
        newXSproto("Net::SSLeay::CTX_get_options", XS_Net__SSLeay_CTX_get_options, file, "$");
        newXSproto("Net::SSLeay::CTX_set_options", XS_Net__SSLeay_CTX_set_options, file, "$$");
        newXSproto("Net::SSLeay::CTX_sessions", XS_Net__SSLeay_CTX_sessions, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_number", XS_Net__SSLeay_CTX_sess_number, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_connect", XS_Net__SSLeay_CTX_sess_connect, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_connect_good", XS_Net__SSLeay_CTX_sess_connect_good, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_connect_renegotiate", XS_Net__SSLeay_CTX_sess_connect_renegotiate, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_accept", XS_Net__SSLeay_CTX_sess_accept, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_accept_renegotiate", XS_Net__SSLeay_CTX_sess_accept_renegotiate, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_accept_good", XS_Net__SSLeay_CTX_sess_accept_good, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_hits", XS_Net__SSLeay_CTX_sess_hits, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_cb_hits", XS_Net__SSLeay_CTX_sess_cb_hits, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_misses", XS_Net__SSLeay_CTX_sess_misses, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_timeouts", XS_Net__SSLeay_CTX_sess_timeouts, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_cache_full", XS_Net__SSLeay_CTX_sess_cache_full, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_get_cache_size", XS_Net__SSLeay_CTX_sess_get_cache_size, file, "$");
        newXSproto("Net::SSLeay::CTX_sess_set_cache_size", XS_Net__SSLeay_CTX_sess_set_cache_size, file, "$$");
        newXSproto("Net::SSLeay::want", XS_Net__SSLeay_want, file, "$");
        newXSproto("Net::SSLeay::state", XS_Net__SSLeay_state, file, "$");
        newXSproto("Net::SSLeay::BIO_f_ssl", XS_Net__SSLeay_BIO_f_ssl, file, "");
        newXSproto("Net::SSLeay::BIO_s_mem", XS_Net__SSLeay_BIO_s_mem, file, "");
        newXSproto("Net::SSLeay::ERR_get_error", XS_Net__SSLeay_ERR_get_error, file, "");
        newXSproto("Net::SSLeay::ERR_peek_error", XS_Net__SSLeay_ERR_peek_error, file, "");
        newXSproto("Net::SSLeay::ERR_put_error", XS_Net__SSLeay_ERR_put_error, file, "$$$$$");
        newXSproto("Net::SSLeay::ERR_clear_error", XS_Net__SSLeay_ERR_clear_error, file, "");
        newXSproto("Net::SSLeay::ERR_error_string", XS_Net__SSLeay_ERR_error_string, file, "$;$");
        newXSproto("Net::SSLeay::load_error_strings", XS_Net__SSLeay_load_error_strings, file, "");
        newXSproto("Net::SSLeay::ERR_load_crypto_strings", XS_Net__SSLeay_ERR_load_crypto_strings, file, "");
        newXSproto("Net::SSLeay::SSLeay_add_ssl_algorithms", XS_Net__SSLeay_SSLeay_add_ssl_algorithms, file, "");
        newXSproto("Net::SSLeay::ERR_load_SSL_strings", XS_Net__SSLeay_ERR_load_SSL_strings, file, "");
        newXSproto("Net::SSLeay::ERR_load_RAND_strings", XS_Net__SSLeay_ERR_load_RAND_strings, file, "");
        newXSproto("Net::SSLeay::RAND_bytes", XS_Net__SSLeay_RAND_bytes, file, "$$");
        newXSproto("Net::SSLeay::RAND_pseudo_bytes", XS_Net__SSLeay_RAND_pseudo_bytes, file, "$$");
        newXSproto("Net::SSLeay::RAND_add", XS_Net__SSLeay_RAND_add, file, "$$$");
        newXSproto("Net::SSLeay::RAND_poll", XS_Net__SSLeay_RAND_poll, file, "");
        newXSproto("Net::SSLeay::RAND_status", XS_Net__SSLeay_RAND_status, file, "");
        newXSproto("Net::SSLeay::RAND_egd_bytes", XS_Net__SSLeay_RAND_egd_bytes, file, "$$");
        newXSproto("Net::SSLeay::RAND_file_name", XS_Net__SSLeay_RAND_file_name, file, "$");
        newXSproto("Net::SSLeay::RAND_seed", XS_Net__SSLeay_RAND_seed, file, "$");
        newXSproto("Net::SSLeay::RAND_cleanup", XS_Net__SSLeay_RAND_cleanup, file, "");
        newXSproto("Net::SSLeay::RAND_load_file", XS_Net__SSLeay_RAND_load_file, file, "$$");
        newXSproto("Net::SSLeay::RAND_write_file", XS_Net__SSLeay_RAND_write_file, file, "$");
        newXSproto("Net::SSLeay::RAND_egd", XS_Net__SSLeay_RAND_egd, file, "$");
        newXSproto("Net::SSLeay::X509_get_issuer_name", XS_Net__SSLeay_X509_get_issuer_name, file, "$");
        newXSproto("Net::SSLeay::X509_get_subject_name", XS_Net__SSLeay_X509_get_subject_name, file, "$");
        newXSproto("Net::SSLeay::X509_NAME_oneline", XS_Net__SSLeay_X509_NAME_oneline, file, "$");
        newXSproto("Net::SSLeay::X509_NAME_get_text_by_NID", XS_Net__SSLeay_X509_NAME_get_text_by_NID, file, "$$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_get_current_cert", XS_Net__SSLeay_X509_STORE_CTX_get_current_cert, file, "$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_get_ex_data", XS_Net__SSLeay_X509_STORE_CTX_get_ex_data, file, "$$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_get_error", XS_Net__SSLeay_X509_STORE_CTX_get_error, file, "$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_get_error_depth", XS_Net__SSLeay_X509_STORE_CTX_get_error_depth, file, "$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_set_ex_data", XS_Net__SSLeay_X509_STORE_CTX_set_ex_data, file, "$$$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_set_error", XS_Net__SSLeay_X509_STORE_CTX_set_error, file, "$$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_set_cert", XS_Net__SSLeay_X509_STORE_CTX_set_cert, file, "$$");
        newXSproto("Net::SSLeay::X509_STORE_add_cert", XS_Net__SSLeay_X509_STORE_add_cert, file, "$$");
        newXSproto("Net::SSLeay::X509_STORE_add_crl", XS_Net__SSLeay_X509_STORE_add_crl, file, "$$");
        newXSproto("Net::SSLeay::X509_STORE_CTX_set_flags", XS_Net__SSLeay_X509_STORE_CTX_set_flags, file, "$$");
        newXSproto("Net::SSLeay::X509_load_cert_file", XS_Net__SSLeay_X509_load_cert_file, file, "$$$");
        newXSproto("Net::SSLeay::X509_load_crl_file", XS_Net__SSLeay_X509_load_crl_file, file, "$$$");
        newXSproto("Net::SSLeay::X509_load_cert_crl_file", XS_Net__SSLeay_X509_load_cert_crl_file, file, "$$$");
        newXSproto("Net::SSLeay::X509_get_notBefore", XS_Net__SSLeay_X509_get_notBefore, file, "$");
        newXSproto("Net::SSLeay::X509_get_notAfter", XS_Net__SSLeay_X509_get_notAfter, file, "$");
        newXSproto("Net::SSLeay::P_ASN1_UTCTIME_put2string", XS_Net__SSLeay_P_ASN1_UTCTIME_put2string, file, "$");
        newXSproto("Net::SSLeay::EVP_PKEY_copy_parameters", XS_Net__SSLeay_EVP_PKEY_copy_parameters, file, "$$");
        newXSproto("Net::SSLeay::PEM_get_string_X509", XS_Net__SSLeay_PEM_get_string_X509, file, "$");
        newXSproto("Net::SSLeay::MD5", XS_Net__SSLeay_MD5, file, "$");
        newXSproto("Net::SSLeay::SSLv2_method", XS_Net__SSLeay_SSLv2_method, file, "");
        newXSproto("Net::SSLeay::SSLv3_method", XS_Net__SSLeay_SSLv3_method, file, "");
        newXSproto("Net::SSLeay::TLSv1_method", XS_Net__SSLeay_TLSv1_method, file, "");
        newXSproto("Net::SSLeay::set_ssl_method", XS_Net__SSLeay_set_ssl_method, file, "$$");
        newXSproto("Net::SSLeay::get_ssl_method", XS_Net__SSLeay_get_ssl_method, file, "$");
        newXSproto("Net::SSLeay::BIO_new_buffer_ssl_connect", XS_Net__SSLeay_BIO_new_buffer_ssl_connect, file, "$");
        newXSproto("Net::SSLeay::BIO_new_file", XS_Net__SSLeay_BIO_new_file, file, "$$");
        newXSproto("Net::SSLeay::BIO_new_ssl", XS_Net__SSLeay_BIO_new_ssl, file, "$$");
        newXSproto("Net::SSLeay::BIO_new_ssl_connect", XS_Net__SSLeay_BIO_new_ssl_connect, file, "$");
        newXSproto("Net::SSLeay::BIO_new", XS_Net__SSLeay_BIO_new, file, "$");
        newXSproto("Net::SSLeay::BIO_free", XS_Net__SSLeay_BIO_free, file, "$");
        newXSproto("Net::SSLeay::BIO_read", XS_Net__SSLeay_BIO_read, file, "$;$");
        newXSproto("Net::SSLeay::BIO_write", XS_Net__SSLeay_BIO_write, file, "$$");
        newXSproto("Net::SSLeay::BIO_eof", XS_Net__SSLeay_BIO_eof, file, "$");
        newXSproto("Net::SSLeay::BIO_pending", XS_Net__SSLeay_BIO_pending, file, "$");
        newXSproto("Net::SSLeay::BIO_wpending", XS_Net__SSLeay_BIO_wpending, file, "$");
        newXSproto("Net::SSLeay::BIO_ssl_copy_session_id", XS_Net__SSLeay_BIO_ssl_copy_session_id, file, "$$");
        newXSproto("Net::SSLeay::BIO_ssl_shutdown", XS_Net__SSLeay_BIO_ssl_shutdown, file, "$");
        newXSproto("Net::SSLeay::add_client_CA", XS_Net__SSLeay_add_client_CA, file, "$$");
        newXSproto("Net::SSLeay::alert_desc_string", XS_Net__SSLeay_alert_desc_string, file, "$");
        newXSproto("Net::SSLeay::alert_desc_string_long", XS_Net__SSLeay_alert_desc_string_long, file, "$");
        newXSproto("Net::SSLeay::alert_type_string", XS_Net__SSLeay_alert_type_string, file, "$");
        newXSproto("Net::SSLeay::alert_type_string_long", XS_Net__SSLeay_alert_type_string_long, file, "$");
        newXSproto("Net::SSLeay::callback_ctrl", XS_Net__SSLeay_callback_ctrl, file, "$$$");
        newXSproto("Net::SSLeay::check_private_key", XS_Net__SSLeay_check_private_key, file, "$");
        newXSproto("Net::SSLeay::CIPHER_description", XS_Net__SSLeay_CIPHER_description, file, "$$$");
        newXSproto("Net::SSLeay::CIPHER_get_bits", XS_Net__SSLeay_CIPHER_get_bits, file, "$$");
        newXSproto("Net::SSLeay::COMP_add_compression_method", XS_Net__SSLeay_COMP_add_compression_method, file, "$$");
        newXSproto("Net::SSLeay::CTX_add_client_CA", XS_Net__SSLeay_CTX_add_client_CA, file, "$$");
        newXSproto("Net::SSLeay::CTX_callback_ctrl", XS_Net__SSLeay_CTX_callback_ctrl, file, "$$$");
        newXSproto("Net::SSLeay::CTX_check_private_key", XS_Net__SSLeay_CTX_check_private_key, file, "$");
        newXSproto("Net::SSLeay::CTX_get_ex_data", XS_Net__SSLeay_CTX_get_ex_data, file, "$$");
        newXSproto("Net::SSLeay::CTX_get_quiet_shutdown", XS_Net__SSLeay_CTX_get_quiet_shutdown, file, "$");
        newXSproto("Net::SSLeay::CTX_get_timeout", XS_Net__SSLeay_CTX_get_timeout, file, "$");
        newXSproto("Net::SSLeay::CTX_get_verify_depth", XS_Net__SSLeay_CTX_get_verify_depth, file, "$");
        newXSproto("Net::SSLeay::CTX_get_verify_mode", XS_Net__SSLeay_CTX_get_verify_mode, file, "$");
        newXSproto("Net::SSLeay::CTX_set_cert_store", XS_Net__SSLeay_CTX_set_cert_store, file, "$$");
        newXSproto("Net::SSLeay::CTX_get_cert_store", XS_Net__SSLeay_CTX_get_cert_store, file, "$");
        newXSproto("Net::SSLeay::CTX_set_cert_verify_callback", XS_Net__SSLeay_CTX_set_cert_verify_callback, file, "$$$");
        newXSproto("Net::SSLeay::CTX_set_client_CA_list", XS_Net__SSLeay_CTX_set_client_CA_list, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_default_passwd_cb", XS_Net__SSLeay_CTX_set_default_passwd_cb, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_default_passwd_cb_userdata", XS_Net__SSLeay_CTX_set_default_passwd_cb_userdata, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_ex_data", XS_Net__SSLeay_CTX_set_ex_data, file, "$$$");
        newXSproto("Net::SSLeay::CTX_set_purpose", XS_Net__SSLeay_CTX_set_purpose, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_quiet_shutdown", XS_Net__SSLeay_CTX_set_quiet_shutdown, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_ssl_version", XS_Net__SSLeay_CTX_set_ssl_version, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_timeout", XS_Net__SSLeay_CTX_set_timeout, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_trust", XS_Net__SSLeay_CTX_set_trust, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_verify_depth", XS_Net__SSLeay_CTX_set_verify_depth, file, "$$");
        newXSproto("Net::SSLeay::CTX_use_certificate", XS_Net__SSLeay_CTX_use_certificate, file, "$$");
        newXSproto("Net::SSLeay::CTX_use_certificate_chain_file", XS_Net__SSLeay_CTX_use_certificate_chain_file, file, "$$");
        newXSproto("Net::SSLeay::CTX_use_PrivateKey", XS_Net__SSLeay_CTX_use_PrivateKey, file, "$$");
        newXSproto("Net::SSLeay::CTX_use_RSAPrivateKey", XS_Net__SSLeay_CTX_use_RSAPrivateKey, file, "$$");
        newXSproto("Net::SSLeay::do_handshake", XS_Net__SSLeay_do_handshake, file, "$");
        newXSproto("Net::SSLeay::dup", XS_Net__SSLeay_dup, file, "$");
        newXSproto("Net::SSLeay::get_current_cipher", XS_Net__SSLeay_get_current_cipher, file, "$");
        newXSproto("Net::SSLeay::get_default_timeout", XS_Net__SSLeay_get_default_timeout, file, "$");
        newXSproto("Net::SSLeay::get_ex_data", XS_Net__SSLeay_get_ex_data, file, "$$");
        newXSproto("Net::SSLeay::get_finished", XS_Net__SSLeay_get_finished, file, "$$$");
        newXSproto("Net::SSLeay::get_peer_finished", XS_Net__SSLeay_get_peer_finished, file, "$$$");
        newXSproto("Net::SSLeay::get_quiet_shutdown", XS_Net__SSLeay_get_quiet_shutdown, file, "$");
        newXSproto("Net::SSLeay::get_shutdown", XS_Net__SSLeay_get_shutdown, file, "$");
        newXSproto("Net::SSLeay::get_verify_depth", XS_Net__SSLeay_get_verify_depth, file, "$");
        newXSproto("Net::SSLeay::get_verify_mode", XS_Net__SSLeay_get_verify_mode, file, "$");
        newXSproto("Net::SSLeay::get_verify_result", XS_Net__SSLeay_get_verify_result, file, "$");
        newXSproto("Net::SSLeay::library_init", XS_Net__SSLeay_library_init, file, "");
        newXSproto("Net::SSLeay::renegotiate", XS_Net__SSLeay_renegotiate, file, "$");
        newXSproto("Net::SSLeay::SESSION_cmp", XS_Net__SSLeay_SESSION_cmp, file, "$$");
        newXSproto("Net::SSLeay::SESSION_get_ex_data", XS_Net__SSLeay_SESSION_get_ex_data, file, "$$");
        newXSproto("Net::SSLeay::SESSION_get_time", XS_Net__SSLeay_SESSION_get_time, file, "$");
        newXSproto("Net::SSLeay::SESSION_get_timeout", XS_Net__SSLeay_SESSION_get_timeout, file, "$");
        newXSproto("Net::SSLeay::SESSION_print_fp", XS_Net__SSLeay_SESSION_print_fp, file, "$$");
        newXSproto("Net::SSLeay::SESSION_set_ex_data", XS_Net__SSLeay_SESSION_set_ex_data, file, "$$$");
        newXSproto("Net::SSLeay::SESSION_set_time", XS_Net__SSLeay_SESSION_set_time, file, "$$");
        newXSproto("Net::SSLeay::SESSION_set_timeout", XS_Net__SSLeay_SESSION_set_timeout, file, "$$");
        newXSproto("Net::SSLeay::set_accept_state", XS_Net__SSLeay_set_accept_state, file, "$");
        newXSproto("Net::SSLeay::set_client_CA_list", XS_Net__SSLeay_set_client_CA_list, file, "$$");
        newXSproto("Net::SSLeay::set_connect_state", XS_Net__SSLeay_set_connect_state, file, "$");
        newXSproto("Net::SSLeay::set_ex_data", XS_Net__SSLeay_set_ex_data, file, "$$$");
        newXSproto("Net::SSLeay::set_info_callback", XS_Net__SSLeay_set_info_callback, file, "$$");
        newXSproto("Net::SSLeay::set_purpose", XS_Net__SSLeay_set_purpose, file, "$$");
        newXSproto("Net::SSLeay::set_quiet_shutdown", XS_Net__SSLeay_set_quiet_shutdown, file, "$$");
        newXSproto("Net::SSLeay::set_shutdown", XS_Net__SSLeay_set_shutdown, file, "$$");
        newXSproto("Net::SSLeay::set_trust", XS_Net__SSLeay_set_trust, file, "$$");
        newXSproto("Net::SSLeay::set_verify_depth", XS_Net__SSLeay_set_verify_depth, file, "$$");
        newXSproto("Net::SSLeay::set_verify_result", XS_Net__SSLeay_set_verify_result, file, "$$");
        newXSproto("Net::SSLeay::shutdown", XS_Net__SSLeay_shutdown, file, "$");
        newXSproto("Net::SSLeay::version", XS_Net__SSLeay_version, file, "$");
        newXSproto("Net::SSLeay::load_client_CA_file", XS_Net__SSLeay_load_client_CA_file, file, "$");
        newXSproto("Net::SSLeay::add_file_cert_subjects_to_stack", XS_Net__SSLeay_add_file_cert_subjects_to_stack, file, "$$");
#if XSubPPtmpAAAD
        newXSproto("Net::SSLeay::add_dir_cert_subjects_to_stack", XS_Net__SSLeay_add_dir_cert_subjects_to_stack, file, "$$");
#endif
        newXSproto("Net::SSLeay::CTX_get_ex_new_index", XS_Net__SSLeay_CTX_get_ex_new_index, file, "$$$$$");
        newXSproto("Net::SSLeay::CTX_set_session_id_context", XS_Net__SSLeay_CTX_set_session_id_context, file, "$$$");
        newXSproto("Net::SSLeay::set_session_id_context", XS_Net__SSLeay_set_session_id_context, file, "$$$");
        newXSproto("Net::SSLeay::CTX_set_tmp_rsa_callback", XS_Net__SSLeay_CTX_set_tmp_rsa_callback, file, "$$");
        newXSproto("Net::SSLeay::set_tmp_rsa_callback", XS_Net__SSLeay_set_tmp_rsa_callback, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_tmp_dh_callback", XS_Net__SSLeay_CTX_set_tmp_dh_callback, file, "$$");
        newXSproto("Net::SSLeay::set_tmp_dh_callback", XS_Net__SSLeay_set_tmp_dh_callback, file, "$$");
        newXSproto("Net::SSLeay::get_ex_new_index", XS_Net__SSLeay_get_ex_new_index, file, "$$$$$");
        newXSproto("Net::SSLeay::SESSION_get_ex_new_index", XS_Net__SSLeay_SESSION_get_ex_new_index, file, "$$$$$");
        newXSproto("Net::SSLeay::OpenSSL_add_ssl_algorithms", XS_Net__SSLeay_OpenSSL_add_ssl_algorithms, file, "");
        newXSproto("Net::SSLeay::clear_num_renegotiations", XS_Net__SSLeay_clear_num_renegotiations, file, "$");
        newXSproto("Net::SSLeay::CTX_add_extra_chain_cert", XS_Net__SSLeay_CTX_add_extra_chain_cert, file, "$$");
        newXSproto("Net::SSLeay::CTX_get_app_data", XS_Net__SSLeay_CTX_get_app_data, file, "$");
        newXSproto("Net::SSLeay::CTX_get_mode", XS_Net__SSLeay_CTX_get_mode, file, "$");
        newXSproto("Net::SSLeay::CTX_get_read_ahead", XS_Net__SSLeay_CTX_get_read_ahead, file, "$");
        newXSproto("Net::SSLeay::CTX_get_session_cache_mode", XS_Net__SSLeay_CTX_get_session_cache_mode, file, "$");
        newXSproto("Net::SSLeay::CTX_need_tmp_RSA", XS_Net__SSLeay_CTX_need_tmp_RSA, file, "$");
        newXSproto("Net::SSLeay::CTX_set_app_data", XS_Net__SSLeay_CTX_set_app_data, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_mode", XS_Net__SSLeay_CTX_set_mode, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_read_ahead", XS_Net__SSLeay_CTX_set_read_ahead, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_session_cache_mode", XS_Net__SSLeay_CTX_set_session_cache_mode, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_tmp_dh", XS_Net__SSLeay_CTX_set_tmp_dh, file, "$$");
        newXSproto("Net::SSLeay::CTX_set_tmp_rsa", XS_Net__SSLeay_CTX_set_tmp_rsa, file, "$$");
        newXSproto("Net::SSLeay::get_app_data", XS_Net__SSLeay_get_app_data, file, "$");
        newXSproto("Net::SSLeay::get_cipher_bits", XS_Net__SSLeay_get_cipher_bits, file, "$$");
        newXSproto("Net::SSLeay::get_mode", XS_Net__SSLeay_get_mode, file, "$");
        newXSproto("Net::SSLeay::get_state", XS_Net__SSLeay_get_state, file, "$");
        newXSproto("Net::SSLeay::need_tmp_RSA", XS_Net__SSLeay_need_tmp_RSA, file, "$");
        newXSproto("Net::SSLeay::num_renegotiations", XS_Net__SSLeay_num_renegotiations, file, "$");
        newXSproto("Net::SSLeay::SESSION_get_app_data", XS_Net__SSLeay_SESSION_get_app_data, file, "$");
        newXSproto("Net::SSLeay::session_reused", XS_Net__SSLeay_session_reused, file, "$");
        newXSproto("Net::SSLeay::SESSION_set_app_data", XS_Net__SSLeay_SESSION_set_app_data, file, "$$");
        newXSproto("Net::SSLeay::set_app_data", XS_Net__SSLeay_set_app_data, file, "$$");
        newXSproto("Net::SSLeay::set_mode", XS_Net__SSLeay_set_mode, file, "$$");
        newXSproto("Net::SSLeay::set_pref_cipher", XS_Net__SSLeay_set_pref_cipher, file, "$$");
        newXSproto("Net::SSLeay::set_tmp_dh", XS_Net__SSLeay_set_tmp_dh, file, "$$");
        newXSproto("Net::SSLeay::set_tmp_rsa", XS_Net__SSLeay_set_tmp_rsa, file, "$$");
        newXSproto("Net::SSLeay::RSA_generate_key", XS_Net__SSLeay_RSA_generate_key, file, "$$;$$");
        newXSproto("Net::SSLeay::RSA_free", XS_Net__SSLeay_RSA_free, file, "$");
        newXSproto("Net::SSLeay::X509_free", XS_Net__SSLeay_X509_free, file, "$");
        newXSproto("Net::SSLeay::PEM_read_bio_DHparams", XS_Net__SSLeay_PEM_read_bio_DHparams, file, "$;$$$");
        newXSproto("Net::SSLeay::PEM_read_bio_X509_CRL", XS_Net__SSLeay_PEM_read_bio_X509_CRL, file, "$;$$$");
        newXSproto("Net::SSLeay::DH_free", XS_Net__SSLeay_DH_free, file, "$");
        newXSproto("Net::SSLeay::total_renegotiations", XS_Net__SSLeay_total_renegotiations, file, "$");
        newXSproto("Net::SSLeay::SESSION_get_master_key", XS_Net__SSLeay_SESSION_get_master_key, file, "$");
        newXSproto("Net::SSLeay::get_client_random", XS_Net__SSLeay_get_client_random, file, "$");
        newXSproto("Net::SSLeay::get_server_random", XS_Net__SSLeay_get_server_random, file, "$");

    /* Initialisation Section */

#if XSubPPtmpAAAA
#endif
#if XSubPPtmpAAAB
#endif
#if XSubPPtmpAAAC
#endif
#if XSubPPtmpAAAD
#endif
#line 7176 "SSLeay.c"

    /* End of Initialisation Section */

    XSRETURN_YES;
}

