LCOV - code coverage report
Current view: | top level - Modules/clinic - _ssl.c.h (source / functions) |  |  | Hit | Total | Coverage
Test: | CPython 3.12 LCOV report [commit 5e6661bce9] |  | Lines: | 17 | 392 | 4.3 %
Date: | 2023-03-20 08:15:36 |  | Functions: | 1 | 38 | 2.6 %
|  |  | Branches: | 8 | 277 | 2.9 %

               Branch data     Line data    Source code
           1                 :            : /*[clinic input]
           2                 :            : preserve
           3                 :            : [clinic start generated code]*/
           4                 :            :
           5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
           6                 :            : #  include "pycore_gc.h"            // PyGC_Head
           7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
           8                 :            : #endif
           9                 :            :
          10                 :            :
          11                 :            : PyDoc_STRVAR(_ssl__SSLSocket_do_handshake__doc__,
          12                 :            : "do_handshake($self, /)\n"
          13                 :            : "--\n"
          14                 :            : "\n");
          15                 :            :
          16                 :            : #define _SSL__SSLSOCKET_DO_HANDSHAKE_METHODDEF    \
          17                 :            :     {"do_handshake", (PyCFunction)_ssl__SSLSocket_do_handshake, METH_NOARGS, _ssl__SSLSocket_do_handshake__doc__},
          18                 :            :
          19                 :            : static PyObject *
          20                 :            : _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self);
          21                 :            :
          22                 :            : static PyObject *
          23                 :          0 : _ssl__SSLSocket_do_handshake(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
          24                 :            : {
          25                 :          0 :     return _ssl__SSLSocket_do_handshake_impl(self);
          26                 :            : }
          27                 :            :
          28                 :            : PyDoc_STRVAR(_ssl__test_decode_cert__doc__,
          29                 :            : "_test_decode_cert($module, path, /)\n"
          30                 :            : "--\n"
          31                 :            : "\n");
          32                 :            :
          33                 :            : #define _SSL__TEST_DECODE_CERT_METHODDEF    \
          34                 :            :     {"_test_decode_cert", (PyCFunction)_ssl__test_decode_cert, METH_O, _ssl__test_decode_cert__doc__},
          35                 :            :
          36                 :            : static PyObject *
          37                 :            : _ssl__test_decode_cert_impl(PyObject *module, PyObject *path);
          38                 :            :
          39                 :            : static PyObject *
          40                 :          0 : _ssl__test_decode_cert(PyObject *module, PyObject *arg)
          41                 :            : {
          42                 :          0 :     PyObject *return_value = NULL;
          43                 :            :     PyObject *path;
          44                 :            :
          45         [ #  # ]:          0 :     if (!PyUnicode_FSConverter(arg, &path)) {
          46                 :          0 :         goto exit;
          47                 :            :     }
          48                 :          0 :     return_value = _ssl__test_decode_cert_impl(module, path);
          49                 :            :
          50                 :          0 : exit:
          51                 :          0 :     return return_value;
          52                 :            : }
          53                 :            :
          54                 :            : PyDoc_STRVAR(_ssl__SSLSocket_getpeercert__doc__,
          55                 :            : "getpeercert($self, der=False, /)\n"
          56                 :            : "--\n"
          57                 :            : "\n"
          58                 :            : "Returns the certificate for the peer.\n"
          59                 :            : "\n"
          60                 :            : "If no certificate was provided, returns None.  If a certificate was\n"
          61                 :            : "provided, but not validated, returns an empty dictionary.  Otherwise\n"
          62                 :            : "returns a dict containing information about the peer certificate.\n"
          63                 :            : "\n"
          64                 :            : "If the optional argument is True, returns a DER-encoded copy of the\n"
          65                 :            : "peer certificate, or None if no certificate was provided.  This will\n"
          66                 :            : "return the certificate even if it wasn\'t validated.");
          67                 :            :
          68                 :            : #define _SSL__SSLSOCKET_GETPEERCERT_METHODDEF    \
          69                 :            :     {"getpeercert", _PyCFunction_CAST(_ssl__SSLSocket_getpeercert), METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
          70                 :            :
          71                 :            : static PyObject *
          72                 :            : _ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode);
          73                 :            :
          74                 :            : static PyObject *
          75                 :          0 : _ssl__SSLSocket_getpeercert(PySSLSocket *self, PyObject *const *args, Py_ssize_t nargs)
          76                 :            : {
          77                 :          0 :     PyObject *return_value = NULL;
          78                 :          0 :     int binary_mode = 0;
          79                 :            :
          80   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("getpeercert", nargs, 0, 1)) {
                       #  # ]
          81                 :          0 :         goto exit;
          82                 :            :     }
          83         [ #  # ]:          0 :     if (nargs < 1) {
          84                 :          0 :         goto skip_optional;
          85                 :            :     }
          86                 :          0 :     binary_mode = PyObject_IsTrue(args[0]);
          87         [ #  # ]:          0 :     if (binary_mode < 0) {
          88                 :          0 :         goto exit;
          89                 :            :     }
          90                 :          0 : skip_optional:
          91                 :          0 :     return_value = _ssl__SSLSocket_getpeercert_impl(self, binary_mode);
          92                 :            :
          93                 :          0 : exit:
          94                 :          0 :     return return_value;
          95                 :            : }
          96                 :            :
          97                 :            : PyDoc_STRVAR(_ssl__SSLSocket_get_verified_chain__doc__,
          98                 :            : "get_verified_chain($self, /)\n"
          99                 :            : "--\n"
         100                 :            : "\n");
         101                 :            :
         102                 :            : #define _SSL__SSLSOCKET_GET_VERIFIED_CHAIN_METHODDEF    \
         103                 :            :     {"get_verified_chain", (PyCFunction)_ssl__SSLSocket_get_verified_chain, METH_NOARGS, _ssl__SSLSocket_get_verified_chain__doc__},
         104                 :            :
         105                 :            : static PyObject *
         106                 :            : _ssl__SSLSocket_get_verified_chain_impl(PySSLSocket *self);
         107                 :            :
         108                 :            : static PyObject *
         109                 :          0 : _ssl__SSLSocket_get_verified_chain(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         110                 :            : {
         111                 :          0 :     return _ssl__SSLSocket_get_verified_chain_impl(self);
         112                 :            : }
         113                 :            :
         114                 :            : PyDoc_STRVAR(_ssl__SSLSocket_get_unverified_chain__doc__,
         115                 :            : "get_unverified_chain($self, /)\n"
         116                 :            : "--\n"
         117                 :            : "\n");
         118                 :            :
         119                 :            : #define _SSL__SSLSOCKET_GET_UNVERIFIED_CHAIN_METHODDEF    \
         120                 :            :     {"get_unverified_chain", (PyCFunction)_ssl__SSLSocket_get_unverified_chain, METH_NOARGS, _ssl__SSLSocket_get_unverified_chain__doc__},
         121                 :            :
         122                 :            : static PyObject *
         123                 :            : _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self);
         124                 :            :
         125                 :            : static PyObject *
         126                 :          0 : _ssl__SSLSocket_get_unverified_chain(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         127                 :            : {
         128                 :          0 :     return _ssl__SSLSocket_get_unverified_chain_impl(self);
         129                 :            : }
         130                 :            :
         131                 :            : PyDoc_STRVAR(_ssl__SSLSocket_shared_ciphers__doc__,
         132                 :            : "shared_ciphers($self, /)\n"
         133                 :            : "--\n"
         134                 :            : "\n");
         135                 :            :
         136                 :            : #define _SSL__SSLSOCKET_SHARED_CIPHERS_METHODDEF    \
         137                 :            :     {"shared_ciphers", (PyCFunction)_ssl__SSLSocket_shared_ciphers, METH_NOARGS, _ssl__SSLSocket_shared_ciphers__doc__},
         138                 :            :
         139                 :            : static PyObject *
         140                 :            : _ssl__SSLSocket_shared_ciphers_impl(PySSLSocket *self);
         141                 :            :
         142                 :            : static PyObject *
         143                 :          0 : _ssl__SSLSocket_shared_ciphers(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         144                 :            : {
         145                 :          0 :     return _ssl__SSLSocket_shared_ciphers_impl(self);
         146                 :            : }
         147                 :            :
         148                 :            : PyDoc_STRVAR(_ssl__SSLSocket_cipher__doc__,
         149                 :            : "cipher($self, /)\n"
         150                 :            : "--\n"
         151                 :            : "\n");
         152                 :            :
         153                 :            : #define _SSL__SSLSOCKET_CIPHER_METHODDEF    \
         154                 :            :     {"cipher", (PyCFunction)_ssl__SSLSocket_cipher, METH_NOARGS, _ssl__SSLSocket_cipher__doc__},
         155                 :            :
         156                 :            : static PyObject *
         157                 :            : _ssl__SSLSocket_cipher_impl(PySSLSocket *self);
         158                 :            :
         159                 :            : static PyObject *
         160                 :          0 : _ssl__SSLSocket_cipher(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         161                 :            : {
         162                 :          0 :     return _ssl__SSLSocket_cipher_impl(self);
         163                 :            : }
         164                 :            :
         165                 :            : PyDoc_STRVAR(_ssl__SSLSocket_version__doc__,
         166                 :            : "version($self, /)\n"
         167                 :            : "--\n"
         168                 :            : "\n");
         169                 :            :
         170                 :            : #define _SSL__SSLSOCKET_VERSION_METHODDEF    \
         171                 :            :     {"version", (PyCFunction)_ssl__SSLSocket_version, METH_NOARGS, _ssl__SSLSocket_version__doc__},
         172                 :            :
         173                 :            : static PyObject *
         174                 :            : _ssl__SSLSocket_version_impl(PySSLSocket *self);
         175                 :            :
         176                 :            : static PyObject *
         177                 :          0 : _ssl__SSLSocket_version(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         178                 :            : {
         179                 :          0 :     return _ssl__SSLSocket_version_impl(self);
         180                 :            : }
         181                 :            :
         182                 :            : PyDoc_STRVAR(_ssl__SSLSocket_selected_alpn_protocol__doc__,
         183                 :            : "selected_alpn_protocol($self, /)\n"
         184                 :            : "--\n"
         185                 :            : "\n");
         186                 :            :
         187                 :            : #define _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF    \
         188                 :            :     {"selected_alpn_protocol", (PyCFunction)_ssl__SSLSocket_selected_alpn_protocol, METH_NOARGS, _ssl__SSLSocket_selected_alpn_protocol__doc__},
         189                 :            :
         190                 :            : static PyObject *
         191                 :            : _ssl__SSLSocket_selected_alpn_protocol_impl(PySSLSocket *self);
         192                 :            :
         193                 :            : static PyObject *
         194                 :          0 : _ssl__SSLSocket_selected_alpn_protocol(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         195                 :            : {
         196                 :          0 :     return _ssl__SSLSocket_selected_alpn_protocol_impl(self);
         197                 :            : }
         198                 :            :
         199                 :            : PyDoc_STRVAR(_ssl__SSLSocket_compression__doc__,
         200                 :            : "compression($self, /)\n"
         201                 :            : "--\n"
         202                 :            : "\n");
         203                 :            :
         204                 :            : #define _SSL__SSLSOCKET_COMPRESSION_METHODDEF    \
         205                 :            :     {"compression", (PyCFunction)_ssl__SSLSocket_compression, METH_NOARGS, _ssl__SSLSocket_compression__doc__},
         206                 :            :
         207                 :            : static PyObject *
         208                 :            : _ssl__SSLSocket_compression_impl(PySSLSocket *self);
         209                 :            :
         210                 :            : static PyObject *
         211                 :          0 : _ssl__SSLSocket_compression(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         212                 :            : {
         213                 :          0 :     return _ssl__SSLSocket_compression_impl(self);
         214                 :            : }
         215                 :            :
         216                 :            : PyDoc_STRVAR(_ssl__SSLSocket_write__doc__,
         217                 :            : "write($self, b, /)\n"
         218                 :            : "--\n"
         219                 :            : "\n"
         220                 :            : "Writes the bytes-like object b into the SSL object.\n"
         221                 :            : "\n"
         222                 :            : "Returns the number of bytes written.");
         223                 :            :
         224                 :            : #define _SSL__SSLSOCKET_WRITE_METHODDEF    \
         225                 :            :     {"write", (PyCFunction)_ssl__SSLSocket_write, METH_O, _ssl__SSLSocket_write__doc__},
         226                 :            :
         227                 :            : static PyObject *
         228                 :            : _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b);
         229                 :            :
         230                 :            : static PyObject *
         231                 :          0 : _ssl__SSLSocket_write(PySSLSocket *self, PyObject *arg)
         232                 :            : {
         233                 :          0 :     PyObject *return_value = NULL;
         234                 :          0 :     Py_buffer b = {NULL, NULL};
         235                 :            :
         236         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
         237                 :          0 :         goto exit;
         238                 :            :     }
         239         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&b, 'C')) {
         240                 :          0 :         _PyArg_BadArgument("write", "argument", "contiguous buffer", arg);
         241                 :          0 :         goto exit;
         242                 :            :     }
         243                 :          0 :     return_value = _ssl__SSLSocket_write_impl(self, &b);
         244                 :            :
         245                 :          0 : exit:
         246                 :            :     /* Cleanup for b */
         247         [ #  # ]:          0 :     if (b.obj) {
         248                 :          0 :        PyBuffer_Release(&b);
         249                 :            :     }
         250                 :            :
         251                 :          0 :     return return_value;
         252                 :            : }
         253                 :            :
         254                 :            : PyDoc_STRVAR(_ssl__SSLSocket_pending__doc__,
         255                 :            : "pending($self, /)\n"
         256                 :            : "--\n"
         257                 :            : "\n"
         258                 :            : "Returns the number of already decrypted bytes available for read, pending on the connection.");
         259                 :            :
         260                 :            : #define _SSL__SSLSOCKET_PENDING_METHODDEF    \
         261                 :            :     {"pending", (PyCFunction)_ssl__SSLSocket_pending, METH_NOARGS, _ssl__SSLSocket_pending__doc__},
         262                 :            :
         263                 :            : static PyObject *
         264                 :            : _ssl__SSLSocket_pending_impl(PySSLSocket *self);
         265                 :            :
         266                 :            : static PyObject *
         267                 :          0 : _ssl__SSLSocket_pending(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         268                 :            : {
         269                 :          0 :     return _ssl__SSLSocket_pending_impl(self);
         270                 :            : }
         271                 :            :
         272                 :            : PyDoc_STRVAR(_ssl__SSLSocket_read__doc__,
         273                 :            : "read(size, [buffer])\n"
         274                 :            : "Read up to size bytes from the SSL socket.");
         275                 :            :
         276                 :            : #define _SSL__SSLSOCKET_READ_METHODDEF    \
         277                 :            :     {"read", (PyCFunction)_ssl__SSLSocket_read, METH_VARARGS, _ssl__SSLSocket_read__doc__},
         278                 :            :
         279                 :            : static PyObject *
         280                 :            : _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len,
         281                 :            :                           int group_right_1, Py_buffer *buffer);
         282                 :            :
         283                 :            : static PyObject *
         284                 :          0 : _ssl__SSLSocket_read(PySSLSocket *self, PyObject *args)
         285                 :            : {
         286                 :          0 :     PyObject *return_value = NULL;
         287                 :            :     Py_ssize_t len;
         288                 :          0 :     int group_right_1 = 0;
         289                 :          0 :     Py_buffer buffer = {NULL, NULL};
         290                 :            :
         291      [ #  #  # ]:          0 :     switch (PyTuple_GET_SIZE(args)) {
         292                 :          0 :         case 1:
         293         [ #  # ]:          0 :             if (!PyArg_ParseTuple(args, "n:read", &len)) {
         294                 :          0 :                 goto exit;
         295                 :            :             }
         296                 :          0 :             break;
         297                 :          0 :         case 2:
         298         [ #  # ]:          0 :             if (!PyArg_ParseTuple(args, "nw*:read", &len, &buffer)) {
         299                 :          0 :                 goto exit;
         300                 :            :             }
         301                 :          0 :             group_right_1 = 1;
         302                 :          0 :             break;
         303                 :          0 :         default:
         304                 :          0 :             PyErr_SetString(PyExc_TypeError, "_ssl._SSLSocket.read requires 1 to 2 arguments");
         305                 :          0 :             goto exit;
         306                 :            :     }
         307                 :          0 :     return_value = _ssl__SSLSocket_read_impl(self, len, group_right_1, &buffer);
         308                 :            :
         309                 :          0 : exit:
         310                 :            :     /* Cleanup for buffer */
         311         [ #  # ]:          0 :     if (buffer.obj) {
         312                 :          0 :        PyBuffer_Release(&buffer);
         313                 :            :     }
         314                 :            :
         315                 :          0 :     return return_value;
         316                 :            : }
         317                 :            :
         318                 :            : PyDoc_STRVAR(_ssl__SSLSocket_shutdown__doc__,
         319                 :            : "shutdown($self, /)\n"
         320                 :            : "--\n"
         321                 :            : "\n"
         322                 :            : "Does the SSL shutdown handshake with the remote end.");
         323                 :            :
         324                 :            : #define _SSL__SSLSOCKET_SHUTDOWN_METHODDEF    \
         325                 :            :     {"shutdown", (PyCFunction)_ssl__SSLSocket_shutdown, METH_NOARGS, _ssl__SSLSocket_shutdown__doc__},
         326                 :            :
         327                 :            : static PyObject *
         328                 :            : _ssl__SSLSocket_shutdown_impl(PySSLSocket *self);
         329                 :            :
         330                 :            : static PyObject *
         331                 :          0 : _ssl__SSLSocket_shutdown(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         332                 :            : {
         333                 :          0 :     return _ssl__SSLSocket_shutdown_impl(self);
         334                 :            : }
         335                 :            :
         336                 :            : PyDoc_STRVAR(_ssl__SSLSocket_get_channel_binding__doc__,
         337                 :            : "get_channel_binding($self, /, cb_type=\'tls-unique\')\n"
         338                 :            : "--\n"
         339                 :            : "\n"
         340                 :            : "Get channel binding data for current connection.\n"
         341                 :            : "\n"
         342                 :            : "Raise ValueError if the requested `cb_type` is not supported.  Return bytes\n"
         343                 :            : "of the data or None if the data is not available (e.g. before the handshake).\n"
         344                 :            : "Only \'tls-unique\' channel binding data from RFC 5929 is supported.");
         345                 :            :
         346                 :            : #define _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF    \
         347                 :            :     {"get_channel_binding", _PyCFunction_CAST(_ssl__SSLSocket_get_channel_binding), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
         348                 :            :
         349                 :            : static PyObject *
         350                 :            : _ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
         351                 :            :                                          const char *cb_type);
         352                 :            :
         353                 :            : static PyObject *
         354                 :          0 : _ssl__SSLSocket_get_channel_binding(PySSLSocket *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         355                 :            : {
         356                 :          0 :     PyObject *return_value = NULL;
         357                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         358                 :            :
         359                 :            :     #define NUM_KEYWORDS 1
         360                 :            :     static struct {
         361                 :            :         PyGC_Head _this_is_not_used;
         362                 :            :         PyObject_VAR_HEAD
         363                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         364                 :            :     } _kwtuple = {
         365                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         366                 :            :         .ob_item = { &_Py_ID(cb_type), },
         367                 :            :     };
         368                 :            :     #undef NUM_KEYWORDS
         369                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         370                 :            :
         371                 :            :     #else  // !Py_BUILD_CORE
         372                 :            :     #  define KWTUPLE NULL
         373                 :            :     #endif  // !Py_BUILD_CORE
         374                 :            :
         375                 :            :     static const char * const _keywords[] = {"cb_type", NULL};
         376                 :            :     static _PyArg_Parser _parser = {
         377                 :            :         .keywords = _keywords,
         378                 :            :         .fname = "get_channel_binding",
         379                 :            :         .kwtuple = KWTUPLE,
         380                 :            :     };
         381                 :            :     #undef KWTUPLE
         382                 :            :     PyObject *argsbuf[1];
         383         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
         384                 :          0 :     const char *cb_type = "tls-unique";
         385                 :            :
         386   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
                 #  #  #  # ]
         387         [ #  # ]:          0 :     if (!args) {
         388                 :          0 :         goto exit;
         389                 :            :     }
         390         [ #  # ]:          0 :     if (!noptargs) {
         391                 :          0 :         goto skip_optional_pos;
         392                 :            :     }
         393         [ #  # ]:          0 :     if (!PyUnicode_Check(args[0])) {
         394                 :          0 :         _PyArg_BadArgument("get_channel_binding", "argument 'cb_type'", "str", args[0]);
         395                 :          0 :         goto exit;
         396                 :            :     }
         397                 :            :     Py_ssize_t cb_type_length;
         398                 :          0 :     cb_type = PyUnicode_AsUTF8AndSize(args[0], &cb_type_length);
         399         [ #  # ]:          0 :     if (cb_type == NULL) {
         400                 :          0 :         goto exit;
         401                 :            :     }
         402         [ #  # ]:          0 :     if (strlen(cb_type) != (size_t)cb_type_length) {
         403                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
         404                 :          0 :         goto exit;
         405                 :            :     }
         406                 :          0 : skip_optional_pos:
         407                 :          0 :     return_value = _ssl__SSLSocket_get_channel_binding_impl(self, cb_type);
         408                 :            :
         409                 :          0 : exit:
         410                 :          0 :     return return_value;
         411                 :            : }
         412                 :            :
         413                 :            : PyDoc_STRVAR(_ssl__SSLSocket_verify_client_post_handshake__doc__,
         414                 :            : "verify_client_post_handshake($self, /)\n"
         415                 :            : "--\n"
         416                 :            : "\n"
         417                 :            : "Initiate TLS 1.3 post-handshake authentication");
         418                 :            :
         419                 :            : #define _SSL__SSLSOCKET_VERIFY_CLIENT_POST_HANDSHAKE_METHODDEF    \
         420                 :            :     {"verify_client_post_handshake", (PyCFunction)_ssl__SSLSocket_verify_client_post_handshake, METH_NOARGS, _ssl__SSLSocket_verify_client_post_handshake__doc__},
         421                 :            :
         422                 :            : static PyObject *
         423                 :            : _ssl__SSLSocket_verify_client_post_handshake_impl(PySSLSocket *self);
         424                 :            :
         425                 :            : static PyObject *
         426                 :          0 : _ssl__SSLSocket_verify_client_post_handshake(PySSLSocket *self, PyObject *Py_UNUSED(ignored))
         427                 :            : {
         428                 :          0 :     return _ssl__SSLSocket_verify_client_post_handshake_impl(self);
         429                 :            : }
         430                 :            :
         431                 :            : static PyObject *
         432                 :            : _ssl__SSLContext_impl(PyTypeObject *type, int proto_version);
         433                 :            :
         434                 :            : static PyObject *
         435                 :          0 : _ssl__SSLContext(PyTypeObject *type, PyObject *args, PyObject *kwargs)
         436                 :            : {
         437                 :          0 :     PyObject *return_value = NULL;
         438                 :          0 :     PyTypeObject *base_tp = get_state_type(type)->PySSLContext_Type;
         439                 :            :     int proto_version;
         440                 :            :
         441   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
         442         [ #  # ]:          0 :         !_PyArg_NoKeywords("_SSLContext", kwargs)) {
         443                 :          0 :         goto exit;
         444                 :            :     }
         445   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("_SSLContext", PyTuple_GET_SIZE(args), 1, 1)) {
                       #  # ]
         446                 :          0 :         goto exit;
         447                 :            :     }
         448                 :          0 :     proto_version = _PyLong_AsInt(PyTuple_GET_ITEM(args, 0));
         449   [ #  #  #  # ]:          0 :     if (proto_version == -1 && PyErr_Occurred()) {
         450                 :          0 :         goto exit;
         451                 :            :     }
         452                 :          0 :     return_value = _ssl__SSLContext_impl(type, proto_version);
         453                 :            :
         454                 :          0 : exit:
         455                 :          0 :     return return_value;
         456                 :            : }
         457                 :            :
         458                 :            : PyDoc_STRVAR(_ssl__SSLContext_set_ciphers__doc__,
         459                 :            : "set_ciphers($self, cipherlist, /)\n"
         460                 :            : "--\n"
         461                 :            : "\n");
         462                 :            :
         463                 :            : #define _SSL__SSLCONTEXT_SET_CIPHERS_METHODDEF    \
         464                 :            :     {"set_ciphers", (PyCFunction)_ssl__SSLContext_set_ciphers, METH_O, _ssl__SSLContext_set_ciphers__doc__},
         465                 :            :
         466                 :            : static PyObject *
         467                 :            : _ssl__SSLContext_set_ciphers_impl(PySSLContext *self, const char *cipherlist);
         468                 :            :
         469                 :            : static PyObject *
         470                 :          0 : _ssl__SSLContext_set_ciphers(PySSLContext *self, PyObject *arg)
         471                 :            : {
         472                 :          0 :     PyObject *return_value = NULL;
         473                 :            :     const char *cipherlist;
         474                 :            :
         475         [ #  # ]:          0 :     if (!PyUnicode_Check(arg)) {
         476                 :          0 :         _PyArg_BadArgument("set_ciphers", "argument", "str", arg);
         477                 :          0 :         goto exit;
         478                 :            :     }
         479                 :            :     Py_ssize_t cipherlist_length;
         480                 :          0 :     cipherlist = PyUnicode_AsUTF8AndSize(arg, &cipherlist_length);
         481         [ #  # ]:          0 :     if (cipherlist == NULL) {
         482                 :          0 :         goto exit;
         483                 :            :     }
         484         [ #  # ]:          0 :     if (strlen(cipherlist) != (size_t)cipherlist_length) {
         485                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
         486                 :          0 :         goto exit;
         487                 :            :     }
         488                 :          0 :     return_value = _ssl__SSLContext_set_ciphers_impl(self, cipherlist);
         489                 :            :
         490                 :          0 : exit:
         491                 :          0 :     return return_value;
         492                 :            : }
         493                 :            :
         494                 :            : PyDoc_STRVAR(_ssl__SSLContext_get_ciphers__doc__,
         495                 :            : "get_ciphers($self, /)\n"
         496                 :            : "--\n"
         497                 :            : "\n");
         498                 :            :
         499                 :            : #define _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF    \
         500                 :            :     {"get_ciphers", (PyCFunction)_ssl__SSLContext_get_ciphers, METH_NOARGS, _ssl__SSLContext_get_ciphers__doc__},
         501                 :            :
         502                 :            : static PyObject *
         503                 :            : _ssl__SSLContext_get_ciphers_impl(PySSLContext *self);
         504                 :            :
         505                 :            : static PyObject *
         506                 :          0 : _ssl__SSLContext_get_ciphers(PySSLContext *self, PyObject *Py_UNUSED(ignored))
         507                 :            : {
         508                 :          0 :     return _ssl__SSLContext_get_ciphers_impl(self);
         509                 :            : }
         510                 :            :
         511                 :            : PyDoc_STRVAR(_ssl__SSLContext__set_alpn_protocols__doc__,
         512                 :            : "_set_alpn_protocols($self, protos, /)\n"
         513                 :            : "--\n"
         514                 :            : "\n");
         515                 :            :
         516                 :            : #define _SSL__SSLCONTEXT__SET_ALPN_PROTOCOLS_METHODDEF    \
         517                 :            :     {"_set_alpn_protocols", (PyCFunction)_ssl__SSLContext__set_alpn_protocols, METH_O, _ssl__SSLContext__set_alpn_protocols__doc__},
         518                 :            :
         519                 :            : static PyObject *
         520                 :            : _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self,
         521                 :            :                                           Py_buffer *protos);
         522                 :            :
         523                 :            : static PyObject *
         524                 :          0 : _ssl__SSLContext__set_alpn_protocols(PySSLContext *self, PyObject *arg)
         525                 :            : {
         526                 :          0 :     PyObject *return_value = NULL;
         527                 :          0 :     Py_buffer protos = {NULL, NULL};
         528                 :            :
         529         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &protos, PyBUF_SIMPLE) != 0) {
         530                 :          0 :         goto exit;
         531                 :            :     }
         532         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&protos, 'C')) {
         533                 :          0 :         _PyArg_BadArgument("_set_alpn_protocols", "argument", "contiguous buffer", arg);
         534                 :          0 :         goto exit;
         535                 :            :     }
         536                 :          0 :     return_value = _ssl__SSLContext__set_alpn_protocols_impl(self, &protos);
         537                 :            :
         538                 :          0 : exit:
         539                 :            :     /* Cleanup for protos */
         540         [ #  # ]:          0 :     if (protos.obj) {
         541                 :          0 :        PyBuffer_Release(&protos);
         542                 :            :     }
         543                 :            :
         544                 :          0 :     return return_value;
         545                 :            : }
         546                 :            :
         547                 :            : PyDoc_STRVAR(_ssl__SSLContext_load_cert_chain__doc__,
         548                 :            : "load_cert_chain($self, /, certfile, keyfile=None, password=None)\n"
         549                 :            : "--\n"
         550                 :            : "\n");
         551                 :            :
         552                 :            : #define _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF    \
         553                 :            :     {"load_cert_chain", _PyCFunction_CAST(_ssl__SSLContext_load_cert_chain), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
         554                 :            :
         555                 :            : static PyObject *
         556                 :            : _ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
         557                 :            :                                       PyObject *keyfile, PyObject *password);
         558                 :            :
         559                 :            : static PyObject *
         560                 :          0 : _ssl__SSLContext_load_cert_chain(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         561                 :            : {
         562                 :          0 :     PyObject *return_value = NULL;
         563                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         564                 :            :
         565                 :            :     #define NUM_KEYWORDS 3
         566                 :            :     static struct {
         567                 :            :         PyGC_Head _this_is_not_used;
         568                 :            :         PyObject_VAR_HEAD
         569                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         570                 :            :     } _kwtuple = {
         571                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         572                 :            :         .ob_item = { &_Py_ID(certfile), &_Py_ID(keyfile), &_Py_ID(password), },
         573                 :            :     };
         574                 :            :     #undef NUM_KEYWORDS
         575                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         576                 :            :
         577                 :            :     #else  // !Py_BUILD_CORE
         578                 :            :     #  define KWTUPLE NULL
         579                 :            :     #endif  // !Py_BUILD_CORE
         580                 :            :
         581                 :            :     static const char * const _keywords[] = {"certfile", "keyfile", "password", NULL};
         582                 :            :     static _PyArg_Parser _parser = {
         583                 :            :         .keywords = _keywords,
         584                 :            :         .fname = "load_cert_chain",
         585                 :            :         .kwtuple = KWTUPLE,
         586                 :            :     };
         587                 :            :     #undef KWTUPLE
         588                 :            :     PyObject *argsbuf[3];
         589         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
         590                 :            :     PyObject *certfile;
         591                 :          0 :     PyObject *keyfile = Py_None;
         592                 :          0 :     PyObject *password = Py_None;
         593                 :            :
         594   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
                 #  #  #  # ]
         595         [ #  # ]:          0 :     if (!args) {
         596                 :          0 :         goto exit;
         597                 :            :     }
         598                 :          0 :     certfile = args[0];
         599         [ #  # ]:          0 :     if (!noptargs) {
         600                 :          0 :         goto skip_optional_pos;
         601                 :            :     }
         602         [ #  # ]:          0 :     if (args[1]) {
         603                 :          0 :         keyfile = args[1];
         604         [ #  # ]:          0 :         if (!--noptargs) {
         605                 :          0 :             goto skip_optional_pos;
         606                 :            :         }
         607                 :            :     }
         608                 :          0 :     password = args[2];
         609                 :          0 : skip_optional_pos:
         610                 :          0 :     return_value = _ssl__SSLContext_load_cert_chain_impl(self, certfile, keyfile, password);
         611                 :            :
         612                 :          0 : exit:
         613                 :          0 :     return return_value;
         614                 :            : }
         615                 :            :
         616                 :            : PyDoc_STRVAR(_ssl__SSLContext_load_verify_locations__doc__,
         617                 :            : "load_verify_locations($self, /, cafile=None, capath=None, cadata=None)\n"
         618                 :            : "--\n"
         619                 :            : "\n");
         620                 :            :
         621                 :            : #define _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF    \
         622                 :            :     {"load_verify_locations", _PyCFunction_CAST(_ssl__SSLContext_load_verify_locations), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
         623                 :            :
         624                 :            : static PyObject *
         625                 :            : _ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
         626                 :            :                                             PyObject *cafile,
         627                 :            :                                             PyObject *capath,
         628                 :            :                                             PyObject *cadata);
         629                 :            :
         630                 :            : static PyObject *
         631                 :          0 : _ssl__SSLContext_load_verify_locations(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         632                 :            : {
         633                 :          0 :     PyObject *return_value = NULL;
         634                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         635                 :            :
         636                 :            :     #define NUM_KEYWORDS 3
         637                 :            :     static struct {
         638                 :            :         PyGC_Head _this_is_not_used;
         639                 :            :         PyObject_VAR_HEAD
         640                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         641                 :            :     } _kwtuple = {
         642                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         643                 :            :         .ob_item = { &_Py_ID(cafile), &_Py_ID(capath), &_Py_ID(cadata), },
         644                 :            :     };
         645                 :            :     #undef NUM_KEYWORDS
         646                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         647                 :            :
         648                 :            :     #else  // !Py_BUILD_CORE
         649                 :            :     #  define KWTUPLE NULL
         650                 :            :     #endif  // !Py_BUILD_CORE
         651                 :            :
         652                 :            :     static const char * const _keywords[] = {"cafile", "capath", "cadata", NULL};
         653                 :            :     static _PyArg_Parser _parser = {
         654                 :            :         .keywords = _keywords,
         655                 :            :         .fname = "load_verify_locations",
         656                 :            :         .kwtuple = KWTUPLE,
         657                 :            :     };
         658                 :            :     #undef KWTUPLE
         659                 :            :     PyObject *argsbuf[3];
         660         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
         661                 :          0 :     PyObject *cafile = Py_None;
         662                 :          0 :     PyObject *capath = Py_None;
         663                 :          0 :     PyObject *cadata = Py_None;
         664                 :            :
         665   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 3, 0, argsbuf);
                 #  #  #  # ]
         666         [ #  # ]:          0 :     if (!args) {
         667                 :          0 :         goto exit;
         668                 :            :     }
         669         [ #  # ]:          0 :     if (!noptargs) {
         670                 :          0 :         goto skip_optional_pos;
         671                 :            :     }
         672         [ #  # ]:          0 :     if (args[0]) {
         673                 :          0 :         cafile = args[0];
         674         [ #  # ]:          0 :         if (!--noptargs) {
         675                 :          0 :             goto skip_optional_pos;
         676                 :            :         }
         677                 :            :     }
         678         [ #  # ]:          0 :     if (args[1]) {
         679                 :          0 :         capath = args[1];
         680         [ #  # ]:          0 :         if (!--noptargs) {
         681                 :          0 :             goto skip_optional_pos;
         682                 :            :         }
         683                 :            :     }
         684                 :          0 :     cadata = args[2];
         685                 :          0 : skip_optional_pos:
         686                 :          0 :     return_value = _ssl__SSLContext_load_verify_locations_impl(self, cafile, capath, cadata);
         687                 :            :
         688                 :          0 : exit:
         689                 :          0 :     return return_value;
         690                 :            : }
         691                 :            :
         692                 :            : PyDoc_STRVAR(_ssl__SSLContext_load_dh_params__doc__,
         693                 :            : "load_dh_params($self, path, /)\n"
         694                 :            : "--\n"
         695                 :            : "\n");
         696                 :            :
         697                 :            : #define _SSL__SSLCONTEXT_LOAD_DH_PARAMS_METHODDEF    \
         698                 :            :     {"load_dh_params", (PyCFunction)_ssl__SSLContext_load_dh_params, METH_O, _ssl__SSLContext_load_dh_params__doc__},
         699                 :            :
         700                 :            : PyDoc_STRVAR(_ssl__SSLContext__wrap_socket__doc__,
         701                 :            : "_wrap_socket($self, /, sock, server_side, server_hostname=None, *,\n"
         702                 :            : "             owner=None, session=None)\n"
         703                 :            : "--\n"
         704                 :            : "\n");
         705                 :            :
         706                 :            : #define _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF    \
         707                 :            :     {"_wrap_socket", _PyCFunction_CAST(_ssl__SSLContext__wrap_socket), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
         708                 :            :
         709                 :            : static PyObject *
         710                 :            : _ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
         711                 :            :                                    int server_side, PyObject *hostname_obj,
         712                 :            :                                    PyObject *owner, PyObject *session);
         713                 :            :
         714                 :            : static PyObject *
         715                 :          0 : _ssl__SSLContext__wrap_socket(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         716                 :            : {
         717                 :          0 :     PyObject *return_value = NULL;
         718                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         719                 :            :
         720                 :            :     #define NUM_KEYWORDS 5
         721                 :            :     static struct {
         722                 :            :         PyGC_Head _this_is_not_used;
         723                 :            :         PyObject_VAR_HEAD
         724                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         725                 :            :     } _kwtuple = {
         726                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         727                 :            :         .ob_item = { &_Py_ID(sock), &_Py_ID(server_side), &_Py_ID(server_hostname), &_Py_ID(owner), &_Py_ID(session), },
         728                 :            :     };
         729                 :            :     #undef NUM_KEYWORDS
         730                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         731                 :            :
         732                 :            :     #else  // !Py_BUILD_CORE
         733                 :            :     #  define KWTUPLE NULL
         734                 :            :     #endif  // !Py_BUILD_CORE
         735                 :            :
         736                 :            :     static const char * const _keywords[] = {"sock", "server_side", "server_hostname", "owner", "session", NULL};
         737                 :            :     static _PyArg_Parser _parser = {
         738                 :            :         .keywords = _keywords,
         739                 :            :         .fname = "_wrap_socket",
         740                 :            :         .kwtuple = KWTUPLE,
         741                 :            :     };
         742                 :            :     #undef KWTUPLE
         743                 :            :     PyObject *argsbuf[5];
         744         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
         745                 :            :     PyObject *sock;
         746                 :            :     int server_side;
         747                 :          0 :     PyObject *hostname_obj = Py_None;
         748                 :          0 :     PyObject *owner = Py_None;
         749                 :          0 :     PyObject *session = Py_None;
         750                 :            :
         751   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 2, 3, 0, argsbuf);
                 #  #  #  # ]
         752         [ #  # ]:          0 :     if (!args) {
         753                 :          0 :         goto exit;
         754                 :            :     }
         755         [ #  # ]:          0 :     if (!PyObject_TypeCheck(args[0], get_state_ctx(self)->Sock_Type)) {
         756                 :          0 :         _PyArg_BadArgument("_wrap_socket", "argument 'sock'", (get_state_ctx(self)->Sock_Type)->tp_name, args[0]);
         757                 :          0 :         goto exit;
         758                 :            :     }
         759                 :          0 :     sock = args[0];
         760                 :          0 :     server_side = PyObject_IsTrue(args[1]);
         761         [ #  # ]:          0 :     if (server_side < 0) {
         762                 :          0 :         goto exit;
         763                 :            :     }
         764         [ #  # ]:          0 :     if (!noptargs) {
         765                 :          0 :         goto skip_optional_pos;
         766                 :            :     }
         767         [ #  # ]:          0 :     if (args[2]) {
         768                 :          0 :         hostname_obj = args[2];
         769         [ #  # ]:          0 :         if (!--noptargs) {
         770                 :          0 :             goto skip_optional_pos;
         771                 :            :         }
         772                 :            :     }
         773                 :          0 : skip_optional_pos:
         774         [ #  # ]:          0 :     if (!noptargs) {
         775                 :          0 :         goto skip_optional_kwonly;
         776                 :            :     }
         777         [ #  # ]:          0 :     if (args[3]) {
         778                 :          0 :         owner = args[3];
         779         [ #  # ]:          0 :         if (!--noptargs) {
         780                 :          0 :             goto skip_optional_kwonly;
         781                 :            :         }
         782                 :            :     }
         783                 :          0 :     session = args[4];
         784                 :          0 : skip_optional_kwonly:
         785                 :          0 :     return_value = _ssl__SSLContext__wrap_socket_impl(self, sock, server_side, hostname_obj, owner, session);
         786                 :            :
         787                 :          0 : exit:
         788                 :          0 :     return return_value;
         789                 :            : }
         790                 :            :
         791                 :            : PyDoc_STRVAR(_ssl__SSLContext__wrap_bio__doc__,
         792                 :            : "_wrap_bio($self, /, incoming, outgoing, server_side,\n"
         793                 :            : "          server_hostname=None, *, owner=None, session=None)\n"
         794                 :            : "--\n"
         795                 :            : "\n");
         796                 :            :
         797                 :            : #define _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF    \
         798                 :            :     {"_wrap_bio", _PyCFunction_CAST(_ssl__SSLContext__wrap_bio), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
         799                 :            :
         800                 :            : static PyObject *
         801                 :            : _ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
         802                 :            :                                 PySSLMemoryBIO *outgoing, int server_side,
         803                 :            :                                 PyObject *hostname_obj, PyObject *owner,
         804                 :            :                                 PyObject *session);
         805                 :            :
         806                 :            : static PyObject *
         807                 :          0 : _ssl__SSLContext__wrap_bio(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         808                 :            : {
         809                 :          0 :     PyObject *return_value = NULL;
         810                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         811                 :            :
         812                 :            :     #define NUM_KEYWORDS 6
         813                 :            :     static struct {
         814                 :            :         PyGC_Head _this_is_not_used;
         815                 :            :         PyObject_VAR_HEAD
         816                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         817                 :            :     } _kwtuple = {
         818                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         819                 :            :         .ob_item = { &_Py_ID(incoming), &_Py_ID(outgoing), &_Py_ID(server_side), &_Py_ID(server_hostname), &_Py_ID(owner), &_Py_ID(session), },
         820                 :            :     };
         821                 :            :     #undef NUM_KEYWORDS
         822                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         823                 :            :
         824                 :            :     #else  // !Py_BUILD_CORE
         825                 :            :     #  define KWTUPLE NULL
         826                 :            :     #endif  // !Py_BUILD_CORE
         827                 :            :
         828                 :            :     static const char * const _keywords[] = {"incoming", "outgoing", "server_side", "server_hostname", "owner", "session", NULL};
         829                 :            :     static _PyArg_Parser _parser = {
         830                 :            :         .keywords = _keywords,
         831                 :            :         .fname = "_wrap_bio",
         832                 :            :         .kwtuple = KWTUPLE,
         833                 :            :     };
         834                 :            :     #undef KWTUPLE
         835                 :            :     PyObject *argsbuf[6];
         836         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
         837                 :            :     PySSLMemoryBIO *incoming;
         838                 :            :     PySSLMemoryBIO *outgoing;
         839                 :            :     int server_side;
         840                 :          0 :     PyObject *hostname_obj = Py_None;
         841                 :          0 :     PyObject *owner = Py_None;
         842                 :          0 :     PyObject *session = Py_None;
         843                 :            :
         844   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 4, 0, argsbuf);
                 #  #  #  # ]
         845         [ #  # ]:          0 :     if (!args) {
         846                 :          0 :         goto exit;
         847                 :            :     }
         848         [ #  # ]:          0 :     if (!PyObject_TypeCheck(args[0], get_state_ctx(self)->PySSLMemoryBIO_Type)) {
         849                 :          0 :         _PyArg_BadArgument("_wrap_bio", "argument 'incoming'", (get_state_ctx(self)->PySSLMemoryBIO_Type)->tp_name, args[0]);
         850                 :          0 :         goto exit;
         851                 :            :     }
         852                 :          0 :     incoming = (PySSLMemoryBIO *)args[0];
         853         [ #  # ]:          0 :     if (!PyObject_TypeCheck(args[1], get_state_ctx(self)->PySSLMemoryBIO_Type)) {
         854                 :          0 :         _PyArg_BadArgument("_wrap_bio", "argument 'outgoing'", (get_state_ctx(self)->PySSLMemoryBIO_Type)->tp_name, args[1]);
         855                 :          0 :         goto exit;
         856                 :            :     }
         857                 :          0 :     outgoing = (PySSLMemoryBIO *)args[1];
         858                 :          0 :     server_side = PyObject_IsTrue(args[2]);
         859         [ #  # ]:          0 :     if (server_side < 0) {
         860                 :          0 :         goto exit;
         861                 :            :     }
         862         [ #  # ]:          0 :     if (!noptargs) {
         863                 :          0 :         goto skip_optional_pos;
         864                 :            :     }
         865         [ #  # ]:          0 :     if (args[3]) {
         866                 :          0 :         hostname_obj = args[3];
         867         [ #  # ]:          0 :         if (!--noptargs) {
         868                 :          0 :             goto skip_optional_pos;
         869                 :            :         }
         870                 :            :     }
         871                 :          0 : skip_optional_pos:
         872         [ #  # ]:          0 :     if (!noptargs) {
         873                 :          0 :         goto skip_optional_kwonly;
         874                 :            :     }
         875         [ #  # ]:          0 :     if (args[4]) {
         876                 :          0 :         owner = args[4];
         877         [ #  # ]:          0 :         if (!--noptargs) {
         878                 :          0 :             goto skip_optional_kwonly;
         879                 :            :         }
         880                 :            :     }
         881                 :          0 :     session = args[5];
         882                 :          0 : skip_optional_kwonly:
         883                 :          0 :     return_value = _ssl__SSLContext__wrap_bio_impl(self, incoming, outgoing, server_side, hostname_obj, owner, session);
         884                 :            :
         885                 :          0 : exit:
         886                 :          0 :     return return_value;
         887                 :            : }
         888                 :            :
         889                 :            : PyDoc_STRVAR(_ssl__SSLContext_session_stats__doc__,
         890                 :            : "session_stats($self, /)\n"
         891                 :            : "--\n"
         892                 :            : "\n");
         893                 :            :
         894                 :            : #define _SSL__SSLCONTEXT_SESSION_STATS_METHODDEF    \
         895                 :            :     {"session_stats", (PyCFunction)_ssl__SSLContext_session_stats, METH_NOARGS, _ssl__SSLContext_session_stats__doc__},
         896                 :            :
         897                 :            : static PyObject *
         898                 :            : _ssl__SSLContext_session_stats_impl(PySSLContext *self);
         899                 :            :
         900                 :            : static PyObject *
         901                 :          0 : _ssl__SSLContext_session_stats(PySSLContext *self, PyObject *Py_UNUSED(ignored))
         902                 :            : {
         903                 :          0 :     return _ssl__SSLContext_session_stats_impl(self);
         904                 :            : }
         905                 :            :
         906                 :            : PyDoc_STRVAR(_ssl__SSLContext_set_default_verify_paths__doc__,
         907                 :            : "set_default_verify_paths($self, /)\n"
         908                 :            : "--\n"
         909                 :            : "\n");
         910                 :            :
         911                 :            : #define _SSL__SSLCONTEXT_SET_DEFAULT_VERIFY_PATHS_METHODDEF    \
         912                 :            :     {"set_default_verify_paths", (PyCFunction)_ssl__SSLContext_set_default_verify_paths, METH_NOARGS, _ssl__SSLContext_set_default_verify_paths__doc__},
         913                 :            :
         914                 :            : static PyObject *
         915                 :            : _ssl__SSLContext_set_default_verify_paths_impl(PySSLContext *self);
         916                 :            :
         917                 :            : static PyObject *
         918                 :          0 : _ssl__SSLContext_set_default_verify_paths(PySSLContext *self, PyObject *Py_UNUSED(ignored))
         919                 :            : {
         920                 :          0 :     return _ssl__SSLContext_set_default_verify_paths_impl(self);
         921                 :            : }
         922                 :            :
         923                 :            : PyDoc_STRVAR(_ssl__SSLContext_set_ecdh_curve__doc__,
         924                 :            : "set_ecdh_curve($self, name, /)\n"
         925                 :            : "--\n"
         926                 :            : "\n");
         927                 :            :
         928                 :            : #define _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF    \
         929                 :            :     {"set_ecdh_curve", (PyCFunction)_ssl__SSLContext_set_ecdh_curve, METH_O, _ssl__SSLContext_set_ecdh_curve__doc__},
         930                 :            :
         931                 :            : PyDoc_STRVAR(_ssl__SSLContext_cert_store_stats__doc__,
         932                 :            : "cert_store_stats($self, /)\n"
         933                 :            : "--\n"
         934                 :            : "\n"
         935                 :            : "Returns quantities of loaded X.509 certificates.\n"
         936                 :            : "\n"
         937                 :            : "X.509 certificates with a CA extension and certificate revocation lists\n"
         938                 :            : "inside the context\'s cert store.\n"
         939                 :            : "\n"
         940                 :            : "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n"
         941                 :            : "been used at least once.");
         942                 :            :
         943                 :            : #define _SSL__SSLCONTEXT_CERT_STORE_STATS_METHODDEF    \
         944                 :            :     {"cert_store_stats", (PyCFunction)_ssl__SSLContext_cert_store_stats, METH_NOARGS, _ssl__SSLContext_cert_store_stats__doc__},
         945                 :            :
         946                 :            : static PyObject *
         947                 :            : _ssl__SSLContext_cert_store_stats_impl(PySSLContext *self);
         948                 :            :
         949                 :            : static PyObject *
         950                 :          0 : _ssl__SSLContext_cert_store_stats(PySSLContext *self, PyObject *Py_UNUSED(ignored))
         951                 :            : {
         952                 :          0 :     return _ssl__SSLContext_cert_store_stats_impl(self);
         953                 :            : }
         954                 :            :
         955                 :            : PyDoc_STRVAR(_ssl__SSLContext_get_ca_certs__doc__,
         956                 :            : "get_ca_certs($self, /, binary_form=False)\n"
         957                 :            : "--\n"
         958                 :            : "\n"
         959                 :            : "Returns a list of dicts with information of loaded CA certs.\n"
         960                 :            : "\n"
         961                 :            : "If the optional argument is True, returns a DER-encoded copy of the CA\n"
         962                 :            : "certificate.\n"
         963                 :            : "\n"
         964                 :            : "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n"
         965                 :            : "been used at least once.");
         966                 :            :
         967                 :            : #define _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF    \
         968                 :            :     {"get_ca_certs", _PyCFunction_CAST(_ssl__SSLContext_get_ca_certs), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
         969                 :            :
         970                 :            : static PyObject *
         971                 :            : _ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form);
         972                 :            :
         973                 :            : static PyObject *
         974                 :          0 : _ssl__SSLContext_get_ca_certs(PySSLContext *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
         975                 :            : {
         976                 :          0 :     PyObject *return_value = NULL;
         977                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
         978                 :            :
         979                 :            :     #define NUM_KEYWORDS 1
         980                 :            :     static struct {
         981                 :            :         PyGC_Head _this_is_not_used;
         982                 :            :         PyObject_VAR_HEAD
         983                 :            :         PyObject *ob_item[NUM_KEYWORDS];
         984                 :            :     } _kwtuple = {
         985                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
         986                 :            :         .ob_item = { &_Py_ID(binary_form), },
         987                 :            :     };
         988                 :            :     #undef NUM_KEYWORDS
         989                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
         990                 :            :
         991                 :            :     #else  // !Py_BUILD_CORE
         992                 :            :     #  define KWTUPLE NULL
         993                 :            :     #endif  // !Py_BUILD_CORE
         994                 :            :
         995                 :            :     static const char * const _keywords[] = {"binary_form", NULL};
         996                 :            :     static _PyArg_Parser _parser = {
         997                 :            :         .keywords = _keywords,
         998                 :            :         .fname = "get_ca_certs",
         999                 :            :         .kwtuple = KWTUPLE,
        1000                 :            :     };
        1001                 :            :     #undef KWTUPLE
        1002                 :            :     PyObject *argsbuf[1];
        1003         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
        1004                 :          0 :     int binary_form = 0;
        1005                 :            :
        1006   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
                 #  #  #  # ]
        1007         [ #  # ]:          0 :     if (!args) {
        1008                 :          0 :         goto exit;
        1009                 :            :     }
        1010         [ #  # ]:          0 :     if (!noptargs) {
        1011                 :          0 :         goto skip_optional_pos;
        1012                 :            :     }
        1013                 :          0 :     binary_form = PyObject_IsTrue(args[0]);
        1014         [ #  # ]:          0 :     if (binary_form < 0) {
        1015                 :          0 :         goto exit;
        1016                 :            :     }
        1017                 :          0 : skip_optional_pos:
        1018                 :          0 :     return_value = _ssl__SSLContext_get_ca_certs_impl(self, binary_form);
        1019                 :            :
        1020                 :          0 : exit:
        1021                 :          0 :     return return_value;
        1022                 :            : }
        1023                 :            :
        1024                 :            : static PyObject *
        1025                 :            : _ssl_MemoryBIO_impl(PyTypeObject *type);
        1026                 :            :
        1027                 :            : static PyObject *
        1028                 :          0 : _ssl_MemoryBIO(PyTypeObject *type, PyObject *args, PyObject *kwargs)
        1029                 :            : {
        1030                 :          0 :     PyObject *return_value = NULL;
        1031                 :          0 :     PyTypeObject *base_tp = get_state_type(type)->PySSLMemoryBIO_Type;
        1032                 :            :
        1033   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
        1034         [ #  # ]:          0 :         !_PyArg_NoPositional("MemoryBIO", args)) {
        1035                 :          0 :         goto exit;
        1036                 :            :     }
        1037   [ #  #  #  #  :          0 :     if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
                       #  # ]
        1038         [ #  # ]:          0 :         !_PyArg_NoKeywords("MemoryBIO", kwargs)) {
        1039                 :          0 :         goto exit;
        1040                 :            :     }
        1041                 :          0 :     return_value = _ssl_MemoryBIO_impl(type);
        1042                 :            :
        1043                 :          0 : exit:
        1044                 :          0 :     return return_value;
        1045                 :            : }
        1046                 :            :
        1047                 :            : PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__,
        1048                 :            : "read($self, size=-1, /)\n"
        1049                 :            : "--\n"
        1050                 :            : "\n"
        1051                 :            : "Read up to size bytes from the memory BIO.\n"
        1052                 :            : "\n"
        1053                 :            : "If size is not specified, read the entire buffer.\n"
        1054                 :            : "If the return value is an empty bytes instance, this means either\n"
        1055                 :            : "EOF or that no data is available. Use the \"eof\" property to\n"
        1056                 :            : "distinguish between the two.");
        1057                 :            :
        1058                 :            : #define _SSL_MEMORYBIO_READ_METHODDEF    \
        1059                 :            :     {"read", _PyCFunction_CAST(_ssl_MemoryBIO_read), METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
        1060                 :            :
        1061                 :            : static PyObject *
        1062                 :            : _ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len);
        1063                 :            :
        1064                 :            : static PyObject *
        1065                 :          0 : _ssl_MemoryBIO_read(PySSLMemoryBIO *self, PyObject *const *args, Py_ssize_t nargs)
        1066                 :            : {
        1067                 :          0 :     PyObject *return_value = NULL;
        1068                 :          0 :     int len = -1;
        1069                 :            :
        1070   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
                       #  # ]
        1071                 :          0 :         goto exit;
        1072                 :            :     }
        1073         [ #  # ]:          0 :     if (nargs < 1) {
        1074                 :          0 :         goto skip_optional;
        1075                 :            :     }
        1076                 :          0 :     len = _PyLong_AsInt(args[0]);
        1077   [ #  #  #  # ]:          0 :     if (len == -1 && PyErr_Occurred()) {
        1078                 :          0 :         goto exit;
        1079                 :            :     }
        1080                 :          0 : skip_optional:
        1081                 :          0 :     return_value = _ssl_MemoryBIO_read_impl(self, len);
        1082                 :            :
        1083                 :          0 : exit:
        1084                 :          0 :     return return_value;
        1085                 :            : }
        1086                 :            :
        1087                 :            : PyDoc_STRVAR(_ssl_MemoryBIO_write__doc__,
        1088                 :            : "write($self, b, /)\n"
        1089                 :            : "--\n"
        1090                 :            : "\n"
        1091                 :            : "Writes the bytes b into the memory BIO.\n"
        1092                 :            : "\n"
        1093                 :            : "Returns the number of bytes written.");
        1094                 :            :
        1095                 :            : #define _SSL_MEMORYBIO_WRITE_METHODDEF    \
        1096                 :            :     {"write", (PyCFunction)_ssl_MemoryBIO_write, METH_O, _ssl_MemoryBIO_write__doc__},
        1097                 :            :
        1098                 :            : static PyObject *
        1099                 :            : _ssl_MemoryBIO_write_impl(PySSLMemoryBIO *self, Py_buffer *b);
        1100                 :            :
        1101                 :            : static PyObject *
        1102                 :          0 : _ssl_MemoryBIO_write(PySSLMemoryBIO *self, PyObject *arg)
        1103                 :            : {
        1104                 :          0 :     PyObject *return_value = NULL;
        1105                 :          0 :     Py_buffer b = {NULL, NULL};
        1106                 :            :
        1107         [ #  # ]:          0 :     if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
        1108                 :          0 :         goto exit;
        1109                 :            :     }
        1110         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&b, 'C')) {
        1111                 :          0 :         _PyArg_BadArgument("write", "argument", "contiguous buffer", arg);
        1112                 :          0 :         goto exit;
        1113                 :            :     }
        1114                 :          0 :     return_value = _ssl_MemoryBIO_write_impl(self, &b);
        1115                 :            :
        1116                 :          0 : exit:
        1117                 :            :     /* Cleanup for b */
        1118         [ #  # ]:          0 :     if (b.obj) {
        1119                 :          0 :        PyBuffer_Release(&b);
        1120                 :            :     }
        1121                 :            :
        1122                 :          0 :     return return_value;
        1123                 :            : }
        1124                 :            :
        1125                 :            : PyDoc_STRVAR(_ssl_MemoryBIO_write_eof__doc__,
        1126                 :            : "write_eof($self, /)\n"
        1127                 :            : "--\n"
        1128                 :            : "\n"
        1129                 :            : "Write an EOF marker to the memory BIO.\n"
        1130                 :            : "\n"
        1131                 :            : "When all data has been read, the \"eof\" property will be True.");
        1132                 :            :
        1133                 :            : #define _SSL_MEMORYBIO_WRITE_EOF_METHODDEF    \
        1134                 :            :     {"write_eof", (PyCFunction)_ssl_MemoryBIO_write_eof, METH_NOARGS, _ssl_MemoryBIO_write_eof__doc__},
        1135                 :            :
        1136                 :            : static PyObject *
        1137                 :            : _ssl_MemoryBIO_write_eof_impl(PySSLMemoryBIO *self);
        1138                 :            :
        1139                 :            : static PyObject *
        1140                 :          0 : _ssl_MemoryBIO_write_eof(PySSLMemoryBIO *self, PyObject *Py_UNUSED(ignored))
        1141                 :            : {
        1142                 :          0 :     return _ssl_MemoryBIO_write_eof_impl(self);
        1143                 :            : }
        1144                 :            :
        1145                 :            : PyDoc_STRVAR(_ssl_RAND_add__doc__,
        1146                 :            : "RAND_add($module, string, entropy, /)\n"
        1147                 :            : "--\n"
        1148                 :            : "\n"
        1149                 :            : "Mix string into the OpenSSL PRNG state.\n"
        1150                 :            : "\n"
        1151                 :            : "entropy (a float) is a lower bound on the entropy contained in\n"
        1152                 :            : "string.  See RFC 4086.");
        1153                 :            :
        1154                 :            : #define _SSL_RAND_ADD_METHODDEF    \
        1155                 :            :     {"RAND_add", _PyCFunction_CAST(_ssl_RAND_add), METH_FASTCALL, _ssl_RAND_add__doc__},
        1156                 :            :
        1157                 :            : static PyObject *
        1158                 :            : _ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy);
        1159                 :            :
        1160                 :            : static PyObject *
        1161                 :          0 : _ssl_RAND_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
        1162                 :            : {
        1163                 :          0 :     PyObject *return_value = NULL;
        1164                 :          0 :     Py_buffer view = {NULL, NULL};
        1165                 :            :     double entropy;
        1166                 :            :
        1167   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("RAND_add", nargs, 2, 2)) {
                       #  # ]
        1168                 :          0 :         goto exit;
        1169                 :            :     }
        1170         [ #  # ]:          0 :     if (PyUnicode_Check(args[0])) {
        1171                 :            :         Py_ssize_t len;
        1172                 :          0 :         const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
        1173         [ #  # ]:          0 :         if (ptr == NULL) {
        1174                 :          0 :             goto exit;
        1175                 :            :         }
        1176                 :          0 :         PyBuffer_FillInfo(&view, args[0], (void *)ptr, len, 1, 0);
        1177                 :            :     }
        1178                 :            :     else { /* any bytes-like object */
        1179         [ #  # ]:          0 :         if (PyObject_GetBuffer(args[0], &view, PyBUF_SIMPLE) != 0) {
        1180                 :          0 :             goto exit;
        1181                 :            :         }
        1182         [ #  # ]:          0 :         if (!PyBuffer_IsContiguous(&view, 'C')) {
        1183                 :          0 :             _PyArg_BadArgument("RAND_add", "argument 1", "contiguous buffer", args[0]);
        1184                 :          0 :             goto exit;
        1185                 :            :         }
        1186                 :            :     }
        1187         [ #  # ]:          0 :     if (PyFloat_CheckExact(args[1])) {
        1188                 :          0 :         entropy = PyFloat_AS_DOUBLE(args[1]);
        1189                 :            :     }
        1190                 :            :     else
        1191                 :            :     {
        1192                 :          0 :         entropy = PyFloat_AsDouble(args[1]);
        1193   [ #  #  #  # ]:          0 :         if (entropy == -1.0 && PyErr_Occurred()) {
        1194                 :          0 :             goto exit;
        1195                 :            :         }
        1196                 :            :     }
        1197                 :          0 :     return_value = _ssl_RAND_add_impl(module, &view, entropy);
        1198                 :            :
        1199                 :          0 : exit:
        1200                 :            :     /* Cleanup for view */
        1201         [ #  # ]:          0 :     if (view.obj) {
        1202                 :          0 :        PyBuffer_Release(&view);
        1203                 :            :     }
        1204                 :            :
        1205                 :          0 :     return return_value;
        1206                 :            : }
        1207                 :            :
        1208                 :            : PyDoc_STRVAR(_ssl_RAND_bytes__doc__,
        1209                 :            : "RAND_bytes($module, n, /)\n"
        1210                 :            : "--\n"
        1211                 :            : "\n"
        1212                 :            : "Generate n cryptographically strong pseudo-random bytes.");
        1213                 :            :
        1214                 :            : #define _SSL_RAND_BYTES_METHODDEF    \
        1215                 :            :     {"RAND_bytes", (PyCFunction)_ssl_RAND_bytes, METH_O, _ssl_RAND_bytes__doc__},
        1216                 :            :
        1217                 :            : static PyObject *
        1218                 :            : _ssl_RAND_bytes_impl(PyObject *module, int n);
        1219                 :            :
        1220                 :            : static PyObject *
        1221                 :          0 : _ssl_RAND_bytes(PyObject *module, PyObject *arg)
        1222                 :            : {
        1223                 :          0 :     PyObject *return_value = NULL;
        1224                 :            :     int n;
        1225                 :            :
        1226                 :          0 :     n = _PyLong_AsInt(arg);
        1227   [ #  #  #  # ]:          0 :     if (n == -1 && PyErr_Occurred()) {
        1228                 :          0 :         goto exit;
        1229                 :            :     }
        1230                 :          0 :     return_value = _ssl_RAND_bytes_impl(module, n);
        1231                 :            :
        1232                 :          0 : exit:
        1233                 :          0 :     return return_value;
        1234                 :            : }
        1235                 :            :
        1236                 :            : PyDoc_STRVAR(_ssl_RAND_status__doc__,
        1237                 :            : "RAND_status($module, /)\n"
        1238                 :            : "--\n"
        1239                 :            : "\n"
        1240                 :            : "Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.\n"
        1241                 :            : "\n"
        1242                 :            : "It is necessary to seed the PRNG with RAND_add() on some platforms before\n"
        1243                 :            : "using the ssl() function.");
        1244                 :            :
        1245                 :            : #define _SSL_RAND_STATUS_METHODDEF    \
        1246                 :            :     {"RAND_status", (PyCFunction)_ssl_RAND_status, METH_NOARGS, _ssl_RAND_status__doc__},
        1247                 :            :
        1248                 :            : static PyObject *
        1249                 :            : _ssl_RAND_status_impl(PyObject *module);
        1250                 :            :
        1251                 :            : static PyObject *
        1252                 :          0 : _ssl_RAND_status(PyObject *module, PyObject *Py_UNUSED(ignored))
        1253                 :            : {
        1254                 :          0 :     return _ssl_RAND_status_impl(module);
        1255                 :            : }
        1256                 :            :
        1257                 :            : PyDoc_STRVAR(_ssl_get_default_verify_paths__doc__,
        1258                 :            : "get_default_verify_paths($module, /)\n"
        1259                 :            : "--\n"
        1260                 :            : "\n"
        1261                 :            : "Return search paths and environment vars that are used by SSLContext\'s set_default_verify_paths() to load default CAs.\n"
        1262                 :            : "\n"
        1263                 :            : "The values are \'cert_file_env\', \'cert_file\', \'cert_dir_env\', \'cert_dir\'.");
        1264                 :            :
        1265                 :            : #define _SSL_GET_DEFAULT_VERIFY_PATHS_METHODDEF    \
        1266                 :            :     {"get_default_verify_paths", (PyCFunction)_ssl_get_default_verify_paths, METH_NOARGS, _ssl_get_default_verify_paths__doc__},
        1267                 :            :
        1268                 :            : static PyObject *
        1269                 :            : _ssl_get_default_verify_paths_impl(PyObject *module);
        1270                 :            :
        1271                 :            : static PyObject *
        1272                 :          0 : _ssl_get_default_verify_paths(PyObject *module, PyObject *Py_UNUSED(ignored))
        1273                 :            : {
        1274                 :          0 :     return _ssl_get_default_verify_paths_impl(module);
        1275                 :            : }
        1276                 :            :
        1277                 :            : PyDoc_STRVAR(_ssl_txt2obj__doc__,
        1278                 :            : "txt2obj($module, /, txt, name=False)\n"
        1279                 :            : "--\n"
        1280                 :            : "\n"
        1281                 :            : "Lookup NID, short name, long name and OID of an ASN1_OBJECT.\n"
        1282                 :            : "\n"
        1283                 :            : "By default objects are looked up by OID. With name=True short and\n"
        1284                 :            : "long name are also matched.");
        1285                 :            :
        1286                 :            : #define _SSL_TXT2OBJ_METHODDEF    \
        1287                 :            :     {"txt2obj", _PyCFunction_CAST(_ssl_txt2obj), METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
        1288                 :            :
        1289                 :            : static PyObject *
        1290                 :            : _ssl_txt2obj_impl(PyObject *module, const char *txt, int name);
        1291                 :            :
        1292                 :            : static PyObject *
        1293                 :          4 : _ssl_txt2obj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1294                 :            : {
        1295                 :          4 :     PyObject *return_value = NULL;
        1296                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1297                 :            :
        1298                 :            :     #define NUM_KEYWORDS 2
        1299                 :            :     static struct {
        1300                 :            :         PyGC_Head _this_is_not_used;
        1301                 :            :         PyObject_VAR_HEAD
        1302                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1303                 :            :     } _kwtuple = {
        1304                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1305                 :            :         .ob_item = { &_Py_ID(txt), &_Py_ID(name), },
        1306                 :            :     };
        1307                 :            :     #undef NUM_KEYWORDS
        1308                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1309                 :            :
        1310                 :            :     #else  // !Py_BUILD_CORE
        1311                 :            :     #  define KWTUPLE NULL
        1312                 :            :     #endif  // !Py_BUILD_CORE
        1313                 :            :
        1314                 :            :     static const char * const _keywords[] = {"txt", "name", NULL};
        1315                 :            :     static _PyArg_Parser _parser = {
        1316                 :            :         .keywords = _keywords,
        1317                 :            :         .fname = "txt2obj",
        1318                 :            :         .kwtuple = KWTUPLE,
        1319                 :            :     };
        1320                 :            :     #undef KWTUPLE
        1321                 :            :     PyObject *argsbuf[2];
        1322         [ +  - ]:          4 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
        1323                 :            :     const char *txt;
        1324                 :          4 :     int name = 0;
        1325                 :            :
        1326   [ -  +  -  -  :          4 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
                 -  -  -  - ]
        1327         [ -  + ]:          4 :     if (!args) {
        1328                 :          0 :         goto exit;
        1329                 :            :     }
        1330         [ -  + ]:          4 :     if (!PyUnicode_Check(args[0])) {
        1331                 :          0 :         _PyArg_BadArgument("txt2obj", "argument 'txt'", "str", args[0]);
        1332                 :          0 :         goto exit;
        1333                 :            :     }
        1334                 :            :     Py_ssize_t txt_length;
        1335                 :          4 :     txt = PyUnicode_AsUTF8AndSize(args[0], &txt_length);
        1336         [ -  + ]:          4 :     if (txt == NULL) {
        1337                 :          0 :         goto exit;
        1338                 :            :     }
        1339         [ -  + ]:          4 :     if (strlen(txt) != (size_t)txt_length) {
        1340                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
        1341                 :          0 :         goto exit;
        1342                 :            :     }
        1343         [ -  + ]:          4 :     if (!noptargs) {
        1344                 :          0 :         goto skip_optional_pos;
        1345                 :            :     }
        1346                 :          4 :     name = PyObject_IsTrue(args[1]);
        1347         [ -  + ]:          4 :     if (name < 0) {
        1348                 :          0 :         goto exit;
        1349                 :            :     }
        1350                 :          4 : skip_optional_pos:
        1351                 :          4 :     return_value = _ssl_txt2obj_impl(module, txt, name);
        1352                 :            :
        1353                 :          4 : exit:
        1354                 :          4 :     return return_value;
        1355                 :            : }
        1356                 :            :
        1357                 :            : PyDoc_STRVAR(_ssl_nid2obj__doc__,
        1358                 :            : "nid2obj($module, nid, /)\n"
        1359                 :            : "--\n"
        1360                 :            : "\n"
        1361                 :            : "Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.");
        1362                 :            :
        1363                 :            : #define _SSL_NID2OBJ_METHODDEF    \
        1364                 :            :     {"nid2obj", (PyCFunction)_ssl_nid2obj, METH_O, _ssl_nid2obj__doc__},
        1365                 :            :
        1366                 :            : static PyObject *
        1367                 :            : _ssl_nid2obj_impl(PyObject *module, int nid);
        1368                 :            :
        1369                 :            : static PyObject *
        1370                 :          0 : _ssl_nid2obj(PyObject *module, PyObject *arg)
        1371                 :            : {
        1372                 :          0 :     PyObject *return_value = NULL;
        1373                 :            :     int nid;
        1374                 :            :
        1375                 :          0 :     nid = _PyLong_AsInt(arg);
        1376   [ #  #  #  # ]:          0 :     if (nid == -1 && PyErr_Occurred()) {
        1377                 :          0 :         goto exit;
        1378                 :            :     }
        1379                 :          0 :     return_value = _ssl_nid2obj_impl(module, nid);
        1380                 :            :
        1381                 :          0 : exit:
        1382                 :          0 :     return return_value;
        1383                 :            : }
        1384                 :            :
        1385                 :            : #if defined(_MSC_VER)
        1386                 :            :
        1387                 :            : PyDoc_STRVAR(_ssl_enum_certificates__doc__,
        1388                 :            : "enum_certificates($module, /, store_name)\n"
        1389                 :            : "--\n"
        1390                 :            : "\n"
        1391                 :            : "Retrieve certificates from Windows\' cert store.\n"
        1392                 :            : "\n"
        1393                 :            : "store_name may be one of \'CA\', \'ROOT\' or \'MY\'.  The system may provide\n"
        1394                 :            : "more cert storages, too.  The function returns a list of (bytes,\n"
        1395                 :            : "encoding_type, trust) tuples.  The encoding_type flag can be interpreted\n"
        1396                 :            : "with X509_ASN_ENCODING or PKCS_7_ASN_ENCODING. The trust setting is either\n"
        1397                 :            : "a set of OIDs or the boolean True.");
        1398                 :            :
        1399                 :            : #define _SSL_ENUM_CERTIFICATES_METHODDEF    \
        1400                 :            :     {"enum_certificates", _PyCFunction_CAST(_ssl_enum_certificates), METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
        1401                 :            :
        1402                 :            : static PyObject *
        1403                 :            : _ssl_enum_certificates_impl(PyObject *module, const char *store_name);
        1404                 :            :
        1405                 :            : static PyObject *
        1406                 :            : _ssl_enum_certificates(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1407                 :            : {
        1408                 :            :     PyObject *return_value = NULL;
        1409                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1410                 :            :
        1411                 :            :     #define NUM_KEYWORDS 1
        1412                 :            :     static struct {
        1413                 :            :         PyGC_Head _this_is_not_used;
        1414                 :            :         PyObject_VAR_HEAD
        1415                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1416                 :            :     } _kwtuple = {
        1417                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1418                 :            :         .ob_item = { &_Py_ID(store_name), },
        1419                 :            :     };
        1420                 :            :     #undef NUM_KEYWORDS
        1421                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1422                 :            :
        1423                 :            :     #else  // !Py_BUILD_CORE
        1424                 :            :     #  define KWTUPLE NULL
        1425                 :            :     #endif  // !Py_BUILD_CORE
        1426                 :            :
        1427                 :            :     static const char * const _keywords[] = {"store_name", NULL};
        1428                 :            :     static _PyArg_Parser _parser = {
        1429                 :            :         .keywords = _keywords,
        1430                 :            :         .fname = "enum_certificates",
        1431                 :            :         .kwtuple = KWTUPLE,
        1432                 :            :     };
        1433                 :            :     #undef KWTUPLE
        1434                 :            :     PyObject *argsbuf[1];
        1435                 :            :     const char *store_name;
        1436                 :            :
        1437                 :            :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
        1438                 :            :     if (!args) {
        1439                 :            :         goto exit;
        1440                 :            :     }
        1441                 :            :     if (!PyUnicode_Check(args[0])) {
        1442                 :            :         _PyArg_BadArgument("enum_certificates", "argument 'store_name'", "str", args[0]);
        1443                 :            :         goto exit;
        1444                 :            :     }
        1445                 :            :     Py_ssize_t store_name_length;
        1446                 :            :     store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length);
        1447                 :            :     if (store_name == NULL) {
        1448                 :            :         goto exit;
        1449                 :            :     }
        1450                 :            :     if (strlen(store_name) != (size_t)store_name_length) {
        1451                 :            :         PyErr_SetString(PyExc_ValueError, "embedded null character");
        1452                 :            :         goto exit;
        1453                 :            :     }
        1454                 :            :     return_value = _ssl_enum_certificates_impl(module, store_name);
        1455                 :            :
        1456                 :            : exit:
        1457                 :            :     return return_value;
        1458                 :            : }
        1459                 :            :
        1460                 :            : #endif /* defined(_MSC_VER) */
        1461                 :            :
        1462                 :            : #if defined(_MSC_VER)
        1463                 :            :
        1464                 :            : PyDoc_STRVAR(_ssl_enum_crls__doc__,
        1465                 :            : "enum_crls($module, /, store_name)\n"
        1466                 :            : "--\n"
        1467                 :            : "\n"
        1468                 :            : "Retrieve CRLs from Windows\' cert store.\n"
        1469                 :            : "\n"
        1470                 :            : "store_name may be one of \'CA\', \'ROOT\' or \'MY\'.  The system may provide\n"
        1471                 :            : "more cert storages, too.  The function returns a list of (bytes,\n"
        1472                 :            : "encoding_type) tuples.  The encoding_type flag can be interpreted with\n"
        1473                 :            : "X509_ASN_ENCODING or PKCS_7_ASN_ENCODING.");
        1474                 :            :
        1475                 :            : #define _SSL_ENUM_CRLS_METHODDEF    \
        1476                 :            :     {"enum_crls", _PyCFunction_CAST(_ssl_enum_crls), METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
        1477                 :            :
        1478                 :            : static PyObject *
        1479                 :            : _ssl_enum_crls_impl(PyObject *module, const char *store_name);
        1480                 :            :
        1481                 :            : static PyObject *
        1482                 :            : _ssl_enum_crls(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
        1483                 :            : {
        1484                 :            :     PyObject *return_value = NULL;
        1485                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
        1486                 :            :
        1487                 :            :     #define NUM_KEYWORDS 1
        1488                 :            :     static struct {
        1489                 :            :         PyGC_Head _this_is_not_used;
        1490                 :            :         PyObject_VAR_HEAD
        1491                 :            :         PyObject *ob_item[NUM_KEYWORDS];
        1492                 :            :     } _kwtuple = {
        1493                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
        1494                 :            :         .ob_item = { &_Py_ID(store_name), },
        1495                 :            :     };
        1496                 :            :     #undef NUM_KEYWORDS
        1497                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
        1498                 :            :
        1499                 :            :     #else  // !Py_BUILD_CORE
        1500                 :            :     #  define KWTUPLE NULL
        1501                 :            :     #endif  // !Py_BUILD_CORE
        1502                 :            :
        1503                 :            :     static const char * const _keywords[] = {"store_name", NULL};
        1504                 :            :     static _PyArg_Parser _parser = {
        1505                 :            :         .keywords = _keywords,
        1506                 :            :         .fname = "enum_crls",
        1507                 :            :         .kwtuple = KWTUPLE,
        1508                 :            :     };
        1509                 :            :     #undef KWTUPLE
        1510                 :            :     PyObject *argsbuf[1];
        1511                 :            :     const char *store_name;
        1512                 :            :
        1513                 :            :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
        1514                 :            :     if (!args) {
        1515                 :            :         goto exit;
        1516                 :            :     }
        1517                 :            :     if (!PyUnicode_Check(args[0])) {
        1518                 :            :         _PyArg_BadArgument("enum_crls", "argument 'store_name'", "str", args[0]);
        1519                 :            :         goto exit;
        1520                 :            :     }
        1521                 :            :     Py_ssize_t store_name_length;
        1522                 :            :     store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length);
        1523                 :            :     if (store_name == NULL) {
        1524                 :            :         goto exit;
        1525                 :            :     }
        1526                 :            :     if (strlen(store_name) != (size_t)store_name_length) {
        1527                 :            :         PyErr_SetString(PyExc_ValueError, "embedded null character");
        1528                 :            :         goto exit;
        1529                 :            :     }
        1530                 :            :     return_value = _ssl_enum_crls_impl(module, store_name);
        1531                 :            :
        1532                 :            : exit:
        1533                 :            :     return return_value;
        1534                 :            : }
        1535                 :            :
        1536                 :            : #endif /* defined(_MSC_VER) */
        1537                 :            :
        1538                 :            : #ifndef _SSL_ENUM_CERTIFICATES_METHODDEF
        1539                 :            :     #define _SSL_ENUM_CERTIFICATES_METHODDEF
        1540                 :            : #endif /* !defined(_SSL_ENUM_CERTIFICATES_METHODDEF) */
        1541                 :            :
        1542                 :            : #ifndef _SSL_ENUM_CRLS_METHODDEF
        1543                 :            :     #define _SSL_ENUM_CRLS_METHODDEF
        1544                 :            : #endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */
        1545                 :            : /*[clinic end generated code: output=4d9b81fa81f520f0 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14