Lines Matching refs:self
418 SSLError_str(PyOSErrorObject *self)
420 if (self->strerror != NULL && PyUnicode_Check(self->strerror)) {
421 Py_INCREF(self->strerror);
422 return self->strerror;
425 return PyObject_Str(self->args);
718 _ssl_configure_hostname(PySSLSocket *self, const char* server_hostname)
750 self->server_hostname = hostname;
754 if (!SSL_set_tlsext_host_name(self->ssl, server_hostname)) {
755 _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
759 if (self->ctx->check_hostname) {
760 X509_VERIFY_PARAM *param = SSL_get0_param(self->ssl);
764 _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
770 _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
790 PySSLSocket *self;
809 self = PyObject_GC_New(PySSLSocket,
811 if (self == NULL)
814 self->ssl = NULL;
815 self->Socket = NULL;
816 self->ctx = sslctx;
818 self->shutdown_seen_zero = 0;
819 self->owner = NULL;
820 self->server_hostname = NULL;
821 self->err = err;
822 self->exc_type = NULL;
823 self->exc_value = NULL;
824 self->exc_tb = NULL;
830 self->ssl = SSL_new(ctx);
832 if (self->ssl == NULL) {
833 Py_DECREF(self);
834 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
839 X509_VERIFY_PARAM *ssl_params = SSL_get0_param(self->ssl);
842 SSL_set_app_data(self->ssl, self);
844 SSL_set_fd(self->ssl, Py_SAFE_DOWNCAST(sock->sock_fd, SOCKET_T, int));
851 SSL_set_bio(self->ssl, inbio->bio, outbio->bio);
853 SSL_set_mode(self->ssl,
862 int mode = SSL_get_verify_mode(self->ssl);
865 verify_cb = SSL_get_verify_callback(self->ssl);
867 SSL_set_verify(self->ssl, mode, verify_cb);
871 SSL_set_post_handshake_auth(self->ssl, 1);
877 if (_ssl_configure_hostname(self, server_hostname) < 0) {
878 Py_DECREF(self);
886 BIO_set_nbio(SSL_get_rbio(self->ssl), 1);
887 BIO_set_nbio(SSL_get_wbio(self->ssl), 1);
892 SSL_set_connect_state(self->ssl);
894 SSL_set_accept_state(self->ssl);
897 self->socket_type = socket_type;
899 self->Socket = PyWeakref_NewRef((PyObject *) sock, NULL);
900 if (self->Socket == NULL) {
901 Py_DECREF(self);
906 if (PySSL_set_owner(self, owner, NULL) == -1) {
907 Py_DECREF(self);
912 if (PySSL_set_session(self, session, NULL) == -1) {
913 Py_DECREF(self);
918 PyObject_GC_Track(self);
919 return self;
929 _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self)
935 PySocketSockObject *sock = GET_SOCKET(self);
941 _setSSLError(get_state_sock(self),
950 BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
951 BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
964 ret = SSL_do_handshake(self->ssl);
965 err = _PySSL_errno(ret < 1, self->ssl, ret);
967 self->err = err;
988 PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
992 PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
1002 return PySSL_SetError(self, ret, __FILE__, __LINE__);
1003 if (PySSL_ChainExceptions(self) < 0)
1008 PySSL_ChainExceptions(self);
1819 _ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode)
1826 if (!SSL_is_init_finished(self->ssl)) {
1831 peer_cert = SSL_get_peer_certificate(self->ssl);
1837 result = _certificate_to_der(get_state_sock(self), peer_cert);
1839 verification = SSL_CTX_get_verify_mode(SSL_get_SSL_CTX(self->ssl));
1843 result = _decode_certificate(get_state_sock(self), peer_cert);
1855 _ssl__SSLSocket_get_verified_chain_impl(PySSLSocket *self)
1859 STACK_OF(X509) *chain = SSL_get0_verified_chain(self->ssl);
1863 return _PySSL_CertificateFromX509Stack(self->ctx->state, chain, 1);
1872 _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self)
1878 STACK_OF(X509) *chain = SSL_get_peer_cert_chain(self->ssl);
1882 retval = _PySSL_CertificateFromX509Stack(self->ctx->state, chain, 1);
1887 if (self->socket_type == PY_SSL_SERVER) {
1889 X509 *peer = SSL_get_peer_certificate(self->ssl);
1896 peerobj = _PySSL_CertificateFromX509(self->ctx->state, peer, 0);
2010 _ssl__SSLSocket_shared_ciphers_impl(PySSLSocket *self)
2027 server_ciphers = SSL_get_ciphers(self->ssl);
2030 client_ciphers = SSL_get_client_ciphers(self->ssl);
2059 _ssl__SSLSocket_cipher_impl(PySSLSocket *self)
2064 if (self->ssl == NULL)
2066 current = SSL_get_current_cipher(self->ssl);
2077 _ssl__SSLSocket_version_impl(PySSLSocket *self)
2082 if (self->ssl == NULL)
2084 if (!SSL_is_init_finished(self->ssl)) {
2088 version = SSL_get_version(self->ssl);
2099 _ssl__SSLSocket_selected_alpn_protocol_impl(PySSLSocket *self)
2105 SSL_get0_alpn_selected(self->ssl, &out, &outlen);
2117 _ssl__SSLSocket_compression_impl(PySSLSocket *self)
2126 if (self->ssl == NULL)
2128 comp_method = SSL_get_current_compression(self->ssl);
2138 static PySSLContext *PySSL_get_context(PySSLSocket *self, void *closure) {
2139 Py_INCREF(self->ctx);
2140 return self->ctx;
2143 static int PySSL_set_context(PySSLSocket *self, PyObject *value,
2146 if (PyObject_TypeCheck(value, self->ctx->state->PySSLContext_Type)) {
2148 Py_SETREF(self->ctx, (PySSLContext *)value);
2149 SSL_set_SSL_CTX(self->ssl, self->ctx->ctx);
2152 self->ssl,
2153 self->ctx->msg_cb ? _PySSL_msg_callback : NULL
2173 PySSL_get_server_side(PySSLSocket *self, void *c)
2175 return PyBool_FromLong(self->socket_type == PY_SSL_SERVER);
2182 PySSL_get_server_hostname(PySSLSocket *self, void *c)
2184 if (self->server_hostname == NULL)
2186 Py_INCREF(self->server_hostname);
2187 return self->server_hostname;
2194 PySSL_get_owner(PySSLSocket *self, void *c)
2198 if (self->owner == NULL)
2201 owner = PyWeakref_GetObject(self->owner);
2207 PySSL_set_owner(PySSLSocket *self, PyObject *value, void *c)
2209 Py_XSETREF(self->owner, PyWeakref_NewRef(value, NULL));
2210 if (self->owner == NULL)
2217 Passed as \"self\" in servername callback.");
2220 PySSL_traverse(PySSLSocket *self, visitproc visit, void *arg)
2222 Py_VISIT(self->exc_type);
2223 Py_VISIT(self->exc_value);
2224 Py_VISIT(self->exc_tb);
2225 Py_VISIT(Py_TYPE(self));
2230 PySSL_clear(PySSLSocket *self)
2232 Py_CLEAR(self->exc_type);
2233 Py_CLEAR(self->exc_value);
2234 Py_CLEAR(self->exc_tb);
2239 PySSL_dealloc(PySSLSocket *self)
2241 PyTypeObject *tp = Py_TYPE(self);
2242 PyObject_GC_UnTrack(self);
2243 if (self->ssl) {
2244 SSL_free(self->ssl);
2246 Py_XDECREF(self->Socket);
2247 Py_XDECREF(self->ctx);
2248 Py_XDECREF(self->server_hostname);
2249 Py_XDECREF(self->owner);
2250 PyObject_GC_Del(self);
2335 _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b)
2343 PySocketSockObject *sock = GET_SOCKET(self);
2349 _setSSLError(get_state_sock(self),
2360 BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
2361 BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
2376 PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
2380 PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
2387 retval = SSL_write_ex(self->ssl, b->buf, (size_t)b->len, &count);
2388 err = _PySSL_errno(retval == 0, self->ssl, retval);
2390 self->err = err;
2412 PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
2423 return PySSL_SetError(self, retval, __FILE__, __LINE__);
2424 if (PySSL_ChainExceptions(self) < 0)
2429 PySSL_ChainExceptions(self);
2440 _ssl__SSLSocket_pending_impl(PySSLSocket *self)
2447 count = SSL_pending(self->ssl);
2448 err = _PySSL_errno(count < 0, self->ssl, count);
2450 self->err = err;
2453 return PySSL_SetError(self, count, __FILE__, __LINE__);
2470 _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len,
2481 PySocketSockObject *sock = GET_SOCKET(self);
2492 _setSSLError(get_state_sock(self),
2529 BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
2530 BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
2540 retval = SSL_read_ex(self->ssl, mem, (size_t)len, &count);
2541 err = _PySSL_errno(retval == 0, self->ssl, retval);
2543 self->err = err;
2557 SSL_get_shutdown(self->ssl) == SSL_RECEIVED_SHUTDOWN)
2576 PySSL_SetError(self, retval, __FILE__, __LINE__);
2579 if (self->exc_type != NULL)
2593 PySSL_ChainExceptions(self);
2607 _ssl__SSLSocket_shutdown_impl(PySSLSocket *self)
2613 PySocketSockObject *sock = GET_SOCKET(self);
2620 _setSSLError(get_state_sock(self),
2629 BIO_set_nbio(SSL_get_rbio(self->ssl), nonblocking);
2630 BIO_set_nbio(SSL_get_wbio(self->ssl), nonblocking);
2649 if (self->shutdown_seen_zero)
2650 SSL_set_read_ahead(self->ssl, 0);
2651 ret = SSL_shutdown(self->ssl);
2652 err = _PySSL_errno(ret < 0, self->ssl, ret);
2654 self->err = err;
2666 self->shutdown_seen_zero = 1;
2692 PyErr_SetString(get_state_sock(self)->PySSLErrorObject,
2702 PySSL_SetError(self, ret, __FILE__, __LINE__);
2705 if (self->exc_type != NULL)
2715 PySSL_ChainExceptions(self);
2731 _ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
2739 if (SSL_session_reused(self->ssl) ^ !self->socket_type) {
2741 len = SSL_get_finished(self->ssl, buf, PySSL_CB_MAXLEN);
2745 len = SSL_get_peer_finished(self->ssl, buf, PySSL_CB_MAXLEN);
2771 _ssl__SSLSocket_verify_client_post_handshake_impl(PySSLSocket *self)
2775 int err = SSL_verify_client_post_handshake(self->ssl);
2777 return _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
2830 PySSL_get_session(PySSLSocket *self, void *closure) {
2838 session = SSL_get0_session(self->ssl); /* borrowed reference */
2845 session = SSL_get1_session(self->ssl);
2849 pysess = PyObject_GC_New(PySSLSession, self->ctx->state->PySSLSession_Type);
2855 assert(self->ctx);
2856 pysess->ctx = self->ctx;
2863 static int PySSL_set_session(PySSLSocket *self, PyObject *value,
2870 if (!Py_IS_TYPE(value, get_state_sock(self)->PySSLSession_Type)) {
2876 if (self->ctx->ctx != pysess->ctx->ctx) {
2881 if (self->socket_type != PY_SSL_CLIENT) {
2886 if (SSL_is_init_finished(self->ssl)) {
2895 result = SSL_set_session(self->ssl, session);
2899 _setSSLError(get_state_sock(self), NULL, 0, __FILE__, __LINE__);
2911 PySSL_get_session_reused(PySSLSocket *self, void *closure) {
2912 if (SSL_session_reused(self->ssl)) {
2979 _set_verify_mode(PySSLContext *self, enum py_ssl_cert_requirements n)
3004 verify_cb = SSL_CTX_get_verify_callback(self->ctx);
3005 SSL_CTX_set_verify(self->ctx, mode, verify_cb);
3020 PySSLContext *self;
3098 self = (PySSLContext *) type->tp_alloc(type, 0);
3099 if (self == NULL) {
3103 self->ctx = ctx;
3104 self->hostflags = X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS;
3105 self->protocol = proto_version;
3106 self->msg_cb = NULL;
3107 self->keylog_filename = NULL;
3108 self->keylog_bio = NULL;
3109 self->alpn_protocols = NULL;
3110 self->set_sni_cb = NULL;
3111 self->state = get_ssl_state(module);
3115 self->check_hostname = 1;
3116 if (_set_verify_mode(self, PY_SSL_CERT_REQUIRED) == -1) {
3117 Py_DECREF(self);
3121 self->check_hostname = 0;
3122 if (_set_verify_mode(self, PY_SSL_CERT_NONE) == -1) {
3123 Py_DECREF(self);
3147 SSL_CTX_set_options(self->ctx, options);
3163 Py_DECREF(self);
3165 PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
3189 SSL_CTX_set_mode(self->ctx, SSL_MODE_RELEASE_BUFFERS);
3192 SSL_CTX_set_session_id_context(self->ctx, (const unsigned char *) SID_CTX,
3196 params = SSL_CTX_get0_param(self->ctx);
3200 X509_VERIFY_PARAM_set_hostflags(params, self->hostflags);
3203 self->post_handshake_auth = 0;
3204 SSL_CTX_set_post_handshake_auth(self->ctx, self->post_handshake_auth);
3207 return (PyObject *)self;
3209 Py_XDECREF(self);
3215 context_traverse(PySSLContext *self, visitproc visit, void *arg)
3217 Py_VISIT(self->set_sni_cb);
3218 Py_VISIT(self->msg_cb);
3219 Py_VISIT(Py_TYPE(self));
3224 context_clear(PySSLContext *self)
3226 Py_CLEAR(self->set_sni_cb);
3227 Py_CLEAR(self->msg_cb);
3228 Py_CLEAR(self->keylog_filename);
3229 if (self->keylog_bio != NULL) {
3231 BIO_free_all(self->keylog_bio);
3233 self->keylog_bio = NULL;
3239 context_dealloc(PySSLContext *self)
3241 PyTypeObject *tp = Py_TYPE(self);
3243 PyObject_GC_UnTrack(self);
3244 context_clear(self);
3245 SSL_CTX_free(self->ctx);
3246 PyMem_FREE(self->alpn_protocols);
3247 Py_TYPE(self)->tp_free(self);
3258 _ssl__SSLContext_set_ciphers_impl(PySSLContext *self, const char *cipherlist)
3261 int ret = SSL_CTX_set_cipher_list(self->ctx, cipherlist);
3267 PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
3279 _ssl__SSLContext_get_ciphers_impl(PySSLContext *self)
3288 ssl = SSL_new(self->ctx);
3290 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
3361 _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self,
3371 PyMem_Free(self->alpn_protocols);
3372 self->alpn_protocols = PyMem_Malloc(protos->len);
3373 if (!self->alpn_protocols)
3375 memcpy(self->alpn_protocols, protos->buf, protos->len);
3376 self->alpn_protocols_len = (unsigned int)protos->len;
3378 if (SSL_CTX_set_alpn_protos(self->ctx, self->alpn_protocols, self->alpn_protocols_len))
3380 SSL_CTX_set_alpn_select_cb(self->ctx, _selectALPN_cb, self);
3386 get_verify_mode(PySSLContext *self, void *c)
3391 switch (SSL_CTX_get_verify_mode(self->ctx) & mask) {
3399 PyErr_SetString(get_state_ctx(self)->PySSLErrorObject,
3405 set_verify_mode(PySSLContext *self, PyObject *arg, void *c)
3410 if (n == PY_SSL_CERT_NONE && self->check_hostname) {
3416 return _set_verify_mode(self, n);
3420 get_verify_flags(PySSLContext *self, void *c)
3425 param = SSL_CTX_get0_param(self->ctx);
3431 set_verify_flags(PySSLContext *self, PyObject *arg, void *c)
3438 param = SSL_CTX_get0_param(self->ctx);
3444 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
3450 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
3459 set_min_max_proto_version(PySSLContext *self, PyObject *arg, int what)
3471 switch(self->protocol) {
3520 result = SSL_CTX_set_min_proto_version(self->ctx, v);
3534 result = SSL_CTX_set_max_proto_version(self->ctx, v);
3545 get_minimum_version(PySSLContext *self, void *c)
3547 int v = SSL_CTX_get_min_proto_version(self->ctx);
3555 set_minimum_version(PySSLContext *self, PyObject *arg, void *c)
3557 return set_min_max_proto_version(self, arg, 0);
3561 get_maximum_version(PySSLContext *self, void *c)
3563 int v = SSL_CTX_get_max_proto_version(self->ctx);
3571 set_maximum_version(PySSLContext *self, PyObject *arg, void *c)
3573 return set_min_max_proto_version(self, arg, 1);
3578 get_num_tickets(PySSLContext *self, void *c)
3580 return PyLong_FromSize_t(SSL_CTX_get_num_tickets(self->ctx));
3584 set_num_tickets(PySSLContext *self, PyObject *arg, void *c)
3593 if (self->protocol != PY_SSL_VERSION_TLS_SERVER) {
3598 if (SSL_CTX_set_num_tickets(self->ctx, num) != 1) {
3610 get_security_level(PySSLContext *self, void *c)
3612 return PyLong_FromLong(SSL_CTX_get_security_level(self->ctx));
3617 get_options(PySSLContext *self, void *c)
3619 return PyLong_FromLong(SSL_CTX_get_options(self->ctx));
3623 set_options(PySSLContext *self, PyObject *arg, void *c)
3633 opts = SSL_CTX_get_options(self->ctx);
3644 SSL_CTX_clear_options(self->ctx, clear);
3647 SSL_CTX_set_options(self->ctx, set);
3652 get_host_flags(PySSLContext *self, void *c)
3654 return PyLong_FromUnsignedLong(self->hostflags);
3658 set_host_flags(PySSLContext *self, PyObject *arg, void *c)
3666 param = SSL_CTX_get0_param(self->ctx);
3667 self->hostflags = new_flags;
3673 get_check_hostname(PySSLContext *self, void *c)
3675 return PyBool_FromLong(self->check_hostname);
3679 set_check_hostname(PySSLContext *self, PyObject *arg, void *c)
3685 SSL_CTX_get_verify_mode(self->ctx) == SSL_VERIFY_NONE) {
3687 if (_set_verify_mode(self, PY_SSL_CERT_REQUIRED) == -1) {
3691 self->check_hostname = check_hostname;
3696 get_post_handshake_auth(PySSLContext *self, void *c) {
3698 return PyBool_FromLong(self->post_handshake_auth);
3706 set_post_handshake_auth(PySSLContext *self, PyObject *arg, void *c) {
3716 self->post_handshake_auth = pha;
3726 get_protocol(PySSLContext *self, void *c) {
3727 return PyLong_FromLong(self->protocol);
3848 _ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
3853 pem_password_cb *orig_passwd_cb = SSL_CTX_get_default_passwd_cb(self->ctx);
3854 void *orig_passwd_userdata = SSL_CTX_get_default_passwd_cb_userdata(self->ctx);
3883 SSL_CTX_set_default_passwd_cb(self->ctx, _password_callback);
3884 SSL_CTX_set_default_passwd_cb_userdata(self->ctx, &pw_info);
3887 r = SSL_CTX_use_certificate_chain_file(self->ctx,
3900 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
3905 r = SSL_CTX_use_PrivateKey_file(self->ctx,
3921 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
3926 r = SSL_CTX_check_private_key(self->ctx);
3929 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
3932 SSL_CTX_set_default_passwd_cb(self->ctx, orig_passwd_cb);
3933 SSL_CTX_set_default_passwd_cb_userdata(self->ctx, orig_passwd_userdata);
3938 SSL_CTX_set_default_passwd_cb(self->ctx, orig_passwd_cb);
3939 SSL_CTX_set_default_passwd_cb_userdata(self->ctx, orig_passwd_userdata);
3949 _add_ca_certs(PySSLContext *self, const void *data, Py_ssize_t len,
3970 _setSSLError(get_state_ctx(self), "Can't allocate buffer", 0, __FILE__, __LINE__);
3974 store = SSL_CTX_get_cert_store(self->ctx);
3985 SSL_CTX_get_default_passwd_cb(self->ctx),
3986 SSL_CTX_get_default_passwd_cb_userdata(self->ctx)
4015 _setSSLError(get_state_ctx(self), msg, 0, __FILE__, __LINE__);
4030 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4050 _ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
4098 r = _add_ca_certs(self,
4119 r = _add_ca_certs(self, buf.buf, buf.len, SSL_FILETYPE_ASN1);
4141 r = SSL_CTX_load_verify_locations(self->ctx, cafile_buf, capath_buf);
4149 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4176 _ssl__SSLContext_load_dh_params(PySSLContext *self, PyObject *filepath)
4197 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4201 if (!SSL_CTX_set_tmp_dh(self->ctx, dh)) {
4203 return _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4211 sock: object(subclass_of="get_state_ctx(self)->Sock_Type")
4221 _ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
4236 res = (PyObject *) newPySSLSocket(self, (PySocketSockObject *)sock,
4247 incoming: object(subclass_of="get_state_ctx(self)->PySSLMemoryBIO_Type", type="PySSLMemoryBIO *")
4248 outgoing: object(subclass_of="get_state_ctx(self)->PySSLMemoryBIO_Type", type="PySSLMemoryBIO *")
4258 _ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
4274 res = (PyObject *) newPySSLSocket(self, NULL, server_side, hostname,
4287 _ssl__SSLContext_session_stats_impl(PySSLContext *self)
4296 value = PyLong_FromLong(SSL_CTX_sess_ ## SSL_NAME (self->ctx)); \
4331 _ssl__SSLContext_set_default_verify_paths_impl(PySSLContext *self)
4336 rc = SSL_CTX_set_default_verify_paths(self->ctx);
4339 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4353 _ssl__SSLContext_set_ecdh_curve(PySSLContext *self, PyObject *name)
4371 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4374 SSL_CTX_set_tmp_ecdh(self->ctx, key);
4377 if (!SSL_CTX_set1_groups(self->ctx, &nid, 1)) {
4378 _setSSLError(get_state_ctx(self), NULL, 0, __FILE__, __LINE__);
4490 get_sni_callback(PySSLContext *self, void *c)
4492 PyObject *cb = self->set_sni_cb;
4501 set_sni_callback(PySSLContext *self, PyObject *arg, void *c)
4503 if (self->protocol == PY_SSL_VERSION_TLS_CLIENT) {
4508 Py_CLEAR(self->set_sni_cb);
4510 SSL_CTX_set_tlsext_servername_callback(self->ctx, NULL);
4514 SSL_CTX_set_tlsext_servername_callback(self->ctx, NULL);
4520 self->set_sni_cb = arg;
4521 SSL_CTX_set_tlsext_servername_callback(self->ctx, _servername_callback);
4522 SSL_CTX_set_tlsext_servername_arg(self->ctx, self);
4591 _ssl__SSLContext_cert_store_stats_impl(PySSLContext *self)
4599 store = SSL_CTX_get_cert_store(self->ctx);
4642 _ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form)
4654 store = SSL_CTX_get_cert_store(self->ctx);
4676 ci = _certificate_to_der(get_state_ctx(self), cert);
4678 ci = _decode_certificate(get_state_ctx(self), cert);
4789 PySSLMemoryBIO *self;
4803 self = (PySSLMemoryBIO *) type->tp_alloc(type, 0);
4804 if (self == NULL) {
4808 self->bio = bio;
4809 self->eof_written = 0;
4811 return (PyObject *) self;
4815 memory_bio_traverse(PySSLMemoryBIO *self, visitproc visit, void *arg)
4817 Py_VISIT(Py_TYPE(self));
4822 memory_bio_dealloc(PySSLMemoryBIO *self)
4824 PyTypeObject *tp = Py_TYPE(self);
4825 PyObject_GC_UnTrack(self);
4826 BIO_free(self->bio);
4827 Py_TYPE(self)->tp_free(self);
4832 memory_bio_get_pending(PySSLMemoryBIO *self, void *c)
4834 return PyLong_FromSize_t(BIO_ctrl_pending(self->bio));
4841 memory_bio_get_eof(PySSLMemoryBIO *self, void *c)
4843 return PyBool_FromLong((BIO_ctrl_pending(self->bio) == 0)
4844 && self->eof_written);
4864 _ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len)
4870 avail = (int)Py_MIN(BIO_ctrl_pending(self->bio), INT_MAX);
4878 nbytes = BIO_read(self->bio, PyBytes_AS_STRING(result), len);
4880 _sslmodulestate *state = get_state_mbio(self);
4905 _ssl_MemoryBIO_write_impl(PySSLMemoryBIO *self, Py_buffer *b)
4916 if (self->eof_written) {
4917 PyObject *module = PyType_GetModule(Py_TYPE(self));
4925 nbytes = BIO_write(self->bio, b->buf, (int)b->len);
4927 _sslmodulestate *state = get_state_mbio(self);
4944 _ssl_MemoryBIO_write_eof_impl(PySSLMemoryBIO *self)
4947 self->eof_written = 1;
4950 BIO_clear_retry_flags(self->bio);
4951 BIO_set_mem_eof_return(self->bio, 0);
4993 PySSLSession_dealloc(PySSLSession *self)
4995 PyTypeObject *tp = Py_TYPE(self);
4997 PyObject_GC_UnTrack(self);
4998 Py_XDECREF(self->ctx);
4999 if (self->session != NULL) {
5000 SSL_SESSION_free(self->session);
5002 PyObject_GC_Del(self);
5065 PySSLSession_traverse(PySSLSession *self, visitproc visit, void *arg)
5067 Py_VISIT(self->ctx);
5068 Py_VISIT(Py_TYPE(self));
5073 PySSLSession_clear(PySSLSession *self)
5075 Py_CLEAR(self->ctx);
5081 PySSLSession_get_time(PySSLSession *self, void *closure) {
5082 return PyLong_FromLong(SSL_SESSION_get_time(self->session));
5090 PySSLSession_get_timeout(PySSLSession *self, void *closure) {
5091 return PyLong_FromLong(SSL_SESSION_get_timeout(self->session));
5099 PySSLSession_get_ticket_lifetime_hint(PySSLSession *self, void *closure) {
5100 unsigned long hint = SSL_SESSION_get_ticket_lifetime_hint(self->session);
5109 PySSLSession_get_session_id(PySSLSession *self, void *closure) {
5112 id = SSL_SESSION_get_id(self->session, &len);
5121 PySSLSession_get_has_ticket(PySSLSession *self, void *closure) {
5122 if (SSL_SESSION_has_ticket(self->session)) {