#include "Python.h"

#include "structmember.h"

#define WINDOWS_LEAN_AND_MEAN

#include "windows.h"

#include <crtdbg.h>

#include "winreparse.h"

#if defined(MS_WIN32) && !defined(MS_WIN64)

#define HANDLE_TO_PYNUM(handle) \

PyLong_FromUnsignedLong((unsigned long) handle)

#define PYNUM_TO_HANDLE(obj) ((HANDLE)PyLong_AsUnsignedLong(obj))

#define F_POINTER "k"

#define T_POINTER T_ULONG

#define HANDLE_TO_PYNUM(handle) \

PyLong_FromUnsignedLongLong((unsigned long long) handle)

#define PYNUM_TO_HANDLE(obj) ((HANDLE)PyLong_AsUnsignedLongLong(obj))

#define F_POINTER "K"

#define T_POINTER T_ULONGLONG

#define F_HANDLE F_POINTER

#define F_DWORD "k"

#define T_HANDLE T_POINTER

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;

}

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

if (check_CancelIoEx() &&

Py_CancelIoEx(self->handle, &self->overlapped) &&

GetOverlappedResult(self->handle, &self->overlapped, &bytes, TRUE))

{

/* The operation is no longer pending -- nothing to do. */

}

else if (_Py_IsFinalizing())

{

/* The operation is still pending -- give a warning. This

PyErr_SetString(PyExc_RuntimeError,

"I/O operations still in flight while destroying "

"Overlapped object, the process may crash");

PyErr_WriteUnraisable(NULL);

}

else

{

/* The operation is still pending, but the process is

CloseHandle(self->overlapped.hEvent);

SetLastError(err);

return;

}

}

CloseHandle(self->overlapped.hEvent);

SetLastError(err);

if (self->write_buffer.obj)

PyBuffer_Release(&self->write_buffer);

Py_CLEAR(self->read_buffer);

PyObject_Del(self);

}

#include "clinic/_winapi.c.h"

static PyObject *

_winapi_Overlapped_GetOverlappedResult_impl(OverlappedObject *self, int wait)

{

BOOL res;

DWORD transferred = 0;

DWORD err;

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_OSError, 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 *

_winapi_Overlapped_getbuffer_impl(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 *

_winapi_Overlapped_cancel_impl(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_OSError, 0);

self->pending = 0;

Py_RETURN_NONE;

}

static PyMethodDef overlapped_methods[] = {

_WINAPI_OVERLAPPED_GETOVERLAPPEDRESULT_METHODDEF

_WINAPI_OVERLAPPED_GETBUFFER_METHODDEF

_WINAPI_OVERLAPPED_CANCEL_METHODDEF

{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 */ "_winapi.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;

}

static PyObject *

_winapi_CloseHandle_impl(PyObject *module, HANDLE handle)

{

BOOL success;

Py_BEGIN_ALLOW_THREADS

success = CloseHandle(handle);

Py_END_ALLOW_THREADS

if (!success)

return PyErr_SetFromWindowsErr(0);

Py_RETURN_NONE;

}

static PyObject *

_winapi_ConnectNamedPipe_impl(PyObject *module, HANDLE handle,

int use_overlapped)

{

BOOL success;

OverlappedObject *overlapped = NULL;

if (use_overlapped) {

overlapped = new_overlapped(handle);

if (!overlapped)

return NULL;

}

Py_BEGIN_ALLOW_THREADS

success = ConnectNamedPipe(handle,

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 HANDLE

_winapi_CreateFile_impl(PyObject *module, LPCTSTR file_name,

DWORD flags_and_attributes, HANDLE template_file)

{

HANDLE handle;

Py_BEGIN_ALLOW_THREADS

handle = CreateFile(file_name, desired_access,

share_mode, security_attributes,

creation_disposition,

flags_and_attributes, template_file);

Py_END_ALLOW_THREADS

if (handle == INVALID_HANDLE_VALUE)

PyErr_SetFromWindowsErr(0);

return handle;

}

static PyObject *

_winapi_CreateJunction_impl(PyObject *module, LPWSTR src_path,

LPWSTR dst_path)

{

/* Privilege adjustment */

HANDLE token = NULL;

TOKEN_PRIVILEGES tp;

/* Reparse data buffer */

const USHORT prefix_len = 4;

USHORT print_len = 0;

USHORT rdb_size = 0;

_Py_PREPARSE_DATA_BUFFER rdb = NULL;

/* Junction point creation */

HANDLE junction = NULL;

DWORD ret = 0;

if (src_path == NULL || dst_path == NULL)

return PyErr_SetFromWindowsErr(ERROR_INVALID_PARAMETER);

if (wcsncmp(src_path, L"\\??\\", prefix_len) == 0)

return PyErr_SetFromWindowsErr(ERROR_INVALID_PARAMETER);

/* Adjust privileges to allow rewriting directory entry as a

if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))

goto cleanup;

if (!LookupPrivilegeValue(NULL, SE_RESTORE_NAME, &tp.Privileges[0].Luid))

goto cleanup;

tp.PrivilegeCount = 1;

tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

if (!AdjustTokenPrivileges(token, FALSE, &tp, sizeof(TOKEN_PRIVILEGES),

NULL, NULL))

goto cleanup;

if (GetFileAttributesW(src_path) == INVALID_FILE_ATTRIBUTES)

goto cleanup;

/* Store the absolute link target path length in print_len. */

print_len = (USHORT)GetFullPathNameW(src_path, 0, NULL, NULL);

if (print_len == 0)

goto cleanup;

/* NUL terminator should not be part of print_len. */

--print_len;

/* REPARSE_DATA_BUFFER usage is heavily under-documented, especially for

rdb_size = _Py_REPARSE_DATA_BUFFER_HEADER_SIZE +

sizeof(rdb->MountPointReparseBuffer) -

sizeof(rdb->MountPointReparseBuffer.PathBuffer) +

/* Two +1's for NUL terminators. */

(prefix_len + print_len + 1 + print_len + 1) * sizeof(WCHAR);

rdb = (_Py_PREPARSE_DATA_BUFFER)PyMem_RawMalloc(rdb_size);

if (rdb == NULL)

goto cleanup;

memset(rdb, 0, rdb_size);

rdb->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;

rdb->ReparseDataLength = rdb_size - _Py_REPARSE_DATA_BUFFER_HEADER_SIZE;

rdb->MountPointReparseBuffer.SubstituteNameOffset = 0;

rdb->MountPointReparseBuffer.SubstituteNameLength =

(prefix_len + print_len) * sizeof(WCHAR);

rdb->MountPointReparseBuffer.PrintNameOffset =

rdb->MountPointReparseBuffer.SubstituteNameLength + sizeof(WCHAR);

rdb->MountPointReparseBuffer.PrintNameLength = print_len * sizeof(WCHAR);

/* Store the full native path of link target at the substitute name

wcscpy(rdb->MountPointReparseBuffer.PathBuffer, L"\\??\\");

if (GetFullPathNameW(src_path, print_len + 1,

rdb->MountPointReparseBuffer.PathBuffer + prefix_len,

NULL) == 0)

goto cleanup;

/* Copy everything but the native prefix to the print name offset. */

wcscpy(rdb->MountPointReparseBuffer.PathBuffer +

prefix_len + print_len + 1,

rdb->MountPointReparseBuffer.PathBuffer + prefix_len);

/* Create a directory for the junction point. */

if (!CreateDirectoryW(dst_path, NULL))

goto cleanup;

junction = CreateFileW(dst_path, GENERIC_READ | GENERIC_WRITE, 0, NULL,

OPEN_EXISTING,

FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);

if (junction == INVALID_HANDLE_VALUE)

goto cleanup;

/* Make the directory entry a junction point. */

if (!DeviceIoControl(junction, FSCTL_SET_REPARSE_POINT, rdb, rdb_size,

NULL, 0, &ret, NULL))

goto cleanup;

cleanup:

ret = GetLastError();

CloseHandle(token);

CloseHandle(junction);

PyMem_RawFree(rdb);

if (ret != 0)

return PyErr_SetFromWindowsErr(ret);

Py_RETURN_NONE;

}

static HANDLE

_winapi_CreateNamedPipe_impl(PyObject *module, LPCTSTR name, DWORD open_mode,

LPSECURITY_ATTRIBUTES security_attributes)

{

HANDLE handle;

Py_BEGIN_ALLOW_THREADS

handle = CreateNamedPipe(name, open_mode, pipe_mode,

max_instances, out_buffer_size,

in_buffer_size, default_timeout,

security_attributes);

Py_END_ALLOW_THREADS

if (handle == INVALID_HANDLE_VALUE)

PyErr_SetFromWindowsErr(0);

return handle;

}

static PyObject *

_winapi_CreatePipe_impl(PyObject *module, PyObject *pipe_attrs, DWORD size)

{

HANDLE read_pipe;

HANDLE write_pipe;

BOOL result;

Py_BEGIN_ALLOW_THREADS

result = CreatePipe(&read_pipe, &write_pipe, NULL, size);

Py_END_ALLOW_THREADS

if (! result)

return PyErr_SetFromWindowsErr(GetLastError());

return Py_BuildValue(

"NN", HANDLE_TO_PYNUM(read_pipe), HANDLE_TO_PYNUM(write_pipe));

}

static unsigned long

getulong(PyObject* obj, const char* name)

{

PyObject* value;

unsigned long ret;

value = PyObject_GetAttrString(obj, name);

if (! value) {

PyErr_Clear(); /* FIXME: propagate error? */

return 0;

}

ret = PyLong_AsUnsignedLong(value);

Py_DECREF(value);

return ret;

}

static HANDLE

gethandle(PyObject* obj, const char* name)

{

PyObject* value;

HANDLE ret;

value = PyObject_GetAttrString(obj, name);

if (! value) {

PyErr_Clear(); /* FIXME: propagate error? */

return NULL;

}

if (value == Py_None)

ret = NULL;

else

ret = PYNUM_TO_HANDLE(value);

Py_DECREF(value);

return ret;

}

static PyObject*

getenvironment(PyObject* environment)

{

Py_ssize_t i, envsize, totalsize;

Py_UCS4 *buffer = NULL, *p, *end;

PyObject *keys, *values, *res;

/* convert environment dictionary to windows environment string */

if (! PyMapping_Check(environment)) {

PyErr_SetString(

PyExc_TypeError, "environment must be dictionary or None");

return NULL;

}

keys = PyMapping_Keys(environment);

if (!keys) {

return NULL;

}

values = PyMapping_Values(environment);

if (!values) {

goto error;

}

envsize = PySequence_Fast_GET_SIZE(keys);

if (PySequence_Fast_GET_SIZE(values) != envsize) {

PyErr_SetString(PyExc_RuntimeError,

"environment changed size during iteration");

goto error;

}

totalsize = 1; /* trailing null character */

for (i = 0; i < envsize; i++) {

PyObject* key = PySequence_Fast_GET_ITEM(keys, i);

PyObject* value = PySequence_Fast_GET_ITEM(values, i);

if (! PyUnicode_Check(key) || ! PyUnicode_Check(value)) {

PyErr_SetString(PyExc_TypeError,

"environment can only contain strings");

goto error;

}

if (PyUnicode_FindChar(key, '\0', 0, PyUnicode_GET_LENGTH(key), 1) != -1 ||

PyUnicode_FindChar(value, '\0', 0, PyUnicode_GET_LENGTH(value), 1) != -1)

{

PyErr_SetString(PyExc_ValueError, "embedded null character");

goto error;

}

/* Search from index 1 because on Windows starting '=' is allowed for

if (PyUnicode_GET_LENGTH(key) == 0 ||

PyUnicode_FindChar(key, '=', 1, PyUnicode_GET_LENGTH(key), 1) != -1)

{

PyErr_SetString(PyExc_ValueError, "illegal environment variable name");

goto error;

}

if (totalsize > PY_SSIZE_T_MAX - PyUnicode_GET_LENGTH(key) - 1) {

PyErr_SetString(PyExc_OverflowError, "environment too long");

goto error;

}

totalsize += PyUnicode_GET_LENGTH(key) + 1; /* +1 for '=' */

if (totalsize > PY_SSIZE_T_MAX - PyUnicode_GET_LENGTH(value) - 1) {

PyErr_SetString(PyExc_OverflowError, "environment too long");

goto error;

}

totalsize += PyUnicode_GET_LENGTH(value) + 1; /* +1 for '\0' */

}

buffer = PyMem_NEW(Py_UCS4, totalsize);

if (! buffer) {

PyErr_NoMemory();

goto error;

}

p = buffer;

end = buffer + totalsize;

for (i = 0; i < envsize; i++) {

PyObject* key = PySequence_Fast_GET_ITEM(keys, i);

PyObject* value = PySequence_Fast_GET_ITEM(values, i);

if (!PyUnicode_AsUCS4(key, p, end - p, 0))

goto error;

p += PyUnicode_GET_LENGTH(key);

*p++ = '=';

if (!PyUnicode_AsUCS4(value, p, end - p, 0))

goto error;

p += PyUnicode_GET_LENGTH(value);

*p++ = '\0';

}

/* add trailing null byte */

*p++ = '\0';

assert(p == end);

Py_XDECREF(keys);

Py_XDECREF(values);

res = PyUnicode_FromKindAndData(PyUnicode_4BYTE_KIND, buffer, p - buffer);

PyMem_Free(buffer);

return res;

error:

PyMem_Free(buffer);

Py_XDECREF(keys);

Py_XDECREF(values);

return NULL;

}

static LPHANDLE

gethandlelist(PyObject *mapping, const char *name, Py_ssize_t *size)

{

LPHANDLE ret = NULL;

PyObject *value_fast = NULL;

PyObject *value;

Py_ssize_t i;

value = PyMapping_GetItemString(mapping, name);

if (!value) {

PyErr_Clear();

return NULL;

}

if (value == Py_None) {

goto cleanup;

}

value_fast = PySequence_Fast(value, "handle_list must be a sequence or None");

if (value_fast == NULL)

goto cleanup;

*size = PySequence_Fast_GET_SIZE(value_fast) * sizeof(HANDLE);

/* Passing an empty array causes CreateProcess to fail so just don't set it */

if (*size == 0) {

goto cleanup;

}

ret = PyMem_Malloc(*size);

if (ret == NULL)

goto cleanup;

for (i = 0; i < PySequence_Fast_GET_SIZE(value_fast); i++) {

ret[i] = PYNUM_TO_HANDLE(PySequence_Fast_GET_ITEM(value_fast, i));

if (ret[i] == (HANDLE)-1 && PyErr_Occurred()) {

PyMem_Free(ret);

ret = NULL;

goto cleanup;

}

}

cleanup:

Py_DECREF(value);

Py_XDECREF(value_fast);

return ret;

}

typedef struct {

LPPROC_THREAD_ATTRIBUTE_LIST attribute_list;

LPHANDLE handle_list;

} AttributeList;

static void

freeattributelist(AttributeList *attribute_list)

{

if (attribute_list->attribute_list != NULL) {

DeleteProcThreadAttributeList(attribute_list->attribute_list);

PyMem_Free(attribute_list->attribute_list);

}

PyMem_Free(attribute_list->handle_list);

memset(attribute_list, 0, sizeof(*attribute_list));

}

static int

getattributelist(PyObject *obj, const char *name, AttributeList *attribute_list)

{

int ret = 0;

DWORD err;

BOOL result;

PyObject *value;

Py_ssize_t handle_list_size;

DWORD attribute_count = 0;

SIZE_T attribute_list_size = 0;

value = PyObject_GetAttrString(obj, name);

if (!value) {

PyErr_Clear(); /* FIXME: propagate error? */

return 0;

}

if (value == Py_None) {

ret = 0;

goto cleanup;

}

if (!PyMapping_Check(value)) {

ret = -1;

PyErr_Format(PyExc_TypeError, "%s must be a mapping or None", name);

goto cleanup;

}

attribute_list->handle_list = gethandlelist(value, "handle_list", &handle_list_size);

if (attribute_list->handle_list == NULL && PyErr_Occurred()) {

ret = -1;

goto cleanup;

}

if (attribute_list->handle_list != NULL)

++attribute_count;

/* Get how many bytes we need for the attribute list */

result = InitializeProcThreadAttributeList(NULL, attribute_count, 0, &attribute_list_size);

if (result || GetLastError() != ERROR_INSUFFICIENT_BUFFER) {

ret = -1;

PyErr_SetFromWindowsErr(GetLastError());

goto cleanup;

}

attribute_list->attribute_list = PyMem_Malloc(attribute_list_size);

if (attribute_list->attribute_list == NULL) {

ret = -1;

goto cleanup;

}

result = InitializeProcThreadAttributeList(

attribute_list->attribute_list,

attribute_count,

0,

&attribute_list_size);

if (!result) {

err = GetLastError();

/* So that we won't call DeleteProcThreadAttributeList */

PyMem_Free(attribute_list->attribute_list);

attribute_list->attribute_list = NULL;

ret = -1;

PyErr_SetFromWindowsErr(err);

goto cleanup;

}

if (attribute_list->handle_list != NULL) {

result = UpdateProcThreadAttribute(

attribute_list->attribute_list,

0,

PROC_THREAD_ATTRIBUTE_HANDLE_LIST,

attribute_list->handle_list,

handle_list_size,

NULL,

NULL);

if (!result) {

ret = -1;

PyErr_SetFromWindowsErr(GetLastError());

goto cleanup;

}

}

cleanup:

Py_DECREF(value);

if (ret < 0)

freeattributelist(attribute_list);

return ret;

}

static PyObject *

_winapi_CreateProcess_impl(PyObject *module, Py_UNICODE *application_name,