1 /*[clinic input]
2 preserve
3 [clinic start generated code]*/
4
5 PyDoc_STRVAR(_overlapped_CreateIoCompletionPort__doc__,
6 "CreateIoCompletionPort($module, handle, port, key, concurrency, /)\n"
7 "--\n"
8 "\n"
9 "Create a completion port or register a handle with a port.");
10
11 #define _OVERLAPPED_CREATEIOCOMPLETIONPORT_METHODDEF \
12 {"CreateIoCompletionPort", _PyCFunction_CAST(_overlapped_CreateIoCompletionPort), METH_FASTCALL, _overlapped_CreateIoCompletionPort__doc__},
13
14 static PyObject *
15 _overlapped_CreateIoCompletionPort_impl(PyObject *module, HANDLE FileHandle,
16 HANDLE ExistingCompletionPort,
17 ULONG_PTR CompletionKey,
18 DWORD NumberOfConcurrentThreads);
19
20 static PyObject *
21 _overlapped_CreateIoCompletionPort(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
22 {
23 PyObject *return_value = NULL;
24 HANDLE FileHandle;
25 HANDLE ExistingCompletionPort;
26 ULONG_PTR CompletionKey;
27 DWORD NumberOfConcurrentThreads;
28
29 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_ULONG_PTR"k:CreateIoCompletionPort",
30 &FileHandle, &ExistingCompletionPort, &CompletionKey, &NumberOfConcurrentThreads)) {
31 goto exit;
32 }
33 return_value = _overlapped_CreateIoCompletionPort_impl(module, FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads);
34
35 exit:
36 return return_value;
37 }
38
39 PyDoc_STRVAR(_overlapped_GetQueuedCompletionStatus__doc__,
40 "GetQueuedCompletionStatus($module, port, msecs, /)\n"
41 "--\n"
42 "\n"
43 "Get a message from completion port.\n"
44 "\n"
45 "Wait for up to msecs milliseconds.");
46
47 #define _OVERLAPPED_GETQUEUEDCOMPLETIONSTATUS_METHODDEF \
48 {"GetQueuedCompletionStatus", _PyCFunction_CAST(_overlapped_GetQueuedCompletionStatus), METH_FASTCALL, _overlapped_GetQueuedCompletionStatus__doc__},
49
50 static PyObject *
51 _overlapped_GetQueuedCompletionStatus_impl(PyObject *module,
52 HANDLE CompletionPort,
53 DWORD Milliseconds);
54
55 static PyObject *
56 _overlapped_GetQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
57 {
58 PyObject *return_value = NULL;
59 HANDLE CompletionPort;
60 DWORD Milliseconds;
61
62 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:GetQueuedCompletionStatus",
63 &CompletionPort, &Milliseconds)) {
64 goto exit;
65 }
66 return_value = _overlapped_GetQueuedCompletionStatus_impl(module, CompletionPort, Milliseconds);
67
68 exit:
69 return return_value;
70 }
71
72 PyDoc_STRVAR(_overlapped_PostQueuedCompletionStatus__doc__,
73 "PostQueuedCompletionStatus($module, port, bytes, key, address, /)\n"
74 "--\n"
75 "\n"
76 "Post a message to completion port.");
77
78 #define _OVERLAPPED_POSTQUEUEDCOMPLETIONSTATUS_METHODDEF \
79 {"PostQueuedCompletionStatus", _PyCFunction_CAST(_overlapped_PostQueuedCompletionStatus), METH_FASTCALL, _overlapped_PostQueuedCompletionStatus__doc__},
80
81 static PyObject *
82 _overlapped_PostQueuedCompletionStatus_impl(PyObject *module,
83 HANDLE CompletionPort,
84 DWORD NumberOfBytes,
85 ULONG_PTR CompletionKey,
86 OVERLAPPED *Overlapped);
87
88 static PyObject *
89 _overlapped_PostQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
90 {
91 PyObject *return_value = NULL;
92 HANDLE CompletionPort;
93 DWORD NumberOfBytes;
94 ULONG_PTR CompletionKey;
95 OVERLAPPED *Overlapped;
96
97 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k"F_ULONG_PTR""F_POINTER":PostQueuedCompletionStatus",
98 &CompletionPort, &NumberOfBytes, &CompletionKey, &Overlapped)) {
99 goto exit;
100 }
101 return_value = _overlapped_PostQueuedCompletionStatus_impl(module, CompletionPort, NumberOfBytes, CompletionKey, Overlapped);
102
103 exit:
104 return return_value;
105 }
106
107 PyDoc_STRVAR(_overlapped_RegisterWaitWithQueue__doc__,
108 "RegisterWaitWithQueue($module, Object, CompletionPort, Overlapped,\n"
109 " Timeout, /)\n"
110 "--\n"
111 "\n"
112 "Register wait for Object; when complete CompletionPort is notified.");
113
114 #define _OVERLAPPED_REGISTERWAITWITHQUEUE_METHODDEF \
115 {"RegisterWaitWithQueue", _PyCFunction_CAST(_overlapped_RegisterWaitWithQueue), METH_FASTCALL, _overlapped_RegisterWaitWithQueue__doc__},
116
117 static PyObject *
118 _overlapped_RegisterWaitWithQueue_impl(PyObject *module, HANDLE Object,
119 HANDLE CompletionPort,
120 OVERLAPPED *Overlapped,
121 DWORD Milliseconds);
122
123 static PyObject *
124 _overlapped_RegisterWaitWithQueue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
125 {
126 PyObject *return_value = NULL;
127 HANDLE Object;
128 HANDLE CompletionPort;
129 OVERLAPPED *Overlapped;
130 DWORD Milliseconds;
131
132 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_POINTER"k:RegisterWaitWithQueue",
133 &Object, &CompletionPort, &Overlapped, &Milliseconds)) {
134 goto exit;
135 }
136 return_value = _overlapped_RegisterWaitWithQueue_impl(module, Object, CompletionPort, Overlapped, Milliseconds);
137
138 exit:
139 return return_value;
140 }
141
142 PyDoc_STRVAR(_overlapped_UnregisterWait__doc__,
143 "UnregisterWait($module, WaitHandle, /)\n"
144 "--\n"
145 "\n"
146 "Unregister wait handle.");
147
148 #define _OVERLAPPED_UNREGISTERWAIT_METHODDEF \
149 {"UnregisterWait", (PyCFunction)_overlapped_UnregisterWait, METH_O, _overlapped_UnregisterWait__doc__},
150
151 static PyObject *
152 _overlapped_UnregisterWait_impl(PyObject *module, HANDLE WaitHandle);
153
154 static PyObject *
155 _overlapped_UnregisterWait(PyObject *module, PyObject *arg)
156 {
157 PyObject *return_value = NULL;
158 HANDLE WaitHandle;
159
160 if (!PyArg_Parse(arg, ""F_HANDLE":UnregisterWait", &WaitHandle)) {
161 goto exit;
162 }
163 return_value = _overlapped_UnregisterWait_impl(module, WaitHandle);
164
165 exit:
166 return return_value;
167 }
168
169 PyDoc_STRVAR(_overlapped_UnregisterWaitEx__doc__,
170 "UnregisterWaitEx($module, WaitHandle, Event, /)\n"
171 "--\n"
172 "\n"
173 "Unregister wait handle.");
174
175 #define _OVERLAPPED_UNREGISTERWAITEX_METHODDEF \
176 {"UnregisterWaitEx", _PyCFunction_CAST(_overlapped_UnregisterWaitEx), METH_FASTCALL, _overlapped_UnregisterWaitEx__doc__},
177
178 static PyObject *
179 _overlapped_UnregisterWaitEx_impl(PyObject *module, HANDLE WaitHandle,
180 HANDLE Event);
181
182 static PyObject *
183 _overlapped_UnregisterWaitEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
184 {
185 PyObject *return_value = NULL;
186 HANDLE WaitHandle;
187 HANDLE Event;
188
189 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":UnregisterWaitEx",
190 &WaitHandle, &Event)) {
191 goto exit;
192 }
193 return_value = _overlapped_UnregisterWaitEx_impl(module, WaitHandle, Event);
194
195 exit:
196 return return_value;
197 }
198
199 PyDoc_STRVAR(_overlapped_CreateEvent__doc__,
200 "CreateEvent($module, EventAttributes, ManualReset, InitialState, Name,\n"
201 " /)\n"
202 "--\n"
203 "\n"
204 "Create an event.\n"
205 "\n"
206 "EventAttributes must be None.");
207
208 #define _OVERLAPPED_CREATEEVENT_METHODDEF \
209 {"CreateEvent", _PyCFunction_CAST(_overlapped_CreateEvent), METH_FASTCALL, _overlapped_CreateEvent__doc__},
210
211 static PyObject *
212 _overlapped_CreateEvent_impl(PyObject *module, PyObject *EventAttributes,
213 BOOL ManualReset, BOOL InitialState,
214 const Py_UNICODE *Name);
215
216 static PyObject *
217 _overlapped_CreateEvent(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
218 {
219 PyObject *return_value = NULL;
220 PyObject *EventAttributes;
221 BOOL ManualReset;
222 BOOL InitialState;
223 const Py_UNICODE *Name = NULL;
224
225 if (!_PyArg_ParseStack(args, nargs, "OiiO&:CreateEvent",
226 &EventAttributes, &ManualReset, &InitialState, _PyUnicode_WideCharString_Opt_Converter, &Name)) {
227 goto exit;
228 }
229 return_value = _overlapped_CreateEvent_impl(module, EventAttributes, ManualReset, InitialState, Name);
230
231 exit:
232 /* Cleanup for Name */
233 #if !USE_UNICODE_WCHAR_CACHE
234 PyMem_Free((void *)Name);
235 #endif /* USE_UNICODE_WCHAR_CACHE */
236
237 return return_value;
238 }
239
240 PyDoc_STRVAR(_overlapped_SetEvent__doc__,
241 "SetEvent($module, Handle, /)\n"
242 "--\n"
243 "\n"
244 "Set event.");
245
246 #define _OVERLAPPED_SETEVENT_METHODDEF \
247 {"SetEvent", (PyCFunction)_overlapped_SetEvent, METH_O, _overlapped_SetEvent__doc__},
248
249 static PyObject *
250 _overlapped_SetEvent_impl(PyObject *module, HANDLE Handle);
251
252 static PyObject *
253 _overlapped_SetEvent(PyObject *module, PyObject *arg)
254 {
255 PyObject *return_value = NULL;
256 HANDLE Handle;
257
258 if (!PyArg_Parse(arg, ""F_HANDLE":SetEvent", &Handle)) {
259 goto exit;
260 }
261 return_value = _overlapped_SetEvent_impl(module, Handle);
262
263 exit:
264 return return_value;
265 }
266
267 PyDoc_STRVAR(_overlapped_ResetEvent__doc__,
268 "ResetEvent($module, Handle, /)\n"
269 "--\n"
270 "\n"
271 "Reset event.");
272
273 #define _OVERLAPPED_RESETEVENT_METHODDEF \
274 {"ResetEvent", (PyCFunction)_overlapped_ResetEvent, METH_O, _overlapped_ResetEvent__doc__},
275
276 static PyObject *
277 _overlapped_ResetEvent_impl(PyObject *module, HANDLE Handle);
278
279 static PyObject *
280 _overlapped_ResetEvent(PyObject *module, PyObject *arg)
281 {
282 PyObject *return_value = NULL;
283 HANDLE Handle;
284
285 if (!PyArg_Parse(arg, ""F_HANDLE":ResetEvent", &Handle)) {
286 goto exit;
287 }
288 return_value = _overlapped_ResetEvent_impl(module, Handle);
289
290 exit:
291 return return_value;
292 }
293
294 PyDoc_STRVAR(_overlapped_BindLocal__doc__,
295 "BindLocal($module, handle, family, /)\n"
296 "--\n"
297 "\n"
298 "Bind a socket handle to an arbitrary local port.\n"
299 "\n"
300 "family should be AF_INET or AF_INET6.");
301
302 #define _OVERLAPPED_BINDLOCAL_METHODDEF \
303 {"BindLocal", _PyCFunction_CAST(_overlapped_BindLocal), METH_FASTCALL, _overlapped_BindLocal__doc__},
304
305 static PyObject *
306 _overlapped_BindLocal_impl(PyObject *module, HANDLE Socket, int Family);
307
308 static PyObject *
309 _overlapped_BindLocal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
310 {
311 PyObject *return_value = NULL;
312 HANDLE Socket;
313 int Family;
314
315 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"i:BindLocal",
316 &Socket, &Family)) {
317 goto exit;
318 }
319 return_value = _overlapped_BindLocal_impl(module, Socket, Family);
320
321 exit:
322 return return_value;
323 }
324
325 PyDoc_STRVAR(_overlapped_FormatMessage__doc__,
326 "FormatMessage($module, error_code, /)\n"
327 "--\n"
328 "\n"
329 "Return error message for an error code.");
330
331 #define _OVERLAPPED_FORMATMESSAGE_METHODDEF \
332 {"FormatMessage", (PyCFunction)_overlapped_FormatMessage, METH_O, _overlapped_FormatMessage__doc__},
333
334 static PyObject *
335 _overlapped_FormatMessage_impl(PyObject *module, DWORD code);
336
337 static PyObject *
338 _overlapped_FormatMessage(PyObject *module, PyObject *arg)
339 {
340 PyObject *return_value = NULL;
341 DWORD code;
342
343 if (!PyArg_Parse(arg, "k:FormatMessage", &code)) {
344 goto exit;
345 }
346 return_value = _overlapped_FormatMessage_impl(module, code);
347
348 exit:
349 return return_value;
350 }
351
352 PyDoc_STRVAR(_overlapped_Overlapped__doc__,
353 "Overlapped(event=_overlapped.INVALID_HANDLE_VALUE)\n"
354 "--\n"
355 "\n"
356 "OVERLAPPED structure wrapper.");
357
358 static PyObject *
359 _overlapped_Overlapped_impl(PyTypeObject *type, HANDLE event);
360
361 static PyObject *
362 _overlapped_Overlapped(PyTypeObject *type, PyObject *args, PyObject *kwargs)
363 {
364 PyObject *return_value = NULL;
365 static const char * const _keywords[] = {"event", NULL};
366 static _PyArg_Parser _parser = {"|"F_HANDLE":Overlapped", _keywords, 0};
367 HANDLE event = INVALID_HANDLE_VALUE;
368
369 if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
370 &event)) {
371 goto exit;
372 }
373 return_value = _overlapped_Overlapped_impl(type, event);
374
375 exit:
376 return return_value;
377 }
378
379 PyDoc_STRVAR(_overlapped_Overlapped_cancel__doc__,
380 "cancel($self, /)\n"
381 "--\n"
382 "\n"
383 "Cancel overlapped operation.");
384
385 #define _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF \
386 {"cancel", (PyCFunction)_overlapped_Overlapped_cancel, METH_NOARGS, _overlapped_Overlapped_cancel__doc__},
387
388 static PyObject *
389 _overlapped_Overlapped_cancel_impl(OverlappedObject *self);
390
391 static PyObject *
392 _overlapped_Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
393 {
394 return _overlapped_Overlapped_cancel_impl(self);
395 }
396
397 PyDoc_STRVAR(_overlapped_Overlapped_getresult__doc__,
398 "getresult($self, wait=False, /)\n"
399 "--\n"
400 "\n"
401 "Retrieve result of operation.\n"
402 "\n"
403 "If wait is true then it blocks until the operation is finished. If wait\n"
404 "is false and the operation is still pending then an error is raised.");
405
406 #define _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF \
407 {"getresult", _PyCFunction_CAST(_overlapped_Overlapped_getresult), METH_FASTCALL, _overlapped_Overlapped_getresult__doc__},
408
409 static PyObject *
410 _overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait);
411
412 static PyObject *
413 _overlapped_Overlapped_getresult(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
414 {
415 PyObject *return_value = NULL;
416 BOOL wait = FALSE;
417
418 if (!_PyArg_ParseStack(args, nargs, "|i:getresult",
419 &wait)) {
420 goto exit;
421 }
422 return_value = _overlapped_Overlapped_getresult_impl(self, wait);
423
424 exit:
425 return return_value;
426 }
427
428 PyDoc_STRVAR(_overlapped_Overlapped_ReadFile__doc__,
429 "ReadFile($self, handle, size, /)\n"
430 "--\n"
431 "\n"
432 "Start overlapped read.");
433
434 #define _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF \
435 {"ReadFile", _PyCFunction_CAST(_overlapped_Overlapped_ReadFile), METH_FASTCALL, _overlapped_Overlapped_ReadFile__doc__},
436
437 static PyObject *
438 _overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
439 DWORD size);
440
441 static PyObject *
442 _overlapped_Overlapped_ReadFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
443 {
444 PyObject *return_value = NULL;
445 HANDLE handle;
446 DWORD size;
447
448 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:ReadFile",
449 &handle, &size)) {
450 goto exit;
451 }
452 return_value = _overlapped_Overlapped_ReadFile_impl(self, handle, size);
453
454 exit:
455 return return_value;
456 }
457
458 PyDoc_STRVAR(_overlapped_Overlapped_ReadFileInto__doc__,
459 "ReadFileInto($self, handle, buf, /)\n"
460 "--\n"
461 "\n"
462 "Start overlapped receive.");
463
464 #define _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF \
465 {"ReadFileInto", _PyCFunction_CAST(_overlapped_Overlapped_ReadFileInto), METH_FASTCALL, _overlapped_Overlapped_ReadFileInto__doc__},
466
467 static PyObject *
468 _overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
469 HANDLE handle, Py_buffer *bufobj);
470
471 static PyObject *
472 _overlapped_Overlapped_ReadFileInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
473 {
474 PyObject *return_value = NULL;
475 HANDLE handle;
476 Py_buffer bufobj = {NULL, NULL};
477
478 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*:ReadFileInto",
479 &handle, &bufobj)) {
480 goto exit;
481 }
482 return_value = _overlapped_Overlapped_ReadFileInto_impl(self, handle, &bufobj);
483
484 exit:
485 /* Cleanup for bufobj */
486 if (bufobj.obj) {
487 PyBuffer_Release(&bufobj);
488 }
489
490 return return_value;
491 }
492
493 PyDoc_STRVAR(_overlapped_Overlapped_WSARecv__doc__,
494 "WSARecv($self, handle, size, flags=0, /)\n"
495 "--\n"
496 "\n"
497 "Start overlapped receive.");
498
499 #define _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF \
500 {"WSARecv", _PyCFunction_CAST(_overlapped_Overlapped_WSARecv), METH_FASTCALL, _overlapped_Overlapped_WSARecv__doc__},
501
502 static PyObject *
503 _overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
504 DWORD size, DWORD flags);
505
506 static PyObject *
507 _overlapped_Overlapped_WSARecv(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
508 {
509 PyObject *return_value = NULL;
510 HANDLE handle;
511 DWORD size;
512 DWORD flags = 0;
513
514 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecv",
515 &handle, &size, &flags)) {
516 goto exit;
517 }
518 return_value = _overlapped_Overlapped_WSARecv_impl(self, handle, size, flags);
519
520 exit:
521 return return_value;
522 }
523
524 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvInto__doc__,
525 "WSARecvInto($self, handle, buf, flags, /)\n"
526 "--\n"
527 "\n"
528 "Start overlapped receive.");
529
530 #define _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF \
531 {"WSARecvInto", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvInto), METH_FASTCALL, _overlapped_Overlapped_WSARecvInto__doc__},
532
533 static PyObject *
534 _overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
535 HANDLE handle, Py_buffer *bufobj,
536 DWORD flags);
537
538 static PyObject *
539 _overlapped_Overlapped_WSARecvInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
540 {
541 PyObject *return_value = NULL;
542 HANDLE handle;
543 Py_buffer bufobj = {NULL, NULL};
544 DWORD flags;
545
546 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*k:WSARecvInto",
547 &handle, &bufobj, &flags)) {
548 goto exit;
549 }
550 return_value = _overlapped_Overlapped_WSARecvInto_impl(self, handle, &bufobj, flags);
551
552 exit:
553 /* Cleanup for bufobj */
554 if (bufobj.obj) {
555 PyBuffer_Release(&bufobj);
556 }
557
558 return return_value;
559 }
560
561 PyDoc_STRVAR(_overlapped_Overlapped_WriteFile__doc__,
562 "WriteFile($self, handle, buf, /)\n"
563 "--\n"
564 "\n"
565 "Start overlapped write.");
566
567 #define _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF \
568 {"WriteFile", _PyCFunction_CAST(_overlapped_Overlapped_WriteFile), METH_FASTCALL, _overlapped_Overlapped_WriteFile__doc__},
569
570 static PyObject *
571 _overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
572 Py_buffer *bufobj);
573
574 static PyObject *
575 _overlapped_Overlapped_WriteFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
576 {
577 PyObject *return_value = NULL;
578 HANDLE handle;
579 Py_buffer bufobj = {NULL, NULL};
580
581 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*:WriteFile",
582 &handle, &bufobj)) {
583 goto exit;
584 }
585 return_value = _overlapped_Overlapped_WriteFile_impl(self, handle, &bufobj);
586
587 exit:
588 /* Cleanup for bufobj */
589 if (bufobj.obj) {
590 PyBuffer_Release(&bufobj);
591 }
592
593 return return_value;
594 }
595
596 PyDoc_STRVAR(_overlapped_Overlapped_WSASend__doc__,
597 "WSASend($self, handle, buf, flags, /)\n"
598 "--\n"
599 "\n"
600 "Start overlapped send.");
601
602 #define _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF \
603 {"WSASend", _PyCFunction_CAST(_overlapped_Overlapped_WSASend), METH_FASTCALL, _overlapped_Overlapped_WSASend__doc__},
604
605 static PyObject *
606 _overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
607 Py_buffer *bufobj, DWORD flags);
608
609 static PyObject *
610 _overlapped_Overlapped_WSASend(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
611 {
612 PyObject *return_value = NULL;
613 HANDLE handle;
614 Py_buffer bufobj = {NULL, NULL};
615 DWORD flags;
616
617 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*k:WSASend",
618 &handle, &bufobj, &flags)) {
619 goto exit;
620 }
621 return_value = _overlapped_Overlapped_WSASend_impl(self, handle, &bufobj, flags);
622
623 exit:
624 /* Cleanup for bufobj */
625 if (bufobj.obj) {
626 PyBuffer_Release(&bufobj);
627 }
628
629 return return_value;
630 }
631
632 PyDoc_STRVAR(_overlapped_Overlapped_AcceptEx__doc__,
633 "AcceptEx($self, listen_handle, accept_handle, /)\n"
634 "--\n"
635 "\n"
636 "Start overlapped wait for client to connect.");
637
638 #define _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF \
639 {"AcceptEx", _PyCFunction_CAST(_overlapped_Overlapped_AcceptEx), METH_FASTCALL, _overlapped_Overlapped_AcceptEx__doc__},
640
641 static PyObject *
642 _overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
643 HANDLE ListenSocket,
644 HANDLE AcceptSocket);
645
646 static PyObject *
647 _overlapped_Overlapped_AcceptEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
648 {
649 PyObject *return_value = NULL;
650 HANDLE ListenSocket;
651 HANDLE AcceptSocket;
652
653 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":AcceptEx",
654 &ListenSocket, &AcceptSocket)) {
655 goto exit;
656 }
657 return_value = _overlapped_Overlapped_AcceptEx_impl(self, ListenSocket, AcceptSocket);
658
659 exit:
660 return return_value;
661 }
662
663 PyDoc_STRVAR(_overlapped_Overlapped_ConnectEx__doc__,
664 "ConnectEx($self, client_handle, address_as_bytes, /)\n"
665 "--\n"
666 "\n"
667 "Start overlapped connect.\n"
668 "\n"
669 "client_handle should be unbound.");
670
671 #define _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF \
672 {"ConnectEx", _PyCFunction_CAST(_overlapped_Overlapped_ConnectEx), METH_FASTCALL, _overlapped_Overlapped_ConnectEx__doc__},
673
674 static PyObject *
675 _overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
676 HANDLE ConnectSocket,
677 PyObject *AddressObj);
678
679 static PyObject *
680 _overlapped_Overlapped_ConnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
681 {
682 PyObject *return_value = NULL;
683 HANDLE ConnectSocket;
684 PyObject *AddressObj;
685
686 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O!:ConnectEx",
687 &ConnectSocket, &PyTuple_Type, &AddressObj)) {
688 goto exit;
689 }
690 return_value = _overlapped_Overlapped_ConnectEx_impl(self, ConnectSocket, AddressObj);
691
692 exit:
693 return return_value;
694 }
695
696 PyDoc_STRVAR(_overlapped_Overlapped_DisconnectEx__doc__,
697 "DisconnectEx($self, handle, flags, /)\n"
698 "--\n"
699 "\n");
700
701 #define _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF \
702 {"DisconnectEx", _PyCFunction_CAST(_overlapped_Overlapped_DisconnectEx), METH_FASTCALL, _overlapped_Overlapped_DisconnectEx__doc__},
703
704 static PyObject *
705 _overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
706 HANDLE Socket, DWORD flags);
707
708 static PyObject *
709 _overlapped_Overlapped_DisconnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
710 {
711 PyObject *return_value = NULL;
712 HANDLE Socket;
713 DWORD flags;
714
715 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:DisconnectEx",
716 &Socket, &flags)) {
717 goto exit;
718 }
719 return_value = _overlapped_Overlapped_DisconnectEx_impl(self, Socket, flags);
720
721 exit:
722 return return_value;
723 }
724
725 PyDoc_STRVAR(_overlapped_Overlapped_TransmitFile__doc__,
726 "TransmitFile($self, socket, file, offset, offset_high, count_to_write,\n"
727 " count_per_send, flags, /)\n"
728 "--\n"
729 "\n"
730 "Transmit file data over a connected socket.");
731
732 #define _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF \
733 {"TransmitFile", _PyCFunction_CAST(_overlapped_Overlapped_TransmitFile), METH_FASTCALL, _overlapped_Overlapped_TransmitFile__doc__},
734
735 static PyObject *
736 _overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
737 HANDLE Socket, HANDLE File,
738 DWORD offset, DWORD offset_high,
739 DWORD count_to_write,
740 DWORD count_per_send, DWORD flags);
741
742 static PyObject *
743 _overlapped_Overlapped_TransmitFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
744 {
745 PyObject *return_value = NULL;
746 HANDLE Socket;
747 HANDLE File;
748 DWORD offset;
749 DWORD offset_high;
750 DWORD count_to_write;
751 DWORD count_per_send;
752 DWORD flags;
753
754 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE"kkkkk:TransmitFile",
755 &Socket, &File, &offset, &offset_high, &count_to_write, &count_per_send, &flags)) {
756 goto exit;
757 }
758 return_value = _overlapped_Overlapped_TransmitFile_impl(self, Socket, File, offset, offset_high, count_to_write, count_per_send, flags);
759
760 exit:
761 return return_value;
762 }
763
764 PyDoc_STRVAR(_overlapped_Overlapped_ConnectNamedPipe__doc__,
765 "ConnectNamedPipe($self, handle, /)\n"
766 "--\n"
767 "\n"
768 "Start overlapped wait for a client to connect.");
769
770 #define _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF \
771 {"ConnectNamedPipe", (PyCFunction)_overlapped_Overlapped_ConnectNamedPipe, METH_O, _overlapped_Overlapped_ConnectNamedPipe__doc__},
772
773 static PyObject *
774 _overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
775 HANDLE Pipe);
776
777 static PyObject *
778 _overlapped_Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *arg)
779 {
780 PyObject *return_value = NULL;
781 HANDLE Pipe;
782
783 if (!PyArg_Parse(arg, ""F_HANDLE":ConnectNamedPipe", &Pipe)) {
784 goto exit;
785 }
786 return_value = _overlapped_Overlapped_ConnectNamedPipe_impl(self, Pipe);
787
788 exit:
789 return return_value;
790 }
791
792 PyDoc_STRVAR(_overlapped_Overlapped_ConnectPipe__doc__,
793 "ConnectPipe($self, addr, /)\n"
794 "--\n"
795 "\n"
796 "Connect to the pipe for asynchronous I/O (overlapped).");
797
798 #define _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF \
799 {"ConnectPipe", (PyCFunction)_overlapped_Overlapped_ConnectPipe, METH_O, _overlapped_Overlapped_ConnectPipe__doc__},
800
801 static PyObject *
802 _overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
803 const Py_UNICODE *Address);
804
805 static PyObject *
806 _overlapped_Overlapped_ConnectPipe(OverlappedObject *self, PyObject *arg)
807 {
808 PyObject *return_value = NULL;
809 const Py_UNICODE *Address = NULL;
810
811 if (!PyUnicode_Check(arg)) {
812 _PyArg_BadArgument("ConnectPipe", "argument", "str", arg);
813 goto exit;
814 }
815 #if USE_UNICODE_WCHAR_CACHE
816 Address = _PyUnicode_AsUnicode(arg);
817 #else /* USE_UNICODE_WCHAR_CACHE */
818 Address = PyUnicode_AsWideCharString(arg, NULL);
819 #endif /* USE_UNICODE_WCHAR_CACHE */
820 if (Address == NULL) {
821 goto exit;
822 }
823 return_value = _overlapped_Overlapped_ConnectPipe_impl(self, Address);
824
825 exit:
826 /* Cleanup for Address */
827 #if !USE_UNICODE_WCHAR_CACHE
828 PyMem_Free((void *)Address);
829 #endif /* USE_UNICODE_WCHAR_CACHE */
830
831 return return_value;
832 }
833
834 PyDoc_STRVAR(_overlapped_WSAConnect__doc__,
835 "WSAConnect($module, client_handle, address_as_bytes, /)\n"
836 "--\n"
837 "\n"
838 "Bind a remote address to a connectionless (UDP) socket.");
839
840 #define _OVERLAPPED_WSACONNECT_METHODDEF \
841 {"WSAConnect", _PyCFunction_CAST(_overlapped_WSAConnect), METH_FASTCALL, _overlapped_WSAConnect__doc__},
842
843 static PyObject *
844 _overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
845 PyObject *AddressObj);
846
847 static PyObject *
848 _overlapped_WSAConnect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
849 {
850 PyObject *return_value = NULL;
851 HANDLE ConnectSocket;
852 PyObject *AddressObj;
853
854 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O!:WSAConnect",
855 &ConnectSocket, &PyTuple_Type, &AddressObj)) {
856 goto exit;
857 }
858 return_value = _overlapped_WSAConnect_impl(module, ConnectSocket, AddressObj);
859
860 exit:
861 return return_value;
862 }
863
864 PyDoc_STRVAR(_overlapped_Overlapped_WSASendTo__doc__,
865 "WSASendTo($self, handle, buf, flags, address_as_bytes, /)\n"
866 "--\n"
867 "\n"
868 "Start overlapped sendto over a connectionless (UDP) socket.");
869
870 #define _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF \
871 {"WSASendTo", _PyCFunction_CAST(_overlapped_Overlapped_WSASendTo), METH_FASTCALL, _overlapped_Overlapped_WSASendTo__doc__},
872
873 static PyObject *
874 _overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
875 Py_buffer *bufobj, DWORD flags,
876 PyObject *AddressObj);
877
878 static PyObject *
879 _overlapped_Overlapped_WSASendTo(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
880 {
881 PyObject *return_value = NULL;
882 HANDLE handle;
883 Py_buffer bufobj = {NULL, NULL};
884 DWORD flags;
885 PyObject *AddressObj;
886
887 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*kO!:WSASendTo",
888 &handle, &bufobj, &flags, &PyTuple_Type, &AddressObj)) {
889 goto exit;
890 }
891 return_value = _overlapped_Overlapped_WSASendTo_impl(self, handle, &bufobj, flags, AddressObj);
892
893 exit:
894 /* Cleanup for bufobj */
895 if (bufobj.obj) {
896 PyBuffer_Release(&bufobj);
897 }
898
899 return return_value;
900 }
901
902 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFrom__doc__,
903 "WSARecvFrom($self, handle, size, flags=0, /)\n"
904 "--\n"
905 "\n"
906 "Start overlapped receive.");
907
908 #define _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF \
909 {"WSARecvFrom", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvFrom), METH_FASTCALL, _overlapped_Overlapped_WSARecvFrom__doc__},
910
911 static PyObject *
912 _overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
913 HANDLE handle, DWORD size,
914 DWORD flags);
915
916 static PyObject *
917 _overlapped_Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
918 {
919 PyObject *return_value = NULL;
920 HANDLE handle;
921 DWORD size;
922 DWORD flags = 0;
923
924 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecvFrom",
925 &handle, &size, &flags)) {
926 goto exit;
927 }
928 return_value = _overlapped_Overlapped_WSARecvFrom_impl(self, handle, size, flags);
929
930 exit:
931 return return_value;
932 }
933
934 PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFromInto__doc__,
935 "WSARecvFromInto($self, handle, buf, size, flags=0, /)\n"
936 "--\n"
937 "\n"
938 "Start overlapped receive.");
939
940 #define _OVERLAPPED_OVERLAPPED_WSARECVFROMINTO_METHODDEF \
941 {"WSARecvFromInto", _PyCFunction_CAST(_overlapped_Overlapped_WSARecvFromInto), METH_FASTCALL, _overlapped_Overlapped_WSARecvFromInto__doc__},
942
943 static PyObject *
944 _overlapped_Overlapped_WSARecvFromInto_impl(OverlappedObject *self,
945 HANDLE handle, Py_buffer *bufobj,
946 DWORD size, DWORD flags);
947
948 static PyObject *
949 _overlapped_Overlapped_WSARecvFromInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
950 {
951 PyObject *return_value = NULL;
952 HANDLE handle;
953 Py_buffer bufobj = {NULL, NULL};
954 DWORD size;
955 DWORD flags = 0;
956
957 if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"y*k|k:WSARecvFromInto",
958 &handle, &bufobj, &size, &flags)) {
959 goto exit;
960 }
961 return_value = _overlapped_Overlapped_WSARecvFromInto_impl(self, handle, &bufobj, size, flags);
962
963 exit:
964 /* Cleanup for bufobj */
965 if (bufobj.obj) {
966 PyBuffer_Release(&bufobj);
967 }
968
969 return return_value;
970 }
971 /*[clinic end generated code: output=5023f7748f0e073e input=a9049054013a1b77]*/