Debian Codegraph @

Modules/clinic/overlapped.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_long.h" // _PyLong_UnsignedLong_Converter()
10 #include "pycore_modsupport.h" // _PyArg_CheckPositional()
11
12 PyDoc_STRVAR(_overlapped_CreateIoCompletionPort__doc__,
13 "CreateIoCompletionPort($module, handle, port, key, concurrency, /)\n"
14 "--\n"
15 "\n"
16 "Create a completion port or register a handle with a port.");
17
18 #define _OVERLAPPED_CREATEIOCOMPLETIONPORT_METHODDEF \
19 {"CreateIoCompletionPort", _PyCFunction_CAST(_overlapped_CreateIoCompletionPort), METH_FASTCALL, _overlapped_CreateIoCompletionPort__doc__},
20
21 static PyObject *
22 _overlapped_CreateIoCompletionPort_impl(PyObject *module, HANDLE FileHandle,
23 HANDLE ExistingCompletionPort,
24 ULONG_PTR CompletionKey,
25 DWORD NumberOfConcurrentThreads);
26
27 static PyObject *
28 _overlapped_CreateIoCompletionPort(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
29 {
30 PyObject *return_value = NULL;
31 HANDLE FileHandle;
32 HANDLE ExistingCompletionPort;
33 ULONG_PTR CompletionKey;
34 DWORD NumberOfConcurrentThreads;
35
36 if (!_PyArg_CheckPositional("CreateIoCompletionPort", nargs, 4, 4)) {
37 goto exit;
38 }
39 FileHandle = PyLong_AsVoidPtr(args[0]);
40 if (!FileHandle && PyErr_Occurred()) {
41 goto exit;
42 }
43 ExistingCompletionPort = PyLong_AsVoidPtr(args[1]);
44 if (!ExistingCompletionPort && PyErr_Occurred()) {
45 goto exit;
46 }
47 CompletionKey = (uintptr_t)PyLong_AsVoidPtr(args[2]);
48 if (!CompletionKey && PyErr_Occurred()) {
49 goto exit;
50 }
51 if (!_PyLong_UnsignedLong_Converter(args[3], &NumberOfConcurrentThreads)) {
52 goto exit;
53 }
54 return_value = _overlapped_CreateIoCompletionPort_impl(module, FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads);
55
56 exit:
57 return return_value;
58 }
59
60 PyDoc_STRVAR(_overlapped_GetQueuedCompletionStatus__doc__,
61 "GetQueuedCompletionStatus($module, port, msecs, /)\n"
62 "--\n"
63 "\n"
64 "Get a message from completion port.\n"
65 "\n"
66 "Wait for up to msecs milliseconds.");
67
68 #define _OVERLAPPED_GETQUEUEDCOMPLETIONSTATUS_METHODDEF \
69 {"GetQueuedCompletionStatus", _PyCFunction_CAST(_overlapped_GetQueuedCompletionStatus), METH_FASTCALL, _overlapped_GetQueuedCompletionStatus__doc__},
70
71 static PyObject *
72 _overlapped_GetQueuedCompletionStatus_impl(PyObject *module,
73 HANDLE CompletionPort,
74 DWORD Milliseconds);
75
76 static PyObject *
77 _overlapped_GetQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
78 {
79 PyObject *return_value = NULL;
80 HANDLE CompletionPort;
81 DWORD Milliseconds;
82
83 if (!_PyArg_CheckPositional("GetQueuedCompletionStatus", nargs, 2, 2)) {
84 goto exit;
85 }
86 CompletionPort = PyLong_AsVoidPtr(args[0]);
87 if (!CompletionPort && PyErr_Occurred()) {
88 goto exit;
89 }
90 if (!_PyLong_UnsignedLong_Converter(args[1], &Milliseconds)) {
91 goto exit;
92 }
93 return_value = _overlapped_GetQueuedCompletionStatus_impl(module, CompletionPort, Milliseconds);
94
95 exit:
96 return return_value;
97 }
98
99 PyDoc_STRVAR(_overlapped_PostQueuedCompletionStatus__doc__,
100 "PostQueuedCompletionStatus($module, port, bytes, key, address, /)\n"
101 "--\n"
102 "\n"
103 "Post a message to completion port.");
104
105 #define _OVERLAPPED_POSTQUEUEDCOMPLETIONSTATUS_METHODDEF \
106 {"PostQueuedCompletionStatus", _PyCFunction_CAST(_overlapped_PostQueuedCompletionStatus), METH_FASTCALL, _overlapped_PostQueuedCompletionStatus__doc__},
107
108 static PyObject *
109 _overlapped_PostQueuedCompletionStatus_impl(PyObject *module,
110 HANDLE CompletionPort,
111 DWORD NumberOfBytes,
112 ULONG_PTR CompletionKey,
113 OVERLAPPED *Overlapped);
114
115 static PyObject *
116 _overlapped_PostQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
117 {
118 PyObject *return_value = NULL;
119 HANDLE CompletionPort;
120 DWORD NumberOfBytes;
121 ULONG_PTR CompletionKey;
122 OVERLAPPED *Overlapped;
123
124 if (!_PyArg_CheckPositional("PostQueuedCompletionStatus", nargs, 4, 4)) {
125 goto exit;
126 }
127 CompletionPort = PyLong_AsVoidPtr(args[0]);
128 if (!CompletionPort && PyErr_Occurred()) {
129 goto exit;
130 }
131 if (!_PyLong_UnsignedLong_Converter(args[1], &NumberOfBytes)) {
132 goto exit;
133 }
134 CompletionKey = (uintptr_t)PyLong_AsVoidPtr(args[2]);
135 if (!CompletionKey && PyErr_Occurred()) {
136 goto exit;
137 }
138 Overlapped = PyLong_AsVoidPtr(args[3]);
139 if (!Overlapped && PyErr_Occurred()) {
140 goto exit;
141 }
142 return_value = _overlapped_PostQueuedCompletionStatus_impl(module, CompletionPort, NumberOfBytes, CompletionKey, Overlapped);
143
144 exit:
145 return return_value;
146 }
147
148 PyDoc_STRVAR(_overlapped_RegisterWaitWithQueue__doc__,
149 "RegisterWaitWithQueue($module, Object, CompletionPort, Overlapped,\n"
150 " Timeout, /)\n"
151 "--\n"
152 "\n"
153 "Register wait for Object; when complete CompletionPort is notified.");
154
155 #define _OVERLAPPED_REGISTERWAITWITHQUEUE_METHODDEF \
156 {"RegisterWaitWithQueue", _PyCFunction_CAST(_overlapped_RegisterWaitWithQueue), METH_FASTCALL, _overlapped_RegisterWaitWithQueue__doc__},
157
158 static PyObject *
159 _overlapped_RegisterWaitWithQueue_impl(PyObject *module, HANDLE Object,
160 HANDLE CompletionPort,
161 OVERLAPPED *Overlapped,
162 DWORD Milliseconds);
163
164 static PyObject *
165 _overlapped_RegisterWaitWithQueue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
166 {
167 PyObject *return_value = NULL;
168 HANDLE Object;
169 HANDLE CompletionPort;
170 OVERLAPPED *Overlapped;
171 DWORD Milliseconds;
172
173 if (!_PyArg_CheckPositional("RegisterWaitWithQueue", nargs, 4, 4)) {
174 goto exit;
175 }
176 Object = PyLong_AsVoidPtr(args[0]);
177 if (!Object && PyErr_Occurred()) {
178 goto exit;
179 }
180 CompletionPort = PyLong_AsVoidPtr(args[1]);
181 if (!CompletionPort && PyErr_Occurred()) {
182 goto exit;
183 }
184 Overlapped = PyLong_AsVoidPtr(args[2]);
185 if (!Overlapped && PyErr_Occurred()) {
186 goto exit;
187 }
188 if (!_PyLong_UnsignedLong_Converter(args[3], &Milliseconds)) {
189 goto exit;
190 }
191 return_value = _overlapped_RegisterWaitWithQueue_impl(module, Object, CompletionPort, Overlapped, Milliseconds);
192
193 exit:
194 return return_value;
195 }
196
197 PyDoc_STRVAR(_overlapped_UnregisterWait__doc__,
198 "UnregisterWait($module, WaitHandle, /)\n"
199 "--\n"
200 "\n"
201 "Unregister wait handle.");
202
203 #define _OVERLAPPED_UNREGISTERWAIT_METHODDEF \
204 {"UnregisterWait", (PyCFunction)_overlapped_UnregisterWait, METH_O, _overlapped_UnregisterWait__doc__},
205
206 static PyObject *
207 _overlapped_UnregisterWait_impl(PyObject *module, HANDLE WaitHandle);
208
209 static PyObject *
210 _overlapped_UnregisterWait(PyObject *module, PyObject *arg)
211 {
212 PyObject *return_value = NULL;
213 HANDLE WaitHandle;
214
215 WaitHandle = PyLong_AsVoidPtr(arg);
216 if (!WaitHandle && PyErr_Occurred()) {
217 goto exit;
218 }
219 return_value = _overlapped_UnregisterWait_impl(module, WaitHandle);
220
221 exit:
222 return return_value;
223 }
224
225 PyDoc_STRVAR(_overlapped_UnregisterWaitEx__doc__,
226 "UnregisterWaitEx($module, WaitHandle, Event, /)\n"
227 "--\n"
228 "\n"
229 "Unregister wait handle.");
230
231 #define _OVERLAPPED_UNREGISTERWAITEX_METHODDEF \
232 {"UnregisterWaitEx", _PyCFunction_CAST(_overlapped_UnregisterWaitEx), METH_FASTCALL, _overlapped_UnregisterWaitEx__doc__},
233
234 static PyObject *
235 _overlapped_UnregisterWaitEx_impl(PyObject *module, HANDLE WaitHandle,
236 HANDLE Event);
237
238 static PyObject *
239 _overlapped_UnregisterWaitEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
240 {
241 PyObject *return_value = NULL;
242 HANDLE WaitHandle;
243 HANDLE Event;
244
245 if (!_PyArg_CheckPositional("UnregisterWaitEx", nargs, 2, 2)) {
246 goto exit;
247 }
248 WaitHandle = PyLong_AsVoidPtr(args[0]);
249 if (!WaitHandle && PyErr_Occurred()) {
250 goto exit;
251 }
252 Event = PyLong_AsVoidPtr(args[1]);
253 if (!Event && PyErr_Occurred()) {
254 goto exit;
255 }
256 return_value = _overlapped_UnregisterWaitEx_impl(module, WaitHandle, Event);
257
258 exit:
259 return return_value;
260 }
261
262 PyDoc_STRVAR(_overlapped_CreateEvent__doc__,
263 "CreateEvent($module, EventAttributes, ManualReset, InitialState, Name,\n"
264 " /)\n"
265 "--\n"
266 "\n"
267 "Create an event.\n"
268 "\n"
269 "EventAttributes must be None.");
270
271 #define _OVERLAPPED_CREATEEVENT_METHODDEF \
272 {"CreateEvent", _PyCFunction_CAST(_overlapped_CreateEvent), METH_FASTCALL, _overlapped_CreateEvent__doc__},
273
274 static PyObject *
275 _overlapped_CreateEvent_impl(PyObject *module, PyObject *EventAttributes,
276 BOOL ManualReset, BOOL InitialState,
277 const wchar_t *Name);
278
279 static PyObject *
280 _overlapped_CreateEvent(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
281 {
282 PyObject *return_value = NULL;
283 PyObject *EventAttributes;
284 BOOL ManualReset;
285 BOOL InitialState;
286 const wchar_t *Name = NULL;
287
288 if (!_PyArg_CheckPositional("CreateEvent", nargs, 4, 4)) {
289 goto exit;
290 }
291 EventAttributes = args[0];
292 ManualReset = PyLong_AsInt(args[1]);
293 if (ManualReset == -1 && PyErr_Occurred()) {
294 goto exit;
295 }
296 InitialState = PyLong_AsInt(args[2]);
297 if (InitialState == -1 && PyErr_Occurred()) {
298 goto exit;
299 }
300 if (args[3] == Py_None) {
301 Name = NULL;
302 }
303 else if (PyUnicode_Check(args[3])) {
304 Name = PyUnicode_AsWideCharString(args[3], NULL);
305 if (Name == NULL) {
306 goto exit;
307 }
308 }
309 else {
310 _PyArg_BadArgument("CreateEvent", "argument 4", "str or None", args[3]);
311 goto exit;
312 }
313 return_value = _overlapped_CreateEvent_impl(module, EventAttributes, ManualReset, InitialState, Name);
314
315 exit:
316 /* Cleanup for Name */
317 PyMem_Free((void *)Name);
318
319 return return_value;
320 }
321
322 PyDoc_STRVAR(_overlapped_SetEvent__doc__,
323 "SetEvent($module, Handle, /)\n"
324 "--\n"
325 "\n"
326 "Set event.");
327
328 #define _OVERLAPPED_SETEVENT_METHODDEF \
329 {"SetEvent", (PyCFunction)_overlapped_SetEvent, METH_O, _overlapped_SetEvent__doc__},
330
331 static PyObject *
332 _overlapped_SetEvent_impl(PyObject *module, HANDLE Handle);
333
334 static PyObject *
335 _overlapped_SetEvent(PyObject *module, PyObject *arg)
336 {
337 PyObject *return_value = NULL;
338 HANDLE Handle;
339
340 Handle = PyLong_AsVoidPtr(arg);
341 if (!Handle && PyErr_Occurred()) {
342 goto exit;
343 }
344 return_value = _overlapped_SetEvent_impl(module, Handle);
345
346 exit:
347 return return_value;
348 }
349
350 PyDoc_STRVAR(_overlapped_ResetEvent__doc__,
351 "ResetEvent($module, Handle, /)\n"
352 "--\n"
353 "\n"
354 "Reset event.");
355
356 #define _OVERLAPPED_RESETEVENT_METHODDEF \
357 {"ResetEvent", (PyCFunction)_overlapped_ResetEvent, METH_O, _overlapped_ResetEvent__doc__},
358
359 static PyObject *
360 _overlapped_ResetEvent_impl(PyObject *module, HANDLE Handle);
361
362 static PyObject *
363 _overlapped_ResetEvent(PyObject *module, PyObject *arg)
364 {
365 PyObject *return_value = NULL;
366 HANDLE Handle;
367
368 Handle = PyLong_AsVoidPtr(arg);
369 if (!Handle && PyErr_Occurred()) {
370 goto exit;
371 }
372 return_value = _overlapped_ResetEvent_impl(module, Handle);
373
374 exit:
375 return return_value;
376 }
377
378 PyDoc_STRVAR(_overlapped_BindLocal__doc__,
379 "BindLocal($module, handle, family, /)\n"
380 "--\n"
381 "\n"
382 "Bind a socket handle to an arbitrary local port.\n"
383 "\n"
384 "family should be AF_INET or AF_INET6.");
385
386 #define _OVERLAPPED_BINDLOCAL_METHODDEF \
387 {"BindLocal", _PyCFunction_CAST(_overlapped_BindLocal), METH_FASTCALL, _overlapped_BindLocal__doc__},
388
389 static PyObject *
390 _overlapped_BindLocal_impl(PyObject *module, HANDLE Socket, int Family);
391
392 static PyObject *
393 _overlapped_BindLocal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
394 {
395 PyObject *return_value = NULL;
396 HANDLE Socket;
397 int Family;
398
399 if (!_PyArg_CheckPositional("BindLocal", nargs, 2, 2)) {
400 goto exit;
401 }
402 Socket = PyLong_AsVoidPtr(args[0]);
403 if (!Socket && PyErr_Occurred()) {
404 goto exit;
405 }
406 Family = PyLong_AsInt(args[1]);
407 if (Family == -1 && PyErr_Occurred()) {
408 goto exit;
409 }
410 return_value = _overlapped_BindLocal_impl(module, Socket, Family);
411
412 exit:
413 return return_value;
414 }
415
416 PyDoc_STRVAR(_overlapped_FormatMessage__doc__,
417 "FormatMessage($module, error_code, /)\n"
418 "--\n"
419 "\n"
420 "Return error message for an error code.");
421
422 #define _OVERLAPPED_FORMATMESSAGE_METHODDEF \
423 {"FormatMessage", (PyCFunction)_overlapped_FormatMessage, METH_O, _overlapped_FormatMessage__doc__},
424
425 static PyObject *
426 _overlapped_FormatMessage_impl(PyObject *module, DWORD code);
427
428 static PyObject *
429 _overlapped_FormatMessage(PyObject *module, PyObject *arg)
430 {
431 PyObject *return_value = NULL;
432 DWORD code;
433
434 if (!_PyLong_UnsignedLong_Converter(arg, &code)) {
435 goto exit;
436 }
437 return_value = _overlapped_FormatMessage_impl(module, code);
438
439 exit:
440 return return_value;
441 }
442
443 PyDoc_STRVAR(_overlapped_Overlapped__doc__,
444 "Overlapped(event=_overlapped.INVALID_HANDLE_VALUE)\n"
445 "--\n"
446 "\n"
447 "OVERLAPPED structure wrapper.");
448
449 static PyObject *
450 _overlapped_Overlapped_impl(PyTypeObject *type, HANDLE event);
451
452 static PyObject *
453 _overlapped_Overlapped(PyTypeObject *type, PyObject *args, PyObject *kwargs)
454 {
455 PyObject *return_value = NULL;
456 #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
457
458 #define NUM_KEYWORDS 1
459 static struct {
460 PyGC_Head _this_is_not_used;
461 PyObject_VAR_HEAD
462 Py_hash_t ob_hash;
463 PyObject *ob_item[NUM_KEYWORDS];
464 } _kwtuple = {
465 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
466 .ob_hash = -1,
467 .ob_item = { &_Py_ID(event), },
468 };
469 #undef NUM_KEYWORDS
470 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
471
472 #else // !Py_BUILD_CORE
473 # define KWTUPLE NULL
474 #endif // !Py_BUILD_CORE
475
476 static const char * const _keywords[] = {"event", NULL};
477 static _PyArg_Parser _parser = {
478 .keywords = _keywords,
479 .fname = "Overlapped",
480 .kwtuple = KWTUPLE,
481 };
482 #undef KWTUPLE
483 PyObject *argsbuf[1];
484 PyObject * const *fastargs;
485 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
486 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
487 HANDLE event = INVALID_HANDLE_VALUE;
488
489 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser,
490 /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf);
491 if (!fastargs) {
492 goto exit;
493 }
494 if (!noptargs) {
495 goto skip_optional_pos;
496 }
497 event = PyLong_AsVoidPtr(fastargs[0]);
498 if (!event && PyErr_Occurred()) {
499 goto exit;
500 }
501 skip_optional_pos:
502 return_value = _overlapped_Overlapped_impl(type, event);
503
504 exit:
505 return return_value;
506 }
507
508 PyDoc_STRVAR(_overlapped_Overlapped_cancel__doc__,
509 "cancel($self, /)\n"
510 "--\n"
511 "\n"
512 "Cancel overlapped operation.");
513
514 #define _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF \
515 {"cancel", (PyCFunction)_overlapped_Overlapped_cancel, METH_NOARGS, _overlapped_Overlapped_cancel__doc__},
516
517 static PyObject *
518 _overlapped_Overlapped_cancel_impl(OverlappedObject *self);
519
520 static PyObject *
521 _overlapped_Overlapped_cancel(PyObject *self, PyObject *Py_UNUSED(ignored))
522 {
523 return _overlapped_Overlapped_cancel_impl((OverlappedObject *)self);
524 }
525
526 PyDoc_STRVAR(_overlapped_Overlapped_getresult__doc__,
527 "getresult($self, wait=False, /)\n"
528 "--\n"
529 "\n"
530 "Retrieve result of operation.\n"
531 "\n"
532 "If wait is true then it blocks until the operation is finished. If wait\n"
533 "is false and the operation is still pending then an error is raised.");
534
535 #define _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF \
536 {"getresult", _PyCFunction_CAST(_overlapped_Overlapped_getresult), METH_FASTCALL, _overlapped_Overlapped_getresult__doc__},
537
538 static PyObject *
539 _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait);
540
541 static PyObject *
542 _overlapped_Overlapped_getresult(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
543 {
544 PyObject *return_value = NULL;
545 BOOL wait = FALSE;
546
547 if (!_PyArg_CheckPositional("getresult", nargs, 0, 1)) {
548 goto exit;
549 }
550 if (nargs < 1) {
551 goto skip_optional;
552 }
553 wait = PyLong_AsInt(args[0]);
554 if (wait == -1 && PyErr_Occurred()) {
555 goto exit;
556 }
557 skip_optional:
558 return_value = _overlapped_Overlapped_getresult_impl((OverlappedObject *)self, wait);
559
560 exit:
561 return return_value;
562 }
563
564 PyDoc_STRVAR(_overlapped_Overlapped_ReadFile__doc__,
565 "ReadFile($self, handle, size, /)\n"
566 "--\n"
567 "\n"
568 "Start overlapped read.");
569
570 #define _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF \
571 {"ReadFile", _PyCFunction_CAST(_overlapped_Overlapped_ReadFile), METH_FASTCALL, _overlapped_Overlapped_ReadFile__doc__},
572
573 static PyObject *
574 _overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
575 DWORD size);
576
577 static PyObject *
578 _overlapped_Overlapped_ReadFile(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
579 {
580 PyObject *return_value = NULL;
581 HANDLE handle;
582 DWORD size;
583
584 if (!_PyArg_CheckPositional("ReadFile", nargs, 2, 2)) {
585 goto exit;
586 }
587 handle = PyLong_AsVoidPtr(args[0]);
588 if (!handle && PyErr_Occurred()) {
589 goto exit;
590 }
591 if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
592 goto exit;
593 }
594 return_value = _overlapped_Overlapped_ReadFile_impl((OverlappedObject *)self, handle, size);
595
596 exit:
597 return return_value;
598 }
599
600 PyDoc_STRVAR(_overlapped_Overlapped_ReadFileInto__doc__,
601 "ReadFileInto($self, handle, buf, /)\n"
602 "--\n"
603 "\n"
604 "Start overlapped receive.");
605
606 #define _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF \
607 {"ReadFileInto", _PyCFunction_CAST(_overlapped_Overlapped_ReadFileInto), METH_FASTCALL, _overlapped_Overlapped_ReadFileInto__doc__},
608
609 static PyObject *
610 _overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
611 HANDLE handle, Py_buffer *bufobj);
612
613 static PyObject *
614 _overlapped_Overlapped_ReadFileInto(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
615 {
616 PyObject *return_value = NULL;
617 HANDLE handle;
618 Py_buffer bufobj = {NULL, NULL};
619
620 if (!_PyArg_CheckPositional("ReadFileInto", nargs, 2, 2)) {
621 goto exit;
622 }
623 handle = PyLong_AsVoidPtr(args[0]);
624 if (!handle && PyErr_Occurred()) {
625 goto exit;
626 }
627 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
628 goto exit;
629 }
630 return_value = _overlapped_Overlapped_ReadFileInto_impl((OverlappedObject *)self, handle, &bufobj);
631
632 exit:
633 /* Cleanup for bufobj */
634 if (bufobj.obj) {
635 PyBuffer_Release(&bufobj);
636 }
637
638 return return_value;
639 }
640
641 PyDoc_STRVAR(_overlapped_Overlapped_WSARecv__doc__,
642 "WSARecv($self, handle, size, flags=0, /)\n"
643 "--\n"
644 "\n"
645 "Start overlapped receive.");
646
647 #define _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF \
648 {"WSARecv", _PyCFunction_CAST(_overlapped_Overlapped_WSARecv), METH_FASTCALL, _overlapped_Overlapped_WSARecv__doc__},
649
650 static PyObject *
651 _overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
652 DWORD size, DWORD flags);
653
654 static PyObject *
655 _overlapped_Overlapped_WSARecv(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
656 {
657 PyObject *return_value = NULL;
658 HANDLE handle;
659 DWORD size;
660 DWORD flags = 0;
661
662 if (!_PyArg_CheckPositional("WSARecv", nargs, 2, 3)) {
663 goto exit;
664 }
665 handle = PyLong_AsVoidPtr(args[0]);
666 if (!handle && PyErr_Occurred()) {
667 goto exit;
668 }
669 if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
670 goto exit;
671 }
672 if (nargs < 3) {
673 goto skip_optional;
674 }
675 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
676 goto exit;
677 }
678 skip_optional:
679 return_value = _overlapped_Overlapped_WSARecv_impl((OverlappedObject *)self, handle, size, flags);
680
681 exit:
682 return return_value;
683 }
684
685 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvInto__doc__,
686 "WSARecvInto($self, handle, buf, flags, /)\n"
687 "--\n"
688 "\n"
689 "Start overlapped receive.");
690
691 #define _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF \
692 {"WSARecvInto", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvInto), METH_FASTCALL, _overlapped_Overlapped_WSARecvInto__doc__},
693
694 static PyObject *
695 _overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
696 HANDLE handle, Py_buffer *bufobj,
697 DWORD flags);
698
699 static PyObject *
700 _overlapped_Overlapped_WSARecvInto(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
701 {
702 PyObject *return_value = NULL;
703 HANDLE handle;
704 Py_buffer bufobj = {NULL, NULL};
705 DWORD flags;
706
707 if (!_PyArg_CheckPositional("WSARecvInto", nargs, 3, 3)) {
708 goto exit;
709 }
710 handle = PyLong_AsVoidPtr(args[0]);
711 if (!handle && PyErr_Occurred()) {
712 goto exit;
713 }
714 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
715 goto exit;
716 }
717 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
718 goto exit;
719 }
720 return_value = _overlapped_Overlapped_WSARecvInto_impl((OverlappedObject *)self, handle, &bufobj, flags);
721
722 exit:
723 /* Cleanup for bufobj */
724 if (bufobj.obj) {
725 PyBuffer_Release(&bufobj);
726 }
727
728 return return_value;
729 }
730
731 PyDoc_STRVAR(_overlapped_Overlapped_WriteFile__doc__,
732 "WriteFile($self, handle, buf, /)\n"
733 "--\n"
734 "\n"
735 "Start overlapped write.");
736
737 #define _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF \
738 {"WriteFile", _PyCFunction_CAST(_overlapped_Overlapped_WriteFile), METH_FASTCALL, _overlapped_Overlapped_WriteFile__doc__},
739
740 static PyObject *
741 _overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
742 Py_buffer *bufobj);
743
744 static PyObject *
745 _overlapped_Overlapped_WriteFile(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
746 {
747 PyObject *return_value = NULL;
748 HANDLE handle;
749 Py_buffer bufobj = {NULL, NULL};
750
751 if (!_PyArg_CheckPositional("WriteFile", nargs, 2, 2)) {
752 goto exit;
753 }
754 handle = PyLong_AsVoidPtr(args[0]);
755 if (!handle && PyErr_Occurred()) {
756 goto exit;
757 }
758 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
759 goto exit;
760 }
761 return_value = _overlapped_Overlapped_WriteFile_impl((OverlappedObject *)self, handle, &bufobj);
762
763 exit:
764 /* Cleanup for bufobj */
765 if (bufobj.obj) {
766 PyBuffer_Release(&bufobj);
767 }
768
769 return return_value;
770 }
771
772 PyDoc_STRVAR(_overlapped_Overlapped_WSASend__doc__,
773 "WSASend($self, handle, buf, flags, /)\n"
774 "--\n"
775 "\n"
776 "Start overlapped send.");
777
778 #define _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF \
779 {"WSASend", _PyCFunction_CAST(_overlapped_Overlapped_WSASend), METH_FASTCALL, _overlapped_Overlapped_WSASend__doc__},
780
781 static PyObject *
782 _overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
783 Py_buffer *bufobj, DWORD flags);
784
785 static PyObject *
786 _overlapped_Overlapped_WSASend(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
787 {
788 PyObject *return_value = NULL;
789 HANDLE handle;
790 Py_buffer bufobj = {NULL, NULL};
791 DWORD flags;
792
793 if (!_PyArg_CheckPositional("WSASend", nargs, 3, 3)) {
794 goto exit;
795 }
796 handle = PyLong_AsVoidPtr(args[0]);
797 if (!handle && PyErr_Occurred()) {
798 goto exit;
799 }
800 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
801 goto exit;
802 }
803 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
804 goto exit;
805 }
806 return_value = _overlapped_Overlapped_WSASend_impl((OverlappedObject *)self, handle, &bufobj, flags);
807
808 exit:
809 /* Cleanup for bufobj */
810 if (bufobj.obj) {
811 PyBuffer_Release(&bufobj);
812 }
813
814 return return_value;
815 }
816
817 PyDoc_STRVAR(_overlapped_Overlapped_AcceptEx__doc__,
818 "AcceptEx($self, listen_handle, accept_handle, /)\n"
819 "--\n"
820 "\n"
821 "Start overlapped wait for client to connect.");
822
823 #define _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF \
824 {"AcceptEx", _PyCFunction_CAST(_overlapped_Overlapped_AcceptEx), METH_FASTCALL, _overlapped_Overlapped_AcceptEx__doc__},
825
826 static PyObject *
827 _overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
828 HANDLE ListenSocket,
829 HANDLE AcceptSocket);
830
831 static PyObject *
832 _overlapped_Overlapped_AcceptEx(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
833 {
834 PyObject *return_value = NULL;
835 HANDLE ListenSocket;
836 HANDLE AcceptSocket;
837
838 if (!_PyArg_CheckPositional("AcceptEx", nargs, 2, 2)) {
839 goto exit;
840 }
841 ListenSocket = PyLong_AsVoidPtr(args[0]);
842 if (!ListenSocket && PyErr_Occurred()) {
843 goto exit;
844 }
845 AcceptSocket = PyLong_AsVoidPtr(args[1]);
846 if (!AcceptSocket && PyErr_Occurred()) {
847 goto exit;
848 }
849 return_value = _overlapped_Overlapped_AcceptEx_impl((OverlappedObject *)self, ListenSocket, AcceptSocket);
850
851 exit:
852 return return_value;
853 }
854
855 PyDoc_STRVAR(_overlapped_Overlapped_ConnectEx__doc__,
856 "ConnectEx($self, client_handle, address_as_bytes, /)\n"
857 "--\n"
858 "\n"
859 "Start overlapped connect.\n"
860 "\n"
861 "client_handle should be unbound.");
862
863 #define _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF \
864 {"ConnectEx", _PyCFunction_CAST(_overlapped_Overlapped_ConnectEx), METH_FASTCALL, _overlapped_Overlapped_ConnectEx__doc__},
865
866 static PyObject *
867 _overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
868 HANDLE ConnectSocket,
869 PyObject *AddressObj);
870
871 static PyObject *
872 _overlapped_Overlapped_ConnectEx(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
873 {
874 PyObject *return_value = NULL;
875 HANDLE ConnectSocket;
876 PyObject *AddressObj;
877
878 if (!_PyArg_CheckPositional("ConnectEx", nargs, 2, 2)) {
879 goto exit;
880 }
881 ConnectSocket = PyLong_AsVoidPtr(args[0]);
882 if (!ConnectSocket && PyErr_Occurred()) {
883 goto exit;
884 }
885 if (!PyTuple_Check(args[1])) {
886 _PyArg_BadArgument("ConnectEx", "argument 2", "tuple", args[1]);
887 goto exit;
888 }
889 AddressObj = args[1];
890 return_value = _overlapped_Overlapped_ConnectEx_impl((OverlappedObject *)self, ConnectSocket, AddressObj);
891
892 exit:
893 return return_value;
894 }
895
896 PyDoc_STRVAR(_overlapped_Overlapped_DisconnectEx__doc__,
897 "DisconnectEx($self, handle, flags, /)\n"
898 "--\n"
899 "\n");
900
901 #define _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF \
902 {"DisconnectEx", _PyCFunction_CAST(_overlapped_Overlapped_DisconnectEx), METH_FASTCALL, _overlapped_Overlapped_DisconnectEx__doc__},
903
904 static PyObject *
905 _overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
906 HANDLE Socket, DWORD flags);
907
908 static PyObject *
909 _overlapped_Overlapped_DisconnectEx(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
910 {
911 PyObject *return_value = NULL;
912 HANDLE Socket;
913 DWORD flags;
914
915 if (!_PyArg_CheckPositional("DisconnectEx", nargs, 2, 2)) {
916 goto exit;
917 }
918 Socket = PyLong_AsVoidPtr(args[0]);
919 if (!Socket && PyErr_Occurred()) {
920 goto exit;
921 }
922 if (!_PyLong_UnsignedLong_Converter(args[1], &flags)) {
923 goto exit;
924 }
925 return_value = _overlapped_Overlapped_DisconnectEx_impl((OverlappedObject *)self, Socket, flags);
926
927 exit:
928 return return_value;
929 }
930
931 PyDoc_STRVAR(_overlapped_Overlapped_TransmitFile__doc__,
932 "TransmitFile($self, socket, file, offset, offset_high, count_to_write,\n"
933 " count_per_send, flags, /)\n"
934 "--\n"
935 "\n"
936 "Transmit file data over a connected socket.");
937
938 #define _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF \
939 {"TransmitFile", _PyCFunction_CAST(_overlapped_Overlapped_TransmitFile), METH_FASTCALL, _overlapped_Overlapped_TransmitFile__doc__},
940
941 static PyObject *
942 _overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
943 HANDLE Socket, HANDLE File,
944 DWORD offset, DWORD offset_high,
945 DWORD count_to_write,
946 DWORD count_per_send, DWORD flags);
947
948 static PyObject *
949 _overlapped_Overlapped_TransmitFile(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
950 {
951 PyObject *return_value = NULL;
952 HANDLE Socket;
953 HANDLE File;
954 DWORD offset;
955 DWORD offset_high;
956 DWORD count_to_write;
957 DWORD count_per_send;
958 DWORD flags;
959
960 if (!_PyArg_CheckPositional("TransmitFile", nargs, 7, 7)) {
961 goto exit;
962 }
963 Socket = PyLong_AsVoidPtr(args[0]);
964 if (!Socket && PyErr_Occurred()) {
965 goto exit;
966 }
967 File = PyLong_AsVoidPtr(args[1]);
968 if (!File && PyErr_Occurred()) {
969 goto exit;
970 }
971 if (!_PyLong_UnsignedLong_Converter(args[2], &offset)) {
972 goto exit;
973 }
974 if (!_PyLong_UnsignedLong_Converter(args[3], &offset_high)) {
975 goto exit;
976 }
977 if (!_PyLong_UnsignedLong_Converter(args[4], &count_to_write)) {
978 goto exit;
979 }
980 if (!_PyLong_UnsignedLong_Converter(args[5], &count_per_send)) {
981 goto exit;
982 }
983 if (!_PyLong_UnsignedLong_Converter(args[6], &flags)) {
984 goto exit;
985 }
986 return_value = _overlapped_Overlapped_TransmitFile_impl((OverlappedObject *)self, Socket, File, offset, offset_high, count_to_write, count_per_send, flags);
987
988 exit:
989 return return_value;
990 }
991
992 PyDoc_STRVAR(_overlapped_Overlapped_ConnectNamedPipe__doc__,
993 "ConnectNamedPipe($self, handle, /)\n"
994 "--\n"
995 "\n"
996 "Start overlapped wait for a client to connect.");
997
998 #define _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF \
999 {"ConnectNamedPipe", (PyCFunction)_overlapped_Overlapped_ConnectNamedPipe, METH_O, _overlapped_Overlapped_ConnectNamedPipe__doc__},
1000
1001 static PyObject *
1002 _overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
1003 HANDLE Pipe);
1004
1005 static PyObject *
1006 _overlapped_Overlapped_ConnectNamedPipe(PyObject *self, PyObject *arg)
1007 {
1008 PyObject *return_value = NULL;
1009 HANDLE Pipe;
1010
1011 Pipe = PyLong_AsVoidPtr(arg);
1012 if (!Pipe && PyErr_Occurred()) {
1013 goto exit;
1014 }
1015 return_value = _overlapped_Overlapped_ConnectNamedPipe_impl((OverlappedObject *)self, Pipe);
1016
1017 exit:
1018 return return_value;
1019 }
1020
1021 PyDoc_STRVAR(_overlapped_Overlapped_ConnectPipe__doc__,
1022 "ConnectPipe($self, addr, /)\n"
1023 "--\n"
1024 "\n"
1025 "Connect to the pipe for asynchronous I/O (overlapped).");
1026
1027 #define _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF \
1028 {"ConnectPipe", (PyCFunction)_overlapped_Overlapped_ConnectPipe, METH_O, _overlapped_Overlapped_ConnectPipe__doc__},
1029
1030 static PyObject *
1031 _overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
1032 const wchar_t *Address);
1033
1034 static PyObject *
1035 _overlapped_Overlapped_ConnectPipe(PyObject *self, PyObject *arg)
1036 {
1037 PyObject *return_value = NULL;
1038 const wchar_t *Address = NULL;
1039
1040 if (!PyUnicode_Check(arg)) {
1041 _PyArg_BadArgument("ConnectPipe", "argument", "str", arg);
1042 goto exit;
1043 }
1044 Address = PyUnicode_AsWideCharString(arg, NULL);
1045 if (Address == NULL) {
1046 goto exit;
1047 }
1048 return_value = _overlapped_Overlapped_ConnectPipe_impl((OverlappedObject *)self, Address);
1049
1050 exit:
1051 /* Cleanup for Address */
1052 PyMem_Free((void *)Address);
1053
1054 return return_value;
1055 }
1056
1057 PyDoc_STRVAR(_overlapped_WSAConnect__doc__,
1058 "WSAConnect($module, client_handle, address_as_bytes, /)\n"
1059 "--\n"
1060 "\n"
1061 "Bind a remote address to a connectionless (UDP) socket.");
1062
1063 #define _OVERLAPPED_WSACONNECT_METHODDEF \
1064 {"WSAConnect", _PyCFunction_CAST(_overlapped_WSAConnect), METH_FASTCALL, _overlapped_WSAConnect__doc__},
1065
1066 static PyObject *
1067 _overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
1068 PyObject *AddressObj);
1069
1070 static PyObject *
1071 _overlapped_WSAConnect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1072 {
1073 PyObject *return_value = NULL;
1074 HANDLE ConnectSocket;
1075 PyObject *AddressObj;
1076
1077 if (!_PyArg_CheckPositional("WSAConnect", nargs, 2, 2)) {
1078 goto exit;
1079 }
1080 ConnectSocket = PyLong_AsVoidPtr(args[0]);
1081 if (!ConnectSocket && PyErr_Occurred()) {
1082 goto exit;
1083 }
1084 if (!PyTuple_Check(args[1])) {
1085 _PyArg_BadArgument("WSAConnect", "argument 2", "tuple", args[1]);
1086 goto exit;
1087 }
1088 AddressObj = args[1];
1089 return_value = _overlapped_WSAConnect_impl(module, ConnectSocket, AddressObj);
1090
1091 exit:
1092 return return_value;
1093 }
1094
1095 PyDoc_STRVAR(_overlapped_Overlapped_WSASendTo__doc__,
1096 "WSASendTo($self, handle, buf, flags, address_as_bytes, /)\n"
1097 "--\n"
1098 "\n"
1099 "Start overlapped sendto over a connectionless (UDP) socket.");
1100
1101 #define _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF \
1102 {"WSASendTo", _PyCFunction_CAST(_overlapped_Overlapped_WSASendTo), METH_FASTCALL, _overlapped_Overlapped_WSASendTo__doc__},
1103
1104 static PyObject *
1105 _overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
1106 Py_buffer *bufobj, DWORD flags,
1107 PyObject *AddressObj);
1108
1109 static PyObject *
1110 _overlapped_Overlapped_WSASendTo(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
1111 {
1112 PyObject *return_value = NULL;
1113 HANDLE handle;
1114 Py_buffer bufobj = {NULL, NULL};
1115 DWORD flags;
1116 PyObject *AddressObj;
1117
1118 if (!_PyArg_CheckPositional("WSASendTo", nargs, 4, 4)) {
1119 goto exit;
1120 }
1121 handle = PyLong_AsVoidPtr(args[0]);
1122 if (!handle && PyErr_Occurred()) {
1123 goto exit;
1124 }
1125 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
1126 goto exit;
1127 }
1128 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
1129 goto exit;
1130 }
1131 if (!PyTuple_Check(args[3])) {
1132 _PyArg_BadArgument("WSASendTo", "argument 4", "tuple", args[3]);
1133 goto exit;
1134 }
1135 AddressObj = args[3];
1136 return_value = _overlapped_Overlapped_WSASendTo_impl((OverlappedObject *)self, handle, &bufobj, flags, AddressObj);
1137
1138 exit:
1139 /* Cleanup for bufobj */
1140 if (bufobj.obj) {
1141 PyBuffer_Release(&bufobj);
1142 }
1143
1144 return return_value;
1145 }
1146
1147 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFrom__doc__,
1148 "WSARecvFrom($self, handle, size, flags=0, /)\n"
1149 "--\n"
1150 "\n"
1151 "Start overlapped receive.");
1152
1153 #define _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF \
1154 {"WSARecvFrom", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvFrom), METH_FASTCALL, _overlapped_Overlapped_WSARecvFrom__doc__},
1155
1156 static PyObject *
1157 _overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
1158 HANDLE handle, DWORD size,
1159 DWORD flags);
1160
1161 static PyObject *
1162 _overlapped_Overlapped_WSARecvFrom(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
1163 {
1164 PyObject *return_value = NULL;
1165 HANDLE handle;
1166 DWORD size;
1167 DWORD flags = 0;
1168
1169 if (!_PyArg_CheckPositional("WSARecvFrom", nargs, 2, 3)) {
1170 goto exit;
1171 }
1172 handle = PyLong_AsVoidPtr(args[0]);
1173 if (!handle && PyErr_Occurred()) {
1174 goto exit;
1175 }
1176 if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
1177 goto exit;
1178 }
1179 if (nargs < 3) {
1180 goto skip_optional;
1181 }
1182 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
1183 goto exit;
1184 }
1185 skip_optional:
1186 return_value = _overlapped_Overlapped_WSARecvFrom_impl((OverlappedObject *)self, handle, size, flags);
1187
1188 exit:
1189 return return_value;
1190 }
1191
1192 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFromInto__doc__,
1193 "WSARecvFromInto($self, handle, buf, size, flags=0, /)\n"
1194 "--\n"
1195 "\n"
1196 "Start overlapped receive.");
1197
1198 #define _OVERLAPPED_OVERLAPPED_WSARECVFROMINTO_METHODDEF \
1199 {"WSARecvFromInto", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvFromInto), METH_FASTCALL, _overlapped_Overlapped_WSARecvFromInto__doc__},
1200
1201 static PyObject *
1202 _overlapped_Overlapped_WSARecvFromInto_impl(OverlappedObject *self,
1203 HANDLE handle, Py_buffer *bufobj,
1204 DWORD size, DWORD flags);
1205
1206 static PyObject *
1207 _overlapped_Overlapped_WSARecvFromInto(PyObject *self, PyObject *const *args, Py_ssize_t nargs)
1208 {
1209 PyObject *return_value = NULL;
1210 HANDLE handle;
1211 Py_buffer bufobj = {NULL, NULL};
1212 DWORD size;
1213 DWORD flags = 0;
1214
1215 if (!_PyArg_CheckPositional("WSARecvFromInto", nargs, 3, 4)) {
1216 goto exit;
1217 }
1218 handle = PyLong_AsVoidPtr(args[0]);
1219 if (!handle && PyErr_Occurred()) {
1220 goto exit;
1221 }
1222 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
1223 goto exit;
1224 }
1225 if (!_PyLong_UnsignedLong_Converter(args[2], &size)) {
1226 goto exit;
1227 }
1228 if (nargs < 4) {
1229 goto skip_optional;
1230 }
1231 if (!_PyLong_UnsignedLong_Converter(args[3], &flags)) {
1232 goto exit;
1233 }
1234 skip_optional:
1235 return_value = _overlapped_Overlapped_WSARecvFromInto_impl((OverlappedObject *)self, handle, &bufobj, size, flags);
1236
1237 exit:
1238 /* Cleanup for bufobj */
1239 if (bufobj.obj) {
1240 PyBuffer_Release(&bufobj);
1241 }
1242
1243 return return_value;
1244 }
1245 /*[clinic end generated code: output=3e4cb2b55342cd96 input=a9049054013a1b77]*/