Skip to content

C
cpython
Kaydet (Commit) f3250b0b authored tarafından Tim Peters's avatar Tim Peters
Dosyalara gözat
Seçenekler

Before this turns into an unreadable mess, follow PEP 7 by using 

hard tab indents in C code.
üst 25b38c89
Hide whitespace changes
Inline Side-by-side
Showing with 340 additions and 315 deletions
PC/_subprocess.c
Dosyayı görüntüle @ f3250b0b
...@@ -3,16 +3,16 @@ ...@@ -3,16 +3,16 @@
* *
* Currently, this extension module is only required when using the * Currently, this extension module is only required when using the
* subprocess module on Windows, but in the future, stubs for other * subprocess module on Windows, but in the future, stubs for other
* platforms might be added here as well. * platforms might be added here as well.
* *
* Copyright (c) 2004 by Fredrik Lundh <fredrik@pythonware.com> * Copyright (c) 2004 by Fredrik Lundh <fredrik@pythonware.com>
* Copyright (c) 2004 by Secret Labs AB, http://www.pythonware.com * Copyright (c) 2004 by Secret Labs AB, http://www.pythonware.com
* Copyright (c) 2004 by Peter Astrand <astrand@lysator.liu.se> * Copyright (c) 2004 by Peter Astrand <astrand@lysator.liu.se>
* *
* By obtaining, using, and/or copying this software and/or its * By obtaining, using, and/or copying this software and/or its
* associated documentation, you agree that you have read, understood, * associated documentation, you agree that you have read, understood,
* and will comply with the following terms and conditions: * and will comply with the following terms and conditions:
* *
* Permission to use, copy, modify, and distribute this software and * Permission to use, copy, modify, and distribute this software and
* its associated documentation for any purpose and without fee is * its associated documentation for any purpose and without fee is
* hereby granted, provided that the above copyright notice appears in * hereby granted, provided that the above copyright notice appears in
...@@ -21,7 +21,7 @@ ...@@ -21,7 +21,7 @@
* authors not be used in advertising or publicity pertaining to * authors not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior * distribution of the software without specific, written prior
* permission. * permission.
* *
* THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
* IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
...@@ -29,7 +29,7 @@ ...@@ -29,7 +29,7 @@
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
* NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
* *
*/ */
/* TODO: handle unicode command lines? */ /* TODO: handle unicode command lines? */
...@@ -46,8 +46,8 @@ ...@@ -46,8 +46,8 @@
the wrapper is used to provide Detach and Close methods */ the wrapper is used to provide Detach and Close methods */
typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
HANDLE handle; HANDLE handle;
} sp_handle_object; } sp_handle_object;
staticforward PyTypeObject sp_handle_type; staticforward PyTypeObject sp_handle_type;
...@@ -55,89 +55,89 @@ staticforward PyTypeObject sp_handle_type; ...@@ -55,89 +55,89 @@ staticforward PyTypeObject sp_handle_type;
static PyObject* static PyObject*
sp_handle_new(HANDLE handle) sp_handle_new(HANDLE handle)
{ {
sp_handle_object* self; sp_handle_object* self;
self = PyObject_NEW(sp_handle_object, &sp_handle_type); self = PyObject_NEW(sp_handle_object, &sp_handle_type);
if (self == NULL) if (self == NULL)
return NULL; return NULL;
self->handle = handle; self->handle = handle;
return (PyObject*) self; return (PyObject*) self;
} }
static PyObject* static PyObject*
sp_handle_detach(sp_handle_object* self, PyObject* args) sp_handle_detach(sp_handle_object* self, PyObject* args)
{ {
HANDLE handle; HANDLE handle;
if (!PyArg_ParseTuple(args, ":Detach")) if (! PyArg_ParseTuple(args, ":Detach"))
return NULL; return NULL;
handle = self->handle; handle = self->handle;
self->handle = NULL; self->handle = NULL;
/* note: return the current handle, as an integer */ /* note: return the current handle, as an integer */
return PyInt_FromLong((long) handle); return PyInt_FromLong((long) handle);
} }
static PyObject* static PyObject*
sp_handle_close(sp_handle_object* self, PyObject* args) sp_handle_close(sp_handle_object* self, PyObject* args)
{ {
if (!PyArg_ParseTuple(args, ":Close")) if (! PyArg_ParseTuple(args, ":Close"))
return NULL; return NULL;
if (self->handle != INVALID_HANDLE_VALUE) { if (self->handle != INVALID_HANDLE_VALUE) {
CloseHandle(self->handle); CloseHandle(self->handle);
self->handle = INVALID_HANDLE_VALUE; self->handle = INVALID_HANDLE_VALUE;
} }
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
} }
static void static void
sp_handle_dealloc(sp_handle_object* self) sp_handle_dealloc(sp_handle_object* self)
{ {
if (self->handle != INVALID_HANDLE_VALUE) if (self->handle != INVALID_HANDLE_VALUE)
CloseHandle(self->handle); CloseHandle(self->handle);
PyMem_DEL(self); PyMem_DEL(self);
} }
static PyMethodDef sp_handle_methods[] = { static PyMethodDef sp_handle_methods[] = {
{"Detach", (PyCFunction) sp_handle_detach, 1}, {"Detach", (PyCFunction) sp_handle_detach, 1},
{"Close", (PyCFunction) sp_handle_close, 1}, {"Close", (PyCFunction) sp_handle_close, 1},
{NULL, NULL} {NULL, NULL}
}; };
static PyObject* static PyObject*
sp_handle_getattr(sp_handle_object* self, char* name) sp_handle_getattr(sp_handle_object* self, char* name)
{ {
return Py_FindMethod(sp_handle_methods, (PyObject*) self, name); return Py_FindMethod(sp_handle_methods, (PyObject*) self, name);
} }
static PyObject* static PyObject*
sp_handle_as_int(sp_handle_object* self) sp_handle_as_int(sp_handle_object* self)
{ {
return PyInt_FromLong((long) self->handle); return PyInt_FromLong((long) self->handle);
} }
static PyNumberMethods sp_handle_as_number; static PyNumberMethods sp_handle_as_number;
statichere PyTypeObject sp_handle_type = { statichere PyTypeObject sp_handle_type = {
PyObject_HEAD_INIT(NULL) PyObject_HEAD_INIT(NULL)
0, /*ob_size*/ 0, /*ob_size*/
"_subprocess_handle", sizeof(sp_handle_object), 0, "_subprocess_handle", sizeof(sp_handle_object), 0,
(destructor) sp_handle_dealloc, /*tp_dealloc*/ (destructor) sp_handle_dealloc, /*tp_dealloc*/
0, /*tp_print*/ 0, /*tp_print*/
(getattrfunc) sp_handle_getattr, /*tp_getattr*/ (getattrfunc) sp_handle_getattr,/*tp_getattr*/
0, /*tp_setattr*/ 0, /*tp_setattr*/
0, /*tp_compare*/ 0, /*tp_compare*/
0, /*tp_repr*/ 0, /*tp_repr*/
&sp_handle_as_number, /*tp_as_number */ &sp_handle_as_number, /*tp_as_number */
0, /*tp_as_sequence */ 0, /*tp_as_sequence */
0, /*tp_as_mapping */ 0, /*tp_as_mapping */
0 /*tp_hash*/ 0 /*tp_hash*/
}; };
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
...@@ -146,91 +146,99 @@ statichere PyTypeObject sp_handle_type = { ...@@ -146,91 +146,99 @@ statichere PyTypeObject sp_handle_type = {
static PyObject * static PyObject *
sp_GetStdHandle(PyObject* self, PyObject* args) sp_GetStdHandle(PyObject* self, PyObject* args)
{ {
HANDLE handle; HANDLE handle;
int std_handle;
int std_handle; if (! PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle))
if (!PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle)) return NULL;
return NULL;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
handle = GetStdHandle((DWORD) std_handle); handle = GetStdHandle((DWORD) std_handle);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (handle == INVALID_HANDLE_VALUE) if (handle == INVALID_HANDLE_VALUE)
return PyErr_SetFromWindowsErr(GetLastError()); return PyErr_SetFromWindowsErr(GetLastError());
if (!handle) { if (! handle) {
Py_INCREF(Py_None); Py_INCREF(Py_None);
return Py_None; return Py_None;
} }
/* note: returns integer, not handle object */ /* note: returns integer, not handle object */
return PyInt_FromLong((long) handle); return PyInt_FromLong((long) handle);
} }
static PyObject * static PyObject *
sp_GetCurrentProcess(PyObject* self, PyObject* args) sp_GetCurrentProcess(PyObject* self, PyObject* args)
{ {
if (!PyArg_ParseTuple(args, ":GetCurrentProcess")) if (! PyArg_ParseTuple(args, ":GetCurrentProcess"))
return NULL; return NULL;
return sp_handle_new(GetCurrentProcess()); return sp_handle_new(GetCurrentProcess());
} }
static PyObject * static PyObject *
sp_DuplicateHandle(PyObject* self, PyObject* args) sp_DuplicateHandle(PyObject* self, PyObject* args)
{ {
HANDLE target_handle; HANDLE target_handle;
BOOL result; BOOL result;
long source_process_handle; long source_process_handle;
long source_handle; long source_handle;
long target_process_handle; long target_process_handle;
int desired_access; int desired_access;
int inherit_handle; int inherit_handle;
int options = 0; int options = 0;
if (!PyArg_ParseTuple(args, "lllii|i:DuplicateHandle",
&source_process_handle, &source_handle, if (! PyArg_ParseTuple(args, "lllii|i:DuplicateHandle",
&target_process_handle, &source_process_handle,
&desired_access, &inherit_handle, &options)) &source_handle,
return NULL; &target_process_handle,
&desired_access,
Py_BEGIN_ALLOW_THREADS &inherit_handle,
result = DuplicateHandle( &options))
(HANDLE) source_process_handle, (HANDLE) source_handle, return NULL;
(HANDLE) target_process_handle, &target_handle, desired_access,
inherit_handle, options Py_BEGIN_ALLOW_THREADS
); result = DuplicateHandle(
Py_END_ALLOW_THREADS (HANDLE) source_process_handle,
(HANDLE) source_handle,
if (!result) (HANDLE) target_process_handle,
return PyErr_SetFromWindowsErr(GetLastError()); &target_handle,
desired_access,
return sp_handle_new(target_handle); inherit_handle,
options
);
Py_END_ALLOW_THREADS
if (! result)
return PyErr_SetFromWindowsErr(GetLastError());
return sp_handle_new(target_handle);
} }
static PyObject * static PyObject *
sp_CreatePipe(PyObject* self, PyObject* args) sp_CreatePipe(PyObject* self, PyObject* args)
{ {
HANDLE read_pipe; HANDLE read_pipe;
HANDLE write_pipe; HANDLE write_pipe;
BOOL result; BOOL result;
PyObject* pipe_attributes; /* ignored */
int size;
PyObject* pipe_attributes; /* ignored */ if (! PyArg_ParseTuple(args, "Oi:CreatePipe", &pipe_attributes, &size))
int size; return NULL;
if (!PyArg_ParseTuple(args, "Oi:CreatePipe", &pipe_attributes, &size))
return NULL;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
result = CreatePipe(&read_pipe, &write_pipe, NULL, size); result = CreatePipe(&read_pipe, &write_pipe, NULL, size);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (!result) if (! result)
return PyErr_SetFromWindowsErr(GetLastError()); return PyErr_SetFromWindowsErr(GetLastError());
return Py_BuildValue( return Py_BuildValue(
"NN", sp_handle_new(read_pipe), sp_handle_new(write_pipe) "NN", sp_handle_new(read_pipe), sp_handle_new(write_pipe));
);
} }
/* helpers for createprocess */ /* helpers for createprocess */
...@@ -238,236 +246,253 @@ sp_CreatePipe(PyObject* self, PyObject* args) ...@@ -238,236 +246,253 @@ sp_CreatePipe(PyObject* self, PyObject* args)
static int static int
getint(PyObject* obj, char* name) getint(PyObject* obj, char* name)
{ {
PyObject* value; PyObject* value;
value = PyObject_GetAttrString(obj, name);
if (!value) { value = PyObject_GetAttrString(obj, name);
PyErr_Clear(); /* FIXME: propagate error? */ if (! value) {
return 0; PyErr_Clear(); /* FIXME: propagate error? */
} return 0;
return (int) PyInt_AsLong(value); }
return (int) PyInt_AsLong(value);
} }
static HANDLE static HANDLE
gethandle(PyObject* obj, char* name) gethandle(PyObject* obj, char* name)
{ {
sp_handle_object* value; sp_handle_object* value;
value = (sp_handle_object*) PyObject_GetAttrString(obj, name);
if (!value) { value = (sp_handle_object*) PyObject_GetAttrString(obj, name);
PyErr_Clear(); /* FIXME: propagate error? */ if (! value) {
return NULL; PyErr_Clear(); /* FIXME: propagate error? */
} return NULL;
if (value->ob_type != &sp_handle_type) }
return NULL; if (value->ob_type != &sp_handle_type)
return value->handle; return NULL;
return value->handle;
} }
static PyObject* static PyObject*
getenvironment(PyObject* environment) getenvironment(PyObject* environment)
{ {
int i, envsize; int i, envsize;
PyObject* out = NULL; PyObject* out = NULL;
PyObject* keys; PyObject* keys;
PyObject* values; PyObject* values;
char* p; char* p;
/* convert environment dictionary to windows enviroment string */ /* convert environment dictionary to windows enviroment string */
if (! PyMapping_Check(environment)) {
if (!PyMapping_Check(environment)) { PyErr_SetString(
PyErr_SetString( PyExc_TypeError, "environment must be dictionary or None");
PyExc_TypeError, "environment must be dictionary or None" return NULL;
); }
return NULL;
} envsize = PyMapping_Length(environment);
envsize = PyMapping_Length(environment); keys = PyMapping_Keys(environment);
values = PyMapping_Values(environment);
keys = PyMapping_Keys(environment); if (!keys || !values)
values = PyMapping_Values(environment); goto error;
if (!keys || !values)
goto error; out = PyString_FromStringAndSize(NULL, 2048);
if (! out)
out = PyString_FromStringAndSize(NULL, 2048); goto error;
if (!out)
goto error; p = PyString_AS_STRING(out);
p = PyString_AS_STRING(out); for (i = 0; i < envsize; i++) {
int ksize, vsize, totalsize;
for (i = 0; i < envsize; i++) { PyObject* key = PyList_GET_ITEM(keys, i);
int ksize, vsize, totalsize; PyObject* value = PyList_GET_ITEM(values, i);
PyObject* key = PyList_GET_ITEM(keys, i);
PyObject* value = PyList_GET_ITEM(values, i); if (! PyString_Check(key) || ! PyString_Check(value)) {
if (!PyString_Check(key) || !PyString_Check(value)) { PyErr_SetString(PyExc_TypeError,
PyErr_SetString( "environment can only contain strings");
PyExc_TypeError, "environment can only contain strings" goto error;
); }
goto error; ksize = PyString_GET_SIZE(key);
} vsize = PyString_GET_SIZE(value);
ksize = PyString_GET_SIZE(key); totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 +
vsize = PyString_GET_SIZE(value); vsize + 1 + 1;
totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 + vsize + 1 + 1; if (totalsize > PyString_GET_SIZE(out)) {
if (totalsize > PyString_GET_SIZE(out)) { int offset = p - PyString_AS_STRING(out);
int offset = p - PyString_AS_STRING(out); _PyString_Resize(&out, totalsize + 1024);
_PyString_Resize(&out, totalsize + 1024); p = PyString_AS_STRING(out) + offset;
p = PyString_AS_STRING(out) + offset; }
} memcpy(p, PyString_AS_STRING(key), ksize);
memcpy(p, PyString_AS_STRING(key), ksize); p += ksize; *p++ = '='; p += ksize;
memcpy(p, PyString_AS_STRING(value), vsize); p += vsize; *p++ = '\0'; *p++ = '=';
} memcpy(p, PyString_AS_STRING(value), vsize);
p += vsize;
/* add trailing null byte */ *p++ = '\0';
*p++ = '\0'; }
_PyString_Resize(&out, p - PyString_AS_STRING(out)); /* add trailing null byte */
*p++ = '\0';
/* PyObject_Print(out, stdout, 0); */ _PyString_Resize(&out, p - PyString_AS_STRING(out));
return out; /* PyObject_Print(out, stdout, 0); */
error: return out;
Py_XDECREF(out);
Py_XDECREF(keys); error:
Py_XDECREF(values); Py_XDECREF(out);
return NULL; Py_XDECREF(keys);
Py_XDECREF(values);
return NULL;
} }
static PyObject * static PyObject *
sp_CreateProcess(PyObject* self, PyObject* args) sp_CreateProcess(PyObject* self, PyObject* args)
{ {
BOOL result; BOOL result;
PROCESS_INFORMATION pi; PROCESS_INFORMATION pi;
STARTUPINFO si; STARTUPINFO si;
PyObject* environment; PyObject* environment;
char* application_name; char* application_name;
char* command_line; char* command_line;
PyObject* process_attributes; /* ignored */ PyObject* process_attributes; /* ignored */
PyObject* thread_attributes; /* ignored */ PyObject* thread_attributes; /* ignored */
int inherit_handles; int inherit_handles;
int creation_flags; int creation_flags;
PyObject* env_mapping; PyObject* env_mapping;
char* current_directory; char* current_directory;
PyObject* startup_info; PyObject* startup_info;
if (!PyArg_ParseTuple(args, "zzOOiiOzO:CreateProcess",
&application_name, &command_line, if (! PyArg_ParseTuple(args, "zzOOiiOzO:CreateProcess",
&process_attributes, &thread_attributes, &application_name,
&inherit_handles, &creation_flags, &command_line,
&env_mapping, &current_directory, &startup_info)) &process_attributes,
return NULL; &thread_attributes,
&inherit_handles,
ZeroMemory(&si, sizeof(si)); &creation_flags,
si.cb = sizeof(si); &env_mapping,
&current_directory,
/* note: we only support a small subset of all SI attributes */ &startup_info))
si.dwFlags = getint(startup_info, "dwFlags"); return NULL;
si.hStdInput = gethandle(startup_info, "hStdInput");
si.hStdOutput = gethandle(startup_info, "hStdOutput"); ZeroMemory(&si, sizeof(si));
si.hStdError = gethandle(startup_info, "hStdError"); si.cb = sizeof(si);
if (env_mapping == Py_None) /* note: we only support a small subset of all SI attributes */
environment = NULL; si.dwFlags = getint(startup_info, "dwFlags");
else { si.hStdInput = gethandle(startup_info, "hStdInput");
environment = getenvironment(env_mapping); si.hStdOutput = gethandle(startup_info, "hStdOutput");
if (!environment) si.hStdError = gethandle(startup_info, "hStdError");
return NULL;
} if (env_mapping == Py_None)
environment = NULL;
Py_BEGIN_ALLOW_THREADS else {
result = CreateProcess( environment = getenvironment(env_mapping);
application_name, command_line, NULL, NULL, inherit_handles, if (! environment)
creation_flags, environment ? PyString_AS_STRING(environment) : NULL, return NULL;
current_directory, &si, &pi }
);
Py_END_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
result = CreateProcess(application_name,
Py_XDECREF(environment); command_line,
NULL,
if (!result) NULL,
return PyErr_SetFromWindowsErr(GetLastError()); inherit_handles,
creation_flags,
return Py_BuildValue( environment ? PyString_AS_STRING(environment) : NULL,
"NNii", sp_handle_new(pi.hProcess), sp_handle_new(pi.hThread), current_directory,
pi.dwProcessId, pi.dwThreadId &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);
} }
static PyObject * static PyObject *
sp_GetExitCodeProcess(PyObject* self, PyObject* args) sp_GetExitCodeProcess(PyObject* self, PyObject* args)
{ {
DWORD exit_code; DWORD exit_code;
BOOL result; BOOL result;
long process; long process;
if (!PyArg_ParseTuple(args, "l:GetExitCodeProcess", &process)) if (! PyArg_ParseTuple(args, "l:GetExitCodeProcess", &process))
return NULL; return NULL;
result = GetExitCodeProcess((HANDLE) process, &exit_code); result = GetExitCodeProcess((HANDLE) process, &exit_code);
if (!result) if (! result)
return PyErr_SetFromWindowsErr(GetLastError()); return PyErr_SetFromWindowsErr(GetLastError());
return PyInt_FromLong(exit_code); return PyInt_FromLong(exit_code);
} }
static PyObject * static PyObject *
sp_WaitForSingleObject(PyObject* self, PyObject* args) sp_WaitForSingleObject(PyObject* self, PyObject* args)
{ {
DWORD result; DWORD result;
long handle; long handle;
int milliseconds; int milliseconds;
if (!PyArg_ParseTuple(args, "li:WaitForSingleObject", if (! PyArg_ParseTuple(args, "li:WaitForSingleObject",
&handle, &milliseconds)) &handle,
return NULL; &milliseconds))
return NULL;
Py_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
result = WaitForSingleObject((HANDLE) handle, (DWORD) milliseconds); result = WaitForSingleObject((HANDLE) handle, (DWORD) milliseconds);
Py_END_ALLOW_THREADS Py_END_ALLOW_THREADS
if (result == WAIT_FAILED) if (result == WAIT_FAILED)
return PyErr_SetFromWindowsErr(GetLastError()); return PyErr_SetFromWindowsErr(GetLastError());
return PyInt_FromLong((int) result); return PyInt_FromLong((int) result);
} }
static PyObject * static PyObject *
sp_GetVersion(PyObject* self, PyObject* args) sp_GetVersion(PyObject* self, PyObject* args)
{ {
if (!PyArg_ParseTuple(args, ":GetVersion")) if (! PyArg_ParseTuple(args, ":GetVersion"))
return NULL; return NULL;
return PyInt_FromLong((int) GetVersion()); return PyInt_FromLong((int) GetVersion());
} }
static PyObject * static PyObject *
sp_GetModuleFileName(PyObject* self, PyObject* args) sp_GetModuleFileName(PyObject* self, PyObject* args)
{ {
BOOL result; BOOL result;
long module; long module;
TCHAR filename[MAX_PATH]; TCHAR filename[MAX_PATH];
if (!PyArg_ParseTuple(args, "l:GetModuleFileName", &module)) if (! PyArg_ParseTuple(args, "l:GetModuleFileName", &module))
return NULL; return NULL;
result = GetModuleFileName((HMODULE)module, filename, MAX_PATH); result = GetModuleFileName((HMODULE)module, filename, MAX_PATH);
filename[MAX_PATH-1] = '\0'; filename[MAX_PATH-1] = '\0';
if (!result) if (! result)
return PyErr_SetFromWindowsErr(GetLastError()); return PyErr_SetFromWindowsErr(GetLastError());
return PyString_FromString(filename); return PyString_FromString(filename);
} }
static PyMethodDef sp_functions[] = { static PyMethodDef sp_functions[] = {
{"GetStdHandle", sp_GetStdHandle, METH_VARARGS}, {"GetStdHandle", sp_GetStdHandle, METH_VARARGS},
{"GetCurrentProcess", sp_GetCurrentProcess, METH_VARARGS}, {"GetCurrentProcess", sp_GetCurrentProcess, METH_VARARGS},
{"DuplicateHandle", sp_DuplicateHandle, METH_VARARGS}, {"DuplicateHandle", sp_DuplicateHandle, METH_VARARGS},
{"CreatePipe", sp_CreatePipe, METH_VARARGS}, {"CreatePipe", sp_CreatePipe, METH_VARARGS},
{"CreateProcess", sp_CreateProcess, METH_VARARGS}, {"CreateProcess", sp_CreateProcess, METH_VARARGS},
{"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS}, {"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS},
{"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS}, {"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS},
{"GetVersion", sp_GetVersion, METH_VARARGS}, {"GetVersion", sp_GetVersion, METH_VARARGS},
{"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS}, {"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS},
{NULL, NULL} {NULL, NULL}
}; };
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
...@@ -475,11 +500,11 @@ static PyMethodDef sp_functions[] = { ...@@ -475,11 +500,11 @@ static PyMethodDef sp_functions[] = {
static void static void
defint(PyObject* d, const char* name, int value) defint(PyObject* d, const char* name, int value)
{ {
PyObject* v = PyInt_FromLong((long) value); PyObject* v = PyInt_FromLong((long) value);
if (v) { if (v) {
PyDict_SetItemString(d, (char*) name, v); PyDict_SetItemString(d, (char*) name, v);
Py_DECREF(v); Py_DECREF(v);
} }
} }
#if PY_VERSION_HEX >= 0x02030000 #if PY_VERSION_HEX >= 0x02030000
...@@ -489,23 +514,23 @@ DL_EXPORT(void) ...@@ -489,23 +514,23 @@ DL_EXPORT(void)
#endif #endif
init_subprocess() init_subprocess()
{ {
PyObject *d; PyObject *d;
PyObject *m; PyObject *m;
/* patch up object descriptors */ /* patch up object descriptors */
sp_handle_type.ob_type = &PyType_Type; sp_handle_type.ob_type = &PyType_Type;
sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int; sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int;
m = Py_InitModule("_subprocess", sp_functions); m = Py_InitModule("_subprocess", sp_functions);
d = PyModule_GetDict(m); d = PyModule_GetDict(m);
/* constants */ /* constants */
defint(d, "STD_INPUT_HANDLE", STD_INPUT_HANDLE); defint(d, "STD_INPUT_HANDLE", STD_INPUT_HANDLE);
defint(d, "STD_OUTPUT_HANDLE", STD_OUTPUT_HANDLE); defint(d, "STD_OUTPUT_HANDLE", STD_OUTPUT_HANDLE);
defint(d, "STD_ERROR_HANDLE", STD_ERROR_HANDLE); defint(d, "STD_ERROR_HANDLE", STD_ERROR_HANDLE);
defint(d, "DUPLICATE_SAME_ACCESS", DUPLICATE_SAME_ACCESS); defint(d, "DUPLICATE_SAME_ACCESS", DUPLICATE_SAME_ACCESS);
defint(d, "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES); defint(d, "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES);
defint(d, "INFINITE", INFINITE); defint(d, "INFINITE", INFINITE);
defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0); defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0);
defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE); defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE);
} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment