diff options
Diffstat (limited to 'PC/_subprocess.c')
| -rw-r--r-- | PC/_subprocess.c | 691 |
1 files changed, 691 insertions, 0 deletions
diff --git a/PC/_subprocess.c b/PC/_subprocess.c new file mode 100644 index 0000000..66940ff --- /dev/null +++ b/PC/_subprocess.c @@ -0,0 +1,691 @@ +/* + * support routines for subprocess module + * + * Currently, this extension module is only required when using the + * subprocess module on Windows, but in the future, stubs for other + * platforms might be added here as well. + * + * 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 http://www.python.org/2.4/license for licensing details. */ + +/* TODO: handle unicode command lines? */ +/* TODO: handle unicode environment? */ + +#include "Python.h" + +#define WINDOWS_LEAN_AND_MEAN +#include "windows.h" + +/* -------------------------------------------------------------------- */ +/* handle wrapper. note that this library uses integers when passing + handles to a function, and handle wrappers when returning handles. + the wrapper is used to provide Detach and Close methods */ + +typedef struct { + PyObject_HEAD + HANDLE handle; +} sp_handle_object; + +staticforward PyTypeObject sp_handle_type; + +static PyObject* +sp_handle_new(HANDLE handle) +{ + sp_handle_object* self; + + self = PyObject_NEW(sp_handle_object, &sp_handle_type); + if (self == NULL) + return NULL; + + self->handle = handle; + + return (PyObject*) self; +} + +#if defined(MS_WIN32) && !defined(MS_WIN64) +#define HANDLE_TO_PYNUM(handle) PyInt_FromLong((long) handle) +#define PY_HANDLE_PARAM "l" +#else +#define HANDLE_TO_PYNUM(handle) PyLong_FromLongLong((long long) handle) +#define PY_HANDLE_PARAM "L" +#endif + +static PyObject* +sp_handle_detach(sp_handle_object* self, PyObject* args) +{ + HANDLE handle; + + if (! PyArg_ParseTuple(args, ":Detach")) + return NULL; + + handle = self->handle; + + self->handle = INVALID_HANDLE_VALUE; + + /* note: return the current handle, as an integer */ + return HANDLE_TO_PYNUM(handle); +} + +static PyObject* +sp_handle_close(sp_handle_object* self, PyObject* args) +{ + if (! PyArg_ParseTuple(args, ":Close")) + return NULL; + + if (self->handle != INVALID_HANDLE_VALUE) { + CloseHandle(self->handle); + self->handle = INVALID_HANDLE_VALUE; + } + Py_INCREF(Py_None); + return Py_None; +} + +static void +sp_handle_dealloc(sp_handle_object* self) +{ + if (self->handle != INVALID_HANDLE_VALUE) + CloseHandle(self->handle); + PyObject_FREE(self); +} + +static PyMethodDef sp_handle_methods[] = { + {"Detach", (PyCFunction) sp_handle_detach, METH_VARARGS}, + {"Close", (PyCFunction) sp_handle_close, METH_VARARGS}, + {NULL, NULL} +}; + +static PyObject* +sp_handle_getattr(sp_handle_object* self, char* name) +{ + return Py_FindMethod(sp_handle_methods, (PyObject*) self, name); +} + +static PyObject* +sp_handle_as_int(sp_handle_object* self) +{ + return HANDLE_TO_PYNUM(self->handle); +} + +static PyNumberMethods sp_handle_as_number; + +statichere PyTypeObject sp_handle_type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_subprocess_handle", sizeof(sp_handle_object), 0, + (destructor) sp_handle_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + (getattrfunc) sp_handle_getattr,/*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + &sp_handle_as_number, /*tp_as_number */ + 0, /*tp_as_sequence */ + 0, /*tp_as_mapping */ + 0 /*tp_hash*/ +}; + +/* -------------------------------------------------------------------- */ +/* windows API functions */ + +PyDoc_STRVAR(GetStdHandle_doc, +"GetStdHandle(handle) -> integer\n\ +\n\ +Return a handle to the specified standard device\n\ +(STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE).\n\ +The integer associated with the handle object is returned."); + +static PyObject * +sp_GetStdHandle(PyObject* self, PyObject* args) +{ + HANDLE handle; + int std_handle; + + if (! PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + handle = GetStdHandle((DWORD) std_handle); + Py_END_ALLOW_THREADS + + if (handle == INVALID_HANDLE_VALUE) + return PyErr_SetFromWindowsErr(GetLastError()); + + if (! handle) { + Py_INCREF(Py_None); + return Py_None; + } + + /* note: returns integer, not handle object */ + return HANDLE_TO_PYNUM(handle); +} + +PyDoc_STRVAR(GetCurrentProcess_doc, +"GetCurrentProcess() -> handle\n\ +\n\ +Return a handle object for the current process."); + +static PyObject * +sp_GetCurrentProcess(PyObject* self, PyObject* args) +{ + if (! PyArg_ParseTuple(args, ":GetCurrentProcess")) + return NULL; + + return sp_handle_new(GetCurrentProcess()); +} + +PyDoc_STRVAR(DuplicateHandle_doc, +"DuplicateHandle(source_proc_handle, source_handle,\n\ + target_proc_handle, target_handle, access,\n\ + inherit[, options]) -> handle\n\ +\n\ +Return a duplicate handle object.\n\ +\n\ +The duplicate handle refers to the same object as the original\n\ +handle. Therefore, any changes to the object are reflected\n\ +through both handles."); + +static PyObject * +sp_DuplicateHandle(PyObject* self, PyObject* args) +{ + HANDLE target_handle; + BOOL result; + + HANDLE source_process_handle; + HANDLE source_handle; + HANDLE target_process_handle; + int desired_access; + int inherit_handle; + int options = 0; + + if (! PyArg_ParseTuple(args, + PY_HANDLE_PARAM PY_HANDLE_PARAM PY_HANDLE_PARAM + "ii|i:DuplicateHandle", + &source_process_handle, + &source_handle, + &target_process_handle, + &desired_access, + &inherit_handle, + &options)) + return NULL; + + 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) + return PyErr_SetFromWindowsErr(GetLastError()); + + return sp_handle_new(target_handle); +} + +PyDoc_STRVAR(CreatePipe_doc, +"CreatePipe(pipe_attrs, size) -> (read_handle, write_handle)\n\ +\n\ +Create an anonymous pipe, and return handles to the read and\n\ +write ends of the pipe.\n\ +\n\ +pipe_attrs is ignored internally and can be None."); + +static PyObject * +sp_CreatePipe(PyObject* self, PyObject* args) +{ + HANDLE read_pipe; + HANDLE write_pipe; + BOOL result; + + PyObject* pipe_attributes; /* ignored */ + int size; + + if (! PyArg_ParseTuple(args, "Oi:CreatePipe", &pipe_attributes, &size)) + 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", sp_handle_new(read_pipe), sp_handle_new(write_pipe)); +} + +/* helpers for createprocess */ + +static int +getint(PyObject* obj, char* name) +{ + PyObject* value; + int ret; + + value = PyObject_GetAttrString(obj, name); + if (! value) { + PyErr_Clear(); /* FIXME: propagate error? */ + return 0; + } + ret = (int) PyInt_AsLong(value); + Py_DECREF(value); + return ret; +} + +static HANDLE +gethandle(PyObject* obj, char* name) +{ + sp_handle_object* value; + HANDLE ret; + + value = (sp_handle_object*) PyObject_GetAttrString(obj, name); + if (! value) { + PyErr_Clear(); /* FIXME: propagate error? */ + return NULL; + } + if (value->ob_type != &sp_handle_type) + ret = NULL; + else + ret = value->handle; + Py_DECREF(value); + return ret; +} + +static PyObject* +getenvironment(PyObject* environment) +{ + int i, envsize; + PyObject* out = NULL; + PyObject* keys; + PyObject* values; + char* p; + + /* convert environment dictionary to windows environment string */ + if (! PyMapping_Check(environment)) { + PyErr_SetString( + PyExc_TypeError, "environment must be dictionary or None"); + return NULL; + } + + envsize = PyMapping_Length(environment); + + keys = PyMapping_Keys(environment); + if (!keys) { + return NULL; + } + values = PyMapping_Values(environment); + if (!values) { + goto error; + } + + out = PyString_FromStringAndSize(NULL, 2048); + if (! out) + goto error; + + p = PyString_AS_STRING(out); + + for (i = 0; i < envsize; i++) { + size_t ksize, vsize, totalsize; + PyObject* key = PyList_GET_ITEM(keys, i); + PyObject* value = PyList_GET_ITEM(values, i); + + if (! PyString_Check(key) || ! PyString_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "environment can only contain strings"); + goto error; + } + ksize = PyString_GET_SIZE(key); + vsize = PyString_GET_SIZE(value); + if (strlen(PyString_AS_STRING(key)) != ksize || + strlen(PyString_AS_STRING(value)) != vsize) + { + PyErr_SetString(PyExc_TypeError, "embedded null character"); + goto error; + } + /* Search from index 1 because on Windows starting '=' is allowed for + defining hidden environment variables. */ + if (ksize == 0 || strchr(PyString_AS_STRING(key) + 1, '=') != NULL) { + PyErr_SetString(PyExc_ValueError, "illegal environment variable name"); + goto error; + } + totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 + + vsize + 1 + 1; + if (totalsize > (size_t)PyString_GET_SIZE(out)) { + size_t offset = p - PyString_AS_STRING(out); + if (_PyString_Resize(&out, totalsize + 1024)) + goto exit; + p = PyString_AS_STRING(out) + offset; + } + memcpy(p, PyString_AS_STRING(key), ksize); + p += ksize; + *p++ = '='; + memcpy(p, PyString_AS_STRING(value), vsize); + p += vsize; + *p++ = '\0'; + } + + /* add trailing null byte */ + *p++ = '\0'; + _PyString_Resize(&out, p - PyString_AS_STRING(out)); + + /* PyObject_Print(out, stdout, 0); */ +exit: + Py_XDECREF(keys); + Py_XDECREF(values); + + return out; + + error: + Py_XDECREF(out); + Py_XDECREF(keys); + Py_XDECREF(values); + return NULL; +} + +PyDoc_STRVAR(CreateProcess_doc, +"CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs,\n\ + inherit, flags, env_mapping, curdir,\n\ + startup_info) -> (proc_handle, thread_handle,\n\ + pid, tid)\n\ +\n\ +Create a new process and its primary thread. The return\n\ +value is a tuple of the process handle, thread handle,\n\ +process ID, and thread ID.\n\ +\n\ +proc_attrs and thread_attrs are ignored internally and can be None."); + +static PyObject * +sp_CreateProcess(PyObject* self, PyObject* args) +{ + BOOL result; + PROCESS_INFORMATION pi; + STARTUPINFO si; + PyObject* environment; + + char* application_name; + char* command_line; + PyObject* process_attributes; /* ignored */ + PyObject* thread_attributes; /* ignored */ + int inherit_handles; + int creation_flags; + PyObject* env_mapping; + char* current_directory; + PyObject* startup_info; + + if (! PyArg_ParseTuple(args, "zzOOiiOzO:CreateProcess", + &application_name, + &command_line, + &process_attributes, + &thread_attributes, + &inherit_handles, + &creation_flags, + &env_mapping, + ¤t_directory, + &startup_info)) + return NULL; + + ZeroMemory(&si, sizeof(si)); + si.cb = sizeof(si); + + /* note: we only support a small subset of all SI attributes */ + si.dwFlags = getint(startup_info, "dwFlags"); + si.wShowWindow = getint(startup_info, "wShowWindow"); + si.hStdInput = gethandle(startup_info, "hStdInput"); + si.hStdOutput = gethandle(startup_info, "hStdOutput"); + si.hStdError = gethandle(startup_info, "hStdError"); + + if (PyErr_Occurred()) + return NULL; + + if (env_mapping == Py_None) + environment = NULL; + else { + environment = getenvironment(env_mapping); + if (! environment) + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + result = CreateProcess(application_name, + command_line, + NULL, + NULL, + inherit_handles, + creation_flags, + environment ? PyString_AS_STRING(environment) : NULL, + current_directory, + &si, + &pi); + Py_END_ALLOW_THREADS + + Py_XDECREF(environment); + + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + return Py_BuildValue("NNii", + sp_handle_new(pi.hProcess), + sp_handle_new(pi.hThread), + pi.dwProcessId, + pi.dwThreadId); +} + +PyDoc_STRVAR(TerminateProcess_doc, +"TerminateProcess(handle, exit_code) -> None\n\ +\n\ +Terminate the specified process and all of its threads."); + +static PyObject * +sp_TerminateProcess(PyObject* self, PyObject* args) +{ + BOOL result; + + HANDLE process; + int exit_code; + if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:TerminateProcess", + &process, &exit_code)) + return NULL; + + result = TerminateProcess(process, exit_code); + + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + Py_INCREF(Py_None); + return Py_None; +} + +PyDoc_STRVAR(GetExitCodeProcess_doc, +"GetExitCodeProcess(handle) -> Exit code\n\ +\n\ +Return the termination status of the specified process."); + +static PyObject * +sp_GetExitCodeProcess(PyObject* self, PyObject* args) +{ + DWORD exit_code; + BOOL result; + + HANDLE process; + if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetExitCodeProcess", &process)) + return NULL; + + result = GetExitCodeProcess(process, &exit_code); + + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + return PyInt_FromLong(exit_code); +} + +PyDoc_STRVAR(WaitForSingleObject_doc, +"WaitForSingleObject(handle, timeout) -> result\n\ +\n\ +Wait until the specified object is in the signaled state or\n\ +the time-out interval elapses. The timeout value is specified\n\ +in milliseconds."); + +static PyObject * +sp_WaitForSingleObject(PyObject* self, PyObject* args) +{ + DWORD result; + + HANDLE handle; + int milliseconds; + if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:WaitForSingleObject", + &handle, + &milliseconds)) + return NULL; + + Py_BEGIN_ALLOW_THREADS + result = WaitForSingleObject(handle, (DWORD) milliseconds); + Py_END_ALLOW_THREADS + + if (result == WAIT_FAILED) + return PyErr_SetFromWindowsErr(GetLastError()); + + return PyInt_FromLong((int) result); +} + +PyDoc_STRVAR(GetVersion_doc, +"GetVersion() -> version\n\ +\n\ +Return the version number of the current operating system."); + +static PyObject * +sp_GetVersion(PyObject* self, PyObject* args) +{ + if (! PyArg_ParseTuple(args, ":GetVersion")) + return NULL; + + return PyInt_FromLong((int) GetVersion()); +} + +PyDoc_STRVAR(GetModuleFileName_doc, +"GetModuleFileName(module) -> path\n\ +\n\ +Return the fully-qualified path for the file that contains\n\ +the specified module. The module must have been loaded by the\n\ +current process.\n\ +\n\ +The module parameter should be a handle to the loaded module\n\ +whose path is being requested. If this parameter is 0, \n\ +GetModuleFileName retrieves the path of the executable file\n\ +of the current process."); + +static PyObject * +sp_GetModuleFileName(PyObject* self, PyObject* args) +{ + BOOL result; + HMODULE module; + TCHAR filename[MAX_PATH]; + + if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetModuleFileName", + &module)) + return NULL; + + result = GetModuleFileName(module, filename, MAX_PATH); + filename[MAX_PATH-1] = '\0'; + + if (! result) + return PyErr_SetFromWindowsErr(GetLastError()); + + return PyString_FromString(filename); +} + +static PyMethodDef sp_functions[] = { + {"GetStdHandle", sp_GetStdHandle, METH_VARARGS, GetStdHandle_doc}, + {"GetCurrentProcess", sp_GetCurrentProcess, METH_VARARGS, + GetCurrentProcess_doc}, + {"DuplicateHandle", sp_DuplicateHandle, METH_VARARGS, + DuplicateHandle_doc}, + {"CreatePipe", sp_CreatePipe, METH_VARARGS, CreatePipe_doc}, + {"CreateProcess", sp_CreateProcess, METH_VARARGS, CreateProcess_doc}, + {"TerminateProcess", sp_TerminateProcess, METH_VARARGS, + TerminateProcess_doc}, + {"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS, + GetExitCodeProcess_doc}, + {"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS, + WaitForSingleObject_doc}, + {"GetVersion", sp_GetVersion, METH_VARARGS, GetVersion_doc}, + {"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS, + GetModuleFileName_doc}, + {NULL, NULL} +}; + +/* -------------------------------------------------------------------- */ + +static void +defint(PyObject* d, const char* name, int value) +{ + PyObject* v = PyInt_FromLong((long) value); + if (v) { + PyDict_SetItemString(d, (char*) name, v); + Py_DECREF(v); + } +} + +#if PY_VERSION_HEX >= 0x02030000 +PyMODINIT_FUNC +#else +DL_EXPORT(void) +#endif +init_subprocess() +{ + PyObject *d; + PyObject *m; + + /* patch up object descriptors */ + sp_handle_type.ob_type = &PyType_Type; + sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int; + + m = Py_InitModule("_subprocess", sp_functions); + if (m == NULL) + return; + d = PyModule_GetDict(m); + + /* constants */ + defint(d, "STD_INPUT_HANDLE", STD_INPUT_HANDLE); + defint(d, "STD_OUTPUT_HANDLE", STD_OUTPUT_HANDLE); + defint(d, "STD_ERROR_HANDLE", STD_ERROR_HANDLE); + defint(d, "DUPLICATE_SAME_ACCESS", DUPLICATE_SAME_ACCESS); + defint(d, "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES); + defint(d, "STARTF_USESHOWWINDOW", STARTF_USESHOWWINDOW); + defint(d, "SW_HIDE", SW_HIDE); + defint(d, "INFINITE", INFINITE); + defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0); + defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE); + defint(d, "CREATE_NEW_PROCESS_GROUP", CREATE_NEW_PROCESS_GROUP); + defint(d, "STILL_ACTIVE", STILL_ACTIVE); +} |