Debian Codegraph @

Modules/_billiard/win32_functions.c

raw
1 /*
2 * Win32 functions used by multiprocessing package
3 *
4 * win32_functions.c
5 *
6 * Copyright (c) 2006-2008, R Oudkerk --- see COPYING.txt
7 */
8
9 #include "multiprocessing.h"
10
11
12 #if defined(MS_WIN32) && !defined(MS_WIN64)
13 #define HANDLE_TO_PYNUM(handle) \
14 PyLong_FromUnsignedLong((unsigned long) handle)
15 #define PYNUM_TO_HANDLE(obj) ((HANDLE)PyLong_AsUnsignedLong(obj))
16 #define F_POINTER "k"
17 #define T_POINTER T_ULONG
18 #else
19 #define HANDLE_TO_PYNUM(handle) \
20 PyLong_FromUnsignedLongLong((unsigned long long) handle)
21 #define PYNUM_TO_HANDLE(obj) ((HANDLE)PyLong_AsUnsignedLongLong(obj))
22 #define F_POINTER "K"
23 #define T_POINTER T_ULONGLONG
24 #endif
25
26 #define F_HANDLE F_POINTER
27 #define F_DWORD "k"
28 #define F_BOOL "i"
29 #define F_UINT "I"
30
31 #define T_HANDLE T_POINTER
32
33 #define DWORD_MAX 4294967295U
34
35 #define Py_MIN(x, y) (((x) > (y)) ? (y) : (x))
36
37 /* Grab CancelIoEx dynamically from kernel32 */
38 static int has_CancelIoEx = -1;
39 static BOOL (CALLBACK *Py_CancelIoEx)(HANDLE, LPOVERLAPPED);
40
41 static int
42 check_CancelIoEx()
43 {
44 if (has_CancelIoEx == -1)
45 {
46 HINSTANCE hKernel32 = GetModuleHandle("KERNEL32");
47 * (FARPROC *) &Py_CancelIoEx = GetProcAddress(hKernel32,
48 "CancelIoEx");
49 has_CancelIoEx = (Py_CancelIoEx != NULL);
50 }
51 return has_CancelIoEx;
52 }
53
54 /*
55 * A Python object wrapping an OVERLAPPED structure and other useful data
56 * for overlapped I/O
57 */
58
59 typedef struct {
60 PyObject_HEAD
61 OVERLAPPED overlapped;
62 /* For convenience, we store the file handle too */
63 HANDLE handle;
64 /* Whether there's I/O in flight */
65 int pending;
66 /* Whether I/O completed successfully */
67 int completed;
68 /* Buffer used for reading (optional) */
69 PyObject *read_buffer;
70 /* Buffer used for writing (optional) */
71 Py_buffer write_buffer;
72 } OverlappedObject;
73
74 static void
75 overlapped_dealloc(OverlappedObject *self)
76 {
77 DWORD bytes;
78 int err = GetLastError();
79
80 if (self->pending) {
81 if (check_CancelIoEx() &&
82 Py_CancelIoEx(self->handle, &self->overlapped) &&
83 GetOverlappedResult(self->handle, &self->overlapped, &bytes, TRUE))
84 {
85 /* The operation is no longer pending -- nothing to do. */
86 }
87 else
88 {
89 /* The operation is still pending, but the process is
90 probably about to exit, so we need not worry too much
91 about memory leaks. Leaking self prevents a potential
92 crash. This can happen when a daemon thread is cleaned
93 up at exit -- see #19565. We only expect to get here
94 on Windows XP. */
95 CloseHandle(self->overlapped.hEvent);
96 SetLastError(err);
97 return;
98 }
99 }
100
101 CloseHandle(self->overlapped.hEvent);
102 SetLastError(err);
103 if (self->write_buffer.obj)
104 PyBuffer_Release(&self->write_buffer);
105 Py_CLEAR(self->read_buffer);
106 PyObject_Del(self);
107 }
108
109 static PyObject *
110 overlapped_GetOverlappedResult(OverlappedObject *self, PyObject *waitobj)
111 {
112 int wait;
113 BOOL res;
114 DWORD transferred = 0;
115 DWORD err;
116
117 wait = PyObject_IsTrue(waitobj);
118 if (wait < 0)
119 return NULL;
120 Py_BEGIN_ALLOW_THREADS
121 res = GetOverlappedResult(self->handle, &self->overlapped, &transferred,
122 wait != 0);
123 Py_END_ALLOW_THREADS
124
125 err = res ? ERROR_SUCCESS : GetLastError();
126 switch (err) {
127 case ERROR_SUCCESS:
128 case ERROR_MORE_DATA:
129 case ERROR_OPERATION_ABORTED:
130 self->completed = 1;
131 self->pending = 0;
132 break;
133 case ERROR_IO_INCOMPLETE:
134 break;
135 default:
136 self->pending = 0;
137 return PyErr_SetExcFromWindowsErr(PyExc_IOError, err);
138 }
139 if (self->completed && self->read_buffer != NULL) {
140 assert(PyBytes_CheckExact(self->read_buffer));
141 if (transferred != PyBytes_GET_SIZE(self->read_buffer) &&
142 _PyBytes_Resize(&self->read_buffer, transferred))
143 return NULL;
144 }
145 return Py_BuildValue("II", (unsigned) transferred, (unsigned) err);
146 }
147
148 static PyObject *
149 overlapped_getbuffer(OverlappedObject *self)
150 {
151 PyObject *res;
152 if (!self->completed) {
153 PyErr_SetString(PyExc_ValueError,
154 "can't get read buffer before GetOverlappedResult() "
155 "signals the operation completed");
156 return NULL;
157 }
158 res = self->read_buffer ? self->read_buffer : Py_None;
159 Py_INCREF(res);
160 return res;
161 }
162
163 static PyObject *
164 overlapped_cancel(OverlappedObject *self)
165 {
166 BOOL res = TRUE;
167
168 if (self->pending) {
169 Py_BEGIN_ALLOW_THREADS
170 if (check_CancelIoEx())
171 res = Py_CancelIoEx(self->handle, &self->overlapped);
172 else
173 res = CancelIo(self->handle);
174 Py_END_ALLOW_THREADS
175 }
176
177 /* CancelIoEx returns ERROR_NOT_FOUND if the I/O completed in-between */
178 if (!res && GetLastError() != ERROR_NOT_FOUND)
179 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
180 self->pending = 0;
181 Py_RETURN_NONE;
182 }
183
184 static PyMethodDef overlapped_methods[] = {
185 {"GetOverlappedResult", (PyCFunction) overlapped_GetOverlappedResult,
186 METH_O, NULL},
187 {"getbuffer", (PyCFunction) overlapped_getbuffer, METH_NOARGS, NULL},
188 {"cancel", (PyCFunction) overlapped_cancel, METH_NOARGS, NULL},
189 {NULL}
190 };
191
192 static PyMemberDef overlapped_members[] = {
193 {"event", T_HANDLE,
194 offsetof(OverlappedObject, overlapped) + offsetof(OVERLAPPED, hEvent),
195 READONLY, "overlapped event handle"},
196 {NULL}
197 };
198
199 PyTypeObject OverlappedType = {
200 PyVarObject_HEAD_INIT(NULL, 0)
201 /* tp_name */ "_winapi.Overlapped",
202 /* tp_basicsize */ sizeof(OverlappedObject),
203 /* tp_itemsize */ 0,
204 /* tp_dealloc */ (destructor) overlapped_dealloc,
205 /* tp_print */ 0,
206 /* tp_getattr */ 0,
207 /* tp_setattr */ 0,
208 /* tp_reserved */ 0,
209 /* tp_repr */ 0,
210 /* tp_as_number */ 0,
211 /* tp_as_sequence */ 0,
212 /* tp_as_mapping */ 0,
213 /* tp_hash */ 0,
214 /* tp_call */ 0,
215 /* tp_str */ 0,
216 /* tp_getattro */ 0,
217 /* tp_setattro */ 0,
218 /* tp_as_buffer */ 0,
219 /* tp_flags */ Py_TPFLAGS_DEFAULT,
220 /* tp_doc */ "OVERLAPPED structure wrapper",
221 /* tp_traverse */ 0,
222 /* tp_clear */ 0,
223 /* tp_richcompare */ 0,
224 /* tp_weaklistoffset */ 0,
225 /* tp_iter */ 0,
226 /* tp_iternext */ 0,
227 /* tp_methods */ overlapped_methods,
228 /* tp_members */ overlapped_members,
229 /* tp_getset */ 0,
230 /* tp_base */ 0,
231 /* tp_dict */ 0,
232 /* tp_descr_get */ 0,
233 /* tp_descr_set */ 0,
234 /* tp_dictoffset */ 0,
235 /* tp_init */ 0,
236 /* tp_alloc */ 0,
237 /* tp_new */ 0,
238 };
239
240 static OverlappedObject *
241 new_overlapped(HANDLE handle)
242 {
243 OverlappedObject *self;
244
245 self = PyObject_New(OverlappedObject, &OverlappedType);
246 if (!self)
247 return NULL;
248 self->handle = handle;
249 self->read_buffer = NULL;
250 self->pending = 0;
251 self->completed = 0;
252 memset(&self->overlapped, 0, sizeof(OVERLAPPED));
253 memset(&self->write_buffer, 0, sizeof(Py_buffer));
254 /* Manual reset, initially non-signaled */
255 self->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
256 return self;
257 }
258
259 static PyObject *
260 win32_CloseHandle(PyObject *self, PyObject *args)
261 {
262 HANDLE hObject;
263 BOOL success;
264
265 if (!PyArg_ParseTuple(args, F_HANDLE, &hObject))
266 return NULL;
267
268 Py_BEGIN_ALLOW_THREADS
269 success = CloseHandle(hObject);
270 Py_END_ALLOW_THREADS
271
272 if (!success)
273 return PyErr_SetFromWindowsErr(0);
274
275 Py_RETURN_NONE;
276 }
277
278 static PyObject *
279 win32_ConnectNamedPipe(PyObject *self, PyObject *args, PyObject *kwds)
280 {
281 HANDLE hNamedPipe;
282 int use_overlapped = 0;
283 BOOL success;
284 OverlappedObject *overlapped = NULL;
285 static char *kwlist[] = {"handle", "overlapped", NULL};
286
287 if (!PyArg_ParseTupleAndKeywords(args, kwds,
288 F_HANDLE "|" F_BOOL, kwlist,
289 &hNamedPipe, &use_overlapped))
290 return NULL;
291
292 if (use_overlapped) {
293 overlapped = new_overlapped(hNamedPipe);
294 if (!overlapped)
295 return NULL;
296 }
297
298 Py_BEGIN_ALLOW_THREADS
299 success = ConnectNamedPipe(hNamedPipe,
300 overlapped ? &overlapped->overlapped : NULL);
301 Py_END_ALLOW_THREADS
302
303 if (overlapped) {
304 int err = GetLastError();
305 /* Overlapped ConnectNamedPipe never returns a success code */
306 assert(success == 0);
307 if (err == ERROR_IO_PENDING)
308 overlapped->pending = 1;
309 else if (err == ERROR_PIPE_CONNECTED)
310 SetEvent(overlapped->overlapped.hEvent);
311 else {
312 Py_DECREF(overlapped);
313 return PyErr_SetFromWindowsErr(err);
314 }
315 return (PyObject *) overlapped;
316 }
317 if (!success)
318 return PyErr_SetFromWindowsErr(0);
319
320 Py_RETURN_NONE;
321 }
322
323 static PyObject *
324 win32_CreateFile(PyObject *self, PyObject *args)
325 {
326 LPCTSTR lpFileName;
327 DWORD dwDesiredAccess;
328 DWORD dwShareMode;
329 LPSECURITY_ATTRIBUTES lpSecurityAttributes;
330 DWORD dwCreationDisposition;
331 DWORD dwFlagsAndAttributes;
332 HANDLE hTemplateFile;
333 HANDLE handle;
334
335 if (!PyArg_ParseTuple(args, "s" F_DWORD F_DWORD F_POINTER
336 F_DWORD F_DWORD F_HANDLE,
337 &lpFileName, &dwDesiredAccess, &dwShareMode,
338 &lpSecurityAttributes, &dwCreationDisposition,
339 &dwFlagsAndAttributes, &hTemplateFile))
340 return NULL;
341
342 Py_BEGIN_ALLOW_THREADS
343 handle = CreateFile(lpFileName, dwDesiredAccess,
344 dwShareMode, lpSecurityAttributes,
345 dwCreationDisposition,
346 dwFlagsAndAttributes, hTemplateFile);
347 Py_END_ALLOW_THREADS
348
349 if (handle == INVALID_HANDLE_VALUE)
350 return PyErr_SetFromWindowsErr(0);
351
352 return Py_BuildValue(F_HANDLE, handle);
353 }
354
355 static PyObject *
356 win32_CreateNamedPipe(PyObject *self, PyObject *args)
357 {
358 LPCTSTR lpName;
359 DWORD dwOpenMode;
360 DWORD dwPipeMode;
361 DWORD nMaxInstances;
362 DWORD nOutBufferSize;
363 DWORD nInBufferSize;
364 DWORD nDefaultTimeOut;
365 LPSECURITY_ATTRIBUTES lpSecurityAttributes;
366 HANDLE handle;
367
368 if (!PyArg_ParseTuple(args, "s" F_DWORD F_DWORD F_DWORD
369 F_DWORD F_DWORD F_DWORD F_POINTER,
370 &lpName, &dwOpenMode, &dwPipeMode,
371 &nMaxInstances, &nOutBufferSize,
372 &nInBufferSize, &nDefaultTimeOut,
373 &lpSecurityAttributes))
374 return NULL;
375
376 Py_BEGIN_ALLOW_THREADS
377 handle = CreateNamedPipe(lpName, dwOpenMode, dwPipeMode,
378 nMaxInstances, nOutBufferSize,
379 nInBufferSize, nDefaultTimeOut,
380 lpSecurityAttributes);
381 Py_END_ALLOW_THREADS
382
383 if (handle == INVALID_HANDLE_VALUE)
384 return PyErr_SetFromWindowsErr(0);
385
386 return Py_BuildValue(F_HANDLE, handle);
387 }
388
389 static PyObject *
390 win32_ExitProcess(PyObject *self, PyObject *args)
391 {
392 UINT uExitCode;
393
394 if (!PyArg_ParseTuple(args, "I", &uExitCode))
395 return NULL;
396
397 #if defined(Py_DEBUG)
398 SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOALIGNMENTFAULTEXCEPT|SEM_NOGPFAULTERRORBOX|SEM_NOOPENFILEERRORBOX);
399 _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
400 #endif
401
402
403 ExitProcess(uExitCode);
404
405 return NULL;
406 }
407
408 static PyObject *
409 win32_GetLastError(PyObject *self, PyObject *args)
410 {
411 return Py_BuildValue(F_DWORD, GetLastError());
412 }
413
414 static PyObject *
415 win32_OpenProcess(PyObject *self, PyObject *args)
416 {
417 DWORD dwDesiredAccess;
418 BOOL bInheritHandle;
419 DWORD dwProcessId;
420 HANDLE handle;
421
422 if (!PyArg_ParseTuple(args, F_DWORD "i" F_DWORD,
423 &dwDesiredAccess, &bInheritHandle, &dwProcessId))
424 return NULL;
425
426 handle = OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);
427 if (handle == NULL)
428 return PyErr_SetFromWindowsErr(0);
429
430 return Py_BuildValue(F_HANDLE, handle);
431 }
432
433 static PyObject *
434 win32_SetNamedPipeHandleState(PyObject *self, PyObject *args)
435 {
436 HANDLE hNamedPipe;
437 PyObject *oArgs[3];
438 DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL};
439 int i;
440
441 if (!PyArg_ParseTuple(args, F_HANDLE "OOO",
442 &hNamedPipe, &oArgs[0], &oArgs[1], &oArgs[2]))
443 return NULL;
444
445 PyErr_Clear();
446
447 for (i = 0 ; i < 3 ; i++) {
448 if (oArgs[i] != Py_None) {
449 dwArgs[i] = PyInt_AsUnsignedLongMask(oArgs[i]);
450 if (PyErr_Occurred())
451 return NULL;
452 pArgs[i] = &dwArgs[i];
453 }
454 }
455
456 if (!SetNamedPipeHandleState(hNamedPipe, pArgs[0], pArgs[1], pArgs[2]))
457 return PyErr_SetFromWindowsErr(0);
458
459 Py_RETURN_NONE;
460 }
461
462 static PyObject *
463 win32_WaitNamedPipe(PyObject *self, PyObject *args)
464 {
465 LPCTSTR lpNamedPipeName;
466 DWORD nTimeOut;
467 BOOL success;
468
469 if (!PyArg_ParseTuple(args, "s" F_DWORD, &lpNamedPipeName, &nTimeOut))
470 return NULL;
471
472 Py_BEGIN_ALLOW_THREADS
473 success = WaitNamedPipe(lpNamedPipeName, nTimeOut);
474 Py_END_ALLOW_THREADS
475
476 if (!success)
477 return PyErr_SetFromWindowsErr(0);
478
479 Py_RETURN_NONE;
480 }
481
482 static PyObject *
483 win32_PeekNamedPipe(PyObject *self, PyObject *args)
484 {
485 HANDLE handle;
486 int size = 0;
487 PyObject *buf = NULL;
488 DWORD nread, navail, nleft;
489 BOOL ret;
490
491 if (!PyArg_ParseTuple(args, F_HANDLE "|i:PeekNamedPipe" , &handle, &size))
492 return NULL;
493
494 if (size < 0) {
495 PyErr_SetString(PyExc_ValueError, "negative size");
496 return NULL;
497 }
498
499 if (size) {
500 buf = PyBytes_FromStringAndSize(NULL, size);
501 if (!buf)
502 return NULL;
503 Py_BEGIN_ALLOW_THREADS
504 ret = PeekNamedPipe(handle, PyBytes_AS_STRING(buf), size, &nread,
505 &navail, &nleft);
506 Py_END_ALLOW_THREADS
507 if (!ret) {
508 Py_DECREF(buf);
509 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
510 }
511 if (_PyBytes_Resize(&buf, nread))
512 return NULL;
513 return Py_BuildValue("Nii", buf, navail, nleft);
514 }
515 else {
516 Py_BEGIN_ALLOW_THREADS
517 ret = PeekNamedPipe(handle, NULL, 0, NULL, &navail, &nleft);
518 Py_END_ALLOW_THREADS
519 if (!ret) {
520 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
521 }
522 return Py_BuildValue("ii", navail, nleft);
523 }
524 }
525
526 static PyObject *
527 win32_WriteFile(PyObject *self, PyObject *args, PyObject *kwds)
528 {
529 HANDLE handle;
530 Py_buffer _buf, *buf;
531 PyObject *bufobj;
532 DWORD len, written;
533 BOOL ret;
534 int use_overlapped = 0;
535 DWORD err;
536 OverlappedObject *overlapped = NULL;
537 static char *kwlist[] = {"handle", "buffer", "overlapped", NULL};
538
539 /* First get handle and use_overlapped to know which Py_buffer to use */
540 if (!PyArg_ParseTupleAndKeywords(args, kwds,
541 F_HANDLE "O|i:WriteFile", kwlist,
542 &handle, &bufobj, &use_overlapped))
543 return NULL;
544
545 if (use_overlapped) {
546 overlapped = new_overlapped(handle);
547 if (!overlapped)
548 return NULL;
549 buf = &overlapped->write_buffer;
550 }
551 else
552 buf = &_buf;
553
554 if (!PyArg_Parse(bufobj, "s*", buf)) {
555 Py_XDECREF(overlapped);
556 return NULL;
557 }
558
559 Py_BEGIN_ALLOW_THREADS
560 len = (DWORD)Py_MIN(buf->len, DWORD_MAX);
561 ret = WriteFile(handle, buf->buf, len, &written,
562 overlapped ? &overlapped->overlapped : NULL);
563 Py_END_ALLOW_THREADS
564
565 err = ret ? 0 : GetLastError();
566
567 if (overlapped) {
568 if (!ret) {
569 if (err == ERROR_IO_PENDING)
570 overlapped->pending = 1;
571 else {
572 Py_DECREF(overlapped);
573 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
574 }
575 }
576 return Py_BuildValue("NI", (PyObject *) overlapped, err);
577 }
578
579 PyBuffer_Release(buf);
580 if (!ret)
581 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
582 return Py_BuildValue("II", written, err);
583 }
584
585 static PyObject *
586 win32_ReadFile(PyObject *self, PyObject *args, PyObject *kwds)
587 {
588 HANDLE handle;
589 int size;
590 DWORD nread;
591 PyObject *buf;
592 BOOL ret;
593 int use_overlapped = 0;
594 DWORD err;
595 OverlappedObject *overlapped = NULL;
596 static char *kwlist[] = {"handle", "size", "overlapped", NULL};
597
598 if (!PyArg_ParseTupleAndKeywords(args, kwds,
599 F_HANDLE "i|i:ReadFile", kwlist,
600 &handle, &size, &use_overlapped))
601 return NULL;
602
603 buf = PyBytes_FromStringAndSize(NULL, size);
604 if (!buf)
605 return NULL;
606 if (use_overlapped) {
607 overlapped = new_overlapped(handle);
608 if (!overlapped) {
609 Py_DECREF(buf);
610 return NULL;
611 }
612 /* Steals reference to buf */
613 overlapped->read_buffer = buf;
614 }
615
616 Py_BEGIN_ALLOW_THREADS
617 ret = ReadFile(handle, PyBytes_AS_STRING(buf), size, &nread,
618 overlapped ? &overlapped->overlapped : NULL);
619 Py_END_ALLOW_THREADS
620
621 err = ret ? 0 : GetLastError();
622
623 if (overlapped) {
624 if (!ret) {
625 if (err == ERROR_IO_PENDING)
626 overlapped->pending = 1;
627 else if (err != ERROR_MORE_DATA) {
628 Py_DECREF(overlapped);
629 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
630 }
631 }
632 return Py_BuildValue("NI", (PyObject *) overlapped, err);
633 }
634
635 if (!ret && err != ERROR_MORE_DATA) {
636 Py_DECREF(buf);
637 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
638 }
639 if (_PyBytes_Resize(&buf, nread))
640 return NULL;
641 return Py_BuildValue("NI", buf, err);
642 }
643
644 static PyObject *
645 win32_WaitForMultipleObjects(PyObject* self, PyObject* args)
646 {
647 DWORD result;
648 PyObject *handle_seq;
649 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
650 HANDLE sigint_event = NULL;
651 Py_ssize_t nhandles, i;
652 BOOL wait_flag;
653 DWORD milliseconds = INFINITE;
654
655 if (!PyArg_ParseTuple(args, "O" F_BOOL "|" F_DWORD
656 ":WaitForMultipleObjects",
657 &handle_seq, &wait_flag, &milliseconds))
658 return NULL;
659
660 if (!PySequence_Check(handle_seq)) {
661 PyErr_Format(PyExc_TypeError,
662 "sequence type expected, got '%s'",
663 Py_TYPE(handle_seq)->tp_name);
664 return NULL;
665 }
666 nhandles = PySequence_Length(handle_seq);
667 if (nhandles == -1)
668 return NULL;
669 if (nhandles < 0 || nhandles >= MAXIMUM_WAIT_OBJECTS - 1) {
670 PyErr_Format(PyExc_ValueError,
671 "need at most %zd handles, got a sequence of length %zd",
672 MAXIMUM_WAIT_OBJECTS - 1, nhandles);
673 return NULL;
674 }
675 for (i = 0; i < nhandles; i++) {
676 HANDLE h;
677 PyObject *v = PySequence_GetItem(handle_seq, i);
678 if (v == NULL)
679 return NULL;
680 if (!PyArg_Parse(v, F_HANDLE, &h)) {
681 Py_DECREF(v);
682 return NULL;
683 }
684 handles[i] = h;
685 Py_DECREF(v);
686 }
687 /* If this is the main thread then make the wait interruptible
688 by Ctrl-C unless we are waiting for *all* handles
689 if (!wait_flag && _PyOS_IsMainThread()) {
690 sigint_event = _PyOS_SigintEvent();
691 assert(sigint_event != NULL);
692 handles[nhandles++] = sigint_event;
693 }*/
694
695 Py_BEGIN_ALLOW_THREADS
696 /*if (sigint_event != NULL)
697 ResetEvent(sigint_event);*/
698 result = WaitForMultipleObjects((DWORD) nhandles, handles,
699 wait_flag, milliseconds);
700 Py_END_ALLOW_THREADS
701
702 if (result == WAIT_FAILED)
703 return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
704 /*
705 else if (sigint_event != NULL && result == WAIT_OBJECT_0 + nhandles - 1) {
706 errno = EINTR;
707 return PyErr_SetFromErrno(PyExc_IOError);
708 }*/
709
710 return PyLong_FromLong((int) result);
711 }
712
713 static PyObject *
714 win32_GetCurrentProcess(PyObject* self, PyObject* args)
715 {
716 if (! PyArg_ParseTuple(args, ":GetCurrentProcess"))
717 return NULL;
718
719 return HANDLE_TO_PYNUM(GetCurrentProcess());
720 }
721
722 static PyObject *
723 win32_DuplicateHandle(PyObject* self, PyObject* args)
724 {
725 HANDLE target_handle;
726 BOOL result;
727
728 HANDLE source_process_handle;
729 HANDLE source_handle;
730 HANDLE target_process_handle;
731 DWORD desired_access;
732 BOOL inherit_handle;
733 DWORD options = 0;
734
735 if (! PyArg_ParseTuple(args,
736 F_HANDLE F_HANDLE F_HANDLE F_DWORD F_BOOL F_DWORD
737 ":DuplicateHandle",
738 &source_process_handle,
739 &source_handle,
740 &target_process_handle,
741 &desired_access,
742 &inherit_handle,
743 &options))
744 return NULL;
745
746 Py_BEGIN_ALLOW_THREADS
747 result = DuplicateHandle(
748 source_process_handle,
749 source_handle,
750 target_process_handle,
751 &target_handle,
752 desired_access,
753 inherit_handle,
754 options
755 );
756 Py_END_ALLOW_THREADS
757
758 if (! result)
759 return PyErr_SetFromWindowsErr(GetLastError());
760
761 return HANDLE_TO_PYNUM(target_handle);
762 }
763
764 static PyObject *
765 win32_CreatePipe(PyObject* self, PyObject* args)
766 {
767 HANDLE read_pipe;
768 HANDLE write_pipe;
769 BOOL result;
770
771 PyObject* pipe_attributes; /* ignored */
772 DWORD size;
773
774 if (! PyArg_ParseTuple(args, "O" F_DWORD ":CreatePipe",
775 &pipe_attributes, &size))
776 return NULL;
777
778 Py_BEGIN_ALLOW_THREADS
779 result = CreatePipe(&read_pipe, &write_pipe, NULL, size);
780 Py_END_ALLOW_THREADS
781
782 if (! result)
783 return PyErr_SetFromWindowsErr(GetLastError());
784
785 return Py_BuildValue(
786 "NN", HANDLE_TO_PYNUM(read_pipe), HANDLE_TO_PYNUM(write_pipe));
787 }
788
789 static PyObject *
790 win32_WaitForSingleObject(PyObject* self, PyObject* args)
791 {
792 DWORD result;
793
794 HANDLE handle;
795 DWORD milliseconds;
796 if (! PyArg_ParseTuple(args, F_HANDLE F_DWORD ":WaitForSingleObject",
797 &handle,
798 &milliseconds))
799 return NULL;
800
801 Py_BEGIN_ALLOW_THREADS
802 result = WaitForSingleObject(handle, milliseconds);
803 Py_END_ALLOW_THREADS
804
805 if (result == WAIT_FAILED)
806 return PyErr_SetFromWindowsErr(GetLastError());
807
808 return PyLong_FromUnsignedLong(result);
809 }
810
811 static PyObject *
812 win32_GetExitCodeProcess(PyObject* self, PyObject* args)
813 {
814 DWORD exit_code;
815 BOOL result;
816
817 HANDLE process;
818 if (! PyArg_ParseTuple(args, F_HANDLE ":GetExitCodeProcess", &process))
819 return NULL;
820
821 result = GetExitCodeProcess(process, &exit_code);
822
823 if (! result)
824 return PyErr_SetFromWindowsErr(GetLastError());
825
826 return PyLong_FromUnsignedLong(exit_code);
827 }
828
829 static PyObject *
830 win32_TerminateProcess(PyObject* self, PyObject* args)
831 {
832 BOOL result;
833
834 HANDLE process;
835 UINT exit_code;
836 if (! PyArg_ParseTuple(args, F_HANDLE F_UINT ":TerminateProcess",
837 &process, &exit_code))
838 return NULL;
839
840 result = TerminateProcess(process, exit_code);
841
842 if (! result)
843 return PyErr_SetFromWindowsErr(GetLastError());
844
845 Py_INCREF(Py_None);
846 return Py_None;
847 }
848
849 static PyMethodDef win32_functions[] = {
850 {"CloseHandle", win32_CloseHandle, METH_VARARGS, ""},
851 {"GetLastError", win32_GetLastError, METH_NOARGS, ""},
852 {"OpenProcess", win32_OpenProcess, METH_VARARGS, ""},
853 {"ExitProcess", win32_ExitProcess, METH_VARARGS, ""},
854 {"ConnectNamedPipe", (PyCFunction)win32_ConnectNamedPipe,
855 METH_VARARGS | METH_KEYWORDS, ""},
856 {"CreateFile", win32_CreateFile, METH_VARARGS, ""},
857 {"WriteFile", (PyCFunction)win32_WriteFile,
858 METH_VARARGS | METH_KEYWORDS, ""},
859 {"ReadFile", (PyCFunction)win32_ReadFile,
860 METH_VARARGS | METH_KEYWORDS, ""},
861 {"CreateNamedPipe", win32_CreateNamedPipe, METH_VARARGS, ""},
862 {"SetNamedPipeHandleState", win32_SetNamedPipeHandleState,
863 METH_VARARGS, ""},
864 {"WaitNamedPipe", win32_WaitNamedPipe, METH_VARARGS, ""},
865 {"PeekNamedPipe", win32_PeekNamedPipe, METH_VARARGS, ""},
866 {"WaitForMultipleObjects", win32_WaitForMultipleObjects,
867 METH_VARARGS, ""},
868 {"WaitForSingleObject", win32_WaitForSingleObject,
869 METH_VARARGS, ""},
870 {"GetCurrentProcess", win32_GetCurrentProcess, METH_VARARGS, ""},
871 {"GetExitCodeProcess", win32_GetExitCodeProcess, METH_VARARGS, ""},
872 {"TerminateProcess", win32_TerminateProcess, METH_VARARGS, ""},
873 {"DuplicateHandle", win32_DuplicateHandle, METH_VARARGS, ""},
874 {"CreatePipe", win32_CreatePipe, METH_VARARGS, ""},
875 {NULL}
876 };
877
878 #define WIN32_CONSTANT(fmt, con) \
879 PyDict_SetItemString(d, #con, Py_BuildValue(fmt, con))
880
881 PyMODINIT_FUNC
882 init_winapi(void)
883 {
884 PyObject *d;
885 PyObject *m;
886
887 if (PyType_Ready(&OverlappedType) < 0)
888 return NULL;
889
890 m = Py_InitModule("_winapi", win32_functions);
891 if (!m)
892 return;
893
894 d = PyModule_GetDict(m);
895 PyDict_SetItemString(d, "Overlapped", (PyObject *) &OverlappedType);
896
897 /* constants */
898
899 WIN32_CONSTANT(F_DWORD, ERROR_ALREADY_EXISTS);
900 WIN32_CONSTANT(F_DWORD, ERROR_PIPE_BUSY);
901 WIN32_CONSTANT(F_DWORD, ERROR_PIPE_CONNECTED);
902 WIN32_CONSTANT(F_DWORD, ERROR_SEM_TIMEOUT);
903 WIN32_CONSTANT(F_DWORD, ERROR_MORE_DATA);
904 WIN32_CONSTANT(F_DWORD, ERROR_BROKEN_PIPE);
905 WIN32_CONSTANT(F_DWORD, ERROR_IO_PENDING);
906 WIN32_CONSTANT(F_DWORD, ERROR_NETNAME_DELETED);
907 WIN32_CONSTANT(F_DWORD, ERROR_OPERATION_ABORTED);
908 WIN32_CONSTANT(F_DWORD, GENERIC_READ);
909 WIN32_CONSTANT(F_DWORD, GENERIC_WRITE);
910 WIN32_CONSTANT(F_DWORD, DUPLICATE_SAME_ACCESS);
911 WIN32_CONSTANT(F_DWORD, DUPLICATE_CLOSE_SOURCE);
912 WIN32_CONSTANT(F_DWORD, INFINITE);
913 WIN32_CONSTANT(F_DWORD, NMPWAIT_WAIT_FOREVER);
914 WIN32_CONSTANT(F_DWORD, OPEN_EXISTING);
915 WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_DUPLEX);
916 WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_INBOUND);
917 WIN32_CONSTANT(F_DWORD, PIPE_READMODE_MESSAGE);
918 WIN32_CONSTANT(F_DWORD, PIPE_TYPE_MESSAGE);
919 WIN32_CONSTANT(F_DWORD, PIPE_UNLIMITED_INSTANCES);
920 WIN32_CONSTANT(F_DWORD, PIPE_WAIT);
921 WIN32_CONSTANT(F_DWORD, PROCESS_ALL_ACCESS);
922 WIN32_CONSTANT(F_DWORD, PROCESS_DUP_HANDLE);
923 WIN32_CONSTANT(F_DWORD, WAIT_OBJECT_0);
924 WIN32_CONSTANT(F_DWORD, WAIT_ABANDONED_0);
925 WIN32_CONSTANT(F_DWORD, WAIT_TIMEOUT);
926 WIN32_CONSTANT(F_DWORD, FILE_FLAG_FIRST_PIPE_INSTANCE);
927 WIN32_CONSTANT(F_DWORD, FILE_FLAG_OVERLAPPED);
928 WIN32_CONSTANT(F_DWORD, FILE_GENERIC_READ);
929 WIN32_CONSTANT(F_DWORD, FILE_GENERIC_WRITE);
930
931 WIN32_CONSTANT("i", NULL);
932 }