/*

 * 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_CONSTANT(fmt, con) \

    PyDict_SetItemString(Win32Type.tp_dict, #con, Py_BuildValue(fmt, con))

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)

{

	HANDLE hNamedPipe;

	LPOVERLAPPED lpOverlapped;

	BOOL success;

	if (!PyArg_ParseTuple(args, F_HANDLE F_POINTER, 

			      &hNamedPipe, &lpOverlapped))

		return NULL;

	Py_BEGIN_ALLOW_THREADS

	success = ConnectNamedPipe(hNamedPipe, lpOverlapped);

	Py_END_ALLOW_THREADS

	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;

	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] = PyInt_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 PyMethodDef win32_methods[] = {

	WIN32_FUNCTION(CloseHandle),

	WIN32_FUNCTION(GetLastError),

	WIN32_FUNCTION(OpenProcess),

	WIN32_FUNCTION(ExitProcess),

	WIN32_FUNCTION(ConnectNamedPipe),

	WIN32_FUNCTION(CreateFile),

	WIN32_FUNCTION(CreateNamedPipe),

	WIN32_FUNCTION(SetNamedPipeHandleState),

	WIN32_FUNCTION(WaitNamedPipe),

	{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);

	WIN32_CONSTANT(F_DWORD, ERROR_ALREADY_EXISTS);

	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, 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;

}