Mercurial > ~astiob > upreckon > hgweb
view _unixmodule.cpp @ 142:98bccf81db4d
win32.call() now trusts its own case.time_started
author | Oleg Oshmyan <chortos@inbox.lv> |
---|---|
date | Wed, 25 May 2011 00:27:12 +0100 |
parents | f4361d557929 |
children |
line wrap: on
line source
// Copyright (c) 2011 Chortos-2 <chortos@inbox.lv> #include <Python.h> #include <structmember.h> #ifdef HAVE_SYS_TYPES_H #include <sys/types.h> #endif #ifdef HAVE_FCNTL_H #include <fcntl.h> #endif #include <limits.h> #ifdef HAVE_SIGNAL_H #include <signal.h> #endif #ifdef HAVE_SPAWN_H #include <spawn.h> #ifdef __APPLE__ #pragma weak_import posix_spawnp #endif #endif #ifdef HAVE_SYS_RESOURCE_H #include <sys/resource.h> #endif #ifdef HAVE_SYS_WAIT_H #include <sys/wait.h> #endif #ifdef HAVE_TERMIOS_H #include <termios.h> #endif #if !(defined __cplusplus) && !(defined bool) #ifdef HAVE_C99_BOOL #define bool _Bool #else #define bool char #endif #undef true #define true 1 #undef false #define false 0 #endif // On Python 2.5, SIGINT handling may get delayed until we return to Python #if PY_MAJOR_VERSION > 2 || PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 6 #define USE_WAKEUP_FD #endif #if !(defined RLIMIT_AS) && defined RLIMIT_VMEM #define RLIMIT_AS RLIMIT_VMEM #endif // Condition stolen from posixmodule.c of Python 2.7.1 #if defined __USLC__ && defined __SCO_VERSION__ // SCO UDK Compiler //#ifdef HAVE_FORK1 #define fork fork1 #endif // Stolen from posixmodule.c of Python 2.7.1 #ifdef WITH_NEXT_FRAMEWORK #include <crt_externs.h> static char **environ = NULL; #elif !(defined _MSC_VER) && (!(defined __WATCOMC__) || defined __QNX__) extern char **environ; #endif #ifndef Py_PYTIME_H typedef struct timeval _PyTime_timeval; #ifndef GETTIMEOFDAY_NO_TZ #define _PyTime_gettimeofday(tvp) gettimeofday((tvp), NULL) #else #define _PyTime_gettimeofday(tvp) gettimeofday((tvp)) #endif #endif #if PY_MAJOR_VERSION >= 3 #define PyInt_AsLong PyLong_AsLong #define PyInt_FromLong PyLong_FromLong #define PyNumber_Int PyNumber_Long #endif #define TESTEE_SPAWNED 0 #define TESTEE_SPAWN_FAILED 1 #define TESTEE_REPORT_STATUS(status) \ do \ { \ const char c = (status); \ write(c2ppipe[1], &c, 1); \ } \ while (0) #if !(defined SIGKILL) && defined SIGTERM #define SIGKILL SIGTERM #endif #if defined HAVE_KILL && defined SIGKILL #ifdef HAVE_WAITPID #define TERM_TESTEE \ do \ { \ kill(-curpid, SIGKILL); \ kill(-curpid, SIGCONT); \ while (waitpid(curpid, &retstat, 0) != curpid); \ } \ while (0) #else #define TERM_TESTEE \ do \ { \ kill(-curpid, SIGKILL); \ kill(-curpid, SIGCONT); \ while (wait(&retstat) != curpid); \ } \ while (0) #endif #else #define TERM_TESTEE #endif #if defined HAVE_KILL && defined SIGINT #define PROPAGATE_SIGINT ((void) kill(-curpid, SIGINT)) #else #define PROPAGATE_SIGINT #endif struct child_stats { int returncode; _PyTime_timeval walltime; #if defined HAVE_SYS_RESOURCE_H || defined HAVE_WAIT4 || defined HAVE_WAIT3 _PyTime_timeval cputime; Py_ssize_t memory; #endif }; static pid_t curpid; static const struct child_stats zero_stats = { 0 }; static PyObject *CannotStartTestee, *CanceledByUser, *WallTimeLimitExceeded, *CPUTimeLimitExceeded, *MemoryLimitExceeded; static _PyTime_timeval time_end; #ifdef USE_WAKEUP_FD static char dont_care_buffer[512]; static int intpipe[2] = { 0 }; #endif #ifdef HAVE_TERMIOS_H static bool catch_escape = false; static struct termios orig_termios; #endif typedef struct { PyObject_HEAD int returncode; } _unix__PopenPlaceholderObject; static PyMemberDef _PopenPlaceholder_members[] = { { "returncode", T_INT, offsetof(_unix__PopenPlaceholderObject, returncode), READONLY, NULL }, { NULL } }; static PyTypeObject _unix__PopenPlaceholderType = { #if PY_MAJOR_VERSION >= 3 PyVarObject_HEAD_INIT(NULL, 0) #else PyObject_HEAD_INIT(NULL) 0, /*ob_size*/ #endif "_unix._PopenPlaceholder", /*tp_name*/ sizeof(_unix__PopenPlaceholderObject), /*tp_basicsize*/ 0, /*tp_itemsize*/ 0, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash */ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ _PopenPlaceholder_members, /*tp_members*/ }; #ifndef timeradd #define timeradd(a, b, res) \ do \ { \ (res)->tv_sec = (a)->tv_sec + (b)->tv_sec; \ (res)->tv_usec = (a)->tv_usec + (b)->tv_usec; \ if ((res)->tv_usec >= 1000000) \ { \ ++(res)->tv_sec; \ (res)->tv_usec -= 1000000; \ } \ } \ while (0) #endif #ifndef timersub #define timersub(a, b, res) \ do \ { \ (res)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ (res)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ if ((res)->tv_usec < 0) \ { \ --(res)->tv_sec; \ (res)->tv_usec += 1000000; \ } \ } \ while (0) #endif #ifndef timerclear #define timerclear(tvp) ((void) ((tvp)->tv_sec = (tvp)->tv_usec = 0)) #endif #ifndef timerisset #define timerisset(tvp) ((tvp)->tv_sec || (tvp)->tv_usec) #endif #ifndef timercmp #define timercmp(a, b, cmp) \ (((a)->tv_sec == (b)->tv_sec) \ ? ((a)->tv_usec cmp (b)->tv_usec) \ : ((a)->tv_sec cmp (b)->tv_sec)) #endif // Stolen from posixmodule.c of Python 2.7.1 static void free_string_array(char **array, Py_ssize_t count) { Py_ssize_t i; for (i = 0; i < count; ++i) PyMem_Free(array[i]); PyMem_DEL(array); } // Stolen from termios.c of Python 2.7.1 static int fdconv(PyObject *obj, void *p) { int fd = PyObject_AsFileDescriptor(obj); if (fd >= 0) { *((int *) p) = fd; return 1; } return 0; } // Parts stolen from bltinmodule.c, posixmodule.c and termios.c of Python 2.7.1 static int my_spawn(PyObject *args, PyObject *kwds, int c2ppipe[2], int maxcputime, Py_ssize_t maxmemory) { static const char *const kwlist[] = { "stdin", "stdout", "stderr", NULL }; static PyObject *dummy_args = NULL; Py_ssize_t i, argc; char **argv; bool own_args = false; int fdin = 0, fdout = 1, fderr = 2; if (dummy_args == NULL) { if (!(dummy_args = PyTuple_New(0))) { return -1; } } if (!PyArg_ParseTuple(args, "O:call", &args)) { return -1; } if (!PyArg_ParseTupleAndKeywords(dummy_args, kwds, "|O&O&O&:call", (char **) kwlist, fdconv, &fdin, fdconv, &fdout, fdconv, &fderr)) { return -1; } #if PY_MAJOR_VERSION >= 3 if (PyUnicode_Check(args)) #else if (PyString_Check(args) || PyUnicode_Check(args)) #endif { argc = 1; args = PyTuple_Pack(1, args); if (args == NULL) { return -1; } own_args = true; } else if (!PySequence_Check(args)) { PyErr_SetString(PyExc_TypeError, "call() argument must be a sequence or string"); return -1; } else { argc = PySequence_Size(args); if (argc < 1) { PyErr_SetString(PyExc_TypeError, "call() argument must not be empty"); return -1; } } argv = PyMem_NEW(char *, argc + 1); if (argv == NULL) { if (own_args) { Py_DECREF(args); } PyErr_NoMemory(); return -1; } for (i = 0; i < argc; ++i) { if (!PyArg_Parse(PySequence_ITEM(args, i), "et", Py_FileSystemDefaultEncoding, &argv[i])) { free_string_array(argv, i); if (own_args) { Py_DECREF(args); } PyErr_SetString(PyExc_TypeError, "call() argument must contain only strings"); return -1; } } argv[argc] = NULL; curpid = fork(); if (!curpid) { pid_t pid; int spawn_errno, status, fd, fddupped[3]; struct child_stats stats; _PyTime_timeval tvstart, tvend; #if defined HAVE_SYS_RESOURCE_H || defined HAVE_WAIT4 || defined HAVE_WAIT3 struct rusage rusage; #endif #if defined RLIMIT_AS || defined RLIMIT_CPU struct rlimit rlimit; #endif /* Assume no errors occur: * POSIX:2008 doesn't even define any errors for setpgrp, nor does the (probably copied-verbatim-from-FreeBSD) man page on Mac OS X 10.6; * none of the error conditions POSIX:2008 does define for setpgid can occur. */ #ifdef HAVE_SETPGID setpgid(0, 0); #else //if defined HAVE_SETPGRP #ifdef SETPGRP_HAVE_ARG setpgrp(0, 0); #else setpgrp(); #endif #endif #ifdef SIGINT signal(SIGINT, SIG_DFL); #endif #if PY_MAJOR_VERSION > 3 || PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION >= 2 _Py_RestoreSignals(); #else #ifdef SIGPIPE signal(SIGPIPE, SIG_DFL); #endif #ifdef SIGXFSZ signal(SIGXFSZ, SIG_DFL); #endif #ifdef SIGXFZ signal(SIGXFZ, SIG_DFL); #endif #endif if (c2ppipe[1] < 3) { int newfd; #ifdef F_DUPFD_CLOEXEC newfd = fcntl(c2ppipe[1], F_DUPFD_CLOEXEC, 3); if (newfd == -1) { spawn_errno = errno; TESTEE_REPORT_STATUS(TESTEE_SPAWN_FAILED); write(c2ppipe[1], &spawn_errno, sizeof spawn_errno); _exit(127); } c2ppipe[1] = newfd; #else newfd = fcntl(c2ppipe[1], F_DUPFD, 3); // Other threads should not fork/spawn right now if (newfd == -1 || fcntl(newfd, F_SETFD, fcntl(newfd, F_GETFD) | FD_CLOEXEC) == -1) { spawn_errno = errno; TESTEE_REPORT_STATUS(TESTEE_SPAWN_FAILED); write(c2ppipe[1], &spawn_errno, sizeof spawn_errno); _exit(127); } c2ppipe[1] = newfd; #endif } // Yes, this works as intended even if fdin == fdout == fderr == 0 // and there are no open file descriptors except 0 and c2ppipe // FIXME: error handling fddupped[0] = dup(fdin); fddupped[1] = dup(fdout); fddupped[2] = dup(fderr); dup2(fddupped[0], 0); dup2(fddupped[1], 1); dup2(fddupped[2], 2); // FIXME: close() may fail with EINTR or EIO; is setting CLOEXEC safer? // Bear in mind we still want to close them in _this_ process for (fd = sysconf(_SC_OPEN_MAX); --fd > c2ppipe[1]; ) { close(fd); } while (--fd >= 3) { close(fd); } #ifdef RLIMIT_AS if (maxmemory) { rlimit.rlim_cur = rlimit.rlim_max = maxmemory; setrlimit(RLIMIT_AS, &rlimit); } #endif #ifdef RLIMIT_CPU if (maxcputime) { rlimit.rlim_cur = rlimit.rlim_max = maxcputime; setrlimit(RLIMIT_CPU, &rlimit); } #endif #ifdef HAVE_SPAWN_H #ifdef __APPLE__ if (posix_spawnp != NULL) { #endif spawn_errno = posix_spawnp(&pid, argv[0], NULL, NULL, argv, environ); _PyTime_gettimeofday(&tvstart); if (spawn_errno) { TESTEE_REPORT_STATUS(TESTEE_SPAWN_FAILED); write(c2ppipe[1], &spawn_errno, sizeof spawn_errno); _exit(127); } #ifdef __APPLE__ } else #endif #endif #if !(defined HAVE_SPAWN_H) || defined __APPLE__ { pid = fork(); if (!pid) { execvp(argv[0], argv); spawn_errno = errno; TESTEE_REPORT_STATUS(TESTEE_SPAWN_FAILED); write(c2ppipe[1], &spawn_errno, sizeof spawn_errno); _exit(127); } else if (pid == -1) { spawn_errno = errno; TESTEE_REPORT_STATUS(TESTEE_SPAWN_FAILED); write(c2ppipe[1], &spawn_errno, sizeof spawn_errno); _exit(127); } else { _PyTime_gettimeofday(&tvstart); } } #endif TESTEE_REPORT_STATUS(TESTEE_SPAWNED); write(c2ppipe[1], &tvstart, sizeof tvstart); #ifdef HAVE_WAIT4 while (wait4(pid, &status, 0, &rusage) != pid); #elif defined HAVE_WAIT3 while (wait3(&status, 0, &rusage) != pid); #elif defined HAVE_WAITPID while (waitpid(pid, &status, 0) != pid); #else while (wait(&status) != pid); #endif _PyTime_gettimeofday(&tvend); #if defined HAVE_SYS_RESOURCE_H && !(defined HAVE_WAIT4 || defined HAVE_WAIT3) getrusage(RUSAGE_CHILDREN, &rusage); #endif stats = zero_stats; if (WIFEXITED(status) && WEXITSTATUS(status) == 127) _exit(127); else if (WIFSIGNALED(status)) stats.returncode = -WTERMSIG(status); else stats.returncode = WEXITSTATUS(status); timersub(&tvend, &tvstart, &stats.walltime); #if defined HAVE_SYS_RESOURCE_H || defined HAVE_WAIT4 || defined HAVE_WAIT3 timeradd(&rusage.ru_utime, &rusage.ru_stime, &stats.cputime); #ifdef __APPLE__ stats.memory = rusage.ru_maxrss; #else stats.memory = rusage.ru_maxrss << 10; #endif #endif write(c2ppipe[1], &stats, sizeof stats); _exit(0); } else if (curpid == -1) { PyErr_SetFromErrno(PyExc_OSError); free_string_array(argv, argc); if (own_args) { Py_DECREF(args); } return 0; } /* Assume no errors occur if the child is still alive: * the (probably copied-verbatim-from-FreeBSD) man page on Mac OS X 10.6 doesn't even define any errors for setpgrp; * none of the error conditions POSIX:2008 defines for setpgid can occur. */ #ifdef HAVE_SETPGID setpgid(curpid, 0); #elif defined SETPGRP_HAVE_ARG setpgrp(curpid, 0); #endif free_string_array(argv, argc); if (own_args) { Py_DECREF(args); } return 1; } static inline bool attr_to_timeval(PyObject *obj, const char *attr, _PyTime_timeval *ptv) { #ifdef HAVE_LONG_LONG long long i_whole; #else long i_whole; #endif PyObject *whole, *frac, *million, *usec, *usec_whole; PyObject *member = PyObject_GetAttrString(obj, attr); if (member == NULL) { return false; } if (member == Py_None) { Py_DECREF(member); timerclear(ptv); return true; } whole = PyNumber_Int(member); if (whole == NULL) { Py_DECREF(member); return false; } #ifdef HAVE_LONG_LONG i_whole = PyLong_AsLongLong(whole); #else i_whole = PyInt_AsLong(whole); #endif if (i_whole == -1 && PyErr_Occurred() != NULL) { Py_DECREF(whole); Py_DECREF(member); return false; } // FIXME: detect time_t overflow ptv->tv_sec = i_whole; frac = PyNumber_Subtract(member, whole); Py_DECREF(whole); Py_DECREF(member); if (frac == NULL) { return false; } million = PyInt_FromLong(1000000); if (million == NULL) { Py_DECREF(frac); return false; } usec = PyNumber_InPlaceMultiply(frac, million); Py_DECREF(million); Py_DECREF(frac); if (usec == NULL) { return false; } usec_whole = PyNumber_Int(usec); Py_DECREF(usec); if (usec_whole == NULL) { return false; } // FIXME: a sanity check (0 <= value < 1000000) here wouldn't harm ptv->tv_usec = PyInt_AsLong(usec_whole); Py_DECREF(usec_whole); return ptv->tv_usec != -1 || PyErr_Occurred() == NULL; } #ifdef __cplusplus typedef struct { char a[2]; } two_chars; static char is_int(char); static char is_int(signed char); static char is_int(unsigned char); static char is_int(short); static char is_int(unsigned short); static char is_int(int); static char is_int(unsigned); static char is_int(long); static char is_int(unsigned long); #ifdef HAVE_LONG_LONG static char is_int(long long); static char is_int(unsigned long long); #endif static two_chars is_int(...); #endif static inline bool timeval_to_attr(_PyTime_timeval *ptv, PyObject *obj, const char *attr) { PyObject *value; #ifdef __cplusplus // If tv_sec has an integral type and !tv_usec, try to create a Python int if (sizeof is_int(ptv->tv_sec) == sizeof(char) && !ptv->tv_usec) { if (ptv->tv_sec <= LONG_MAX) { value = PyInt_FromLong(ptv->tv_sec); } // FIXME: signed/unsigned comparisons ruin everything #ifdef HAVE_LONG_LONG else// if (ptv->tv_sec <= ULLONG_MAX) { value = PyLong_FromUnsignedLongLong(ptv->tv_sec); } #else // else if (ptv->tv_sec <= ULONG_MAX) // { // value = PyLong_FromUnsignedLong(ptv->tv_sec); // } //#endif else { value = PyFloat_FromDouble(ptv->tv_sec); } // #endif // } else #endif { // TODO: use decimal.Decimal or fractions.Fraction value = PyFloat_FromDouble(ptv->tv_sec + ptv->tv_usec * 0.000001); } if (value == NULL) { return false; } if (PyObject_SetAttrString(obj, attr, value) == -1) { return false; } Py_DECREF(value); return true; } /* TODO/FIXME: * Replace timeval->timespec and select->pselect if pselect is available (preferably only if pselect is not a wrapper around select). * File descriptors might be >= FD_SETSIZE? */ static PyObject *_unix_call(PyObject *self, PyObject *args, PyObject *kwds) { PyObject *testcase = NULL, *obj; _unix__PopenPlaceholderObject *Popen_placeholder; int spawn_errno = 0, spawn_status, s, c2ppipe[2], retstat; struct child_stats stats = zero_stats; _PyTime_timeval maxwalltime, maxcputime, timeout, time_start; Py_ssize_t maxmemory, r; size_t stats_read = 0; fd_set readfds; char c; bool have_maxwalltime; if (kwds != NULL) { testcase = PyDict_GetItemString(kwds, "case"); } if (testcase == NULL) { PyErr_SetString(PyExc_TypeError, "call() requires a keyword argument 'case'"); return NULL; } Py_INCREF(testcase); PyDict_DelItemString(kwds, "case"); if (!attr_to_timeval(testcase, "maxwalltime", &maxwalltime) || !attr_to_timeval(testcase, "maxcputime", &maxcputime)) { Py_DECREF(testcase); return NULL; } obj = PyObject_GetAttrString(testcase, "maxmemory"); if (obj == NULL) { Py_DECREF(testcase); return NULL; } if (PyObject_IsTrue(obj)) { PyObject *factor, *bytes; factor = PyInt_FromLong(1024 * 1024); if (factor == NULL) { Py_DECREF(testcase); return NULL; } bytes = PyNumber_Multiply(obj, factor); Py_DECREF(factor); if (bytes == NULL) { Py_DECREF(testcase); return NULL; } maxmemory = PyNumber_AsSsize_t(bytes, PyExc_OverflowError); Py_DECREF(bytes); if (maxmemory == -1 && PyErr_Occurred() != NULL) { Py_DECREF(testcase); return NULL; } } else { maxmemory = 0; } Py_DECREF(obj); #ifdef HAVE_PIPE2 if (pipe2(c2ppipe, O_CLOEXEC)) { PyErr_SetFromErrno(PyExc_IOError); Py_DECREF(testcase); return NULL; } #else if (pipe(c2ppipe)) { PyErr_SetFromErrno(PyExc_IOError); Py_DECREF(testcase); return NULL; } // Does any other thread fork/spawn right now? Please shoot it in the head // (well, if this ends up causing trouble, anyway) if (fcntl(c2ppipe[0], F_SETFD, fcntl(c2ppipe[0], F_GETFD) | FD_CLOEXEC) == -1 || fcntl(c2ppipe[1], F_SETFD, fcntl(c2ppipe[1], F_GETFD) | FD_CLOEXEC) == -1) { PyErr_SetFromErrno(PyExc_IOError); close(c2ppipe[0]); close(c2ppipe[1]); Py_DECREF(testcase); return NULL; } #endif spawn_status = my_spawn(args, kwds, c2ppipe, maxcputime.tv_sec + (maxcputime.tv_usec > 0), maxmemory); close(c2ppipe[1]); if (!spawn_status) { PyObject *type, *value, *traceback, *e; close(c2ppipe[0]); Py_DECREF(testcase); PyErr_Fetch(&type, &value, &traceback); PyErr_NormalizeException(&type, &value, &traceback); Py_XDECREF(traceback); Py_DECREF(type); e = PyObject_CallFunctionObjArgs(CannotStartTestee, value, NULL); Py_DECREF(value); PyErr_SetObject(CannotStartTestee, e); Py_DECREF(e); return NULL; } else if (spawn_status < 0) { close(c2ppipe[0]); Py_DECREF(testcase); return NULL; } // FIXME: use select in order not to miss SIGINT while ((r = read(c2ppipe[0], &c, 1)) == -1 && errno == EINTR) { if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } } if (r == 1) { if (c == TESTEE_SPAWNED) { size_t got = 0; while (got < sizeof time_start) { r = read(c2ppipe[0], got + (char *) &time_start, sizeof time_start - got); if (r > 0) { got += r; } else if (!r) { errno = 0; PyErr_SetFromErrno(PyExc_IOError); goto spawn_failed; } else if (errno == EINTR) { if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } } else { PyErr_SetFromErrno(PyExc_IOError); goto spawn_failed; } } if (!timeval_to_attr(&time_start, testcase, "time_started")) { close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } } else // if (c == TESTEE_SPAWN_FAILED) { size_t got = 0; while (got < sizeof spawn_errno) { r = read(c2ppipe[0], got + (char *) &spawn_errno, sizeof spawn_errno - got); if (r > 0) { got += r; } else if (!r) { // Can't get the real error; use zero instead spawn_errno = 0; break; } else if (errno == EINTR) { if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } } else { PyErr_SetFromErrno(PyExc_IOError); goto spawn_failed; } } errno = spawn_errno; /* if (errno == EACCES || errno == EINVAL || errno == ELOOP || errno == ENAMETOOLONG || errno == ENOENT || errno == ENOTDIR || errno == ENOEXEC || errno == ETXTBSY) { PyErr_SetFromErrnoWithFilenameObject(PyExc_OSError, PySequence_ITEM(args, 0)); } else {*/ PyErr_SetFromErrno(PyExc_OSError); //} goto spawn_failed; } } else { PyObject *type, *value, *traceback, *e; if (!r) errno = 0; PyErr_SetFromErrno(PyExc_IOError); spawn_failed: Py_DECREF(testcase); close(c2ppipe[0]); TERM_TESTEE; PyErr_Fetch(&type, &value, &traceback); PyErr_NormalizeException(&type, &value, &traceback); Py_XDECREF(traceback); Py_DECREF(type); e = PyObject_CallFunctionObjArgs(CannotStartTestee, value, NULL); Py_DECREF(value); PyErr_SetObject(CannotStartTestee, e); Py_DECREF(e); return NULL; } Py_BEGIN_ALLOW_THREADS timeradd(&time_start, &maxwalltime, &time_end); FD_ZERO(&readfds); have_maxwalltime = timerisset(&maxwalltime); /* Implementations may place limitations on the maximum timeout interval supported. All implementations shall support a maximum timeout interval of at least 31 days. If the timeout argument specifies a timeout interval greater than the implementation- defined maximum value, the maximum value shall be used as the actual timeout value. (POSIX:2008) Therefore the loop and the && timercmp(&time_end, &now, <). */ for (;;) { _PyTime_timeval now; int maxfd = c2ppipe[0]; #ifdef HAVE_TERMIOS_H if (catch_escape) FD_SET(0, &readfds); #endif #ifdef USE_WAKEUP_FD FD_SET(intpipe[0], &readfds); if (intpipe[0] > maxfd) maxfd = intpipe[0]; #endif FD_SET(c2ppipe[0], &readfds); if (have_maxwalltime) { _PyTime_gettimeofday(&now); if (timercmp(&time_end, &now, <)) { timerclear(&timeout); } else { timersub(&time_end, &now, &timeout); } s = select(maxfd + 1, &readfds, NULL, NULL, &timeout); if (!s && timercmp(&time_end, &now, <)) { close(c2ppipe[0]); TERM_TESTEE; Py_BLOCK_THREADS Py_DECREF(testcase); PyErr_SetObject(WallTimeLimitExceeded, NULL); return NULL; } } else { s = select(maxfd + 1, &readfds, NULL, NULL, NULL); } if (s < 0 && errno == EINTR) { Py_BLOCK_THREADS if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } Py_UNBLOCK_THREADS } else if (s < 0 && errno != EAGAIN) { Py_BLOCK_THREADS PyErr_SetFromErrno(PyExc_IOError); close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } #ifdef USE_WAKEUP_FD else if (s > 0 && FD_ISSET(intpipe[0], &readfds)) { // FIXME: is error handling needed? while (read(intpipe[0], dont_care_buffer, sizeof dont_care_buffer) > 0); Py_BLOCK_THREADS if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } Py_UNBLOCK_THREADS } #endif #ifdef HAVE_TERMIOS_H else if (s > 0 && !FD_ISSET(c2ppipe[0], &readfds)) { // FIXME: is error and EOF handling needed? if ((r = read(0, &c, 1)) == 1) { if (c == '\33') { close(c2ppipe[0]); TERM_TESTEE; Py_BLOCK_THREADS Py_DECREF(testcase); PyErr_SetObject(CanceledByUser, NULL); return NULL; } } else if (r == -1 && errno == EINTR) { if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } } } #endif else if (s > 0) { bool blocked_threads = false; while ((r = read(c2ppipe[0], stats_read + (char *) &stats, sizeof stats - stats_read)) == -1 && errno == EINTR) { Py_BLOCK_THREADS blocked_threads = true; if (PyErr_CheckSignals() == -1) { PROPAGATE_SIGINT; close(c2ppipe[0]); Py_DECREF(testcase); TERM_TESTEE; return NULL; } } if (r > 0) { stats_read += r; } else if (!r) { break; } else { close(c2ppipe[0]); TERM_TESTEE; if (!blocked_threads) { Py_BLOCK_THREADS } Py_DECREF(testcase); PyErr_SetFromErrno(PyExc_IOError); return NULL; } if (blocked_threads) { Py_UNBLOCK_THREADS } } } close(c2ppipe[0]); Py_END_ALLOW_THREADS #ifdef HAVE_WAITPID while (waitpid(curpid, &retstat, 0) != curpid) #else while (wait(&retstat) != curpid) #endif { if (PyErr_CheckSignals() == -1) { Py_DECREF(testcase); return NULL; } } if (WIFEXITED(retstat) && WEXITSTATUS(retstat) == 127) { PyObject *type, *value, *traceback, *e; Py_DECREF(testcase); errno = 0; PyErr_SetFromErrno(PyExc_OSError); PyErr_Fetch(&type, &value, &traceback); PyErr_NormalizeException(&type, &value, &traceback); Py_XDECREF(traceback); Py_DECREF(type); e = PyObject_CallFunctionObjArgs(CannotStartTestee, value, NULL); Py_DECREF(value); PyErr_SetObject(CannotStartTestee, e); Py_DECREF(e); return NULL; } else if (!WIFEXITED(retstat) || WEXITSTATUS(retstat)) { Py_DECREF(testcase); if (WIFSTOPPED(retstat)) { return PyErr_Format(PyExc_EnvironmentError, "unexpected exit status from worker: stopped by signal %d", WSTOPSIG(retstat)); } else if (WIFSIGNALED(retstat)) { return PyErr_Format(PyExc_EnvironmentError, "unexpected exit status from worker: terminated by signal %d", WTERMSIG(retstat)); } else if (WIFEXITED(retstat)) { return PyErr_Format(PyExc_EnvironmentError, "unexpected exit status from worker: %d", WEXITSTATUS(retstat)); } else { PyErr_SetString(PyExc_EnvironmentError, "unexpected exit status from worker: not exited, signaled or stopped"); return NULL; } } if (stats_read != sizeof stats) { Py_DECREF(testcase); PyErr_SetString(PyExc_EnvironmentError, "unexpectedly early end of output from worker"); return NULL; } if (timerisset(&maxwalltime) && timercmp(&stats.walltime, &maxwalltime, >)) { Py_DECREF(testcase); PyErr_SetObject(WallTimeLimitExceeded, NULL); return NULL; } obj = PyInt_FromLong(0); if (obj == NULL) { Py_DECREF(testcase); return NULL; } if (PyObject_SetAttrString(testcase, "time_started", obj) == -1) { Py_DECREF(testcase); return NULL; } Py_DECREF(obj); #if defined HAVE_SYS_RESOURCE_H || defined HAVE_WAIT4 || defined HAVE_WAIT3 if (timerisset(&maxcputime) || !timerisset(&maxwalltime)) { PyObject *cputls; if (!timeval_to_attr(&stats.cputime, testcase, "time_stopped")) { Py_DECREF(testcase); return NULL; } cputls = PyObject_GetAttrString(testcase, "cpu_time_limit_string"); if (cputls == NULL) { Py_DECREF(testcase); return NULL; } if (PyObject_SetAttrString(testcase, "time_limit_string", cputls) == -1) { Py_DECREF(testcase); return NULL; } Py_DECREF(cputls); if (timerisset(&maxcputime) && timercmp(&stats.cputime, &maxcputime, >)) { Py_DECREF(testcase); PyErr_SetObject(CPUTimeLimitExceeded, NULL); return NULL; } } else #endif { if (!timeval_to_attr(&stats.walltime, testcase, "time_stopped")) { Py_DECREF(testcase); return NULL; } } #if defined HAVE_SYS_RESOURCE_H || defined HAVE_WAIT4 || defined HAVE_WAIT3 if (maxmemory && stats.memory > maxmemory) { Py_DECREF(testcase); PyErr_SetObject(MemoryLimitExceeded, NULL); return NULL; } #endif Popen_placeholder = PyObject_New(_unix__PopenPlaceholderObject, &_unix__PopenPlaceholderType); if (Popen_placeholder == NULL) { return NULL; } Popen_placeholder->returncode = stats.returncode; PyObject_SetAttrString(testcase, "process", (PyObject *) Popen_placeholder); Py_DECREF(Popen_placeholder); Py_DECREF(testcase); Py_RETURN_NONE; } static PyObject *_unix_pause(PyObject *self) { #ifdef HAVE_TERMIOS_H if (catch_escape) { char c; while (read(0, &c, 1) == -1 && errno == EINTR); } #endif Py_RETURN_NONE; } static PyMethodDef _unixMethods[] = { { "call", (PyCFunction) _unix_call, METH_VARARGS | METH_KEYWORDS, "Call a process." }, { "pause", (PyCFunction) _unix_pause, METH_NOARGS, "Block until a key is pressed." }, { NULL } }; #ifdef USE_WAKEUP_FD static void close_intpipe(void) { close(intpipe[0]); close(intpipe[1]); intpipe[0] = intpipe[1] = 0; } #endif #ifdef HAVE_TERMIOS_H static void restore_termios(void) { tcsetattr(0, TCSAFLUSH, &orig_termios); #ifdef USE_WAKEUP_FD close_intpipe(); #endif } #endif #if PY_MAJOR_VERSION >= 3 #define INIT_FAIL return NULL static PyModuleDef _unixmodule = { PyModuleDef_HEAD_INIT, "_unix", NULL, -1, _unixMethods }; PyMODINIT_FUNC PyInit__unix(void) #else #define INIT_FAIL return PyMODINIT_FUNC init_unix(void) #endif { struct termios new_termios; PyObject *testcases; _unix__PopenPlaceholderType.tp_new = PyType_GenericNew; if (PyType_Ready(&_unix__PopenPlaceholderType) == -1) { INIT_FAIL; } testcases = PyImport_ImportModule("testcases"); if (testcases == NULL) { INIT_FAIL; } if ((CannotStartTestee = PyObject_GetAttrString(testcases, "CannotStartTestee")) == NULL || (CanceledByUser = PyObject_GetAttrString(testcases, "CanceledByUser")) == NULL || (WallTimeLimitExceeded = PyObject_GetAttrString(testcases, "WallTimeLimitExceeded")) == NULL || (CPUTimeLimitExceeded = PyObject_GetAttrString(testcases, "CPUTimeLimitExceeded")) == NULL || (MemoryLimitExceeded = PyObject_GetAttrString(testcases, "MemoryLimitExceeded")) == NULL) { Py_XDECREF(MemoryLimitExceeded); Py_XDECREF(CPUTimeLimitExceeded); Py_XDECREF(WallTimeLimitExceeded); Py_XDECREF(CanceledByUser); Py_XDECREF(CannotStartTestee); Py_DECREF(testcases); INIT_FAIL; } Py_DECREF(testcases); #ifdef WITH_NEXT_FRAMEWORK if (environ == NULL) { environ = *_NSGetEnviron(); } #endif #ifdef USE_WAKEUP_FD if (!intpipe[0] || !intpipe[1]) { #ifdef HAVE_PIPE2 if (pipe2(intpipe, O_CLOEXEC | O_NONBLOCK)) { PyErr_SetFromErrno(PyExc_IOError); Py_DECREF(MemoryLimitExceeded); Py_DECREF(CPUTimeLimitExceeded); Py_DECREF(WallTimeLimitExceeded); Py_DECREF(CanceledByUser); Py_DECREF(CannotStartTestee); INIT_FAIL; } #else if (pipe(intpipe)) { PyErr_SetFromErrno(PyExc_IOError); Py_DECREF(MemoryLimitExceeded); Py_DECREF(CPUTimeLimitExceeded); Py_DECREF(WallTimeLimitExceeded); Py_DECREF(CanceledByUser); Py_DECREF(CannotStartTestee); INIT_FAIL; } // Other threads must not fork now if (fcntl(intpipe[0], F_SETFD, fcntl(intpipe[0], F_GETFD) | FD_CLOEXEC) == -1 || fcntl(intpipe[1], F_SETFD, fcntl(intpipe[1], F_GETFD) | FD_CLOEXEC) == -1 || fcntl(intpipe[0], F_SETFL, fcntl(intpipe[0], F_GETFL) | O_NONBLOCK) == -1 || fcntl(intpipe[1], F_SETFL, fcntl(intpipe[1], F_GETFL) | O_NONBLOCK) == -1) { PyErr_SetFromErrno(PyExc_IOError); close(intpipe[0]); close(intpipe[1]); Py_DECREF(MemoryLimitExceeded); Py_DECREF(CPUTimeLimitExceeded); Py_DECREF(WallTimeLimitExceeded); Py_DECREF(CanceledByUser); Py_DECREF(CannotStartTestee); INIT_FAIL; } #endif } PySignal_SetWakeupFd(intpipe[1]); #endif #ifdef HAVE_TERMIOS_H if (!tcgetattr(0, &orig_termios)) { new_termios = orig_termios; // Stolen from tty.py of Python 2.7.1 new_termios.c_lflag &= ~(ECHO | ICANON); new_termios.c_cc[VMIN] = 1; new_termios.c_cc[VTIME] = 0; if (!Py_AtExit(restore_termios) && !tcsetattr(0, TCSAFLUSH, &new_termios)) { catch_escape = true; } } #ifdef USE_WAKEUP_FD else { Py_AtExit(close_intpipe); } #endif #elif defined USE_WAKEUP_FD Py_AtExit(close_intpipe); #endif #if PY_MAJOR_VERSION >= 3 PyObject *module = PyModule_Create(&_unixmodule); if (module == NULL) { Py_DECREF(MemoryLimitExceeded); Py_DECREF(CPUTimeLimitExceeded); Py_DECREF(WallTimeLimitExceeded); Py_DECREF(CanceledByUser); Py_DECREF(CannotStartTestee); } return module; #else Py_InitModule("_unix", _unixMethods); #endif }