#define PY_SSIZE_T_CLEAN

#include "Python.h"

#ifdef WITH_THREAD

#include "pythread.h"

#define PySSL_BEGIN_ALLOW_THREADS_S(save) \

do { if (_ssl_locks_count>0) { (save) = PyEval_SaveThread(); } } while (0)

#define PySSL_END_ALLOW_THREADS_S(save) \

do { if (_ssl_locks_count>0) { PyEval_RestoreThread(save); } } while (0)

#define PySSL_BEGIN_ALLOW_THREADS { \

PyThreadState *_save = NULL; \

PySSL_BEGIN_ALLOW_THREADS_S(_save);

#define PySSL_BLOCK_THREADS PySSL_END_ALLOW_THREADS_S(_save);

#define PySSL_UNBLOCK_THREADS PySSL_BEGIN_ALLOW_THREADS_S(_save);

#define PySSL_END_ALLOW_THREADS PySSL_END_ALLOW_THREADS_S(_save); }

#else /* no WITH_THREAD */

#define PySSL_BEGIN_ALLOW_THREADS_S(save)

#define PySSL_END_ALLOW_THREADS_S(save)

#define PySSL_BEGIN_ALLOW_THREADS

#define PySSL_BLOCK_THREADS

#define PySSL_UNBLOCK_THREADS

#define PySSL_END_ALLOW_THREADS

#include "socketmodule.h"

static PySocketModule_APIObject PySocketModule;

#if defined(HAVE_POLL_H)

#include <poll.h>

#elif defined(HAVE_SYS_POLL_H)

#include <sys/poll.h>

#ifdef __GNUC__

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#ifdef __clang__

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

#include "openssl/rsa.h"

#include "openssl/crypto.h"

#include "openssl/x509.h"

#include "openssl/x509v3.h"

#include "openssl/pem.h"

#include "openssl/ssl.h"

#include "openssl/err.h"

#include "openssl/rand.h"

#include "openssl/bio.h"

static PyObject *PySSLErrorObject;

static PyObject *PySSLZeroReturnErrorObject;

static PyObject *PySSLWantReadErrorObject;

static PyObject *PySSLWantWriteErrorObject;

static PyObject *PySSLSyscallErrorObject;

static PyObject *PySSLEOFErrorObject;

static PyObject *err_codes_to_names;

static PyObject *err_names_to_codes;

static PyObject *lib_codes_to_names;

struct py_ssl_error_code {

const char *mnemonic;

int library, reason;

};

struct py_ssl_library_code {

const char *library;

int code;

};

#include "_ssl_data.h"

#if (OPENSSL_VERSION_NUMBER >= 0x10100000L) && !defined(LIBRESSL_VERSION_NUMBER)

# define OPENSSL_VERSION_1_1 1

# define PY_OPENSSL_1_1_API 1

#if defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER >= 0x2070000fL

# define PY_OPENSSL_1_1_API 1

#if OPENSSL_VERSION_NUMBER >= 0x10001000L

# define HAVE_TLSv1_2 1

# define HAVE_TLSv1_2 0

#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

# define HAVE_SNI 1

# define HAVE_SNI 0

#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation

# define HAVE_ALPN

#ifndef INVALID_SOCKET /* MS defines this */

#define INVALID_SOCKET (-1)

#ifndef OPENSSL_VERSION_1_1

#define HAVE_OPENSSL_CRYPTO_LOCK

#if defined(OPENSSL_VERSION_1_1) && !defined(OPENSSL_NO_SSL2)

#define OPENSSL_NO_SSL2

#ifndef PY_OPENSSL_1_1_API

#define TLS_method SSLv23_method

static int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)

{

return ne->set;

}

#ifndef OPENSSL_NO_COMP

static int COMP_get_type(const COMP_METHOD *meth)

{

return meth->type;

}

static pem_password_cb *SSL_CTX_get_default_passwd_cb(SSL_CTX *ctx)

{

return ctx->default_passwd_callback;

}

static void *SSL_CTX_get_default_passwd_cb_userdata(SSL_CTX *ctx)

{

return ctx->default_passwd_callback_userdata;

}

static int X509_OBJECT_get_type(X509_OBJECT *x)

{

return x->type;

}

static X509 *X509_OBJECT_get0_X509(X509_OBJECT *x)

{

return x->data.x509;

}

static int BIO_up_ref(BIO *b)

{

CRYPTO_add(&b->references, 1, CRYPTO_LOCK_BIO);

return 1;

}

static STACK_OF(X509_OBJECT) *X509_STORE_get0_objects(X509_STORE *store) {

return store->objs;

}

static X509_VERIFY_PARAM *X509_STORE_get0_param(X509_STORE *store)

{

return store->param;

}

#endif /* OpenSSL < 1.1.0 or LibreSSL < 2.7.0 */

enum py_ssl_error {

};

enum py_ssl_server_or_client {

PY_SSL_CLIENT,

PY_SSL_SERVER

};

enum py_ssl_cert_requirements {

};

enum py_ssl_version {

};

#ifdef WITH_THREAD

static unsigned int _ssl_locks_count = 0;

#endif /* def WITH_THREAD */

#define X509_NAME_MAXLEN 256

#if OPENSSL_VERSION_NUMBER >= 0x009080dfL && OPENSSL_VERSION_NUMBER != 0x00909000L

# define HAVE_SSL_CTX_CLEAR_OPTIONS

# undef HAVE_SSL_CTX_CLEAR_OPTIONS

#define PySSL_CB_MAXLEN 128

typedef struct {

PyObject_HEAD

SSL_CTX *ctx;

#ifdef OPENSSL_NPN_NEGOTIATED

unsigned char *npn_protocols;

int npn_protocols_len;

#ifdef HAVE_ALPN

unsigned char *alpn_protocols;

int alpn_protocols_len;

#ifndef OPENSSL_NO_TLSEXT

PyObject *set_hostname;

int check_hostname;

} PySSLContext;

typedef struct {

PyObject_HEAD

PyObject *Socket; /* weakref to socket on which we're layered */

SSL *ssl;

PySSLContext *ctx; /* weakref to SSL context */

X509 *peer_cert;

char shutdown_seen_zero;

char handshake_done;

enum py_ssl_server_or_client socket_type;

PyObject *owner; /* Python level "owner" passed to servername callback */

PyObject *server_hostname;

} PySSLSocket;

typedef struct {

PyObject_HEAD

BIO *bio;

int eof_written;

} PySSLMemoryBIO;

static PyTypeObject PySSLContext_Type;

static PyTypeObject PySSLSocket_Type;

static PyTypeObject PySSLMemoryBIO_Type;

#include "clinic/_ssl.c.h"

static int PySSL_select(PySocketSockObject *s, int writing, _PyTime_t timeout);

#define PySSLContext_Check(v) (Py_TYPE(v) == &PySSLContext_Type)

#define PySSLSocket_Check(v) (Py_TYPE(v) == &PySSLSocket_Type)

#define PySSLMemoryBIO_Check(v) (Py_TYPE(v) == &PySSLMemoryBIO_Type)

typedef enum {

SOCKET_IS_NONBLOCKING,

SOCKET_IS_BLOCKING,

SOCKET_HAS_TIMED_OUT,

SOCKET_HAS_BEEN_CLOSED,

SOCKET_TOO_LARGE_FOR_SELECT,

SOCKET_OPERATION_OK

} timeout_state;

#define ERRSTR1(x,y,z) (x ":" y ": " z)

#define ERRSTR(x) ERRSTR1("_ssl.c", Py_STRINGIFY(__LINE__), x)

#define GET_SOCKET(obj) ((obj)->Socket ? \

(PySocketSockObject *) PyWeakref_GetObject((obj)->Socket) : NULL)

#define GET_SOCKET_TIMEOUT(sock) \

((sock != NULL) ? (sock)->sock_timeout : 0)

PyDoc_STRVAR(SSLError_doc,

"An error occurred in the SSL implementation.");

PyDoc_STRVAR(SSLZeroReturnError_doc,

"SSL/TLS session closed cleanly.");

PyDoc_STRVAR(SSLWantReadError_doc,

"before the requested operation can be completed.");

PyDoc_STRVAR(SSLWantWriteError_doc,

"before the requested operation can be completed.");

PyDoc_STRVAR(SSLSyscallError_doc,

"System error when attempting SSL operation.");

PyDoc_STRVAR(SSLEOFError_doc,

"SSL/TLS connection terminated abruptly.");

static PyObject *

SSLError_str(PyOSErrorObject *self)

{

if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {

Py_INCREF(self->strerror);

return self->strerror;

}

else

return PyObject_Str(self->args);

}

static PyType_Slot sslerror_type_slots[] = {

{Py_tp_base, NULL}, /* Filled out in module init as it's not a constant */

{Py_tp_doc, SSLError_doc},

{Py_tp_str, SSLError_str},

{0, 0},

};

static PyType_Spec sslerror_type_spec = {

"ssl.SSLError",

sizeof(PyOSErrorObject),

0,

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,

sslerror_type_slots

};

static void

fill_and_set_sslerror(PyObject *type, int ssl_errno, const char *errstr,

int lineno, unsigned long errcode)

{

PyObject *err_value = NULL, *reason_obj = NULL, *lib_obj = NULL;

PyObject *init_value, *msg, *key;

_Py_IDENTIFIER(reason);

_Py_IDENTIFIER(library);

if (errcode != 0) {

int lib, reason;

lib = ERR_GET_LIB(errcode);

reason = ERR_GET_REASON(errcode);

key = Py_BuildValue("ii", lib, reason);

if (key == NULL)

goto fail;

reason_obj = PyDict_GetItem(err_codes_to_names, key);

Py_DECREF(key);

if (reason_obj == NULL) {

/* XXX if reason < 100, it might reflect a library number (!!) */

PyErr_Clear();

}

key = PyLong_FromLong(lib);

if (key == NULL)

goto fail;

lib_obj = PyDict_GetItem(lib_codes_to_names, key);

Py_DECREF(key);

if (lib_obj == NULL) {

PyErr_Clear();

}

if (errstr == NULL)

errstr = ERR_reason_error_string(errcode);

}

if (errstr == NULL)

errstr = "unknown error";

if (reason_obj && lib_obj)

msg = PyUnicode_FromFormat("[%S: %S] %s (_ssl.c:%d)",

lib_obj, reason_obj, errstr, lineno);

else if (lib_obj)

msg = PyUnicode_FromFormat("[%S] %s (_ssl.c:%d)",

lib_obj, errstr, lineno);

else

msg = PyUnicode_FromFormat("%s (_ssl.c:%d)", errstr, lineno);

if (msg == NULL)

goto fail;

init_value = Py_BuildValue("iN", ssl_errno, msg);

if (init_value == NULL)

goto fail;

err_value = PyObject_CallObject(type, init_value);

Py_DECREF(init_value);

if (err_value == NULL)

goto fail;

if (reason_obj == NULL)

reason_obj = Py_None;

if (_PyObject_SetAttrId(err_value, &PyId_reason, reason_obj))

goto fail;

if (lib_obj == NULL)

lib_obj = Py_None;

if (_PyObject_SetAttrId(err_value, &PyId_library, lib_obj))

goto fail;

PyErr_SetObject(type, err_value);

fail:

Py_XDECREF(err_value);

}

static PyObject *

PySSL_SetError(PySSLSocket *obj, int ret, char *filename, int lineno)

{

PyObject *type = PySSLErrorObject;

char *errstr = NULL;

int err;

enum py_ssl_error p = PY_SSL_ERROR_NONE;

unsigned long e = 0;

assert(ret <= 0);

e = ERR_peek_last_error();

if (obj->ssl != NULL) {

err = SSL_get_error(obj->ssl, ret);

switch (err) {

case SSL_ERROR_ZERO_RETURN:

errstr = "TLS/SSL connection has been closed (EOF)";

type = PySSLZeroReturnErrorObject;

p = PY_SSL_ERROR_ZERO_RETURN;

break;

case SSL_ERROR_WANT_READ:

errstr = "The operation did not complete (read)";

type = PySSLWantReadErrorObject;

p = PY_SSL_ERROR_WANT_READ;

break;

case SSL_ERROR_WANT_WRITE:

p = PY_SSL_ERROR_WANT_WRITE;

type = PySSLWantWriteErrorObject;

errstr = "The operation did not complete (write)";

break;

case SSL_ERROR_WANT_X509_LOOKUP:

p = PY_SSL_ERROR_WANT_X509_LOOKUP;

errstr = "The operation did not complete (X509 lookup)";

break;

case SSL_ERROR_WANT_CONNECT:

p = PY_SSL_ERROR_WANT_CONNECT;

errstr = "The operation did not complete (connect)";

break;

case SSL_ERROR_SYSCALL:

{

if (e == 0) {

PySocketSockObject *s = GET_SOCKET(obj);

if (ret == 0 || (((PyObject *)s) == Py_None)) {

p = PY_SSL_ERROR_EOF;

type = PySSLEOFErrorObject;

errstr = "EOF occurred in violation of protocol";

} else if (s && ret == -1) {

/* underlying BIO reported an I/O error */

Py_INCREF(s);

ERR_clear_error();

s->errorhandler();

Py_DECREF(s);

return NULL;

} else { /* possible? */

p = PY_SSL_ERROR_SYSCALL;

type = PySSLSyscallErrorObject;

errstr = "Some I/O error occurred";

}

} else {

p = PY_SSL_ERROR_SYSCALL;

}

break;

}

case SSL_ERROR_SSL:

{

p = PY_SSL_ERROR_SSL;

if (e == 0)

/* possible? */

errstr = "A failure in the SSL library occurred";

break;

}

default:

p = PY_SSL_ERROR_INVALID_ERROR_CODE;

errstr = "Invalid error code";

}

}

fill_and_set_sslerror(type, p, errstr, lineno, e);

ERR_clear_error();

return NULL;

}

static PyObject *

_setSSLError (char *errstr, int errcode, char *filename, int lineno) {

if (errstr == NULL)

errcode = ERR_peek_last_error();

else

errcode = 0;

fill_and_set_sslerror(PySSLErrorObject, errcode, errstr, lineno, errcode);

ERR_clear_error();

return NULL;

}

static PySSLSocket *

newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,

enum py_ssl_server_or_client socket_type,

char *server_hostname,

PySSLMemoryBIO *inbio, PySSLMemoryBIO *outbio)

{

PySSLSocket *self;

SSL_CTX *ctx = sslctx->ctx;

long mode;

self = PyObject_New(PySSLSocket, &PySSLSocket_Type);

if (self == NULL)

return NULL;

self->peer_cert = NULL;

self->ssl = NULL;

self->Socket = NULL;

self->ctx = sslctx;

Py_INCREF(sslctx);

self->shutdown_seen_zero = 0;

self->handshake_done = 0;

self->owner = NULL;

self->server_hostname = NULL;

if (server_hostname != NULL) {

PyObject *hostname = PyUnicode_Decode(server_hostname, strlen(server_hostname),

"idna", "strict");

if (hostname == NULL) {

Py_DECREF(self);

return NULL;

}

self->server_hostname = hostname;

}

/* Make sure the SSL error state is initialized */

(void) ERR_get_state();

ERR_clear_error();

PySSL_BEGIN_ALLOW_THREADS

self->ssl = SSL_new(ctx);

PySSL_END_ALLOW_THREADS

SSL_set_app_data(self->ssl, self);

if (sock) {

SSL_set_fd(self->ssl, Py_SAFE_DOWNCAST(sock->sock_fd, SOCKET_T, int));

} else {

/* BIOs are reference counted and SSL_set_bio borrows our reference.

BIO_up_ref(inbio->bio);

BIO_up_ref(outbio->bio);

SSL_set_bio(self->ssl, inbio->bio, outbio->bio);

}

mode = SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER;

#ifdef SSL_MODE_AUTO_RETRY

mode |= SSL_MODE_AUTO_RETRY;

SSL_set_mode(self->ssl, mode);

#if HAVE_SNI

if (server_hostname != NULL)

SSL_set_tlsext_host_name(self->ssl, server_hostname);

/* If the socket is in non-blocking mode or timeout mode, set the BIO

if (sock && sock->sock_timeout >= 0) {

BIO_set_nbio(SSL_get_rbio(self->ssl), 1);

BIO_set_nbio(SSL_get_wbio(self->ssl), 1);

}

PySSL_BEGIN_ALLOW_THREADS

if (socket_type == PY_SSL_CLIENT)

SSL_set_connect_state(self->ssl);

else

SSL_set_accept_state(self->ssl);

PySSL_END_ALLOW_THREADS

self->socket_type = socket_type;

if (sock != NULL) {

self->Socket = PyWeakref_NewRef((PyObject *) sock, NULL);

if (self->Socket == NULL) {

Py_DECREF(self);

return NULL;

}

}

return self;

}

static PyObject *

_ssl__SSLSocket_do_handshake_impl(PySSLSocket *self)

{

int ret;

int err;

int sockstate, nonblocking;

PySocketSockObject *sock = GET_SOCKET(self);

_PyTime_t timeout, deadline = 0;

int has_timeout;

if (sock) {

if (((PyObject*)sock) == Py_None) {

_setSSLError("Underlying socket connection gone",

PY_SSL_ERROR_NO_SOCKET, __FILE__, __LINE__);

return NULL;

}

Py_INCREF(sock);

/* just in case the blocking state of the socket has been changed */

nonblocking = (sock->sock_timeout >= 0);

BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);

BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);

}

timeout = GET_SOCKET_TIMEOUT(sock);

has_timeout = (timeout > 0);

if (has_timeout)

deadline = _PyTime_GetMonotonicClock() + timeout;

/* Actually negotiate SSL connection */

/* XXX If SSL_do_handshake() returns 0, it's also a failure. */

do {

PySSL_BEGIN_ALLOW_THREADS

ret = SSL_do_handshake(self->ssl);

err = SSL_get_error(self->ssl, ret);

PySSL_END_ALLOW_THREADS

if (PyErr_CheckSignals())

goto error;

if (has_timeout)

timeout = deadline - _PyTime_GetMonotonicClock();

if (err == SSL_ERROR_WANT_READ) {

sockstate = PySSL_select(sock, 0, timeout);

} else if (err == SSL_ERROR_WANT_WRITE) {

sockstate = PySSL_select(sock, 1, timeout);

} else {

sockstate = SOCKET_OPERATION_OK;

}

if (sockstate == SOCKET_HAS_TIMED_OUT) {

PyErr_SetString(PySocketModule.timeout_error,

ERRSTR("The handshake operation timed out"));

goto error;

} else if (sockstate == SOCKET_HAS_BEEN_CLOSED) {

PyErr_SetString(PySSLErrorObject,

ERRSTR("Underlying socket has been closed."));

goto error;

} else if (sockstate == SOCKET_TOO_LARGE_FOR_SELECT) {

PyErr_SetString(PySSLErrorObject,

ERRSTR("Underlying socket too large for select()."));

goto error;

} else if (sockstate == SOCKET_IS_NONBLOCKING) {

break;

}

} while (err == SSL_ERROR_WANT_READ || err == SSL_ERROR_WANT_WRITE);

Py_XDECREF(sock);

if (ret < 1)

return PySSL_SetError(self, ret, __FILE__, __LINE__);

if (self->peer_cert)

X509_free (self->peer_cert);

PySSL_BEGIN_ALLOW_THREADS

self->peer_cert = SSL_get_peer_certificate(self->ssl);

PySSL_END_ALLOW_THREADS

self->handshake_done = 1;

Py_INCREF(Py_None);

return Py_None;

error:

Py_XDECREF(sock);

return NULL;

}

static PyObject *

_create_tuple_for_attribute (ASN1_OBJECT *name, ASN1_STRING *value) {

char namebuf[X509_NAME_MAXLEN];

int buflen;

PyObject *name_obj;

PyObject *value_obj;

PyObject *attr;

unsigned char *valuebuf = NULL;

buflen = OBJ_obj2txt(namebuf, sizeof(namebuf), name, 0);

if (buflen < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

goto fail;

}

name_obj = PyUnicode_FromStringAndSize(namebuf, buflen);

if (name_obj == NULL)

goto fail;

buflen = ASN1_STRING_to_UTF8(&valuebuf, value);

if (buflen < 0) {

_setSSLError(NULL, 0, __FILE__, __LINE__);

Py_DECREF(name_obj);

goto fail;

}

value_obj = PyUnicode_DecodeUTF8((char *) valuebuf,

buflen, "strict");

OPENSSL_free(valuebuf);

if (value_obj == NULL) {

Py_DECREF(name_obj);

goto fail;

}

attr = PyTuple_New(2);

if (attr == NULL) {

Py_DECREF(name_obj);

Py_DECREF(value_obj);

goto fail;

}

PyTuple_SET_ITEM(attr, 0, name_obj);

PyTuple_SET_ITEM(attr, 1, value_obj);

return attr;

fail:

return NULL;

}

static PyObject *

_create_tuple_for_X509_NAME (X509_NAME *xname)

{

PyObject *dn = NULL; /* tuple which represents the "distinguished name" */

PyObject *rdn = NULL; /* tuple to hold a "relative distinguished name" */

PyObject *rdnt;

PyObject *attr = NULL; /* tuple to hold an attribute */

int entry_count = X509_NAME_entry_count(xname);

X509_NAME_ENTRY *entry;

ASN1_OBJECT *name;

ASN1_STRING *value;

int index_counter;

int rdn_level = -1;

int retcode;

dn = PyList_New(0);

if (dn == NULL)

return NULL;

/* now create another tuple to hold the top-level RDN */

rdn = PyList_New(0);

if (rdn == NULL)

goto fail0;

for (index_counter = 0;

index_counter < entry_count;

index_counter++)

{

entry = X509_NAME_get_entry(xname, index_counter);

/* check to see if we've gotten to a new RDN */

if (rdn_level >= 0) {

if (rdn_level != X509_NAME_ENTRY_set(entry)) {

/* yes, new RDN */

/* add old RDN to DN */

rdnt = PyList_AsTuple(rdn);

Py_DECREF(rdn);

if (rdnt == NULL)

goto fail0;

retcode = PyList_Append(dn, rdnt);

Py_DECREF(rdnt);

if (retcode < 0)

goto fail0;

/* create new RDN */

rdn = PyList_New(0);

if (rdn == NULL)

goto fail0;

}

}

rdn_level = X509_NAME_ENTRY_set(entry);

/* now add this attribute to the current RDN */

name = X509_NAME_ENTRY_get_object(entry);

value = X509_NAME_ENTRY_get_data(entry);

attr = _create_tuple_for_attribute(name, value);

/*

if (attr == NULL)

goto fail1;

retcode = PyList_Append(rdn, attr);

Py_DECREF(attr);

if (retcode < 0)

goto fail1;

}

/* now, there's typically a dangling RDN */

if (rdn != NULL) {

if (PyList_GET_SIZE(rdn) > 0) {

rdnt = PyList_AsTuple(rdn);

Py_DECREF(rdn);

if (rdnt == NULL)

goto fail0;

retcode = PyList_Append(dn, rdnt);

Py_DECREF(rdnt);

if (retcode < 0)

goto fail0;

}

else {

Py_DECREF(rdn);

}

}

/* convert list to tuple */

rdnt = PyList_AsTuple(dn);

Py_DECREF(dn);

if (rdnt == NULL)

return NULL;

return rdnt;

fail1:

Py_XDECREF(rdn);

fail0:

Py_XDECREF(dn);

return NULL;

}

static PyObject *

_get_peer_alt_names (X509 *certificate) {

/* this code follows the procedure outlined in

int i, j;

PyObject *peer_alt_names = Py_None;

PyObject *v = NULL, *t;

X509_EXTENSION *ext = NULL;

GENERAL_NAMES *names = NULL;

GENERAL_NAME *name;

const X509V3_EXT_METHOD *method;

BIO *biobuf = NULL;

char buf[2048];

char *vptr;

int len;

const unsigned char *p;

if (certificate == NULL)

return peer_alt_names;

/* get a memory buffer */

biobuf = BIO_new(BIO_s_mem());

i = -1;

while ((i = X509_get_ext_by_NID(

certificate, NID_subject_alt_name, i)) >= 0) {

if (peer_alt_names == Py_None) {

peer_alt_names = PyList_New(0);

if (peer_alt_names == NULL)

goto fail;

}

/* now decode the altName */

ext = X509_get_ext(certificate, i);

if(!(method = X509V3_EXT_get(ext))) {

PyErr_SetString

(PySSLErrorObject,

ERRSTR("No method for internalizing subjectAltName!"));

goto fail;

}

p = X509_EXTENSION_get_data(ext)->data;

if (method->it)

names = (GENERAL_NAMES*)

(ASN1_item_d2i(NULL,

&p,

X509_EXTENSION_get_data(ext)->length,

ASN1_ITEM_ptr(method->it)));

else

names = (GENERAL_NAMES*)

(method->d2i(NULL,

&p,

X509_EXTENSION_get_data(ext)->length));

for(j = 0; j < sk_GENERAL_NAME_num(names); j++) {

/* get a rendering of each name in the set of names */

int gntype;

ASN1_STRING *as = NULL;

name = sk_GENERAL_NAME_value(names, j);

gntype = name->type;

switch (gntype) {

case GEN_DIRNAME:

/* we special-case DirName as a tuple of

t = PyTuple_New(2);

if (t == NULL) {

goto fail;

}

v = PyUnicode_FromString("DirName");

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 0, v);

v = _create_tuple_for_X509_NAME (name->d.dirn);

if (v == NULL) {

Py_DECREF(t);

goto fail;

}

PyTuple_SET_ITEM(t, 1, v);

break;

case GEN_EMAIL:

case GEN_DNS:

case GEN_URI:

/* GENERAL_NAME_print() doesn't handle NULL bytes in ASN1_string

t = PyTuple_New(2);

if (t == NULL)

goto fail;

switch (gntype) {

case GEN_EMAIL:

v = PyUnicode_FromString("email");

as = name->d.rfc822Name;

break;

case GEN_DNS:

v = PyUnicode_FromString("DNS");

as = name->d.dNSName;

break;

case GEN_URI:

v = PyUnicode_FromString("URI");