| /*[clinic input] |
| preserve |
| [clinic start generated code]*/ |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_do_handshake__doc__, |
| "do_handshake($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_DO_HANDSHAKE_METHODDEF \ |
| {"do_handshake", (PyCFunction)_ssl__SSLSocket_do_handshake, METH_NOARGS, _ssl__SSLSocket_do_handshake__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_do_handshake(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_do_handshake_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__test_decode_cert__doc__, |
| "_test_decode_cert($module, path, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__TEST_DECODE_CERT_METHODDEF \ |
| {"_test_decode_cert", (PyCFunction)_ssl__test_decode_cert, METH_O, _ssl__test_decode_cert__doc__}, |
| |
| static PyObject * |
| _ssl__test_decode_cert_impl(PyObject *module, PyObject *path); |
| |
| static PyObject * |
| _ssl__test_decode_cert(PyObject *module, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| PyObject *path; |
| |
| if (!PyUnicode_FSConverter(arg, &path)) { |
| goto exit; |
| } |
| return_value = _ssl__test_decode_cert_impl(module, path); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_getpeercert__doc__, |
| "getpeercert($self, der=False, /)\n" |
| "--\n" |
| "\n" |
| "Returns the certificate for the peer.\n" |
| "\n" |
| "If no certificate was provided, returns None. If a certificate was\n" |
| "provided, but not validated, returns an empty dictionary. Otherwise\n" |
| "returns a dict containing information about the peer certificate.\n" |
| "\n" |
| "If the optional argument is True, returns a DER-encoded copy of the\n" |
| "peer certificate, or None if no certificate was provided. This will\n" |
| "return the certificate even if it wasn\'t validated."); |
| |
| #define _SSL__SSLSOCKET_GETPEERCERT_METHODDEF \ |
| {"getpeercert", (PyCFunction)(void(*)(void))_ssl__SSLSocket_getpeercert, METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode); |
| |
| static PyObject * |
| _ssl__SSLSocket_getpeercert(PySSLSocket *self, PyObject *const *args, Py_ssize_t nargs) |
| { |
| PyObject *return_value = NULL; |
| int binary_mode = 0; |
| |
| if (!_PyArg_CheckPositional("getpeercert", nargs, 0, 1)) { |
| goto exit; |
| } |
| if (nargs < 1) { |
| goto skip_optional; |
| } |
| binary_mode = PyObject_IsTrue(args[0]); |
| if (binary_mode < 0) { |
| goto exit; |
| } |
| skip_optional: |
| return_value = _ssl__SSLSocket_getpeercert_impl(self, binary_mode); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_shared_ciphers__doc__, |
| "shared_ciphers($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_SHARED_CIPHERS_METHODDEF \ |
| {"shared_ciphers", (PyCFunction)_ssl__SSLSocket_shared_ciphers, METH_NOARGS, _ssl__SSLSocket_shared_ciphers__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_shared_ciphers_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_shared_ciphers(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_shared_ciphers_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_cipher__doc__, |
| "cipher($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_CIPHER_METHODDEF \ |
| {"cipher", (PyCFunction)_ssl__SSLSocket_cipher, METH_NOARGS, _ssl__SSLSocket_cipher__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_cipher_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_cipher(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_cipher_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_version__doc__, |
| "version($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_VERSION_METHODDEF \ |
| {"version", (PyCFunction)_ssl__SSLSocket_version, METH_NOARGS, _ssl__SSLSocket_version__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_version_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_version(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_version_impl(self); |
| } |
| |
| #if (HAVE_NPN) |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_selected_npn_protocol__doc__, |
| "selected_npn_protocol($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_SELECTED_NPN_PROTOCOL_METHODDEF \ |
| {"selected_npn_protocol", (PyCFunction)_ssl__SSLSocket_selected_npn_protocol, METH_NOARGS, _ssl__SSLSocket_selected_npn_protocol__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_selected_npn_protocol_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_selected_npn_protocol(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_selected_npn_protocol_impl(self); |
| } |
| |
| #endif /* (HAVE_NPN) */ |
| |
| #if (HAVE_ALPN) |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_selected_alpn_protocol__doc__, |
| "selected_alpn_protocol($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF \ |
| {"selected_alpn_protocol", (PyCFunction)_ssl__SSLSocket_selected_alpn_protocol, METH_NOARGS, _ssl__SSLSocket_selected_alpn_protocol__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_selected_alpn_protocol_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_selected_alpn_protocol(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_selected_alpn_protocol_impl(self); |
| } |
| |
| #endif /* (HAVE_ALPN) */ |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_compression__doc__, |
| "compression($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLSOCKET_COMPRESSION_METHODDEF \ |
| {"compression", (PyCFunction)_ssl__SSLSocket_compression, METH_NOARGS, _ssl__SSLSocket_compression__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_compression_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_compression(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_compression_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_write__doc__, |
| "write($self, b, /)\n" |
| "--\n" |
| "\n" |
| "Writes the bytes-like object b into the SSL object.\n" |
| "\n" |
| "Returns the number of bytes written."); |
| |
| #define _SSL__SSLSOCKET_WRITE_METHODDEF \ |
| {"write", (PyCFunction)_ssl__SSLSocket_write, METH_O, _ssl__SSLSocket_write__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b); |
| |
| static PyObject * |
| _ssl__SSLSocket_write(PySSLSocket *self, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| Py_buffer b = {NULL, NULL}; |
| |
| if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) { |
| goto exit; |
| } |
| if (!PyBuffer_IsContiguous(&b, 'C')) { |
| _PyArg_BadArgument("write", "argument", "contiguous buffer", arg); |
| goto exit; |
| } |
| return_value = _ssl__SSLSocket_write_impl(self, &b); |
| |
| exit: |
| /* Cleanup for b */ |
| if (b.obj) { |
| PyBuffer_Release(&b); |
| } |
| |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_pending__doc__, |
| "pending($self, /)\n" |
| "--\n" |
| "\n" |
| "Returns the number of already decrypted bytes available for read, pending on the connection."); |
| |
| #define _SSL__SSLSOCKET_PENDING_METHODDEF \ |
| {"pending", (PyCFunction)_ssl__SSLSocket_pending, METH_NOARGS, _ssl__SSLSocket_pending__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_pending_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_pending(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_pending_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_read__doc__, |
| "read(size, [buffer])\n" |
| "Read up to size bytes from the SSL socket."); |
| |
| #define _SSL__SSLSOCKET_READ_METHODDEF \ |
| {"read", (PyCFunction)_ssl__SSLSocket_read, METH_VARARGS, _ssl__SSLSocket_read__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_read_impl(PySSLSocket *self, int len, int group_right_1, |
| Py_buffer *buffer); |
| |
| static PyObject * |
| _ssl__SSLSocket_read(PySSLSocket *self, PyObject *args) |
| { |
| PyObject *return_value = NULL; |
| int len; |
| int group_right_1 = 0; |
| Py_buffer buffer = {NULL, NULL}; |
| |
| switch (PyTuple_GET_SIZE(args)) { |
| case 1: |
| if (!PyArg_ParseTuple(args, "i:read", &len)) { |
| goto exit; |
| } |
| break; |
| case 2: |
| if (!PyArg_ParseTuple(args, "iw*:read", &len, &buffer)) { |
| goto exit; |
| } |
| group_right_1 = 1; |
| break; |
| default: |
| PyErr_SetString(PyExc_TypeError, "_ssl._SSLSocket.read requires 1 to 2 arguments"); |
| goto exit; |
| } |
| return_value = _ssl__SSLSocket_read_impl(self, len, group_right_1, &buffer); |
| |
| exit: |
| /* Cleanup for buffer */ |
| if (buffer.obj) { |
| PyBuffer_Release(&buffer); |
| } |
| |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_shutdown__doc__, |
| "shutdown($self, /)\n" |
| "--\n" |
| "\n" |
| "Does the SSL shutdown handshake with the remote end."); |
| |
| #define _SSL__SSLSOCKET_SHUTDOWN_METHODDEF \ |
| {"shutdown", (PyCFunction)_ssl__SSLSocket_shutdown, METH_NOARGS, _ssl__SSLSocket_shutdown__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_shutdown_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_shutdown(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_shutdown_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_get_channel_binding__doc__, |
| "get_channel_binding($self, /, cb_type=\'tls-unique\')\n" |
| "--\n" |
| "\n" |
| "Get channel binding data for current connection.\n" |
| "\n" |
| "Raise ValueError if the requested `cb_type` is not supported. Return bytes\n" |
| "of the data or None if the data is not available (e.g. before the handshake).\n" |
| "Only \'tls-unique\' channel binding data from RFC 5929 is supported."); |
| |
| #define _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF \ |
| {"get_channel_binding", (PyCFunction)(void(*)(void))_ssl__SSLSocket_get_channel_binding, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self, |
| const char *cb_type); |
| |
| static PyObject * |
| _ssl__SSLSocket_get_channel_binding(PySSLSocket *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"cb_type", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "get_channel_binding", 0}; |
| PyObject *argsbuf[1]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; |
| const char *cb_type = "tls-unique"; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| if (!PyUnicode_Check(args[0])) { |
| _PyArg_BadArgument("get_channel_binding", "argument 'cb_type'", "str", args[0]); |
| goto exit; |
| } |
| Py_ssize_t cb_type_length; |
| cb_type = PyUnicode_AsUTF8AndSize(args[0], &cb_type_length); |
| if (cb_type == NULL) { |
| goto exit; |
| } |
| if (strlen(cb_type) != (size_t)cb_type_length) { |
| PyErr_SetString(PyExc_ValueError, "embedded null character"); |
| goto exit; |
| } |
| skip_optional_pos: |
| return_value = _ssl__SSLSocket_get_channel_binding_impl(self, cb_type); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLSocket_verify_client_post_handshake__doc__, |
| "verify_client_post_handshake($self, /)\n" |
| "--\n" |
| "\n" |
| "Initiate TLS 1.3 post-handshake authentication"); |
| |
| #define _SSL__SSLSOCKET_VERIFY_CLIENT_POST_HANDSHAKE_METHODDEF \ |
| {"verify_client_post_handshake", (PyCFunction)_ssl__SSLSocket_verify_client_post_handshake, METH_NOARGS, _ssl__SSLSocket_verify_client_post_handshake__doc__}, |
| |
| static PyObject * |
| _ssl__SSLSocket_verify_client_post_handshake_impl(PySSLSocket *self); |
| |
| static PyObject * |
| _ssl__SSLSocket_verify_client_post_handshake(PySSLSocket *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLSocket_verify_client_post_handshake_impl(self); |
| } |
| |
| static PyObject * |
| _ssl__SSLContext_impl(PyTypeObject *type, int proto_version); |
| |
| static PyObject * |
| _ssl__SSLContext(PyTypeObject *type, PyObject *args, PyObject *kwargs) |
| { |
| PyObject *return_value = NULL; |
| int proto_version; |
| |
| if ((type == &PySSLContext_Type) && |
| !_PyArg_NoKeywords("_SSLContext", kwargs)) { |
| goto exit; |
| } |
| if (!_PyArg_CheckPositional("_SSLContext", PyTuple_GET_SIZE(args), 1, 1)) { |
| goto exit; |
| } |
| if (PyFloat_Check(PyTuple_GET_ITEM(args, 0))) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| proto_version = _PyLong_AsInt(PyTuple_GET_ITEM(args, 0)); |
| if (proto_version == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| return_value = _ssl__SSLContext_impl(type, proto_version); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_set_ciphers__doc__, |
| "set_ciphers($self, cipherlist, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_SET_CIPHERS_METHODDEF \ |
| {"set_ciphers", (PyCFunction)_ssl__SSLContext_set_ciphers, METH_O, _ssl__SSLContext_set_ciphers__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_set_ciphers_impl(PySSLContext *self, const char *cipherlist); |
| |
| static PyObject * |
| _ssl__SSLContext_set_ciphers(PySSLContext *self, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| const char *cipherlist; |
| |
| if (!PyUnicode_Check(arg)) { |
| _PyArg_BadArgument("set_ciphers", "argument", "str", arg); |
| goto exit; |
| } |
| Py_ssize_t cipherlist_length; |
| cipherlist = PyUnicode_AsUTF8AndSize(arg, &cipherlist_length); |
| if (cipherlist == NULL) { |
| goto exit; |
| } |
| if (strlen(cipherlist) != (size_t)cipherlist_length) { |
| PyErr_SetString(PyExc_ValueError, "embedded null character"); |
| goto exit; |
| } |
| return_value = _ssl__SSLContext_set_ciphers_impl(self, cipherlist); |
| |
| exit: |
| return return_value; |
| } |
| |
| #if (OPENSSL_VERSION_NUMBER >= 0x10002000UL) |
| |
| PyDoc_STRVAR(_ssl__SSLContext_get_ciphers__doc__, |
| "get_ciphers($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF \ |
| {"get_ciphers", (PyCFunction)_ssl__SSLContext_get_ciphers, METH_NOARGS, _ssl__SSLContext_get_ciphers__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_get_ciphers_impl(PySSLContext *self); |
| |
| static PyObject * |
| _ssl__SSLContext_get_ciphers(PySSLContext *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLContext_get_ciphers_impl(self); |
| } |
| |
| #endif /* (OPENSSL_VERSION_NUMBER >= 0x10002000UL) */ |
| |
| PyDoc_STRVAR(_ssl__SSLContext__set_npn_protocols__doc__, |
| "_set_npn_protocols($self, protos, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT__SET_NPN_PROTOCOLS_METHODDEF \ |
| {"_set_npn_protocols", (PyCFunction)_ssl__SSLContext__set_npn_protocols, METH_O, _ssl__SSLContext__set_npn_protocols__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext__set_npn_protocols_impl(PySSLContext *self, |
| Py_buffer *protos); |
| |
| static PyObject * |
| _ssl__SSLContext__set_npn_protocols(PySSLContext *self, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| Py_buffer protos = {NULL, NULL}; |
| |
| if (PyObject_GetBuffer(arg, &protos, PyBUF_SIMPLE) != 0) { |
| goto exit; |
| } |
| if (!PyBuffer_IsContiguous(&protos, 'C')) { |
| _PyArg_BadArgument("_set_npn_protocols", "argument", "contiguous buffer", arg); |
| goto exit; |
| } |
| return_value = _ssl__SSLContext__set_npn_protocols_impl(self, &protos); |
| |
| exit: |
| /* Cleanup for protos */ |
| if (protos.obj) { |
| PyBuffer_Release(&protos); |
| } |
| |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext__set_alpn_protocols__doc__, |
| "_set_alpn_protocols($self, protos, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT__SET_ALPN_PROTOCOLS_METHODDEF \ |
| {"_set_alpn_protocols", (PyCFunction)_ssl__SSLContext__set_alpn_protocols, METH_O, _ssl__SSLContext__set_alpn_protocols__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self, |
| Py_buffer *protos); |
| |
| static PyObject * |
| _ssl__SSLContext__set_alpn_protocols(PySSLContext *self, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| Py_buffer protos = {NULL, NULL}; |
| |
| if (PyObject_GetBuffer(arg, &protos, PyBUF_SIMPLE) != 0) { |
| goto exit; |
| } |
| if (!PyBuffer_IsContiguous(&protos, 'C')) { |
| _PyArg_BadArgument("_set_alpn_protocols", "argument", "contiguous buffer", arg); |
| goto exit; |
| } |
| return_value = _ssl__SSLContext__set_alpn_protocols_impl(self, &protos); |
| |
| exit: |
| /* Cleanup for protos */ |
| if (protos.obj) { |
| PyBuffer_Release(&protos); |
| } |
| |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_load_cert_chain__doc__, |
| "load_cert_chain($self, /, certfile, keyfile=None, password=None)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF \ |
| {"load_cert_chain", (PyCFunction)(void(*)(void))_ssl__SSLContext_load_cert_chain, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile, |
| PyObject *keyfile, PyObject *password); |
| |
| static PyObject * |
| _ssl__SSLContext_load_cert_chain(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"certfile", "keyfile", "password", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "load_cert_chain", 0}; |
| PyObject *argsbuf[3]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; |
| PyObject *certfile; |
| PyObject *keyfile = Py_None; |
| PyObject *password = Py_None; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| certfile = args[0]; |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| if (args[1]) { |
| keyfile = args[1]; |
| if (!--noptargs) { |
| goto skip_optional_pos; |
| } |
| } |
| password = args[2]; |
| skip_optional_pos: |
| return_value = _ssl__SSLContext_load_cert_chain_impl(self, certfile, keyfile, password); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_load_verify_locations__doc__, |
| "load_verify_locations($self, /, cafile=None, capath=None, cadata=None)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF \ |
| {"load_verify_locations", (PyCFunction)(void(*)(void))_ssl__SSLContext_load_verify_locations, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_load_verify_locations_impl(PySSLContext *self, |
| PyObject *cafile, |
| PyObject *capath, |
| PyObject *cadata); |
| |
| static PyObject * |
| _ssl__SSLContext_load_verify_locations(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"cafile", "capath", "cadata", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "load_verify_locations", 0}; |
| PyObject *argsbuf[3]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; |
| PyObject *cafile = Py_None; |
| PyObject *capath = Py_None; |
| PyObject *cadata = Py_None; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 3, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| if (args[0]) { |
| cafile = args[0]; |
| if (!--noptargs) { |
| goto skip_optional_pos; |
| } |
| } |
| if (args[1]) { |
| capath = args[1]; |
| if (!--noptargs) { |
| goto skip_optional_pos; |
| } |
| } |
| cadata = args[2]; |
| skip_optional_pos: |
| return_value = _ssl__SSLContext_load_verify_locations_impl(self, cafile, capath, cadata); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_load_dh_params__doc__, |
| "load_dh_params($self, path, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_LOAD_DH_PARAMS_METHODDEF \ |
| {"load_dh_params", (PyCFunction)_ssl__SSLContext_load_dh_params, METH_O, _ssl__SSLContext_load_dh_params__doc__}, |
| |
| PyDoc_STRVAR(_ssl__SSLContext__wrap_socket__doc__, |
| "_wrap_socket($self, /, sock, server_side, server_hostname=None, *,\n" |
| " owner=None, session=None)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF \ |
| {"_wrap_socket", (PyCFunction)(void(*)(void))_ssl__SSLContext__wrap_socket, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock, |
| int server_side, PyObject *hostname_obj, |
| PyObject *owner, PyObject *session); |
| |
| static PyObject * |
| _ssl__SSLContext__wrap_socket(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"sock", "server_side", "server_hostname", "owner", "session", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "_wrap_socket", 0}; |
| PyObject *argsbuf[5]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2; |
| PyObject *sock; |
| int server_side; |
| PyObject *hostname_obj = Py_None; |
| PyObject *owner = Py_None; |
| PyObject *session = Py_None; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!PyObject_TypeCheck(args[0], PySocketModule.Sock_Type)) { |
| _PyArg_BadArgument("_wrap_socket", "argument 'sock'", (PySocketModule.Sock_Type)->tp_name, args[0]); |
| goto exit; |
| } |
| sock = args[0]; |
| if (PyFloat_Check(args[1])) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| server_side = _PyLong_AsInt(args[1]); |
| if (server_side == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| if (args[2]) { |
| hostname_obj = args[2]; |
| if (!--noptargs) { |
| goto skip_optional_pos; |
| } |
| } |
| skip_optional_pos: |
| if (!noptargs) { |
| goto skip_optional_kwonly; |
| } |
| if (args[3]) { |
| owner = args[3]; |
| if (!--noptargs) { |
| goto skip_optional_kwonly; |
| } |
| } |
| session = args[4]; |
| skip_optional_kwonly: |
| return_value = _ssl__SSLContext__wrap_socket_impl(self, sock, server_side, hostname_obj, owner, session); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext__wrap_bio__doc__, |
| "_wrap_bio($self, /, incoming, outgoing, server_side,\n" |
| " server_hostname=None, *, owner=None, session=None)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF \ |
| {"_wrap_bio", (PyCFunction)(void(*)(void))_ssl__SSLContext__wrap_bio, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming, |
| PySSLMemoryBIO *outgoing, int server_side, |
| PyObject *hostname_obj, PyObject *owner, |
| PyObject *session); |
| |
| static PyObject * |
| _ssl__SSLContext__wrap_bio(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"incoming", "outgoing", "server_side", "server_hostname", "owner", "session", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "_wrap_bio", 0}; |
| PyObject *argsbuf[6]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3; |
| PySSLMemoryBIO *incoming; |
| PySSLMemoryBIO *outgoing; |
| int server_side; |
| PyObject *hostname_obj = Py_None; |
| PyObject *owner = Py_None; |
| PyObject *session = Py_None; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 4, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!PyObject_TypeCheck(args[0], &PySSLMemoryBIO_Type)) { |
| _PyArg_BadArgument("_wrap_bio", "argument 'incoming'", (&PySSLMemoryBIO_Type)->tp_name, args[0]); |
| goto exit; |
| } |
| incoming = (PySSLMemoryBIO *)args[0]; |
| if (!PyObject_TypeCheck(args[1], &PySSLMemoryBIO_Type)) { |
| _PyArg_BadArgument("_wrap_bio", "argument 'outgoing'", (&PySSLMemoryBIO_Type)->tp_name, args[1]); |
| goto exit; |
| } |
| outgoing = (PySSLMemoryBIO *)args[1]; |
| if (PyFloat_Check(args[2])) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| server_side = _PyLong_AsInt(args[2]); |
| if (server_side == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| if (args[3]) { |
| hostname_obj = args[3]; |
| if (!--noptargs) { |
| goto skip_optional_pos; |
| } |
| } |
| skip_optional_pos: |
| if (!noptargs) { |
| goto skip_optional_kwonly; |
| } |
| if (args[4]) { |
| owner = args[4]; |
| if (!--noptargs) { |
| goto skip_optional_kwonly; |
| } |
| } |
| session = args[5]; |
| skip_optional_kwonly: |
| return_value = _ssl__SSLContext__wrap_bio_impl(self, incoming, outgoing, server_side, hostname_obj, owner, session); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_session_stats__doc__, |
| "session_stats($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_SESSION_STATS_METHODDEF \ |
| {"session_stats", (PyCFunction)_ssl__SSLContext_session_stats, METH_NOARGS, _ssl__SSLContext_session_stats__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_session_stats_impl(PySSLContext *self); |
| |
| static PyObject * |
| _ssl__SSLContext_session_stats(PySSLContext *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLContext_session_stats_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_set_default_verify_paths__doc__, |
| "set_default_verify_paths($self, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_SET_DEFAULT_VERIFY_PATHS_METHODDEF \ |
| {"set_default_verify_paths", (PyCFunction)_ssl__SSLContext_set_default_verify_paths, METH_NOARGS, _ssl__SSLContext_set_default_verify_paths__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_set_default_verify_paths_impl(PySSLContext *self); |
| |
| static PyObject * |
| _ssl__SSLContext_set_default_verify_paths(PySSLContext *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLContext_set_default_verify_paths_impl(self); |
| } |
| |
| #if !defined(OPENSSL_NO_ECDH) |
| |
| PyDoc_STRVAR(_ssl__SSLContext_set_ecdh_curve__doc__, |
| "set_ecdh_curve($self, name, /)\n" |
| "--\n" |
| "\n"); |
| |
| #define _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF \ |
| {"set_ecdh_curve", (PyCFunction)_ssl__SSLContext_set_ecdh_curve, METH_O, _ssl__SSLContext_set_ecdh_curve__doc__}, |
| |
| #endif /* !defined(OPENSSL_NO_ECDH) */ |
| |
| PyDoc_STRVAR(_ssl__SSLContext_cert_store_stats__doc__, |
| "cert_store_stats($self, /)\n" |
| "--\n" |
| "\n" |
| "Returns quantities of loaded X.509 certificates.\n" |
| "\n" |
| "X.509 certificates with a CA extension and certificate revocation lists\n" |
| "inside the context\'s cert store.\n" |
| "\n" |
| "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n" |
| "been used at least once."); |
| |
| #define _SSL__SSLCONTEXT_CERT_STORE_STATS_METHODDEF \ |
| {"cert_store_stats", (PyCFunction)_ssl__SSLContext_cert_store_stats, METH_NOARGS, _ssl__SSLContext_cert_store_stats__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_cert_store_stats_impl(PySSLContext *self); |
| |
| static PyObject * |
| _ssl__SSLContext_cert_store_stats(PySSLContext *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl__SSLContext_cert_store_stats_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl__SSLContext_get_ca_certs__doc__, |
| "get_ca_certs($self, /, binary_form=False)\n" |
| "--\n" |
| "\n" |
| "Returns a list of dicts with information of loaded CA certs.\n" |
| "\n" |
| "If the optional argument is True, returns a DER-encoded copy of the CA\n" |
| "certificate.\n" |
| "\n" |
| "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n" |
| "been used at least once."); |
| |
| #define _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF \ |
| {"get_ca_certs", (PyCFunction)(void(*)(void))_ssl__SSLContext_get_ca_certs, METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__}, |
| |
| static PyObject * |
| _ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form); |
| |
| static PyObject * |
| _ssl__SSLContext_get_ca_certs(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"binary_form", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "get_ca_certs", 0}; |
| PyObject *argsbuf[1]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; |
| int binary_form = 0; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| binary_form = PyObject_IsTrue(args[0]); |
| if (binary_form < 0) { |
| goto exit; |
| } |
| skip_optional_pos: |
| return_value = _ssl__SSLContext_get_ca_certs_impl(self, binary_form); |
| |
| exit: |
| return return_value; |
| } |
| |
| static PyObject * |
| _ssl_MemoryBIO_impl(PyTypeObject *type); |
| |
| static PyObject * |
| _ssl_MemoryBIO(PyTypeObject *type, PyObject *args, PyObject *kwargs) |
| { |
| PyObject *return_value = NULL; |
| |
| if ((type == &PySSLMemoryBIO_Type) && |
| !_PyArg_NoPositional("MemoryBIO", args)) { |
| goto exit; |
| } |
| if ((type == &PySSLMemoryBIO_Type) && |
| !_PyArg_NoKeywords("MemoryBIO", kwargs)) { |
| goto exit; |
| } |
| return_value = _ssl_MemoryBIO_impl(type); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__, |
| "read($self, size=-1, /)\n" |
| "--\n" |
| "\n" |
| "Read up to size bytes from the memory BIO.\n" |
| "\n" |
| "If size is not specified, read the entire buffer.\n" |
| "If the return value is an empty bytes instance, this means either\n" |
| "EOF or that no data is available. Use the \"eof\" property to\n" |
| "distinguish between the two."); |
| |
| #define _SSL_MEMORYBIO_READ_METHODDEF \ |
| {"read", (PyCFunction)(void(*)(void))_ssl_MemoryBIO_read, METH_FASTCALL, _ssl_MemoryBIO_read__doc__}, |
| |
| static PyObject * |
| _ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len); |
| |
| static PyObject * |
| _ssl_MemoryBIO_read(PySSLMemoryBIO *self, PyObject *const *args, Py_ssize_t nargs) |
| { |
| PyObject *return_value = NULL; |
| int len = -1; |
| |
| if (!_PyArg_CheckPositional("read", nargs, 0, 1)) { |
| goto exit; |
| } |
| if (nargs < 1) { |
| goto skip_optional; |
| } |
| if (PyFloat_Check(args[0])) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| len = _PyLong_AsInt(args[0]); |
| if (len == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| skip_optional: |
| return_value = _ssl_MemoryBIO_read_impl(self, len); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_MemoryBIO_write__doc__, |
| "write($self, b, /)\n" |
| "--\n" |
| "\n" |
| "Writes the bytes b into the memory BIO.\n" |
| "\n" |
| "Returns the number of bytes written."); |
| |
| #define _SSL_MEMORYBIO_WRITE_METHODDEF \ |
| {"write", (PyCFunction)_ssl_MemoryBIO_write, METH_O, _ssl_MemoryBIO_write__doc__}, |
| |
| static PyObject * |
| _ssl_MemoryBIO_write_impl(PySSLMemoryBIO *self, Py_buffer *b); |
| |
| static PyObject * |
| _ssl_MemoryBIO_write(PySSLMemoryBIO *self, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| Py_buffer b = {NULL, NULL}; |
| |
| if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) { |
| goto exit; |
| } |
| if (!PyBuffer_IsContiguous(&b, 'C')) { |
| _PyArg_BadArgument("write", "argument", "contiguous buffer", arg); |
| goto exit; |
| } |
| return_value = _ssl_MemoryBIO_write_impl(self, &b); |
| |
| exit: |
| /* Cleanup for b */ |
| if (b.obj) { |
| PyBuffer_Release(&b); |
| } |
| |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_MemoryBIO_write_eof__doc__, |
| "write_eof($self, /)\n" |
| "--\n" |
| "\n" |
| "Write an EOF marker to the memory BIO.\n" |
| "\n" |
| "When all data has been read, the \"eof\" property will be True."); |
| |
| #define _SSL_MEMORYBIO_WRITE_EOF_METHODDEF \ |
| {"write_eof", (PyCFunction)_ssl_MemoryBIO_write_eof, METH_NOARGS, _ssl_MemoryBIO_write_eof__doc__}, |
| |
| static PyObject * |
| _ssl_MemoryBIO_write_eof_impl(PySSLMemoryBIO *self); |
| |
| static PyObject * |
| _ssl_MemoryBIO_write_eof(PySSLMemoryBIO *self, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl_MemoryBIO_write_eof_impl(self); |
| } |
| |
| PyDoc_STRVAR(_ssl_RAND_add__doc__, |
| "RAND_add($module, string, entropy, /)\n" |
| "--\n" |
| "\n" |
| "Mix string into the OpenSSL PRNG state.\n" |
| "\n" |
| "entropy (a float) is a lower bound on the entropy contained in\n" |
| "string. See RFC 4086."); |
| |
| #define _SSL_RAND_ADD_METHODDEF \ |
| {"RAND_add", (PyCFunction)(void(*)(void))_ssl_RAND_add, METH_FASTCALL, _ssl_RAND_add__doc__}, |
| |
| static PyObject * |
| _ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy); |
| |
| static PyObject * |
| _ssl_RAND_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs) |
| { |
| PyObject *return_value = NULL; |
| Py_buffer view = {NULL, NULL}; |
| double entropy; |
| |
| if (!_PyArg_CheckPositional("RAND_add", nargs, 2, 2)) { |
| goto exit; |
| } |
| if (PyUnicode_Check(args[0])) { |
| Py_ssize_t len; |
| const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len); |
| if (ptr == NULL) { |
| goto exit; |
| } |
| PyBuffer_FillInfo(&view, args[0], (void *)ptr, len, 1, 0); |
| } |
| else { /* any bytes-like object */ |
| if (PyObject_GetBuffer(args[0], &view, PyBUF_SIMPLE) != 0) { |
| goto exit; |
| } |
| if (!PyBuffer_IsContiguous(&view, 'C')) { |
| _PyArg_BadArgument("RAND_add", "argument 1", "contiguous buffer", args[0]); |
| goto exit; |
| } |
| } |
| if (PyFloat_CheckExact(args[1])) { |
| entropy = PyFloat_AS_DOUBLE(args[1]); |
| } |
| else |
| { |
| entropy = PyFloat_AsDouble(args[1]); |
| if (entropy == -1.0 && PyErr_Occurred()) { |
| goto exit; |
| } |
| } |
| return_value = _ssl_RAND_add_impl(module, &view, entropy); |
| |
| exit: |
| /* Cleanup for view */ |
| if (view.obj) { |
| PyBuffer_Release(&view); |
| } |
| |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_RAND_bytes__doc__, |
| "RAND_bytes($module, n, /)\n" |
| "--\n" |
| "\n" |
| "Generate n cryptographically strong pseudo-random bytes."); |
| |
| #define _SSL_RAND_BYTES_METHODDEF \ |
| {"RAND_bytes", (PyCFunction)_ssl_RAND_bytes, METH_O, _ssl_RAND_bytes__doc__}, |
| |
| static PyObject * |
| _ssl_RAND_bytes_impl(PyObject *module, int n); |
| |
| static PyObject * |
| _ssl_RAND_bytes(PyObject *module, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| int n; |
| |
| if (PyFloat_Check(arg)) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| n = _PyLong_AsInt(arg); |
| if (n == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| return_value = _ssl_RAND_bytes_impl(module, n); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_RAND_pseudo_bytes__doc__, |
| "RAND_pseudo_bytes($module, n, /)\n" |
| "--\n" |
| "\n" |
| "Generate n pseudo-random bytes.\n" |
| "\n" |
| "Return a pair (bytes, is_cryptographic). is_cryptographic is True\n" |
| "if the bytes generated are cryptographically strong."); |
| |
| #define _SSL_RAND_PSEUDO_BYTES_METHODDEF \ |
| {"RAND_pseudo_bytes", (PyCFunction)_ssl_RAND_pseudo_bytes, METH_O, _ssl_RAND_pseudo_bytes__doc__}, |
| |
| static PyObject * |
| _ssl_RAND_pseudo_bytes_impl(PyObject *module, int n); |
| |
| static PyObject * |
| _ssl_RAND_pseudo_bytes(PyObject *module, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| int n; |
| |
| if (PyFloat_Check(arg)) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| n = _PyLong_AsInt(arg); |
| if (n == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| return_value = _ssl_RAND_pseudo_bytes_impl(module, n); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_RAND_status__doc__, |
| "RAND_status($module, /)\n" |
| "--\n" |
| "\n" |
| "Returns 1 if the OpenSSL PRNG has been seeded with enough data and 0 if not.\n" |
| "\n" |
| "It is necessary to seed the PRNG with RAND_add() on some platforms before\n" |
| "using the ssl() function."); |
| |
| #define _SSL_RAND_STATUS_METHODDEF \ |
| {"RAND_status", (PyCFunction)_ssl_RAND_status, METH_NOARGS, _ssl_RAND_status__doc__}, |
| |
| static PyObject * |
| _ssl_RAND_status_impl(PyObject *module); |
| |
| static PyObject * |
| _ssl_RAND_status(PyObject *module, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl_RAND_status_impl(module); |
| } |
| |
| #if !defined(OPENSSL_NO_EGD) |
| |
| PyDoc_STRVAR(_ssl_RAND_egd__doc__, |
| "RAND_egd($module, path, /)\n" |
| "--\n" |
| "\n" |
| "Queries the entropy gather daemon (EGD) on the socket named by \'path\'.\n" |
| "\n" |
| "Returns number of bytes read. Raises SSLError if connection to EGD\n" |
| "fails or if it does not provide enough data to seed PRNG."); |
| |
| #define _SSL_RAND_EGD_METHODDEF \ |
| {"RAND_egd", (PyCFunction)_ssl_RAND_egd, METH_O, _ssl_RAND_egd__doc__}, |
| |
| static PyObject * |
| _ssl_RAND_egd_impl(PyObject *module, PyObject *path); |
| |
| static PyObject * |
| _ssl_RAND_egd(PyObject *module, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| PyObject *path; |
| |
| if (!PyUnicode_FSConverter(arg, &path)) { |
| goto exit; |
| } |
| return_value = _ssl_RAND_egd_impl(module, path); |
| |
| exit: |
| return return_value; |
| } |
| |
| #endif /* !defined(OPENSSL_NO_EGD) */ |
| |
| PyDoc_STRVAR(_ssl_get_default_verify_paths__doc__, |
| "get_default_verify_paths($module, /)\n" |
| "--\n" |
| "\n" |
| "Return search paths and environment vars that are used by SSLContext\'s set_default_verify_paths() to load default CAs.\n" |
| "\n" |
| "The values are \'cert_file_env\', \'cert_file\', \'cert_dir_env\', \'cert_dir\'."); |
| |
| #define _SSL_GET_DEFAULT_VERIFY_PATHS_METHODDEF \ |
| {"get_default_verify_paths", (PyCFunction)_ssl_get_default_verify_paths, METH_NOARGS, _ssl_get_default_verify_paths__doc__}, |
| |
| static PyObject * |
| _ssl_get_default_verify_paths_impl(PyObject *module); |
| |
| static PyObject * |
| _ssl_get_default_verify_paths(PyObject *module, PyObject *Py_UNUSED(ignored)) |
| { |
| return _ssl_get_default_verify_paths_impl(module); |
| } |
| |
| PyDoc_STRVAR(_ssl_txt2obj__doc__, |
| "txt2obj($module, /, txt, name=False)\n" |
| "--\n" |
| "\n" |
| "Lookup NID, short name, long name and OID of an ASN1_OBJECT.\n" |
| "\n" |
| "By default objects are looked up by OID. With name=True short and\n" |
| "long name are also matched."); |
| |
| #define _SSL_TXT2OBJ_METHODDEF \ |
| {"txt2obj", (PyCFunction)(void(*)(void))_ssl_txt2obj, METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__}, |
| |
| static PyObject * |
| _ssl_txt2obj_impl(PyObject *module, const char *txt, int name); |
| |
| static PyObject * |
| _ssl_txt2obj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"txt", "name", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "txt2obj", 0}; |
| PyObject *argsbuf[2]; |
| Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1; |
| const char *txt; |
| int name = 0; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!PyUnicode_Check(args[0])) { |
| _PyArg_BadArgument("txt2obj", "argument 'txt'", "str", args[0]); |
| goto exit; |
| } |
| Py_ssize_t txt_length; |
| txt = PyUnicode_AsUTF8AndSize(args[0], &txt_length); |
| if (txt == NULL) { |
| goto exit; |
| } |
| if (strlen(txt) != (size_t)txt_length) { |
| PyErr_SetString(PyExc_ValueError, "embedded null character"); |
| goto exit; |
| } |
| if (!noptargs) { |
| goto skip_optional_pos; |
| } |
| name = PyObject_IsTrue(args[1]); |
| if (name < 0) { |
| goto exit; |
| } |
| skip_optional_pos: |
| return_value = _ssl_txt2obj_impl(module, txt, name); |
| |
| exit: |
| return return_value; |
| } |
| |
| PyDoc_STRVAR(_ssl_nid2obj__doc__, |
| "nid2obj($module, nid, /)\n" |
| "--\n" |
| "\n" |
| "Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID."); |
| |
| #define _SSL_NID2OBJ_METHODDEF \ |
| {"nid2obj", (PyCFunction)_ssl_nid2obj, METH_O, _ssl_nid2obj__doc__}, |
| |
| static PyObject * |
| _ssl_nid2obj_impl(PyObject *module, int nid); |
| |
| static PyObject * |
| _ssl_nid2obj(PyObject *module, PyObject *arg) |
| { |
| PyObject *return_value = NULL; |
| int nid; |
| |
| if (PyFloat_Check(arg)) { |
| PyErr_SetString(PyExc_TypeError, |
| "integer argument expected, got float" ); |
| goto exit; |
| } |
| nid = _PyLong_AsInt(arg); |
| if (nid == -1 && PyErr_Occurred()) { |
| goto exit; |
| } |
| return_value = _ssl_nid2obj_impl(module, nid); |
| |
| exit: |
| return return_value; |
| } |
| |
| #if defined(_MSC_VER) |
| |
| PyDoc_STRVAR(_ssl_enum_certificates__doc__, |
| "enum_certificates($module, /, store_name)\n" |
| "--\n" |
| "\n" |
| "Retrieve certificates from Windows\' cert store.\n" |
| "\n" |
| "store_name may be one of \'CA\', \'ROOT\' or \'MY\'. The system may provide\n" |
| "more cert storages, too. The function returns a list of (bytes,\n" |
| "encoding_type, trust) tuples. The encoding_type flag can be interpreted\n" |
| "with X509_ASN_ENCODING or PKCS_7_ASN_ENCODING. The trust setting is either\n" |
| "a set of OIDs or the boolean True."); |
| |
| #define _SSL_ENUM_CERTIFICATES_METHODDEF \ |
| {"enum_certificates", (PyCFunction)(void(*)(void))_ssl_enum_certificates, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__}, |
| |
| static PyObject * |
| _ssl_enum_certificates_impl(PyObject *module, const char *store_name); |
| |
| static PyObject * |
| _ssl_enum_certificates(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"store_name", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "enum_certificates", 0}; |
| PyObject *argsbuf[1]; |
| const char *store_name; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!PyUnicode_Check(args[0])) { |
| _PyArg_BadArgument("enum_certificates", "argument 'store_name'", "str", args[0]); |
| goto exit; |
| } |
| Py_ssize_t store_name_length; |
| store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length); |
| if (store_name == NULL) { |
| goto exit; |
| } |
| if (strlen(store_name) != (size_t)store_name_length) { |
| PyErr_SetString(PyExc_ValueError, "embedded null character"); |
| goto exit; |
| } |
| return_value = _ssl_enum_certificates_impl(module, store_name); |
| |
| exit: |
| return return_value; |
| } |
| |
| #endif /* defined(_MSC_VER) */ |
| |
| #if defined(_MSC_VER) |
| |
| PyDoc_STRVAR(_ssl_enum_crls__doc__, |
| "enum_crls($module, /, store_name)\n" |
| "--\n" |
| "\n" |
| "Retrieve CRLs from Windows\' cert store.\n" |
| "\n" |
| "store_name may be one of \'CA\', \'ROOT\' or \'MY\'. The system may provide\n" |
| "more cert storages, too. The function returns a list of (bytes,\n" |
| "encoding_type) tuples. The encoding_type flag can be interpreted with\n" |
| "X509_ASN_ENCODING or PKCS_7_ASN_ENCODING."); |
| |
| #define _SSL_ENUM_CRLS_METHODDEF \ |
| {"enum_crls", (PyCFunction)(void(*)(void))_ssl_enum_crls, METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__}, |
| |
| static PyObject * |
| _ssl_enum_crls_impl(PyObject *module, const char *store_name); |
| |
| static PyObject * |
| _ssl_enum_crls(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) |
| { |
| PyObject *return_value = NULL; |
| static const char * const _keywords[] = {"store_name", NULL}; |
| static _PyArg_Parser _parser = {NULL, _keywords, "enum_crls", 0}; |
| PyObject *argsbuf[1]; |
| const char *store_name; |
| |
| args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf); |
| if (!args) { |
| goto exit; |
| } |
| if (!PyUnicode_Check(args[0])) { |
| _PyArg_BadArgument("enum_crls", "argument 'store_name'", "str", args[0]); |
| goto exit; |
| } |
| Py_ssize_t store_name_length; |
| store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length); |
| if (store_name == NULL) { |
| goto exit; |
| } |
| if (strlen(store_name) != (size_t)store_name_length) { |
| PyErr_SetString(PyExc_ValueError, "embedded null character"); |
| goto exit; |
| } |
| return_value = _ssl_enum_crls_impl(module, store_name); |
| |
| exit: |
| return return_value; |
| } |
| |
| #endif /* defined(_MSC_VER) */ |
| |
| #ifndef _SSL__SSLSOCKET_SELECTED_NPN_PROTOCOL_METHODDEF |
| #define _SSL__SSLSOCKET_SELECTED_NPN_PROTOCOL_METHODDEF |
| #endif /* !defined(_SSL__SSLSOCKET_SELECTED_NPN_PROTOCOL_METHODDEF) */ |
| |
| #ifndef _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF |
| #define _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF |
| #endif /* !defined(_SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF) */ |
| |
| #ifndef _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF |
| #define _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF |
| #endif /* !defined(_SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF) */ |
| |
| #ifndef _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF |
| #define _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF |
| #endif /* !defined(_SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF) */ |
| |
| #ifndef _SSL_RAND_EGD_METHODDEF |
| #define _SSL_RAND_EGD_METHODDEF |
| #endif /* !defined(_SSL_RAND_EGD_METHODDEF) */ |
| |
| #ifndef _SSL_ENUM_CERTIFICATES_METHODDEF |
| #define _SSL_ENUM_CERTIFICATES_METHODDEF |
| #endif /* !defined(_SSL_ENUM_CERTIFICATES_METHODDEF) */ |
| |
| #ifndef _SSL_ENUM_CRLS_METHODDEF |
| #define _SSL_ENUM_CRLS_METHODDEF |
| #endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */ |
| /*[clinic end generated code: output=a4aeb3f92a091c64 input=a9049054013a1b77]*/ |