Issue #11750: The Windows API functions scattered in the _subprocess and
_multiprocessing.win32 modules now live in a single module "_winapi".
Patch by sbt.
diff --git a/Modules/_multiprocessing/multiprocessing.c b/Modules/_multiprocessing/multiprocessing.c
index d370f9a..6e39a23 100644
--- a/Modules/_multiprocessing/multiprocessing.c
+++ b/Modules/_multiprocessing/multiprocessing.c
@@ -9,8 +9,6 @@
#include "multiprocessing.h"
-PyObject *create_win32_namespace(void);
-
PyObject *ProcessError, *BufferTooShort;
/*
@@ -66,6 +64,72 @@
PyLong_FromVoidPtr(buffer), buffer_len);
}
+#ifdef MS_WINDOWS
+static PyObject *
+multiprocessing_closesocket(PyObject *self, PyObject *args)
+{
+ HANDLE handle;
+ int ret;
+
+ if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ ret = closesocket((SOCKET) handle);
+ Py_END_ALLOW_THREADS
+
+ if (ret)
+ return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
+ Py_RETURN_NONE;
+}
+
+static PyObject *
+multiprocessing_recv(PyObject *self, PyObject *args)
+{
+ HANDLE handle;
+ int size, nread;
+ PyObject *buf;
+
+ if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size))
+ return NULL;
+
+ buf = PyBytes_FromStringAndSize(NULL, size);
+ if (!buf)
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ nread = recv((SOCKET) handle, PyBytes_AS_STRING(buf), size, 0);
+ Py_END_ALLOW_THREADS
+
+ if (nread < 0) {
+ Py_DECREF(buf);
+ return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
+ }
+ _PyBytes_Resize(&buf, nread);
+ return buf;
+}
+
+static PyObject *
+multiprocessing_send(PyObject *self, PyObject *args)
+{
+ HANDLE handle;
+ Py_buffer buf;
+ int ret;
+
+ if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf))
+ return NULL;
+
+ Py_BEGIN_ALLOW_THREADS
+ ret = send((SOCKET) handle, buf.buf, buf.len, 0);
+ Py_END_ALLOW_THREADS
+
+ PyBuffer_Release(&buf);
+ if (ret < 0)
+ return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
+ return PyLong_FromLong(ret);
+}
+
+#endif
/*
* Function table
@@ -75,6 +139,11 @@
{"address_of_buffer", multiprocessing_address_of_buffer, METH_O,
"address_of_buffer(obj) -> int\n"
"Return address of obj assuming obj supports buffer inteface"},
+#ifdef MS_WINDOWS
+ {"closesocket", multiprocessing_closesocket, METH_VARARGS, ""},
+ {"recv", multiprocessing_recv, METH_VARARGS, ""},
+ {"send", multiprocessing_send, METH_VARARGS, ""},
+#endif
{NULL}
};
@@ -135,14 +204,6 @@
PyModule_AddObject(module, "SemLock", (PyObject*)&SemLockType);
#endif
-#ifdef MS_WINDOWS
- /* Initialize win32 class and add to multiprocessing */
- temp = create_win32_namespace();
- if (!temp)
- return NULL;
- PyModule_AddObject(module, "win32", temp);
-#endif
-
/* Add configuration macros */
temp = PyDict_New();
if (!temp)
@@ -152,7 +213,7 @@
value = Py_BuildValue("i", name); \
if (value == NULL) { Py_DECREF(temp); return NULL; } \
if (PyDict_SetItemString(temp, #name, value) < 0) { \
- Py_DECREF(temp); Py_DECREF(value); return NULL; } \
+ Py_DECREF(temp); Py_DECREF(value); return NULL; } \
Py_DECREF(value)
#if defined(HAVE_SEM_OPEN) && !defined(POSIX_SEMAPHORES_NOT_ENABLED)
diff --git a/Modules/_multiprocessing/win32_functions.c b/Modules/_multiprocessing/win32_functions.c
deleted file mode 100644
index 93c8fc9..0000000
--- a/Modules/_multiprocessing/win32_functions.c
+++ /dev/null
@@ -1,823 +0,0 @@
-/*
- * Win32 functions used by multiprocessing package
- *
- * win32_functions.c
- *
- * Copyright (c) 2006-2008, R Oudkerk --- see COPYING.txt
- */
-
-#include "multiprocessing.h"
-
-
-#define WIN32_FUNCTION(func) \
- {#func, (PyCFunction)win32_ ## func, METH_VARARGS | METH_STATIC, ""}
-
-#define WIN32_KWARGS_FUNCTION(func) \
- {#func, (PyCFunction)win32_ ## func, METH_VARARGS | METH_KEYWORDS | METH_STATIC, ""}
-
-#define WIN32_CONSTANT(fmt, con) \
- PyDict_SetItemString(Win32Type.tp_dict, #con, Py_BuildValue(fmt, con))
-
-
-/* Grab CancelIoEx dynamically from kernel32 */
-static int has_CancelIoEx = -1;
-static BOOL (CALLBACK *Py_CancelIoEx)(HANDLE, LPOVERLAPPED);
-
-static int
-check_CancelIoEx()
-{
- if (has_CancelIoEx == -1)
- {
- HINSTANCE hKernel32 = GetModuleHandle("KERNEL32");
- * (FARPROC *) &Py_CancelIoEx = GetProcAddress(hKernel32,
- "CancelIoEx");
- has_CancelIoEx = (Py_CancelIoEx != NULL);
- }
- return has_CancelIoEx;
-}
-
-
-/*
- * A Python object wrapping an OVERLAPPED structure and other useful data
- * for overlapped I/O
- */
-
-typedef struct {
- PyObject_HEAD
- OVERLAPPED overlapped;
- /* For convenience, we store the file handle too */
- HANDLE handle;
- /* Whether there's I/O in flight */
- int pending;
- /* Whether I/O completed successfully */
- int completed;
- /* Buffer used for reading (optional) */
- PyObject *read_buffer;
- /* Buffer used for writing (optional) */
- Py_buffer write_buffer;
-} OverlappedObject;
-
-static void
-overlapped_dealloc(OverlappedObject *self)
-{
- DWORD bytes;
- int err = GetLastError();
- if (self->pending) {
- /* make it a programming error to deallocate while operation
- is pending, even if we can safely cancel it */
- if (check_CancelIoEx() &&
- Py_CancelIoEx(self->handle, &self->overlapped))
- GetOverlappedResult(self->handle, &self->overlapped, &bytes, TRUE);
- PyErr_SetString(PyExc_RuntimeError,
- "I/O operations still in flight while destroying "
- "Overlapped object, the process may crash");
- PyErr_WriteUnraisable(NULL);
- }
- CloseHandle(self->overlapped.hEvent);
- SetLastError(err);
- if (self->write_buffer.obj)
- PyBuffer_Release(&self->write_buffer);
- Py_CLEAR(self->read_buffer);
- PyObject_Del(self);
-}
-
-static PyObject *
-overlapped_GetOverlappedResult(OverlappedObject *self, PyObject *waitobj)
-{
- int wait;
- BOOL res;
- DWORD transferred = 0;
- DWORD err;
-
- wait = PyObject_IsTrue(waitobj);
- if (wait < 0)
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- res = GetOverlappedResult(self->handle, &self->overlapped, &transferred,
- wait != 0);
- Py_END_ALLOW_THREADS
-
- err = res ? ERROR_SUCCESS : GetLastError();
- switch (err) {
- case ERROR_SUCCESS:
- case ERROR_MORE_DATA:
- case ERROR_OPERATION_ABORTED:
- self->completed = 1;
- self->pending = 0;
- break;
- case ERROR_IO_INCOMPLETE:
- break;
- default:
- self->pending = 0;
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, err);
- }
- if (self->completed && self->read_buffer != NULL) {
- assert(PyBytes_CheckExact(self->read_buffer));
- if (transferred != PyBytes_GET_SIZE(self->read_buffer) &&
- _PyBytes_Resize(&self->read_buffer, transferred))
- return NULL;
- }
- return Py_BuildValue("II", (unsigned) transferred, (unsigned) err);
-}
-
-static PyObject *
-overlapped_getbuffer(OverlappedObject *self)
-{
- PyObject *res;
- if (!self->completed) {
- PyErr_SetString(PyExc_ValueError,
- "can't get read buffer before GetOverlappedResult() "
- "signals the operation completed");
- return NULL;
- }
- res = self->read_buffer ? self->read_buffer : Py_None;
- Py_INCREF(res);
- return res;
-}
-
-static PyObject *
-overlapped_cancel(OverlappedObject *self)
-{
- BOOL res = TRUE;
-
- if (self->pending) {
- Py_BEGIN_ALLOW_THREADS
- if (check_CancelIoEx())
- res = Py_CancelIoEx(self->handle, &self->overlapped);
- else
- res = CancelIo(self->handle);
- Py_END_ALLOW_THREADS
- }
-
- /* CancelIoEx returns ERROR_NOT_FOUND if the I/O completed in-between */
- if (!res && GetLastError() != ERROR_NOT_FOUND)
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- self->pending = 0;
- Py_RETURN_NONE;
-}
-
-static PyMethodDef overlapped_methods[] = {
- {"GetOverlappedResult", (PyCFunction) overlapped_GetOverlappedResult,
- METH_O, NULL},
- {"getbuffer", (PyCFunction) overlapped_getbuffer, METH_NOARGS, NULL},
- {"cancel", (PyCFunction) overlapped_cancel, METH_NOARGS, NULL},
- {NULL}
-};
-
-static PyMemberDef overlapped_members[] = {
- {"event", T_HANDLE,
- offsetof(OverlappedObject, overlapped) + offsetof(OVERLAPPED, hEvent),
- READONLY, "overlapped event handle"},
- {NULL}
-};
-
-PyTypeObject OverlappedType = {
- PyVarObject_HEAD_INIT(NULL, 0)
- /* tp_name */ "_multiprocessing.win32.Overlapped",
- /* tp_basicsize */ sizeof(OverlappedObject),
- /* tp_itemsize */ 0,
- /* tp_dealloc */ (destructor) overlapped_dealloc,
- /* tp_print */ 0,
- /* tp_getattr */ 0,
- /* tp_setattr */ 0,
- /* tp_reserved */ 0,
- /* tp_repr */ 0,
- /* tp_as_number */ 0,
- /* tp_as_sequence */ 0,
- /* tp_as_mapping */ 0,
- /* tp_hash */ 0,
- /* tp_call */ 0,
- /* tp_str */ 0,
- /* tp_getattro */ 0,
- /* tp_setattro */ 0,
- /* tp_as_buffer */ 0,
- /* tp_flags */ Py_TPFLAGS_DEFAULT,
- /* tp_doc */ "OVERLAPPED structure wrapper",
- /* tp_traverse */ 0,
- /* tp_clear */ 0,
- /* tp_richcompare */ 0,
- /* tp_weaklistoffset */ 0,
- /* tp_iter */ 0,
- /* tp_iternext */ 0,
- /* tp_methods */ overlapped_methods,
- /* tp_members */ overlapped_members,
- /* tp_getset */ 0,
- /* tp_base */ 0,
- /* tp_dict */ 0,
- /* tp_descr_get */ 0,
- /* tp_descr_set */ 0,
- /* tp_dictoffset */ 0,
- /* tp_init */ 0,
- /* tp_alloc */ 0,
- /* tp_new */ 0,
-};
-
-static OverlappedObject *
-new_overlapped(HANDLE handle)
-{
- OverlappedObject *self;
-
- self = PyObject_New(OverlappedObject, &OverlappedType);
- if (!self)
- return NULL;
- self->handle = handle;
- self->read_buffer = NULL;
- self->pending = 0;
- self->completed = 0;
- memset(&self->overlapped, 0, sizeof(OVERLAPPED));
- memset(&self->write_buffer, 0, sizeof(Py_buffer));
- /* Manual reset, initially non-signalled */
- self->overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
- return self;
-}
-
-
-/*
- * Module functions
- */
-
-static PyObject *
-win32_CloseHandle(PyObject *self, PyObject *args)
-{
- HANDLE hObject;
- BOOL success;
-
- if (!PyArg_ParseTuple(args, F_HANDLE, &hObject))
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- success = CloseHandle(hObject);
- Py_END_ALLOW_THREADS
-
- if (!success)
- return PyErr_SetFromWindowsErr(0);
-
- Py_RETURN_NONE;
-}
-
-static PyObject *
-win32_ConnectNamedPipe(PyObject *self, PyObject *args, PyObject *kwds)
-{
- HANDLE hNamedPipe;
- int use_overlapped = 0;
- BOOL success;
- OverlappedObject *overlapped = NULL;
- static char *kwlist[] = {"handle", "overlapped", NULL};
-
- if (!PyArg_ParseTupleAndKeywords(args, kwds,
- F_HANDLE "|i", kwlist,
- &hNamedPipe, &use_overlapped))
- return NULL;
-
- if (use_overlapped) {
- overlapped = new_overlapped(hNamedPipe);
- if (!overlapped)
- return NULL;
- }
-
- Py_BEGIN_ALLOW_THREADS
- success = ConnectNamedPipe(hNamedPipe,
- overlapped ? &overlapped->overlapped : NULL);
- Py_END_ALLOW_THREADS
-
- if (overlapped) {
- int err = GetLastError();
- /* Overlapped ConnectNamedPipe never returns a success code */
- assert(success == 0);
- if (err == ERROR_IO_PENDING)
- overlapped->pending = 1;
- else if (err == ERROR_PIPE_CONNECTED)
- SetEvent(overlapped->overlapped.hEvent);
- else {
- Py_DECREF(overlapped);
- return PyErr_SetFromWindowsErr(err);
- }
- return (PyObject *) overlapped;
- }
- if (!success)
- return PyErr_SetFromWindowsErr(0);
-
- Py_RETURN_NONE;
-}
-
-static PyObject *
-win32_CreateFile(PyObject *self, PyObject *args)
-{
- LPCTSTR lpFileName;
- DWORD dwDesiredAccess;
- DWORD dwShareMode;
- LPSECURITY_ATTRIBUTES lpSecurityAttributes;
- DWORD dwCreationDisposition;
- DWORD dwFlagsAndAttributes;
- HANDLE hTemplateFile;
- HANDLE handle;
-
- if (!PyArg_ParseTuple(args, "s" F_DWORD F_DWORD F_POINTER
- F_DWORD F_DWORD F_HANDLE,
- &lpFileName, &dwDesiredAccess, &dwShareMode,
- &lpSecurityAttributes, &dwCreationDisposition,
- &dwFlagsAndAttributes, &hTemplateFile))
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- handle = CreateFile(lpFileName, dwDesiredAccess,
- dwShareMode, lpSecurityAttributes,
- dwCreationDisposition,
- dwFlagsAndAttributes, hTemplateFile);
- Py_END_ALLOW_THREADS
-
- if (handle == INVALID_HANDLE_VALUE)
- return PyErr_SetFromWindowsErr(0);
-
- return Py_BuildValue(F_HANDLE, handle);
-}
-
-static PyObject *
-win32_CreateNamedPipe(PyObject *self, PyObject *args)
-{
- LPCTSTR lpName;
- DWORD dwOpenMode;
- DWORD dwPipeMode;
- DWORD nMaxInstances;
- DWORD nOutBufferSize;
- DWORD nInBufferSize;
- DWORD nDefaultTimeOut;
- LPSECURITY_ATTRIBUTES lpSecurityAttributes;
- HANDLE handle;
-
- if (!PyArg_ParseTuple(args, "s" F_DWORD F_DWORD F_DWORD
- F_DWORD F_DWORD F_DWORD F_POINTER,
- &lpName, &dwOpenMode, &dwPipeMode,
- &nMaxInstances, &nOutBufferSize,
- &nInBufferSize, &nDefaultTimeOut,
- &lpSecurityAttributes))
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- handle = CreateNamedPipe(lpName, dwOpenMode, dwPipeMode,
- nMaxInstances, nOutBufferSize,
- nInBufferSize, nDefaultTimeOut,
- lpSecurityAttributes);
- Py_END_ALLOW_THREADS
-
- if (handle == INVALID_HANDLE_VALUE)
- return PyErr_SetFromWindowsErr(0);
-
- return Py_BuildValue(F_HANDLE, handle);
-}
-
-static PyObject *
-win32_ExitProcess(PyObject *self, PyObject *args)
-{
- UINT uExitCode;
-
- if (!PyArg_ParseTuple(args, "I", &uExitCode))
- return NULL;
-
- #if defined(Py_DEBUG)
- SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOALIGNMENTFAULTEXCEPT|SEM_NOGPFAULTERRORBOX|SEM_NOOPENFILEERRORBOX);
- _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
- #endif
-
-
- ExitProcess(uExitCode);
-
- return NULL;
-}
-
-static PyObject *
-win32_GetLastError(PyObject *self, PyObject *args)
-{
- return Py_BuildValue(F_DWORD, GetLastError());
-}
-
-static PyObject *
-win32_OpenProcess(PyObject *self, PyObject *args)
-{
- DWORD dwDesiredAccess;
- BOOL bInheritHandle;
- DWORD dwProcessId;
- HANDLE handle;
-
- if (!PyArg_ParseTuple(args, F_DWORD "i" F_DWORD,
- &dwDesiredAccess, &bInheritHandle, &dwProcessId))
- return NULL;
-
- handle = OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);
- if (handle == NULL)
- return PyErr_SetFromWindowsErr(0);
-
- return Py_BuildValue(F_HANDLE, handle);
-}
-
-static PyObject *
-win32_SetNamedPipeHandleState(PyObject *self, PyObject *args)
-{
- HANDLE hNamedPipe;
- PyObject *oArgs[3];
- DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL};
- int i;
-
- if (!PyArg_ParseTuple(args, F_HANDLE "OOO",
- &hNamedPipe, &oArgs[0], &oArgs[1], &oArgs[2]))
- return NULL;
-
- PyErr_Clear();
-
- for (i = 0 ; i < 3 ; i++) {
- if (oArgs[i] != Py_None) {
- dwArgs[i] = PyLong_AsUnsignedLongMask(oArgs[i]);
- if (PyErr_Occurred())
- return NULL;
- pArgs[i] = &dwArgs[i];
- }
- }
-
- if (!SetNamedPipeHandleState(hNamedPipe, pArgs[0], pArgs[1], pArgs[2]))
- return PyErr_SetFromWindowsErr(0);
-
- Py_RETURN_NONE;
-}
-
-static PyObject *
-win32_WaitNamedPipe(PyObject *self, PyObject *args)
-{
- LPCTSTR lpNamedPipeName;
- DWORD nTimeOut;
- BOOL success;
-
- if (!PyArg_ParseTuple(args, "s" F_DWORD, &lpNamedPipeName, &nTimeOut))
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- success = WaitNamedPipe(lpNamedPipeName, nTimeOut);
- Py_END_ALLOW_THREADS
-
- if (!success)
- return PyErr_SetFromWindowsErr(0);
-
- Py_RETURN_NONE;
-}
-
-static PyObject *
-win32_closesocket(PyObject *self, PyObject *args)
-{
- HANDLE handle;
- int ret;
-
- if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle))
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- ret = closesocket((SOCKET) handle);
- Py_END_ALLOW_THREADS
-
- if (ret)
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
- Py_RETURN_NONE;
-}
-
-static PyObject *
-win32_recv(PyObject *self, PyObject *args)
-{
- HANDLE handle;
- int size, nread;
- PyObject *buf;
-
- if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size))
- return NULL;
-
- buf = PyBytes_FromStringAndSize(NULL, size);
- if (!buf)
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- nread = recv((SOCKET) handle, PyBytes_AS_STRING(buf), size, 0);
- Py_END_ALLOW_THREADS
-
- if (nread < 0) {
- Py_DECREF(buf);
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
- }
- _PyBytes_Resize(&buf, nread);
- return buf;
-}
-
-static PyObject *
-win32_send(PyObject *self, PyObject *args)
-{
- HANDLE handle;
- Py_buffer buf;
- int ret;
-
- if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf))
- return NULL;
-
- Py_BEGIN_ALLOW_THREADS
- ret = send((SOCKET) handle, buf.buf, buf.len, 0);
- Py_END_ALLOW_THREADS
-
- PyBuffer_Release(&buf);
- if (ret < 0)
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError());
- return PyLong_FromLong(ret);
-}
-
-static PyObject *
-win32_WriteFile(PyObject *self, PyObject *args, PyObject *kwds)
-{
- HANDLE handle;
- Py_buffer _buf, *buf;
- PyObject *bufobj;
- DWORD written;
- BOOL ret;
- int use_overlapped = 0;
- DWORD err;
- OverlappedObject *overlapped = NULL;
- static char *kwlist[] = {"handle", "buffer", "overlapped", NULL};
-
- /* First get handle and use_overlapped to know which Py_buffer to use */
- if (!PyArg_ParseTupleAndKeywords(args, kwds,
- F_HANDLE "O|i:WriteFile", kwlist,
- &handle, &bufobj, &use_overlapped))
- return NULL;
-
- if (use_overlapped) {
- overlapped = new_overlapped(handle);
- if (!overlapped)
- return NULL;
- buf = &overlapped->write_buffer;
- }
- else
- buf = &_buf;
-
- if (!PyArg_Parse(bufobj, "y*", buf)) {
- Py_XDECREF(overlapped);
- return NULL;
- }
-
- Py_BEGIN_ALLOW_THREADS
- ret = WriteFile(handle, buf->buf, buf->len, &written,
- overlapped ? &overlapped->overlapped : NULL);
- Py_END_ALLOW_THREADS
-
- err = ret ? 0 : GetLastError();
-
- if (overlapped) {
- if (!ret) {
- if (err == ERROR_IO_PENDING)
- overlapped->pending = 1;
- else {
- Py_DECREF(overlapped);
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- }
- }
- return Py_BuildValue("NI", (PyObject *) overlapped, err);
- }
-
- PyBuffer_Release(buf);
- if (!ret)
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- return Py_BuildValue("II", written, err);
-}
-
-static PyObject *
-win32_ReadFile(PyObject *self, PyObject *args, PyObject *kwds)
-{
- HANDLE handle;
- int size;
- DWORD nread;
- PyObject *buf;
- BOOL ret;
- int use_overlapped = 0;
- DWORD err;
- OverlappedObject *overlapped = NULL;
- static char *kwlist[] = {"handle", "size", "overlapped", NULL};
-
- if (!PyArg_ParseTupleAndKeywords(args, kwds,
- F_HANDLE "i|i:ReadFile", kwlist,
- &handle, &size, &use_overlapped))
- return NULL;
-
- buf = PyBytes_FromStringAndSize(NULL, size);
- if (!buf)
- return NULL;
- if (use_overlapped) {
- overlapped = new_overlapped(handle);
- if (!overlapped) {
- Py_DECREF(buf);
- return NULL;
- }
- /* Steals reference to buf */
- overlapped->read_buffer = buf;
- }
-
- Py_BEGIN_ALLOW_THREADS
- ret = ReadFile(handle, PyBytes_AS_STRING(buf), size, &nread,
- overlapped ? &overlapped->overlapped : NULL);
- Py_END_ALLOW_THREADS
-
- err = ret ? 0 : GetLastError();
-
- if (overlapped) {
- if (!ret) {
- if (err == ERROR_IO_PENDING)
- overlapped->pending = 1;
- else if (err != ERROR_MORE_DATA) {
- Py_DECREF(overlapped);
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- }
- }
- return Py_BuildValue("NI", (PyObject *) overlapped, err);
- }
-
- if (!ret && err != ERROR_MORE_DATA) {
- Py_DECREF(buf);
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- }
- if (_PyBytes_Resize(&buf, nread))
- return NULL;
- return Py_BuildValue("NI", buf, err);
-}
-
-static PyObject *
-win32_PeekNamedPipe(PyObject *self, PyObject *args)
-{
- HANDLE handle;
- int size = 0;
- PyObject *buf = NULL;
- DWORD nread, navail, nleft;
- BOOL ret;
-
- if (!PyArg_ParseTuple(args, F_HANDLE "|i:PeekNamedPipe" , &handle, &size))
- return NULL;
-
- if (size < 0) {
- PyErr_SetString(PyExc_ValueError, "negative size");
- return NULL;
- }
-
- if (size) {
- buf = PyBytes_FromStringAndSize(NULL, size);
- if (!buf)
- return NULL;
- Py_BEGIN_ALLOW_THREADS
- ret = PeekNamedPipe(handle, PyBytes_AS_STRING(buf), size, &nread,
- &navail, &nleft);
- Py_END_ALLOW_THREADS
- if (!ret) {
- Py_DECREF(buf);
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- }
- if (_PyBytes_Resize(&buf, nread))
- return NULL;
- return Py_BuildValue("Nii", buf, navail, nleft);
- }
- else {
- Py_BEGIN_ALLOW_THREADS
- ret = PeekNamedPipe(handle, NULL, 0, NULL, &navail, &nleft);
- Py_END_ALLOW_THREADS
- if (!ret) {
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- }
- return Py_BuildValue("ii", navail, nleft);
- }
-}
-
-static PyObject *
-win32_WaitForMultipleObjects(PyObject* self, PyObject* args)
-{
- DWORD result;
- PyObject *handle_seq;
- HANDLE handles[MAXIMUM_WAIT_OBJECTS];
- HANDLE sigint_event = NULL;
- Py_ssize_t nhandles, i;
- int wait_flag;
- int milliseconds = INFINITE;
-
- if (!PyArg_ParseTuple(args, "Oi|i:WaitForMultipleObjects",
- &handle_seq, &wait_flag, &milliseconds))
- return NULL;
-
- if (!PySequence_Check(handle_seq)) {
- PyErr_Format(PyExc_TypeError,
- "sequence type expected, got '%s'",
- Py_TYPE(handle_seq)->tp_doc);
- return NULL;
- }
- nhandles = PySequence_Length(handle_seq);
- if (nhandles == -1)
- return NULL;
- if (nhandles < 0 || nhandles >= MAXIMUM_WAIT_OBJECTS - 1) {
- PyErr_Format(PyExc_ValueError,
- "need at most %zd handles, got a sequence of length %zd",
- MAXIMUM_WAIT_OBJECTS - 1, nhandles);
- return NULL;
- }
- for (i = 0; i < nhandles; i++) {
- HANDLE h;
- PyObject *v = PySequence_GetItem(handle_seq, i);
- if (v == NULL)
- return NULL;
- if (!PyArg_Parse(v, F_HANDLE, &h)) {
- Py_DECREF(v);
- return NULL;
- }
- handles[i] = h;
- Py_DECREF(v);
- }
- /* If this is the main thread then make the wait interruptible
- by Ctrl-C unless we are waiting for *all* handles */
- if (!wait_flag && _PyOS_IsMainThread()) {
- sigint_event = _PyOS_SigintEvent();
- assert(sigint_event != NULL);
- handles[nhandles++] = sigint_event;
- }
-
- Py_BEGIN_ALLOW_THREADS
- if (sigint_event != NULL)
- ResetEvent(sigint_event);
- result = WaitForMultipleObjects((DWORD) nhandles, handles,
- (BOOL) wait_flag, (DWORD) milliseconds);
- Py_END_ALLOW_THREADS
-
- if (result == WAIT_FAILED)
- return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0);
- else if (sigint_event != NULL && result == WAIT_OBJECT_0 + nhandles - 1) {
- errno = EINTR;
- return PyErr_SetFromErrno(PyExc_IOError);
- }
-
- return PyLong_FromLong((int) result);
-}
-
-
-static PyMethodDef win32_methods[] = {
- WIN32_FUNCTION(CloseHandle),
- WIN32_FUNCTION(GetLastError),
- WIN32_FUNCTION(OpenProcess),
- WIN32_FUNCTION(ExitProcess),
- WIN32_KWARGS_FUNCTION(ConnectNamedPipe),
- WIN32_FUNCTION(CreateFile),
- WIN32_FUNCTION(CreateNamedPipe),
- WIN32_KWARGS_FUNCTION(ReadFile),
- WIN32_FUNCTION(PeekNamedPipe),
- WIN32_FUNCTION(SetNamedPipeHandleState),
- WIN32_FUNCTION(WaitForMultipleObjects),
- WIN32_FUNCTION(WaitNamedPipe),
- WIN32_KWARGS_FUNCTION(WriteFile),
- WIN32_FUNCTION(closesocket),
- WIN32_FUNCTION(recv),
- WIN32_FUNCTION(send),
- {NULL}
-};
-
-
-PyTypeObject Win32Type = {
- PyVarObject_HEAD_INIT(NULL, 0)
-};
-
-
-PyObject *
-create_win32_namespace(void)
-{
- Win32Type.tp_name = "_multiprocessing.win32";
- Win32Type.tp_methods = win32_methods;
- if (PyType_Ready(&Win32Type) < 0)
- return NULL;
- Py_INCREF(&Win32Type);
-
- if (PyType_Ready(&OverlappedType) < 0)
- return NULL;
- PyDict_SetItemString(Win32Type.tp_dict, "Overlapped",
- (PyObject *) &OverlappedType);
-
- WIN32_CONSTANT(F_DWORD, ERROR_ALREADY_EXISTS);
- WIN32_CONSTANT(F_DWORD, ERROR_BROKEN_PIPE);
- WIN32_CONSTANT(F_DWORD, ERROR_IO_PENDING);
- WIN32_CONSTANT(F_DWORD, ERROR_MORE_DATA);
- WIN32_CONSTANT(F_DWORD, ERROR_NETNAME_DELETED);
- WIN32_CONSTANT(F_DWORD, ERROR_NO_SYSTEM_RESOURCES);
- WIN32_CONSTANT(F_DWORD, ERROR_OPERATION_ABORTED);
- WIN32_CONSTANT(F_DWORD, ERROR_PIPE_BUSY);
- WIN32_CONSTANT(F_DWORD, ERROR_PIPE_CONNECTED);
- WIN32_CONSTANT(F_DWORD, ERROR_SEM_TIMEOUT);
- WIN32_CONSTANT(F_DWORD, FILE_FLAG_FIRST_PIPE_INSTANCE);
- WIN32_CONSTANT(F_DWORD, FILE_FLAG_OVERLAPPED);
- WIN32_CONSTANT(F_DWORD, GENERIC_READ);
- WIN32_CONSTANT(F_DWORD, GENERIC_WRITE);
- WIN32_CONSTANT(F_DWORD, INFINITE);
- WIN32_CONSTANT(F_DWORD, NMPWAIT_WAIT_FOREVER);
- WIN32_CONSTANT(F_DWORD, OPEN_EXISTING);
- WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_DUPLEX);
- WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_INBOUND);
- WIN32_CONSTANT(F_DWORD, PIPE_READMODE_MESSAGE);
- WIN32_CONSTANT(F_DWORD, PIPE_TYPE_MESSAGE);
- WIN32_CONSTANT(F_DWORD, PIPE_UNLIMITED_INSTANCES);
- WIN32_CONSTANT(F_DWORD, PIPE_WAIT);
- WIN32_CONSTANT(F_DWORD, PROCESS_ALL_ACCESS);
-
- WIN32_CONSTANT("i", NULL);
-
- return (PyObject*)&Win32Type;
-}