/*

* Support routines from the Windows API

*

* This module was originally created by merging PC/_subprocess.c with

* Modules/_multiprocessing/win32_functions.c.

*

* Copyright (c) 2004 by Fredrik Lundh <[email protected]>

* Copyright (c) 2004 by Secret Labs AB, http://www.pythonware.com

* Copyright (c) 2004 by Peter Astrand <[email protected]>

*

* By obtaining, using, and/or copying this software and/or its

* associated documentation, you agree that you have read, understood,

* and will comply with the following terms and conditions:

*

* Permission to use, copy, modify, and distribute this software and

* its associated documentation for any purpose and without fee is

* hereby granted, provided that the above copyright notice appears in

* all copies, and that both that copyright notice and this permission

* notice appear in supporting documentation, and that the name of the

* authors not be used in advertising or publicity pertaining to

* distribution of the software without specific, written prior

* permission.

*

* THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,

* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.

* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR

* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS

* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,

* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION

* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

*

*/

/* Licensed to PSF under a Contributor Agreement. */

/* See https://www.python.org/2.4/license for licensing details. */

#include "Python.h"

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "pycore_pylifecycle.h" // _Py_IsInterpreterFinalizing()

#include "pycore_pystate.h" // _PyInterpreterState_GET

#ifndef WINDOWS_LEAN_AND_MEAN

#define WINDOWS_LEAN_AND_MEAN

#endif

#include "windows.h"

#include <winioctl.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 Py_T_ULONG

#else

#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 Py_T_ULONGLONG

#endif

#define F_HANDLE F_POINTER

#define F_DWORD "k"

#define T_HANDLE T_POINTER

// winbase.h limits the STARTF_* flags to the desktop API as of 10.0.19041.

#ifndef STARTF_USESHOWWINDOW

#define STARTF_USESHOWWINDOW 0x00000001

#endif

#ifndef STARTF_USESTDHANDLES

#define STARTF_USESTDHANDLES 0x00000100

#endif

typedef struct {

PyTypeObject *overlapped_type;

} WinApiState;

static inline WinApiState*

winapi_get_state(PyObject *module)

{

void *state = _PyModule_GetState(module);

assert(state != NULL);

return (WinApiState *)state;

}

/*

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

/*

Note: tp_clear (overlapped_clear) is not implemented because it

requires cancelling the IO operation if it's pending and the cancellation is

quite complex and can fail (see: overlapped_dealloc).

*/

static int

overlapped_traverse(OverlappedObject *self, visitproc visit, void *arg)

{

Py_VISIT(self->read_buffer);

Py_VISIT(self->write_buffer.obj);

Py_VISIT(Py_TYPE(self));

return 0;

}

static void

overlapped_dealloc(OverlappedObject *self)

{

DWORD bytes;

int err = GetLastError();

PyObject_GC_UnTrack(self);

if (self->pending) {

if (CancelIoEx(self->handle, &self->overlapped) &&

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

{

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

}

else if (_Py_IsInterpreterFinalizing(_PyInterpreterState_GET()))

{

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

will probably only happen on Windows XP. */

PyErr_SetString(PyExc_PythonFinalizationError,

"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

probably about to exit, so we need not worry too much

about memory leaks. Leaking self prevents a potential

crash. This can happen when a daemon thread is cleaned

up at exit -- see #19565. We only expect to get here

on Windows XP. */

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

PyTypeObject *tp = Py_TYPE(self);

tp->tp_free(self);

Py_DECREF(tp);

}

/*[clinic input]

module _winapi

class _winapi.Overlapped "OverlappedObject *" "&OverlappedType"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c13d3f5fd1dabb84]*/

/*[python input]

def create_converter(type_, format_unit):

name = type_ + '_converter'

# registered upon creation by CConverter's metaclass

type(name, (CConverter,), {'type': type_, 'format_unit': format_unit})

# format unit differs between platforms for these

create_converter('HANDLE', '" F_HANDLE "')

create_converter('HMODULE', '" F_HANDLE "')

create_converter('LPSECURITY_ATTRIBUTES', '" F_POINTER "')

create_converter('LPCVOID', '" F_POINTER "')

create_converter('BOOL', 'i') # F_BOOL used previously (always 'i')

create_converter('DWORD', 'k') # F_DWORD is always "k" (which is much shorter)

create_converter('LPCTSTR', 's')

create_converter('UINT', 'I') # F_UINT used previously (always 'I')

class LPCWSTR_converter(Py_UNICODE_converter):

type = 'LPCWSTR'

class HANDLE_return_converter(CReturnConverter):

type = 'HANDLE'

def render(self, function, data):

self.declare(data)

self.err_occurred_if("_return_value == INVALID_HANDLE_VALUE", data)

data.return_conversion.append(

'if (_return_value == NULL) {\n Py_RETURN_NONE;\n}\n')

data.return_conversion.append(

'return_value = HANDLE_TO_PYNUM(_return_value);\n')

class DWORD_return_converter(CReturnConverter):

type = 'DWORD'

def render(self, function, data):

self.declare(data)

self.err_occurred_if("_return_value == PY_DWORD_MAX", data)

data.return_conversion.append(

'return_value = PyLong_FromUnsignedLong(_return_value);\n')

class LPVOID_return_converter(CReturnConverter):

type = 'LPVOID'

def render(self, function, data):

self.declare(data)

self.err_occurred_if("_return_value == NULL", data)

data.return_conversion.append(

'return_value = HANDLE_TO_PYNUM(_return_value);\n')

[python start generated code]*/

/*[python end generated code: output=da39a3ee5e6b4b0d input=ef52a757a1830d92]*/

#include "clinic/_winapi.c.h"

/*[clinic input]

_winapi.Overlapped.GetOverlappedResult

wait: bool

/

[clinic start generated code]*/

static PyObject *

_winapi_Overlapped_GetOverlappedResult_impl(OverlappedObject *self, int wait)

/*[clinic end generated code: output=bdd0c1ed6518cd03 input=194505ee8e0e3565]*/

{

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

}

/*[clinic input]

_winapi.Overlapped.getbuffer

[clinic start generated code]*/

static PyObject *

_winapi_Overlapped_getbuffer_impl(OverlappedObject *self)

/*[clinic end generated code: output=95a3eceefae0f748 input=347fcfd56b4ceabd]*/

{

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;

return Py_NewRef(res);

}

/*[clinic input]

_winapi.Overlapped.cancel

[clinic start generated code]*/

static PyObject *

_winapi_Overlapped_cancel_impl(OverlappedObject *self)

/*[clinic end generated code: output=fcb9ab5df4ebdae5 input=cbf3da142290039f]*/

{

BOOL res = TRUE;

if (self->pending) {

Py_BEGIN_ALLOW_THREADS

res = CancelIoEx(self->handle, &self->overlapped);

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

Py_READONLY, "overlapped event handle"},

{NULL}

};

static PyType_Slot winapi_overlapped_type_slots[] = {

{Py_tp_traverse, overlapped_traverse},

{Py_tp_dealloc, overlapped_dealloc},

{Py_tp_doc, "OVERLAPPED structure wrapper"},

{Py_tp_methods, overlapped_methods},

{Py_tp_members, overlapped_members},

{0,0}

};

static PyType_Spec winapi_overlapped_type_spec = {

.name = "_winapi.Overlapped",

.basicsize = sizeof(OverlappedObject),

.flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |

Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_IMMUTABLETYPE),

.slots = winapi_overlapped_type_slots,

};

static OverlappedObject *

new_overlapped(PyObject *module, HANDLE handle)

{

WinApiState *st = winapi_get_state(module);

OverlappedObject *self = PyObject_GC_New(OverlappedObject, st->overlapped_type);

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

PyObject_GC_Track(self);

return self;

}

/* -------------------------------------------------------------------- */

/* windows API functions */

/*[clinic input]

_winapi.CloseHandle

handle: HANDLE

/

Close handle.

[clinic start generated code]*/

static PyObject *

_winapi_CloseHandle_impl(PyObject *module, HANDLE handle)

/*[clinic end generated code: output=7ad37345f07bd782 input=7f0e4ac36e0352b8]*/

{

BOOL success;

Py_BEGIN_ALLOW_THREADS

success = CloseHandle(handle);

Py_END_ALLOW_THREADS

if (!success)

return PyErr_SetFromWindowsErr(0);

Py_RETURN_NONE;

}

/*[clinic input]

_winapi.ConnectNamedPipe

handle: HANDLE

overlapped as use_overlapped: bool = False

[clinic start generated code]*/

static PyObject *

_winapi_ConnectNamedPipe_impl(PyObject *module, HANDLE handle,

int use_overlapped)

/*[clinic end generated code: output=335a0e7086800671 input=a80e56e8bd370e31]*/

{

BOOL success;

OverlappedObject *overlapped = NULL;

if (use_overlapped) {

overlapped = new_overlapped(module, 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;

}

/*[clinic input]

_winapi.CreateEventW -> HANDLE

security_attributes: LPSECURITY_ATTRIBUTES

manual_reset: BOOL

initial_state: BOOL

name: LPCWSTR(accept={str, NoneType})

[clinic start generated code]*/

static HANDLE

_winapi_CreateEventW_impl(PyObject *module,

LPSECURITY_ATTRIBUTES security_attributes,

BOOL manual_reset, BOOL initial_state,

LPCWSTR name)

/*[clinic end generated code: output=2d4c7d5852ecb298 input=4187cee28ac763f8]*/

{

HANDLE handle;

if (PySys_Audit("_winapi.CreateEventW", "bbu", manual_reset, initial_state, name) < 0) {

return INVALID_HANDLE_VALUE;

}

Py_BEGIN_ALLOW_THREADS

handle = CreateEventW(security_attributes, manual_reset, initial_state, name);

Py_END_ALLOW_THREADS

if (handle == INVALID_HANDLE_VALUE) {

PyErr_SetFromWindowsErr(0);

}

return handle;

}

/*[clinic input]

_winapi.CreateFile -> HANDLE

file_name: LPCWSTR

desired_access: DWORD

share_mode: DWORD

security_attributes: LPSECURITY_ATTRIBUTES

creation_disposition: DWORD

flags_and_attributes: DWORD

template_file: HANDLE

/

[clinic start generated code]*/

static HANDLE

_winapi_CreateFile_impl(PyObject *module, LPCWSTR file_name,

DWORD desired_access, DWORD share_mode,

LPSECURITY_ATTRIBUTES security_attributes,

DWORD creation_disposition,

DWORD flags_and_attributes, HANDLE template_file)

/*[clinic end generated code: output=818c811e5e04d550 input=1fa870ed1c2e3d69]*/

{

HANDLE handle;

if (PySys_Audit("_winapi.CreateFile", "uIIII",

file_name, desired_access, share_mode,

creation_disposition, flags_and_attributes) < 0) {

return INVALID_HANDLE_VALUE;

}

Py_BEGIN_ALLOW_THREADS

handle = CreateFileW(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;

}

/*[clinic input]

_winapi.CreateFileMapping -> HANDLE

file_handle: HANDLE

security_attributes: LPSECURITY_ATTRIBUTES

protect: DWORD

max_size_high: DWORD

max_size_low: DWORD

name: LPCWSTR

/

[clinic start generated code]*/

static HANDLE

_winapi_CreateFileMapping_impl(PyObject *module, HANDLE file_handle,

LPSECURITY_ATTRIBUTES security_attributes,

DWORD protect, DWORD max_size_high,

DWORD max_size_low, LPCWSTR name)

/*[clinic end generated code: output=6c0a4d5cf7f6fcc6 input=3dc5cf762a74dee8]*/

{

HANDLE handle;

Py_BEGIN_ALLOW_THREADS

handle = CreateFileMappingW(file_handle, security_attributes,

protect, max_size_high, max_size_low,

name);

Py_END_ALLOW_THREADS

if (handle == NULL) {

PyObject *temp = PyUnicode_FromWideChar(name, -1);

PyErr_SetExcFromWindowsErrWithFilenameObject(PyExc_OSError, 0, temp);

Py_XDECREF(temp);

handle = INVALID_HANDLE_VALUE;

}

return handle;

}

/*[clinic input]

_winapi.CreateJunction

src_path: LPCWSTR

dst_path: LPCWSTR

/

[clinic start generated code]*/

static PyObject *

_winapi_CreateJunction_impl(PyObject *module, LPCWSTR src_path,

LPCWSTR dst_path)

/*[clinic end generated code: output=44b3f5e9bbcc4271 input=963d29b44b9384a7]*/

{

/* Privilege adjustment */

HANDLE token = NULL;

struct {

TOKEN_PRIVILEGES base;

/* overallocate by a few array elements */

LUID_AND_ATTRIBUTES privs[4];

} tp, previousTp;

int previousTpSize = 0;

/* 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);

if (PySys_Audit("_winapi.CreateJunction", "uu", src_path, dst_path) < 0) {

return NULL;

}

/* Adjust privileges to allow rewriting directory entry as a

junction point. */

if (!OpenProcessToken(GetCurrentProcess(),

TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token)) {

goto cleanup;

}

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

goto cleanup;

}

tp.base.PrivilegeCount = 1;

tp.base.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

if (!AdjustTokenPrivileges(token, FALSE, &tp.base, sizeof(previousTp),

&previousTp.base, &previousTpSize)) {

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

junction points. Here's what I've learned along the way:

- A junction point has two components: a print name and a substitute

name. They both describe the link target, but the substitute name is

the physical target and the print name is shown in directory listings.

- The print name must be a native name, prefixed with "\??\".

- Both names are stored after each other in the same buffer (the

PathBuffer) and both must be NUL-terminated.

- There are four members defining their respective offset and length

inside PathBuffer: SubstituteNameOffset, SubstituteNameLength,

PrintNameOffset and PrintNameLength.

- The total size we need to allocate for the REPARSE_DATA_BUFFER, thus,

is the sum of:

- the fixed header size (REPARSE_DATA_BUFFER_HEADER_SIZE)

- the size of the MountPointReparseBuffer member without the PathBuffer

- the size of the prefix ("\??\") in bytes

- the size of the print name in bytes

- the size of the substitute name in bytes

- the size of two NUL terminators in bytes */

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_RawCalloc(1, rdb_size);

if (rdb == NULL)

goto cleanup;

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

offset (0). */

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

if (previousTpSize) {

AdjustTokenPrivileges(token, FALSE, &previousTp.base, previousTpSize,

NULL, NULL);

}

if (token != NULL)

CloseHandle(token);

if (junction != NULL)

CloseHandle(junction);

PyMem_RawFree(rdb);

if (ret != 0)

return PyErr_SetFromWindowsErr(ret);

Py_RETURN_NONE;

}

/*[clinic input]

_winapi.CreateMutexW -> HANDLE

security_attributes: LPSECURITY_ATTRIBUTES

initial_owner: BOOL

name: LPCWSTR(accept={str, NoneType})

[clinic start generated code]*/

static HANDLE

_winapi_CreateMutexW_impl(PyObject *module,

LPSECURITY_ATTRIBUTES security_attributes,

BOOL initial_owner, LPCWSTR name)

/*[clinic end generated code: output=31b9ee8fc37e49a5 input=7d54b921e723254a]*/

{

HANDLE handle;

if (PySys_Audit("_winapi.CreateMutexW", "bu", initial_owner, name) < 0) {

return INVALID_HANDLE_VALUE;

}

Py_BEGIN_ALLOW_THREADS

handle = CreateMutexW(security_attributes, initial_owner, name);

Py_END_ALLOW_THREADS

if (handle == INVALID_HANDLE_VALUE) {

PyErr_SetFromWindowsErr(0);

}

return handle;

}

/*[clinic input]

_winapi.CreateNamedPipe -> HANDLE

name: LPCTSTR

open_mode: DWORD

pipe_mode: DWORD

max_instances: DWORD

out_buffer_size: DWORD

in_buffer_size: DWORD

default_timeout: DWORD

security_attributes: LPSECURITY_ATTRIBUTES

/

[clinic start generated code]*/

static HANDLE

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

DWORD pipe_mode, DWORD max_instances,

DWORD out_buffer_size, DWORD in_buffer_size,

DWORD default_timeout,

LPSECURITY_ATTRIBUTES security_attributes)

/*[clinic end generated code: output=80f8c07346a94fbc input=5a73530b84d8bc37]*/

{

HANDLE handle;

if (PySys_Audit("_winapi.CreateNamedPipe", "uII",

name, open_mode, pipe_mode) < 0) {

return INVALID_HANDLE_VALUE;

}

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;

}

/*[clinic input]

_winapi.CreatePipe

pipe_attrs: object

Ignored internally, can be None.

size: DWORD

/

Create an anonymous pipe.

Returns a 2-tuple of handles, to the read and write ends of the pipe.

[clinic start generated code]*/

static PyObject *

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

/*[clinic end generated code: output=1c4411d8699f0925 input=c4f2cfa56ef68d90]*/

{

HANDLE read_pipe;

HANDLE write_pipe;

BOOL result;

if (PySys_Audit("_winapi.CreatePipe", NULL) < 0) {

return NULL;

}

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

}

/* helpers for createprocess */

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 *

sortenvironmentkey(PyObject *module, PyObject *item)

{

return _winapi_LCMapStringEx_impl(NULL, LOCALE_NAME_INVARIANT,

LCMAP_UPPERCASE, item);

}

static PyMethodDef sortenvironmentkey_def = {

"sortenvironmentkey", _PyCFunction_CAST(sortenvironmentkey), METH_O, "",

};

static int

sort_environment_keys(PyObject *keys)

{

PyObject *keyfunc = PyCFunction_New(&sortenvironmentkey_def, NULL);

if (keyfunc == NULL) {

return -1;

}

PyObject *kwnames = Py_BuildValue("(s)", "key");

if (kwnames == NULL) {

Py_DECREF(keyfunc);

return -1;

}

PyObject *args[] = { keys, keyfunc };

PyObject *ret = PyObject_VectorcallMethod(&_Py_ID(sort), args, 1, kwnames);

Py_DECREF(keyfunc);

Py_DECREF(kwnames);

if (ret == NULL) {

return -1;

}

Py_DECREF(ret);

return 0;

}

static int

compare_string_ordinal(PyObject *str1, PyObject *str2, int *result)

{

wchar_t *s1 = PyUnicode_AsWideCharString(str1, NULL);

if (s1 == NULL) {

return -1;

}

wchar_t *s2 = PyUnicode_AsWideCharString(str2, NULL);

if (s2 == NULL) {

PyMem_Free(s1);

return -1;

}

*result = CompareStringOrdinal(s1, -1, s2, -1, TRUE);

PyMem_Free(s1);

PyMem_Free(s2);

return 0;

}

static PyObject *

dedup_environment_keys(PyObject *keys)

{

PyObject *result = PyList_New(0);

if (result == NULL) {

return NULL;

}

// Iterate over the pre-ordered keys, check whether the current key is equal

// to the next key (ignoring case), if different, insert the current value

// into the result list. If they are equal, do nothing because we always

// want to keep the last inserted one.

for (Py_ssize_t i = 0; i < PyList_GET_SIZE(keys); i++) {

PyObject *key = PyList_GET_ITEM(keys, i);

// The last key will always be kept.

if (i + 1 == PyList_GET_SIZE(keys)) {

if (PyList_Append(result, key) < 0) {

Py_DECREF(result);

return NULL;

}

continue;

}

PyObject *next_key = PyList_GET_ITEM(keys, i + 1);

int compare_result;

if (compare_string_ordinal(key, next_key, &compare_result) < 0) {

Py_DECREF(result);

return NULL;

}

if (compare_result == CSTR_EQUAL) {

continue;

}

if (PyList_Append(result, key) < 0) {

Py_DECREF(result);

return NULL;

}

}

return result;

}

static PyObject *

normalize_environment(PyObject *environment)

{

PyObject *keys = PyMapping_Keys(environment);

if (keys == NULL) {

return NULL;

}

if (sort_environment_keys(keys) < 0) {

Py_DECREF(keys);

return NULL;

}

PyObject *normalized_keys = dedup_environment_keys(keys);

Py_DECREF(keys);

if (normalized_keys == NULL) {

return NULL;

}

PyObject *result = PyDict_New();

if (result == NULL) {

Py_DECREF(normalized_keys);

return NULL;

}

for (int i = 0; i < PyList_GET_SIZE(normalized_keys); i++) {

PyObject *key = PyList_GET_ITEM(normalized_keys, i);

PyObject *value = PyObject_GetItem(environment, key);

if (value == NULL) {

Py_DECREF(normalized_keys);

Py_DECREF(result);

return NULL;

}

int ret = PyObject_SetItem(result, key, value);

Py_DECREF(value);

if (ret < 0) {

Py_DECREF(normalized_keys);

Py_DECREF(result);

return NULL;

}

}

Py_DECREF(normalized_keys);

return result;

}

static wchar_t *

getenvironment(PyObject* environment)