Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 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 | #define WIN32_FUNCTION(func) \ |
| 13 | {#func, (PyCFunction)win32_ ## func, METH_VARARGS | METH_STATIC, ""} |
| 14 | |
| 15 | #define WIN32_CONSTANT(fmt, con) \ |
| 16 | PyDict_SetItemString(Win32Type.tp_dict, #con, Py_BuildValue(fmt, con)) |
| 17 | |
| 18 | |
| 19 | static PyObject * |
| 20 | win32_CloseHandle(PyObject *self, PyObject *args) |
| 21 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 22 | HANDLE hObject; |
| 23 | BOOL success; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 24 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 25 | if (!PyArg_ParseTuple(args, F_HANDLE, &hObject)) |
| 26 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 27 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 28 | Py_BEGIN_ALLOW_THREADS |
| 29 | success = CloseHandle(hObject); |
| 30 | Py_END_ALLOW_THREADS |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 31 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 32 | if (!success) |
| 33 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 34 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 35 | Py_RETURN_NONE; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 36 | } |
| 37 | |
| 38 | static PyObject * |
| 39 | win32_ConnectNamedPipe(PyObject *self, PyObject *args) |
| 40 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 41 | HANDLE hNamedPipe; |
| 42 | LPOVERLAPPED lpOverlapped; |
| 43 | BOOL success; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 44 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 45 | if (!PyArg_ParseTuple(args, F_HANDLE F_POINTER, |
| 46 | &hNamedPipe, &lpOverlapped)) |
| 47 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 48 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 49 | Py_BEGIN_ALLOW_THREADS |
| 50 | success = ConnectNamedPipe(hNamedPipe, lpOverlapped); |
| 51 | Py_END_ALLOW_THREADS |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 52 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 53 | if (!success) |
| 54 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 55 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 56 | Py_RETURN_NONE; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 57 | } |
| 58 | |
| 59 | static PyObject * |
| 60 | win32_CreateFile(PyObject *self, PyObject *args) |
| 61 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 62 | LPCTSTR lpFileName; |
| 63 | DWORD dwDesiredAccess; |
| 64 | DWORD dwShareMode; |
| 65 | LPSECURITY_ATTRIBUTES lpSecurityAttributes; |
| 66 | DWORD dwCreationDisposition; |
| 67 | DWORD dwFlagsAndAttributes; |
| 68 | HANDLE hTemplateFile; |
| 69 | HANDLE handle; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 70 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 71 | if (!PyArg_ParseTuple(args, "s" F_DWORD F_DWORD F_POINTER |
| 72 | F_DWORD F_DWORD F_HANDLE, |
| 73 | &lpFileName, &dwDesiredAccess, &dwShareMode, |
| 74 | &lpSecurityAttributes, &dwCreationDisposition, |
| 75 | &dwFlagsAndAttributes, &hTemplateFile)) |
| 76 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 77 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 78 | Py_BEGIN_ALLOW_THREADS |
| 79 | handle = CreateFile(lpFileName, dwDesiredAccess, |
| 80 | dwShareMode, lpSecurityAttributes, |
| 81 | dwCreationDisposition, |
| 82 | dwFlagsAndAttributes, hTemplateFile); |
| 83 | Py_END_ALLOW_THREADS |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 84 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 85 | if (handle == INVALID_HANDLE_VALUE) |
| 86 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 87 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 88 | return Py_BuildValue(F_HANDLE, handle); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | static PyObject * |
| 92 | win32_CreateNamedPipe(PyObject *self, PyObject *args) |
| 93 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 94 | LPCTSTR lpName; |
| 95 | DWORD dwOpenMode; |
| 96 | DWORD dwPipeMode; |
| 97 | DWORD nMaxInstances; |
| 98 | DWORD nOutBufferSize; |
| 99 | DWORD nInBufferSize; |
| 100 | DWORD nDefaultTimeOut; |
| 101 | LPSECURITY_ATTRIBUTES lpSecurityAttributes; |
| 102 | HANDLE handle; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 103 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 104 | if (!PyArg_ParseTuple(args, "s" F_DWORD F_DWORD F_DWORD |
| 105 | F_DWORD F_DWORD F_DWORD F_POINTER, |
| 106 | &lpName, &dwOpenMode, &dwPipeMode, |
| 107 | &nMaxInstances, &nOutBufferSize, |
| 108 | &nInBufferSize, &nDefaultTimeOut, |
| 109 | &lpSecurityAttributes)) |
| 110 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 111 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 112 | Py_BEGIN_ALLOW_THREADS |
| 113 | handle = CreateNamedPipe(lpName, dwOpenMode, dwPipeMode, |
| 114 | nMaxInstances, nOutBufferSize, |
| 115 | nInBufferSize, nDefaultTimeOut, |
| 116 | lpSecurityAttributes); |
| 117 | Py_END_ALLOW_THREADS |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 118 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 119 | if (handle == INVALID_HANDLE_VALUE) |
| 120 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 121 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 122 | return Py_BuildValue(F_HANDLE, handle); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | static PyObject * |
| 126 | win32_ExitProcess(PyObject *self, PyObject *args) |
| 127 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 128 | UINT uExitCode; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 129 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 130 | if (!PyArg_ParseTuple(args, "I", &uExitCode)) |
| 131 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 132 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 133 | #if defined(Py_DEBUG) |
| 134 | SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOALIGNMENTFAULTEXCEPT|SEM_NOGPFAULTERRORBOX|SEM_NOOPENFILEERRORBOX); |
| 135 | _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG); |
| 136 | #endif |
Kristján Valur Jónsson | b8e138a | 2009-07-04 15:16:38 +0000 | [diff] [blame] | 137 | |
| 138 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 139 | ExitProcess(uExitCode); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 140 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 141 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | static PyObject * |
| 145 | win32_GetLastError(PyObject *self, PyObject *args) |
| 146 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 147 | return Py_BuildValue(F_DWORD, GetLastError()); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | static PyObject * |
| 151 | win32_OpenProcess(PyObject *self, PyObject *args) |
| 152 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 153 | DWORD dwDesiredAccess; |
| 154 | BOOL bInheritHandle; |
| 155 | DWORD dwProcessId; |
| 156 | HANDLE handle; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 157 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 158 | if (!PyArg_ParseTuple(args, F_DWORD "i" F_DWORD, |
| 159 | &dwDesiredAccess, &bInheritHandle, &dwProcessId)) |
| 160 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 161 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 162 | handle = OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId); |
| 163 | if (handle == NULL) |
| 164 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 165 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 166 | return Py_BuildValue(F_HANDLE, handle); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 167 | } |
| 168 | |
| 169 | static PyObject * |
| 170 | win32_SetNamedPipeHandleState(PyObject *self, PyObject *args) |
| 171 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 172 | HANDLE hNamedPipe; |
| 173 | PyObject *oArgs[3]; |
| 174 | DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL}; |
| 175 | int i; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 176 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 177 | if (!PyArg_ParseTuple(args, F_HANDLE "OOO", |
| 178 | &hNamedPipe, &oArgs[0], &oArgs[1], &oArgs[2])) |
| 179 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 180 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 181 | PyErr_Clear(); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 182 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 183 | for (i = 0 ; i < 3 ; i++) { |
| 184 | if (oArgs[i] != Py_None) { |
| 185 | dwArgs[i] = PyLong_AsUnsignedLongMask(oArgs[i]); |
| 186 | if (PyErr_Occurred()) |
| 187 | return NULL; |
| 188 | pArgs[i] = &dwArgs[i]; |
| 189 | } |
| 190 | } |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 191 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 192 | if (!SetNamedPipeHandleState(hNamedPipe, pArgs[0], pArgs[1], pArgs[2])) |
| 193 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 194 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 195 | Py_RETURN_NONE; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | static PyObject * |
| 199 | win32_WaitNamedPipe(PyObject *self, PyObject *args) |
| 200 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 201 | LPCTSTR lpNamedPipeName; |
| 202 | DWORD nTimeOut; |
| 203 | BOOL success; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 204 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 205 | if (!PyArg_ParseTuple(args, "s" F_DWORD, &lpNamedPipeName, &nTimeOut)) |
| 206 | return NULL; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 207 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 208 | Py_BEGIN_ALLOW_THREADS |
| 209 | success = WaitNamedPipe(lpNamedPipeName, nTimeOut); |
| 210 | Py_END_ALLOW_THREADS |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 211 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 212 | if (!success) |
| 213 | return PyErr_SetFromWindowsErr(0); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 214 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 215 | Py_RETURN_NONE; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 216 | } |
| 217 | |
Antoine Pitrou | 87cf220 | 2011-05-09 17:04:27 +0200 | [diff] [blame] | 218 | static PyObject * |
| 219 | win32_closesocket(PyObject *self, PyObject *args) |
| 220 | { |
| 221 | HANDLE handle; |
| 222 | int ret; |
| 223 | |
| 224 | if (!PyArg_ParseTuple(args, F_HANDLE ":closesocket" , &handle)) |
| 225 | return NULL; |
| 226 | |
| 227 | Py_BEGIN_ALLOW_THREADS |
| 228 | ret = closesocket((SOCKET) handle); |
| 229 | Py_END_ALLOW_THREADS |
| 230 | |
| 231 | if (ret) |
| 232 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError()); |
| 233 | Py_RETURN_NONE; |
| 234 | } |
| 235 | |
| 236 | static PyObject * |
| 237 | win32_recv(PyObject *self, PyObject *args) |
| 238 | { |
| 239 | HANDLE handle; |
| 240 | int size, nread; |
| 241 | PyObject *buf; |
| 242 | |
| 243 | if (!PyArg_ParseTuple(args, F_HANDLE "i:recv" , &handle, &size)) |
| 244 | return NULL; |
| 245 | |
| 246 | buf = PyBytes_FromStringAndSize(NULL, size); |
| 247 | if (!buf) |
| 248 | return NULL; |
| 249 | |
| 250 | Py_BEGIN_ALLOW_THREADS |
| 251 | nread = recv((SOCKET) handle, PyBytes_AS_STRING(buf), size, 0); |
| 252 | Py_END_ALLOW_THREADS |
| 253 | |
| 254 | if (nread < 0) { |
| 255 | Py_DECREF(buf); |
| 256 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError()); |
| 257 | } |
| 258 | _PyBytes_Resize(&buf, nread); |
| 259 | return buf; |
| 260 | } |
| 261 | |
| 262 | static PyObject * |
| 263 | win32_send(PyObject *self, PyObject *args) |
| 264 | { |
| 265 | HANDLE handle; |
| 266 | Py_buffer buf; |
| 267 | int ret; |
| 268 | |
| 269 | if (!PyArg_ParseTuple(args, F_HANDLE "y*:send" , &handle, &buf)) |
| 270 | return NULL; |
| 271 | |
| 272 | Py_BEGIN_ALLOW_THREADS |
| 273 | ret = send((SOCKET) handle, buf.buf, buf.len, 0); |
| 274 | Py_END_ALLOW_THREADS |
| 275 | |
| 276 | PyBuffer_Release(&buf); |
| 277 | if (ret < 0) |
| 278 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, WSAGetLastError()); |
| 279 | return PyLong_FromLong(ret); |
| 280 | } |
| 281 | |
| 282 | static PyObject * |
| 283 | win32_WriteFile(PyObject *self, PyObject *args) |
| 284 | { |
| 285 | HANDLE handle; |
| 286 | Py_buffer buf; |
| 287 | int written; |
| 288 | BOOL ret; |
| 289 | |
| 290 | if (!PyArg_ParseTuple(args, F_HANDLE "y*:WriteFile" , &handle, &buf)) |
| 291 | return NULL; |
| 292 | |
| 293 | Py_BEGIN_ALLOW_THREADS |
| 294 | ret = WriteFile(handle, buf.buf, buf.len, &written, NULL); |
| 295 | Py_END_ALLOW_THREADS |
| 296 | |
| 297 | PyBuffer_Release(&buf); |
| 298 | if (!ret) |
| 299 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0); |
| 300 | return PyLong_FromLong(written); |
| 301 | } |
| 302 | |
| 303 | static PyObject * |
| 304 | win32_ReadFile(PyObject *self, PyObject *args) |
| 305 | { |
| 306 | HANDLE handle; |
| 307 | int size; |
| 308 | DWORD nread; |
| 309 | PyObject *buf; |
| 310 | BOOL ret; |
| 311 | |
| 312 | if (!PyArg_ParseTuple(args, F_HANDLE "i:ReadFile" , &handle, &size)) |
| 313 | return NULL; |
| 314 | |
| 315 | buf = PyBytes_FromStringAndSize(NULL, size); |
| 316 | if (!buf) |
| 317 | return NULL; |
| 318 | |
| 319 | Py_BEGIN_ALLOW_THREADS |
| 320 | ret = ReadFile(handle, PyBytes_AS_STRING(buf), size, &nread, NULL); |
| 321 | Py_END_ALLOW_THREADS |
| 322 | |
| 323 | if (!ret && GetLastError() != ERROR_MORE_DATA) { |
| 324 | Py_DECREF(buf); |
| 325 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0); |
| 326 | } |
| 327 | if (_PyBytes_Resize(&buf, nread)) |
| 328 | return NULL; |
| 329 | return Py_BuildValue("NN", buf, PyBool_FromLong(ret)); |
| 330 | } |
| 331 | |
| 332 | static PyObject * |
| 333 | win32_PeekNamedPipe(PyObject *self, PyObject *args) |
| 334 | { |
| 335 | HANDLE handle; |
| 336 | int size = 0; |
| 337 | PyObject *buf = NULL; |
| 338 | DWORD nread, navail, nleft; |
| 339 | BOOL ret; |
| 340 | |
| 341 | if (!PyArg_ParseTuple(args, F_HANDLE "|i:PeekNamedPipe" , &handle, &size)) |
| 342 | return NULL; |
| 343 | |
| 344 | if (size < 0) { |
| 345 | PyErr_SetString(PyExc_ValueError, "negative size"); |
| 346 | return NULL; |
| 347 | } |
| 348 | |
| 349 | if (size) { |
| 350 | buf = PyBytes_FromStringAndSize(NULL, size); |
| 351 | if (!buf) |
| 352 | return NULL; |
| 353 | Py_BEGIN_ALLOW_THREADS |
| 354 | ret = PeekNamedPipe(handle, PyBytes_AS_STRING(buf), size, &nread, |
| 355 | &navail, &nleft); |
| 356 | Py_END_ALLOW_THREADS |
| 357 | if (!ret) { |
| 358 | Py_DECREF(buf); |
| 359 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0); |
| 360 | } |
| 361 | if (_PyBytes_Resize(&buf, nread)) |
| 362 | return NULL; |
| 363 | return Py_BuildValue("Nii", buf, navail, nleft); |
| 364 | } |
| 365 | else { |
| 366 | Py_BEGIN_ALLOW_THREADS |
| 367 | ret = PeekNamedPipe(handle, NULL, 0, NULL, &navail, &nleft); |
| 368 | Py_END_ALLOW_THREADS |
| 369 | if (!ret) { |
| 370 | return PyErr_SetExcFromWindowsErr(PyExc_IOError, 0); |
| 371 | } |
| 372 | return Py_BuildValue("ii", navail, nleft); |
| 373 | } |
| 374 | } |
| 375 | |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 376 | static PyMethodDef win32_methods[] = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 377 | WIN32_FUNCTION(CloseHandle), |
| 378 | WIN32_FUNCTION(GetLastError), |
| 379 | WIN32_FUNCTION(OpenProcess), |
| 380 | WIN32_FUNCTION(ExitProcess), |
| 381 | WIN32_FUNCTION(ConnectNamedPipe), |
| 382 | WIN32_FUNCTION(CreateFile), |
| 383 | WIN32_FUNCTION(CreateNamedPipe), |
Antoine Pitrou | 87cf220 | 2011-05-09 17:04:27 +0200 | [diff] [blame] | 384 | WIN32_FUNCTION(ReadFile), |
| 385 | WIN32_FUNCTION(PeekNamedPipe), |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 386 | WIN32_FUNCTION(SetNamedPipeHandleState), |
| 387 | WIN32_FUNCTION(WaitNamedPipe), |
Antoine Pitrou | 87cf220 | 2011-05-09 17:04:27 +0200 | [diff] [blame] | 388 | WIN32_FUNCTION(WriteFile), |
| 389 | WIN32_FUNCTION(closesocket), |
| 390 | WIN32_FUNCTION(recv), |
| 391 | WIN32_FUNCTION(send), |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 392 | {NULL} |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 393 | }; |
| 394 | |
| 395 | |
| 396 | PyTypeObject Win32Type = { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 397 | PyVarObject_HEAD_INIT(NULL, 0) |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 398 | }; |
| 399 | |
| 400 | |
| 401 | PyObject * |
| 402 | create_win32_namespace(void) |
| 403 | { |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 404 | Win32Type.tp_name = "_multiprocessing.win32"; |
| 405 | Win32Type.tp_methods = win32_methods; |
| 406 | if (PyType_Ready(&Win32Type) < 0) |
| 407 | return NULL; |
| 408 | Py_INCREF(&Win32Type); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 409 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 410 | WIN32_CONSTANT(F_DWORD, ERROR_ALREADY_EXISTS); |
Antoine Pitrou | 87cf220 | 2011-05-09 17:04:27 +0200 | [diff] [blame] | 411 | WIN32_CONSTANT(F_DWORD, ERROR_BROKEN_PIPE); |
| 412 | WIN32_CONSTANT(F_DWORD, ERROR_NO_SYSTEM_RESOURCES); |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 413 | WIN32_CONSTANT(F_DWORD, ERROR_PIPE_BUSY); |
| 414 | WIN32_CONSTANT(F_DWORD, ERROR_PIPE_CONNECTED); |
| 415 | WIN32_CONSTANT(F_DWORD, ERROR_SEM_TIMEOUT); |
| 416 | WIN32_CONSTANT(F_DWORD, GENERIC_READ); |
| 417 | WIN32_CONSTANT(F_DWORD, GENERIC_WRITE); |
| 418 | WIN32_CONSTANT(F_DWORD, INFINITE); |
| 419 | WIN32_CONSTANT(F_DWORD, NMPWAIT_WAIT_FOREVER); |
| 420 | WIN32_CONSTANT(F_DWORD, OPEN_EXISTING); |
| 421 | WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_DUPLEX); |
| 422 | WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_INBOUND); |
| 423 | WIN32_CONSTANT(F_DWORD, PIPE_READMODE_MESSAGE); |
| 424 | WIN32_CONSTANT(F_DWORD, PIPE_TYPE_MESSAGE); |
| 425 | WIN32_CONSTANT(F_DWORD, PIPE_UNLIMITED_INSTANCES); |
| 426 | WIN32_CONSTANT(F_DWORD, PIPE_WAIT); |
| 427 | WIN32_CONSTANT(F_DWORD, PROCESS_ALL_ACCESS); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 428 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 429 | WIN32_CONSTANT("i", NULL); |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 430 | |
Antoine Pitrou | f95a1b3 | 2010-05-09 15:52:27 +0000 | [diff] [blame] | 431 | return (PyObject*)&Win32Type; |
Benjamin Peterson | fa26803 | 2008-06-13 19:28:21 +0000 | [diff] [blame] | 432 | } |