Debian Codegraph @

Modules/clinic/_ssl.c.h

raw
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 #include "pycore_critical_section.h"// Py_BEGIN_CRITICAL_SECTION()
10 #include "pycore_modsupport.h" // _PyArg_CheckPositional()
11
12 PyDoc_STRVAR(_ssl__SSLSocket_do_handshake__doc__,
13 "do_handshake($self, /)\n"
14 "--\n"
15 "\n");
16
17 #define _SSL__SSLSOCKET_DO_HANDSHAKE_METHODDEF \
18 {"do_handshake", (PyCFunction)_ssl__SSLSocket_do_handshake, METH_NOARGS, _ssl__SSLSocket_do_handshake__doc__},
19
20 static PyObject *
21 _ssl__SSLSocket_do_handshake_impl(PySSLSocket *self);
22
23 static PyObject *
24 _ssl__SSLSocket_do_handshake(PyObject *self, PyObject *Py_UNUSED(ignored))
25 {
26 PyObject *return_value = NULL;
27
28 Py_BEGIN_CRITICAL_SECTION(self);
29 return_value = _ssl__SSLSocket_do_handshake_impl((PySSLSocket *)self);
30 Py_END_CRITICAL_SECTION();
31
32 return return_value;
33 }
34
35 PyDoc_STRVAR(_ssl__test_decode_cert__doc__,
36 "_test_decode_cert($module, path, /)\n"
37 "--\n"
38 "\n");
39
40 #define _SSL__TEST_DECODE_CERT_METHODDEF \
41 {"_test_decode_cert", (PyCFunction)_ssl__test_decode_cert, METH_O, _ssl__test_decode_cert__doc__},
42
43 static PyObject *
44 _ssl__test_decode_cert_impl(PyObject *module, PyObject *path);
45
46 static PyObject *
47 _ssl__test_decode_cert(PyObject *module, PyObject *arg)
48 {
49 PyObject *return_value = NULL;
50 PyObject *path = NULL;
51
52 if (!PyUnicode_FSConverter(arg, &path)) {
53 goto exit;
54 }
55 return_value = _ssl__test_decode_cert_impl(module, path);
56
57 exit:
58 /* Cleanup for path */
59 Py_XDECREF(path);
60
61 return return_value;
62 }
63
64 PyDoc_STRVAR(_ssl__SSLSocket_getpeercert__doc__,
65 "getpeercert($self, der=False, /)\n"
66 "--\n"
67 "\n"
68 "Returns the certificate for the peer.\n"
69 "\n"
70 "If no certificate was provided, returns None. If a certificate was\n"
71 "provided, but not validated, returns an empty dictionary. Otherwise\n"
72 "returns a dict containing information about the peer certificate.\n"
73 "\n"
74 "If the optional argument is True, returns a DER-encoded copy of the\n"
75 "peer certificate, or None if no certificate was provided. This will\n"
76 "return the certificate even if it wasn\'t validated.");
77
78 #define _SSL__SSLSOCKET_GETPEERCERT_METHODDEF \
79 {"getpeercert", _PyCFunction_CAST(_ssl__SSLSocket_getpeercert), METH_FASTCALL, _ssl__SSLSocket_getpeercert__doc__},
80
81 static PyObject *
82 _ssl__SSLSocket_getpeercert_impl(PySSLSocket *self, int binary_mode);
83
84 static PyObject *
85 _ssl__SSLSocket_getpeercert(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
86 {
87 PyObject *return_value = NULL;
88 int binary_mode = 0;
89
90 if (!_PyArg_CheckPositional("getpeercert", nargs, 0, 1)) {
91 goto exit;
92 }
93 if (nargs < 1) {
94 goto skip_optional;
95 }
96 binary_mode = PyObject_IsTrue(args[0]);
97 if (binary_mode < 0) {
98 goto exit;
99 }
100 skip_optional:
101 Py_BEGIN_CRITICAL_SECTION(self);
102 return_value = _ssl__SSLSocket_getpeercert_impl((PySSLSocket *)self, binary_mode);
103 Py_END_CRITICAL_SECTION();
104
105 exit:
106 return return_value;
107 }
108
109 PyDoc_STRVAR(_ssl__SSLSocket_get_verified_chain__doc__,
110 "get_verified_chain($self, /)\n"
111 "--\n"
112 "\n");
113
114 #define _SSL__SSLSOCKET_GET_VERIFIED_CHAIN_METHODDEF \
115 {"get_verified_chain", (PyCFunction)_ssl__SSLSocket_get_verified_chain, METH_NOARGS, _ssl__SSLSocket_get_verified_chain__doc__},
116
117 static PyObject *
118 _ssl__SSLSocket_get_verified_chain_impl(PySSLSocket *self);
119
120 static PyObject *
121 _ssl__SSLSocket_get_verified_chain(PyObject *self, PyObject *Py_UNUSED(ignored))
122 {
123 PyObject *return_value = NULL;
124
125 Py_BEGIN_CRITICAL_SECTION(self);
126 return_value = _ssl__SSLSocket_get_verified_chain_impl((PySSLSocket *)self);
127 Py_END_CRITICAL_SECTION();
128
129 return return_value;
130 }
131
132 PyDoc_STRVAR(_ssl__SSLSocket_get_unverified_chain__doc__,
133 "get_unverified_chain($self, /)\n"
134 "--\n"
135 "\n");
136
137 #define _SSL__SSLSOCKET_GET_UNVERIFIED_CHAIN_METHODDEF \
138 {"get_unverified_chain", (PyCFunction)_ssl__SSLSocket_get_unverified_chain, METH_NOARGS, _ssl__SSLSocket_get_unverified_chain__doc__},
139
140 static PyObject *
141 _ssl__SSLSocket_get_unverified_chain_impl(PySSLSocket *self);
142
143 static PyObject *
144 _ssl__SSLSocket_get_unverified_chain(PyObject *self, PyObject *Py_UNUSED(ignored))
145 {
146 PyObject *return_value = NULL;
147
148 Py_BEGIN_CRITICAL_SECTION(self);
149 return_value = _ssl__SSLSocket_get_unverified_chain_impl((PySSLSocket *)self);
150 Py_END_CRITICAL_SECTION();
151
152 return return_value;
153 }
154
155 PyDoc_STRVAR(_ssl__SSLSocket_shared_ciphers__doc__,
156 "shared_ciphers($self, /)\n"
157 "--\n"
158 "\n");
159
160 #define _SSL__SSLSOCKET_SHARED_CIPHERS_METHODDEF \
161 {"shared_ciphers", (PyCFunction)_ssl__SSLSocket_shared_ciphers, METH_NOARGS, _ssl__SSLSocket_shared_ciphers__doc__},
162
163 static PyObject *
164 _ssl__SSLSocket_shared_ciphers_impl(PySSLSocket *self);
165
166 static PyObject *
167 _ssl__SSLSocket_shared_ciphers(PyObject *self, PyObject *Py_UNUSED(ignored))
168 {
169 PyObject *return_value = NULL;
170
171 Py_BEGIN_CRITICAL_SECTION(self);
172 return_value = _ssl__SSLSocket_shared_ciphers_impl((PySSLSocket *)self);
173 Py_END_CRITICAL_SECTION();
174
175 return return_value;
176 }
177
178 PyDoc_STRVAR(_ssl__SSLSocket_cipher__doc__,
179 "cipher($self, /)\n"
180 "--\n"
181 "\n");
182
183 #define _SSL__SSLSOCKET_CIPHER_METHODDEF \
184 {"cipher", (PyCFunction)_ssl__SSLSocket_cipher, METH_NOARGS, _ssl__SSLSocket_cipher__doc__},
185
186 static PyObject *
187 _ssl__SSLSocket_cipher_impl(PySSLSocket *self);
188
189 static PyObject *
190 _ssl__SSLSocket_cipher(PyObject *self, PyObject *Py_UNUSED(ignored))
191 {
192 PyObject *return_value = NULL;
193
194 Py_BEGIN_CRITICAL_SECTION(self);
195 return_value = _ssl__SSLSocket_cipher_impl((PySSLSocket *)self);
196 Py_END_CRITICAL_SECTION();
197
198 return return_value;
199 }
200
201 PyDoc_STRVAR(_ssl__SSLSocket_version__doc__,
202 "version($self, /)\n"
203 "--\n"
204 "\n");
205
206 #define _SSL__SSLSOCKET_VERSION_METHODDEF \
207 {"version", (PyCFunction)_ssl__SSLSocket_version, METH_NOARGS, _ssl__SSLSocket_version__doc__},
208
209 static PyObject *
210 _ssl__SSLSocket_version_impl(PySSLSocket *self);
211
212 static PyObject *
213 _ssl__SSLSocket_version(PyObject *self, PyObject *Py_UNUSED(ignored))
214 {
215 PyObject *return_value = NULL;
216
217 Py_BEGIN_CRITICAL_SECTION(self);
218 return_value = _ssl__SSLSocket_version_impl((PySSLSocket *)self);
219 Py_END_CRITICAL_SECTION();
220
221 return return_value;
222 }
223
224 PyDoc_STRVAR(_ssl__SSLSocket_selected_alpn_protocol__doc__,
225 "selected_alpn_protocol($self, /)\n"
226 "--\n"
227 "\n");
228
229 #define _SSL__SSLSOCKET_SELECTED_ALPN_PROTOCOL_METHODDEF \
230 {"selected_alpn_protocol", (PyCFunction)_ssl__SSLSocket_selected_alpn_protocol, METH_NOARGS, _ssl__SSLSocket_selected_alpn_protocol__doc__},
231
232 static PyObject *
233 _ssl__SSLSocket_selected_alpn_protocol_impl(PySSLSocket *self);
234
235 static PyObject *
236 _ssl__SSLSocket_selected_alpn_protocol(PyObject *self, PyObject *Py_UNUSED(ignored))
237 {
238 PyObject *return_value = NULL;
239
240 Py_BEGIN_CRITICAL_SECTION(self);
241 return_value = _ssl__SSLSocket_selected_alpn_protocol_impl((PySSLSocket *)self);
242 Py_END_CRITICAL_SECTION();
243
244 return return_value;
245 }
246
247 PyDoc_STRVAR(_ssl__SSLSocket_compression__doc__,
248 "compression($self, /)\n"
249 "--\n"
250 "\n");
251
252 #define _SSL__SSLSOCKET_COMPRESSION_METHODDEF \
253 {"compression", (PyCFunction)_ssl__SSLSocket_compression, METH_NOARGS, _ssl__SSLSocket_compression__doc__},
254
255 static PyObject *
256 _ssl__SSLSocket_compression_impl(PySSLSocket *self);
257
258 static PyObject *
259 _ssl__SSLSocket_compression(PyObject *self, PyObject *Py_UNUSED(ignored))
260 {
261 return _ssl__SSLSocket_compression_impl((PySSLSocket *)self);
262 }
263
264 PyDoc_STRVAR(_ssl__SSLSocket_context__doc__,
265 "This changes the context associated with the SSLSocket.\n"
266 "\n"
267 "This is typically used from within a callback function set by the sni_callback\n"
268 "on the SSLContext to change the certificate information associated with the\n"
269 "SSLSocket before the cryptographic exchange handshake messages.");
270 #if defined(_ssl__SSLSocket_context_DOCSTR)
271 # undef _ssl__SSLSocket_context_DOCSTR
272 #endif
273 #define _ssl__SSLSocket_context_DOCSTR _ssl__SSLSocket_context__doc__
274
275 #if !defined(_ssl__SSLSocket_context_DOCSTR)
276 # define _ssl__SSLSocket_context_DOCSTR NULL
277 #endif
278 #if defined(_SSL__SSLSOCKET_CONTEXT_GETSETDEF)
279 # undef _SSL__SSLSOCKET_CONTEXT_GETSETDEF
280 # define _SSL__SSLSOCKET_CONTEXT_GETSETDEF {"context", (getter)_ssl__SSLSocket_context_get, (setter)_ssl__SSLSocket_context_set, _ssl__SSLSocket_context_DOCSTR},
281 #else
282 # define _SSL__SSLSOCKET_CONTEXT_GETSETDEF {"context", (getter)_ssl__SSLSocket_context_get, NULL, _ssl__SSLSocket_context_DOCSTR},
283 #endif
284
285 static PyObject *
286 _ssl__SSLSocket_context_get_impl(PySSLSocket *self);
287
288 static PyObject *
289 _ssl__SSLSocket_context_get(PyObject *self, void *Py_UNUSED(context))
290 {
291 PyObject *return_value = NULL;
292
293 Py_BEGIN_CRITICAL_SECTION(self);
294 return_value = _ssl__SSLSocket_context_get_impl((PySSLSocket *)self);
295 Py_END_CRITICAL_SECTION();
296
297 return return_value;
298 }
299
300 #if !defined(_ssl__SSLSocket_context_DOCSTR)
301 # define _ssl__SSLSocket_context_DOCSTR NULL
302 #endif
303 #if defined(_SSL__SSLSOCKET_CONTEXT_GETSETDEF)
304 # undef _SSL__SSLSOCKET_CONTEXT_GETSETDEF
305 # define _SSL__SSLSOCKET_CONTEXT_GETSETDEF {"context", (getter)_ssl__SSLSocket_context_get, (setter)_ssl__SSLSocket_context_set, _ssl__SSLSocket_context_DOCSTR},
306 #else
307 # define _SSL__SSLSOCKET_CONTEXT_GETSETDEF {"context", NULL, (setter)_ssl__SSLSocket_context_set, NULL},
308 #endif
309
310 static int
311 _ssl__SSLSocket_context_set_impl(PySSLSocket *self, PyObject *value);
312
313 static int
314 _ssl__SSLSocket_context_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
315 {
316 int return_value;
317
318 Py_BEGIN_CRITICAL_SECTION(self);
319 return_value = _ssl__SSLSocket_context_set_impl((PySSLSocket *)self, value);
320 Py_END_CRITICAL_SECTION();
321
322 return return_value;
323 }
324
325 PyDoc_STRVAR(_ssl__SSLSocket_server_side__doc__,
326 "Whether this is a server-side socket.");
327 #if defined(_ssl__SSLSocket_server_side_DOCSTR)
328 # undef _ssl__SSLSocket_server_side_DOCSTR
329 #endif
330 #define _ssl__SSLSocket_server_side_DOCSTR _ssl__SSLSocket_server_side__doc__
331
332 #if !defined(_ssl__SSLSocket_server_side_DOCSTR)
333 # define _ssl__SSLSocket_server_side_DOCSTR NULL
334 #endif
335 #if defined(_SSL__SSLSOCKET_SERVER_SIDE_GETSETDEF)
336 # undef _SSL__SSLSOCKET_SERVER_SIDE_GETSETDEF
337 # define _SSL__SSLSOCKET_SERVER_SIDE_GETSETDEF {"server_side", (getter)_ssl__SSLSocket_server_side_get, (setter)_ssl__SSLSocket_server_side_set, _ssl__SSLSocket_server_side_DOCSTR},
338 #else
339 # define _SSL__SSLSOCKET_SERVER_SIDE_GETSETDEF {"server_side", (getter)_ssl__SSLSocket_server_side_get, NULL, _ssl__SSLSocket_server_side_DOCSTR},
340 #endif
341
342 static PyObject *
343 _ssl__SSLSocket_server_side_get_impl(PySSLSocket *self);
344
345 static PyObject *
346 _ssl__SSLSocket_server_side_get(PyObject *self, void *Py_UNUSED(context))
347 {
348 PyObject *return_value = NULL;
349
350 Py_BEGIN_CRITICAL_SECTION(self);
351 return_value = _ssl__SSLSocket_server_side_get_impl((PySSLSocket *)self);
352 Py_END_CRITICAL_SECTION();
353
354 return return_value;
355 }
356
357 PyDoc_STRVAR(_ssl__SSLSocket_server_hostname__doc__,
358 "The currently set server hostname (for SNI).");
359 #if defined(_ssl__SSLSocket_server_hostname_DOCSTR)
360 # undef _ssl__SSLSocket_server_hostname_DOCSTR
361 #endif
362 #define _ssl__SSLSocket_server_hostname_DOCSTR _ssl__SSLSocket_server_hostname__doc__
363
364 #if !defined(_ssl__SSLSocket_server_hostname_DOCSTR)
365 # define _ssl__SSLSocket_server_hostname_DOCSTR NULL
366 #endif
367 #if defined(_SSL__SSLSOCKET_SERVER_HOSTNAME_GETSETDEF)
368 # undef _SSL__SSLSOCKET_SERVER_HOSTNAME_GETSETDEF
369 # define _SSL__SSLSOCKET_SERVER_HOSTNAME_GETSETDEF {"server_hostname", (getter)_ssl__SSLSocket_server_hostname_get, (setter)_ssl__SSLSocket_server_hostname_set, _ssl__SSLSocket_server_hostname_DOCSTR},
370 #else
371 # define _SSL__SSLSOCKET_SERVER_HOSTNAME_GETSETDEF {"server_hostname", (getter)_ssl__SSLSocket_server_hostname_get, NULL, _ssl__SSLSocket_server_hostname_DOCSTR},
372 #endif
373
374 static PyObject *
375 _ssl__SSLSocket_server_hostname_get_impl(PySSLSocket *self);
376
377 static PyObject *
378 _ssl__SSLSocket_server_hostname_get(PyObject *self, void *Py_UNUSED(context))
379 {
380 PyObject *return_value = NULL;
381
382 Py_BEGIN_CRITICAL_SECTION(self);
383 return_value = _ssl__SSLSocket_server_hostname_get_impl((PySSLSocket *)self);
384 Py_END_CRITICAL_SECTION();
385
386 return return_value;
387 }
388
389 PyDoc_STRVAR(_ssl__SSLSocket_owner__doc__,
390 "The Python-level owner of this object.\n"
391 "\n"
392 "Passed as \"self\" in servername callback.");
393 #if defined(_ssl__SSLSocket_owner_DOCSTR)
394 # undef _ssl__SSLSocket_owner_DOCSTR
395 #endif
396 #define _ssl__SSLSocket_owner_DOCSTR _ssl__SSLSocket_owner__doc__
397
398 #if !defined(_ssl__SSLSocket_owner_DOCSTR)
399 # define _ssl__SSLSocket_owner_DOCSTR NULL
400 #endif
401 #if defined(_SSL__SSLSOCKET_OWNER_GETSETDEF)
402 # undef _SSL__SSLSOCKET_OWNER_GETSETDEF
403 # define _SSL__SSLSOCKET_OWNER_GETSETDEF {"owner", (getter)_ssl__SSLSocket_owner_get, (setter)_ssl__SSLSocket_owner_set, _ssl__SSLSocket_owner_DOCSTR},
404 #else
405 # define _SSL__SSLSOCKET_OWNER_GETSETDEF {"owner", (getter)_ssl__SSLSocket_owner_get, NULL, _ssl__SSLSocket_owner_DOCSTR},
406 #endif
407
408 static PyObject *
409 _ssl__SSLSocket_owner_get_impl(PySSLSocket *self);
410
411 static PyObject *
412 _ssl__SSLSocket_owner_get(PyObject *self, void *Py_UNUSED(context))
413 {
414 PyObject *return_value = NULL;
415
416 Py_BEGIN_CRITICAL_SECTION(self);
417 return_value = _ssl__SSLSocket_owner_get_impl((PySSLSocket *)self);
418 Py_END_CRITICAL_SECTION();
419
420 return return_value;
421 }
422
423 #if !defined(_ssl__SSLSocket_owner_DOCSTR)
424 # define _ssl__SSLSocket_owner_DOCSTR NULL
425 #endif
426 #if defined(_SSL__SSLSOCKET_OWNER_GETSETDEF)
427 # undef _SSL__SSLSOCKET_OWNER_GETSETDEF
428 # define _SSL__SSLSOCKET_OWNER_GETSETDEF {"owner", (getter)_ssl__SSLSocket_owner_get, (setter)_ssl__SSLSocket_owner_set, _ssl__SSLSocket_owner_DOCSTR},
429 #else
430 # define _SSL__SSLSOCKET_OWNER_GETSETDEF {"owner", NULL, (setter)_ssl__SSLSocket_owner_set, NULL},
431 #endif
432
433 static int
434 _ssl__SSLSocket_owner_set_impl(PySSLSocket *self, PyObject *value);
435
436 static int
437 _ssl__SSLSocket_owner_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
438 {
439 int return_value;
440
441 Py_BEGIN_CRITICAL_SECTION(self);
442 return_value = _ssl__SSLSocket_owner_set_impl((PySSLSocket *)self, value);
443 Py_END_CRITICAL_SECTION();
444
445 return return_value;
446 }
447
448 PyDoc_STRVAR(_ssl__SSLSocket_write__doc__,
449 "write($self, b, /)\n"
450 "--\n"
451 "\n"
452 "Writes the bytes-like object b into the SSL object.\n"
453 "\n"
454 "Returns the number of bytes written.");
455
456 #define _SSL__SSLSOCKET_WRITE_METHODDEF \
457 {"write", (PyCFunction)_ssl__SSLSocket_write, METH_O, _ssl__SSLSocket_write__doc__},
458
459 static PyObject *
460 _ssl__SSLSocket_write_impl(PySSLSocket *self, Py_buffer *b);
461
462 static PyObject *
463 _ssl__SSLSocket_write(PyObject *self, PyObject *arg)
464 {
465 PyObject *return_value = NULL;
466 Py_buffer b = {NULL, NULL};
467
468 if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
469 goto exit;
470 }
471 Py_BEGIN_CRITICAL_SECTION(self);
472 return_value = _ssl__SSLSocket_write_impl((PySSLSocket *)self, &b);
473 Py_END_CRITICAL_SECTION();
474
475 exit:
476 /* Cleanup for b */
477 if (b.obj) {
478 PyBuffer_Release(&b);
479 }
480
481 return return_value;
482 }
483
484 PyDoc_STRVAR(_ssl__SSLSocket_pending__doc__,
485 "pending($self, /)\n"
486 "--\n"
487 "\n"
488 "Returns the number of already decrypted bytes available for read, pending on the connection.");
489
490 #define _SSL__SSLSOCKET_PENDING_METHODDEF \
491 {"pending", (PyCFunction)_ssl__SSLSocket_pending, METH_NOARGS, _ssl__SSLSocket_pending__doc__},
492
493 static PyObject *
494 _ssl__SSLSocket_pending_impl(PySSLSocket *self);
495
496 static PyObject *
497 _ssl__SSLSocket_pending(PyObject *self, PyObject *Py_UNUSED(ignored))
498 {
499 PyObject *return_value = NULL;
500
501 Py_BEGIN_CRITICAL_SECTION(self);
502 return_value = _ssl__SSLSocket_pending_impl((PySSLSocket *)self);
503 Py_END_CRITICAL_SECTION();
504
505 return return_value;
506 }
507
508 PyDoc_STRVAR(_ssl__SSLSocket_read__doc__,
509 "read(size, [buffer])\n"
510 "Read up to size bytes from the SSL socket.");
511
512 #define _SSL__SSLSOCKET_READ_METHODDEF \
513 {"read", (PyCFunction)_ssl__SSLSocket_read, METH_VARARGS, _ssl__SSLSocket_read__doc__},
514
515 static PyObject *
516 _ssl__SSLSocket_read_impl(PySSLSocket *self, Py_ssize_t len,
517 int group_right_1, Py_buffer *buffer);
518
519 static PyObject *
520 _ssl__SSLSocket_read(PyObject *self, PyObject *args)
521 {
522 PyObject *return_value = NULL;
523 Py_ssize_t len;
524 int group_right_1 = 0;
525 Py_buffer buffer = {NULL, NULL};
526
527 switch (PyTuple_GET_SIZE(args)) {
528 case 1:
529 if (!PyArg_ParseTuple(args, "n:read", &len)) {
530 goto exit;
531 }
532 break;
533 case 2:
534 if (!PyArg_ParseTuple(args, "nw*:read", &len, &buffer)) {
535 goto exit;
536 }
537 group_right_1 = 1;
538 break;
539 default:
540 PyErr_SetString(PyExc_TypeError, "_ssl._SSLSocket.read requires 1 to 2 arguments");
541 goto exit;
542 }
543 Py_BEGIN_CRITICAL_SECTION(self);
544 return_value = _ssl__SSLSocket_read_impl((PySSLSocket *)self, len, group_right_1, &buffer);
545 Py_END_CRITICAL_SECTION();
546
547 exit:
548 /* Cleanup for buffer */
549 if (buffer.obj) {
550 PyBuffer_Release(&buffer);
551 }
552
553 return return_value;
554 }
555
556 PyDoc_STRVAR(_ssl__SSLSocket_shutdown__doc__,
557 "shutdown($self, /)\n"
558 "--\n"
559 "\n"
560 "Does the SSL shutdown handshake with the remote end.");
561
562 #define _SSL__SSLSOCKET_SHUTDOWN_METHODDEF \
563 {"shutdown", (PyCFunction)_ssl__SSLSocket_shutdown, METH_NOARGS, _ssl__SSLSocket_shutdown__doc__},
564
565 static PyObject *
566 _ssl__SSLSocket_shutdown_impl(PySSLSocket *self);
567
568 static PyObject *
569 _ssl__SSLSocket_shutdown(PyObject *self, PyObject *Py_UNUSED(ignored))
570 {
571 PyObject *return_value = NULL;
572
573 Py_BEGIN_CRITICAL_SECTION(self);
574 return_value = _ssl__SSLSocket_shutdown_impl((PySSLSocket *)self);
575 Py_END_CRITICAL_SECTION();
576
577 return return_value;
578 }
579
580 PyDoc_STRVAR(_ssl__SSLSocket_get_channel_binding__doc__,
581 "get_channel_binding($self, /, cb_type=\'tls-unique\')\n"
582 "--\n"
583 "\n"
584 "Get channel binding data for current connection.\n"
585 "\n"
586 "Raise ValueError if the requested `cb_type` is not supported. Return bytes\n"
587 "of the data or None if the data is not available (e.g. before the handshake).\n"
588 "Only \'tls-unique\' channel binding data from RFC 5929 is supported.");
589
590 #define _SSL__SSLSOCKET_GET_CHANNEL_BINDING_METHODDEF \
591 {"get_channel_binding", _PyCFunction_CAST(_ssl__SSLSocket_get_channel_binding), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLSocket_get_channel_binding__doc__},
592
593 static PyObject *
594 _ssl__SSLSocket_get_channel_binding_impl(PySSLSocket *self,
595 const char *cb_type);
596
597 static PyObject *
598 _ssl__SSLSocket_get_channel_binding(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
599 {
600 PyObject *return_value = NULL;
601 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
602
603 #define NUM_KEYWORDS 1
604 static struct {
605 PyGC_Head _this_is_not_used;
606 PyObject_VAR_HEAD
607 Py_hash_t ob_hash;
608 PyObject *ob_item[NUM_KEYWORDS];
609 } _kwtuple = {
610 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
611 .ob_hash = -1,
612 .ob_item = { &_Py_ID(cb_type), },
613 };
614 #undef NUM_KEYWORDS
615 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
616
617 #else // !Py_BUILD_CORE
618 # define KWTUPLE NULL
619 #endif // !Py_BUILD_CORE
620
621 static const char * const _keywords[] = {"cb_type", NULL};
622 static _PyArg_Parser _parser = {
623 .keywords = _keywords,
624 .fname = "get_channel_binding",
625 .kwtuple = KWTUPLE,
626 };
627 #undef KWTUPLE
628 PyObject *argsbuf[1];
629 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
630 const char *cb_type = "tls-unique";
631
632 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
633 /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
634 if (!args) {
635 goto exit;
636 }
637 if (!noptargs) {
638 goto skip_optional_pos;
639 }
640 if (!PyUnicode_Check(args[0])) {
641 _PyArg_BadArgument("get_channel_binding", "argument 'cb_type'", "str", args[0]);
642 goto exit;
643 }
644 Py_ssize_t cb_type_length;
645 cb_type = PyUnicode_AsUTF8AndSize(args[0], &cb_type_length);
646 if (cb_type == NULL) {
647 goto exit;
648 }
649 if (strlen(cb_type) != (size_t)cb_type_length) {
650 PyErr_SetString(PyExc_ValueError, "embedded null character");
651 goto exit;
652 }
653 skip_optional_pos:
654 Py_BEGIN_CRITICAL_SECTION(self);
655 return_value = _ssl__SSLSocket_get_channel_binding_impl((PySSLSocket *)self, cb_type);
656 Py_END_CRITICAL_SECTION();
657
658 exit:
659 return return_value;
660 }
661
662 PyDoc_STRVAR(_ssl__SSLSocket_verify_client_post_handshake__doc__,
663 "verify_client_post_handshake($self, /)\n"
664 "--\n"
665 "\n"
666 "Initiate TLS 1.3 post-handshake authentication");
667
668 #define _SSL__SSLSOCKET_VERIFY_CLIENT_POST_HANDSHAKE_METHODDEF \
669 {"verify_client_post_handshake", (PyCFunction)_ssl__SSLSocket_verify_client_post_handshake, METH_NOARGS, _ssl__SSLSocket_verify_client_post_handshake__doc__},
670
671 static PyObject *
672 _ssl__SSLSocket_verify_client_post_handshake_impl(PySSLSocket *self);
673
674 static PyObject *
675 _ssl__SSLSocket_verify_client_post_handshake(PyObject *self, PyObject *Py_UNUSED(ignored))
676 {
677 PyObject *return_value = NULL;
678
679 Py_BEGIN_CRITICAL_SECTION(self);
680 return_value = _ssl__SSLSocket_verify_client_post_handshake_impl((PySSLSocket *)self);
681 Py_END_CRITICAL_SECTION();
682
683 return return_value;
684 }
685
686 PyDoc_STRVAR(_ssl__SSLSocket_session__doc__,
687 "The underlying SSLSession object.");
688 #if defined(_ssl__SSLSocket_session_DOCSTR)
689 # undef _ssl__SSLSocket_session_DOCSTR
690 #endif
691 #define _ssl__SSLSocket_session_DOCSTR _ssl__SSLSocket_session__doc__
692
693 #if !defined(_ssl__SSLSocket_session_DOCSTR)
694 # define _ssl__SSLSocket_session_DOCSTR NULL
695 #endif
696 #if defined(_SSL__SSLSOCKET_SESSION_GETSETDEF)
697 # undef _SSL__SSLSOCKET_SESSION_GETSETDEF
698 # define _SSL__SSLSOCKET_SESSION_GETSETDEF {"session", (getter)_ssl__SSLSocket_session_get, (setter)_ssl__SSLSocket_session_set, _ssl__SSLSocket_session_DOCSTR},
699 #else
700 # define _SSL__SSLSOCKET_SESSION_GETSETDEF {"session", (getter)_ssl__SSLSocket_session_get, NULL, _ssl__SSLSocket_session_DOCSTR},
701 #endif
702
703 static PyObject *
704 _ssl__SSLSocket_session_get_impl(PySSLSocket *self);
705
706 static PyObject *
707 _ssl__SSLSocket_session_get(PyObject *self, void *Py_UNUSED(context))
708 {
709 PyObject *return_value = NULL;
710
711 Py_BEGIN_CRITICAL_SECTION(self);
712 return_value = _ssl__SSLSocket_session_get_impl((PySSLSocket *)self);
713 Py_END_CRITICAL_SECTION();
714
715 return return_value;
716 }
717
718 #if !defined(_ssl__SSLSocket_session_DOCSTR)
719 # define _ssl__SSLSocket_session_DOCSTR NULL
720 #endif
721 #if defined(_SSL__SSLSOCKET_SESSION_GETSETDEF)
722 # undef _SSL__SSLSOCKET_SESSION_GETSETDEF
723 # define _SSL__SSLSOCKET_SESSION_GETSETDEF {"session", (getter)_ssl__SSLSocket_session_get, (setter)_ssl__SSLSocket_session_set, _ssl__SSLSocket_session_DOCSTR},
724 #else
725 # define _SSL__SSLSOCKET_SESSION_GETSETDEF {"session", NULL, (setter)_ssl__SSLSocket_session_set, NULL},
726 #endif
727
728 static int
729 _ssl__SSLSocket_session_set_impl(PySSLSocket *self, PyObject *value);
730
731 static int
732 _ssl__SSLSocket_session_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
733 {
734 int return_value;
735
736 Py_BEGIN_CRITICAL_SECTION(self);
737 return_value = _ssl__SSLSocket_session_set_impl((PySSLSocket *)self, value);
738 Py_END_CRITICAL_SECTION();
739
740 return return_value;
741 }
742
743 PyDoc_STRVAR(_ssl__SSLSocket_session_reused__doc__,
744 "Was the client session reused during handshake?");
745 #if defined(_ssl__SSLSocket_session_reused_DOCSTR)
746 # undef _ssl__SSLSocket_session_reused_DOCSTR
747 #endif
748 #define _ssl__SSLSocket_session_reused_DOCSTR _ssl__SSLSocket_session_reused__doc__
749
750 #if !defined(_ssl__SSLSocket_session_reused_DOCSTR)
751 # define _ssl__SSLSocket_session_reused_DOCSTR NULL
752 #endif
753 #if defined(_SSL__SSLSOCKET_SESSION_REUSED_GETSETDEF)
754 # undef _SSL__SSLSOCKET_SESSION_REUSED_GETSETDEF
755 # define _SSL__SSLSOCKET_SESSION_REUSED_GETSETDEF {"session_reused", (getter)_ssl__SSLSocket_session_reused_get, (setter)_ssl__SSLSocket_session_reused_set, _ssl__SSLSocket_session_reused_DOCSTR},
756 #else
757 # define _SSL__SSLSOCKET_SESSION_REUSED_GETSETDEF {"session_reused", (getter)_ssl__SSLSocket_session_reused_get, NULL, _ssl__SSLSocket_session_reused_DOCSTR},
758 #endif
759
760 static PyObject *
761 _ssl__SSLSocket_session_reused_get_impl(PySSLSocket *self);
762
763 static PyObject *
764 _ssl__SSLSocket_session_reused_get(PyObject *self, void *Py_UNUSED(context))
765 {
766 PyObject *return_value = NULL;
767
768 Py_BEGIN_CRITICAL_SECTION(self);
769 return_value = _ssl__SSLSocket_session_reused_get_impl((PySSLSocket *)self);
770 Py_END_CRITICAL_SECTION();
771
772 return return_value;
773 }
774
775 static PyObject *
776 _ssl__SSLContext_impl(PyTypeObject *type, int proto_version);
777
778 static PyObject *
779 _ssl__SSLContext(PyTypeObject *type, PyObject *args, PyObject *kwargs)
780 {
781 PyObject *return_value = NULL;
782 PyTypeObject *base_tp = get_state_type(type)->PySSLContext_Type;
783 int proto_version;
784
785 if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
786 !_PyArg_NoKeywords("_SSLContext", kwargs)) {
787 goto exit;
788 }
789 if (!_PyArg_CheckPositional("_SSLContext", PyTuple_GET_SIZE(args), 1, 1)) {
790 goto exit;
791 }
792 proto_version = PyLong_AsInt(PyTuple_GET_ITEM(args, 0));
793 if (proto_version == -1 && PyErr_Occurred()) {
794 goto exit;
795 }
796 Py_BEGIN_CRITICAL_SECTION(type);
797 return_value = _ssl__SSLContext_impl(type, proto_version);
798 Py_END_CRITICAL_SECTION();
799
800 exit:
801 return return_value;
802 }
803
804 PyDoc_STRVAR(_ssl__SSLContext_set_ciphers__doc__,
805 "set_ciphers($self, cipherlist, /)\n"
806 "--\n"
807 "\n");
808
809 #define _SSL__SSLCONTEXT_SET_CIPHERS_METHODDEF \
810 {"set_ciphers", (PyCFunction)_ssl__SSLContext_set_ciphers, METH_O, _ssl__SSLContext_set_ciphers__doc__},
811
812 static PyObject *
813 _ssl__SSLContext_set_ciphers_impl(PySSLContext *self, const char *cipherlist);
814
815 static PyObject *
816 _ssl__SSLContext_set_ciphers(PyObject *self, PyObject *arg)
817 {
818 PyObject *return_value = NULL;
819 const char *cipherlist;
820
821 if (!PyUnicode_Check(arg)) {
822 _PyArg_BadArgument("set_ciphers", "argument", "str", arg);
823 goto exit;
824 }
825 Py_ssize_t cipherlist_length;
826 cipherlist = PyUnicode_AsUTF8AndSize(arg, &cipherlist_length);
827 if (cipherlist == NULL) {
828 goto exit;
829 }
830 if (strlen(cipherlist) != (size_t)cipherlist_length) {
831 PyErr_SetString(PyExc_ValueError, "embedded null character");
832 goto exit;
833 }
834 Py_BEGIN_CRITICAL_SECTION(self);
835 return_value = _ssl__SSLContext_set_ciphers_impl((PySSLContext *)self, cipherlist);
836 Py_END_CRITICAL_SECTION();
837
838 exit:
839 return return_value;
840 }
841
842 PyDoc_STRVAR(_ssl__SSLContext_get_ciphers__doc__,
843 "get_ciphers($self, /)\n"
844 "--\n"
845 "\n");
846
847 #define _SSL__SSLCONTEXT_GET_CIPHERS_METHODDEF \
848 {"get_ciphers", (PyCFunction)_ssl__SSLContext_get_ciphers, METH_NOARGS, _ssl__SSLContext_get_ciphers__doc__},
849
850 static PyObject *
851 _ssl__SSLContext_get_ciphers_impl(PySSLContext *self);
852
853 static PyObject *
854 _ssl__SSLContext_get_ciphers(PyObject *self, PyObject *Py_UNUSED(ignored))
855 {
856 PyObject *return_value = NULL;
857
858 Py_BEGIN_CRITICAL_SECTION(self);
859 return_value = _ssl__SSLContext_get_ciphers_impl((PySSLContext *)self);
860 Py_END_CRITICAL_SECTION();
861
862 return return_value;
863 }
864
865 PyDoc_STRVAR(_ssl__SSLContext__set_alpn_protocols__doc__,
866 "_set_alpn_protocols($self, protos, /)\n"
867 "--\n"
868 "\n");
869
870 #define _SSL__SSLCONTEXT__SET_ALPN_PROTOCOLS_METHODDEF \
871 {"_set_alpn_protocols", (PyCFunction)_ssl__SSLContext__set_alpn_protocols, METH_O, _ssl__SSLContext__set_alpn_protocols__doc__},
872
873 static PyObject *
874 _ssl__SSLContext__set_alpn_protocols_impl(PySSLContext *self,
875 Py_buffer *protos);
876
877 static PyObject *
878 _ssl__SSLContext__set_alpn_protocols(PyObject *self, PyObject *arg)
879 {
880 PyObject *return_value = NULL;
881 Py_buffer protos = {NULL, NULL};
882
883 if (PyObject_GetBuffer(arg, &protos, PyBUF_SIMPLE) != 0) {
884 goto exit;
885 }
886 Py_BEGIN_CRITICAL_SECTION(self);
887 return_value = _ssl__SSLContext__set_alpn_protocols_impl((PySSLContext *)self, &protos);
888 Py_END_CRITICAL_SECTION();
889
890 exit:
891 /* Cleanup for protos */
892 if (protos.obj) {
893 PyBuffer_Release(&protos);
894 }
895
896 return return_value;
897 }
898
899 #if !defined(_ssl__SSLContext_verify_mode_DOCSTR)
900 # define _ssl__SSLContext_verify_mode_DOCSTR NULL
901 #endif
902 #if defined(_SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF)
903 # undef _SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF
904 # define _SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF {"verify_mode", (getter)_ssl__SSLContext_verify_mode_get, (setter)_ssl__SSLContext_verify_mode_set, _ssl__SSLContext_verify_mode_DOCSTR},
905 #else
906 # define _SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF {"verify_mode", (getter)_ssl__SSLContext_verify_mode_get, NULL, _ssl__SSLContext_verify_mode_DOCSTR},
907 #endif
908
909 static PyObject *
910 _ssl__SSLContext_verify_mode_get_impl(PySSLContext *self);
911
912 static PyObject *
913 _ssl__SSLContext_verify_mode_get(PyObject *self, void *Py_UNUSED(context))
914 {
915 PyObject *return_value = NULL;
916
917 Py_BEGIN_CRITICAL_SECTION(self);
918 return_value = _ssl__SSLContext_verify_mode_get_impl((PySSLContext *)self);
919 Py_END_CRITICAL_SECTION();
920
921 return return_value;
922 }
923
924 #if !defined(_ssl__SSLContext_verify_mode_DOCSTR)
925 # define _ssl__SSLContext_verify_mode_DOCSTR NULL
926 #endif
927 #if defined(_SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF)
928 # undef _SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF
929 # define _SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF {"verify_mode", (getter)_ssl__SSLContext_verify_mode_get, (setter)_ssl__SSLContext_verify_mode_set, _ssl__SSLContext_verify_mode_DOCSTR},
930 #else
931 # define _SSL__SSLCONTEXT_VERIFY_MODE_GETSETDEF {"verify_mode", NULL, (setter)_ssl__SSLContext_verify_mode_set, NULL},
932 #endif
933
934 static int
935 _ssl__SSLContext_verify_mode_set_impl(PySSLContext *self, PyObject *value);
936
937 static int
938 _ssl__SSLContext_verify_mode_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
939 {
940 int return_value;
941
942 Py_BEGIN_CRITICAL_SECTION(self);
943 return_value = _ssl__SSLContext_verify_mode_set_impl((PySSLContext *)self, value);
944 Py_END_CRITICAL_SECTION();
945
946 return return_value;
947 }
948
949 #if !defined(_ssl__SSLContext_verify_flags_DOCSTR)
950 # define _ssl__SSLContext_verify_flags_DOCSTR NULL
951 #endif
952 #if defined(_SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF)
953 # undef _SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF
954 # define _SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF {"verify_flags", (getter)_ssl__SSLContext_verify_flags_get, (setter)_ssl__SSLContext_verify_flags_set, _ssl__SSLContext_verify_flags_DOCSTR},
955 #else
956 # define _SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF {"verify_flags", (getter)_ssl__SSLContext_verify_flags_get, NULL, _ssl__SSLContext_verify_flags_DOCSTR},
957 #endif
958
959 static PyObject *
960 _ssl__SSLContext_verify_flags_get_impl(PySSLContext *self);
961
962 static PyObject *
963 _ssl__SSLContext_verify_flags_get(PyObject *self, void *Py_UNUSED(context))
964 {
965 PyObject *return_value = NULL;
966
967 Py_BEGIN_CRITICAL_SECTION(self);
968 return_value = _ssl__SSLContext_verify_flags_get_impl((PySSLContext *)self);
969 Py_END_CRITICAL_SECTION();
970
971 return return_value;
972 }
973
974 #if !defined(_ssl__SSLContext_verify_flags_DOCSTR)
975 # define _ssl__SSLContext_verify_flags_DOCSTR NULL
976 #endif
977 #if defined(_SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF)
978 # undef _SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF
979 # define _SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF {"verify_flags", (getter)_ssl__SSLContext_verify_flags_get, (setter)_ssl__SSLContext_verify_flags_set, _ssl__SSLContext_verify_flags_DOCSTR},
980 #else
981 # define _SSL__SSLCONTEXT_VERIFY_FLAGS_GETSETDEF {"verify_flags", NULL, (setter)_ssl__SSLContext_verify_flags_set, NULL},
982 #endif
983
984 static int
985 _ssl__SSLContext_verify_flags_set_impl(PySSLContext *self, PyObject *value);
986
987 static int
988 _ssl__SSLContext_verify_flags_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
989 {
990 int return_value;
991
992 Py_BEGIN_CRITICAL_SECTION(self);
993 return_value = _ssl__SSLContext_verify_flags_set_impl((PySSLContext *)self, value);
994 Py_END_CRITICAL_SECTION();
995
996 return return_value;
997 }
998
999 #if !defined(_ssl__SSLContext_minimum_version_DOCSTR)
1000 # define _ssl__SSLContext_minimum_version_DOCSTR NULL
1001 #endif
1002 #if defined(_SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF)
1003 # undef _SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF
1004 # define _SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF {"minimum_version", (getter)_ssl__SSLContext_minimum_version_get, (setter)_ssl__SSLContext_minimum_version_set, _ssl__SSLContext_minimum_version_DOCSTR},
1005 #else
1006 # define _SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF {"minimum_version", (getter)_ssl__SSLContext_minimum_version_get, NULL, _ssl__SSLContext_minimum_version_DOCSTR},
1007 #endif
1008
1009 static PyObject *
1010 _ssl__SSLContext_minimum_version_get_impl(PySSLContext *self);
1011
1012 static PyObject *
1013 _ssl__SSLContext_minimum_version_get(PyObject *self, void *Py_UNUSED(context))
1014 {
1015 PyObject *return_value = NULL;
1016
1017 Py_BEGIN_CRITICAL_SECTION(self);
1018 return_value = _ssl__SSLContext_minimum_version_get_impl((PySSLContext *)self);
1019 Py_END_CRITICAL_SECTION();
1020
1021 return return_value;
1022 }
1023
1024 #if !defined(_ssl__SSLContext_minimum_version_DOCSTR)
1025 # define _ssl__SSLContext_minimum_version_DOCSTR NULL
1026 #endif
1027 #if defined(_SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF)
1028 # undef _SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF
1029 # define _SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF {"minimum_version", (getter)_ssl__SSLContext_minimum_version_get, (setter)_ssl__SSLContext_minimum_version_set, _ssl__SSLContext_minimum_version_DOCSTR},
1030 #else
1031 # define _SSL__SSLCONTEXT_MINIMUM_VERSION_GETSETDEF {"minimum_version", NULL, (setter)_ssl__SSLContext_minimum_version_set, NULL},
1032 #endif
1033
1034 static int
1035 _ssl__SSLContext_minimum_version_set_impl(PySSLContext *self,
1036 PyObject *value);
1037
1038 static int
1039 _ssl__SSLContext_minimum_version_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1040 {
1041 int return_value;
1042
1043 Py_BEGIN_CRITICAL_SECTION(self);
1044 return_value = _ssl__SSLContext_minimum_version_set_impl((PySSLContext *)self, value);
1045 Py_END_CRITICAL_SECTION();
1046
1047 return return_value;
1048 }
1049
1050 #if !defined(_ssl__SSLContext_maximum_version_DOCSTR)
1051 # define _ssl__SSLContext_maximum_version_DOCSTR NULL
1052 #endif
1053 #if defined(_SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF)
1054 # undef _SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF
1055 # define _SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF {"maximum_version", (getter)_ssl__SSLContext_maximum_version_get, (setter)_ssl__SSLContext_maximum_version_set, _ssl__SSLContext_maximum_version_DOCSTR},
1056 #else
1057 # define _SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF {"maximum_version", (getter)_ssl__SSLContext_maximum_version_get, NULL, _ssl__SSLContext_maximum_version_DOCSTR},
1058 #endif
1059
1060 static PyObject *
1061 _ssl__SSLContext_maximum_version_get_impl(PySSLContext *self);
1062
1063 static PyObject *
1064 _ssl__SSLContext_maximum_version_get(PyObject *self, void *Py_UNUSED(context))
1065 {
1066 PyObject *return_value = NULL;
1067
1068 Py_BEGIN_CRITICAL_SECTION(self);
1069 return_value = _ssl__SSLContext_maximum_version_get_impl((PySSLContext *)self);
1070 Py_END_CRITICAL_SECTION();
1071
1072 return return_value;
1073 }
1074
1075 #if !defined(_ssl__SSLContext_maximum_version_DOCSTR)
1076 # define _ssl__SSLContext_maximum_version_DOCSTR NULL
1077 #endif
1078 #if defined(_SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF)
1079 # undef _SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF
1080 # define _SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF {"maximum_version", (getter)_ssl__SSLContext_maximum_version_get, (setter)_ssl__SSLContext_maximum_version_set, _ssl__SSLContext_maximum_version_DOCSTR},
1081 #else
1082 # define _SSL__SSLCONTEXT_MAXIMUM_VERSION_GETSETDEF {"maximum_version", NULL, (setter)_ssl__SSLContext_maximum_version_set, NULL},
1083 #endif
1084
1085 static int
1086 _ssl__SSLContext_maximum_version_set_impl(PySSLContext *self,
1087 PyObject *value);
1088
1089 static int
1090 _ssl__SSLContext_maximum_version_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1091 {
1092 int return_value;
1093
1094 Py_BEGIN_CRITICAL_SECTION(self);
1095 return_value = _ssl__SSLContext_maximum_version_set_impl((PySSLContext *)self, value);
1096 Py_END_CRITICAL_SECTION();
1097
1098 return return_value;
1099 }
1100
1101 PyDoc_STRVAR(_ssl__SSLContext_num_tickets__doc__,
1102 "Control the number of TLSv1.3 session tickets.");
1103 #if defined(_ssl__SSLContext_num_tickets_DOCSTR)
1104 # undef _ssl__SSLContext_num_tickets_DOCSTR
1105 #endif
1106 #define _ssl__SSLContext_num_tickets_DOCSTR _ssl__SSLContext_num_tickets__doc__
1107
1108 #if !defined(_ssl__SSLContext_num_tickets_DOCSTR)
1109 # define _ssl__SSLContext_num_tickets_DOCSTR NULL
1110 #endif
1111 #if defined(_SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF)
1112 # undef _SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF
1113 # define _SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF {"num_tickets", (getter)_ssl__SSLContext_num_tickets_get, (setter)_ssl__SSLContext_num_tickets_set, _ssl__SSLContext_num_tickets_DOCSTR},
1114 #else
1115 # define _SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF {"num_tickets", (getter)_ssl__SSLContext_num_tickets_get, NULL, _ssl__SSLContext_num_tickets_DOCSTR},
1116 #endif
1117
1118 static PyObject *
1119 _ssl__SSLContext_num_tickets_get_impl(PySSLContext *self);
1120
1121 static PyObject *
1122 _ssl__SSLContext_num_tickets_get(PyObject *self, void *Py_UNUSED(context))
1123 {
1124 PyObject *return_value = NULL;
1125
1126 Py_BEGIN_CRITICAL_SECTION(self);
1127 return_value = _ssl__SSLContext_num_tickets_get_impl((PySSLContext *)self);
1128 Py_END_CRITICAL_SECTION();
1129
1130 return return_value;
1131 }
1132
1133 #if !defined(_ssl__SSLContext_num_tickets_DOCSTR)
1134 # define _ssl__SSLContext_num_tickets_DOCSTR NULL
1135 #endif
1136 #if defined(_SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF)
1137 # undef _SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF
1138 # define _SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF {"num_tickets", (getter)_ssl__SSLContext_num_tickets_get, (setter)_ssl__SSLContext_num_tickets_set, _ssl__SSLContext_num_tickets_DOCSTR},
1139 #else
1140 # define _SSL__SSLCONTEXT_NUM_TICKETS_GETSETDEF {"num_tickets", NULL, (setter)_ssl__SSLContext_num_tickets_set, NULL},
1141 #endif
1142
1143 static int
1144 _ssl__SSLContext_num_tickets_set_impl(PySSLContext *self, PyObject *value);
1145
1146 static int
1147 _ssl__SSLContext_num_tickets_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1148 {
1149 int return_value;
1150
1151 Py_BEGIN_CRITICAL_SECTION(self);
1152 return_value = _ssl__SSLContext_num_tickets_set_impl((PySSLContext *)self, value);
1153 Py_END_CRITICAL_SECTION();
1154
1155 return return_value;
1156 }
1157
1158 PyDoc_STRVAR(_ssl__SSLContext_security_level__doc__,
1159 "The current security level.");
1160 #if defined(_ssl__SSLContext_security_level_DOCSTR)
1161 # undef _ssl__SSLContext_security_level_DOCSTR
1162 #endif
1163 #define _ssl__SSLContext_security_level_DOCSTR _ssl__SSLContext_security_level__doc__
1164
1165 #if !defined(_ssl__SSLContext_security_level_DOCSTR)
1166 # define _ssl__SSLContext_security_level_DOCSTR NULL
1167 #endif
1168 #if defined(_SSL__SSLCONTEXT_SECURITY_LEVEL_GETSETDEF)
1169 # undef _SSL__SSLCONTEXT_SECURITY_LEVEL_GETSETDEF
1170 # define _SSL__SSLCONTEXT_SECURITY_LEVEL_GETSETDEF {"security_level", (getter)_ssl__SSLContext_security_level_get, (setter)_ssl__SSLContext_security_level_set, _ssl__SSLContext_security_level_DOCSTR},
1171 #else
1172 # define _SSL__SSLCONTEXT_SECURITY_LEVEL_GETSETDEF {"security_level", (getter)_ssl__SSLContext_security_level_get, NULL, _ssl__SSLContext_security_level_DOCSTR},
1173 #endif
1174
1175 static PyObject *
1176 _ssl__SSLContext_security_level_get_impl(PySSLContext *self);
1177
1178 static PyObject *
1179 _ssl__SSLContext_security_level_get(PyObject *self, void *Py_UNUSED(context))
1180 {
1181 PyObject *return_value = NULL;
1182
1183 Py_BEGIN_CRITICAL_SECTION(self);
1184 return_value = _ssl__SSLContext_security_level_get_impl((PySSLContext *)self);
1185 Py_END_CRITICAL_SECTION();
1186
1187 return return_value;
1188 }
1189
1190 #if !defined(_ssl__SSLContext_options_DOCSTR)
1191 # define _ssl__SSLContext_options_DOCSTR NULL
1192 #endif
1193 #if defined(_SSL__SSLCONTEXT_OPTIONS_GETSETDEF)
1194 # undef _SSL__SSLCONTEXT_OPTIONS_GETSETDEF
1195 # define _SSL__SSLCONTEXT_OPTIONS_GETSETDEF {"options", (getter)_ssl__SSLContext_options_get, (setter)_ssl__SSLContext_options_set, _ssl__SSLContext_options_DOCSTR},
1196 #else
1197 # define _SSL__SSLCONTEXT_OPTIONS_GETSETDEF {"options", (getter)_ssl__SSLContext_options_get, NULL, _ssl__SSLContext_options_DOCSTR},
1198 #endif
1199
1200 static PyObject *
1201 _ssl__SSLContext_options_get_impl(PySSLContext *self);
1202
1203 static PyObject *
1204 _ssl__SSLContext_options_get(PyObject *self, void *Py_UNUSED(context))
1205 {
1206 PyObject *return_value = NULL;
1207
1208 Py_BEGIN_CRITICAL_SECTION(self);
1209 return_value = _ssl__SSLContext_options_get_impl((PySSLContext *)self);
1210 Py_END_CRITICAL_SECTION();
1211
1212 return return_value;
1213 }
1214
1215 #if !defined(_ssl__SSLContext_options_DOCSTR)
1216 # define _ssl__SSLContext_options_DOCSTR NULL
1217 #endif
1218 #if defined(_SSL__SSLCONTEXT_OPTIONS_GETSETDEF)
1219 # undef _SSL__SSLCONTEXT_OPTIONS_GETSETDEF
1220 # define _SSL__SSLCONTEXT_OPTIONS_GETSETDEF {"options", (getter)_ssl__SSLContext_options_get, (setter)_ssl__SSLContext_options_set, _ssl__SSLContext_options_DOCSTR},
1221 #else
1222 # define _SSL__SSLCONTEXT_OPTIONS_GETSETDEF {"options", NULL, (setter)_ssl__SSLContext_options_set, NULL},
1223 #endif
1224
1225 static int
1226 _ssl__SSLContext_options_set_impl(PySSLContext *self, PyObject *value);
1227
1228 static int
1229 _ssl__SSLContext_options_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1230 {
1231 int return_value;
1232
1233 Py_BEGIN_CRITICAL_SECTION(self);
1234 return_value = _ssl__SSLContext_options_set_impl((PySSLContext *)self, value);
1235 Py_END_CRITICAL_SECTION();
1236
1237 return return_value;
1238 }
1239
1240 #if !defined(_ssl__SSLContext__host_flags_DOCSTR)
1241 # define _ssl__SSLContext__host_flags_DOCSTR NULL
1242 #endif
1243 #if defined(_SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF)
1244 # undef _SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF
1245 # define _SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF {"_host_flags", (getter)_ssl__SSLContext__host_flags_get, (setter)_ssl__SSLContext__host_flags_set, _ssl__SSLContext__host_flags_DOCSTR},
1246 #else
1247 # define _SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF {"_host_flags", (getter)_ssl__SSLContext__host_flags_get, NULL, _ssl__SSLContext__host_flags_DOCSTR},
1248 #endif
1249
1250 static PyObject *
1251 _ssl__SSLContext__host_flags_get_impl(PySSLContext *self);
1252
1253 static PyObject *
1254 _ssl__SSLContext__host_flags_get(PyObject *self, void *Py_UNUSED(context))
1255 {
1256 PyObject *return_value = NULL;
1257
1258 Py_BEGIN_CRITICAL_SECTION(self);
1259 return_value = _ssl__SSLContext__host_flags_get_impl((PySSLContext *)self);
1260 Py_END_CRITICAL_SECTION();
1261
1262 return return_value;
1263 }
1264
1265 #if !defined(_ssl__SSLContext__host_flags_DOCSTR)
1266 # define _ssl__SSLContext__host_flags_DOCSTR NULL
1267 #endif
1268 #if defined(_SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF)
1269 # undef _SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF
1270 # define _SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF {"_host_flags", (getter)_ssl__SSLContext__host_flags_get, (setter)_ssl__SSLContext__host_flags_set, _ssl__SSLContext__host_flags_DOCSTR},
1271 #else
1272 # define _SSL__SSLCONTEXT__HOST_FLAGS_GETSETDEF {"_host_flags", NULL, (setter)_ssl__SSLContext__host_flags_set, NULL},
1273 #endif
1274
1275 static int
1276 _ssl__SSLContext__host_flags_set_impl(PySSLContext *self, PyObject *value);
1277
1278 static int
1279 _ssl__SSLContext__host_flags_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1280 {
1281 int return_value;
1282
1283 Py_BEGIN_CRITICAL_SECTION(self);
1284 return_value = _ssl__SSLContext__host_flags_set_impl((PySSLContext *)self, value);
1285 Py_END_CRITICAL_SECTION();
1286
1287 return return_value;
1288 }
1289
1290 #if !defined(_ssl__SSLContext_check_hostname_DOCSTR)
1291 # define _ssl__SSLContext_check_hostname_DOCSTR NULL
1292 #endif
1293 #if defined(_SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF)
1294 # undef _SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF
1295 # define _SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF {"check_hostname", (getter)_ssl__SSLContext_check_hostname_get, (setter)_ssl__SSLContext_check_hostname_set, _ssl__SSLContext_check_hostname_DOCSTR},
1296 #else
1297 # define _SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF {"check_hostname", (getter)_ssl__SSLContext_check_hostname_get, NULL, _ssl__SSLContext_check_hostname_DOCSTR},
1298 #endif
1299
1300 static PyObject *
1301 _ssl__SSLContext_check_hostname_get_impl(PySSLContext *self);
1302
1303 static PyObject *
1304 _ssl__SSLContext_check_hostname_get(PyObject *self, void *Py_UNUSED(context))
1305 {
1306 PyObject *return_value = NULL;
1307
1308 Py_BEGIN_CRITICAL_SECTION(self);
1309 return_value = _ssl__SSLContext_check_hostname_get_impl((PySSLContext *)self);
1310 Py_END_CRITICAL_SECTION();
1311
1312 return return_value;
1313 }
1314
1315 #if !defined(_ssl__SSLContext_check_hostname_DOCSTR)
1316 # define _ssl__SSLContext_check_hostname_DOCSTR NULL
1317 #endif
1318 #if defined(_SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF)
1319 # undef _SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF
1320 # define _SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF {"check_hostname", (getter)_ssl__SSLContext_check_hostname_get, (setter)_ssl__SSLContext_check_hostname_set, _ssl__SSLContext_check_hostname_DOCSTR},
1321 #else
1322 # define _SSL__SSLCONTEXT_CHECK_HOSTNAME_GETSETDEF {"check_hostname", NULL, (setter)_ssl__SSLContext_check_hostname_set, NULL},
1323 #endif
1324
1325 static int
1326 _ssl__SSLContext_check_hostname_set_impl(PySSLContext *self, PyObject *value);
1327
1328 static int
1329 _ssl__SSLContext_check_hostname_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1330 {
1331 int return_value;
1332
1333 Py_BEGIN_CRITICAL_SECTION(self);
1334 return_value = _ssl__SSLContext_check_hostname_set_impl((PySSLContext *)self, value);
1335 Py_END_CRITICAL_SECTION();
1336
1337 return return_value;
1338 }
1339
1340 #if !defined(_ssl__SSLContext_protocol_DOCSTR)
1341 # define _ssl__SSLContext_protocol_DOCSTR NULL
1342 #endif
1343 #if defined(_SSL__SSLCONTEXT_PROTOCOL_GETSETDEF)
1344 # undef _SSL__SSLCONTEXT_PROTOCOL_GETSETDEF
1345 # define _SSL__SSLCONTEXT_PROTOCOL_GETSETDEF {"protocol", (getter)_ssl__SSLContext_protocol_get, (setter)_ssl__SSLContext_protocol_set, _ssl__SSLContext_protocol_DOCSTR},
1346 #else
1347 # define _SSL__SSLCONTEXT_PROTOCOL_GETSETDEF {"protocol", (getter)_ssl__SSLContext_protocol_get, NULL, _ssl__SSLContext_protocol_DOCSTR},
1348 #endif
1349
1350 static PyObject *
1351 _ssl__SSLContext_protocol_get_impl(PySSLContext *self);
1352
1353 static PyObject *
1354 _ssl__SSLContext_protocol_get(PyObject *self, void *Py_UNUSED(context))
1355 {
1356 PyObject *return_value = NULL;
1357
1358 Py_BEGIN_CRITICAL_SECTION(self);
1359 return_value = _ssl__SSLContext_protocol_get_impl((PySSLContext *)self);
1360 Py_END_CRITICAL_SECTION();
1361
1362 return return_value;
1363 }
1364
1365 PyDoc_STRVAR(_ssl__SSLContext_load_cert_chain__doc__,
1366 "load_cert_chain($self, /, certfile, keyfile=None, password=None)\n"
1367 "--\n"
1368 "\n");
1369
1370 #define _SSL__SSLCONTEXT_LOAD_CERT_CHAIN_METHODDEF \
1371 {"load_cert_chain", _PyCFunction_CAST(_ssl__SSLContext_load_cert_chain), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_cert_chain__doc__},
1372
1373 static PyObject *
1374 _ssl__SSLContext_load_cert_chain_impl(PySSLContext *self, PyObject *certfile,
1375 PyObject *keyfile, PyObject *password);
1376
1377 static PyObject *
1378 _ssl__SSLContext_load_cert_chain(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1379 {
1380 PyObject *return_value = NULL;
1381 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
1382
1383 #define NUM_KEYWORDS 3
1384 static struct {
1385 PyGC_Head _this_is_not_used;
1386 PyObject_VAR_HEAD
1387 Py_hash_t ob_hash;
1388 PyObject *ob_item[NUM_KEYWORDS];
1389 } _kwtuple = {
1390 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
1391 .ob_hash = -1,
1392 .ob_item = { &_Py_ID(certfile), &_Py_ID(keyfile), &_Py_ID(password), },
1393 };
1394 #undef NUM_KEYWORDS
1395 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
1396
1397 #else // !Py_BUILD_CORE
1398 # define KWTUPLE NULL
1399 #endif // !Py_BUILD_CORE
1400
1401 static const char * const _keywords[] = {"certfile", "keyfile", "password", NULL};
1402 static _PyArg_Parser _parser = {
1403 .keywords = _keywords,
1404 .fname = "load_cert_chain",
1405 .kwtuple = KWTUPLE,
1406 };
1407 #undef KWTUPLE
1408 PyObject *argsbuf[3];
1409 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1410 PyObject *certfile;
1411 PyObject *keyfile = Py_None;
1412 PyObject *password = Py_None;
1413
1414 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
1415 /*minpos*/ 1, /*maxpos*/ 3, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
1416 if (!args) {
1417 goto exit;
1418 }
1419 certfile = args[0];
1420 if (!noptargs) {
1421 goto skip_optional_pos;
1422 }
1423 if (args[1]) {
1424 keyfile = args[1];
1425 if (!--noptargs) {
1426 goto skip_optional_pos;
1427 }
1428 }
1429 password = args[2];
1430 skip_optional_pos:
1431 Py_BEGIN_CRITICAL_SECTION(self);
1432 return_value = _ssl__SSLContext_load_cert_chain_impl((PySSLContext *)self, certfile, keyfile, password);
1433 Py_END_CRITICAL_SECTION();
1434
1435 exit:
1436 return return_value;
1437 }
1438
1439 PyDoc_STRVAR(_ssl__SSLContext_load_verify_locations__doc__,
1440 "load_verify_locations($self, /, cafile=None, capath=None, cadata=None)\n"
1441 "--\n"
1442 "\n");
1443
1444 #define _SSL__SSLCONTEXT_LOAD_VERIFY_LOCATIONS_METHODDEF \
1445 {"load_verify_locations", _PyCFunction_CAST(_ssl__SSLContext_load_verify_locations), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_load_verify_locations__doc__},
1446
1447 static PyObject *
1448 _ssl__SSLContext_load_verify_locations_impl(PySSLContext *self,
1449 PyObject *cafile,
1450 PyObject *capath,
1451 PyObject *cadata);
1452
1453 static PyObject *
1454 _ssl__SSLContext_load_verify_locations(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1455 {
1456 PyObject *return_value = NULL;
1457 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
1458
1459 #define NUM_KEYWORDS 3
1460 static struct {
1461 PyGC_Head _this_is_not_used;
1462 PyObject_VAR_HEAD
1463 Py_hash_t ob_hash;
1464 PyObject *ob_item[NUM_KEYWORDS];
1465 } _kwtuple = {
1466 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
1467 .ob_hash = -1,
1468 .ob_item = { &_Py_ID(cafile), &_Py_ID(capath), &_Py_ID(cadata), },
1469 };
1470 #undef NUM_KEYWORDS
1471 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
1472
1473 #else // !Py_BUILD_CORE
1474 # define KWTUPLE NULL
1475 #endif // !Py_BUILD_CORE
1476
1477 static const char * const _keywords[] = {"cafile", "capath", "cadata", NULL};
1478 static _PyArg_Parser _parser = {
1479 .keywords = _keywords,
1480 .fname = "load_verify_locations",
1481 .kwtuple = KWTUPLE,
1482 };
1483 #undef KWTUPLE
1484 PyObject *argsbuf[3];
1485 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
1486 PyObject *cafile = Py_None;
1487 PyObject *capath = Py_None;
1488 PyObject *cadata = Py_None;
1489
1490 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
1491 /*minpos*/ 0, /*maxpos*/ 3, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
1492 if (!args) {
1493 goto exit;
1494 }
1495 if (!noptargs) {
1496 goto skip_optional_pos;
1497 }
1498 if (args[0]) {
1499 cafile = args[0];
1500 if (!--noptargs) {
1501 goto skip_optional_pos;
1502 }
1503 }
1504 if (args[1]) {
1505 capath = args[1];
1506 if (!--noptargs) {
1507 goto skip_optional_pos;
1508 }
1509 }
1510 cadata = args[2];
1511 skip_optional_pos:
1512 Py_BEGIN_CRITICAL_SECTION(self);
1513 return_value = _ssl__SSLContext_load_verify_locations_impl((PySSLContext *)self, cafile, capath, cadata);
1514 Py_END_CRITICAL_SECTION();
1515
1516 exit:
1517 return return_value;
1518 }
1519
1520 PyDoc_STRVAR(_ssl__SSLContext_load_dh_params__doc__,
1521 "load_dh_params($self, path, /)\n"
1522 "--\n"
1523 "\n");
1524
1525 #define _SSL__SSLCONTEXT_LOAD_DH_PARAMS_METHODDEF \
1526 {"load_dh_params", (PyCFunction)_ssl__SSLContext_load_dh_params, METH_O, _ssl__SSLContext_load_dh_params__doc__},
1527
1528 static PyObject *
1529 _ssl__SSLContext_load_dh_params_impl(PySSLContext *self, PyObject *filepath);
1530
1531 static PyObject *
1532 _ssl__SSLContext_load_dh_params(PyObject *self, PyObject *filepath)
1533 {
1534 PyObject *return_value = NULL;
1535
1536 Py_BEGIN_CRITICAL_SECTION(self);
1537 return_value = _ssl__SSLContext_load_dh_params_impl((PySSLContext *)self, filepath);
1538 Py_END_CRITICAL_SECTION();
1539
1540 return return_value;
1541 }
1542
1543 PyDoc_STRVAR(_ssl__SSLContext__wrap_socket__doc__,
1544 "_wrap_socket($self, /, sock, server_side, server_hostname=None, *,\n"
1545 " owner=None, session=None)\n"
1546 "--\n"
1547 "\n");
1548
1549 #define _SSL__SSLCONTEXT__WRAP_SOCKET_METHODDEF \
1550 {"_wrap_socket", _PyCFunction_CAST(_ssl__SSLContext__wrap_socket), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_socket__doc__},
1551
1552 static PyObject *
1553 _ssl__SSLContext__wrap_socket_impl(PySSLContext *self, PyObject *sock,
1554 int server_side, PyObject *hostname_obj,
1555 PyObject *owner, PyObject *session);
1556
1557 static PyObject *
1558 _ssl__SSLContext__wrap_socket(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1559 {
1560 PyObject *return_value = NULL;
1561 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
1562
1563 #define NUM_KEYWORDS 5
1564 static struct {
1565 PyGC_Head _this_is_not_used;
1566 PyObject_VAR_HEAD
1567 Py_hash_t ob_hash;
1568 PyObject *ob_item[NUM_KEYWORDS];
1569 } _kwtuple = {
1570 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
1571 .ob_hash = -1,
1572 .ob_item = { &_Py_ID(sock), &_Py_ID(server_side), &_Py_ID(server_hostname), &_Py_ID(owner), &_Py_ID(session), },
1573 };
1574 #undef NUM_KEYWORDS
1575 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
1576
1577 #else // !Py_BUILD_CORE
1578 # define KWTUPLE NULL
1579 #endif // !Py_BUILD_CORE
1580
1581 static const char * const _keywords[] = {"sock", "server_side", "server_hostname", "owner", "session", NULL};
1582 static _PyArg_Parser _parser = {
1583 .keywords = _keywords,
1584 .fname = "_wrap_socket",
1585 .kwtuple = KWTUPLE,
1586 };
1587 #undef KWTUPLE
1588 PyObject *argsbuf[5];
1589 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 2;
1590 PyObject *sock;
1591 int server_side;
1592 PyObject *hostname_obj = Py_None;
1593 PyObject *owner = Py_None;
1594 PyObject *session = Py_None;
1595
1596 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
1597 /*minpos*/ 2, /*maxpos*/ 3, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
1598 if (!args) {
1599 goto exit;
1600 }
1601 if (!PyObject_TypeCheck(args[0], get_state_ctx(self)->Sock_Type)) {
1602 _PyArg_BadArgument("_wrap_socket", "argument 'sock'", (get_state_ctx(self)->Sock_Type)->tp_name, args[0]);
1603 goto exit;
1604 }
1605 sock = args[0];
1606 server_side = PyObject_IsTrue(args[1]);
1607 if (server_side < 0) {
1608 goto exit;
1609 }
1610 if (!noptargs) {
1611 goto skip_optional_pos;
1612 }
1613 if (args[2]) {
1614 hostname_obj = args[2];
1615 if (!--noptargs) {
1616 goto skip_optional_pos;
1617 }
1618 }
1619 skip_optional_pos:
1620 if (!noptargs) {
1621 goto skip_optional_kwonly;
1622 }
1623 if (args[3]) {
1624 owner = args[3];
1625 if (!--noptargs) {
1626 goto skip_optional_kwonly;
1627 }
1628 }
1629 session = args[4];
1630 skip_optional_kwonly:
1631 Py_BEGIN_CRITICAL_SECTION(self);
1632 return_value = _ssl__SSLContext__wrap_socket_impl((PySSLContext *)self, sock, server_side, hostname_obj, owner, session);
1633 Py_END_CRITICAL_SECTION();
1634
1635 exit:
1636 return return_value;
1637 }
1638
1639 PyDoc_STRVAR(_ssl__SSLContext__wrap_bio__doc__,
1640 "_wrap_bio($self, /, incoming, outgoing, server_side,\n"
1641 " server_hostname=None, *, owner=None, session=None)\n"
1642 "--\n"
1643 "\n");
1644
1645 #define _SSL__SSLCONTEXT__WRAP_BIO_METHODDEF \
1646 {"_wrap_bio", _PyCFunction_CAST(_ssl__SSLContext__wrap_bio), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext__wrap_bio__doc__},
1647
1648 static PyObject *
1649 _ssl__SSLContext__wrap_bio_impl(PySSLContext *self, PySSLMemoryBIO *incoming,
1650 PySSLMemoryBIO *outgoing, int server_side,
1651 PyObject *hostname_obj, PyObject *owner,
1652 PyObject *session);
1653
1654 static PyObject *
1655 _ssl__SSLContext__wrap_bio(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1656 {
1657 PyObject *return_value = NULL;
1658 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
1659
1660 #define NUM_KEYWORDS 6
1661 static struct {
1662 PyGC_Head _this_is_not_used;
1663 PyObject_VAR_HEAD
1664 Py_hash_t ob_hash;
1665 PyObject *ob_item[NUM_KEYWORDS];
1666 } _kwtuple = {
1667 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
1668 .ob_hash = -1,
1669 .ob_item = { &_Py_ID(incoming), &_Py_ID(outgoing), &_Py_ID(server_side), &_Py_ID(server_hostname), &_Py_ID(owner), &_Py_ID(session), },
1670 };
1671 #undef NUM_KEYWORDS
1672 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
1673
1674 #else // !Py_BUILD_CORE
1675 # define KWTUPLE NULL
1676 #endif // !Py_BUILD_CORE
1677
1678 static const char * const _keywords[] = {"incoming", "outgoing", "server_side", "server_hostname", "owner", "session", NULL};
1679 static _PyArg_Parser _parser = {
1680 .keywords = _keywords,
1681 .fname = "_wrap_bio",
1682 .kwtuple = KWTUPLE,
1683 };
1684 #undef KWTUPLE
1685 PyObject *argsbuf[6];
1686 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 3;
1687 PySSLMemoryBIO *incoming;
1688 PySSLMemoryBIO *outgoing;
1689 int server_side;
1690 PyObject *hostname_obj = Py_None;
1691 PyObject *owner = Py_None;
1692 PyObject *session = Py_None;
1693
1694 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
1695 /*minpos*/ 3, /*maxpos*/ 4, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
1696 if (!args) {
1697 goto exit;
1698 }
1699 if (!PyObject_TypeCheck(args[0], get_state_ctx(self)->PySSLMemoryBIO_Type)) {
1700 _PyArg_BadArgument("_wrap_bio", "argument 'incoming'", (get_state_ctx(self)->PySSLMemoryBIO_Type)->tp_name, args[0]);
1701 goto exit;
1702 }
1703 incoming = (PySSLMemoryBIO *)args[0];
1704 if (!PyObject_TypeCheck(args[1], get_state_ctx(self)->PySSLMemoryBIO_Type)) {
1705 _PyArg_BadArgument("_wrap_bio", "argument 'outgoing'", (get_state_ctx(self)->PySSLMemoryBIO_Type)->tp_name, args[1]);
1706 goto exit;
1707 }
1708 outgoing = (PySSLMemoryBIO *)args[1];
1709 server_side = PyObject_IsTrue(args[2]);
1710 if (server_side < 0) {
1711 goto exit;
1712 }
1713 if (!noptargs) {
1714 goto skip_optional_pos;
1715 }
1716 if (args[3]) {
1717 hostname_obj = args[3];
1718 if (!--noptargs) {
1719 goto skip_optional_pos;
1720 }
1721 }
1722 skip_optional_pos:
1723 if (!noptargs) {
1724 goto skip_optional_kwonly;
1725 }
1726 if (args[4]) {
1727 owner = args[4];
1728 if (!--noptargs) {
1729 goto skip_optional_kwonly;
1730 }
1731 }
1732 session = args[5];
1733 skip_optional_kwonly:
1734 Py_BEGIN_CRITICAL_SECTION(self);
1735 return_value = _ssl__SSLContext__wrap_bio_impl((PySSLContext *)self, incoming, outgoing, server_side, hostname_obj, owner, session);
1736 Py_END_CRITICAL_SECTION();
1737
1738 exit:
1739 return return_value;
1740 }
1741
1742 PyDoc_STRVAR(_ssl__SSLContext_session_stats__doc__,
1743 "session_stats($self, /)\n"
1744 "--\n"
1745 "\n");
1746
1747 #define _SSL__SSLCONTEXT_SESSION_STATS_METHODDEF \
1748 {"session_stats", (PyCFunction)_ssl__SSLContext_session_stats, METH_NOARGS, _ssl__SSLContext_session_stats__doc__},
1749
1750 static PyObject *
1751 _ssl__SSLContext_session_stats_impl(PySSLContext *self);
1752
1753 static PyObject *
1754 _ssl__SSLContext_session_stats(PyObject *self, PyObject *Py_UNUSED(ignored))
1755 {
1756 PyObject *return_value = NULL;
1757
1758 Py_BEGIN_CRITICAL_SECTION(self);
1759 return_value = _ssl__SSLContext_session_stats_impl((PySSLContext *)self);
1760 Py_END_CRITICAL_SECTION();
1761
1762 return return_value;
1763 }
1764
1765 PyDoc_STRVAR(_ssl__SSLContext_set_default_verify_paths__doc__,
1766 "set_default_verify_paths($self, /)\n"
1767 "--\n"
1768 "\n");
1769
1770 #define _SSL__SSLCONTEXT_SET_DEFAULT_VERIFY_PATHS_METHODDEF \
1771 {"set_default_verify_paths", (PyCFunction)_ssl__SSLContext_set_default_verify_paths, METH_NOARGS, _ssl__SSLContext_set_default_verify_paths__doc__},
1772
1773 static PyObject *
1774 _ssl__SSLContext_set_default_verify_paths_impl(PySSLContext *self);
1775
1776 static PyObject *
1777 _ssl__SSLContext_set_default_verify_paths(PyObject *self, PyObject *Py_UNUSED(ignored))
1778 {
1779 PyObject *return_value = NULL;
1780
1781 Py_BEGIN_CRITICAL_SECTION(self);
1782 return_value = _ssl__SSLContext_set_default_verify_paths_impl((PySSLContext *)self);
1783 Py_END_CRITICAL_SECTION();
1784
1785 return return_value;
1786 }
1787
1788 PyDoc_STRVAR(_ssl__SSLContext_set_ecdh_curve__doc__,
1789 "set_ecdh_curve($self, name, /)\n"
1790 "--\n"
1791 "\n");
1792
1793 #define _SSL__SSLCONTEXT_SET_ECDH_CURVE_METHODDEF \
1794 {"set_ecdh_curve", (PyCFunction)_ssl__SSLContext_set_ecdh_curve, METH_O, _ssl__SSLContext_set_ecdh_curve__doc__},
1795
1796 static PyObject *
1797 _ssl__SSLContext_set_ecdh_curve_impl(PySSLContext *self, PyObject *name);
1798
1799 static PyObject *
1800 _ssl__SSLContext_set_ecdh_curve(PyObject *self, PyObject *name)
1801 {
1802 PyObject *return_value = NULL;
1803
1804 Py_BEGIN_CRITICAL_SECTION(self);
1805 return_value = _ssl__SSLContext_set_ecdh_curve_impl((PySSLContext *)self, name);
1806 Py_END_CRITICAL_SECTION();
1807
1808 return return_value;
1809 }
1810
1811 PyDoc_STRVAR(_ssl__SSLContext_sni_callback__doc__,
1812 "Set a callback that will be called when a server name is provided by the SSL/TLS client in the SNI extension.\n"
1813 "\n"
1814 "If the argument is None then the callback is disabled. The method is called\n"
1815 "with the SSLSocket, the server name as a string, and the SSLContext object.\n"
1816 "\n"
1817 "See RFC 6066 for details of the SNI extension.");
1818 #if defined(_ssl__SSLContext_sni_callback_DOCSTR)
1819 # undef _ssl__SSLContext_sni_callback_DOCSTR
1820 #endif
1821 #define _ssl__SSLContext_sni_callback_DOCSTR _ssl__SSLContext_sni_callback__doc__
1822
1823 #if !defined(_ssl__SSLContext_sni_callback_DOCSTR)
1824 # define _ssl__SSLContext_sni_callback_DOCSTR NULL
1825 #endif
1826 #if defined(_SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF)
1827 # undef _SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF
1828 # define _SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF {"sni_callback", (getter)_ssl__SSLContext_sni_callback_get, (setter)_ssl__SSLContext_sni_callback_set, _ssl__SSLContext_sni_callback_DOCSTR},
1829 #else
1830 # define _SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF {"sni_callback", (getter)_ssl__SSLContext_sni_callback_get, NULL, _ssl__SSLContext_sni_callback_DOCSTR},
1831 #endif
1832
1833 static PyObject *
1834 _ssl__SSLContext_sni_callback_get_impl(PySSLContext *self);
1835
1836 static PyObject *
1837 _ssl__SSLContext_sni_callback_get(PyObject *self, void *Py_UNUSED(context))
1838 {
1839 PyObject *return_value = NULL;
1840
1841 Py_BEGIN_CRITICAL_SECTION(self);
1842 return_value = _ssl__SSLContext_sni_callback_get_impl((PySSLContext *)self);
1843 Py_END_CRITICAL_SECTION();
1844
1845 return return_value;
1846 }
1847
1848 #if !defined(_ssl__SSLContext_sni_callback_DOCSTR)
1849 # define _ssl__SSLContext_sni_callback_DOCSTR NULL
1850 #endif
1851 #if defined(_SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF)
1852 # undef _SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF
1853 # define _SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF {"sni_callback", (getter)_ssl__SSLContext_sni_callback_get, (setter)_ssl__SSLContext_sni_callback_set, _ssl__SSLContext_sni_callback_DOCSTR},
1854 #else
1855 # define _SSL__SSLCONTEXT_SNI_CALLBACK_GETSETDEF {"sni_callback", NULL, (setter)_ssl__SSLContext_sni_callback_set, NULL},
1856 #endif
1857
1858 static int
1859 _ssl__SSLContext_sni_callback_set_impl(PySSLContext *self, PyObject *value);
1860
1861 static int
1862 _ssl__SSLContext_sni_callback_set(PyObject *self, PyObject *value, void *Py_UNUSED(context))
1863 {
1864 int return_value;
1865
1866 Py_BEGIN_CRITICAL_SECTION(self);
1867 return_value = _ssl__SSLContext_sni_callback_set_impl((PySSLContext *)self, value);
1868 Py_END_CRITICAL_SECTION();
1869
1870 return return_value;
1871 }
1872
1873 PyDoc_STRVAR(_ssl__SSLContext_cert_store_stats__doc__,
1874 "cert_store_stats($self, /)\n"
1875 "--\n"
1876 "\n"
1877 "Returns quantities of loaded X.509 certificates.\n"
1878 "\n"
1879 "X.509 certificates with a CA extension and certificate revocation lists\n"
1880 "inside the context\'s cert store.\n"
1881 "\n"
1882 "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n"
1883 "been used at least once.");
1884
1885 #define _SSL__SSLCONTEXT_CERT_STORE_STATS_METHODDEF \
1886 {"cert_store_stats", (PyCFunction)_ssl__SSLContext_cert_store_stats, METH_NOARGS, _ssl__SSLContext_cert_store_stats__doc__},
1887
1888 static PyObject *
1889 _ssl__SSLContext_cert_store_stats_impl(PySSLContext *self);
1890
1891 static PyObject *
1892 _ssl__SSLContext_cert_store_stats(PyObject *self, PyObject *Py_UNUSED(ignored))
1893 {
1894 PyObject *return_value = NULL;
1895
1896 Py_BEGIN_CRITICAL_SECTION(self);
1897 return_value = _ssl__SSLContext_cert_store_stats_impl((PySSLContext *)self);
1898 Py_END_CRITICAL_SECTION();
1899
1900 return return_value;
1901 }
1902
1903 PyDoc_STRVAR(_ssl__SSLContext_get_ca_certs__doc__,
1904 "get_ca_certs($self, /, binary_form=False)\n"
1905 "--\n"
1906 "\n"
1907 "Returns a list of dicts with information of loaded CA certs.\n"
1908 "\n"
1909 "If the optional argument is True, returns a DER-encoded copy of the CA\n"
1910 "certificate.\n"
1911 "\n"
1912 "NOTE: Certificates in a capath directory aren\'t loaded unless they have\n"
1913 "been used at least once.");
1914
1915 #define _SSL__SSLCONTEXT_GET_CA_CERTS_METHODDEF \
1916 {"get_ca_certs", _PyCFunction_CAST(_ssl__SSLContext_get_ca_certs), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_get_ca_certs__doc__},
1917
1918 static PyObject *
1919 _ssl__SSLContext_get_ca_certs_impl(PySSLContext *self, int binary_form);
1920
1921 static PyObject *
1922 _ssl__SSLContext_get_ca_certs(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1923 {
1924 PyObject *return_value = NULL;
1925 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
1926
1927 #define NUM_KEYWORDS 1
1928 static struct {
1929 PyGC_Head _this_is_not_used;
1930 PyObject_VAR_HEAD
1931 Py_hash_t ob_hash;
1932 PyObject *ob_item[NUM_KEYWORDS];
1933 } _kwtuple = {
1934 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
1935 .ob_hash = -1,
1936 .ob_item = { &_Py_ID(binary_form), },
1937 };
1938 #undef NUM_KEYWORDS
1939 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
1940
1941 #else // !Py_BUILD_CORE
1942 # define KWTUPLE NULL
1943 #endif // !Py_BUILD_CORE
1944
1945 static const char * const _keywords[] = {"binary_form", NULL};
1946 static _PyArg_Parser _parser = {
1947 .keywords = _keywords,
1948 .fname = "get_ca_certs",
1949 .kwtuple = KWTUPLE,
1950 };
1951 #undef KWTUPLE
1952 PyObject *argsbuf[1];
1953 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
1954 int binary_form = 0;
1955
1956 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
1957 /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
1958 if (!args) {
1959 goto exit;
1960 }
1961 if (!noptargs) {
1962 goto skip_optional_pos;
1963 }
1964 binary_form = PyObject_IsTrue(args[0]);
1965 if (binary_form < 0) {
1966 goto exit;
1967 }
1968 skip_optional_pos:
1969 Py_BEGIN_CRITICAL_SECTION(self);
1970 return_value = _ssl__SSLContext_get_ca_certs_impl((PySSLContext *)self, binary_form);
1971 Py_END_CRITICAL_SECTION();
1972
1973 exit:
1974 return return_value;
1975 }
1976
1977 PyDoc_STRVAR(_ssl__SSLContext_set_psk_client_callback__doc__,
1978 "set_psk_client_callback($self, /, callback)\n"
1979 "--\n"
1980 "\n");
1981
1982 #define _SSL__SSLCONTEXT_SET_PSK_CLIENT_CALLBACK_METHODDEF \
1983 {"set_psk_client_callback", _PyCFunction_CAST(_ssl__SSLContext_set_psk_client_callback), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_set_psk_client_callback__doc__},
1984
1985 static PyObject *
1986 _ssl__SSLContext_set_psk_client_callback_impl(PySSLContext *self,
1987 PyObject *callback);
1988
1989 static PyObject *
1990 _ssl__SSLContext_set_psk_client_callback(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1991 {
1992 PyObject *return_value = NULL;
1993 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
1994
1995 #define NUM_KEYWORDS 1
1996 static struct {
1997 PyGC_Head _this_is_not_used;
1998 PyObject_VAR_HEAD
1999 Py_hash_t ob_hash;
2000 PyObject *ob_item[NUM_KEYWORDS];
2001 } _kwtuple = {
2002 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
2003 .ob_hash = -1,
2004 .ob_item = { &_Py_ID(callback), },
2005 };
2006 #undef NUM_KEYWORDS
2007 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
2008
2009 #else // !Py_BUILD_CORE
2010 # define KWTUPLE NULL
2011 #endif // !Py_BUILD_CORE
2012
2013 static const char * const _keywords[] = {"callback", NULL};
2014 static _PyArg_Parser _parser = {
2015 .keywords = _keywords,
2016 .fname = "set_psk_client_callback",
2017 .kwtuple = KWTUPLE,
2018 };
2019 #undef KWTUPLE
2020 PyObject *argsbuf[1];
2021 PyObject *callback;
2022
2023 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
2024 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
2025 if (!args) {
2026 goto exit;
2027 }
2028 callback = args[0];
2029 Py_BEGIN_CRITICAL_SECTION(self);
2030 return_value = _ssl__SSLContext_set_psk_client_callback_impl((PySSLContext *)self, callback);
2031 Py_END_CRITICAL_SECTION();
2032
2033 exit:
2034 return return_value;
2035 }
2036
2037 PyDoc_STRVAR(_ssl__SSLContext_set_psk_server_callback__doc__,
2038 "set_psk_server_callback($self, /, callback, identity_hint=None)\n"
2039 "--\n"
2040 "\n");
2041
2042 #define _SSL__SSLCONTEXT_SET_PSK_SERVER_CALLBACK_METHODDEF \
2043 {"set_psk_server_callback", _PyCFunction_CAST(_ssl__SSLContext_set_psk_server_callback), METH_FASTCALL|METH_KEYWORDS, _ssl__SSLContext_set_psk_server_callback__doc__},
2044
2045 static PyObject *
2046 _ssl__SSLContext_set_psk_server_callback_impl(PySSLContext *self,
2047 PyObject *callback,
2048 const char *identity_hint);
2049
2050 static PyObject *
2051 _ssl__SSLContext_set_psk_server_callback(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2052 {
2053 PyObject *return_value = NULL;
2054 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
2055
2056 #define NUM_KEYWORDS 2
2057 static struct {
2058 PyGC_Head _this_is_not_used;
2059 PyObject_VAR_HEAD
2060 Py_hash_t ob_hash;
2061 PyObject *ob_item[NUM_KEYWORDS];
2062 } _kwtuple = {
2063 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
2064 .ob_hash = -1,
2065 .ob_item = { &_Py_ID(callback), &_Py_ID(identity_hint), },
2066 };
2067 #undef NUM_KEYWORDS
2068 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
2069
2070 #else // !Py_BUILD_CORE
2071 # define KWTUPLE NULL
2072 #endif // !Py_BUILD_CORE
2073
2074 static const char * const _keywords[] = {"callback", "identity_hint", NULL};
2075 static _PyArg_Parser _parser = {
2076 .keywords = _keywords,
2077 .fname = "set_psk_server_callback",
2078 .kwtuple = KWTUPLE,
2079 };
2080 #undef KWTUPLE
2081 PyObject *argsbuf[2];
2082 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
2083 PyObject *callback;
2084 const char *identity_hint = NULL;
2085
2086 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
2087 /*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
2088 if (!args) {
2089 goto exit;
2090 }
2091 callback = args[0];
2092 if (!noptargs) {
2093 goto skip_optional_pos;
2094 }
2095 if (args[1] == Py_None) {
2096 identity_hint = NULL;
2097 }
2098 else if (PyUnicode_Check(args[1])) {
2099 Py_ssize_t identity_hint_length;
2100 identity_hint = PyUnicode_AsUTF8AndSize(args[1], &identity_hint_length);
2101 if (identity_hint == NULL) {
2102 goto exit;
2103 }
2104 if (strlen(identity_hint) != (size_t)identity_hint_length) {
2105 PyErr_SetString(PyExc_ValueError, "embedded null character");
2106 goto exit;
2107 }
2108 }
2109 else {
2110 _PyArg_BadArgument("set_psk_server_callback", "argument 'identity_hint'", "str or None", args[1]);
2111 goto exit;
2112 }
2113 skip_optional_pos:
2114 Py_BEGIN_CRITICAL_SECTION(self);
2115 return_value = _ssl__SSLContext_set_psk_server_callback_impl((PySSLContext *)self, callback, identity_hint);
2116 Py_END_CRITICAL_SECTION();
2117
2118 exit:
2119 return return_value;
2120 }
2121
2122 static PyObject *
2123 _ssl_MemoryBIO_impl(PyTypeObject *type);
2124
2125 static PyObject *
2126 _ssl_MemoryBIO(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2127 {
2128 PyObject *return_value = NULL;
2129 PyTypeObject *base_tp = get_state_type(type)->PySSLMemoryBIO_Type;
2130
2131 if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
2132 !_PyArg_NoPositional("MemoryBIO", args)) {
2133 goto exit;
2134 }
2135 if ((type == base_tp || type->tp_init == base_tp->tp_init) &&
2136 !_PyArg_NoKeywords("MemoryBIO", kwargs)) {
2137 goto exit;
2138 }
2139 Py_BEGIN_CRITICAL_SECTION(type);
2140 return_value = _ssl_MemoryBIO_impl(type);
2141 Py_END_CRITICAL_SECTION();
2142
2143 exit:
2144 return return_value;
2145 }
2146
2147 PyDoc_STRVAR(_ssl_MemoryBIO_pending__doc__,
2148 "The number of bytes pending in the memory BIO.");
2149 #if defined(_ssl_MemoryBIO_pending_DOCSTR)
2150 # undef _ssl_MemoryBIO_pending_DOCSTR
2151 #endif
2152 #define _ssl_MemoryBIO_pending_DOCSTR _ssl_MemoryBIO_pending__doc__
2153
2154 #if !defined(_ssl_MemoryBIO_pending_DOCSTR)
2155 # define _ssl_MemoryBIO_pending_DOCSTR NULL
2156 #endif
2157 #if defined(_SSL_MEMORYBIO_PENDING_GETSETDEF)
2158 # undef _SSL_MEMORYBIO_PENDING_GETSETDEF
2159 # define _SSL_MEMORYBIO_PENDING_GETSETDEF {"pending", (getter)_ssl_MemoryBIO_pending_get, (setter)_ssl_MemoryBIO_pending_set, _ssl_MemoryBIO_pending_DOCSTR},
2160 #else
2161 # define _SSL_MEMORYBIO_PENDING_GETSETDEF {"pending", (getter)_ssl_MemoryBIO_pending_get, NULL, _ssl_MemoryBIO_pending_DOCSTR},
2162 #endif
2163
2164 static PyObject *
2165 _ssl_MemoryBIO_pending_get_impl(PySSLMemoryBIO *self);
2166
2167 static PyObject *
2168 _ssl_MemoryBIO_pending_get(PyObject *self, void *Py_UNUSED(context))
2169 {
2170 PyObject *return_value = NULL;
2171
2172 Py_BEGIN_CRITICAL_SECTION(self);
2173 return_value = _ssl_MemoryBIO_pending_get_impl((PySSLMemoryBIO *)self);
2174 Py_END_CRITICAL_SECTION();
2175
2176 return return_value;
2177 }
2178
2179 PyDoc_STRVAR(_ssl_MemoryBIO_eof__doc__,
2180 "Whether the memory BIO is at EOF.");
2181 #if defined(_ssl_MemoryBIO_eof_DOCSTR)
2182 # undef _ssl_MemoryBIO_eof_DOCSTR
2183 #endif
2184 #define _ssl_MemoryBIO_eof_DOCSTR _ssl_MemoryBIO_eof__doc__
2185
2186 #if !defined(_ssl_MemoryBIO_eof_DOCSTR)
2187 # define _ssl_MemoryBIO_eof_DOCSTR NULL
2188 #endif
2189 #if defined(_SSL_MEMORYBIO_EOF_GETSETDEF)
2190 # undef _SSL_MEMORYBIO_EOF_GETSETDEF
2191 # define _SSL_MEMORYBIO_EOF_GETSETDEF {"eof", (getter)_ssl_MemoryBIO_eof_get, (setter)_ssl_MemoryBIO_eof_set, _ssl_MemoryBIO_eof_DOCSTR},
2192 #else
2193 # define _SSL_MEMORYBIO_EOF_GETSETDEF {"eof", (getter)_ssl_MemoryBIO_eof_get, NULL, _ssl_MemoryBIO_eof_DOCSTR},
2194 #endif
2195
2196 static PyObject *
2197 _ssl_MemoryBIO_eof_get_impl(PySSLMemoryBIO *self);
2198
2199 static PyObject *
2200 _ssl_MemoryBIO_eof_get(PyObject *self, void *Py_UNUSED(context))
2201 {
2202 PyObject *return_value = NULL;
2203
2204 Py_BEGIN_CRITICAL_SECTION(self);
2205 return_value = _ssl_MemoryBIO_eof_get_impl((PySSLMemoryBIO *)self);
2206 Py_END_CRITICAL_SECTION();
2207
2208 return return_value;
2209 }
2210
2211 PyDoc_STRVAR(_ssl_MemoryBIO_read__doc__,
2212 "read($self, size=-1, /)\n"
2213 "--\n"
2214 "\n"
2215 "Read up to size bytes from the memory BIO.\n"
2216 "\n"
2217 "If size is not specified, read the entire buffer.\n"
2218 "If the return value is an empty bytes instance, this means either\n"
2219 "EOF or that no data is available. Use the \"eof\" property to\n"
2220 "distinguish between the two.");
2221
2222 #define _SSL_MEMORYBIO_READ_METHODDEF \
2223 {"read", _PyCFunction_CAST(_ssl_MemoryBIO_read), METH_FASTCALL, _ssl_MemoryBIO_read__doc__},
2224
2225 static PyObject *
2226 _ssl_MemoryBIO_read_impl(PySSLMemoryBIO *self, int len);
2227
2228 static PyObject *
2229 _ssl_MemoryBIO_read(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
2230 {
2231 PyObject *return_value = NULL;
2232 int len = -1;
2233
2234 if (!_PyArg_CheckPositional("read", nargs, 0, 1)) {
2235 goto exit;
2236 }
2237 if (nargs < 1) {
2238 goto skip_optional;
2239 }
2240 len = PyLong_AsInt(args[0]);
2241 if (len == -1 && PyErr_Occurred()) {
2242 goto exit;
2243 }
2244 skip_optional:
2245 Py_BEGIN_CRITICAL_SECTION(self);
2246 return_value = _ssl_MemoryBIO_read_impl((PySSLMemoryBIO *)self, len);
2247 Py_END_CRITICAL_SECTION();
2248
2249 exit:
2250 return return_value;
2251 }
2252
2253 PyDoc_STRVAR(_ssl_MemoryBIO_write__doc__,
2254 "write($self, b, /)\n"
2255 "--\n"
2256 "\n"
2257 "Writes the bytes b into the memory BIO.\n"
2258 "\n"
2259 "Returns the number of bytes written.");
2260
2261 #define _SSL_MEMORYBIO_WRITE_METHODDEF \
2262 {"write", (PyCFunction)_ssl_MemoryBIO_write, METH_O, _ssl_MemoryBIO_write__doc__},
2263
2264 static PyObject *
2265 _ssl_MemoryBIO_write_impl(PySSLMemoryBIO *self, Py_buffer *b);
2266
2267 static PyObject *
2268 _ssl_MemoryBIO_write(PyObject *self, PyObject *arg)
2269 {
2270 PyObject *return_value = NULL;
2271 Py_buffer b = {NULL, NULL};
2272
2273 if (PyObject_GetBuffer(arg, &b, PyBUF_SIMPLE) != 0) {
2274 goto exit;
2275 }
2276 Py_BEGIN_CRITICAL_SECTION(self);
2277 return_value = _ssl_MemoryBIO_write_impl((PySSLMemoryBIO *)self, &b);
2278 Py_END_CRITICAL_SECTION();
2279
2280 exit:
2281 /* Cleanup for b */
2282 if (b.obj) {
2283 PyBuffer_Release(&b);
2284 }
2285
2286 return return_value;
2287 }
2288
2289 PyDoc_STRVAR(_ssl_MemoryBIO_write_eof__doc__,
2290 "write_eof($self, /)\n"
2291 "--\n"
2292 "\n"
2293 "Write an EOF marker to the memory BIO.\n"
2294 "\n"
2295 "When all data has been read, the \"eof\" property will be True.");
2296
2297 #define _SSL_MEMORYBIO_WRITE_EOF_METHODDEF \
2298 {"write_eof", (PyCFunction)_ssl_MemoryBIO_write_eof, METH_NOARGS, _ssl_MemoryBIO_write_eof__doc__},
2299
2300 static PyObject *
2301 _ssl_MemoryBIO_write_eof_impl(PySSLMemoryBIO *self);
2302
2303 static PyObject *
2304 _ssl_MemoryBIO_write_eof(PyObject *self, PyObject *Py_UNUSED(ignored))
2305 {
2306 PyObject *return_value = NULL;
2307
2308 Py_BEGIN_CRITICAL_SECTION(self);
2309 return_value = _ssl_MemoryBIO_write_eof_impl((PySSLMemoryBIO *)self);
2310 Py_END_CRITICAL_SECTION();
2311
2312 return return_value;
2313 }
2314
2315 PyDoc_STRVAR(_ssl_SSLSession_time__doc__,
2316 "Session creation time (seconds since epoch).");
2317 #if defined(_ssl_SSLSession_time_DOCSTR)
2318 # undef _ssl_SSLSession_time_DOCSTR
2319 #endif
2320 #define _ssl_SSLSession_time_DOCSTR _ssl_SSLSession_time__doc__
2321
2322 #if !defined(_ssl_SSLSession_time_DOCSTR)
2323 # define _ssl_SSLSession_time_DOCSTR NULL
2324 #endif
2325 #if defined(_SSL_SSLSESSION_TIME_GETSETDEF)
2326 # undef _SSL_SSLSESSION_TIME_GETSETDEF
2327 # define _SSL_SSLSESSION_TIME_GETSETDEF {"time", (getter)_ssl_SSLSession_time_get, (setter)_ssl_SSLSession_time_set, _ssl_SSLSession_time_DOCSTR},
2328 #else
2329 # define _SSL_SSLSESSION_TIME_GETSETDEF {"time", (getter)_ssl_SSLSession_time_get, NULL, _ssl_SSLSession_time_DOCSTR},
2330 #endif
2331
2332 static PyObject *
2333 _ssl_SSLSession_time_get_impl(PySSLSession *self);
2334
2335 static PyObject *
2336 _ssl_SSLSession_time_get(PyObject *self, void *Py_UNUSED(context))
2337 {
2338 PyObject *return_value = NULL;
2339
2340 Py_BEGIN_CRITICAL_SECTION(self);
2341 return_value = _ssl_SSLSession_time_get_impl((PySSLSession *)self);
2342 Py_END_CRITICAL_SECTION();
2343
2344 return return_value;
2345 }
2346
2347 PyDoc_STRVAR(_ssl_SSLSession_timeout__doc__,
2348 "Session timeout (delta in seconds).");
2349 #if defined(_ssl_SSLSession_timeout_DOCSTR)
2350 # undef _ssl_SSLSession_timeout_DOCSTR
2351 #endif
2352 #define _ssl_SSLSession_timeout_DOCSTR _ssl_SSLSession_timeout__doc__
2353
2354 #if !defined(_ssl_SSLSession_timeout_DOCSTR)
2355 # define _ssl_SSLSession_timeout_DOCSTR NULL
2356 #endif
2357 #if defined(_SSL_SSLSESSION_TIMEOUT_GETSETDEF)
2358 # undef _SSL_SSLSESSION_TIMEOUT_GETSETDEF
2359 # define _SSL_SSLSESSION_TIMEOUT_GETSETDEF {"timeout", (getter)_ssl_SSLSession_timeout_get, (setter)_ssl_SSLSession_timeout_set, _ssl_SSLSession_timeout_DOCSTR},
2360 #else
2361 # define _SSL_SSLSESSION_TIMEOUT_GETSETDEF {"timeout", (getter)_ssl_SSLSession_timeout_get, NULL, _ssl_SSLSession_timeout_DOCSTR},
2362 #endif
2363
2364 static PyObject *
2365 _ssl_SSLSession_timeout_get_impl(PySSLSession *self);
2366
2367 static PyObject *
2368 _ssl_SSLSession_timeout_get(PyObject *self, void *Py_UNUSED(context))
2369 {
2370 PyObject *return_value = NULL;
2371
2372 Py_BEGIN_CRITICAL_SECTION(self);
2373 return_value = _ssl_SSLSession_timeout_get_impl((PySSLSession *)self);
2374 Py_END_CRITICAL_SECTION();
2375
2376 return return_value;
2377 }
2378
2379 PyDoc_STRVAR(_ssl_SSLSession_ticket_lifetime_hint__doc__,
2380 "Ticket life time hint.");
2381 #if defined(_ssl_SSLSession_ticket_lifetime_hint_DOCSTR)
2382 # undef _ssl_SSLSession_ticket_lifetime_hint_DOCSTR
2383 #endif
2384 #define _ssl_SSLSession_ticket_lifetime_hint_DOCSTR _ssl_SSLSession_ticket_lifetime_hint__doc__
2385
2386 #if !defined(_ssl_SSLSession_ticket_lifetime_hint_DOCSTR)
2387 # define _ssl_SSLSession_ticket_lifetime_hint_DOCSTR NULL
2388 #endif
2389 #if defined(_SSL_SSLSESSION_TICKET_LIFETIME_HINT_GETSETDEF)
2390 # undef _SSL_SSLSESSION_TICKET_LIFETIME_HINT_GETSETDEF
2391 # define _SSL_SSLSESSION_TICKET_LIFETIME_HINT_GETSETDEF {"ticket_lifetime_hint", (getter)_ssl_SSLSession_ticket_lifetime_hint_get, (setter)_ssl_SSLSession_ticket_lifetime_hint_set, _ssl_SSLSession_ticket_lifetime_hint_DOCSTR},
2392 #else
2393 # define _SSL_SSLSESSION_TICKET_LIFETIME_HINT_GETSETDEF {"ticket_lifetime_hint", (getter)_ssl_SSLSession_ticket_lifetime_hint_get, NULL, _ssl_SSLSession_ticket_lifetime_hint_DOCSTR},
2394 #endif
2395
2396 static PyObject *
2397 _ssl_SSLSession_ticket_lifetime_hint_get_impl(PySSLSession *self);
2398
2399 static PyObject *
2400 _ssl_SSLSession_ticket_lifetime_hint_get(PyObject *self, void *Py_UNUSED(context))
2401 {
2402 PyObject *return_value = NULL;
2403
2404 Py_BEGIN_CRITICAL_SECTION(self);
2405 return_value = _ssl_SSLSession_ticket_lifetime_hint_get_impl((PySSLSession *)self);
2406 Py_END_CRITICAL_SECTION();
2407
2408 return return_value;
2409 }
2410
2411 PyDoc_STRVAR(_ssl_SSLSession_id__doc__,
2412 "Session ID.");
2413 #if defined(_ssl_SSLSession_id_DOCSTR)
2414 # undef _ssl_SSLSession_id_DOCSTR
2415 #endif
2416 #define _ssl_SSLSession_id_DOCSTR _ssl_SSLSession_id__doc__
2417
2418 #if !defined(_ssl_SSLSession_id_DOCSTR)
2419 # define _ssl_SSLSession_id_DOCSTR NULL
2420 #endif
2421 #if defined(_SSL_SSLSESSION_ID_GETSETDEF)
2422 # undef _SSL_SSLSESSION_ID_GETSETDEF
2423 # define _SSL_SSLSESSION_ID_GETSETDEF {"id", (getter)_ssl_SSLSession_id_get, (setter)_ssl_SSLSession_id_set, _ssl_SSLSession_id_DOCSTR},
2424 #else
2425 # define _SSL_SSLSESSION_ID_GETSETDEF {"id", (getter)_ssl_SSLSession_id_get, NULL, _ssl_SSLSession_id_DOCSTR},
2426 #endif
2427
2428 static PyObject *
2429 _ssl_SSLSession_id_get_impl(PySSLSession *self);
2430
2431 static PyObject *
2432 _ssl_SSLSession_id_get(PyObject *self, void *Py_UNUSED(context))
2433 {
2434 PyObject *return_value = NULL;
2435
2436 Py_BEGIN_CRITICAL_SECTION(self);
2437 return_value = _ssl_SSLSession_id_get_impl((PySSLSession *)self);
2438 Py_END_CRITICAL_SECTION();
2439
2440 return return_value;
2441 }
2442
2443 PyDoc_STRVAR(_ssl_SSLSession_has_ticket__doc__,
2444 "Does the session contain a ticket?");
2445 #if defined(_ssl_SSLSession_has_ticket_DOCSTR)
2446 # undef _ssl_SSLSession_has_ticket_DOCSTR
2447 #endif
2448 #define _ssl_SSLSession_has_ticket_DOCSTR _ssl_SSLSession_has_ticket__doc__
2449
2450 #if !defined(_ssl_SSLSession_has_ticket_DOCSTR)
2451 # define _ssl_SSLSession_has_ticket_DOCSTR NULL
2452 #endif
2453 #if defined(_SSL_SSLSESSION_HAS_TICKET_GETSETDEF)
2454 # undef _SSL_SSLSESSION_HAS_TICKET_GETSETDEF
2455 # define _SSL_SSLSESSION_HAS_TICKET_GETSETDEF {"has_ticket", (getter)_ssl_SSLSession_has_ticket_get, (setter)_ssl_SSLSession_has_ticket_set, _ssl_SSLSession_has_ticket_DOCSTR},
2456 #else
2457 # define _SSL_SSLSESSION_HAS_TICKET_GETSETDEF {"has_ticket", (getter)_ssl_SSLSession_has_ticket_get, NULL, _ssl_SSLSession_has_ticket_DOCSTR},
2458 #endif
2459
2460 static PyObject *
2461 _ssl_SSLSession_has_ticket_get_impl(PySSLSession *self);
2462
2463 static PyObject *
2464 _ssl_SSLSession_has_ticket_get(PyObject *self, void *Py_UNUSED(context))
2465 {
2466 PyObject *return_value = NULL;
2467
2468 Py_BEGIN_CRITICAL_SECTION(self);
2469 return_value = _ssl_SSLSession_has_ticket_get_impl((PySSLSession *)self);
2470 Py_END_CRITICAL_SECTION();
2471
2472 return return_value;
2473 }
2474
2475 PyDoc_STRVAR(_ssl_RAND_add__doc__,
2476 "RAND_add($module, string, entropy, /)\n"
2477 "--\n"
2478 "\n"
2479 "Mix string into the OpenSSL PRNG state.\n"
2480 "\n"
2481 "entropy (a float) is a lower bound on the entropy contained in\n"
2482 "string. See RFC 4086.");
2483
2484 #define _SSL_RAND_ADD_METHODDEF \
2485 {"RAND_add", _PyCFunction_CAST(_ssl_RAND_add), METH_FASTCALL, _ssl_RAND_add__doc__},
2486
2487 static PyObject *
2488 _ssl_RAND_add_impl(PyObject *module, Py_buffer *view, double entropy);
2489
2490 static PyObject *
2491 _ssl_RAND_add(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
2492 {
2493 PyObject *return_value = NULL;
2494 Py_buffer view = {NULL, NULL};
2495 double entropy;
2496
2497 if (!_PyArg_CheckPositional("RAND_add", nargs, 2, 2)) {
2498 goto exit;
2499 }
2500 if (PyUnicode_Check(args[0])) {
2501 Py_ssize_t len;
2502 const char *ptr = PyUnicode_AsUTF8AndSize(args[0], &len);
2503 if (ptr == NULL) {
2504 goto exit;
2505 }
2506 if (PyBuffer_FillInfo(&view, args[0], (void *)ptr, len, 1, PyBUF_SIMPLE) < 0) {
2507 goto exit;
2508 }
2509 }
2510 else { /* any bytes-like object */
2511 if (PyObject_GetBuffer(args[0], &view, PyBUF_SIMPLE) != 0) {
2512 goto exit;
2513 }
2514 }
2515 if (PyFloat_CheckExact(args[1])) {
2516 entropy = PyFloat_AS_DOUBLE(args[1]);
2517 }
2518 else
2519 {
2520 entropy = PyFloat_AsDouble(args[1]);
2521 if (entropy == -1.0 && PyErr_Occurred()) {
2522 goto exit;
2523 }
2524 }
2525 Py_BEGIN_CRITICAL_SECTION(module);
2526 return_value = _ssl_RAND_add_impl(module, &view, entropy);
2527 Py_END_CRITICAL_SECTION();
2528
2529 exit:
2530 /* Cleanup for view */
2531 if (view.obj) {
2532 PyBuffer_Release(&view);
2533 }
2534
2535 return return_value;
2536 }
2537
2538 PyDoc_STRVAR(_ssl_RAND_bytes__doc__,
2539 "RAND_bytes($module, n, /)\n"
2540 "--\n"
2541 "\n"
2542 "Generate n cryptographically strong pseudo-random bytes.");
2543
2544 #define _SSL_RAND_BYTES_METHODDEF \
2545 {"RAND_bytes", (PyCFunction)_ssl_RAND_bytes, METH_O, _ssl_RAND_bytes__doc__},
2546
2547 static PyObject *
2548 _ssl_RAND_bytes_impl(PyObject *module, int n);
2549
2550 static PyObject *
2551 _ssl_RAND_bytes(PyObject *module, PyObject *arg)
2552 {
2553 PyObject *return_value = NULL;
2554 int n;
2555
2556 n = PyLong_AsInt(arg);
2557 if (n == -1 && PyErr_Occurred()) {
2558 goto exit;
2559 }
2560 Py_BEGIN_CRITICAL_SECTION(module);
2561 return_value = _ssl_RAND_bytes_impl(module, n);
2562 Py_END_CRITICAL_SECTION();
2563
2564 exit:
2565 return return_value;
2566 }
2567
2568 PyDoc_STRVAR(_ssl_RAND_status__doc__,
2569 "RAND_status($module, /)\n"
2570 "--\n"
2571 "\n"
2572 "Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.\n"
2573 "\n"
2574 "It is necessary to seed the PRNG with RAND_add() on some platforms before\n"
2575 "using the ssl() function.");
2576
2577 #define _SSL_RAND_STATUS_METHODDEF \
2578 {"RAND_status", (PyCFunction)_ssl_RAND_status, METH_NOARGS, _ssl_RAND_status__doc__},
2579
2580 static PyObject *
2581 _ssl_RAND_status_impl(PyObject *module);
2582
2583 static PyObject *
2584 _ssl_RAND_status(PyObject *module, PyObject *Py_UNUSED(ignored))
2585 {
2586 PyObject *return_value = NULL;
2587
2588 Py_BEGIN_CRITICAL_SECTION(module);
2589 return_value = _ssl_RAND_status_impl(module);
2590 Py_END_CRITICAL_SECTION();
2591
2592 return return_value;
2593 }
2594
2595 PyDoc_STRVAR(_ssl_get_default_verify_paths__doc__,
2596 "get_default_verify_paths($module, /)\n"
2597 "--\n"
2598 "\n"
2599 "Return search paths and environment vars that are used by SSLContext\'s set_default_verify_paths() to load default CAs.\n"
2600 "\n"
2601 "The values are \'cert_file_env\', \'cert_file\', \'cert_dir_env\', \'cert_dir\'.");
2602
2603 #define _SSL_GET_DEFAULT_VERIFY_PATHS_METHODDEF \
2604 {"get_default_verify_paths", (PyCFunction)_ssl_get_default_verify_paths, METH_NOARGS, _ssl_get_default_verify_paths__doc__},
2605
2606 static PyObject *
2607 _ssl_get_default_verify_paths_impl(PyObject *module);
2608
2609 static PyObject *
2610 _ssl_get_default_verify_paths(PyObject *module, PyObject *Py_UNUSED(ignored))
2611 {
2612 PyObject *return_value = NULL;
2613
2614 Py_BEGIN_CRITICAL_SECTION(module);
2615 return_value = _ssl_get_default_verify_paths_impl(module);
2616 Py_END_CRITICAL_SECTION();
2617
2618 return return_value;
2619 }
2620
2621 PyDoc_STRVAR(_ssl_txt2obj__doc__,
2622 "txt2obj($module, /, txt, name=False)\n"
2623 "--\n"
2624 "\n"
2625 "Lookup NID, short name, long name and OID of an ASN1_OBJECT.\n"
2626 "\n"
2627 "By default objects are looked up by OID. With name=True short and\n"
2628 "long name are also matched.");
2629
2630 #define _SSL_TXT2OBJ_METHODDEF \
2631 {"txt2obj", _PyCFunction_CAST(_ssl_txt2obj), METH_FASTCALL|METH_KEYWORDS, _ssl_txt2obj__doc__},
2632
2633 static PyObject *
2634 _ssl_txt2obj_impl(PyObject *module, const char *txt, int name);
2635
2636 static PyObject *
2637 _ssl_txt2obj(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2638 {
2639 PyObject *return_value = NULL;
2640 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
2641
2642 #define NUM_KEYWORDS 2
2643 static struct {
2644 PyGC_Head _this_is_not_used;
2645 PyObject_VAR_HEAD
2646 Py_hash_t ob_hash;
2647 PyObject *ob_item[NUM_KEYWORDS];
2648 } _kwtuple = {
2649 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
2650 .ob_hash = -1,
2651 .ob_item = { &_Py_ID(txt), &_Py_ID(name), },
2652 };
2653 #undef NUM_KEYWORDS
2654 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
2655
2656 #else // !Py_BUILD_CORE
2657 # define KWTUPLE NULL
2658 #endif // !Py_BUILD_CORE
2659
2660 static const char * const _keywords[] = {"txt", "name", NULL};
2661 static _PyArg_Parser _parser = {
2662 .keywords = _keywords,
2663 .fname = "txt2obj",
2664 .kwtuple = KWTUPLE,
2665 };
2666 #undef KWTUPLE
2667 PyObject *argsbuf[2];
2668 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
2669 const char *txt;
2670 int name = 0;
2671
2672 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
2673 /*minpos*/ 1, /*maxpos*/ 2, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
2674 if (!args) {
2675 goto exit;
2676 }
2677 if (!PyUnicode_Check(args[0])) {
2678 _PyArg_BadArgument("txt2obj", "argument 'txt'", "str", args[0]);
2679 goto exit;
2680 }
2681 Py_ssize_t txt_length;
2682 txt = PyUnicode_AsUTF8AndSize(args[0], &txt_length);
2683 if (txt == NULL) {
2684 goto exit;
2685 }
2686 if (strlen(txt) != (size_t)txt_length) {
2687 PyErr_SetString(PyExc_ValueError, "embedded null character");
2688 goto exit;
2689 }
2690 if (!noptargs) {
2691 goto skip_optional_pos;
2692 }
2693 name = PyObject_IsTrue(args[1]);
2694 if (name < 0) {
2695 goto exit;
2696 }
2697 skip_optional_pos:
2698 Py_BEGIN_CRITICAL_SECTION(module);
2699 return_value = _ssl_txt2obj_impl(module, txt, name);
2700 Py_END_CRITICAL_SECTION();
2701
2702 exit:
2703 return return_value;
2704 }
2705
2706 PyDoc_STRVAR(_ssl_nid2obj__doc__,
2707 "nid2obj($module, nid, /)\n"
2708 "--\n"
2709 "\n"
2710 "Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.");
2711
2712 #define _SSL_NID2OBJ_METHODDEF \
2713 {"nid2obj", (PyCFunction)_ssl_nid2obj, METH_O, _ssl_nid2obj__doc__},
2714
2715 static PyObject *
2716 _ssl_nid2obj_impl(PyObject *module, int nid);
2717
2718 static PyObject *
2719 _ssl_nid2obj(PyObject *module, PyObject *arg)
2720 {
2721 PyObject *return_value = NULL;
2722 int nid;
2723
2724 nid = PyLong_AsInt(arg);
2725 if (nid == -1 && PyErr_Occurred()) {
2726 goto exit;
2727 }
2728 Py_BEGIN_CRITICAL_SECTION(module);
2729 return_value = _ssl_nid2obj_impl(module, nid);
2730 Py_END_CRITICAL_SECTION();
2731
2732 exit:
2733 return return_value;
2734 }
2735
2736 #if defined(_MSC_VER)
2737
2738 PyDoc_STRVAR(_ssl_enum_certificates__doc__,
2739 "enum_certificates($module, /, store_name)\n"
2740 "--\n"
2741 "\n"
2742 "Retrieve certificates from Windows\' cert store.\n"
2743 "\n"
2744 "store_name may be one of \'CA\', \'ROOT\' or \'MY\'. The system may provide\n"
2745 "more cert storages, too. The function returns a list of (bytes,\n"
2746 "encoding_type, trust) tuples. The encoding_type flag can be interpreted\n"
2747 "with X509_ASN_ENCODING or PKCS_7_ASN_ENCODING. The trust setting is either\n"
2748 "a set of OIDs or the boolean True.");
2749
2750 #define _SSL_ENUM_CERTIFICATES_METHODDEF \
2751 {"enum_certificates", _PyCFunction_CAST(_ssl_enum_certificates), METH_FASTCALL|METH_KEYWORDS, _ssl_enum_certificates__doc__},
2752
2753 static PyObject *
2754 _ssl_enum_certificates_impl(PyObject *module, const char *store_name);
2755
2756 static PyObject *
2757 _ssl_enum_certificates(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2758 {
2759 PyObject *return_value = NULL;
2760 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
2761
2762 #define NUM_KEYWORDS 1
2763 static struct {
2764 PyGC_Head _this_is_not_used;
2765 PyObject_VAR_HEAD
2766 Py_hash_t ob_hash;
2767 PyObject *ob_item[NUM_KEYWORDS];
2768 } _kwtuple = {
2769 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
2770 .ob_hash = -1,
2771 .ob_item = { &_Py_ID(store_name), },
2772 };
2773 #undef NUM_KEYWORDS
2774 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
2775
2776 #else // !Py_BUILD_CORE
2777 # define KWTUPLE NULL
2778 #endif // !Py_BUILD_CORE
2779
2780 static const char * const _keywords[] = {"store_name", NULL};
2781 static _PyArg_Parser _parser = {
2782 .keywords = _keywords,
2783 .fname = "enum_certificates",
2784 .kwtuple = KWTUPLE,
2785 };
2786 #undef KWTUPLE
2787 PyObject *argsbuf[1];
2788 const char *store_name;
2789
2790 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
2791 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
2792 if (!args) {
2793 goto exit;
2794 }
2795 if (!PyUnicode_Check(args[0])) {
2796 _PyArg_BadArgument("enum_certificates", "argument 'store_name'", "str", args[0]);
2797 goto exit;
2798 }
2799 Py_ssize_t store_name_length;
2800 store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length);
2801 if (store_name == NULL) {
2802 goto exit;
2803 }
2804 if (strlen(store_name) != (size_t)store_name_length) {
2805 PyErr_SetString(PyExc_ValueError, "embedded null character");
2806 goto exit;
2807 }
2808 Py_BEGIN_CRITICAL_SECTION(module);
2809 return_value = _ssl_enum_certificates_impl(module, store_name);
2810 Py_END_CRITICAL_SECTION();
2811
2812 exit:
2813 return return_value;
2814 }
2815
2816 #endif /* defined(_MSC_VER) */
2817
2818 #if defined(_MSC_VER)
2819
2820 PyDoc_STRVAR(_ssl_enum_crls__doc__,
2821 "enum_crls($module, /, store_name)\n"
2822 "--\n"
2823 "\n"
2824 "Retrieve CRLs from Windows\' cert store.\n"
2825 "\n"
2826 "store_name may be one of \'CA\', \'ROOT\' or \'MY\'. The system may provide\n"
2827 "more cert storages, too. The function returns a list of (bytes,\n"
2828 "encoding_type) tuples. The encoding_type flag can be interpreted with\n"
2829 "X509_ASN_ENCODING or PKCS_7_ASN_ENCODING.");
2830
2831 #define _SSL_ENUM_CRLS_METHODDEF \
2832 {"enum_crls", _PyCFunction_CAST(_ssl_enum_crls), METH_FASTCALL|METH_KEYWORDS, _ssl_enum_crls__doc__},
2833
2834 static PyObject *
2835 _ssl_enum_crls_impl(PyObject *module, const char *store_name);
2836
2837 static PyObject *
2838 _ssl_enum_crls(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
2839 {
2840 PyObject *return_value = NULL;
2841 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
2842
2843 #define NUM_KEYWORDS 1
2844 static struct {
2845 PyGC_Head _this_is_not_used;
2846 PyObject_VAR_HEAD
2847 Py_hash_t ob_hash;
2848 PyObject *ob_item[NUM_KEYWORDS];
2849 } _kwtuple = {
2850 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
2851 .ob_hash = -1,
2852 .ob_item = { &_Py_ID(store_name), },
2853 };
2854 #undef NUM_KEYWORDS
2855 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
2856
2857 #else // !Py_BUILD_CORE
2858 # define KWTUPLE NULL
2859 #endif // !Py_BUILD_CORE
2860
2861 static const char * const _keywords[] = {"store_name", NULL};
2862 static _PyArg_Parser _parser = {
2863 .keywords = _keywords,
2864 .fname = "enum_crls",
2865 .kwtuple = KWTUPLE,
2866 };
2867 #undef KWTUPLE
2868 PyObject *argsbuf[1];
2869 const char *store_name;
2870
2871 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser,
2872 /*minpos*/ 1, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
2873 if (!args) {
2874 goto exit;
2875 }
2876 if (!PyUnicode_Check(args[0])) {
2877 _PyArg_BadArgument("enum_crls", "argument 'store_name'", "str", args[0]);
2878 goto exit;
2879 }
2880 Py_ssize_t store_name_length;
2881 store_name = PyUnicode_AsUTF8AndSize(args[0], &store_name_length);
2882 if (store_name == NULL) {
2883 goto exit;
2884 }
2885 if (strlen(store_name) != (size_t)store_name_length) {
2886 PyErr_SetString(PyExc_ValueError, "embedded null character");
2887 goto exit;
2888 }
2889 Py_BEGIN_CRITICAL_SECTION(module);
2890 return_value = _ssl_enum_crls_impl(module, store_name);
2891 Py_END_CRITICAL_SECTION();
2892
2893 exit:
2894 return return_value;
2895 }
2896
2897 #endif /* defined(_MSC_VER) */
2898
2899 #ifndef _SSL_ENUM_CERTIFICATES_METHODDEF
2900 #define _SSL_ENUM_CERTIFICATES_METHODDEF
2901 #endif /* !defined(_SSL_ENUM_CERTIFICATES_METHODDEF) */
2902
2903 #ifndef _SSL_ENUM_CRLS_METHODDEF
2904 #define _SSL_ENUM_CRLS_METHODDEF
2905 #endif /* !defined(_SSL_ENUM_CRLS_METHODDEF) */
2906 /*[clinic end generated code: output=cbd8526cd625c433 input=a9049054013a1b77]*/