mirror of
https://github.com/python/cpython.git
synced 2025-11-04 03:44:55 +00:00
3237 lines
94 KiB
C
3237 lines
94 KiB
C
/*
|
|
* 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 <fredrik@pythonware.com>
|
|
* Copyright (c) 2004 by Secret Labs AB, http://www.pythonware.com
|
|
* Copyright (c) 2004 by Peter Astrand <astrand@lysator.liu.se>
|
|
*
|
|
* 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_USESIZE
|
|
#define STARTF_USESIZE 0x00000002
|
|
#endif
|
|
#ifndef STARTF_USEPOSITION
|
|
#define STARTF_USEPOSITION 0x00000004
|
|
#endif
|
|
#ifndef STARTF_USECOUNTCHARS
|
|
#define STARTF_USECOUNTCHARS 0x00000008
|
|
#endif
|
|
#ifndef STARTF_USEFILLATTRIBUTE
|
|
#define STARTF_USEFILLATTRIBUTE 0x00000010
|
|
#endif
|
|
#ifndef STARTF_RUNFULLSCREEN
|
|
#define STARTF_RUNFULLSCREEN 0x00000020
|
|
#endif
|
|
#ifndef STARTF_FORCEONFEEDBACK
|
|
#define STARTF_FORCEONFEEDBACK 0x00000040
|
|
#endif
|
|
#ifndef STARTF_FORCEOFFFEEDBACK
|
|
#define STARTF_FORCEOFFFEEDBACK 0x00000080
|
|
#endif
|
|
#ifndef STARTF_USESTDHANDLES
|
|
#define STARTF_USESTDHANDLES 0x00000100
|
|
#endif
|
|
#ifndef STARTF_USEHOTKEY
|
|
#define STARTF_USEHOTKEY 0x00000200
|
|
#endif
|
|
#ifndef STARTF_TITLEISLINKNAME
|
|
#define STARTF_TITLEISLINKNAME 0x00000800
|
|
#endif
|
|
#ifndef STARTF_TITLEISAPPID
|
|
#define STARTF_TITLEISAPPID 0x00001000
|
|
#endif
|
|
#ifndef STARTF_PREVENTPINNING
|
|
#define STARTF_PREVENTPINNING 0x00002000
|
|
#endif
|
|
#ifndef STARTF_UNTRUSTEDSOURCE
|
|
#define STARTF_UNTRUSTEDSOURCE 0x00008000
|
|
#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('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=da0a4db751936ee7]*/
|
|
|
|
#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", "ukkkk",
|
|
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: LPCWSTR
|
|
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, LPCWSTR 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=7d6fde93227680ba input=5bd4e4a55639ee02]*/
|
|
{
|
|
HANDLE handle;
|
|
|
|
if (PySys_Audit("_winapi.CreateNamedPipe", "ukk",
|
|
name, open_mode, pipe_mode) < 0) {
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
handle = CreateNamedPipeW(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)
|
|
{
|
|
Py_ssize_t i, envsize, totalsize;
|
|
wchar_t *buffer = NULL, *p, *end;
|
|
PyObject *normalized_environment = NULL;
|
|
PyObject *keys = NULL;
|
|
PyObject *values = NULL;
|
|
|
|
/* convert environment dictionary to windows environment string */
|
|
if (! PyMapping_Check(environment)) {
|
|
PyErr_SetString(
|
|
PyExc_TypeError, "environment must be dictionary or None");
|
|
return NULL;
|
|
}
|
|
|
|
normalized_environment = normalize_environment(environment);
|
|
if (normalized_environment == NULL) {
|
|
return NULL;
|
|
}
|
|
|
|
keys = PyMapping_Keys(normalized_environment);
|
|
if (!keys) {
|
|
goto error;
|
|
}
|
|
values = PyMapping_Values(normalized_environment);
|
|
if (!values) {
|
|
goto error;
|
|
}
|
|
|
|
envsize = PyList_GET_SIZE(keys);
|
|
|
|
if (envsize == 0) {
|
|
// A environment block must be terminated by two null characters --
|
|
// one for the last string and one for the block.
|
|
buffer = PyMem_Calloc(2, sizeof(wchar_t));
|
|
if (!buffer) {
|
|
PyErr_NoMemory();
|
|
}
|
|
goto cleanup;
|
|
}
|
|
|
|
if (PyList_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 = PyList_GET_ITEM(keys, i);
|
|
PyObject* value = PyList_GET_ITEM(values, i);
|
|
Py_ssize_t size;
|
|
|
|
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
|
|
defining hidden environment variables. */
|
|
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;
|
|
}
|
|
|
|
size = PyUnicode_AsWideChar(key, NULL, 0);
|
|
assert(size > 1);
|
|
if (totalsize > PY_SSIZE_T_MAX - size) {
|
|
PyErr_SetString(PyExc_OverflowError, "environment too long");
|
|
goto error;
|
|
}
|
|
totalsize += size; /* including '=' */
|
|
|
|
size = PyUnicode_AsWideChar(value, NULL, 0);
|
|
assert(size > 0);
|
|
if (totalsize > PY_SSIZE_T_MAX - size) {
|
|
PyErr_SetString(PyExc_OverflowError, "environment too long");
|
|
goto error;
|
|
}
|
|
totalsize += size; /* including trailing '\0' */
|
|
}
|
|
|
|
buffer = PyMem_NEW(wchar_t, totalsize);
|
|
if (! buffer) {
|
|
PyErr_NoMemory();
|
|
goto error;
|
|
}
|
|
p = buffer;
|
|
end = buffer + totalsize;
|
|
|
|
for (i = 0; i < envsize; i++) {
|
|
PyObject* key = PyList_GET_ITEM(keys, i);
|
|
PyObject* value = PyList_GET_ITEM(values, i);
|
|
Py_ssize_t size = PyUnicode_AsWideChar(key, p, end - p);
|
|
assert(1 <= size && size < end - p);
|
|
p += size;
|
|
*p++ = L'=';
|
|
size = PyUnicode_AsWideChar(value, p, end - p);
|
|
assert(0 <= size && size < end - p);
|
|
p += size + 1;
|
|
}
|
|
|
|
/* add trailing null character */
|
|
*p++ = L'\0';
|
|
assert(p == end);
|
|
|
|
cleanup:
|
|
error:
|
|
Py_XDECREF(normalized_environment);
|
|
Py_XDECREF(keys);
|
|
Py_XDECREF(values);
|
|
return buffer;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.CreateProcess
|
|
|
|
application_name: Py_UNICODE(accept={str, NoneType})
|
|
command_line: object
|
|
Can be str or None
|
|
proc_attrs: object
|
|
Ignored internally, can be None.
|
|
thread_attrs: object
|
|
Ignored internally, can be None.
|
|
inherit_handles: BOOL
|
|
creation_flags: DWORD
|
|
env_mapping: object
|
|
current_directory: Py_UNICODE(accept={str, NoneType})
|
|
startup_info: object
|
|
/
|
|
|
|
Create a new process and its primary thread.
|
|
|
|
The return value is a tuple of the process handle, thread handle,
|
|
process ID, and thread ID.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_CreateProcess_impl(PyObject *module, const wchar_t *application_name,
|
|
PyObject *command_line, PyObject *proc_attrs,
|
|
PyObject *thread_attrs, BOOL inherit_handles,
|
|
DWORD creation_flags, PyObject *env_mapping,
|
|
const wchar_t *current_directory,
|
|
PyObject *startup_info)
|
|
/*[clinic end generated code: output=a25c8e49ea1d6427 input=42ac293eaea03fc4]*/
|
|
{
|
|
PyObject *ret = NULL;
|
|
BOOL result;
|
|
PROCESS_INFORMATION pi;
|
|
STARTUPINFOEXW si;
|
|
wchar_t *wenvironment = NULL;
|
|
wchar_t *command_line_copy = NULL;
|
|
AttributeList attribute_list = {0};
|
|
|
|
if (PySys_Audit("_winapi.CreateProcess", "uuu", application_name,
|
|
command_line, current_directory) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
ZeroMemory(&si, sizeof(si));
|
|
si.StartupInfo.cb = sizeof(si);
|
|
|
|
/* note: we only support a small subset of all SI attributes */
|
|
si.StartupInfo.dwFlags = getulong(startup_info, "dwFlags");
|
|
si.StartupInfo.wShowWindow = (WORD)getulong(startup_info, "wShowWindow");
|
|
si.StartupInfo.hStdInput = gethandle(startup_info, "hStdInput");
|
|
si.StartupInfo.hStdOutput = gethandle(startup_info, "hStdOutput");
|
|
si.StartupInfo.hStdError = gethandle(startup_info, "hStdError");
|
|
if (PyErr_Occurred())
|
|
goto cleanup;
|
|
|
|
if (env_mapping != Py_None) {
|
|
wenvironment = getenvironment(env_mapping);
|
|
if (wenvironment == NULL) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (getattributelist(startup_info, "lpAttributeList", &attribute_list) < 0)
|
|
goto cleanup;
|
|
|
|
si.lpAttributeList = attribute_list.attribute_list;
|
|
if (PyUnicode_Check(command_line)) {
|
|
command_line_copy = PyUnicode_AsWideCharString(command_line, NULL);
|
|
if (command_line_copy == NULL) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
else if (command_line != Py_None) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"CreateProcess() argument 2 must be str or None, not %s",
|
|
Py_TYPE(command_line)->tp_name);
|
|
goto cleanup;
|
|
}
|
|
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
result = CreateProcessW(application_name,
|
|
command_line_copy,
|
|
NULL,
|
|
NULL,
|
|
inherit_handles,
|
|
creation_flags | EXTENDED_STARTUPINFO_PRESENT |
|
|
CREATE_UNICODE_ENVIRONMENT,
|
|
wenvironment,
|
|
current_directory,
|
|
(LPSTARTUPINFOW)&si,
|
|
&pi);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (!result) {
|
|
PyErr_SetFromWindowsErr(GetLastError());
|
|
goto cleanup;
|
|
}
|
|
|
|
ret = Py_BuildValue("NNkk",
|
|
HANDLE_TO_PYNUM(pi.hProcess),
|
|
HANDLE_TO_PYNUM(pi.hThread),
|
|
pi.dwProcessId,
|
|
pi.dwThreadId);
|
|
|
|
cleanup:
|
|
PyMem_Free(command_line_copy);
|
|
PyMem_Free(wenvironment);
|
|
freeattributelist(&attribute_list);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.DuplicateHandle -> HANDLE
|
|
|
|
source_process_handle: HANDLE
|
|
source_handle: HANDLE
|
|
target_process_handle: HANDLE
|
|
desired_access: DWORD
|
|
inherit_handle: BOOL
|
|
options: DWORD = 0
|
|
/
|
|
|
|
Return a duplicate handle object.
|
|
|
|
The duplicate handle refers to the same object as the original
|
|
handle. Therefore, any changes to the object are reflected
|
|
through both handles.
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_DuplicateHandle_impl(PyObject *module, HANDLE source_process_handle,
|
|
HANDLE source_handle,
|
|
HANDLE target_process_handle,
|
|
DWORD desired_access, BOOL inherit_handle,
|
|
DWORD options)
|
|
/*[clinic end generated code: output=ad9711397b5dcd4e input=b933e3f2356a8c12]*/
|
|
{
|
|
HANDLE target_handle;
|
|
BOOL result;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
result = DuplicateHandle(
|
|
source_process_handle,
|
|
source_handle,
|
|
target_process_handle,
|
|
&target_handle,
|
|
desired_access,
|
|
inherit_handle,
|
|
options
|
|
);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (! result) {
|
|
PyErr_SetFromWindowsErr(GetLastError());
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
return target_handle;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.ExitProcess
|
|
|
|
ExitCode: UINT
|
|
/
|
|
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_ExitProcess_impl(PyObject *module, UINT ExitCode)
|
|
/*[clinic end generated code: output=a387deb651175301 input=4f05466a9406c558]*/
|
|
{
|
|
#if defined(Py_DEBUG)
|
|
#ifdef MS_WINDOWS_DESKTOP
|
|
SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOALIGNMENTFAULTEXCEPT|
|
|
SEM_NOGPFAULTERRORBOX|SEM_NOOPENFILEERRORBOX);
|
|
#endif
|
|
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
|
|
#endif
|
|
|
|
ExitProcess(ExitCode);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetCurrentProcess -> HANDLE
|
|
|
|
Return a handle object for the current process.
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_GetCurrentProcess_impl(PyObject *module)
|
|
/*[clinic end generated code: output=ddeb4dd2ffadf344 input=b213403fd4b96b41]*/
|
|
{
|
|
return GetCurrentProcess();
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetExitCodeProcess -> DWORD
|
|
|
|
process: HANDLE
|
|
/
|
|
|
|
Return the termination status of the specified process.
|
|
[clinic start generated code]*/
|
|
|
|
static DWORD
|
|
_winapi_GetExitCodeProcess_impl(PyObject *module, HANDLE process)
|
|
/*[clinic end generated code: output=b4620bdf2bccf36b input=61b6bfc7dc2ee374]*/
|
|
{
|
|
DWORD exit_code;
|
|
BOOL result;
|
|
|
|
result = GetExitCodeProcess(process, &exit_code);
|
|
|
|
if (! result) {
|
|
PyErr_SetFromWindowsErr(GetLastError());
|
|
exit_code = PY_DWORD_MAX;
|
|
}
|
|
|
|
return exit_code;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetLastError -> DWORD
|
|
[clinic start generated code]*/
|
|
|
|
static DWORD
|
|
_winapi_GetLastError_impl(PyObject *module)
|
|
/*[clinic end generated code: output=8585b827cb1a92c5 input=62d47fb9bce038ba]*/
|
|
{
|
|
return GetLastError();
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_winapi.GetLongPathName
|
|
|
|
path: LPCWSTR
|
|
|
|
Return the long version of the provided path.
|
|
|
|
If the path is already in its long form, returns the same value.
|
|
|
|
The path must already be a 'str'. If the type is not known, use
|
|
os.fsdecode before calling this function.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_GetLongPathName_impl(PyObject *module, LPCWSTR path)
|
|
/*[clinic end generated code: output=c4774b080275a2d0 input=9872e211e3a4a88f]*/
|
|
{
|
|
DWORD cchBuffer;
|
|
PyObject *result = NULL;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
cchBuffer = GetLongPathNameW(path, NULL, 0);
|
|
Py_END_ALLOW_THREADS
|
|
if (cchBuffer) {
|
|
WCHAR *buffer = (WCHAR *)PyMem_Malloc(cchBuffer * sizeof(WCHAR));
|
|
if (buffer) {
|
|
Py_BEGIN_ALLOW_THREADS
|
|
cchBuffer = GetLongPathNameW(path, buffer, cchBuffer);
|
|
Py_END_ALLOW_THREADS
|
|
if (cchBuffer) {
|
|
result = PyUnicode_FromWideChar(buffer, cchBuffer);
|
|
} else {
|
|
PyErr_SetFromWindowsErr(0);
|
|
}
|
|
PyMem_Free((void *)buffer);
|
|
}
|
|
} else {
|
|
PyErr_SetFromWindowsErr(0);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetModuleFileName
|
|
|
|
module_handle: HMODULE
|
|
/
|
|
|
|
Return the fully-qualified path for the file that contains module.
|
|
|
|
The module must have been loaded by the current process.
|
|
|
|
The module parameter should be a handle to the loaded module
|
|
whose path is being requested. If this parameter is 0,
|
|
GetModuleFileName retrieves the path of the executable file
|
|
of the current process.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_GetModuleFileName_impl(PyObject *module, HMODULE module_handle)
|
|
/*[clinic end generated code: output=85b4b728c5160306 input=6d66ff7deca5d11f]*/
|
|
{
|
|
BOOL result;
|
|
WCHAR filename[MAX_PATH];
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
result = GetModuleFileNameW(module_handle, filename, MAX_PATH);
|
|
filename[MAX_PATH-1] = '\0';
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (! result)
|
|
return PyErr_SetFromWindowsErr(GetLastError());
|
|
|
|
return PyUnicode_FromWideChar(filename, wcslen(filename));
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetShortPathName
|
|
|
|
path: LPCWSTR
|
|
|
|
Return the short version of the provided path.
|
|
|
|
If the path is already in its short form, returns the same value.
|
|
|
|
The path must already be a 'str'. If the type is not known, use
|
|
os.fsdecode before calling this function.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_GetShortPathName_impl(PyObject *module, LPCWSTR path)
|
|
/*[clinic end generated code: output=dab6ae494c621e81 input=43fa349aaf2ac718]*/
|
|
{
|
|
DWORD cchBuffer;
|
|
PyObject *result = NULL;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
cchBuffer = GetShortPathNameW(path, NULL, 0);
|
|
Py_END_ALLOW_THREADS
|
|
if (cchBuffer) {
|
|
WCHAR *buffer = (WCHAR *)PyMem_Malloc(cchBuffer * sizeof(WCHAR));
|
|
if (buffer) {
|
|
Py_BEGIN_ALLOW_THREADS
|
|
cchBuffer = GetShortPathNameW(path, buffer, cchBuffer);
|
|
Py_END_ALLOW_THREADS
|
|
if (cchBuffer) {
|
|
result = PyUnicode_FromWideChar(buffer, cchBuffer);
|
|
} else {
|
|
PyErr_SetFromWindowsErr(0);
|
|
}
|
|
PyMem_Free((void *)buffer);
|
|
}
|
|
} else {
|
|
PyErr_SetFromWindowsErr(0);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetStdHandle -> HANDLE
|
|
|
|
std_handle: DWORD
|
|
One of STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, or STD_ERROR_HANDLE.
|
|
/
|
|
|
|
Return a handle to the specified standard device.
|
|
|
|
The integer associated with the handle object is returned.
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_GetStdHandle_impl(PyObject *module, DWORD std_handle)
|
|
/*[clinic end generated code: output=0e613001e73ab614 input=07016b06a2fc8826]*/
|
|
{
|
|
HANDLE handle;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
handle = GetStdHandle(std_handle);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (handle == INVALID_HANDLE_VALUE)
|
|
PyErr_SetFromWindowsErr(GetLastError());
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetVersion -> long
|
|
|
|
Return the version number of the current operating system.
|
|
[clinic start generated code]*/
|
|
|
|
static long
|
|
_winapi_GetVersion_impl(PyObject *module)
|
|
/*[clinic end generated code: output=e41f0db5a3b82682 input=e21dff8d0baeded2]*/
|
|
/* Disable deprecation warnings about GetVersionEx as the result is
|
|
being passed straight through to the caller, who is responsible for
|
|
using it correctly. */
|
|
#pragma warning(push)
|
|
#pragma warning(disable:4996)
|
|
|
|
{
|
|
return GetVersion();
|
|
}
|
|
|
|
#pragma warning(pop)
|
|
|
|
/*[clinic input]
|
|
_winapi.MapViewOfFile -> LPVOID
|
|
|
|
file_map: HANDLE
|
|
desired_access: DWORD
|
|
file_offset_high: DWORD
|
|
file_offset_low: DWORD
|
|
number_bytes: size_t
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static LPVOID
|
|
_winapi_MapViewOfFile_impl(PyObject *module, HANDLE file_map,
|
|
DWORD desired_access, DWORD file_offset_high,
|
|
DWORD file_offset_low, size_t number_bytes)
|
|
/*[clinic end generated code: output=f23b1ee4823663e3 input=177471073be1a103]*/
|
|
{
|
|
LPVOID address;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
address = MapViewOfFile(file_map, desired_access, file_offset_high,
|
|
file_offset_low, number_bytes);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (address == NULL)
|
|
PyErr_SetFromWindowsErr(0);
|
|
|
|
return address;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.UnmapViewOfFile
|
|
|
|
address: LPCVOID
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_UnmapViewOfFile_impl(PyObject *module, LPCVOID address)
|
|
/*[clinic end generated code: output=4f7e18ac75d19744 input=8c4b6119ad9288a3]*/
|
|
{
|
|
BOOL success;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
success = UnmapViewOfFile(address);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (!success) {
|
|
return PyErr_SetFromWindowsErr(0);
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.OpenEventW -> HANDLE
|
|
|
|
desired_access: DWORD
|
|
inherit_handle: BOOL
|
|
name: LPCWSTR
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_OpenEventW_impl(PyObject *module, DWORD desired_access,
|
|
BOOL inherit_handle, LPCWSTR name)
|
|
/*[clinic end generated code: output=c4a45e95545a4bd2 input=dec26598748d35aa]*/
|
|
{
|
|
HANDLE handle;
|
|
|
|
if (PySys_Audit("_winapi.OpenEventW", "ku", desired_access, name) < 0) {
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
handle = OpenEventW(desired_access, inherit_handle, name);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (handle == INVALID_HANDLE_VALUE) {
|
|
PyErr_SetFromWindowsErr(0);
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_winapi.OpenMutexW -> HANDLE
|
|
|
|
desired_access: DWORD
|
|
inherit_handle: BOOL
|
|
name: LPCWSTR
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_OpenMutexW_impl(PyObject *module, DWORD desired_access,
|
|
BOOL inherit_handle, LPCWSTR name)
|
|
/*[clinic end generated code: output=dda39d7844397bf0 input=f3a7b466c5307712]*/
|
|
{
|
|
HANDLE handle;
|
|
|
|
if (PySys_Audit("_winapi.OpenMutexW", "ku", desired_access, name) < 0) {
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
handle = OpenMutexW(desired_access, inherit_handle, name);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (handle == INVALID_HANDLE_VALUE) {
|
|
PyErr_SetFromWindowsErr(0);
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.OpenFileMapping -> HANDLE
|
|
|
|
desired_access: DWORD
|
|
inherit_handle: BOOL
|
|
name: LPCWSTR
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_OpenFileMapping_impl(PyObject *module, DWORD desired_access,
|
|
BOOL inherit_handle, LPCWSTR name)
|
|
/*[clinic end generated code: output=08cc44def1cb11f1 input=131f2a405359de7f]*/
|
|
{
|
|
HANDLE handle;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
handle = OpenFileMappingW(desired_access, inherit_handle, 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.OpenProcess -> HANDLE
|
|
|
|
desired_access: DWORD
|
|
inherit_handle: BOOL
|
|
process_id: DWORD
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static HANDLE
|
|
_winapi_OpenProcess_impl(PyObject *module, DWORD desired_access,
|
|
BOOL inherit_handle, DWORD process_id)
|
|
/*[clinic end generated code: output=b42b6b81ea5a0fc3 input=ec98c4cf4ea2ec36]*/
|
|
{
|
|
HANDLE handle;
|
|
|
|
if (PySys_Audit("_winapi.OpenProcess", "kk",
|
|
process_id, desired_access) < 0) {
|
|
return INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
handle = OpenProcess(desired_access, inherit_handle, process_id);
|
|
Py_END_ALLOW_THREADS
|
|
if (handle == NULL) {
|
|
PyErr_SetFromWindowsErr(GetLastError());
|
|
handle = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
return handle;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.PeekNamedPipe
|
|
|
|
handle: HANDLE
|
|
size: int = 0
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_PeekNamedPipe_impl(PyObject *module, HANDLE handle, int size)
|
|
/*[clinic end generated code: output=d0c3e29e49d323dd input=c7aa53bfbce69d70]*/
|
|
{
|
|
PyObject *buf = NULL;
|
|
DWORD nread, navail, nleft;
|
|
BOOL ret;
|
|
|
|
if (size < 0) {
|
|
PyErr_SetString(PyExc_ValueError, "negative size");
|
|
return NULL;
|
|
}
|
|
|
|
if (size) {
|
|
buf = PyBytes_FromStringAndSize(NULL, size);
|
|
if (!buf)
|
|
return NULL;
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ret = PeekNamedPipe(handle, PyBytes_AS_STRING(buf), size, &nread,
|
|
&navail, &nleft);
|
|
Py_END_ALLOW_THREADS
|
|
if (!ret) {
|
|
Py_DECREF(buf);
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
}
|
|
if (_PyBytes_Resize(&buf, nread))
|
|
return NULL;
|
|
return Py_BuildValue("NII", buf, navail, nleft);
|
|
}
|
|
else {
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ret = PeekNamedPipe(handle, NULL, 0, NULL, &navail, &nleft);
|
|
Py_END_ALLOW_THREADS
|
|
if (!ret) {
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
}
|
|
return Py_BuildValue("II", navail, nleft);
|
|
}
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.LCMapStringEx
|
|
|
|
locale: LPCWSTR
|
|
flags: DWORD
|
|
src: unicode
|
|
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_LCMapStringEx_impl(PyObject *module, LPCWSTR locale, DWORD flags,
|
|
PyObject *src)
|
|
/*[clinic end generated code: output=b90e6b26e028ff0a input=3e3dcd9b8164012f]*/
|
|
{
|
|
if (flags & (LCMAP_SORTHANDLE | LCMAP_HASH | LCMAP_BYTEREV |
|
|
LCMAP_SORTKEY)) {
|
|
return PyErr_Format(PyExc_ValueError, "unsupported flags");
|
|
}
|
|
|
|
Py_ssize_t src_size;
|
|
wchar_t *src_ = PyUnicode_AsWideCharString(src, &src_size);
|
|
if (!src_) {
|
|
return NULL;
|
|
}
|
|
if (src_size > INT_MAX) {
|
|
PyMem_Free(src_);
|
|
PyErr_SetString(PyExc_OverflowError, "input string is too long");
|
|
return NULL;
|
|
}
|
|
|
|
int dest_size = LCMapStringEx(locale, flags, src_, (int)src_size, NULL, 0,
|
|
NULL, NULL, 0);
|
|
if (dest_size <= 0) {
|
|
DWORD error = GetLastError();
|
|
PyMem_Free(src_);
|
|
return PyErr_SetFromWindowsErr(error);
|
|
}
|
|
|
|
wchar_t* dest = PyMem_NEW(wchar_t, dest_size);
|
|
if (dest == NULL) {
|
|
PyMem_Free(src_);
|
|
return PyErr_NoMemory();
|
|
}
|
|
|
|
int nmapped = LCMapStringEx(locale, flags, src_, (int)src_size, dest, dest_size,
|
|
NULL, NULL, 0);
|
|
if (nmapped <= 0) {
|
|
DWORD error = GetLastError();
|
|
PyMem_Free(src_);
|
|
PyMem_DEL(dest);
|
|
return PyErr_SetFromWindowsErr(error);
|
|
}
|
|
|
|
PyMem_Free(src_);
|
|
PyObject *ret = PyUnicode_FromWideChar(dest, nmapped);
|
|
PyMem_DEL(dest);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.ReadFile
|
|
|
|
handle: HANDLE
|
|
size: DWORD
|
|
overlapped as use_overlapped: bool = False
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_ReadFile_impl(PyObject *module, HANDLE handle, DWORD size,
|
|
int use_overlapped)
|
|
/*[clinic end generated code: output=d3d5b44a8201b944 input=4f82f8e909ad91ad]*/
|
|
{
|
|
DWORD nread;
|
|
PyObject *buf;
|
|
BOOL ret;
|
|
DWORD err;
|
|
OverlappedObject *overlapped = NULL;
|
|
|
|
buf = PyBytes_FromStringAndSize(NULL, size);
|
|
if (!buf)
|
|
return NULL;
|
|
if (use_overlapped) {
|
|
overlapped = new_overlapped(module, handle);
|
|
if (!overlapped) {
|
|
Py_DECREF(buf);
|
|
return NULL;
|
|
}
|
|
/* Steals reference to buf */
|
|
overlapped->read_buffer = buf;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
ret = ReadFile(handle, PyBytes_AS_STRING(buf), size, &nread,
|
|
overlapped ? &overlapped->overlapped : NULL);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
err = ret ? 0 : GetLastError();
|
|
|
|
if (overlapped) {
|
|
if (!ret) {
|
|
if (err == ERROR_IO_PENDING)
|
|
overlapped->pending = 1;
|
|
else if (err != ERROR_MORE_DATA) {
|
|
Py_DECREF(overlapped);
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
}
|
|
}
|
|
return Py_BuildValue("NI", (PyObject *) overlapped, err);
|
|
}
|
|
|
|
if (!ret && err != ERROR_MORE_DATA) {
|
|
Py_DECREF(buf);
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
}
|
|
if (_PyBytes_Resize(&buf, nread))
|
|
return NULL;
|
|
return Py_BuildValue("NI", buf, err);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.ReleaseMutex
|
|
|
|
mutex: HANDLE
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_ReleaseMutex_impl(PyObject *module, HANDLE mutex)
|
|
/*[clinic end generated code: output=5b9001a72dd8af37 input=49e9d20de3559d84]*/
|
|
{
|
|
int err = 0;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
if (!ReleaseMutex(mutex)) {
|
|
err = GetLastError();
|
|
}
|
|
Py_END_ALLOW_THREADS
|
|
if (err) {
|
|
return PyErr_SetFromWindowsErr(err);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.ResetEvent
|
|
|
|
event: HANDLE
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_ResetEvent_impl(PyObject *module, HANDLE event)
|
|
/*[clinic end generated code: output=81c8501d57c0530d input=e2d42d990322e87a]*/
|
|
{
|
|
int err = 0;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
if (!ResetEvent(event)) {
|
|
err = GetLastError();
|
|
}
|
|
Py_END_ALLOW_THREADS
|
|
if (err) {
|
|
return PyErr_SetFromWindowsErr(err);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.SetEvent
|
|
|
|
event: HANDLE
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_SetEvent_impl(PyObject *module, HANDLE event)
|
|
/*[clinic end generated code: output=c18ba09eb9aa774d input=e660e830a37c09f8]*/
|
|
{
|
|
int err = 0;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
if (!SetEvent(event)) {
|
|
err = GetLastError();
|
|
}
|
|
Py_END_ALLOW_THREADS
|
|
if (err) {
|
|
return PyErr_SetFromWindowsErr(err);
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.SetNamedPipeHandleState
|
|
|
|
named_pipe: HANDLE
|
|
mode: object
|
|
max_collection_count: object
|
|
collect_data_timeout: object
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_SetNamedPipeHandleState_impl(PyObject *module, HANDLE named_pipe,
|
|
PyObject *mode,
|
|
PyObject *max_collection_count,
|
|
PyObject *collect_data_timeout)
|
|
/*[clinic end generated code: output=f2129d222cbfa095 input=9142d72163d0faa6]*/
|
|
{
|
|
PyObject *oArgs[3] = {mode, max_collection_count, collect_data_timeout};
|
|
DWORD dwArgs[3], *pArgs[3] = {NULL, NULL, NULL};
|
|
int i;
|
|
BOOL b;
|
|
|
|
for (i = 0 ; i < 3 ; i++) {
|
|
if (oArgs[i] != Py_None) {
|
|
dwArgs[i] = PyLong_AsUnsignedLongMask(oArgs[i]);
|
|
if (PyErr_Occurred())
|
|
return NULL;
|
|
pArgs[i] = &dwArgs[i];
|
|
}
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
b = SetNamedPipeHandleState(named_pipe, pArgs[0], pArgs[1], pArgs[2]);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (!b)
|
|
return PyErr_SetFromWindowsErr(0);
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_winapi.TerminateProcess
|
|
|
|
handle: HANDLE
|
|
exit_code: UINT
|
|
/
|
|
|
|
Terminate the specified process and all of its threads.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_TerminateProcess_impl(PyObject *module, HANDLE handle,
|
|
UINT exit_code)
|
|
/*[clinic end generated code: output=f4e99ac3f0b1f34a input=d6bc0aa1ee3bb4df]*/
|
|
{
|
|
BOOL result;
|
|
|
|
if (PySys_Audit("_winapi.TerminateProcess", "nI",
|
|
(Py_ssize_t)handle, exit_code) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
result = TerminateProcess(handle, exit_code);
|
|
|
|
if (! result)
|
|
return PyErr_SetFromWindowsErr(GetLastError());
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.VirtualQuerySize -> size_t
|
|
|
|
address: LPCVOID
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static size_t
|
|
_winapi_VirtualQuerySize_impl(PyObject *module, LPCVOID address)
|
|
/*[clinic end generated code: output=40c8e0ff5ec964df input=6b784a69755d0bb6]*/
|
|
{
|
|
SIZE_T size_of_buf;
|
|
MEMORY_BASIC_INFORMATION mem_basic_info;
|
|
SIZE_T region_size;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
size_of_buf = VirtualQuery(address, &mem_basic_info, sizeof(mem_basic_info));
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (size_of_buf == 0)
|
|
PyErr_SetFromWindowsErr(0);
|
|
|
|
region_size = mem_basic_info.RegionSize;
|
|
return region_size;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.WaitNamedPipe
|
|
|
|
name: LPCWSTR
|
|
timeout: DWORD
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_WaitNamedPipe_impl(PyObject *module, LPCWSTR name, DWORD timeout)
|
|
/*[clinic end generated code: output=e161e2e630b3e9c2 input=099a4746544488fa]*/
|
|
{
|
|
BOOL success;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
success = WaitNamedPipeW(name, timeout);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (!success)
|
|
return PyErr_SetFromWindowsErr(0);
|
|
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
|
|
HANDLE cancel_event;
|
|
DWORD handle_base;
|
|
DWORD handle_count;
|
|
HANDLE thread;
|
|
volatile DWORD result;
|
|
} BatchedWaitData;
|
|
|
|
static DWORD WINAPI
|
|
_batched_WaitForMultipleObjects_thread(LPVOID param)
|
|
{
|
|
BatchedWaitData *data = (BatchedWaitData *)param;
|
|
data->result = WaitForMultipleObjects(
|
|
data->handle_count,
|
|
data->handles,
|
|
FALSE,
|
|
INFINITE
|
|
);
|
|
if (data->result == WAIT_FAILED) {
|
|
DWORD err = GetLastError();
|
|
SetEvent(data->cancel_event);
|
|
return err;
|
|
} else if (data->result >= WAIT_ABANDONED_0 && data->result < WAIT_ABANDONED_0 + MAXIMUM_WAIT_OBJECTS) {
|
|
data->result = WAIT_FAILED;
|
|
SetEvent(data->cancel_event);
|
|
return ERROR_ABANDONED_WAIT_0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.BatchedWaitForMultipleObjects
|
|
|
|
handle_seq: object
|
|
wait_all: BOOL
|
|
milliseconds: DWORD(c_default='INFINITE') = _winapi.INFINITE
|
|
|
|
Supports a larger number of handles than WaitForMultipleObjects
|
|
|
|
Note that the handles may be waited on other threads, which could cause
|
|
issues for objects like mutexes that become associated with the thread
|
|
that was waiting for them. Objects may also be left signalled, even if
|
|
the wait fails.
|
|
|
|
It is recommended to use WaitForMultipleObjects whenever possible, and
|
|
only switch to BatchedWaitForMultipleObjects for scenarios where you
|
|
control all the handles involved, such as your own thread pool or
|
|
files, and all wait objects are left unmodified by a wait (for example,
|
|
manual reset events, threads, and files/pipes).
|
|
|
|
Overlapped handles returned from this module use manual reset events.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_BatchedWaitForMultipleObjects_impl(PyObject *module,
|
|
PyObject *handle_seq,
|
|
BOOL wait_all, DWORD milliseconds)
|
|
/*[clinic end generated code: output=d21c1a4ad0a252fd input=7e196f29005dc77b]*/
|
|
{
|
|
Py_ssize_t thread_count = 0, handle_count = 0, i;
|
|
Py_ssize_t nhandles;
|
|
BatchedWaitData *thread_data[MAXIMUM_WAIT_OBJECTS];
|
|
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
|
|
HANDLE sigint_event = NULL;
|
|
HANDLE cancel_event = NULL;
|
|
DWORD result;
|
|
|
|
const Py_ssize_t _MAXIMUM_TOTAL_OBJECTS = (MAXIMUM_WAIT_OBJECTS - 1) * (MAXIMUM_WAIT_OBJECTS - 1);
|
|
|
|
if (!PySequence_Check(handle_seq)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"sequence type expected, got '%s'",
|
|
Py_TYPE(handle_seq)->tp_name);
|
|
return NULL;
|
|
}
|
|
nhandles = PySequence_Length(handle_seq);
|
|
if (nhandles == -1) {
|
|
return NULL;
|
|
}
|
|
if (nhandles == 0) {
|
|
return wait_all ? Py_NewRef(Py_None) : PyList_New(0);
|
|
}
|
|
|
|
/* If this is the main thread then make the wait interruptible
|
|
by Ctrl-C. When waiting for *all* handles, it is only checked
|
|
in between batches. */
|
|
if (_PyOS_IsMainThread()) {
|
|
sigint_event = _PyOS_SigintEvent();
|
|
assert(sigint_event != NULL);
|
|
}
|
|
|
|
if (nhandles < 0 || nhandles > _MAXIMUM_TOTAL_OBJECTS) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"need at most %zd handles, got a sequence of length %zd",
|
|
_MAXIMUM_TOTAL_OBJECTS, nhandles);
|
|
return NULL;
|
|
}
|
|
|
|
if (!wait_all) {
|
|
cancel_event = CreateEventW(NULL, TRUE, FALSE, NULL);
|
|
if (!cancel_event) {
|
|
PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
i = 0;
|
|
while (i < nhandles) {
|
|
BatchedWaitData *data = (BatchedWaitData*)PyMem_Malloc(sizeof(BatchedWaitData));
|
|
if (!data) {
|
|
goto error;
|
|
}
|
|
thread_data[thread_count++] = data;
|
|
data->thread = NULL;
|
|
data->cancel_event = cancel_event;
|
|
data->handle_base = Py_SAFE_DOWNCAST(i, Py_ssize_t, DWORD);
|
|
data->handle_count = Py_SAFE_DOWNCAST(nhandles - i, Py_ssize_t, DWORD);
|
|
if (data->handle_count > MAXIMUM_WAIT_OBJECTS - 1) {
|
|
data->handle_count = MAXIMUM_WAIT_OBJECTS - 1;
|
|
}
|
|
for (DWORD j = 0; j < data->handle_count; ++i, ++j) {
|
|
PyObject *v = PySequence_GetItem(handle_seq, i);
|
|
if (!v || !PyArg_Parse(v, F_HANDLE, &data->handles[j])) {
|
|
Py_XDECREF(v);
|
|
goto error;
|
|
}
|
|
Py_DECREF(v);
|
|
}
|
|
if (!wait_all) {
|
|
data->handles[data->handle_count++] = cancel_event;
|
|
}
|
|
}
|
|
|
|
DWORD err = 0;
|
|
|
|
/* We need to use different strategies when waiting for ALL handles
|
|
as opposed to ANY handle. This is because there is no way to
|
|
(safely) interrupt a thread that is waiting for all handles in a
|
|
group. So for ALL handles, we loop over each set and wait. For
|
|
ANY handle, we use threads and wait on them. */
|
|
if (wait_all) {
|
|
Py_BEGIN_ALLOW_THREADS
|
|
long long deadline = 0;
|
|
if (milliseconds != INFINITE) {
|
|
deadline = (long long)GetTickCount64() + milliseconds;
|
|
}
|
|
|
|
for (i = 0; !err && i < thread_count; ++i) {
|
|
DWORD timeout = milliseconds;
|
|
if (deadline) {
|
|
long long time_to_deadline = deadline - GetTickCount64();
|
|
if (time_to_deadline <= 0) {
|
|
err = WAIT_TIMEOUT;
|
|
break;
|
|
} else if (time_to_deadline < UINT_MAX) {
|
|
timeout = (DWORD)time_to_deadline;
|
|
}
|
|
}
|
|
result = WaitForMultipleObjects(thread_data[i]->handle_count,
|
|
thread_data[i]->handles, TRUE, timeout);
|
|
// ABANDONED is not possible here because we own all the handles
|
|
if (result == WAIT_FAILED) {
|
|
err = GetLastError();
|
|
} else if (result == WAIT_TIMEOUT) {
|
|
err = WAIT_TIMEOUT;
|
|
}
|
|
|
|
if (!err && sigint_event) {
|
|
result = WaitForSingleObject(sigint_event, 0);
|
|
if (result == WAIT_OBJECT_0) {
|
|
err = ERROR_CONTROL_C_EXIT;
|
|
} else if (result == WAIT_FAILED) {
|
|
err = GetLastError();
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseHandle(cancel_event);
|
|
|
|
Py_END_ALLOW_THREADS
|
|
} else {
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
for (i = 0; i < thread_count; ++i) {
|
|
BatchedWaitData *data = thread_data[i];
|
|
data->thread = CreateThread(
|
|
NULL,
|
|
1, // smallest possible initial stack
|
|
_batched_WaitForMultipleObjects_thread,
|
|
(LPVOID)data,
|
|
CREATE_SUSPENDED,
|
|
NULL
|
|
);
|
|
if (!data->thread) {
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
handles[handle_count++] = data->thread;
|
|
}
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (err) {
|
|
PyErr_SetExcFromWindowsErr(PyExc_OSError, err);
|
|
goto error;
|
|
}
|
|
if (handle_count > MAXIMUM_WAIT_OBJECTS - 1) {
|
|
// basically an assert, but stronger
|
|
PyErr_SetString(PyExc_SystemError, "allocated too many wait objects");
|
|
goto error;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
|
|
// Once we start resuming threads, can no longer "goto error"
|
|
for (i = 0; i < thread_count; ++i) {
|
|
ResumeThread(thread_data[i]->thread);
|
|
}
|
|
if (sigint_event) {
|
|
handles[handle_count++] = sigint_event;
|
|
}
|
|
result = WaitForMultipleObjects((DWORD)handle_count, handles, wait_all, milliseconds);
|
|
// ABANDONED is not possible here because we own all the handles
|
|
if (result == WAIT_FAILED) {
|
|
err = GetLastError();
|
|
} else if (result == WAIT_TIMEOUT) {
|
|
err = WAIT_TIMEOUT;
|
|
} else if (sigint_event && result == WAIT_OBJECT_0 + handle_count) {
|
|
err = ERROR_CONTROL_C_EXIT;
|
|
}
|
|
|
|
SetEvent(cancel_event);
|
|
|
|
// Wait for all threads to finish before we start freeing their memory
|
|
if (sigint_event) {
|
|
handle_count -= 1;
|
|
}
|
|
WaitForMultipleObjects((DWORD)handle_count, handles, TRUE, INFINITE);
|
|
|
|
for (i = 0; i < thread_count; ++i) {
|
|
if (!err && thread_data[i]->result == WAIT_FAILED) {
|
|
if (!GetExitCodeThread(thread_data[i]->thread, &err)) {
|
|
err = GetLastError();
|
|
}
|
|
}
|
|
CloseHandle(thread_data[i]->thread);
|
|
}
|
|
|
|
CloseHandle(cancel_event);
|
|
|
|
Py_END_ALLOW_THREADS
|
|
|
|
}
|
|
|
|
PyObject *triggered_indices;
|
|
if (sigint_event != NULL && err == ERROR_CONTROL_C_EXIT) {
|
|
errno = EINTR;
|
|
PyErr_SetFromErrno(PyExc_OSError);
|
|
triggered_indices = NULL;
|
|
} else if (err) {
|
|
PyErr_SetExcFromWindowsErr(PyExc_OSError, err);
|
|
triggered_indices = NULL;
|
|
} else if (wait_all) {
|
|
triggered_indices = Py_NewRef(Py_None);
|
|
} else {
|
|
triggered_indices = PyList_New(0);
|
|
if (triggered_indices) {
|
|
for (i = 0; i < thread_count; ++i) {
|
|
Py_ssize_t triggered = (Py_ssize_t)thread_data[i]->result - WAIT_OBJECT_0;
|
|
if (triggered >= 0 && (size_t)triggered < thread_data[i]->handle_count - 1) {
|
|
PyObject *v = PyLong_FromSsize_t(thread_data[i]->handle_base + triggered);
|
|
if (!v || PyList_Append(triggered_indices, v) < 0) {
|
|
Py_XDECREF(v);
|
|
Py_CLEAR(triggered_indices);
|
|
break;
|
|
}
|
|
Py_DECREF(v);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < thread_count; ++i) {
|
|
PyMem_Free((void *)thread_data[i]);
|
|
}
|
|
|
|
return triggered_indices;
|
|
|
|
error:
|
|
// We should only enter here before any threads start running.
|
|
// Once we start resuming threads, different cleanup is required
|
|
CloseHandle(cancel_event);
|
|
while (--thread_count >= 0) {
|
|
HANDLE t = thread_data[thread_count]->thread;
|
|
if (t) {
|
|
TerminateThread(t, WAIT_ABANDONED_0);
|
|
CloseHandle(t);
|
|
}
|
|
PyMem_Free((void *)thread_data[thread_count]);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.WaitForMultipleObjects
|
|
|
|
handle_seq: object
|
|
wait_flag: BOOL
|
|
milliseconds: DWORD(c_default='INFINITE') = _winapi.INFINITE
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_WaitForMultipleObjects_impl(PyObject *module, PyObject *handle_seq,
|
|
BOOL wait_flag, DWORD milliseconds)
|
|
/*[clinic end generated code: output=295e3f00b8e45899 input=36f76ca057cd28a0]*/
|
|
{
|
|
DWORD result;
|
|
HANDLE handles[MAXIMUM_WAIT_OBJECTS];
|
|
HANDLE sigint_event = NULL;
|
|
Py_ssize_t nhandles, i;
|
|
|
|
if (!PySequence_Check(handle_seq)) {
|
|
PyErr_Format(PyExc_TypeError,
|
|
"sequence type expected, got '%s'",
|
|
Py_TYPE(handle_seq)->tp_name);
|
|
return NULL;
|
|
}
|
|
nhandles = PySequence_Length(handle_seq);
|
|
if (nhandles == -1)
|
|
return NULL;
|
|
if (nhandles < 0 || nhandles > MAXIMUM_WAIT_OBJECTS - 1) {
|
|
PyErr_Format(PyExc_ValueError,
|
|
"need at most %zd handles, got a sequence of length %zd",
|
|
MAXIMUM_WAIT_OBJECTS - 1, nhandles);
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < nhandles; i++) {
|
|
HANDLE h;
|
|
PyObject *v = PySequence_GetItem(handle_seq, i);
|
|
if (v == NULL)
|
|
return NULL;
|
|
if (!PyArg_Parse(v, F_HANDLE, &h)) {
|
|
Py_DECREF(v);
|
|
return NULL;
|
|
}
|
|
handles[i] = h;
|
|
Py_DECREF(v);
|
|
}
|
|
/* If this is the main thread then make the wait interruptible
|
|
by Ctrl-C unless we are waiting for *all* handles */
|
|
if (!wait_flag && _PyOS_IsMainThread()) {
|
|
sigint_event = _PyOS_SigintEvent();
|
|
assert(sigint_event != NULL);
|
|
handles[nhandles++] = sigint_event;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
if (sigint_event != NULL)
|
|
ResetEvent(sigint_event);
|
|
result = WaitForMultipleObjects((DWORD) nhandles, handles,
|
|
wait_flag, milliseconds);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (result == WAIT_FAILED)
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
else if (sigint_event != NULL && result == WAIT_OBJECT_0 + nhandles - 1) {
|
|
errno = EINTR;
|
|
return PyErr_SetFromErrno(PyExc_OSError);
|
|
}
|
|
|
|
return PyLong_FromLong((int) result);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.WaitForSingleObject -> long
|
|
|
|
handle: HANDLE
|
|
milliseconds: DWORD
|
|
/
|
|
|
|
Wait for a single object.
|
|
|
|
Wait until the specified object is in the signaled state or
|
|
the time-out interval elapses. The timeout value is specified
|
|
in milliseconds.
|
|
[clinic start generated code]*/
|
|
|
|
static long
|
|
_winapi_WaitForSingleObject_impl(PyObject *module, HANDLE handle,
|
|
DWORD milliseconds)
|
|
/*[clinic end generated code: output=3c4715d8f1b39859 input=443d1ab076edc7b1]*/
|
|
{
|
|
DWORD result;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
result = WaitForSingleObject(handle, milliseconds);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (result == WAIT_FAILED) {
|
|
PyErr_SetFromWindowsErr(GetLastError());
|
|
return -1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.WriteFile
|
|
|
|
handle: HANDLE
|
|
buffer: object
|
|
overlapped as use_overlapped: bool = False
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_WriteFile_impl(PyObject *module, HANDLE handle, PyObject *buffer,
|
|
int use_overlapped)
|
|
/*[clinic end generated code: output=2ca80f6bf3fa92e3 input=2badb008c8a2e2a0]*/
|
|
{
|
|
Py_buffer _buf, *buf;
|
|
DWORD len, written;
|
|
BOOL ret;
|
|
DWORD err;
|
|
OverlappedObject *overlapped = NULL;
|
|
|
|
if (use_overlapped) {
|
|
overlapped = new_overlapped(module, handle);
|
|
if (!overlapped)
|
|
return NULL;
|
|
buf = &overlapped->write_buffer;
|
|
}
|
|
else
|
|
buf = &_buf;
|
|
|
|
if (!PyArg_Parse(buffer, "y*", buf)) {
|
|
Py_XDECREF(overlapped);
|
|
return NULL;
|
|
}
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
len = (DWORD)Py_MIN(buf->len, PY_DWORD_MAX);
|
|
ret = WriteFile(handle, buf->buf, len, &written,
|
|
overlapped ? &overlapped->overlapped : NULL);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
err = ret ? 0 : GetLastError();
|
|
|
|
if (overlapped) {
|
|
if (!ret) {
|
|
if (err == ERROR_IO_PENDING)
|
|
overlapped->pending = 1;
|
|
else {
|
|
Py_DECREF(overlapped);
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
}
|
|
}
|
|
return Py_BuildValue("NI", (PyObject *) overlapped, err);
|
|
}
|
|
|
|
PyBuffer_Release(buf);
|
|
if (!ret)
|
|
return PyErr_SetExcFromWindowsErr(PyExc_OSError, 0);
|
|
return Py_BuildValue("II", written, err);
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetACP
|
|
|
|
Get the current Windows ANSI code page identifier.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_GetACP_impl(PyObject *module)
|
|
/*[clinic end generated code: output=f7ee24bf705dbb88 input=1433c96d03a05229]*/
|
|
{
|
|
return PyLong_FromUnsignedLong(GetACP());
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.GetFileType -> DWORD
|
|
|
|
handle: HANDLE
|
|
[clinic start generated code]*/
|
|
|
|
static DWORD
|
|
_winapi_GetFileType_impl(PyObject *module, HANDLE handle)
|
|
/*[clinic end generated code: output=92b8466ac76ecc17 input=0058366bc40bbfbf]*/
|
|
{
|
|
DWORD result;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
result = GetFileType(handle);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (result == FILE_TYPE_UNKNOWN && GetLastError() != NO_ERROR) {
|
|
PyErr_SetFromWindowsErr(0);
|
|
return -1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_winapi._mimetypes_read_windows_registry
|
|
|
|
on_type_read: object
|
|
|
|
Optimized function for reading all known MIME types from the registry.
|
|
|
|
*on_type_read* is a callable taking *type* and *ext* arguments, as for
|
|
MimeTypes.add_type.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi__mimetypes_read_windows_registry_impl(PyObject *module,
|
|
PyObject *on_type_read)
|
|
/*[clinic end generated code: output=20829f00bebce55b input=cd357896d6501f68]*/
|
|
{
|
|
#define CCH_EXT 128
|
|
#define CB_TYPE 510
|
|
struct {
|
|
wchar_t ext[CCH_EXT];
|
|
wchar_t type[CB_TYPE / sizeof(wchar_t) + 1];
|
|
} entries[64];
|
|
int entry = 0;
|
|
HKEY hkcr = NULL;
|
|
LRESULT err;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
err = RegOpenKeyExW(HKEY_CLASSES_ROOT, NULL, 0, KEY_READ, &hkcr);
|
|
for (DWORD i = 0; err == ERROR_SUCCESS || err == ERROR_MORE_DATA; ++i) {
|
|
LPWSTR ext = entries[entry].ext;
|
|
LPWSTR type = entries[entry].type;
|
|
DWORD cchExt = CCH_EXT;
|
|
DWORD cbType = CB_TYPE;
|
|
HKEY subkey;
|
|
DWORD regType;
|
|
|
|
err = RegEnumKeyExW(hkcr, i, ext, &cchExt, NULL, NULL, NULL, NULL);
|
|
if (err != ERROR_SUCCESS || (cchExt && ext[0] != L'.')) {
|
|
continue;
|
|
}
|
|
|
|
err = RegOpenKeyExW(hkcr, ext, 0, KEY_READ, &subkey);
|
|
if (err == ERROR_FILE_NOT_FOUND || err == ERROR_ACCESS_DENIED) {
|
|
err = ERROR_SUCCESS;
|
|
continue;
|
|
} else if (err != ERROR_SUCCESS) {
|
|
continue;
|
|
}
|
|
|
|
err = RegQueryValueExW(subkey, L"Content Type", NULL,
|
|
®Type, (LPBYTE)type, &cbType);
|
|
RegCloseKey(subkey);
|
|
if (err == ERROR_FILE_NOT_FOUND) {
|
|
err = ERROR_SUCCESS;
|
|
continue;
|
|
} else if (err != ERROR_SUCCESS) {
|
|
continue;
|
|
} else if (regType != REG_SZ || !cbType) {
|
|
continue;
|
|
}
|
|
type[cbType / sizeof(wchar_t)] = L'\0';
|
|
|
|
entry += 1;
|
|
|
|
/* Flush our cached entries if we are full */
|
|
if (entry == sizeof(entries) / sizeof(entries[0])) {
|
|
Py_BLOCK_THREADS
|
|
for (int j = 0; j < entry; ++j) {
|
|
PyObject *r = PyObject_CallFunction(
|
|
on_type_read, "uu", entries[j].type, entries[j].ext
|
|
);
|
|
if (!r) {
|
|
/* We blocked threads, so safe to return from here */
|
|
RegCloseKey(hkcr);
|
|
return NULL;
|
|
}
|
|
Py_DECREF(r);
|
|
}
|
|
Py_UNBLOCK_THREADS
|
|
entry = 0;
|
|
}
|
|
}
|
|
if (hkcr) {
|
|
RegCloseKey(hkcr);
|
|
}
|
|
Py_END_ALLOW_THREADS
|
|
|
|
if (err != ERROR_SUCCESS && err != ERROR_NO_MORE_ITEMS) {
|
|
PyErr_SetFromWindowsErr((int)err);
|
|
return NULL;
|
|
}
|
|
|
|
for (int j = 0; j < entry; ++j) {
|
|
PyObject *r = PyObject_CallFunction(
|
|
on_type_read, "uu", entries[j].type, entries[j].ext
|
|
);
|
|
if (!r) {
|
|
return NULL;
|
|
}
|
|
Py_DECREF(r);
|
|
}
|
|
|
|
Py_RETURN_NONE;
|
|
#undef CCH_EXT
|
|
#undef CB_TYPE
|
|
}
|
|
|
|
/*[clinic input]
|
|
_winapi.NeedCurrentDirectoryForExePath -> bool
|
|
|
|
exe_name: LPCWSTR
|
|
/
|
|
[clinic start generated code]*/
|
|
|
|
static int
|
|
_winapi_NeedCurrentDirectoryForExePath_impl(PyObject *module,
|
|
LPCWSTR exe_name)
|
|
/*[clinic end generated code: output=a65ec879502b58fc input=972aac88a1ec2f00]*/
|
|
{
|
|
BOOL result;
|
|
|
|
Py_BEGIN_ALLOW_THREADS
|
|
result = NeedCurrentDirectoryForExePathW(exe_name);
|
|
Py_END_ALLOW_THREADS
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/*[clinic input]
|
|
_winapi.CopyFile2
|
|
|
|
existing_file_name: LPCWSTR
|
|
new_file_name: LPCWSTR
|
|
flags: DWORD
|
|
progress_routine: object = None
|
|
|
|
Copies a file from one name to a new name.
|
|
|
|
This is implemented using the CopyFile2 API, which preserves all stat
|
|
and metadata information apart from security attributes.
|
|
|
|
progress_routine is reserved for future use, but is currently not
|
|
implemented. Its value is ignored.
|
|
[clinic start generated code]*/
|
|
|
|
static PyObject *
|
|
_winapi_CopyFile2_impl(PyObject *module, LPCWSTR existing_file_name,
|
|
LPCWSTR new_file_name, DWORD flags,
|
|
PyObject *progress_routine)
|
|
/*[clinic end generated code: output=43d960d9df73d984 input=fb976b8d1492d130]*/
|
|
{
|
|
HRESULT hr;
|
|
COPYFILE2_EXTENDED_PARAMETERS params = { sizeof(COPYFILE2_EXTENDED_PARAMETERS) };
|
|
|
|
if (PySys_Audit("_winapi.CopyFile2", "uuk",
|
|
existing_file_name, new_file_name, flags) < 0) {
|
|
return NULL;
|
|
}
|
|
|
|
params.dwCopyFlags = flags;
|
|
/* For future implementation. We ignore the value for now so that
|
|
users only have to test for 'CopyFile2' existing and not whether
|
|
the additional parameter exists.
|
|
if (progress_routine != Py_None) {
|
|
params.pProgressRoutine = _winapi_CopyFile2ProgressRoutine;
|
|
params.pvCallbackContext = Py_NewRef(progress_routine);
|
|
}
|
|
*/
|
|
Py_BEGIN_ALLOW_THREADS;
|
|
hr = CopyFile2(existing_file_name, new_file_name, ¶ms);
|
|
Py_END_ALLOW_THREADS;
|
|
/* For future implementation.
|
|
if (progress_routine != Py_None) {
|
|
Py_DECREF(progress_routine);
|
|
}
|
|
*/
|
|
if (FAILED(hr)) {
|
|
if ((hr & 0xFFFF0000) == 0x80070000) {
|
|
PyErr_SetFromWindowsErr(hr & 0xFFFF);
|
|
} else {
|
|
PyErr_SetFromWindowsErr(hr);
|
|
}
|
|
return NULL;
|
|
}
|
|
Py_RETURN_NONE;
|
|
}
|
|
|
|
|
|
static PyMethodDef winapi_functions[] = {
|
|
_WINAPI_CLOSEHANDLE_METHODDEF
|
|
_WINAPI_CONNECTNAMEDPIPE_METHODDEF
|
|
_WINAPI_CREATEEVENTW_METHODDEF
|
|
_WINAPI_CREATEFILE_METHODDEF
|
|
_WINAPI_CREATEFILEMAPPING_METHODDEF
|
|
_WINAPI_CREATEMUTEXW_METHODDEF
|
|
_WINAPI_CREATENAMEDPIPE_METHODDEF
|
|
_WINAPI_CREATEPIPE_METHODDEF
|
|
_WINAPI_CREATEPROCESS_METHODDEF
|
|
_WINAPI_CREATEJUNCTION_METHODDEF
|
|
_WINAPI_DUPLICATEHANDLE_METHODDEF
|
|
_WINAPI_EXITPROCESS_METHODDEF
|
|
_WINAPI_GETCURRENTPROCESS_METHODDEF
|
|
_WINAPI_GETEXITCODEPROCESS_METHODDEF
|
|
_WINAPI_GETLASTERROR_METHODDEF
|
|
_WINAPI_GETLONGPATHNAME_METHODDEF
|
|
_WINAPI_GETMODULEFILENAME_METHODDEF
|
|
_WINAPI_GETSHORTPATHNAME_METHODDEF
|
|
_WINAPI_GETSTDHANDLE_METHODDEF
|
|
_WINAPI_GETVERSION_METHODDEF
|
|
_WINAPI_MAPVIEWOFFILE_METHODDEF
|
|
_WINAPI_OPENEVENTW_METHODDEF
|
|
_WINAPI_OPENFILEMAPPING_METHODDEF
|
|
_WINAPI_OPENMUTEXW_METHODDEF
|
|
_WINAPI_OPENPROCESS_METHODDEF
|
|
_WINAPI_PEEKNAMEDPIPE_METHODDEF
|
|
_WINAPI_LCMAPSTRINGEX_METHODDEF
|
|
_WINAPI_READFILE_METHODDEF
|
|
_WINAPI_RELEASEMUTEX_METHODDEF
|
|
_WINAPI_RESETEVENT_METHODDEF
|
|
_WINAPI_SETEVENT_METHODDEF
|
|
_WINAPI_SETNAMEDPIPEHANDLESTATE_METHODDEF
|
|
_WINAPI_TERMINATEPROCESS_METHODDEF
|
|
_WINAPI_UNMAPVIEWOFFILE_METHODDEF
|
|
_WINAPI_VIRTUALQUERYSIZE_METHODDEF
|
|
_WINAPI_WAITNAMEDPIPE_METHODDEF
|
|
_WINAPI_WAITFORMULTIPLEOBJECTS_METHODDEF
|
|
_WINAPI_BATCHEDWAITFORMULTIPLEOBJECTS_METHODDEF
|
|
_WINAPI_WAITFORSINGLEOBJECT_METHODDEF
|
|
_WINAPI_WRITEFILE_METHODDEF
|
|
_WINAPI_GETACP_METHODDEF
|
|
_WINAPI_GETFILETYPE_METHODDEF
|
|
_WINAPI__MIMETYPES_READ_WINDOWS_REGISTRY_METHODDEF
|
|
_WINAPI_NEEDCURRENTDIRECTORYFOREXEPATH_METHODDEF
|
|
_WINAPI_COPYFILE2_METHODDEF
|
|
{NULL, NULL}
|
|
};
|
|
|
|
#define WINAPI_CONSTANT(fmt, con) \
|
|
do { \
|
|
PyObject *value = Py_BuildValue(fmt, con); \
|
|
if (value == NULL) { \
|
|
return -1; \
|
|
} \
|
|
if (PyDict_SetItemString(d, #con, value) < 0) { \
|
|
Py_DECREF(value); \
|
|
return -1; \
|
|
} \
|
|
Py_DECREF(value); \
|
|
} while (0)
|
|
|
|
static int winapi_exec(PyObject *m)
|
|
{
|
|
WinApiState *st = winapi_get_state(m);
|
|
|
|
st->overlapped_type = (PyTypeObject *)PyType_FromModuleAndSpec(m, &winapi_overlapped_type_spec, NULL);
|
|
if (st->overlapped_type == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
if (PyModule_AddType(m, st->overlapped_type) < 0) {
|
|
return -1;
|
|
}
|
|
|
|
PyObject *d = PyModule_GetDict(m);
|
|
|
|
/* constants */
|
|
WINAPI_CONSTANT(F_DWORD, CREATE_NEW_CONSOLE);
|
|
WINAPI_CONSTANT(F_DWORD, CREATE_NEW_PROCESS_GROUP);
|
|
WINAPI_CONSTANT(F_DWORD, DUPLICATE_SAME_ACCESS);
|
|
WINAPI_CONSTANT(F_DWORD, DUPLICATE_CLOSE_SOURCE);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_ACCESS_DENIED);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_ALREADY_EXISTS);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_BROKEN_PIPE);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_IO_PENDING);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_MORE_DATA);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_NETNAME_DELETED);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_NO_SYSTEM_RESOURCES);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_MORE_DATA);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_NETNAME_DELETED);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_NO_DATA);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_NO_SYSTEM_RESOURCES);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_OPERATION_ABORTED);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_PIPE_BUSY);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_PIPE_CONNECTED);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_PRIVILEGE_NOT_HELD);
|
|
WINAPI_CONSTANT(F_DWORD, ERROR_SEM_TIMEOUT);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_FLAG_FIRST_PIPE_INSTANCE);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_FLAG_OVERLAPPED);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_GENERIC_READ);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_GENERIC_WRITE);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_MAP_ALL_ACCESS);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_MAP_COPY);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_MAP_EXECUTE);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_MAP_READ);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_MAP_WRITE);
|
|
WINAPI_CONSTANT(F_DWORD, GENERIC_READ);
|
|
WINAPI_CONSTANT(F_DWORD, GENERIC_WRITE);
|
|
WINAPI_CONSTANT(F_DWORD, INFINITE);
|
|
WINAPI_CONSTANT(F_HANDLE, INVALID_HANDLE_VALUE);
|
|
WINAPI_CONSTANT(F_DWORD, MEM_COMMIT);
|
|
WINAPI_CONSTANT(F_DWORD, MEM_FREE);
|
|
WINAPI_CONSTANT(F_DWORD, MEM_IMAGE);
|
|
WINAPI_CONSTANT(F_DWORD, MEM_MAPPED);
|
|
WINAPI_CONSTANT(F_DWORD, MEM_PRIVATE);
|
|
WINAPI_CONSTANT(F_DWORD, MEM_RESERVE);
|
|
WINAPI_CONSTANT(F_DWORD, NMPWAIT_WAIT_FOREVER);
|
|
WINAPI_CONSTANT(F_DWORD, OPEN_EXISTING);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_EXECUTE);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_EXECUTE_READ);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_EXECUTE_READWRITE);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_EXECUTE_WRITECOPY);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_GUARD);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_NOACCESS);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_NOCACHE);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_READONLY);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_READWRITE);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_WRITECOMBINE);
|
|
WINAPI_CONSTANT(F_DWORD, PAGE_WRITECOPY);
|
|
WINAPI_CONSTANT(F_DWORD, PIPE_ACCESS_DUPLEX);
|
|
WINAPI_CONSTANT(F_DWORD, PIPE_ACCESS_INBOUND);
|
|
WINAPI_CONSTANT(F_DWORD, PIPE_READMODE_MESSAGE);
|
|
WINAPI_CONSTANT(F_DWORD, PIPE_TYPE_MESSAGE);
|
|
WINAPI_CONSTANT(F_DWORD, PIPE_UNLIMITED_INSTANCES);
|
|
WINAPI_CONSTANT(F_DWORD, PIPE_WAIT);
|
|
WINAPI_CONSTANT(F_DWORD, PROCESS_ALL_ACCESS);
|
|
WINAPI_CONSTANT(F_DWORD, SYNCHRONIZE);
|
|
WINAPI_CONSTANT(F_DWORD, PROCESS_DUP_HANDLE);
|
|
WINAPI_CONSTANT(F_DWORD, SEC_COMMIT);
|
|
WINAPI_CONSTANT(F_DWORD, SEC_IMAGE);
|
|
WINAPI_CONSTANT(F_DWORD, SEC_LARGE_PAGES);
|
|
WINAPI_CONSTANT(F_DWORD, SEC_NOCACHE);
|
|
WINAPI_CONSTANT(F_DWORD, SEC_RESERVE);
|
|
WINAPI_CONSTANT(F_DWORD, SEC_WRITECOMBINE);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USESHOWWINDOW);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USESIZE);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USEPOSITION);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USECOUNTCHARS);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USEFILLATTRIBUTE);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_RUNFULLSCREEN);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_FORCEONFEEDBACK);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_FORCEOFFFEEDBACK);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USESTDHANDLES);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_USEHOTKEY);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_TITLEISLINKNAME);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_TITLEISAPPID);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_PREVENTPINNING);
|
|
WINAPI_CONSTANT(F_DWORD, STARTF_UNTRUSTEDSOURCE);
|
|
WINAPI_CONSTANT(F_DWORD, STD_INPUT_HANDLE);
|
|
WINAPI_CONSTANT(F_DWORD, STD_OUTPUT_HANDLE);
|
|
WINAPI_CONSTANT(F_DWORD, STD_ERROR_HANDLE);
|
|
WINAPI_CONSTANT(F_DWORD, STILL_ACTIVE);
|
|
WINAPI_CONSTANT(F_DWORD, SW_HIDE);
|
|
WINAPI_CONSTANT(F_DWORD, WAIT_OBJECT_0);
|
|
WINAPI_CONSTANT(F_DWORD, WAIT_ABANDONED_0);
|
|
WINAPI_CONSTANT(F_DWORD, WAIT_TIMEOUT);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, ABOVE_NORMAL_PRIORITY_CLASS);
|
|
WINAPI_CONSTANT(F_DWORD, BELOW_NORMAL_PRIORITY_CLASS);
|
|
WINAPI_CONSTANT(F_DWORD, HIGH_PRIORITY_CLASS);
|
|
WINAPI_CONSTANT(F_DWORD, IDLE_PRIORITY_CLASS);
|
|
WINAPI_CONSTANT(F_DWORD, NORMAL_PRIORITY_CLASS);
|
|
WINAPI_CONSTANT(F_DWORD, REALTIME_PRIORITY_CLASS);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, CREATE_NO_WINDOW);
|
|
WINAPI_CONSTANT(F_DWORD, DETACHED_PROCESS);
|
|
WINAPI_CONSTANT(F_DWORD, CREATE_DEFAULT_ERROR_MODE);
|
|
WINAPI_CONSTANT(F_DWORD, CREATE_BREAKAWAY_FROM_JOB);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, FILE_TYPE_UNKNOWN);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_TYPE_DISK);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_TYPE_CHAR);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_TYPE_PIPE);
|
|
WINAPI_CONSTANT(F_DWORD, FILE_TYPE_REMOTE);
|
|
|
|
WINAPI_CONSTANT("u", LOCALE_NAME_INVARIANT);
|
|
WINAPI_CONSTANT(F_DWORD, LOCALE_NAME_MAX_LENGTH);
|
|
WINAPI_CONSTANT("u", LOCALE_NAME_SYSTEM_DEFAULT);
|
|
WINAPI_CONSTANT("u", LOCALE_NAME_USER_DEFAULT);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_FULLWIDTH);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_HALFWIDTH);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_HIRAGANA);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_KATAKANA);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_LINGUISTIC_CASING);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_LOWERCASE);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_SIMPLIFIED_CHINESE);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_TITLECASE);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_TRADITIONAL_CHINESE);
|
|
WINAPI_CONSTANT(F_DWORD, LCMAP_UPPERCASE);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_ALLOW_DECRYPTED_DESTINATION);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_COPY_SYMLINK);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_FAIL_IF_EXISTS);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_NO_BUFFERING);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_NO_OFFLOAD);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_OPEN_SOURCE_FOR_WRITE);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_RESTARTABLE);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_REQUEST_SECURITY_PRIVILEGES);
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_RESUME_FROM_PAUSE);
|
|
#ifndef COPY_FILE_REQUEST_COMPRESSED_TRAFFIC
|
|
// Only defined in newer WinSDKs
|
|
#define COPY_FILE_REQUEST_COMPRESSED_TRAFFIC 0x10000000
|
|
#endif
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_REQUEST_COMPRESSED_TRAFFIC);
|
|
#ifndef COPY_FILE_DIRECTORY
|
|
// Only defined in newer WinSDKs
|
|
#define COPY_FILE_DIRECTORY 0x00000080
|
|
#endif
|
|
WINAPI_CONSTANT(F_DWORD, COPY_FILE_DIRECTORY);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_CALLBACK_CHUNK_STARTED);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_CALLBACK_CHUNK_FINISHED);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_CALLBACK_STREAM_STARTED);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_CALLBACK_STREAM_FINISHED);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_CALLBACK_POLL_CONTINUE);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_CALLBACK_ERROR);
|
|
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_PROGRESS_CONTINUE);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_PROGRESS_CANCEL);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_PROGRESS_STOP);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_PROGRESS_QUIET);
|
|
WINAPI_CONSTANT(F_DWORD, COPYFILE2_PROGRESS_PAUSE);
|
|
|
|
WINAPI_CONSTANT("i", NULL);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static PyModuleDef_Slot winapi_slots[] = {
|
|
{Py_mod_exec, winapi_exec},
|
|
{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
|
|
{Py_mod_gil, Py_MOD_GIL_NOT_USED},
|
|
{0, NULL}
|
|
};
|
|
|
|
static int
|
|
winapi_traverse(PyObject *module, visitproc visit, void *arg)
|
|
{
|
|
WinApiState *st = winapi_get_state(module);
|
|
Py_VISIT(st->overlapped_type);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
winapi_clear(PyObject *module)
|
|
{
|
|
WinApiState *st = winapi_get_state(module);
|
|
Py_CLEAR(st->overlapped_type);
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
winapi_free(void *module)
|
|
{
|
|
winapi_clear((PyObject *)module);
|
|
}
|
|
|
|
static struct PyModuleDef winapi_module = {
|
|
PyModuleDef_HEAD_INIT,
|
|
.m_name = "_winapi",
|
|
.m_size = sizeof(WinApiState),
|
|
.m_methods = winapi_functions,
|
|
.m_slots = winapi_slots,
|
|
.m_traverse = winapi_traverse,
|
|
.m_clear = winapi_clear,
|
|
.m_free = winapi_free,
|
|
};
|
|
|
|
PyMODINIT_FUNC
|
|
PyInit__winapi(void)
|
|
{
|
|
return PyModuleDef_Init(&winapi_module);
|
|
}
|