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 *
_overlapped_CreateIoCompletionPort(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_GetQueuedCompletionStatus(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_PostQueuedCompletionStatus(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_RegisterWaitWithQueue(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_UnregisterWait(PyObject * module,PyObject * arg)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 *
_overlapped_UnregisterWaitEx(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_CreateEvent(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_SetEvent(PyObject * module,PyObject * arg)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 *
_overlapped_ResetEvent(PyObject * module,PyObject * arg)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 *
_overlapped_BindLocal(PyObject * module,PyObject * const * args,Py_ssize_t nargs)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 *
_overlapped_FormatMessage(PyObject * module,PyObject * arg)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 *
_overlapped_Overlapped(PyTypeObject * type,PyObject * args,PyObject * kwargs)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 PyObject *ob_item[NUM_KEYWORDS];
463 } _kwtuple = {
464 .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
465 .ob_item = { &_Py_ID(event), },
466 };
467 #undef NUM_KEYWORDS
468 #define KWTUPLE (&_kwtuple.ob_base.ob_base)
469
470 #else // !Py_BUILD_CORE
471 # define KWTUPLE NULL
472 #endif // !Py_BUILD_CORE
473
474 static const char * const _keywords[] = {"event", NULL};
475 static _PyArg_Parser _parser = {
476 .keywords = _keywords,
477 .fname = "Overlapped",
478 .kwtuple = KWTUPLE,
479 };
480 #undef KWTUPLE
481 PyObject *argsbuf[1];
482 PyObject * const *fastargs;
483 Py_ssize_t nargs = PyTuple_GET_SIZE(args);
484 Py_ssize_t noptargs = nargs + (kwargs ? PyDict_GET_SIZE(kwargs) : 0) - 0;
485 HANDLE event = INVALID_HANDLE_VALUE;
486
487 fastargs = _PyArg_UnpackKeywords(_PyTuple_CAST(args)->ob_item, nargs, kwargs, NULL, &_parser, 0, 1, 0, argsbuf);
488 if (!fastargs) {
489 goto exit;
490 }
491 if (!noptargs) {
492 goto skip_optional_pos;
493 }
494 event = PyLong_AsVoidPtr(fastargs[0]);
495 if (!event && PyErr_Occurred()) {
496 goto exit;
497 }
498 skip_optional_pos:
499 return_value = _overlapped_Overlapped_impl(type, event);
500
501 exit:
502 return return_value;
503 }
504
505 PyDoc_STRVAR(_overlapped_Overlapped_cancel__doc__,
506 "cancel($self, /)\n"
507 "--\n"
508 "\n"
509 "Cancel overlapped operation.");
510
511 #define _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF \
512 {"cancel", (PyCFunction)_overlapped_Overlapped_cancel, METH_NOARGS, _overlapped_Overlapped_cancel__doc__},
513
514 static PyObject *
515 _overlapped_Overlapped_cancel_impl(OverlappedObject *self);
516
517 static PyObject *
_overlapped_Overlapped_cancel(OverlappedObject * self,PyObject * Py_UNUSED (ignored))518 _overlapped_Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
519 {
520 return _overlapped_Overlapped_cancel_impl(self);
521 }
522
523 PyDoc_STRVAR(_overlapped_Overlapped_getresult__doc__,
524 "getresult($self, wait=False, /)\n"
525 "--\n"
526 "\n"
527 "Retrieve result of operation.\n"
528 "\n"
529 "If wait is true then it blocks until the operation is finished. If wait\n"
530 "is false and the operation is still pending then an error is raised.");
531
532 #define _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF \
533 {"getresult", _PyCFunction_CAST(_overlapped_Overlapped_getresult), METH_FASTCALL, _overlapped_Overlapped_getresult__doc__},
534
535 static PyObject *
536 _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait);
537
538 static PyObject *
_overlapped_Overlapped_getresult(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)539 _overlapped_Overlapped_getresult(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
540 {
541 PyObject *return_value = NULL;
542 BOOL wait = FALSE;
543
544 if (!_PyArg_CheckPositional("getresult", nargs, 0, 1)) {
545 goto exit;
546 }
547 if (nargs < 1) {
548 goto skip_optional;
549 }
550 wait = PyLong_AsInt(args[0]);
551 if (wait == -1 && PyErr_Occurred()) {
552 goto exit;
553 }
554 skip_optional:
555 return_value = _overlapped_Overlapped_getresult_impl(self, wait);
556
557 exit:
558 return return_value;
559 }
560
561 PyDoc_STRVAR(_overlapped_Overlapped_ReadFile__doc__,
562 "ReadFile($self, handle, size, /)\n"
563 "--\n"
564 "\n"
565 "Start overlapped read.");
566
567 #define _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF \
568 {"ReadFile", _PyCFunction_CAST(_overlapped_Overlapped_ReadFile), METH_FASTCALL, _overlapped_Overlapped_ReadFile__doc__},
569
570 static PyObject *
571 _overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
572 DWORD size);
573
574 static PyObject *
_overlapped_Overlapped_ReadFile(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)575 _overlapped_Overlapped_ReadFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
576 {
577 PyObject *return_value = NULL;
578 HANDLE handle;
579 DWORD size;
580
581 if (!_PyArg_CheckPositional("ReadFile", nargs, 2, 2)) {
582 goto exit;
583 }
584 handle = PyLong_AsVoidPtr(args[0]);
585 if (!handle && PyErr_Occurred()) {
586 goto exit;
587 }
588 if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
589 goto exit;
590 }
591 return_value = _overlapped_Overlapped_ReadFile_impl(self, handle, size);
592
593 exit:
594 return return_value;
595 }
596
597 PyDoc_STRVAR(_overlapped_Overlapped_ReadFileInto__doc__,
598 "ReadFileInto($self, handle, buf, /)\n"
599 "--\n"
600 "\n"
601 "Start overlapped receive.");
602
603 #define _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF \
604 {"ReadFileInto", _PyCFunction_CAST(_overlapped_Overlapped_ReadFileInto), METH_FASTCALL, _overlapped_Overlapped_ReadFileInto__doc__},
605
606 static PyObject *
607 _overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
608 HANDLE handle, Py_buffer *bufobj);
609
610 static PyObject *
_overlapped_Overlapped_ReadFileInto(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)611 _overlapped_Overlapped_ReadFileInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
612 {
613 PyObject *return_value = NULL;
614 HANDLE handle;
615 Py_buffer bufobj = {NULL, NULL};
616
617 if (!_PyArg_CheckPositional("ReadFileInto", nargs, 2, 2)) {
618 goto exit;
619 }
620 handle = PyLong_AsVoidPtr(args[0]);
621 if (!handle && PyErr_Occurred()) {
622 goto exit;
623 }
624 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
625 goto exit;
626 }
627 return_value = _overlapped_Overlapped_ReadFileInto_impl(self, handle, &bufobj);
628
629 exit:
630 /* Cleanup for bufobj */
631 if (bufobj.obj) {
632 PyBuffer_Release(&bufobj);
633 }
634
635 return return_value;
636 }
637
638 PyDoc_STRVAR(_overlapped_Overlapped_WSARecv__doc__,
639 "WSARecv($self, handle, size, flags=0, /)\n"
640 "--\n"
641 "\n"
642 "Start overlapped receive.");
643
644 #define _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF \
645 {"WSARecv", _PyCFunction_CAST(_overlapped_Overlapped_WSARecv), METH_FASTCALL, _overlapped_Overlapped_WSARecv__doc__},
646
647 static PyObject *
648 _overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
649 DWORD size, DWORD flags);
650
651 static PyObject *
_overlapped_Overlapped_WSARecv(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)652 _overlapped_Overlapped_WSARecv(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
653 {
654 PyObject *return_value = NULL;
655 HANDLE handle;
656 DWORD size;
657 DWORD flags = 0;
658
659 if (!_PyArg_CheckPositional("WSARecv", nargs, 2, 3)) {
660 goto exit;
661 }
662 handle = PyLong_AsVoidPtr(args[0]);
663 if (!handle && PyErr_Occurred()) {
664 goto exit;
665 }
666 if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
667 goto exit;
668 }
669 if (nargs < 3) {
670 goto skip_optional;
671 }
672 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
673 goto exit;
674 }
675 skip_optional:
676 return_value = _overlapped_Overlapped_WSARecv_impl(self, handle, size, flags);
677
678 exit:
679 return return_value;
680 }
681
682 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvInto__doc__,
683 "WSARecvInto($self, handle, buf, flags, /)\n"
684 "--\n"
685 "\n"
686 "Start overlapped receive.");
687
688 #define _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF \
689 {"WSARecvInto", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvInto), METH_FASTCALL, _overlapped_Overlapped_WSARecvInto__doc__},
690
691 static PyObject *
692 _overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
693 HANDLE handle, Py_buffer *bufobj,
694 DWORD flags);
695
696 static PyObject *
_overlapped_Overlapped_WSARecvInto(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)697 _overlapped_Overlapped_WSARecvInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
698 {
699 PyObject *return_value = NULL;
700 HANDLE handle;
701 Py_buffer bufobj = {NULL, NULL};
702 DWORD flags;
703
704 if (!_PyArg_CheckPositional("WSARecvInto", nargs, 3, 3)) {
705 goto exit;
706 }
707 handle = PyLong_AsVoidPtr(args[0]);
708 if (!handle && PyErr_Occurred()) {
709 goto exit;
710 }
711 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
712 goto exit;
713 }
714 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
715 goto exit;
716 }
717 return_value = _overlapped_Overlapped_WSARecvInto_impl(self, handle, &bufobj, flags);
718
719 exit:
720 /* Cleanup for bufobj */
721 if (bufobj.obj) {
722 PyBuffer_Release(&bufobj);
723 }
724
725 return return_value;
726 }
727
728 PyDoc_STRVAR(_overlapped_Overlapped_WriteFile__doc__,
729 "WriteFile($self, handle, buf, /)\n"
730 "--\n"
731 "\n"
732 "Start overlapped write.");
733
734 #define _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF \
735 {"WriteFile", _PyCFunction_CAST(_overlapped_Overlapped_WriteFile), METH_FASTCALL, _overlapped_Overlapped_WriteFile__doc__},
736
737 static PyObject *
738 _overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
739 Py_buffer *bufobj);
740
741 static PyObject *
_overlapped_Overlapped_WriteFile(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)742 _overlapped_Overlapped_WriteFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
743 {
744 PyObject *return_value = NULL;
745 HANDLE handle;
746 Py_buffer bufobj = {NULL, NULL};
747
748 if (!_PyArg_CheckPositional("WriteFile", nargs, 2, 2)) {
749 goto exit;
750 }
751 handle = PyLong_AsVoidPtr(args[0]);
752 if (!handle && PyErr_Occurred()) {
753 goto exit;
754 }
755 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
756 goto exit;
757 }
758 return_value = _overlapped_Overlapped_WriteFile_impl(self, handle, &bufobj);
759
760 exit:
761 /* Cleanup for bufobj */
762 if (bufobj.obj) {
763 PyBuffer_Release(&bufobj);
764 }
765
766 return return_value;
767 }
768
769 PyDoc_STRVAR(_overlapped_Overlapped_WSASend__doc__,
770 "WSASend($self, handle, buf, flags, /)\n"
771 "--\n"
772 "\n"
773 "Start overlapped send.");
774
775 #define _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF \
776 {"WSASend", _PyCFunction_CAST(_overlapped_Overlapped_WSASend), METH_FASTCALL, _overlapped_Overlapped_WSASend__doc__},
777
778 static PyObject *
779 _overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
780 Py_buffer *bufobj, DWORD flags);
781
782 static PyObject *
_overlapped_Overlapped_WSASend(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)783 _overlapped_Overlapped_WSASend(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
784 {
785 PyObject *return_value = NULL;
786 HANDLE handle;
787 Py_buffer bufobj = {NULL, NULL};
788 DWORD flags;
789
790 if (!_PyArg_CheckPositional("WSASend", nargs, 3, 3)) {
791 goto exit;
792 }
793 handle = PyLong_AsVoidPtr(args[0]);
794 if (!handle && PyErr_Occurred()) {
795 goto exit;
796 }
797 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
798 goto exit;
799 }
800 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
801 goto exit;
802 }
803 return_value = _overlapped_Overlapped_WSASend_impl(self, handle, &bufobj, flags);
804
805 exit:
806 /* Cleanup for bufobj */
807 if (bufobj.obj) {
808 PyBuffer_Release(&bufobj);
809 }
810
811 return return_value;
812 }
813
814 PyDoc_STRVAR(_overlapped_Overlapped_AcceptEx__doc__,
815 "AcceptEx($self, listen_handle, accept_handle, /)\n"
816 "--\n"
817 "\n"
818 "Start overlapped wait for client to connect.");
819
820 #define _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF \
821 {"AcceptEx", _PyCFunction_CAST(_overlapped_Overlapped_AcceptEx), METH_FASTCALL, _overlapped_Overlapped_AcceptEx__doc__},
822
823 static PyObject *
824 _overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
825 HANDLE ListenSocket,
826 HANDLE AcceptSocket);
827
828 static PyObject *
_overlapped_Overlapped_AcceptEx(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)829 _overlapped_Overlapped_AcceptEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
830 {
831 PyObject *return_value = NULL;
832 HANDLE ListenSocket;
833 HANDLE AcceptSocket;
834
835 if (!_PyArg_CheckPositional("AcceptEx", nargs, 2, 2)) {
836 goto exit;
837 }
838 ListenSocket = PyLong_AsVoidPtr(args[0]);
839 if (!ListenSocket && PyErr_Occurred()) {
840 goto exit;
841 }
842 AcceptSocket = PyLong_AsVoidPtr(args[1]);
843 if (!AcceptSocket && PyErr_Occurred()) {
844 goto exit;
845 }
846 return_value = _overlapped_Overlapped_AcceptEx_impl(self, ListenSocket, AcceptSocket);
847
848 exit:
849 return return_value;
850 }
851
852 PyDoc_STRVAR(_overlapped_Overlapped_ConnectEx__doc__,
853 "ConnectEx($self, client_handle, address_as_bytes, /)\n"
854 "--\n"
855 "\n"
856 "Start overlapped connect.\n"
857 "\n"
858 "client_handle should be unbound.");
859
860 #define _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF \
861 {"ConnectEx", _PyCFunction_CAST(_overlapped_Overlapped_ConnectEx), METH_FASTCALL, _overlapped_Overlapped_ConnectEx__doc__},
862
863 static PyObject *
864 _overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
865 HANDLE ConnectSocket,
866 PyObject *AddressObj);
867
868 static PyObject *
_overlapped_Overlapped_ConnectEx(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)869 _overlapped_Overlapped_ConnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
870 {
871 PyObject *return_value = NULL;
872 HANDLE ConnectSocket;
873 PyObject *AddressObj;
874
875 if (!_PyArg_CheckPositional("ConnectEx", nargs, 2, 2)) {
876 goto exit;
877 }
878 ConnectSocket = PyLong_AsVoidPtr(args[0]);
879 if (!ConnectSocket && PyErr_Occurred()) {
880 goto exit;
881 }
882 if (!PyTuple_Check(args[1])) {
883 _PyArg_BadArgument("ConnectEx", "argument 2", "tuple", args[1]);
884 goto exit;
885 }
886 AddressObj = args[1];
887 return_value = _overlapped_Overlapped_ConnectEx_impl(self, ConnectSocket, AddressObj);
888
889 exit:
890 return return_value;
891 }
892
893 PyDoc_STRVAR(_overlapped_Overlapped_DisconnectEx__doc__,
894 "DisconnectEx($self, handle, flags, /)\n"
895 "--\n"
896 "\n");
897
898 #define _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF \
899 {"DisconnectEx", _PyCFunction_CAST(_overlapped_Overlapped_DisconnectEx), METH_FASTCALL, _overlapped_Overlapped_DisconnectEx__doc__},
900
901 static PyObject *
902 _overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
903 HANDLE Socket, DWORD flags);
904
905 static PyObject *
_overlapped_Overlapped_DisconnectEx(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)906 _overlapped_Overlapped_DisconnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
907 {
908 PyObject *return_value = NULL;
909 HANDLE Socket;
910 DWORD flags;
911
912 if (!_PyArg_CheckPositional("DisconnectEx", nargs, 2, 2)) {
913 goto exit;
914 }
915 Socket = PyLong_AsVoidPtr(args[0]);
916 if (!Socket && PyErr_Occurred()) {
917 goto exit;
918 }
919 if (!_PyLong_UnsignedLong_Converter(args[1], &flags)) {
920 goto exit;
921 }
922 return_value = _overlapped_Overlapped_DisconnectEx_impl(self, Socket, flags);
923
924 exit:
925 return return_value;
926 }
927
928 PyDoc_STRVAR(_overlapped_Overlapped_TransmitFile__doc__,
929 "TransmitFile($self, socket, file, offset, offset_high, count_to_write,\n"
930 " count_per_send, flags, /)\n"
931 "--\n"
932 "\n"
933 "Transmit file data over a connected socket.");
934
935 #define _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF \
936 {"TransmitFile", _PyCFunction_CAST(_overlapped_Overlapped_TransmitFile), METH_FASTCALL, _overlapped_Overlapped_TransmitFile__doc__},
937
938 static PyObject *
939 _overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
940 HANDLE Socket, HANDLE File,
941 DWORD offset, DWORD offset_high,
942 DWORD count_to_write,
943 DWORD count_per_send, DWORD flags);
944
945 static PyObject *
_overlapped_Overlapped_TransmitFile(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)946 _overlapped_Overlapped_TransmitFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
947 {
948 PyObject *return_value = NULL;
949 HANDLE Socket;
950 HANDLE File;
951 DWORD offset;
952 DWORD offset_high;
953 DWORD count_to_write;
954 DWORD count_per_send;
955 DWORD flags;
956
957 if (!_PyArg_CheckPositional("TransmitFile", nargs, 7, 7)) {
958 goto exit;
959 }
960 Socket = PyLong_AsVoidPtr(args[0]);
961 if (!Socket && PyErr_Occurred()) {
962 goto exit;
963 }
964 File = PyLong_AsVoidPtr(args[1]);
965 if (!File && PyErr_Occurred()) {
966 goto exit;
967 }
968 if (!_PyLong_UnsignedLong_Converter(args[2], &offset)) {
969 goto exit;
970 }
971 if (!_PyLong_UnsignedLong_Converter(args[3], &offset_high)) {
972 goto exit;
973 }
974 if (!_PyLong_UnsignedLong_Converter(args[4], &count_to_write)) {
975 goto exit;
976 }
977 if (!_PyLong_UnsignedLong_Converter(args[5], &count_per_send)) {
978 goto exit;
979 }
980 if (!_PyLong_UnsignedLong_Converter(args[6], &flags)) {
981 goto exit;
982 }
983 return_value = _overlapped_Overlapped_TransmitFile_impl(self, Socket, File, offset, offset_high, count_to_write, count_per_send, flags);
984
985 exit:
986 return return_value;
987 }
988
989 PyDoc_STRVAR(_overlapped_Overlapped_ConnectNamedPipe__doc__,
990 "ConnectNamedPipe($self, handle, /)\n"
991 "--\n"
992 "\n"
993 "Start overlapped wait for a client to connect.");
994
995 #define _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF \
996 {"ConnectNamedPipe", (PyCFunction)_overlapped_Overlapped_ConnectNamedPipe, METH_O, _overlapped_Overlapped_ConnectNamedPipe__doc__},
997
998 static PyObject *
999 _overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
1000 HANDLE Pipe);
1001
1002 static PyObject *
_overlapped_Overlapped_ConnectNamedPipe(OverlappedObject * self,PyObject * arg)1003 _overlapped_Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *arg)
1004 {
1005 PyObject *return_value = NULL;
1006 HANDLE Pipe;
1007
1008 Pipe = PyLong_AsVoidPtr(arg);
1009 if (!Pipe && PyErr_Occurred()) {
1010 goto exit;
1011 }
1012 return_value = _overlapped_Overlapped_ConnectNamedPipe_impl(self, Pipe);
1013
1014 exit:
1015 return return_value;
1016 }
1017
1018 PyDoc_STRVAR(_overlapped_Overlapped_ConnectPipe__doc__,
1019 "ConnectPipe($self, addr, /)\n"
1020 "--\n"
1021 "\n"
1022 "Connect to the pipe for asynchronous I/O (overlapped).");
1023
1024 #define _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF \
1025 {"ConnectPipe", (PyCFunction)_overlapped_Overlapped_ConnectPipe, METH_O, _overlapped_Overlapped_ConnectPipe__doc__},
1026
1027 static PyObject *
1028 _overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
1029 const wchar_t *Address);
1030
1031 static PyObject *
_overlapped_Overlapped_ConnectPipe(OverlappedObject * self,PyObject * arg)1032 _overlapped_Overlapped_ConnectPipe(OverlappedObject *self, PyObject *arg)
1033 {
1034 PyObject *return_value = NULL;
1035 const wchar_t *Address = NULL;
1036
1037 if (!PyUnicode_Check(arg)) {
1038 _PyArg_BadArgument("ConnectPipe", "argument", "str", arg);
1039 goto exit;
1040 }
1041 Address = PyUnicode_AsWideCharString(arg, NULL);
1042 if (Address == NULL) {
1043 goto exit;
1044 }
1045 return_value = _overlapped_Overlapped_ConnectPipe_impl(self, Address);
1046
1047 exit:
1048 /* Cleanup for Address */
1049 PyMem_Free((void *)Address);
1050
1051 return return_value;
1052 }
1053
1054 PyDoc_STRVAR(_overlapped_WSAConnect__doc__,
1055 "WSAConnect($module, client_handle, address_as_bytes, /)\n"
1056 "--\n"
1057 "\n"
1058 "Bind a remote address to a connectionless (UDP) socket.");
1059
1060 #define _OVERLAPPED_WSACONNECT_METHODDEF \
1061 {"WSAConnect", _PyCFunction_CAST(_overlapped_WSAConnect), METH_FASTCALL, _overlapped_WSAConnect__doc__},
1062
1063 static PyObject *
1064 _overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
1065 PyObject *AddressObj);
1066
1067 static PyObject *
_overlapped_WSAConnect(PyObject * module,PyObject * const * args,Py_ssize_t nargs)1068 _overlapped_WSAConnect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1069 {
1070 PyObject *return_value = NULL;
1071 HANDLE ConnectSocket;
1072 PyObject *AddressObj;
1073
1074 if (!_PyArg_CheckPositional("WSAConnect", nargs, 2, 2)) {
1075 goto exit;
1076 }
1077 ConnectSocket = PyLong_AsVoidPtr(args[0]);
1078 if (!ConnectSocket && PyErr_Occurred()) {
1079 goto exit;
1080 }
1081 if (!PyTuple_Check(args[1])) {
1082 _PyArg_BadArgument("WSAConnect", "argument 2", "tuple", args[1]);
1083 goto exit;
1084 }
1085 AddressObj = args[1];
1086 return_value = _overlapped_WSAConnect_impl(module, ConnectSocket, AddressObj);
1087
1088 exit:
1089 return return_value;
1090 }
1091
1092 PyDoc_STRVAR(_overlapped_Overlapped_WSASendTo__doc__,
1093 "WSASendTo($self, handle, buf, flags, address_as_bytes, /)\n"
1094 "--\n"
1095 "\n"
1096 "Start overlapped sendto over a connectionless (UDP) socket.");
1097
1098 #define _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF \
1099 {"WSASendTo", _PyCFunction_CAST(_overlapped_Overlapped_WSASendTo), METH_FASTCALL, _overlapped_Overlapped_WSASendTo__doc__},
1100
1101 static PyObject *
1102 _overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
1103 Py_buffer *bufobj, DWORD flags,
1104 PyObject *AddressObj);
1105
1106 static PyObject *
_overlapped_Overlapped_WSASendTo(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)1107 _overlapped_Overlapped_WSASendTo(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
1108 {
1109 PyObject *return_value = NULL;
1110 HANDLE handle;
1111 Py_buffer bufobj = {NULL, NULL};
1112 DWORD flags;
1113 PyObject *AddressObj;
1114
1115 if (!_PyArg_CheckPositional("WSASendTo", nargs, 4, 4)) {
1116 goto exit;
1117 }
1118 handle = PyLong_AsVoidPtr(args[0]);
1119 if (!handle && PyErr_Occurred()) {
1120 goto exit;
1121 }
1122 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
1123 goto exit;
1124 }
1125 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
1126 goto exit;
1127 }
1128 if (!PyTuple_Check(args[3])) {
1129 _PyArg_BadArgument("WSASendTo", "argument 4", "tuple", args[3]);
1130 goto exit;
1131 }
1132 AddressObj = args[3];
1133 return_value = _overlapped_Overlapped_WSASendTo_impl(self, handle, &bufobj, flags, AddressObj);
1134
1135 exit:
1136 /* Cleanup for bufobj */
1137 if (bufobj.obj) {
1138 PyBuffer_Release(&bufobj);
1139 }
1140
1141 return return_value;
1142 }
1143
1144 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFrom__doc__,
1145 "WSARecvFrom($self, handle, size, flags=0, /)\n"
1146 "--\n"
1147 "\n"
1148 "Start overlapped receive.");
1149
1150 #define _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF \
1151 {"WSARecvFrom", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvFrom), METH_FASTCALL, _overlapped_Overlapped_WSARecvFrom__doc__},
1152
1153 static PyObject *
1154 _overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
1155 HANDLE handle, DWORD size,
1156 DWORD flags);
1157
1158 static PyObject *
_overlapped_Overlapped_WSARecvFrom(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)1159 _overlapped_Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
1160 {
1161 PyObject *return_value = NULL;
1162 HANDLE handle;
1163 DWORD size;
1164 DWORD flags = 0;
1165
1166 if (!_PyArg_CheckPositional("WSARecvFrom", nargs, 2, 3)) {
1167 goto exit;
1168 }
1169 handle = PyLong_AsVoidPtr(args[0]);
1170 if (!handle && PyErr_Occurred()) {
1171 goto exit;
1172 }
1173 if (!_PyLong_UnsignedLong_Converter(args[1], &size)) {
1174 goto exit;
1175 }
1176 if (nargs < 3) {
1177 goto skip_optional;
1178 }
1179 if (!_PyLong_UnsignedLong_Converter(args[2], &flags)) {
1180 goto exit;
1181 }
1182 skip_optional:
1183 return_value = _overlapped_Overlapped_WSARecvFrom_impl(self, handle, size, flags);
1184
1185 exit:
1186 return return_value;
1187 }
1188
1189 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFromInto__doc__,
1190 "WSARecvFromInto($self, handle, buf, size, flags=0, /)\n"
1191 "--\n"
1192 "\n"
1193 "Start overlapped receive.");
1194
1195 #define _OVERLAPPED_OVERLAPPED_WSARECVFROMINTO_METHODDEF \
1196 {"WSARecvFromInto", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvFromInto), METH_FASTCALL, _overlapped_Overlapped_WSARecvFromInto__doc__},
1197
1198 static PyObject *
1199 _overlapped_Overlapped_WSARecvFromInto_impl(OverlappedObject *self,
1200 HANDLE handle, Py_buffer *bufobj,
1201 DWORD size, DWORD flags);
1202
1203 static PyObject *
_overlapped_Overlapped_WSARecvFromInto(OverlappedObject * self,PyObject * const * args,Py_ssize_t nargs)1204 _overlapped_Overlapped_WSARecvFromInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
1205 {
1206 PyObject *return_value = NULL;
1207 HANDLE handle;
1208 Py_buffer bufobj = {NULL, NULL};
1209 DWORD size;
1210 DWORD flags = 0;
1211
1212 if (!_PyArg_CheckPositional("WSARecvFromInto", nargs, 3, 4)) {
1213 goto exit;
1214 }
1215 handle = PyLong_AsVoidPtr(args[0]);
1216 if (!handle && PyErr_Occurred()) {
1217 goto exit;
1218 }
1219 if (PyObject_GetBuffer(args[1], &bufobj, PyBUF_SIMPLE) != 0) {
1220 goto exit;
1221 }
1222 if (!_PyLong_UnsignedLong_Converter(args[2], &size)) {
1223 goto exit;
1224 }
1225 if (nargs < 4) {
1226 goto skip_optional;
1227 }
1228 if (!_PyLong_UnsignedLong_Converter(args[3], &flags)) {
1229 goto exit;
1230 }
1231 skip_optional:
1232 return_value = _overlapped_Overlapped_WSARecvFromInto_impl(self, handle, &bufobj, size, flags);
1233
1234 exit:
1235 /* Cleanup for bufobj */
1236 if (bufobj.obj) {
1237 PyBuffer_Release(&bufobj);
1238 }
1239
1240 return return_value;
1241 }
1242 /*[clinic end generated code: output=958cbddbcc355f47 input=a9049054013a1b77]*/
1243