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 {

    22 	HANDLE hObject;

    23 	BOOL success;

    24 

    25 	if (!PyArg_ParseTuple(args, F_HANDLE, &hObject))

    26 		return NULL;

    27 

    28 	Py_BEGIN_ALLOW_THREADS

    29 	success = CloseHandle(hObject); 

    30 	Py_END_ALLOW_THREADS

    31 

    32 	if (!success)

    33 		return PyErr_SetFromWindowsErr(0);

    34 

    35 	Py_RETURN_NONE;

    36 }

    37 

    38 static PyObject *

    39 win32_ConnectNamedPipe(PyObject *self, PyObject *args)

    40 {

    41 	HANDLE hNamedPipe;

    42 	LPOVERLAPPED lpOverlapped;

    43 	BOOL success;

    44 

    45 	if (!PyArg_ParseTuple(args, F_HANDLE F_POINTER, 

    46 			      &hNamedPipe, &lpOverlapped))

    47 		return NULL;

    48 

    49 	Py_BEGIN_ALLOW_THREADS

    50 	success = ConnectNamedPipe(hNamedPipe, lpOverlapped);

    51 	Py_END_ALLOW_THREADS

    52 

    53 	if (!success)

    54 		return PyErr_SetFromWindowsErr(0);

    55 

    56 	Py_RETURN_NONE;

    57 }

    58 

    59 static PyObject *

    60 win32_CreateFile(PyObject *self, PyObject *args)

    61 {

    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;

    70 

    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;

    77 

    78 	Py_BEGIN_ALLOW_THREADS

    79 	handle = CreateFile(lpFileName, dwDesiredAccess, 

    80 			    dwShareMode, lpSecurityAttributes, 

    81 			    dwCreationDisposition, 

    82 			    dwFlagsAndAttributes, hTemplateFile);

    83 	Py_END_ALLOW_THREADS

    84 

    85 	if (handle == INVALID_HANDLE_VALUE)

    86 		return PyErr_SetFromWindowsErr(0);

    87 

    88 	return Py_BuildValue(F_HANDLE, handle);

    89 }

    90 

    91 static PyObject *

    92 win32_CreateNamedPipe(PyObject *self, PyObject *args)

    93 {

    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;

   103 

   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;

   111 

   112 	Py_BEGIN_ALLOW_THREADS

   113 	handle = CreateNamedPipe(lpName, dwOpenMode, dwPipeMode, 

   114 				 nMaxInstances, nOutBufferSize, 

   115 				 nInBufferSize, nDefaultTimeOut,

   116 				 lpSecurityAttributes);

   117 	Py_END_ALLOW_THREADS

   118 

   119 	if (handle == INVALID_HANDLE_VALUE)

   120 		return PyErr_SetFromWindowsErr(0);

   121 

   122 	return Py_BuildValue(F_HANDLE, handle);

   123 }

   124 

   125 static PyObject *

   126 win32_ExitProcess(PyObject *self, PyObject *args)

   127 {

   128 	UINT uExitCode;

   129 

   130 	if (!PyArg_ParseTuple(args, "I", &uExitCode))

   131 		return NULL;

   132 

   133 	ExitProcess(uExitCode);

   134 

   135 	return NULL;

   136 }

   137 

   138 static PyObject *

   139 win32_GetLastError(PyObject *self, PyObject *args)

   140 {

   141 	return Py_BuildValue(F_DWORD, GetLastError());

   142 }

   143 

   144 static PyObject *

   145 win32_OpenProcess(PyObject *self, PyObject *args)

   146 {

   147 	DWORD dwDesiredAccess;

   148 	BOOL bInheritHandle;

   149 	DWORD dwProcessId;

   150 	HANDLE handle;

   151 

   152 	if (!PyArg_ParseTuple(args, F_DWORD "i" F_DWORD, 

   153 			      &dwDesiredAccess, &bInheritHandle, &dwProcessId))

   154 		return NULL;

   155 

   156 	handle = OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId);    

   157 	if (handle == NULL)

   158 		return PyErr_SetFromWindowsErr(0);

   159 

   160 	return Py_BuildValue(F_HANDLE, handle);

   161 }

   162 

   163 static PyObject *

   164 win32_SetNamedPipeHandleState(PyObject *self, PyObject *args)

   165 {

   166 	HANDLE hNamedPipe;

   167 	PyObject *oArgs[3];

   168 	DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL};

   169 	int i;

   170 

   171 	if (!PyArg_ParseTuple(args, F_HANDLE "OOO", 

   172 			      &hNamedPipe, &oArgs[0], &oArgs[1], &oArgs[2]))

   173 		return NULL;

   174 

   175 	PyErr_Clear();

   176 

   177 	for (i = 0 ; i < 3 ; i++) {

   178 		if (oArgs[i] != Py_None) {

   179 			dwArgs[i] = PyInt_AsUnsignedLongMask(oArgs[i]);

   180 			if (PyErr_Occurred())

   181 				return NULL;

   182 			pArgs[i] = &dwArgs[i];

   183 		}

   184 	}

   185 

   186 	if (!SetNamedPipeHandleState(hNamedPipe, pArgs[0], pArgs[1], pArgs[2]))

   187 		return PyErr_SetFromWindowsErr(0);

   188 

   189 	Py_RETURN_NONE;

   190 }

   191 

   192 static PyObject *

   193 win32_WaitNamedPipe(PyObject *self, PyObject *args)

   194 {

   195 	LPCTSTR lpNamedPipeName;

   196 	DWORD nTimeOut;

   197 	BOOL success;

   198 

   199 	if (!PyArg_ParseTuple(args, "s" F_DWORD, &lpNamedPipeName, &nTimeOut))

   200 		return NULL;

   201 

   202 	Py_BEGIN_ALLOW_THREADS

   203 	success = WaitNamedPipe(lpNamedPipeName, nTimeOut);

   204 	Py_END_ALLOW_THREADS

   205 

   206 	if (!success)

   207 		return PyErr_SetFromWindowsErr(0);

   208 

   209 	Py_RETURN_NONE;

   210 }

   211 

   212 static PyMethodDef win32_methods[] = {

   213 	WIN32_FUNCTION(CloseHandle),

   214 	WIN32_FUNCTION(GetLastError),

   215 	WIN32_FUNCTION(OpenProcess),

   216 	WIN32_FUNCTION(ExitProcess),

   217 	WIN32_FUNCTION(ConnectNamedPipe),

   218 	WIN32_FUNCTION(CreateFile),

   219 	WIN32_FUNCTION(CreateNamedPipe),

   220 	WIN32_FUNCTION(SetNamedPipeHandleState),

   221 	WIN32_FUNCTION(WaitNamedPipe),

   222 	{NULL}

   223 };

   224 

   225 

   226 PyTypeObject Win32Type = {

   227 	PyVarObject_HEAD_INIT(NULL, 0)

   228 };

   229 

   230 

   231 PyObject *

   232 create_win32_namespace(void)

   233 {

   234 	Win32Type.tp_name = "_multiprocessing.win32";

   235 	Win32Type.tp_methods = win32_methods;

   236 	if (PyType_Ready(&Win32Type) < 0)

   237 		return NULL;

   238 	Py_INCREF(&Win32Type);

   239 

   240 	WIN32_CONSTANT(F_DWORD, ERROR_ALREADY_EXISTS);

   241 	WIN32_CONSTANT(F_DWORD, ERROR_PIPE_BUSY);

   242 	WIN32_CONSTANT(F_DWORD, ERROR_PIPE_CONNECTED);

   243 	WIN32_CONSTANT(F_DWORD, ERROR_SEM_TIMEOUT);

   244 	WIN32_CONSTANT(F_DWORD, GENERIC_READ);

   245 	WIN32_CONSTANT(F_DWORD, GENERIC_WRITE);

   246 	WIN32_CONSTANT(F_DWORD, INFINITE);

   247 	WIN32_CONSTANT(F_DWORD, NMPWAIT_WAIT_FOREVER);

   248 	WIN32_CONSTANT(F_DWORD, OPEN_EXISTING);

   249 	WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_DUPLEX);

   250 	WIN32_CONSTANT(F_DWORD, PIPE_ACCESS_INBOUND);

   251 	WIN32_CONSTANT(F_DWORD, PIPE_READMODE_MESSAGE);

   252 	WIN32_CONSTANT(F_DWORD, PIPE_TYPE_MESSAGE);

   253 	WIN32_CONSTANT(F_DWORD, PIPE_UNLIMITED_INSTANCES);

   254 	WIN32_CONSTANT(F_DWORD, PIPE_WAIT);

   255 	WIN32_CONSTANT(F_DWORD, PROCESS_ALL_ACCESS);

   256 

   257 	WIN32_CONSTANT("i", NULL);

   258 

   259 	return (PyObject*)&Win32Type;

   260 }