source: python/vendor/Python-2.7.6/PC/_subprocess.c

Last change on this file was 388, checked in by dmik, 11 years ago

python: Update vendor to 2.7.6.
  • Property svn:eol-style set to native
File size: 19.2 KB
Line 
1/*
2 * support routines for subprocess module
3 *
4 * Currently, this extension module is only required when using the
5 * subprocess module on Windows, but in the future, stubs for other
6 * platforms might be added here as well.
7 *
8 * Copyright (c) 2004 by Fredrik Lundh <fredrik@pythonware.com>
9 * Copyright (c) 2004 by Secret Labs AB, http://www.pythonware.com
10 * Copyright (c) 2004 by Peter Astrand <astrand@lysator.liu.se>
11 *
12 * By obtaining, using, and/or copying this software and/or its
13 * associated documentation, you agree that you have read, understood,
14 * and will comply with the following terms and conditions:
15 *
16 * Permission to use, copy, modify, and distribute this software and
17 * its associated documentation for any purpose and without fee is
18 * hereby granted, provided that the above copyright notice appears in
19 * all copies, and that both that copyright notice and this permission
20 * notice appear in supporting documentation, and that the name of the
21 * authors not be used in advertising or publicity pertaining to
22 * distribution of the software without specific, written prior
23 * permission.
24 *
25 * THE AUTHORS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
26 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
27 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
28 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
29 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
30 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
31 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
32 *
33 */
34
35/* Licensed to PSF under a Contributor Agreement. */
36/* See http://www.python.org/2.4/license for licensing details. */
37
38/* TODO: handle unicode command lines? */
39/* TODO: handle unicode environment? */
40
41#include "Python.h"
42
43#define WINDOWS_LEAN_AND_MEAN
44#include "windows.h"
45
46/* -------------------------------------------------------------------- */
47/* handle wrapper. note that this library uses integers when passing
48 handles to a function, and handle wrappers when returning handles.
49 the wrapper is used to provide Detach and Close methods */
50
51typedef struct {
52 PyObject_HEAD
53 HANDLE handle;
54} sp_handle_object;
55
56staticforward PyTypeObject sp_handle_type;
57
58static PyObject*
59sp_handle_new(HANDLE handle)
60{
61 sp_handle_object* self;
62
63 self = PyObject_NEW(sp_handle_object, &sp_handle_type);
64 if (self == NULL)
65 return NULL;
66
67 self->handle = handle;
68
69 return (PyObject*) self;
70}
71
72#if defined(MS_WIN32) && !defined(MS_WIN64)
73#define HANDLE_TO_PYNUM(handle) PyInt_FromLong((long) handle)
74#define PY_HANDLE_PARAM "l"
75#else
76#define HANDLE_TO_PYNUM(handle) PyLong_FromLongLong((long long) handle)
77#define PY_HANDLE_PARAM "L"
78#endif
79
80static PyObject*
81sp_handle_detach(sp_handle_object* self, PyObject* args)
82{
83 HANDLE handle;
84
85 if (! PyArg_ParseTuple(args, ":Detach"))
86 return NULL;
87
88 handle = self->handle;
89
90 self->handle = INVALID_HANDLE_VALUE;
91
92 /* note: return the current handle, as an integer */
93 return HANDLE_TO_PYNUM(handle);
94}
95
96static PyObject*
97sp_handle_close(sp_handle_object* self, PyObject* args)
98{
99 if (! PyArg_ParseTuple(args, ":Close"))
100 return NULL;
101
102 if (self->handle != INVALID_HANDLE_VALUE) {
103 CloseHandle(self->handle);
104 self->handle = INVALID_HANDLE_VALUE;
105 }
106 Py_INCREF(Py_None);
107 return Py_None;
108}
109
110static void
111sp_handle_dealloc(sp_handle_object* self)
112{
113 if (self->handle != INVALID_HANDLE_VALUE)
114 CloseHandle(self->handle);
115 PyObject_FREE(self);
116}
117
118static PyMethodDef sp_handle_methods[] = {
119 {"Detach", (PyCFunction) sp_handle_detach, METH_VARARGS},
120 {"Close", (PyCFunction) sp_handle_close, METH_VARARGS},
121 {NULL, NULL}
122};
123
124static PyObject*
125sp_handle_getattr(sp_handle_object* self, char* name)
126{
127 return Py_FindMethod(sp_handle_methods, (PyObject*) self, name);
128}
129
130static PyObject*
131sp_handle_as_int(sp_handle_object* self)
132{
133 return HANDLE_TO_PYNUM(self->handle);
134}
135
136static PyNumberMethods sp_handle_as_number;
137
138statichere PyTypeObject sp_handle_type = {
139 PyObject_HEAD_INIT(NULL)
140 0, /*ob_size*/
141 "_subprocess_handle", sizeof(sp_handle_object), 0,
142 (destructor) sp_handle_dealloc, /*tp_dealloc*/
143 0, /*tp_print*/
144 (getattrfunc) sp_handle_getattr,/*tp_getattr*/
145 0, /*tp_setattr*/
146 0, /*tp_compare*/
147 0, /*tp_repr*/
148 &sp_handle_as_number, /*tp_as_number */
149 0, /*tp_as_sequence */
150 0, /*tp_as_mapping */
151 0 /*tp_hash*/
152};
153
154/* -------------------------------------------------------------------- */
155/* windows API functions */
156
157PyDoc_STRVAR(GetStdHandle_doc,
158"GetStdHandle(handle) -> integer\n\
159\n\
160Return a handle to the specified standard device\n\
161(STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE).\n\
162The integer associated with the handle object is returned.");
163
164static PyObject *
165sp_GetStdHandle(PyObject* self, PyObject* args)
166{
167 HANDLE handle;
168 int std_handle;
169
170 if (! PyArg_ParseTuple(args, "i:GetStdHandle", &std_handle))
171 return NULL;
172
173 Py_BEGIN_ALLOW_THREADS
174 handle = GetStdHandle((DWORD) std_handle);
175 Py_END_ALLOW_THREADS
176
177 if (handle == INVALID_HANDLE_VALUE)
178 return PyErr_SetFromWindowsErr(GetLastError());
179
180 if (! handle) {
181 Py_INCREF(Py_None);
182 return Py_None;
183 }
184
185 /* note: returns integer, not handle object */
186 return HANDLE_TO_PYNUM(handle);
187}
188
189PyDoc_STRVAR(GetCurrentProcess_doc,
190"GetCurrentProcess() -> handle\n\
191\n\
192Return a handle object for the current process.");
193
194static PyObject *
195sp_GetCurrentProcess(PyObject* self, PyObject* args)
196{
197 if (! PyArg_ParseTuple(args, ":GetCurrentProcess"))
198 return NULL;
199
200 return sp_handle_new(GetCurrentProcess());
201}
202
203PyDoc_STRVAR(DuplicateHandle_doc,
204"DuplicateHandle(source_proc_handle, source_handle,\n\
205 target_proc_handle, target_handle, access,\n\
206 inherit[, options]) -> handle\n\
207\n\
208Return a duplicate handle object.\n\
209\n\
210The duplicate handle refers to the same object as the original\n\
211handle. Therefore, any changes to the object are reflected\n\
212through both handles.");
213
214static PyObject *
215sp_DuplicateHandle(PyObject* self, PyObject* args)
216{
217 HANDLE target_handle;
218 BOOL result;
219
220 HANDLE source_process_handle;
221 HANDLE source_handle;
222 HANDLE target_process_handle;
223 int desired_access;
224 int inherit_handle;
225 int options = 0;
226
227 if (! PyArg_ParseTuple(args,
228 PY_HANDLE_PARAM PY_HANDLE_PARAM PY_HANDLE_PARAM
229 "ii|i:DuplicateHandle",
230 &source_process_handle,
231 &source_handle,
232 &target_process_handle,
233 &desired_access,
234 &inherit_handle,
235 &options))
236 return NULL;
237
238 Py_BEGIN_ALLOW_THREADS
239 result = DuplicateHandle(
240 source_process_handle,
241 source_handle,
242 target_process_handle,
243 &target_handle,
244 desired_access,
245 inherit_handle,
246 options
247 );
248 Py_END_ALLOW_THREADS
249
250 if (! result)
251 return PyErr_SetFromWindowsErr(GetLastError());
252
253 return sp_handle_new(target_handle);
254}
255
256PyDoc_STRVAR(CreatePipe_doc,
257"CreatePipe(pipe_attrs, size) -> (read_handle, write_handle)\n\
258\n\
259Create an anonymous pipe, and return handles to the read and\n\
260write ends of the pipe.\n\
261\n\
262pipe_attrs is ignored internally and can be None.");
263
264static PyObject *
265sp_CreatePipe(PyObject* self, PyObject* args)
266{
267 HANDLE read_pipe;
268 HANDLE write_pipe;
269 BOOL result;
270
271 PyObject* pipe_attributes; /* ignored */
272 int size;
273
274 if (! PyArg_ParseTuple(args, "Oi:CreatePipe", &pipe_attributes, &size))
275 return NULL;
276
277 Py_BEGIN_ALLOW_THREADS
278 result = CreatePipe(&read_pipe, &write_pipe, NULL, size);
279 Py_END_ALLOW_THREADS
280
281 if (! result)
282 return PyErr_SetFromWindowsErr(GetLastError());
283
284 return Py_BuildValue(
285 "NN", sp_handle_new(read_pipe), sp_handle_new(write_pipe));
286}
287
288/* helpers for createprocess */
289
290static int
291getint(PyObject* obj, char* name)
292{
293 PyObject* value;
294 int ret;
295
296 value = PyObject_GetAttrString(obj, name);
297 if (! value) {
298 PyErr_Clear(); /* FIXME: propagate error? */
299 return 0;
300 }
301 ret = (int) PyInt_AsLong(value);
302 Py_DECREF(value);
303 return ret;
304}
305
306static HANDLE
307gethandle(PyObject* obj, char* name)
308{
309 sp_handle_object* value;
310 HANDLE ret;
311
312 value = (sp_handle_object*) PyObject_GetAttrString(obj, name);
313 if (! value) {
314 PyErr_Clear(); /* FIXME: propagate error? */
315 return NULL;
316 }
317 if (value->ob_type != &sp_handle_type)
318 ret = NULL;
319 else
320 ret = value->handle;
321 Py_DECREF(value);
322 return ret;
323}
324
325static PyObject*
326getenvironment(PyObject* environment)
327{
328 int i, envsize;
329 PyObject* out = NULL;
330 PyObject* keys;
331 PyObject* values;
332 char* p;
333
334 /* convert environment dictionary to windows environment string */
335 if (! PyMapping_Check(environment)) {
336 PyErr_SetString(
337 PyExc_TypeError, "environment must be dictionary or None");
338 return NULL;
339 }
340
341 envsize = PyMapping_Length(environment);
342
343 keys = PyMapping_Keys(environment);
344 values = PyMapping_Values(environment);
345 if (!keys || !values)
346 goto error;
347
348 out = PyString_FromStringAndSize(NULL, 2048);
349 if (! out)
350 goto error;
351
352 p = PyString_AS_STRING(out);
353
354 for (i = 0; i < envsize; i++) {
355 int ksize, vsize, totalsize;
356 PyObject* key = PyList_GET_ITEM(keys, i);
357 PyObject* value = PyList_GET_ITEM(values, i);
358
359 if (! PyString_Check(key) || ! PyString_Check(value)) {
360 PyErr_SetString(PyExc_TypeError,
361 "environment can only contain strings");
362 goto error;
363 }
364 ksize = PyString_GET_SIZE(key);
365 vsize = PyString_GET_SIZE(value);
366 totalsize = (p - PyString_AS_STRING(out)) + ksize + 1 +
367 vsize + 1 + 1;
368 if (totalsize > PyString_GET_SIZE(out)) {
369 int offset = p - PyString_AS_STRING(out);
370 _PyString_Resize(&out, totalsize + 1024);
371 p = PyString_AS_STRING(out) + offset;
372 }
373 memcpy(p, PyString_AS_STRING(key), ksize);
374 p += ksize;
375 *p++ = '=';
376 memcpy(p, PyString_AS_STRING(value), vsize);
377 p += vsize;
378 *p++ = '\0';
379 }
380
381 /* add trailing null byte */
382 *p++ = '\0';
383 _PyString_Resize(&out, p - PyString_AS_STRING(out));
384
385 /* PyObject_Print(out, stdout, 0); */
386
387 Py_XDECREF(keys);
388 Py_XDECREF(values);
389
390 return out;
391
392 error:
393 Py_XDECREF(out);
394 Py_XDECREF(keys);
395 Py_XDECREF(values);
396 return NULL;
397}
398
399PyDoc_STRVAR(CreateProcess_doc,
400"CreateProcess(app_name, cmd_line, proc_attrs, thread_attrs,\n\
401 inherit, flags, env_mapping, curdir,\n\
402 startup_info) -> (proc_handle, thread_handle,\n\
403 pid, tid)\n\
404\n\
405Create a new process and its primary thread. The return\n\
406value is a tuple of the process handle, thread handle,\n\
407process ID, and thread ID.\n\
408\n\
409proc_attrs and thread_attrs are ignored internally and can be None.");
410
411static PyObject *
412sp_CreateProcess(PyObject* self, PyObject* args)
413{
414 BOOL result;
415 PROCESS_INFORMATION pi;
416 STARTUPINFO si;
417 PyObject* environment;
418
419 char* application_name;
420 char* command_line;
421 PyObject* process_attributes; /* ignored */
422 PyObject* thread_attributes; /* ignored */
423 int inherit_handles;
424 int creation_flags;
425 PyObject* env_mapping;
426 char* current_directory;
427 PyObject* startup_info;
428
429 if (! PyArg_ParseTuple(args, "zzOOiiOzO:CreateProcess",
430 &application_name,
431 &command_line,
432 &process_attributes,
433 &thread_attributes,
434 &inherit_handles,
435 &creation_flags,
436 &env_mapping,
437 &current_directory,
438 &startup_info))
439 return NULL;
440
441 ZeroMemory(&si, sizeof(si));
442 si.cb = sizeof(si);
443
444 /* note: we only support a small subset of all SI attributes */
445 si.dwFlags = getint(startup_info, "dwFlags");
446 si.wShowWindow = getint(startup_info, "wShowWindow");
447 si.hStdInput = gethandle(startup_info, "hStdInput");
448 si.hStdOutput = gethandle(startup_info, "hStdOutput");
449 si.hStdError = gethandle(startup_info, "hStdError");
450
451 if (PyErr_Occurred())
452 return NULL;
453
454 if (env_mapping == Py_None)
455 environment = NULL;
456 else {
457 environment = getenvironment(env_mapping);
458 if (! environment)
459 return NULL;
460 }
461
462 Py_BEGIN_ALLOW_THREADS
463 result = CreateProcess(application_name,
464 command_line,
465 NULL,
466 NULL,
467 inherit_handles,
468 creation_flags,
469 environment ? PyString_AS_STRING(environment) : NULL,
470 current_directory,
471 &si,
472 &pi);
473 Py_END_ALLOW_THREADS
474
475 Py_XDECREF(environment);
476
477 if (! result)
478 return PyErr_SetFromWindowsErr(GetLastError());
479
480 return Py_BuildValue("NNii",
481 sp_handle_new(pi.hProcess),
482 sp_handle_new(pi.hThread),
483 pi.dwProcessId,
484 pi.dwThreadId);
485}
486
487PyDoc_STRVAR(TerminateProcess_doc,
488"TerminateProcess(handle, exit_code) -> None\n\
489\n\
490Terminate the specified process and all of its threads.");
491
492static PyObject *
493sp_TerminateProcess(PyObject* self, PyObject* args)
494{
495 BOOL result;
496
497 HANDLE process;
498 int exit_code;
499 if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:TerminateProcess",
500 &process, &exit_code))
501 return NULL;
502
503 result = TerminateProcess(process, exit_code);
504
505 if (! result)
506 return PyErr_SetFromWindowsErr(GetLastError());
507
508 Py_INCREF(Py_None);
509 return Py_None;
510}
511
512PyDoc_STRVAR(GetExitCodeProcess_doc,
513"GetExitCodeProcess(handle) -> Exit code\n\
514\n\
515Return the termination status of the specified process.");
516
517static PyObject *
518sp_GetExitCodeProcess(PyObject* self, PyObject* args)
519{
520 DWORD exit_code;
521 BOOL result;
522
523 HANDLE process;
524 if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetExitCodeProcess", &process))
525 return NULL;
526
527 result = GetExitCodeProcess(process, &exit_code);
528
529 if (! result)
530 return PyErr_SetFromWindowsErr(GetLastError());
531
532 return PyInt_FromLong(exit_code);
533}
534
535PyDoc_STRVAR(WaitForSingleObject_doc,
536"WaitForSingleObject(handle, timeout) -> result\n\
537\n\
538Wait until the specified object is in the signaled state or\n\
539the time-out interval elapses. The timeout value is specified\n\
540in milliseconds.");
541
542static PyObject *
543sp_WaitForSingleObject(PyObject* self, PyObject* args)
544{
545 DWORD result;
546
547 HANDLE handle;
548 int milliseconds;
549 if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM "i:WaitForSingleObject",
550 &handle,
551 &milliseconds))
552 return NULL;
553
554 Py_BEGIN_ALLOW_THREADS
555 result = WaitForSingleObject(handle, (DWORD) milliseconds);
556 Py_END_ALLOW_THREADS
557
558 if (result == WAIT_FAILED)
559 return PyErr_SetFromWindowsErr(GetLastError());
560
561 return PyInt_FromLong((int) result);
562}
563
564PyDoc_STRVAR(GetVersion_doc,
565"GetVersion() -> version\n\
566\n\
567Return the version number of the current operating system.");
568
569static PyObject *
570sp_GetVersion(PyObject* self, PyObject* args)
571{
572 if (! PyArg_ParseTuple(args, ":GetVersion"))
573 return NULL;
574
575 return PyInt_FromLong((int) GetVersion());
576}
577
578PyDoc_STRVAR(GetModuleFileName_doc,
579"GetModuleFileName(module) -> path\n\
580\n\
581Return the fully-qualified path for the file that contains\n\
582the specified module. The module must have been loaded by the\n\
583current process.\n\
584\n\
585The module parameter should be a handle to the loaded module\n\
586whose path is being requested. If this parameter is 0, \n\
587GetModuleFileName retrieves the path of the executable file\n\
588of the current process.");
589
590static PyObject *
591sp_GetModuleFileName(PyObject* self, PyObject* args)
592{
593 BOOL result;
594 HMODULE module;
595 TCHAR filename[MAX_PATH];
596
597 if (! PyArg_ParseTuple(args, PY_HANDLE_PARAM ":GetModuleFileName",
598 &module))
599 return NULL;
600
601 result = GetModuleFileName(module, filename, MAX_PATH);
602 filename[MAX_PATH-1] = '\0';
603
604 if (! result)
605 return PyErr_SetFromWindowsErr(GetLastError());
606
607 return PyString_FromString(filename);
608}
609
610static PyMethodDef sp_functions[] = {
611 {"GetStdHandle", sp_GetStdHandle, METH_VARARGS, GetStdHandle_doc},
612 {"GetCurrentProcess", sp_GetCurrentProcess, METH_VARARGS,
613 GetCurrentProcess_doc},
614 {"DuplicateHandle", sp_DuplicateHandle, METH_VARARGS,
615 DuplicateHandle_doc},
616 {"CreatePipe", sp_CreatePipe, METH_VARARGS, CreatePipe_doc},
617 {"CreateProcess", sp_CreateProcess, METH_VARARGS, CreateProcess_doc},
618 {"TerminateProcess", sp_TerminateProcess, METH_VARARGS,
619 TerminateProcess_doc},
620 {"GetExitCodeProcess", sp_GetExitCodeProcess, METH_VARARGS,
621 GetExitCodeProcess_doc},
622 {"WaitForSingleObject", sp_WaitForSingleObject, METH_VARARGS,
623 WaitForSingleObject_doc},
624 {"GetVersion", sp_GetVersion, METH_VARARGS, GetVersion_doc},
625 {"GetModuleFileName", sp_GetModuleFileName, METH_VARARGS,
626 GetModuleFileName_doc},
627 {NULL, NULL}
628};
629
630/* -------------------------------------------------------------------- */
631
632static void
633defint(PyObject* d, const char* name, int value)
634{
635 PyObject* v = PyInt_FromLong((long) value);
636 if (v) {
637 PyDict_SetItemString(d, (char*) name, v);
638 Py_DECREF(v);
639 }
640}
641
642#if PY_VERSION_HEX >= 0x02030000
643PyMODINIT_FUNC
644#else
645DL_EXPORT(void)
646#endif
647init_subprocess()
648{
649 PyObject *d;
650 PyObject *m;
651
652 /* patch up object descriptors */
653 sp_handle_type.ob_type = &PyType_Type;
654 sp_handle_as_number.nb_int = (unaryfunc) sp_handle_as_int;
655
656 m = Py_InitModule("_subprocess", sp_functions);
657 if (m == NULL)
658 return;
659 d = PyModule_GetDict(m);
660
661 /* constants */
662 defint(d, "STD_INPUT_HANDLE", STD_INPUT_HANDLE);
663 defint(d, "STD_OUTPUT_HANDLE", STD_OUTPUT_HANDLE);
664 defint(d, "STD_ERROR_HANDLE", STD_ERROR_HANDLE);
665 defint(d, "DUPLICATE_SAME_ACCESS", DUPLICATE_SAME_ACCESS);
666 defint(d, "STARTF_USESTDHANDLES", STARTF_USESTDHANDLES);
667 defint(d, "STARTF_USESHOWWINDOW", STARTF_USESHOWWINDOW);
668 defint(d, "SW_HIDE", SW_HIDE);
669 defint(d, "INFINITE", INFINITE);
670 defint(d, "WAIT_OBJECT_0", WAIT_OBJECT_0);
671 defint(d, "CREATE_NEW_CONSOLE", CREATE_NEW_CONSOLE);
672 defint(d, "CREATE_NEW_PROCESS_GROUP", CREATE_NEW_PROCESS_GROUP);
673 defint(d, "STILL_ACTIVE", STILL_ACTIVE);
674}
Note: See TracBrowser for help on using the repository browser.