+++ /dev/null
-/** @file\r
- OS-specific module implementation for EDK II and UEFI.\r
- Derived from posixmodule.c in Python 2.7.2.\r
-\r
- Copyright (c) 2015, Daryl McDaniel. All rights reserved.<BR>\r
- Copyright (c) 2011 - 2012, Intel Corporation. All rights reserved.<BR>\r
- This program and the accompanying materials are licensed and made available under\r
- the terms and conditions of the BSD License that accompanies this distribution.\r
- The full text of the license may be found at\r
- http://opensource.org/licenses/bsd-license.\r
-\r
- THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
-**/\r
-#define PY_SSIZE_T_CLEAN\r
-\r
-#include "Python.h"\r
-#include "structseq.h"\r
-\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include <wchar.h>\r
-#include <sys/syslimits.h>\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-PyDoc_STRVAR(edk2__doc__,\r
- "This module provides access to UEFI firmware functionality that is\n\\r
- standardized by the C Standard and the POSIX standard (a thinly\n\\r
- disguised Unix interface). Refer to the library manual and\n\\r
- corresponding UEFI Specification entries for more information on calls.");\r
-\r
-#ifndef Py_USING_UNICODE\r
- /* This is used in signatures of functions. */\r
- #define Py_UNICODE void\r
-#endif\r
-\r
-#ifdef HAVE_SYS_TYPES_H\r
- #include <sys/types.h>\r
-#endif /* HAVE_SYS_TYPES_H */\r
-\r
-#ifdef HAVE_SYS_STAT_H\r
- #include <sys/stat.h>\r
-#endif /* HAVE_SYS_STAT_H */\r
-\r
-#ifdef HAVE_SYS_WAIT_H\r
- #include <sys/wait.h> /* For WNOHANG */\r
-#endif\r
-\r
-#ifdef HAVE_SIGNAL_H\r
- #include <signal.h>\r
-#endif\r
-\r
-#ifdef HAVE_FCNTL_H\r
- #include <fcntl.h>\r
-#endif /* HAVE_FCNTL_H */\r
-\r
-#ifdef HAVE_GRP_H\r
- #include <grp.h>\r
-#endif\r
-\r
-#ifdef HAVE_SYSEXITS_H\r
- #include <sysexits.h>\r
-#endif /* HAVE_SYSEXITS_H */\r
-\r
-#ifdef HAVE_SYS_LOADAVG_H\r
- #include <sys/loadavg.h>\r
-#endif\r
-\r
-#ifdef HAVE_UTIME_H\r
- #include <utime.h>\r
-#endif /* HAVE_UTIME_H */\r
-\r
-#ifdef HAVE_SYS_UTIME_H\r
- #include <sys/utime.h>\r
- #define HAVE_UTIME_H /* pretend we do for the rest of this file */\r
-#endif /* HAVE_SYS_UTIME_H */\r
-\r
-#ifdef HAVE_SYS_TIMES_H\r
- #include <sys/times.h>\r
-#endif /* HAVE_SYS_TIMES_H */\r
-\r
-#ifdef HAVE_SYS_PARAM_H\r
- #include <sys/param.h>\r
-#endif /* HAVE_SYS_PARAM_H */\r
-\r
-#ifdef HAVE_SYS_UTSNAME_H\r
- #include <sys/utsname.h>\r
-#endif /* HAVE_SYS_UTSNAME_H */\r
-\r
-#ifdef HAVE_DIRENT_H\r
- #include <dirent.h>\r
- #define NAMLEN(dirent) wcslen((dirent)->FileName)\r
-#else\r
- #define dirent direct\r
- #define NAMLEN(dirent) (dirent)->d_namlen\r
- #ifdef HAVE_SYS_NDIR_H\r
- #include <sys/ndir.h>\r
- #endif\r
- #ifdef HAVE_SYS_DIR_H\r
- #include <sys/dir.h>\r
- #endif\r
- #ifdef HAVE_NDIR_H\r
- #include <ndir.h>\r
- #endif\r
-#endif\r
-\r
-#ifndef MAXPATHLEN\r
- #if defined(PATH_MAX) && PATH_MAX > 1024\r
- #define MAXPATHLEN PATH_MAX\r
- #else\r
- #define MAXPATHLEN 1024\r
- #endif\r
-#endif /* MAXPATHLEN */\r
-\r
-#define WAIT_TYPE int\r
-#define WAIT_STATUS_INT(s) (s)\r
-\r
-/* Issue #1983: pid_t can be longer than a C long on some systems */\r
-#if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT\r
- #define PARSE_PID "i"\r
- #define PyLong_FromPid PyInt_FromLong\r
- #define PyLong_AsPid PyInt_AsLong\r
-#elif SIZEOF_PID_T == SIZEOF_LONG\r
- #define PARSE_PID "l"\r
- #define PyLong_FromPid PyInt_FromLong\r
- #define PyLong_AsPid PyInt_AsLong\r
-#elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG\r
- #define PARSE_PID "L"\r
- #define PyLong_FromPid PyLong_FromLongLong\r
- #define PyLong_AsPid PyInt_AsLongLong\r
-#else\r
- #error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)"\r
-#endif /* SIZEOF_PID_T */\r
-\r
-/* Don't use the "_r" form if we don't need it (also, won't have a\r
- prototype for it, at least on Solaris -- maybe others as well?). */\r
-#if defined(HAVE_CTERMID_R) && defined(WITH_THREAD)\r
- #define USE_CTERMID_R\r
-#endif\r
-\r
-#if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD)\r
- #define USE_TMPNAM_R\r
-#endif\r
-\r
-/* choose the appropriate stat and fstat functions and return structs */\r
-#undef STAT\r
-#undef FSTAT\r
-#undef STRUCT_STAT\r
-#define STAT stat\r
-#define FSTAT fstat\r
-#define STRUCT_STAT struct stat\r
-\r
-/* dummy version. _PyVerify_fd() is already defined in fileobject.h */\r
-#define _PyVerify_fd_dup2(A, B) (1)\r
-\r
-#ifndef UEFI_C_SOURCE\r
-/* Return a dictionary corresponding to the POSIX environment table */\r
-extern char **environ;\r
-\r
-static PyObject *\r
-convertenviron(void)\r
-{\r
- PyObject *d;\r
- char **e;\r
- d = PyDict_New();\r
- if (d == NULL)\r
- return NULL;\r
- if (environ == NULL)\r
- return d;\r
- /* This part ignores errors */\r
- for (e = environ; *e != NULL; e++) {\r
- PyObject *k;\r
- PyObject *v;\r
- char *p = strchr(*e, '=');\r
- if (p == NULL)\r
- continue;\r
- k = PyString_FromStringAndSize(*e, (int)(p-*e));\r
- if (k == NULL) {\r
- PyErr_Clear();\r
- continue;\r
- }\r
- v = PyString_FromString(p+1);\r
- if (v == NULL) {\r
- PyErr_Clear();\r
- Py_DECREF(k);\r
- continue;\r
- }\r
- if (PyDict_GetItem(d, k) == NULL) {\r
- if (PyDict_SetItem(d, k, v) != 0)\r
- PyErr_Clear();\r
- }\r
- Py_DECREF(k);\r
- Py_DECREF(v);\r
- }\r
- return d;\r
-}\r
-#endif /* UEFI_C_SOURCE */\r
-\r
-/* Set a POSIX-specific error from errno, and return NULL */\r
-\r
-static PyObject *\r
-edk2_error(void)\r
-{\r
- return PyErr_SetFromErrno(PyExc_OSError);\r
-}\r
-static PyObject *\r
-edk2_error_with_filename(char* name)\r
-{\r
- return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);\r
-}\r
-\r
-\r
-static PyObject *\r
-edk2_error_with_allocated_filename(char* name)\r
-{\r
- PyObject *rc = PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);\r
- PyMem_Free(name);\r
- return rc;\r
-}\r
-\r
-/* POSIX generic methods */\r
-\r
-#ifndef UEFI_C_SOURCE\r
- static PyObject *\r
- edk2_fildes(PyObject *fdobj, int (*func)(int))\r
- {\r
- int fd;\r
- int res;\r
- fd = PyObject_AsFileDescriptor(fdobj);\r
- if (fd < 0)\r
- return NULL;\r
- if (!_PyVerify_fd(fd))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = (*func)(fd);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-#endif /* UEFI_C_SOURCE */\r
-\r
-static PyObject *\r
-edk2_1str(PyObject *args, char *format, int (*func)(const char*))\r
-{\r
- char *path1 = NULL;\r
- int res;\r
- if (!PyArg_ParseTuple(args, format,\r
- Py_FileSystemDefaultEncoding, &path1))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = (*func)(path1);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path1);\r
- PyMem_Free(path1);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-static PyObject *\r
-edk2_2str(PyObject *args,\r
- char *format,\r
- int (*func)(const char *, const char *))\r
-{\r
- char *path1 = NULL, *path2 = NULL;\r
- int res;\r
- if (!PyArg_ParseTuple(args, format,\r
- Py_FileSystemDefaultEncoding, &path1,\r
- Py_FileSystemDefaultEncoding, &path2))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = (*func)(path1, path2);\r
- Py_END_ALLOW_THREADS\r
- PyMem_Free(path1);\r
- PyMem_Free(path2);\r
- if (res != 0)\r
- /* XXX how to report both path1 and path2??? */\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-PyDoc_STRVAR(stat_result__doc__,\r
-"stat_result: Result from stat or lstat.\n\n\\r
-This object may be accessed either as a tuple of\n\\r
- (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n\\r
-or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\\r
-\n\\r
-Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n\\r
-or st_flags, they are available as attributes only.\n\\r
-\n\\r
-See os.stat for more information.");\r
-\r
-static PyStructSequence_Field stat_result_fields[] = {\r
- {"st_mode", "protection bits"},\r
- //{"st_ino", "inode"},\r
- //{"st_dev", "device"},\r
- //{"st_nlink", "number of hard links"},\r
- //{"st_uid", "user ID of owner"},\r
- //{"st_gid", "group ID of owner"},\r
- {"st_size", "total size, in bytes"},\r
- /* The NULL is replaced with PyStructSequence_UnnamedField later. */\r
- {NULL, "integer time of last access"},\r
- {NULL, "integer time of last modification"},\r
- {NULL, "integer time of last change"},\r
- {"st_atime", "time of last access"},\r
- {"st_mtime", "time of last modification"},\r
- {"st_ctime", "time of last change"},\r
-#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE\r
- {"st_blksize", "blocksize for filesystem I/O"},\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_BLOCKS\r
- {"st_blocks", "number of blocks allocated"},\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_RDEV\r
- {"st_rdev", "device type (if inode device)"},\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_FLAGS\r
- {"st_flags", "user defined flags for file"},\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_GEN\r
- {"st_gen", "generation number"},\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME\r
- {"st_birthtime", "time of creation"},\r
-#endif\r
- {0}\r
-};\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE\r
-#define ST_BLKSIZE_IDX 8\r
-#else\r
-#define ST_BLKSIZE_IDX 12\r
-#endif\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_BLOCKS\r
-#define ST_BLOCKS_IDX (ST_BLKSIZE_IDX+1)\r
-#else\r
-#define ST_BLOCKS_IDX ST_BLKSIZE_IDX\r
-#endif\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_RDEV\r
-#define ST_RDEV_IDX (ST_BLOCKS_IDX+1)\r
-#else\r
-#define ST_RDEV_IDX ST_BLOCKS_IDX\r
-#endif\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_FLAGS\r
-#define ST_FLAGS_IDX (ST_RDEV_IDX+1)\r
-#else\r
-#define ST_FLAGS_IDX ST_RDEV_IDX\r
-#endif\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_GEN\r
-#define ST_GEN_IDX (ST_FLAGS_IDX+1)\r
-#else\r
-#define ST_GEN_IDX ST_FLAGS_IDX\r
-#endif\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME\r
-#define ST_BIRTHTIME_IDX (ST_GEN_IDX+1)\r
-#else\r
-#define ST_BIRTHTIME_IDX ST_GEN_IDX\r
-#endif\r
-\r
-static PyStructSequence_Desc stat_result_desc = {\r
- "stat_result", /* name */\r
- stat_result__doc__, /* doc */\r
- stat_result_fields,\r
- 10\r
-};\r
-\r
-#ifndef UEFI_C_SOURCE /* Not in UEFI */\r
-PyDoc_STRVAR(statvfs_result__doc__,\r
-"statvfs_result: Result from statvfs or fstatvfs.\n\n\\r
-This object may be accessed either as a tuple of\n\\r
- (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n\\r
-or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\\r
-\n\\r
-See os.statvfs for more information.");\r
-\r
-static PyStructSequence_Field statvfs_result_fields[] = {\r
- {"f_bsize", },\r
- {"f_frsize", },\r
- {"f_blocks", },\r
- {"f_bfree", },\r
- {"f_bavail", },\r
- {"f_files", },\r
- {"f_ffree", },\r
- {"f_favail", },\r
- {"f_flag", },\r
- {"f_namemax",},\r
- {0}\r
-};\r
-\r
-static PyStructSequence_Desc statvfs_result_desc = {\r
- "statvfs_result", /* name */\r
- statvfs_result__doc__, /* doc */\r
- statvfs_result_fields,\r
- 10\r
-};\r
-\r
-static PyTypeObject StatVFSResultType;\r
-#endif\r
-\r
-static int initialized;\r
-static PyTypeObject StatResultType;\r
-static newfunc structseq_new;\r
-\r
-static PyObject *\r
-statresult_new(PyTypeObject *type, PyObject *args, PyObject *kwds)\r
-{\r
- PyStructSequence *result;\r
- int i;\r
-\r
- result = (PyStructSequence*)structseq_new(type, args, kwds);\r
- if (!result)\r
- return NULL;\r
- /* If we have been initialized from a tuple,\r
- st_?time might be set to None. Initialize it\r
- from the int slots. */\r
- for (i = 7; i <= 9; i++) {\r
- if (result->ob_item[i+3] == Py_None) {\r
- Py_DECREF(Py_None);\r
- Py_INCREF(result->ob_item[i]);\r
- result->ob_item[i+3] = result->ob_item[i];\r
- }\r
- }\r
- return (PyObject*)result;\r
-}\r
-\r
-\r
-\r
-/* If true, st_?time is float. */\r
-#if defined(UEFI_C_SOURCE)\r
- static int _stat_float_times = 0;\r
-#else\r
- static int _stat_float_times = 1;\r
-\r
-PyDoc_STRVAR(stat_float_times__doc__,\r
-"stat_float_times([newval]) -> oldval\n\n\\r
-Determine whether os.[lf]stat represents time stamps as float objects.\n\\r
-If newval is True, future calls to stat() return floats, if it is False,\n\\r
-future calls return ints. \n\\r
-If newval is omitted, return the current setting.\n");\r
-\r
-static PyObject*\r
-stat_float_times(PyObject* self, PyObject *args)\r
-{\r
- int newval = -1;\r
-\r
- if (!PyArg_ParseTuple(args, "|i:stat_float_times", &newval))\r
- return NULL;\r
- if (newval == -1)\r
- /* Return old value */\r
- return PyBool_FromLong(_stat_float_times);\r
- _stat_float_times = newval;\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* UEFI_C_SOURCE */\r
-\r
-static void\r
-fill_time(PyObject *v, int index, time_t sec, unsigned long nsec)\r
-{\r
- PyObject *fval,*ival;\r
-#if SIZEOF_TIME_T > SIZEOF_LONG\r
- ival = PyLong_FromLongLong((PY_LONG_LONG)sec);\r
-#else\r
- ival = PyInt_FromLong((long)sec);\r
-#endif\r
- if (!ival)\r
- return;\r
- if (_stat_float_times) {\r
- fval = PyFloat_FromDouble(sec + 1e-9*nsec);\r
- } else {\r
- fval = ival;\r
- Py_INCREF(fval);\r
- }\r
- PyStructSequence_SET_ITEM(v, index, ival);\r
- PyStructSequence_SET_ITEM(v, index+3, fval);\r
-}\r
-\r
-/* pack a system stat C structure into the Python stat tuple\r
- (used by edk2_stat() and edk2_fstat()) */\r
-static PyObject*\r
-_pystat_fromstructstat(STRUCT_STAT *st)\r
-{\r
- unsigned long ansec, mnsec, cnsec;\r
- PyObject *v = PyStructSequence_New(&StatResultType);\r
- if (v == NULL)\r
- return NULL;\r
-\r
- PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long)st->st_mode));\r
- PyStructSequence_SET_ITEM(v, 1,\r
- PyLong_FromLongLong((PY_LONG_LONG)st->st_size));\r
-\r
- ansec = mnsec = cnsec = 0;\r
- /* The index used by fill_time is the index of the integer time.\r
- fill_time will add 3 to the index to get the floating time index.\r
- */\r
- fill_time(v, 2, st->st_atime, ansec);\r
- fill_time(v, 3, st->st_mtime, mnsec);\r
- fill_time(v, 4, st->st_mtime, cnsec);\r
-\r
-#ifdef HAVE_STRUCT_STAT_ST_BLKSIZE\r
- PyStructSequence_SET_ITEM(v, ST_BLKSIZE_IDX,\r
- PyInt_FromLong((long)st->st_blksize));\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_BLOCKS\r
- PyStructSequence_SET_ITEM(v, ST_BLOCKS_IDX,\r
- PyInt_FromLong((long)st->st_blocks));\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_RDEV\r
- PyStructSequence_SET_ITEM(v, ST_RDEV_IDX,\r
- PyInt_FromLong((long)st->st_rdev));\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_GEN\r
- PyStructSequence_SET_ITEM(v, ST_GEN_IDX,\r
- PyInt_FromLong((long)st->st_gen));\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME\r
- {\r
- PyObject *val;\r
- unsigned long bsec,bnsec;\r
- bsec = (long)st->st_birthtime;\r
-#ifdef HAVE_STAT_TV_NSEC2\r
- bnsec = st->st_birthtimespec.tv_nsec;\r
-#else\r
- bnsec = 0;\r
-#endif\r
- if (_stat_float_times) {\r
- val = PyFloat_FromDouble(bsec + 1e-9*bnsec);\r
- } else {\r
- val = PyInt_FromLong((long)bsec);\r
- }\r
- PyStructSequence_SET_ITEM(v, ST_BIRTHTIME_IDX,\r
- val);\r
- }\r
-#endif\r
-#ifdef HAVE_STRUCT_STAT_ST_FLAGS\r
- PyStructSequence_SET_ITEM(v, ST_FLAGS_IDX,\r
- PyInt_FromLong((long)st->st_flags));\r
-#endif\r
-\r
- if (PyErr_Occurred()) {\r
- Py_DECREF(v);\r
- return NULL;\r
- }\r
-\r
- return v;\r
-}\r
-\r
-static PyObject *\r
-edk2_do_stat(PyObject *self, PyObject *args,\r
- char *format,\r
- int (*statfunc)(const char *, STRUCT_STAT *),\r
- char *wformat,\r
- int (*wstatfunc)(const Py_UNICODE *, STRUCT_STAT *))\r
-{\r
- STRUCT_STAT st;\r
- char *path = NULL; /* pass this to stat; do not free() it */\r
- char *pathfree = NULL; /* this memory must be free'd */\r
- int res;\r
- PyObject *result;\r
-\r
- if (!PyArg_ParseTuple(args, format,\r
- Py_FileSystemDefaultEncoding, &path))\r
- return NULL;\r
- pathfree = path;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = (*statfunc)(path, &st);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (res != 0) {\r
- result = edk2_error_with_filename(pathfree);\r
- }\r
- else\r
- result = _pystat_fromstructstat(&st);\r
-\r
- PyMem_Free(pathfree);\r
- return result;\r
-}\r
-\r
-/* POSIX methods */\r
-\r
-PyDoc_STRVAR(edk2_access__doc__,\r
-"access(path, mode) -> True if granted, False otherwise\n\n\\r
-Use the real uid/gid to test for access to a path. Note that most\n\\r
-operations will use the effective uid/gid, therefore this routine can\n\\r
-be used in a suid/sgid environment to test if the invoking user has the\n\\r
-specified access to the path. The mode argument can be F_OK to test\n\\r
-existence, or the inclusive-OR of R_OK, W_OK, and X_OK.");\r
-\r
-static PyObject *\r
-edk2_access(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- int mode;\r
-\r
- int res;\r
- if (!PyArg_ParseTuple(args, "eti:access",\r
- Py_FileSystemDefaultEncoding, &path, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = access(path, mode);\r
- Py_END_ALLOW_THREADS\r
- PyMem_Free(path);\r
- return PyBool_FromLong(res == 0);\r
-}\r
-\r
-#ifndef F_OK\r
- #define F_OK 0\r
-#endif\r
-#ifndef R_OK\r
- #define R_OK 4\r
-#endif\r
-#ifndef W_OK\r
- #define W_OK 2\r
-#endif\r
-#ifndef X_OK\r
- #define X_OK 1\r
-#endif\r
-\r
-PyDoc_STRVAR(edk2_chdir__doc__,\r
-"chdir(path)\n\n\\r
-Change the current working directory to the specified path.");\r
-\r
-static PyObject *\r
-edk2_chdir(PyObject *self, PyObject *args)\r
-{\r
- return edk2_1str(args, "et:chdir", chdir);\r
-}\r
-\r
-PyDoc_STRVAR(edk2_chmod__doc__,\r
-"chmod(path, mode)\n\n\\r
-Change the access permissions of a file.");\r
-\r
-static PyObject *\r
-edk2_chmod(PyObject *self, PyObject *args)\r
-{\r
- char *path = NULL;\r
- int i;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "eti:chmod", Py_FileSystemDefaultEncoding,\r
- &path, &i))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = chmod(path, i);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-#ifdef HAVE_FCHMOD\r
-PyDoc_STRVAR(edk2_fchmod__doc__,\r
-"fchmod(fd, mode)\n\n\\r
-Change the access permissions of the file given by file\n\\r
-descriptor fd.");\r
-\r
-static PyObject *\r
-edk2_fchmod(PyObject *self, PyObject *args)\r
-{\r
- int fd, mode, res;\r
- if (!PyArg_ParseTuple(args, "ii:fchmod", &fd, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = fchmod(fd, mode);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_RETURN_NONE;\r
-}\r
-#endif /* HAVE_FCHMOD */\r
-\r
-#ifdef HAVE_LCHMOD\r
-PyDoc_STRVAR(edk2_lchmod__doc__,\r
-"lchmod(path, mode)\n\n\\r
-Change the access permissions of a file. If path is a symlink, this\n\\r
-affects the link itself rather than the target.");\r
-\r
-static PyObject *\r
-edk2_lchmod(PyObject *self, PyObject *args)\r
-{\r
- char *path = NULL;\r
- int i;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "eti:lchmod", Py_FileSystemDefaultEncoding,\r
- &path, &i))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = lchmod(path, i);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_RETURN_NONE;\r
-}\r
-#endif /* HAVE_LCHMOD */\r
-\r
-\r
-#ifdef HAVE_CHFLAGS\r
-PyDoc_STRVAR(edk2_chflags__doc__,\r
-"chflags(path, flags)\n\n\\r
-Set file flags.");\r
-\r
-static PyObject *\r
-edk2_chflags(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- unsigned long flags;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "etk:chflags",\r
- Py_FileSystemDefaultEncoding, &path, &flags))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = chflags(path, flags);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_CHFLAGS */\r
-\r
-#ifdef HAVE_LCHFLAGS\r
-PyDoc_STRVAR(edk2_lchflags__doc__,\r
-"lchflags(path, flags)\n\n\\r
-Set file flags.\n\\r
-This function will not follow symbolic links.");\r
-\r
-static PyObject *\r
-edk2_lchflags(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- unsigned long flags;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "etk:lchflags",\r
- Py_FileSystemDefaultEncoding, &path, &flags))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = lchflags(path, flags);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_LCHFLAGS */\r
-\r
-#ifdef HAVE_CHROOT\r
-PyDoc_STRVAR(edk2_chroot__doc__,\r
-"chroot(path)\n\n\\r
-Change root directory to path.");\r
-\r
-static PyObject *\r
-edk2_chroot(PyObject *self, PyObject *args)\r
-{\r
- return edk2_1str(args, "et:chroot", chroot);\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_FSYNC\r
-PyDoc_STRVAR(edk2_fsync__doc__,\r
-"fsync(fildes)\n\n\\r
-force write of file with filedescriptor to disk.");\r
-\r
-static PyObject *\r
-edk2_fsync(PyObject *self, PyObject *fdobj)\r
-{\r
- return edk2_fildes(fdobj, fsync);\r
-}\r
-#endif /* HAVE_FSYNC */\r
-\r
-#ifdef HAVE_FDATASYNC\r
-\r
-#ifdef __hpux\r
-extern int fdatasync(int); /* On HP-UX, in libc but not in unistd.h */\r
-#endif\r
-\r
-PyDoc_STRVAR(edk2_fdatasync__doc__,\r
-"fdatasync(fildes)\n\n\\r
-force write of file with filedescriptor to disk.\n\\r
- does not force update of metadata.");\r
-\r
-static PyObject *\r
-edk2_fdatasync(PyObject *self, PyObject *fdobj)\r
-{\r
- return edk2_fildes(fdobj, fdatasync);\r
-}\r
-#endif /* HAVE_FDATASYNC */\r
-\r
-\r
-#ifdef HAVE_CHOWN\r
-PyDoc_STRVAR(edk2_chown__doc__,\r
-"chown(path, uid, gid)\n\n\\r
-Change the owner and group id of path to the numeric uid and gid.");\r
-\r
-static PyObject *\r
-edk2_chown(PyObject *self, PyObject *args)\r
-{\r
- char *path = NULL;\r
- long uid, gid;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "etll:chown",\r
- Py_FileSystemDefaultEncoding, &path,\r
- &uid, &gid))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = chown(path, (uid_t) uid, (gid_t) gid);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_CHOWN */\r
-\r
-#ifdef HAVE_FCHOWN\r
-PyDoc_STRVAR(edk2_fchown__doc__,\r
-"fchown(fd, uid, gid)\n\n\\r
-Change the owner and group id of the file given by file descriptor\n\\r
-fd to the numeric uid and gid.");\r
-\r
-static PyObject *\r
-edk2_fchown(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- long uid, gid;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "ill:chown", &fd, &uid, &gid))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = fchown(fd, (uid_t) uid, (gid_t) gid);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_RETURN_NONE;\r
-}\r
-#endif /* HAVE_FCHOWN */\r
-\r
-#ifdef HAVE_LCHOWN\r
-PyDoc_STRVAR(edk2_lchown__doc__,\r
-"lchown(path, uid, gid)\n\n\\r
-Change the owner and group id of path to the numeric uid and gid.\n\\r
-This function will not follow symbolic links.");\r
-\r
-static PyObject *\r
-edk2_lchown(PyObject *self, PyObject *args)\r
-{\r
- char *path = NULL;\r
- long uid, gid;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "etll:lchown",\r
- Py_FileSystemDefaultEncoding, &path,\r
- &uid, &gid))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = lchown(path, (uid_t) uid, (gid_t) gid);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_LCHOWN */\r
-\r
-\r
-#ifdef HAVE_GETCWD\r
-PyDoc_STRVAR(edk2_getcwd__doc__,\r
-"getcwd() -> path\n\n\\r
-Return a string representing the current working directory.");\r
-\r
-static PyObject *\r
-edk2_getcwd(PyObject *self, PyObject *noargs)\r
-{\r
- int bufsize_incr = 1024;\r
- int bufsize = 0;\r
- char *tmpbuf = NULL;\r
- char *res = NULL;\r
- PyObject *dynamic_return;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- do {\r
- bufsize = bufsize + bufsize_incr;\r
- tmpbuf = malloc(bufsize);\r
- if (tmpbuf == NULL) {\r
- break;\r
- }\r
- res = getcwd(tmpbuf, bufsize);\r
- if (res == NULL) {\r
- free(tmpbuf);\r
- }\r
- } while ((res == NULL) && (errno == ERANGE));\r
- Py_END_ALLOW_THREADS\r
-\r
- if (res == NULL)\r
- return edk2_error();\r
-\r
- dynamic_return = PyString_FromString(tmpbuf);\r
- free(tmpbuf);\r
-\r
- return dynamic_return;\r
-}\r
-\r
-#ifdef Py_USING_UNICODE\r
-PyDoc_STRVAR(edk2_getcwdu__doc__,\r
-"getcwdu() -> path\n\n\\r
-Return a unicode string representing the current working directory.");\r
-\r
-static PyObject *\r
-edk2_getcwdu(PyObject *self, PyObject *noargs)\r
-{\r
- char buf[1026];\r
- char *res;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = getcwd(buf, sizeof buf);\r
- Py_END_ALLOW_THREADS\r
- if (res == NULL)\r
- return edk2_error();\r
- return PyUnicode_Decode(buf, strlen(buf), Py_FileSystemDefaultEncoding,"strict");\r
-}\r
-#endif /* Py_USING_UNICODE */\r
-#endif /* HAVE_GETCWD */\r
-\r
-\r
-PyDoc_STRVAR(edk2_listdir__doc__,\r
-"listdir(path) -> list_of_strings\n\n\\r
-Return a list containing the names of the entries in the directory.\n\\r
-\n\\r
- path: path of directory to list\n\\r
-\n\\r
-The list is in arbitrary order. It does not include the special\n\\r
-entries '.' and '..' even if they are present in the directory.");\r
-\r
-static PyObject *\r
-edk2_listdir(PyObject *self, PyObject *args)\r
-{\r
- /* XXX Should redo this putting the (now four) versions of opendir\r
- in separate files instead of having them all here... */\r
-\r
- char *name = NULL;\r
- char *MBname;\r
- PyObject *d, *v;\r
- DIR *dirp;\r
- struct dirent *ep;\r
- int arg_is_unicode = 1;\r
-\r
- errno = 0;\r
- if (!PyArg_ParseTuple(args, "U:listdir", &v)) {\r
- arg_is_unicode = 0;\r
- PyErr_Clear();\r
- }\r
- if (!PyArg_ParseTuple(args, "et:listdir", Py_FileSystemDefaultEncoding, &name))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- dirp = opendir(name);\r
- Py_END_ALLOW_THREADS\r
- if (dirp == NULL) {\r
- return edk2_error_with_allocated_filename(name);\r
- }\r
- if ((d = PyList_New(0)) == NULL) {\r
- Py_BEGIN_ALLOW_THREADS\r
- closedir(dirp);\r
- Py_END_ALLOW_THREADS\r
- PyMem_Free(name);\r
- return NULL;\r
- }\r
- if((MBname = malloc(NAME_MAX)) == NULL) {\r
- Py_BEGIN_ALLOW_THREADS\r
- closedir(dirp);\r
- Py_END_ALLOW_THREADS\r
- Py_DECREF(d);\r
- PyMem_Free(name);\r
- return NULL;\r
- }\r
- for (;;) {\r
- errno = 0;\r
- Py_BEGIN_ALLOW_THREADS\r
- ep = readdir(dirp);\r
- Py_END_ALLOW_THREADS\r
- if (ep == NULL) {\r
- if ((errno == 0) || (errno == EISDIR)) {\r
- break;\r
- } else {\r
- Py_BEGIN_ALLOW_THREADS\r
- closedir(dirp);\r
- Py_END_ALLOW_THREADS\r
- Py_DECREF(d);\r
- return edk2_error_with_allocated_filename(name);\r
- }\r
- }\r
- if (ep->FileName[0] == L'.' &&\r
- (NAMLEN(ep) == 1 ||\r
- (ep->FileName[1] == L'.' && NAMLEN(ep) == 2)))\r
- continue;\r
- if(wcstombs(MBname, ep->FileName, NAME_MAX) == -1) {\r
- free(MBname);\r
- Py_BEGIN_ALLOW_THREADS\r
- closedir(dirp);\r
- Py_END_ALLOW_THREADS\r
- Py_DECREF(d);\r
- PyMem_Free(name);\r
- return NULL;\r
- }\r
- v = PyString_FromStringAndSize(MBname, strlen(MBname));\r
- if (v == NULL) {\r
- Py_DECREF(d);\r
- d = NULL;\r
- break;\r
- }\r
-#ifdef Py_USING_UNICODE\r
- if (arg_is_unicode) {\r
- PyObject *w;\r
-\r
- w = PyUnicode_FromEncodedObject(v,\r
- Py_FileSystemDefaultEncoding,\r
- "strict");\r
- if (w != NULL) {\r
- Py_DECREF(v);\r
- v = w;\r
- }\r
- else {\r
- /* fall back to the original byte string, as\r
- discussed in patch #683592 */\r
- PyErr_Clear();\r
- }\r
- }\r
-#endif\r
- if (PyList_Append(d, v) != 0) {\r
- Py_DECREF(v);\r
- Py_DECREF(d);\r
- d = NULL;\r
- break;\r
- }\r
- Py_DECREF(v);\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- closedir(dirp);\r
- Py_END_ALLOW_THREADS\r
- PyMem_Free(name);\r
- if(MBname != NULL) {\r
- free(MBname);\r
- }\r
-\r
- return d;\r
-\r
-} /* end of edk2_listdir */\r
-\r
-PyDoc_STRVAR(edk2_mkdir__doc__,\r
-"mkdir(path [, mode=0777])\n\n\\r
-Create a directory.");\r
-\r
-static PyObject *\r
-edk2_mkdir(PyObject *self, PyObject *args)\r
-{\r
- int res;\r
- char *path = NULL;\r
- int mode = 0777;\r
-\r
- if (!PyArg_ParseTuple(args, "et|i:mkdir",\r
- Py_FileSystemDefaultEncoding, &path, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = mkdir(path, mode);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-\r
-/* sys/resource.h is needed for at least: wait3(), wait4(), broken nice. */\r
-#if defined(HAVE_SYS_RESOURCE_H)\r
-#include <sys/resource.h>\r
-#endif\r
-\r
-\r
-#ifdef HAVE_NICE\r
-PyDoc_STRVAR(edk2_nice__doc__,\r
-"nice(inc) -> new_priority\n\n\\r
-Decrease the priority of process by inc and return the new priority.");\r
-\r
-static PyObject *\r
-edk2_nice(PyObject *self, PyObject *args)\r
-{\r
- int increment, value;\r
-\r
- if (!PyArg_ParseTuple(args, "i:nice", &increment))\r
- return NULL;\r
-\r
- /* There are two flavours of 'nice': one that returns the new\r
- priority (as required by almost all standards out there) and the\r
- Linux/FreeBSD/BSDI one, which returns '0' on success and advices\r
- the use of getpriority() to get the new priority.\r
-\r
- If we are of the nice family that returns the new priority, we\r
- need to clear errno before the call, and check if errno is filled\r
- before calling edk2_error() on a returnvalue of -1, because the\r
- -1 may be the actual new priority! */\r
-\r
- errno = 0;\r
- value = nice(increment);\r
-#if defined(HAVE_BROKEN_NICE) && defined(HAVE_GETPRIORITY)\r
- if (value == 0)\r
- value = getpriority(PRIO_PROCESS, 0);\r
-#endif\r
- if (value == -1 && errno != 0)\r
- /* either nice() or getpriority() returned an error */\r
- return edk2_error();\r
- return PyInt_FromLong((long) value);\r
-}\r
-#endif /* HAVE_NICE */\r
-\r
-PyDoc_STRVAR(edk2_rename__doc__,\r
-"rename(old, new)\n\n\\r
-Rename a file or directory.");\r
-\r
-static PyObject *\r
-edk2_rename(PyObject *self, PyObject *args)\r
-{\r
- return edk2_2str(args, "etet:rename", rename);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_rmdir__doc__,\r
-"rmdir(path)\n\n\\r
-Remove a directory.");\r
-\r
-static PyObject *\r
-edk2_rmdir(PyObject *self, PyObject *args)\r
-{\r
- return edk2_1str(args, "et:rmdir", rmdir);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_stat__doc__,\r
-"stat(path) -> stat result\n\n\\r
-Perform a stat system call on the given path.");\r
-\r
-static PyObject *\r
-edk2_stat(PyObject *self, PyObject *args)\r
-{\r
- return edk2_do_stat(self, args, "et:stat", STAT, NULL, NULL);\r
-}\r
-\r
-\r
-#ifdef HAVE_SYSTEM\r
-PyDoc_STRVAR(edk2_system__doc__,\r
-"system(command) -> exit_status\n\n\\r
-Execute the command (a string) in a subshell.");\r
-\r
-static PyObject *\r
-edk2_system(PyObject *self, PyObject *args)\r
-{\r
- char *command;\r
- long sts;\r
- if (!PyArg_ParseTuple(args, "s:system", &command))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- sts = system(command);\r
- Py_END_ALLOW_THREADS\r
- return PyInt_FromLong(sts);\r
-}\r
-#endif\r
-\r
-\r
-PyDoc_STRVAR(edk2_umask__doc__,\r
-"umask(new_mask) -> old_mask\n\n\\r
-Set the current numeric umask and return the previous umask.");\r
-\r
-static PyObject *\r
-edk2_umask(PyObject *self, PyObject *args)\r
-{\r
- int i;\r
- if (!PyArg_ParseTuple(args, "i:umask", &i))\r
- return NULL;\r
- i = (int)umask(i);\r
- if (i < 0)\r
- return edk2_error();\r
- return PyInt_FromLong((long)i);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_unlink__doc__,\r
-"unlink(path)\n\n\\r
-Remove a file (same as remove(path)).");\r
-\r
-PyDoc_STRVAR(edk2_remove__doc__,\r
-"remove(path)\n\n\\r
-Remove a file (same as unlink(path)).");\r
-\r
-static PyObject *\r
-edk2_unlink(PyObject *self, PyObject *args)\r
-{\r
- return edk2_1str(args, "et:remove", unlink);\r
-}\r
-\r
-\r
-static int\r
-extract_time(PyObject *t, time_t* sec, long* usec)\r
-{\r
- time_t intval;\r
- if (PyFloat_Check(t)) {\r
- double tval = PyFloat_AsDouble(t);\r
- PyObject *intobj = PyNumber_Long(t);\r
- if (!intobj)\r
- return -1;\r
-#if SIZEOF_TIME_T > SIZEOF_LONG\r
- intval = PyInt_AsUnsignedLongLongMask(intobj);\r
-#else\r
- intval = PyInt_AsLong(intobj);\r
-#endif\r
- Py_DECREF(intobj);\r
- if (intval == -1 && PyErr_Occurred())\r
- return -1;\r
- *sec = intval;\r
- *usec = (long)((tval - intval) * 1e6); /* can't exceed 1000000 */\r
- if (*usec < 0)\r
- /* If rounding gave us a negative number,\r
- truncate. */\r
- *usec = 0;\r
- return 0;\r
- }\r
-#if SIZEOF_TIME_T > SIZEOF_LONG\r
- intval = PyInt_AsUnsignedLongLongMask(t);\r
-#else\r
- intval = PyInt_AsLong(t);\r
-#endif\r
- if (intval == -1 && PyErr_Occurred())\r
- return -1;\r
- *sec = intval;\r
- *usec = 0;\r
- return 0;\r
-}\r
-\r
-PyDoc_STRVAR(edk2_utime__doc__,\r
-"utime(path, (atime, mtime))\n\\r
-utime(path, None)\n\n\\r
-Set the access and modified time of the file to the given values. If the\n\\r
-second form is used, set the access and modified times to the current time.");\r
-\r
-static PyObject *\r
-edk2_utime(PyObject *self, PyObject *args)\r
-{\r
- char *path = NULL;\r
- time_t atime, mtime;\r
- long ausec, musec;\r
- int res;\r
- PyObject* arg;\r
-\r
-#if defined(HAVE_UTIMES)\r
- struct timeval buf[2];\r
-#define ATIME buf[0].tv_sec\r
-#define MTIME buf[1].tv_sec\r
-#elif defined(HAVE_UTIME_H)\r
-/* XXX should define struct utimbuf instead, above */\r
- struct utimbuf buf;\r
-#define ATIME buf.actime\r
-#define MTIME buf.modtime\r
-#define UTIME_ARG &buf\r
-#else /* HAVE_UTIMES */\r
- time_t buf[2];\r
-#define ATIME buf[0]\r
-#define MTIME buf[1]\r
-#define UTIME_ARG buf\r
-#endif /* HAVE_UTIMES */\r
-\r
-\r
- if (!PyArg_ParseTuple(args, "etO:utime",\r
- Py_FileSystemDefaultEncoding, &path, &arg))\r
- return NULL;\r
- if (arg == Py_None) {\r
- /* optional time values not given */\r
- Py_BEGIN_ALLOW_THREADS\r
- res = utime(path, NULL);\r
- Py_END_ALLOW_THREADS\r
- }\r
- else if (!PyTuple_Check(arg) || PyTuple_Size(arg) != 2) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "utime() arg 2 must be a tuple (atime, mtime)");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- else {\r
- if (extract_time(PyTuple_GET_ITEM(arg, 0),\r
- &atime, &ausec) == -1) {\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- if (extract_time(PyTuple_GET_ITEM(arg, 1),\r
- &mtime, &musec) == -1) {\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- ATIME = atime;\r
- MTIME = mtime;\r
-#ifdef HAVE_UTIMES\r
- buf[0].tv_usec = ausec;\r
- buf[1].tv_usec = musec;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = utimes(path, buf);\r
- Py_END_ALLOW_THREADS\r
-#else\r
- Py_BEGIN_ALLOW_THREADS\r
- res = utime(path, UTIME_ARG);\r
- Py_END_ALLOW_THREADS\r
-#endif /* HAVE_UTIMES */\r
- }\r
- if (res < 0) {\r
- return edk2_error_with_allocated_filename(path);\r
- }\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-#undef UTIME_ARG\r
-#undef ATIME\r
-#undef MTIME\r
-}\r
-\r
-\r
-/* Process operations */\r
-\r
-PyDoc_STRVAR(edk2__exit__doc__,\r
-"_exit(status)\n\n\\r
-Exit to the system with specified status, without normal exit processing.");\r
-\r
-static PyObject *\r
-edk2__exit(PyObject *self, PyObject *args)\r
-{\r
- int sts;\r
- if (!PyArg_ParseTuple(args, "i:_exit", &sts))\r
- return NULL;\r
- _Exit(sts);\r
- return NULL; /* Make gcc -Wall happy */\r
-}\r
-\r
-#if defined(HAVE_EXECV) || defined(HAVE_SPAWNV)\r
-static void\r
-free_string_array(char **array, Py_ssize_t count)\r
-{\r
- Py_ssize_t i;\r
- for (i = 0; i < count; i++)\r
- PyMem_Free(array[i]);\r
- PyMem_DEL(array);\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_EXECV\r
-PyDoc_STRVAR(edk2_execv__doc__,\r
-"execv(path, args)\n\n\\r
-Execute an executable path with arguments, replacing current process.\n\\r
-\n\\r
- path: path of executable file\n\\r
- args: tuple or list of strings");\r
-\r
-static PyObject *\r
-edk2_execv(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- PyObject *argv;\r
- char **argvlist;\r
- Py_ssize_t i, argc;\r
- PyObject *(*getitem)(PyObject *, Py_ssize_t);\r
-\r
- /* execv has two arguments: (path, argv), where\r
- argv is a list or tuple of strings. */\r
-\r
- if (!PyArg_ParseTuple(args, "etO:execv",\r
- Py_FileSystemDefaultEncoding,\r
- &path, &argv))\r
- return NULL;\r
- if (PyList_Check(argv)) {\r
- argc = PyList_Size(argv);\r
- getitem = PyList_GetItem;\r
- }\r
- else if (PyTuple_Check(argv)) {\r
- argc = PyTuple_Size(argv);\r
- getitem = PyTuple_GetItem;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError, "execv() arg 2 must be a tuple or list");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- if (argc < 1) {\r
- PyErr_SetString(PyExc_ValueError, "execv() arg 2 must not be empty");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
-\r
- argvlist = PyMem_NEW(char *, argc+1);\r
- if (argvlist == NULL) {\r
- PyMem_Free(path);\r
- return PyErr_NoMemory();\r
- }\r
- for (i = 0; i < argc; i++) {\r
- if (!PyArg_Parse((*getitem)(argv, i), "et",\r
- Py_FileSystemDefaultEncoding,\r
- &argvlist[i])) {\r
- free_string_array(argvlist, i);\r
- PyErr_SetString(PyExc_TypeError,\r
- "execv() arg 2 must contain only strings");\r
- PyMem_Free(path);\r
- return NULL;\r
-\r
- }\r
- }\r
- argvlist[argc] = NULL;\r
-\r
- execv(path, argvlist);\r
-\r
- /* If we get here it's definitely an error */\r
-\r
- free_string_array(argvlist, argc);\r
- PyMem_Free(path);\r
- return edk2_error();\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_execve__doc__,\r
-"execve(path, args, env)\n\n\\r
-Execute a path with arguments and environment, replacing current process.\n\\r
-\n\\r
- path: path of executable file\n\\r
- args: tuple or list of arguments\n\\r
- env: dictionary of strings mapping to strings");\r
-\r
-static PyObject *\r
-edk2_execve(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- PyObject *argv, *env;\r
- char **argvlist;\r
- char **envlist;\r
- PyObject *key, *val, *keys=NULL, *vals=NULL;\r
- Py_ssize_t i, pos, argc, envc;\r
- PyObject *(*getitem)(PyObject *, Py_ssize_t);\r
- Py_ssize_t lastarg = 0;\r
-\r
- /* execve has three arguments: (path, argv, env), where\r
- argv is a list or tuple of strings and env is a dictionary\r
- like posix.environ. */\r
-\r
- if (!PyArg_ParseTuple(args, "etOO:execve",\r
- Py_FileSystemDefaultEncoding,\r
- &path, &argv, &env))\r
- return NULL;\r
- if (PyList_Check(argv)) {\r
- argc = PyList_Size(argv);\r
- getitem = PyList_GetItem;\r
- }\r
- else if (PyTuple_Check(argv)) {\r
- argc = PyTuple_Size(argv);\r
- getitem = PyTuple_GetItem;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "execve() arg 2 must be a tuple or list");\r
- goto fail_0;\r
- }\r
- if (!PyMapping_Check(env)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "execve() arg 3 must be a mapping object");\r
- goto fail_0;\r
- }\r
-\r
- argvlist = PyMem_NEW(char *, argc+1);\r
- if (argvlist == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_0;\r
- }\r
- for (i = 0; i < argc; i++) {\r
- if (!PyArg_Parse((*getitem)(argv, i),\r
- "et;execve() arg 2 must contain only strings",\r
- Py_FileSystemDefaultEncoding,\r
- &argvlist[i]))\r
- {\r
- lastarg = i;\r
- goto fail_1;\r
- }\r
- }\r
- lastarg = argc;\r
- argvlist[argc] = NULL;\r
-\r
- i = PyMapping_Size(env);\r
- if (i < 0)\r
- goto fail_1;\r
- envlist = PyMem_NEW(char *, i + 1);\r
- if (envlist == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_1;\r
- }\r
- envc = 0;\r
- keys = PyMapping_Keys(env);\r
- vals = PyMapping_Values(env);\r
- if (!keys || !vals)\r
- goto fail_2;\r
- if (!PyList_Check(keys) || !PyList_Check(vals)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "execve(): env.keys() or env.values() is not a list");\r
- goto fail_2;\r
- }\r
-\r
- for (pos = 0; pos < i; pos++) {\r
- char *p, *k, *v;\r
- size_t len;\r
-\r
- key = PyList_GetItem(keys, pos);\r
- val = PyList_GetItem(vals, pos);\r
- if (!key || !val)\r
- goto fail_2;\r
-\r
- if (!PyArg_Parse(\r
- key,\r
- "s;execve() arg 3 contains a non-string key",\r
- &k) ||\r
- !PyArg_Parse(\r
- val,\r
- "s;execve() arg 3 contains a non-string value",\r
- &v))\r
- {\r
- goto fail_2;\r
- }\r
-\r
-#if defined(PYOS_OS2)\r
- /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */\r
- if (stricmp(k, "BEGINLIBPATH") != 0 && stricmp(k, "ENDLIBPATH") != 0) {\r
-#endif\r
- len = PyString_Size(key) + PyString_Size(val) + 2;\r
- p = PyMem_NEW(char, len);\r
- if (p == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_2;\r
- }\r
- PyOS_snprintf(p, len, "%s=%s", k, v);\r
- envlist[envc++] = p;\r
-#if defined(PYOS_OS2)\r
- }\r
-#endif\r
- }\r
- envlist[envc] = 0;\r
-\r
- execve(path, argvlist, envlist);\r
-\r
- /* If we get here it's definitely an error */\r
-\r
- (void) edk2_error();\r
-\r
- fail_2:\r
- while (--envc >= 0)\r
- PyMem_DEL(envlist[envc]);\r
- PyMem_DEL(envlist);\r
- fail_1:\r
- free_string_array(argvlist, lastarg);\r
- Py_XDECREF(vals);\r
- Py_XDECREF(keys);\r
- fail_0:\r
- PyMem_Free(path);\r
- return NULL;\r
-}\r
-#endif /* HAVE_EXECV */\r
-\r
-\r
-#ifdef HAVE_SPAWNV\r
-PyDoc_STRVAR(edk2_spawnv__doc__,\r
-"spawnv(mode, path, args)\n\n\\r
-Execute the program 'path' in a new process.\n\\r
-\n\\r
- mode: mode of process creation\n\\r
- path: path of executable file\n\\r
- args: tuple or list of strings");\r
-\r
-static PyObject *\r
-edk2_spawnv(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- PyObject *argv;\r
- char **argvlist;\r
- int mode, i;\r
- Py_ssize_t argc;\r
- Py_intptr_t spawnval;\r
- PyObject *(*getitem)(PyObject *, Py_ssize_t);\r
-\r
- /* spawnv has three arguments: (mode, path, argv), where\r
- argv is a list or tuple of strings. */\r
-\r
- if (!PyArg_ParseTuple(args, "ietO:spawnv", &mode,\r
- Py_FileSystemDefaultEncoding,\r
- &path, &argv))\r
- return NULL;\r
- if (PyList_Check(argv)) {\r
- argc = PyList_Size(argv);\r
- getitem = PyList_GetItem;\r
- }\r
- else if (PyTuple_Check(argv)) {\r
- argc = PyTuple_Size(argv);\r
- getitem = PyTuple_GetItem;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnv() arg 2 must be a tuple or list");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
-\r
- argvlist = PyMem_NEW(char *, argc+1);\r
- if (argvlist == NULL) {\r
- PyMem_Free(path);\r
- return PyErr_NoMemory();\r
- }\r
- for (i = 0; i < argc; i++) {\r
- if (!PyArg_Parse((*getitem)(argv, i), "et",\r
- Py_FileSystemDefaultEncoding,\r
- &argvlist[i])) {\r
- free_string_array(argvlist, i);\r
- PyErr_SetString(\r
- PyExc_TypeError,\r
- "spawnv() arg 2 must contain only strings");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- }\r
- argvlist[argc] = NULL;\r
-\r
-#if defined(PYOS_OS2) && defined(PYCC_GCC)\r
- Py_BEGIN_ALLOW_THREADS\r
- spawnval = spawnv(mode, path, argvlist);\r
- Py_END_ALLOW_THREADS\r
-#else\r
- if (mode == _OLD_P_OVERLAY)\r
- mode = _P_OVERLAY;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- spawnval = _spawnv(mode, path, argvlist);\r
- Py_END_ALLOW_THREADS\r
-#endif\r
-\r
- free_string_array(argvlist, argc);\r
- PyMem_Free(path);\r
-\r
- if (spawnval == -1)\r
- return edk2_error();\r
- else\r
-#if SIZEOF_LONG == SIZEOF_VOID_P\r
- return Py_BuildValue("l", (long) spawnval);\r
-#else\r
- return Py_BuildValue("L", (PY_LONG_LONG) spawnval);\r
-#endif\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_spawnve__doc__,\r
-"spawnve(mode, path, args, env)\n\n\\r
-Execute the program 'path' in a new process.\n\\r
-\n\\r
- mode: mode of process creation\n\\r
- path: path of executable file\n\\r
- args: tuple or list of arguments\n\\r
- env: dictionary of strings mapping to strings");\r
-\r
-static PyObject *\r
-edk2_spawnve(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- PyObject *argv, *env;\r
- char **argvlist;\r
- char **envlist;\r
- PyObject *key, *val, *keys=NULL, *vals=NULL, *res=NULL;\r
- int mode, pos, envc;\r
- Py_ssize_t argc, i;\r
- Py_intptr_t spawnval;\r
- PyObject *(*getitem)(PyObject *, Py_ssize_t);\r
- Py_ssize_t lastarg = 0;\r
-\r
- /* spawnve has four arguments: (mode, path, argv, env), where\r
- argv is a list or tuple of strings and env is a dictionary\r
- like posix.environ. */\r
-\r
- if (!PyArg_ParseTuple(args, "ietOO:spawnve", &mode,\r
- Py_FileSystemDefaultEncoding,\r
- &path, &argv, &env))\r
- return NULL;\r
- if (PyList_Check(argv)) {\r
- argc = PyList_Size(argv);\r
- getitem = PyList_GetItem;\r
- }\r
- else if (PyTuple_Check(argv)) {\r
- argc = PyTuple_Size(argv);\r
- getitem = PyTuple_GetItem;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnve() arg 2 must be a tuple or list");\r
- goto fail_0;\r
- }\r
- if (!PyMapping_Check(env)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnve() arg 3 must be a mapping object");\r
- goto fail_0;\r
- }\r
-\r
- argvlist = PyMem_NEW(char *, argc+1);\r
- if (argvlist == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_0;\r
- }\r
- for (i = 0; i < argc; i++) {\r
- if (!PyArg_Parse((*getitem)(argv, i),\r
- "et;spawnve() arg 2 must contain only strings",\r
- Py_FileSystemDefaultEncoding,\r
- &argvlist[i]))\r
- {\r
- lastarg = i;\r
- goto fail_1;\r
- }\r
- }\r
- lastarg = argc;\r
- argvlist[argc] = NULL;\r
-\r
- i = PyMapping_Size(env);\r
- if (i < 0)\r
- goto fail_1;\r
- envlist = PyMem_NEW(char *, i + 1);\r
- if (envlist == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_1;\r
- }\r
- envc = 0;\r
- keys = PyMapping_Keys(env);\r
- vals = PyMapping_Values(env);\r
- if (!keys || !vals)\r
- goto fail_2;\r
- if (!PyList_Check(keys) || !PyList_Check(vals)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnve(): env.keys() or env.values() is not a list");\r
- goto fail_2;\r
- }\r
-\r
- for (pos = 0; pos < i; pos++) {\r
- char *p, *k, *v;\r
- size_t len;\r
-\r
- key = PyList_GetItem(keys, pos);\r
- val = PyList_GetItem(vals, pos);\r
- if (!key || !val)\r
- goto fail_2;\r
-\r
- if (!PyArg_Parse(\r
- key,\r
- "s;spawnve() arg 3 contains a non-string key",\r
- &k) ||\r
- !PyArg_Parse(\r
- val,\r
- "s;spawnve() arg 3 contains a non-string value",\r
- &v))\r
- {\r
- goto fail_2;\r
- }\r
- len = PyString_Size(key) + PyString_Size(val) + 2;\r
- p = PyMem_NEW(char, len);\r
- if (p == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_2;\r
- }\r
- PyOS_snprintf(p, len, "%s=%s", k, v);\r
- envlist[envc++] = p;\r
- }\r
- envlist[envc] = 0;\r
-\r
-#if defined(PYOS_OS2) && defined(PYCC_GCC)\r
- Py_BEGIN_ALLOW_THREADS\r
- spawnval = spawnve(mode, path, argvlist, envlist);\r
- Py_END_ALLOW_THREADS\r
-#else\r
- if (mode == _OLD_P_OVERLAY)\r
- mode = _P_OVERLAY;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- spawnval = _spawnve(mode, path, argvlist, envlist);\r
- Py_END_ALLOW_THREADS\r
-#endif\r
-\r
- if (spawnval == -1)\r
- (void) edk2_error();\r
- else\r
-#if SIZEOF_LONG == SIZEOF_VOID_P\r
- res = Py_BuildValue("l", (long) spawnval);\r
-#else\r
- res = Py_BuildValue("L", (PY_LONG_LONG) spawnval);\r
-#endif\r
-\r
- fail_2:\r
- while (--envc >= 0)\r
- PyMem_DEL(envlist[envc]);\r
- PyMem_DEL(envlist);\r
- fail_1:\r
- free_string_array(argvlist, lastarg);\r
- Py_XDECREF(vals);\r
- Py_XDECREF(keys);\r
- fail_0:\r
- PyMem_Free(path);\r
- return res;\r
-}\r
-\r
-/* OS/2 supports spawnvp & spawnvpe natively */\r
-#if defined(PYOS_OS2)\r
-PyDoc_STRVAR(edk2_spawnvp__doc__,\r
-"spawnvp(mode, file, args)\n\n\\r
-Execute the program 'file' in a new process, using the environment\n\\r
-search path to find the file.\n\\r
-\n\\r
- mode: mode of process creation\n\\r
- file: executable file name\n\\r
- args: tuple or list of strings");\r
-\r
-static PyObject *\r
-edk2_spawnvp(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- PyObject *argv;\r
- char **argvlist;\r
- int mode, i, argc;\r
- Py_intptr_t spawnval;\r
- PyObject *(*getitem)(PyObject *, Py_ssize_t);\r
-\r
- /* spawnvp has three arguments: (mode, path, argv), where\r
- argv is a list or tuple of strings. */\r
-\r
- if (!PyArg_ParseTuple(args, "ietO:spawnvp", &mode,\r
- Py_FileSystemDefaultEncoding,\r
- &path, &argv))\r
- return NULL;\r
- if (PyList_Check(argv)) {\r
- argc = PyList_Size(argv);\r
- getitem = PyList_GetItem;\r
- }\r
- else if (PyTuple_Check(argv)) {\r
- argc = PyTuple_Size(argv);\r
- getitem = PyTuple_GetItem;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnvp() arg 2 must be a tuple or list");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
-\r
- argvlist = PyMem_NEW(char *, argc+1);\r
- if (argvlist == NULL) {\r
- PyMem_Free(path);\r
- return PyErr_NoMemory();\r
- }\r
- for (i = 0; i < argc; i++) {\r
- if (!PyArg_Parse((*getitem)(argv, i), "et",\r
- Py_FileSystemDefaultEncoding,\r
- &argvlist[i])) {\r
- free_string_array(argvlist, i);\r
- PyErr_SetString(\r
- PyExc_TypeError,\r
- "spawnvp() arg 2 must contain only strings");\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- }\r
- argvlist[argc] = NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
-#if defined(PYCC_GCC)\r
- spawnval = spawnvp(mode, path, argvlist);\r
-#else\r
- spawnval = _spawnvp(mode, path, argvlist);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
-\r
- free_string_array(argvlist, argc);\r
- PyMem_Free(path);\r
-\r
- if (spawnval == -1)\r
- return edk2_error();\r
- else\r
- return Py_BuildValue("l", (long) spawnval);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_spawnvpe__doc__,\r
-"spawnvpe(mode, file, args, env)\n\n\\r
-Execute the program 'file' in a new process, using the environment\n\\r
-search path to find the file.\n\\r
-\n\\r
- mode: mode of process creation\n\\r
- file: executable file name\n\\r
- args: tuple or list of arguments\n\\r
- env: dictionary of strings mapping to strings");\r
-\r
-static PyObject *\r
-edk2_spawnvpe(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- PyObject *argv, *env;\r
- char **argvlist;\r
- char **envlist;\r
- PyObject *key, *val, *keys=NULL, *vals=NULL, *res=NULL;\r
- int mode, i, pos, argc, envc;\r
- Py_intptr_t spawnval;\r
- PyObject *(*getitem)(PyObject *, Py_ssize_t);\r
- int lastarg = 0;\r
-\r
- /* spawnvpe has four arguments: (mode, path, argv, env), where\r
- argv is a list or tuple of strings and env is a dictionary\r
- like posix.environ. */\r
-\r
- if (!PyArg_ParseTuple(args, "ietOO:spawnvpe", &mode,\r
- Py_FileSystemDefaultEncoding,\r
- &path, &argv, &env))\r
- return NULL;\r
- if (PyList_Check(argv)) {\r
- argc = PyList_Size(argv);\r
- getitem = PyList_GetItem;\r
- }\r
- else if (PyTuple_Check(argv)) {\r
- argc = PyTuple_Size(argv);\r
- getitem = PyTuple_GetItem;\r
- }\r
- else {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnvpe() arg 2 must be a tuple or list");\r
- goto fail_0;\r
- }\r
- if (!PyMapping_Check(env)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnvpe() arg 3 must be a mapping object");\r
- goto fail_0;\r
- }\r
-\r
- argvlist = PyMem_NEW(char *, argc+1);\r
- if (argvlist == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_0;\r
- }\r
- for (i = 0; i < argc; i++) {\r
- if (!PyArg_Parse((*getitem)(argv, i),\r
- "et;spawnvpe() arg 2 must contain only strings",\r
- Py_FileSystemDefaultEncoding,\r
- &argvlist[i]))\r
- {\r
- lastarg = i;\r
- goto fail_1;\r
- }\r
- }\r
- lastarg = argc;\r
- argvlist[argc] = NULL;\r
-\r
- i = PyMapping_Size(env);\r
- if (i < 0)\r
- goto fail_1;\r
- envlist = PyMem_NEW(char *, i + 1);\r
- if (envlist == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_1;\r
- }\r
- envc = 0;\r
- keys = PyMapping_Keys(env);\r
- vals = PyMapping_Values(env);\r
- if (!keys || !vals)\r
- goto fail_2;\r
- if (!PyList_Check(keys) || !PyList_Check(vals)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "spawnvpe(): env.keys() or env.values() is not a list");\r
- goto fail_2;\r
- }\r
-\r
- for (pos = 0; pos < i; pos++) {\r
- char *p, *k, *v;\r
- size_t len;\r
-\r
- key = PyList_GetItem(keys, pos);\r
- val = PyList_GetItem(vals, pos);\r
- if (!key || !val)\r
- goto fail_2;\r
-\r
- if (!PyArg_Parse(\r
- key,\r
- "s;spawnvpe() arg 3 contains a non-string key",\r
- &k) ||\r
- !PyArg_Parse(\r
- val,\r
- "s;spawnvpe() arg 3 contains a non-string value",\r
- &v))\r
- {\r
- goto fail_2;\r
- }\r
- len = PyString_Size(key) + PyString_Size(val) + 2;\r
- p = PyMem_NEW(char, len);\r
- if (p == NULL) {\r
- PyErr_NoMemory();\r
- goto fail_2;\r
- }\r
- PyOS_snprintf(p, len, "%s=%s", k, v);\r
- envlist[envc++] = p;\r
- }\r
- envlist[envc] = 0;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
-#if defined(PYCC_GCC)\r
- spawnval = spawnvpe(mode, path, argvlist, envlist);\r
-#else\r
- spawnval = _spawnvpe(mode, path, argvlist, envlist);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
-\r
- if (spawnval == -1)\r
- (void) edk2_error();\r
- else\r
- res = Py_BuildValue("l", (long) spawnval);\r
-\r
- fail_2:\r
- while (--envc >= 0)\r
- PyMem_DEL(envlist[envc]);\r
- PyMem_DEL(envlist);\r
- fail_1:\r
- free_string_array(argvlist, lastarg);\r
- Py_XDECREF(vals);\r
- Py_XDECREF(keys);\r
- fail_0:\r
- PyMem_Free(path);\r
- return res;\r
-}\r
-#endif /* PYOS_OS2 */\r
-#endif /* HAVE_SPAWNV */\r
-\r
-\r
-#ifdef HAVE_FORK1\r
-PyDoc_STRVAR(edk2_fork1__doc__,\r
-"fork1() -> pid\n\n\\r
-Fork a child process with a single multiplexed (i.e., not bound) thread.\n\\r
-\n\\r
-Return 0 to child process and PID of child to parent process.");\r
-\r
-static PyObject *\r
-edk2_fork1(PyObject *self, PyObject *noargs)\r
-{\r
- pid_t pid;\r
- int result = 0;\r
- _PyImport_AcquireLock();\r
- pid = fork1();\r
- if (pid == 0) {\r
- /* child: this clobbers and resets the import lock. */\r
- PyOS_AfterFork();\r
- } else {\r
- /* parent: release the import lock. */\r
- result = _PyImport_ReleaseLock();\r
- }\r
- if (pid == -1)\r
- return edk2_error();\r
- if (result < 0) {\r
- /* Don't clobber the OSError if the fork failed. */\r
- PyErr_SetString(PyExc_RuntimeError,\r
- "not holding the import lock");\r
- return NULL;\r
- }\r
- return PyLong_FromPid(pid);\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_FORK\r
-PyDoc_STRVAR(edk2_fork__doc__,\r
-"fork() -> pid\n\n\\r
-Fork a child process.\n\\r
-Return 0 to child process and PID of child to parent process.");\r
-\r
-static PyObject *\r
-edk2_fork(PyObject *self, PyObject *noargs)\r
-{\r
- pid_t pid;\r
- int result = 0;\r
- _PyImport_AcquireLock();\r
- pid = fork();\r
- if (pid == 0) {\r
- /* child: this clobbers and resets the import lock. */\r
- PyOS_AfterFork();\r
- } else {\r
- /* parent: release the import lock. */\r
- result = _PyImport_ReleaseLock();\r
- }\r
- if (pid == -1)\r
- return edk2_error();\r
- if (result < 0) {\r
- /* Don't clobber the OSError if the fork failed. */\r
- PyErr_SetString(PyExc_RuntimeError,\r
- "not holding the import lock");\r
- return NULL;\r
- }\r
- return PyLong_FromPid(pid);\r
-}\r
-#endif\r
-\r
-/* AIX uses /dev/ptc but is otherwise the same as /dev/ptmx */\r
-/* IRIX has both /dev/ptc and /dev/ptmx, use ptmx */\r
-#if defined(HAVE_DEV_PTC) && !defined(HAVE_DEV_PTMX)\r
-#define DEV_PTY_FILE "/dev/ptc"\r
-#define HAVE_DEV_PTMX\r
-#else\r
-#define DEV_PTY_FILE "/dev/ptmx"\r
-#endif\r
-\r
-#if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX)\r
-#ifdef HAVE_PTY_H\r
-#include <pty.h>\r
-#else\r
-#ifdef HAVE_LIBUTIL_H\r
-#include <libutil.h>\r
-#else\r
-#ifdef HAVE_UTIL_H\r
-#include <util.h>\r
-#endif /* HAVE_UTIL_H */\r
-#endif /* HAVE_LIBUTIL_H */\r
-#endif /* HAVE_PTY_H */\r
-#ifdef HAVE_STROPTS_H\r
-#include <stropts.h>\r
-#endif\r
-#endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX */\r
-\r
-#if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)\r
-PyDoc_STRVAR(edk2_openpty__doc__,\r
-"openpty() -> (master_fd, slave_fd)\n\n\\r
-Open a pseudo-terminal, returning open fd's for both master and slave end.\n");\r
-\r
-static PyObject *\r
-edk2_openpty(PyObject *self, PyObject *noargs)\r
-{\r
- int master_fd, slave_fd;\r
-#ifndef HAVE_OPENPTY\r
- char * slave_name;\r
-#endif\r
-#if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)\r
- PyOS_sighandler_t sig_saved;\r
-#ifdef sun\r
- extern char *ptsname(int fildes);\r
-#endif\r
-#endif\r
-\r
-#ifdef HAVE_OPENPTY\r
- if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) != 0)\r
- return edk2_error();\r
-#elif defined(HAVE__GETPTY)\r
- slave_name = _getpty(&master_fd, O_RDWR, 0666, 0);\r
- if (slave_name == NULL)\r
- return edk2_error();\r
-\r
- slave_fd = open(slave_name, O_RDWR);\r
- if (slave_fd < 0)\r
- return edk2_error();\r
-#else\r
- master_fd = open(DEV_PTY_FILE, O_RDWR | O_NOCTTY); /* open master */\r
- if (master_fd < 0)\r
- return edk2_error();\r
- sig_saved = PyOS_setsig(SIGCHLD, SIG_DFL);\r
- /* change permission of slave */\r
- if (grantpt(master_fd) < 0) {\r
- PyOS_setsig(SIGCHLD, sig_saved);\r
- return edk2_error();\r
- }\r
- /* unlock slave */\r
- if (unlockpt(master_fd) < 0) {\r
- PyOS_setsig(SIGCHLD, sig_saved);\r
- return edk2_error();\r
- }\r
- PyOS_setsig(SIGCHLD, sig_saved);\r
- slave_name = ptsname(master_fd); /* get name of slave */\r
- if (slave_name == NULL)\r
- return edk2_error();\r
- slave_fd = open(slave_name, O_RDWR | O_NOCTTY); /* open slave */\r
- if (slave_fd < 0)\r
- return edk2_error();\r
-#if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)\r
- ioctl(slave_fd, I_PUSH, "ptem"); /* push ptem */\r
- ioctl(slave_fd, I_PUSH, "ldterm"); /* push ldterm */\r
-#ifndef __hpux\r
- ioctl(slave_fd, I_PUSH, "ttcompat"); /* push ttcompat */\r
-#endif /* __hpux */\r
-#endif /* HAVE_CYGWIN */\r
-#endif /* HAVE_OPENPTY */\r
-\r
- return Py_BuildValue("(ii)", master_fd, slave_fd);\r
-\r
-}\r
-#endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */\r
-\r
-#ifdef HAVE_FORKPTY\r
-PyDoc_STRVAR(edk2_forkpty__doc__,\r
-"forkpty() -> (pid, master_fd)\n\n\\r
-Fork a new process with a new pseudo-terminal as controlling tty.\n\n\\r
-Like fork(), return 0 as pid to child process, and PID of child to parent.\n\\r
-To both, return fd of newly opened pseudo-terminal.\n");\r
-\r
-static PyObject *\r
-edk2_forkpty(PyObject *self, PyObject *noargs)\r
-{\r
- int master_fd = -1, result = 0;\r
- pid_t pid;\r
-\r
- _PyImport_AcquireLock();\r
- pid = forkpty(&master_fd, NULL, NULL, NULL);\r
- if (pid == 0) {\r
- /* child: this clobbers and resets the import lock. */\r
- PyOS_AfterFork();\r
- } else {\r
- /* parent: release the import lock. */\r
- result = _PyImport_ReleaseLock();\r
- }\r
- if (pid == -1)\r
- return edk2_error();\r
- if (result < 0) {\r
- /* Don't clobber the OSError if the fork failed. */\r
- PyErr_SetString(PyExc_RuntimeError,\r
- "not holding the import lock");\r
- return NULL;\r
- }\r
- return Py_BuildValue("(Ni)", PyLong_FromPid(pid), master_fd);\r
-}\r
-#endif\r
-\r
-PyDoc_STRVAR(edk2_getpid__doc__,\r
-"getpid() -> pid\n\n\\r
-Return the current process id");\r
-\r
-static PyObject *\r
-edk2_getpid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyLong_FromPid(getpid());\r
-}\r
-\r
-\r
-#ifdef HAVE_GETLOGIN\r
-PyDoc_STRVAR(edk2_getlogin__doc__,\r
-"getlogin() -> string\n\n\\r
-Return the actual login name.");\r
-\r
-static PyObject *\r
-edk2_getlogin(PyObject *self, PyObject *noargs)\r
-{\r
- PyObject *result = NULL;\r
- char *name;\r
- int old_errno = errno;\r
-\r
- errno = 0;\r
- name = getlogin();\r
- if (name == NULL) {\r
- if (errno)\r
- edk2_error();\r
- else\r
- PyErr_SetString(PyExc_OSError,\r
- "unable to determine login name");\r
- }\r
- else\r
- result = PyString_FromString(name);\r
- errno = old_errno;\r
-\r
- return result;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_KILL\r
-PyDoc_STRVAR(edk2_kill__doc__,\r
-"kill(pid, sig)\n\n\\r
-Kill a process with a signal.");\r
-\r
-static PyObject *\r
-edk2_kill(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid;\r
- int sig;\r
- if (!PyArg_ParseTuple(args, PARSE_PID "i:kill", &pid, &sig))\r
- return NULL;\r
-#if defined(PYOS_OS2) && !defined(PYCC_GCC)\r
- if (sig == XCPT_SIGNAL_INTR || sig == XCPT_SIGNAL_BREAK) {\r
- APIRET rc;\r
- if ((rc = DosSendSignalException(pid, sig)) != NO_ERROR)\r
- return os2_error(rc);\r
-\r
- } else if (sig == XCPT_SIGNAL_KILLPROC) {\r
- APIRET rc;\r
- if ((rc = DosKillProcess(DKP_PROCESS, pid)) != NO_ERROR)\r
- return os2_error(rc);\r
-\r
- } else\r
- return NULL; /* Unrecognized Signal Requested */\r
-#else\r
- if (kill(pid, sig) == -1)\r
- return edk2_error();\r
-#endif\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_PLOCK\r
-\r
-#ifdef HAVE_SYS_LOCK_H\r
-#include <sys/lock.h>\r
-#endif\r
-\r
-PyDoc_STRVAR(edk2_plock__doc__,\r
-"plock(op)\n\n\\r
-Lock program segments into memory.");\r
-\r
-static PyObject *\r
-edk2_plock(PyObject *self, PyObject *args)\r
-{\r
- int op;\r
- if (!PyArg_ParseTuple(args, "i:plock", &op))\r
- return NULL;\r
- if (plock(op) == -1)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_POPEN\r
-PyDoc_STRVAR(edk2_popen__doc__,\r
-"popen(command [, mode='r' [, bufsize]]) -> pipe\n\n\\r
-Open a pipe to/from a command returning a file object.");\r
-\r
-static PyObject *\r
-edk2_popen(PyObject *self, PyObject *args)\r
-{\r
- char *name;\r
- char *mode = "r";\r
- int bufsize = -1;\r
- FILE *fp;\r
- PyObject *f;\r
- if (!PyArg_ParseTuple(args, "s|si:popen", &name, &mode, &bufsize))\r
- return NULL;\r
- /* Strip mode of binary or text modifiers */\r
- if (strcmp(mode, "rb") == 0 || strcmp(mode, "rt") == 0)\r
- mode = "r";\r
- else if (strcmp(mode, "wb") == 0 || strcmp(mode, "wt") == 0)\r
- mode = "w";\r
- Py_BEGIN_ALLOW_THREADS\r
- fp = popen(name, mode);\r
- Py_END_ALLOW_THREADS\r
- if (fp == NULL)\r
- return edk2_error();\r
- f = PyFile_FromFile(fp, name, mode, pclose);\r
- if (f != NULL)\r
- PyFile_SetBufSize(f, bufsize);\r
- return f;\r
-}\r
-\r
-#endif /* HAVE_POPEN */\r
-\r
-\r
-#if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)\r
-static PyObject *\r
-wait_helper(pid_t pid, int status, struct rusage *ru)\r
-{\r
- PyObject *result;\r
- static PyObject *struct_rusage;\r
-\r
- if (pid == -1)\r
- return edk2_error();\r
-\r
- if (struct_rusage == NULL) {\r
- PyObject *m = PyImport_ImportModuleNoBlock("resource");\r
- if (m == NULL)\r
- return NULL;\r
- struct_rusage = PyObject_GetAttrString(m, "struct_rusage");\r
- Py_DECREF(m);\r
- if (struct_rusage == NULL)\r
- return NULL;\r
- }\r
-\r
- /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */\r
- result = PyStructSequence_New((PyTypeObject*) struct_rusage);\r
- if (!result)\r
- return NULL;\r
-\r
-#ifndef doubletime\r
-#define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)\r
-#endif\r
-\r
- PyStructSequence_SET_ITEM(result, 0,\r
- PyFloat_FromDouble(doubletime(ru->ru_utime)));\r
- PyStructSequence_SET_ITEM(result, 1,\r
- PyFloat_FromDouble(doubletime(ru->ru_stime)));\r
-#define SET_INT(result, index, value)\\r
- PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))\r
- SET_INT(result, 2, ru->ru_maxrss);\r
- SET_INT(result, 3, ru->ru_ixrss);\r
- SET_INT(result, 4, ru->ru_idrss);\r
- SET_INT(result, 5, ru->ru_isrss);\r
- SET_INT(result, 6, ru->ru_minflt);\r
- SET_INT(result, 7, ru->ru_majflt);\r
- SET_INT(result, 8, ru->ru_nswap);\r
- SET_INT(result, 9, ru->ru_inblock);\r
- SET_INT(result, 10, ru->ru_oublock);\r
- SET_INT(result, 11, ru->ru_msgsnd);\r
- SET_INT(result, 12, ru->ru_msgrcv);\r
- SET_INT(result, 13, ru->ru_nsignals);\r
- SET_INT(result, 14, ru->ru_nvcsw);\r
- SET_INT(result, 15, ru->ru_nivcsw);\r
-#undef SET_INT\r
-\r
- if (PyErr_Occurred()) {\r
- Py_DECREF(result);\r
- return NULL;\r
- }\r
-\r
- return Py_BuildValue("NiN", PyLong_FromPid(pid), status, result);\r
-}\r
-#endif /* HAVE_WAIT3 || HAVE_WAIT4 */\r
-\r
-#ifdef HAVE_WAIT3\r
-PyDoc_STRVAR(edk2_wait3__doc__,\r
-"wait3(options) -> (pid, status, rusage)\n\n\\r
-Wait for completion of a child process.");\r
-\r
-static PyObject *\r
-edk2_wait3(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid;\r
- int options;\r
- struct rusage ru;\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:wait3", &options))\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- pid = wait3(&status, options, &ru);\r
- Py_END_ALLOW_THREADS\r
-\r
- return wait_helper(pid, WAIT_STATUS_INT(status), &ru);\r
-}\r
-#endif /* HAVE_WAIT3 */\r
-\r
-#ifdef HAVE_WAIT4\r
-PyDoc_STRVAR(edk2_wait4__doc__,\r
-"wait4(pid, options) -> (pid, status, rusage)\n\n\\r
-Wait for completion of a given child process.");\r
-\r
-static PyObject *\r
-edk2_wait4(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid;\r
- int options;\r
- struct rusage ru;\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, PARSE_PID "i:wait4", &pid, &options))\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- pid = wait4(pid, &status, options, &ru);\r
- Py_END_ALLOW_THREADS\r
-\r
- return wait_helper(pid, WAIT_STATUS_INT(status), &ru);\r
-}\r
-#endif /* HAVE_WAIT4 */\r
-\r
-#ifdef HAVE_WAITPID\r
-PyDoc_STRVAR(edk2_waitpid__doc__,\r
-"waitpid(pid, options) -> (pid, status)\n\n\\r
-Wait for completion of a given child process.");\r
-\r
-static PyObject *\r
-edk2_waitpid(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid;\r
- int options;\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, PARSE_PID "i:waitpid", &pid, &options))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- pid = waitpid(pid, &status, options);\r
- Py_END_ALLOW_THREADS\r
- if (pid == -1)\r
- return edk2_error();\r
-\r
- return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));\r
-}\r
-\r
-#elif defined(HAVE_CWAIT)\r
-\r
-/* MS C has a variant of waitpid() that's usable for most purposes. */\r
-PyDoc_STRVAR(edk2_waitpid__doc__,\r
-"waitpid(pid, options) -> (pid, status << 8)\n\n"\r
-"Wait for completion of a given process. options is ignored on Windows.");\r
-\r
-static PyObject *\r
-edk2_waitpid(PyObject *self, PyObject *args)\r
-{\r
- Py_intptr_t pid;\r
- int status, options;\r
-\r
- if (!PyArg_ParseTuple(args, PARSE_PID "i:waitpid", &pid, &options))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- pid = _cwait(&status, pid, options);\r
- Py_END_ALLOW_THREADS\r
- if (pid == -1)\r
- return edk2_error();\r
-\r
- /* shift the status left a byte so this is more like the POSIX waitpid */\r
- return Py_BuildValue("Ni", PyLong_FromPid(pid), status << 8);\r
-}\r
-#endif /* HAVE_WAITPID || HAVE_CWAIT */\r
-\r
-#ifdef HAVE_WAIT\r
-PyDoc_STRVAR(edk2_wait__doc__,\r
-"wait() -> (pid, status)\n\n\\r
-Wait for completion of a child process.");\r
-\r
-static PyObject *\r
-edk2_wait(PyObject *self, PyObject *noargs)\r
-{\r
- pid_t pid;\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- pid = wait(&status);\r
- Py_END_ALLOW_THREADS\r
- if (pid == -1)\r
- return edk2_error();\r
-\r
- return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));\r
-}\r
-#endif\r
-\r
-\r
-PyDoc_STRVAR(edk2_lstat__doc__,\r
-"lstat(path) -> stat result\n\n\\r
-Like stat(path), but do not follow symbolic links.");\r
-\r
-static PyObject *\r
-edk2_lstat(PyObject *self, PyObject *args)\r
-{\r
-#ifdef HAVE_LSTAT\r
- return edk2_do_stat(self, args, "et:lstat", lstat, NULL, NULL);\r
-#else /* !HAVE_LSTAT */\r
- return edk2_do_stat(self, args, "et:lstat", STAT, NULL, NULL);\r
-#endif /* !HAVE_LSTAT */\r
-}\r
-\r
-\r
-#ifdef HAVE_READLINK\r
-PyDoc_STRVAR(edk2_readlink__doc__,\r
-"readlink(path) -> path\n\n\\r
-Return a string representing the path to which the symbolic link points.");\r
-\r
-static PyObject *\r
-edk2_readlink(PyObject *self, PyObject *args)\r
-{\r
- PyObject* v;\r
- char buf[MAXPATHLEN];\r
- char *path;\r
- int n;\r
-#ifdef Py_USING_UNICODE\r
- int arg_is_unicode = 0;\r
-#endif\r
-\r
- if (!PyArg_ParseTuple(args, "et:readlink",\r
- Py_FileSystemDefaultEncoding, &path))\r
- return NULL;\r
-#ifdef Py_USING_UNICODE\r
- v = PySequence_GetItem(args, 0);\r
- if (v == NULL) {\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
-\r
- if (PyUnicode_Check(v)) {\r
- arg_is_unicode = 1;\r
- }\r
- Py_DECREF(v);\r
-#endif\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- n = readlink(path, buf, (int) sizeof buf);\r
- Py_END_ALLOW_THREADS\r
- if (n < 0)\r
- return edk2_error_with_allocated_filename(path);\r
-\r
- PyMem_Free(path);\r
- v = PyString_FromStringAndSize(buf, n);\r
-#ifdef Py_USING_UNICODE\r
- if (arg_is_unicode) {\r
- PyObject *w;\r
-\r
- w = PyUnicode_FromEncodedObject(v,\r
- Py_FileSystemDefaultEncoding,\r
- "strict");\r
- if (w != NULL) {\r
- Py_DECREF(v);\r
- v = w;\r
- }\r
- else {\r
- /* fall back to the original byte string, as\r
- discussed in patch #683592 */\r
- PyErr_Clear();\r
- }\r
- }\r
-#endif\r
- return v;\r
-}\r
-#endif /* HAVE_READLINK */\r
-\r
-\r
-#ifdef HAVE_SYMLINK\r
-PyDoc_STRVAR(edk2_symlink__doc__,\r
-"symlink(src, dst)\n\n\\r
-Create a symbolic link pointing to src named dst.");\r
-\r
-static PyObject *\r
-edk2_symlink(PyObject *self, PyObject *args)\r
-{\r
- return edk2_2str(args, "etet:symlink", symlink);\r
-}\r
-#endif /* HAVE_SYMLINK */\r
-\r
-\r
-#ifdef HAVE_TIMES\r
-#define NEED_TICKS_PER_SECOND\r
-static long ticks_per_second = -1;\r
-static PyObject *\r
-edk2_times(PyObject *self, PyObject *noargs)\r
-{\r
- struct tms t;\r
- clock_t c;\r
- errno = 0;\r
- c = times(&t);\r
- if (c == (clock_t) -1)\r
- return edk2_error();\r
- return Py_BuildValue("ddddd",\r
- (double)t.tms_utime / ticks_per_second,\r
- (double)t.tms_stime / ticks_per_second,\r
- (double)t.tms_cutime / ticks_per_second,\r
- (double)t.tms_cstime / ticks_per_second,\r
- (double)c / ticks_per_second);\r
-}\r
-#endif /* HAVE_TIMES */\r
-\r
-\r
-#ifdef HAVE_TIMES\r
-PyDoc_STRVAR(edk2_times__doc__,\r
-"times() -> (utime, stime, cutime, cstime, elapsed_time)\n\n\\r
-Return a tuple of floating point numbers indicating process times.");\r
-#endif\r
-\r
-\r
-#ifdef HAVE_GETSID\r
-PyDoc_STRVAR(edk2_getsid__doc__,\r
-"getsid(pid) -> sid\n\n\\r
-Call the system call getsid().");\r
-\r
-static PyObject *\r
-edk2_getsid(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid;\r
- int sid;\r
- if (!PyArg_ParseTuple(args, PARSE_PID ":getsid", &pid))\r
- return NULL;\r
- sid = getsid(pid);\r
- if (sid < 0)\r
- return edk2_error();\r
- return PyInt_FromLong((long)sid);\r
-}\r
-#endif /* HAVE_GETSID */\r
-\r
-\r
-#ifdef HAVE_SETSID\r
-PyDoc_STRVAR(edk2_setsid__doc__,\r
-"setsid()\n\n\\r
-Call the system call setsid().");\r
-\r
-static PyObject *\r
-edk2_setsid(PyObject *self, PyObject *noargs)\r
-{\r
- if (setsid() < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETSID */\r
-\r
-#ifdef HAVE_SETPGID\r
-PyDoc_STRVAR(edk2_setpgid__doc__,\r
-"setpgid(pid, pgrp)\n\n\\r
-Call the system call setpgid().");\r
-\r
-static PyObject *\r
-edk2_setpgid(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid;\r
- int pgrp;\r
- if (!PyArg_ParseTuple(args, PARSE_PID "i:setpgid", &pid, &pgrp))\r
- return NULL;\r
- if (setpgid(pid, pgrp) < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETPGID */\r
-\r
-\r
-#ifdef HAVE_TCGETPGRP\r
-PyDoc_STRVAR(edk2_tcgetpgrp__doc__,\r
-"tcgetpgrp(fd) -> pgid\n\n\\r
-Return the process group associated with the terminal given by a fd.");\r
-\r
-static PyObject *\r
-edk2_tcgetpgrp(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- pid_t pgid;\r
- if (!PyArg_ParseTuple(args, "i:tcgetpgrp", &fd))\r
- return NULL;\r
- pgid = tcgetpgrp(fd);\r
- if (pgid < 0)\r
- return edk2_error();\r
- return PyLong_FromPid(pgid);\r
-}\r
-#endif /* HAVE_TCGETPGRP */\r
-\r
-\r
-#ifdef HAVE_TCSETPGRP\r
-PyDoc_STRVAR(edk2_tcsetpgrp__doc__,\r
-"tcsetpgrp(fd, pgid)\n\n\\r
-Set the process group associated with the terminal given by a fd.");\r
-\r
-static PyObject *\r
-edk2_tcsetpgrp(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- pid_t pgid;\r
- if (!PyArg_ParseTuple(args, "i" PARSE_PID ":tcsetpgrp", &fd, &pgid))\r
- return NULL;\r
- if (tcsetpgrp(fd, pgid) < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_TCSETPGRP */\r
-\r
-/* Functions acting on file descriptors */\r
-\r
-PyDoc_STRVAR(edk2_open__doc__,\r
-"open(filename, flag [, mode=0777]) -> fd\n\n\\r
-Open a file (for low level IO).");\r
-\r
-static PyObject *\r
-edk2_open(PyObject *self, PyObject *args)\r
-{\r
- char *file = NULL;\r
- int flag;\r
- int mode = 0777;\r
- int fd;\r
-\r
- if (!PyArg_ParseTuple(args, "eti|i",\r
- Py_FileSystemDefaultEncoding, &file,\r
- &flag, &mode))\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- fd = open(file, flag, mode);\r
- Py_END_ALLOW_THREADS\r
- if (fd < 0)\r
- return edk2_error_with_allocated_filename(file);\r
- PyMem_Free(file);\r
- return PyInt_FromLong((long)fd);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_close__doc__,\r
-"close(fd)\n\n\\r
-Close a file descriptor (for low level IO).");\r
-\r
-static PyObject *\r
-edk2_close(PyObject *self, PyObject *args)\r
-{\r
- int fd, res;\r
- if (!PyArg_ParseTuple(args, "i:close", &fd))\r
- return NULL;\r
- if (!_PyVerify_fd(fd))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = close(fd);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_closerange__doc__,\r
-"closerange(fd_low, fd_high)\n\n\\r
-Closes all file descriptors in [fd_low, fd_high), ignoring errors.");\r
-\r
-static PyObject *\r
-edk2_closerange(PyObject *self, PyObject *args)\r
-{\r
- int fd_from, fd_to, i;\r
- if (!PyArg_ParseTuple(args, "ii:closerange", &fd_from, &fd_to))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- for (i = fd_from; i < fd_to; i++)\r
- if (_PyVerify_fd(i))\r
- close(i);\r
- Py_END_ALLOW_THREADS\r
- Py_RETURN_NONE;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_dup__doc__,\r
-"dup(fd) -> fd2\n\n\\r
-Return a duplicate of a file descriptor.");\r
-\r
-static PyObject *\r
-edk2_dup(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- if (!PyArg_ParseTuple(args, "i:dup", &fd))\r
- return NULL;\r
- if (!_PyVerify_fd(fd))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- fd = dup(fd);\r
- Py_END_ALLOW_THREADS\r
- if (fd < 0)\r
- return edk2_error();\r
- return PyInt_FromLong((long)fd);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_dup2__doc__,\r
-"dup2(old_fd, new_fd)\n\n\\r
-Duplicate file descriptor.");\r
-\r
-static PyObject *\r
-edk2_dup2(PyObject *self, PyObject *args)\r
-{\r
- int fd, fd2, res;\r
- if (!PyArg_ParseTuple(args, "ii:dup2", &fd, &fd2))\r
- return NULL;\r
- if (!_PyVerify_fd_dup2(fd, fd2))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = dup2(fd, fd2);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_lseek__doc__,\r
-"lseek(fd, pos, how) -> newpos\n\n\\r
-Set the current position of a file descriptor.");\r
-\r
-static PyObject *\r
-edk2_lseek(PyObject *self, PyObject *args)\r
-{\r
- int fd, how;\r
- off_t pos, res;\r
- PyObject *posobj;\r
- if (!PyArg_ParseTuple(args, "iOi:lseek", &fd, &posobj, &how))\r
- return NULL;\r
-#ifdef SEEK_SET\r
- /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */\r
- switch (how) {\r
- case 0: how = SEEK_SET; break;\r
- case 1: how = SEEK_CUR; break;\r
- case 2: how = SEEK_END; break;\r
- }\r
-#endif /* SEEK_END */\r
-\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
- pos = PyInt_AsLong(posobj);\r
-#else\r
- pos = PyLong_Check(posobj) ?\r
- PyLong_AsLongLong(posobj) : PyInt_AsLong(posobj);\r
-#endif\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- if (!_PyVerify_fd(fd))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = lseek(fd, pos, how);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
-\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
- return PyInt_FromLong(res);\r
-#else\r
- return PyLong_FromLongLong(res);\r
-#endif\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_read__doc__,\r
-"read(fd, buffersize) -> string\n\n\\r
-Read a file descriptor.");\r
-\r
-static PyObject *\r
-edk2_read(PyObject *self, PyObject *args)\r
-{\r
- int fd, size, n;\r
- PyObject *buffer;\r
- if (!PyArg_ParseTuple(args, "ii:read", &fd, &size))\r
- return NULL;\r
- if (size < 0) {\r
- errno = EINVAL;\r
- return edk2_error();\r
- }\r
- buffer = PyString_FromStringAndSize((char *)NULL, size);\r
- if (buffer == NULL)\r
- return NULL;\r
- if (!_PyVerify_fd(fd)) {\r
- Py_DECREF(buffer);\r
- return edk2_error();\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- n = read(fd, PyString_AsString(buffer), size);\r
- Py_END_ALLOW_THREADS\r
- if (n < 0) {\r
- Py_DECREF(buffer);\r
- return edk2_error();\r
- }\r
- if (n != size)\r
- _PyString_Resize(&buffer, n);\r
- return buffer;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_write__doc__,\r
-"write(fd, string) -> byteswritten\n\n\\r
-Write a string to a file descriptor.");\r
-\r
-static PyObject *\r
-edk2_write(PyObject *self, PyObject *args)\r
-{\r
- Py_buffer pbuf;\r
- int fd;\r
- Py_ssize_t size;\r
-\r
- if (!PyArg_ParseTuple(args, "is*:write", &fd, &pbuf))\r
- return NULL;\r
- if (!_PyVerify_fd(fd)) {\r
- PyBuffer_Release(&pbuf);\r
- return edk2_error();\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- size = write(fd, pbuf.buf, (size_t)pbuf.len);\r
- Py_END_ALLOW_THREADS\r
- PyBuffer_Release(&pbuf);\r
- if (size < 0)\r
- return edk2_error();\r
- return PyInt_FromSsize_t(size);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_fstat__doc__,\r
-"fstat(fd) -> stat result\n\n\\r
-Like stat(), but for an open file descriptor.");\r
-\r
-static PyObject *\r
-edk2_fstat(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- STRUCT_STAT st;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "i:fstat", &fd))\r
- return NULL;\r
- if (!_PyVerify_fd(fd))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = FSTAT(fd, &st);\r
- Py_END_ALLOW_THREADS\r
- if (res != 0) {\r
- return edk2_error();\r
- }\r
-\r
- return _pystat_fromstructstat(&st);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(edk2_fdopen__doc__,\r
-"fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\n\\r
-Return an open file object connected to a file descriptor.");\r
-\r
-static PyObject *\r
-edk2_fdopen(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- char *orgmode = "r";\r
- int bufsize = -1;\r
- FILE *fp;\r
- PyObject *f;\r
- char *mode;\r
- if (!PyArg_ParseTuple(args, "i|si", &fd, &orgmode, &bufsize))\r
- return NULL;\r
-\r
- /* Sanitize mode. See fileobject.c */\r
- mode = PyMem_MALLOC(strlen(orgmode)+3);\r
- if (!mode) {\r
- PyErr_NoMemory();\r
- return NULL;\r
- }\r
- strcpy(mode, orgmode);\r
- if (_PyFile_SanitizeMode(mode)) {\r
- PyMem_FREE(mode);\r
- return NULL;\r
- }\r
- if (!_PyVerify_fd(fd))\r
- return edk2_error();\r
- Py_BEGIN_ALLOW_THREADS\r
-#if defined(HAVE_FCNTL_H)\r
- if (mode[0] == 'a') {\r
- /* try to make sure the O_APPEND flag is set */\r
- int flags;\r
- flags = fcntl(fd, F_GETFL);\r
- if (flags != -1)\r
- fcntl(fd, F_SETFL, flags | O_APPEND);\r
- fp = fdopen(fd, mode);\r
- if (fp == NULL && flags != -1)\r
- /* restore old mode if fdopen failed */\r
- fcntl(fd, F_SETFL, flags);\r
- } else {\r
- fp = fdopen(fd, mode);\r
- }\r
-#else\r
- fp = fdopen(fd, mode);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
- PyMem_FREE(mode);\r
- if (fp == NULL)\r
- return edk2_error();\r
- f = PyFile_FromFile(fp, "<fdopen>", orgmode, fclose);\r
- if (f != NULL)\r
- PyFile_SetBufSize(f, bufsize);\r
- return f;\r
-}\r
-\r
-PyDoc_STRVAR(edk2_isatty__doc__,\r
-"isatty(fd) -> bool\n\n\\r
-Return True if the file descriptor 'fd' is an open file descriptor\n\\r
-connected to the slave end of a terminal.");\r
-\r
-static PyObject *\r
-edk2_isatty(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- if (!PyArg_ParseTuple(args, "i:isatty", &fd))\r
- return NULL;\r
- if (!_PyVerify_fd(fd))\r
- return PyBool_FromLong(0);\r
- return PyBool_FromLong(isatty(fd));\r
-}\r
-\r
-#ifdef HAVE_PIPE\r
-PyDoc_STRVAR(edk2_pipe__doc__,\r
-"pipe() -> (read_end, write_end)\n\n\\r
-Create a pipe.");\r
-\r
-static PyObject *\r
-edk2_pipe(PyObject *self, PyObject *noargs)\r
-{\r
- int fds[2];\r
- int res;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = pipe(fds);\r
- Py_END_ALLOW_THREADS\r
- if (res != 0)\r
- return edk2_error();\r
- return Py_BuildValue("(ii)", fds[0], fds[1]);\r
-}\r
-#endif /* HAVE_PIPE */\r
-\r
-\r
-#ifdef HAVE_MKFIFO\r
-PyDoc_STRVAR(edk2_mkfifo__doc__,\r
-"mkfifo(filename [, mode=0666])\n\n\\r
-Create a FIFO (a POSIX named pipe).");\r
-\r
-static PyObject *\r
-edk2_mkfifo(PyObject *self, PyObject *args)\r
-{\r
- char *filename;\r
- int mode = 0666;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "s|i:mkfifo", &filename, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = mkfifo(filename, mode);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-\r
-#if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)\r
-PyDoc_STRVAR(edk2_mknod__doc__,\r
-"mknod(filename [, mode=0600, device])\n\n\\r
-Create a filesystem node (file, device special file or named pipe)\n\\r
-named filename. mode specifies both the permissions to use and the\n\\r
-type of node to be created, being combined (bitwise OR) with one of\n\\r
-S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\n\\r
-device defines the newly created device special file (probably using\n\\r
-os.makedev()), otherwise it is ignored.");\r
-\r
-\r
-static PyObject *\r
-edk2_mknod(PyObject *self, PyObject *args)\r
-{\r
- char *filename;\r
- int mode = 0600;\r
- int device = 0;\r
- int res;\r
- if (!PyArg_ParseTuple(args, "s|ii:mknod", &filename, &mode, &device))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = mknod(filename, mode, device);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_DEVICE_MACROS\r
-PyDoc_STRVAR(edk2_major__doc__,\r
-"major(device) -> major number\n\\r
-Extracts a device major number from a raw device number.");\r
-\r
-static PyObject *\r
-edk2_major(PyObject *self, PyObject *args)\r
-{\r
- int device;\r
- if (!PyArg_ParseTuple(args, "i:major", &device))\r
- return NULL;\r
- return PyInt_FromLong((long)major(device));\r
-}\r
-\r
-PyDoc_STRVAR(edk2_minor__doc__,\r
-"minor(device) -> minor number\n\\r
-Extracts a device minor number from a raw device number.");\r
-\r
-static PyObject *\r
-edk2_minor(PyObject *self, PyObject *args)\r
-{\r
- int device;\r
- if (!PyArg_ParseTuple(args, "i:minor", &device))\r
- return NULL;\r
- return PyInt_FromLong((long)minor(device));\r
-}\r
-\r
-PyDoc_STRVAR(edk2_makedev__doc__,\r
-"makedev(major, minor) -> device number\n\\r
-Composes a raw device number from the major and minor device numbers.");\r
-\r
-static PyObject *\r
-edk2_makedev(PyObject *self, PyObject *args)\r
-{\r
- int major, minor;\r
- if (!PyArg_ParseTuple(args, "ii:makedev", &major, &minor))\r
- return NULL;\r
- return PyInt_FromLong((long)makedev(major, minor));\r
-}\r
-#endif /* device macros */\r
-\r
-\r
-#ifdef HAVE_FTRUNCATE\r
-PyDoc_STRVAR(edk2_ftruncate__doc__,\r
-"ftruncate(fd, length)\n\n\\r
-Truncate a file to a specified length.");\r
-\r
-static PyObject *\r
-edk2_ftruncate(PyObject *self, PyObject *args)\r
-{\r
- int fd;\r
- off_t length;\r
- int res;\r
- PyObject *lenobj;\r
-\r
- if (!PyArg_ParseTuple(args, "iO:ftruncate", &fd, &lenobj))\r
- return NULL;\r
-\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
- length = PyInt_AsLong(lenobj);\r
-#else\r
- length = PyLong_Check(lenobj) ?\r
- PyLong_AsLongLong(lenobj) : PyInt_AsLong(lenobj);\r
-#endif\r
- if (PyErr_Occurred())\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = ftruncate(fd, length);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return edk2_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_PUTENV\r
-PyDoc_STRVAR(edk2_putenv__doc__,\r
-"putenv(key, value)\n\n\\r
-Change or add an environment variable.");\r
-\r
-/* Save putenv() parameters as values here, so we can collect them when they\r
- * get re-set with another call for the same key. */\r
-static PyObject *edk2_putenv_garbage;\r
-\r
-static PyObject *\r
-edk2_putenv(PyObject *self, PyObject *args)\r
-{\r
- char *s1, *s2;\r
- char *newenv;\r
- PyObject *newstr;\r
- size_t len;\r
-\r
- if (!PyArg_ParseTuple(args, "ss:putenv", &s1, &s2))\r
- return NULL;\r
-\r
- /* XXX This can leak memory -- not easy to fix :-( */\r
- len = strlen(s1) + strlen(s2) + 2;\r
- /* len includes space for a trailing \0; the size arg to\r
- PyString_FromStringAndSize does not count that */\r
- newstr = PyString_FromStringAndSize(NULL, (int)len - 1);\r
- if (newstr == NULL)\r
- return PyErr_NoMemory();\r
- newenv = PyString_AS_STRING(newstr);\r
- PyOS_snprintf(newenv, len, "%s=%s", s1, s2);\r
- if (putenv(newenv)) {\r
- Py_DECREF(newstr);\r
- edk2_error();\r
- return NULL;\r
- }\r
- /* Install the first arg and newstr in edk2_putenv_garbage;\r
- * this will cause previous value to be collected. This has to\r
- * happen after the real putenv() call because the old value\r
- * was still accessible until then. */\r
- if (PyDict_SetItem(edk2_putenv_garbage,\r
- PyTuple_GET_ITEM(args, 0), newstr)) {\r
- /* really not much we can do; just leak */\r
- PyErr_Clear();\r
- }\r
- else {\r
- Py_DECREF(newstr);\r
- }\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* putenv */\r
-\r
-#ifdef HAVE_UNSETENV\r
-PyDoc_STRVAR(edk2_unsetenv__doc__,\r
-"unsetenv(key)\n\n\\r
-Delete an environment variable.");\r
-\r
-static PyObject *\r
-edk2_unsetenv(PyObject *self, PyObject *args)\r
-{\r
- char *s1;\r
-\r
- if (!PyArg_ParseTuple(args, "s:unsetenv", &s1))\r
- return NULL;\r
-\r
- unsetenv(s1);\r
-\r
- /* Remove the key from edk2_putenv_garbage;\r
- * this will cause it to be collected. This has to\r
- * happen after the real unsetenv() call because the\r
- * old value was still accessible until then.\r
- */\r
- if (PyDict_DelItem(edk2_putenv_garbage,\r
- PyTuple_GET_ITEM(args, 0))) {\r
- /* really not much we can do; just leak */\r
- PyErr_Clear();\r
- }\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* unsetenv */\r
-\r
-PyDoc_STRVAR(edk2_strerror__doc__,\r
-"strerror(code) -> string\n\n\\r
-Translate an error code to a message string.");\r
-\r
-static PyObject *\r
-edk2_strerror(PyObject *self, PyObject *args)\r
-{\r
- int code;\r
- char *message;\r
- if (!PyArg_ParseTuple(args, "i:strerror", &code))\r
- return NULL;\r
- message = strerror(code);\r
- if (message == NULL) {\r
- PyErr_SetString(PyExc_ValueError,\r
- "strerror() argument out of range");\r
- return NULL;\r
- }\r
- return PyString_FromString(message);\r
-}\r
-\r
-\r
-#ifdef HAVE_SYS_WAIT_H\r
-\r
-#ifdef WCOREDUMP\r
-PyDoc_STRVAR(edk2_WCOREDUMP__doc__,\r
-"WCOREDUMP(status) -> bool\n\n\\r
-Return True if the process returning 'status' was dumped to a core file.");\r
-\r
-static PyObject *\r
-edk2_WCOREDUMP(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WCOREDUMP", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return PyBool_FromLong(WCOREDUMP(status));\r
-}\r
-#endif /* WCOREDUMP */\r
-\r
-#ifdef WIFCONTINUED\r
-PyDoc_STRVAR(edk2_WIFCONTINUED__doc__,\r
-"WIFCONTINUED(status) -> bool\n\n\\r
-Return True if the process returning 'status' was continued from a\n\\r
-job control stop.");\r
-\r
-static PyObject *\r
-edk2_WIFCONTINUED(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WCONTINUED", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return PyBool_FromLong(WIFCONTINUED(status));\r
-}\r
-#endif /* WIFCONTINUED */\r
-\r
-#ifdef WIFSTOPPED\r
-PyDoc_STRVAR(edk2_WIFSTOPPED__doc__,\r
-"WIFSTOPPED(status) -> bool\n\n\\r
-Return True if the process returning 'status' was stopped.");\r
-\r
-static PyObject *\r
-edk2_WIFSTOPPED(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WIFSTOPPED", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return PyBool_FromLong(WIFSTOPPED(status));\r
-}\r
-#endif /* WIFSTOPPED */\r
-\r
-#ifdef WIFSIGNALED\r
-PyDoc_STRVAR(edk2_WIFSIGNALED__doc__,\r
-"WIFSIGNALED(status) -> bool\n\n\\r
-Return True if the process returning 'status' was terminated by a signal.");\r
-\r
-static PyObject *\r
-edk2_WIFSIGNALED(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WIFSIGNALED", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return PyBool_FromLong(WIFSIGNALED(status));\r
-}\r
-#endif /* WIFSIGNALED */\r
-\r
-#ifdef WIFEXITED\r
-PyDoc_STRVAR(edk2_WIFEXITED__doc__,\r
-"WIFEXITED(status) -> bool\n\n\\r
-Return true if the process returning 'status' exited using the exit()\n\\r
-system call.");\r
-\r
-static PyObject *\r
-edk2_WIFEXITED(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WIFEXITED", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return PyBool_FromLong(WIFEXITED(status));\r
-}\r
-#endif /* WIFEXITED */\r
-\r
-#ifdef WEXITSTATUS\r
-PyDoc_STRVAR(edk2_WEXITSTATUS__doc__,\r
-"WEXITSTATUS(status) -> integer\n\n\\r
-Return the process return code from 'status'.");\r
-\r
-static PyObject *\r
-edk2_WEXITSTATUS(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WEXITSTATUS", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return Py_BuildValue("i", WEXITSTATUS(status));\r
-}\r
-#endif /* WEXITSTATUS */\r
-\r
-#ifdef WTERMSIG\r
-PyDoc_STRVAR(edk2_WTERMSIG__doc__,\r
-"WTERMSIG(status) -> integer\n\n\\r
-Return the signal that terminated the process that provided the 'status'\n\\r
-value.");\r
-\r
-static PyObject *\r
-edk2_WTERMSIG(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WTERMSIG", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return Py_BuildValue("i", WTERMSIG(status));\r
-}\r
-#endif /* WTERMSIG */\r
-\r
-#ifdef WSTOPSIG\r
-PyDoc_STRVAR(edk2_WSTOPSIG__doc__,\r
-"WSTOPSIG(status) -> integer\n\n\\r
-Return the signal that stopped the process that provided\n\\r
-the 'status' value.");\r
-\r
-static PyObject *\r
-edk2_WSTOPSIG(PyObject *self, PyObject *args)\r
-{\r
- WAIT_TYPE status;\r
- WAIT_STATUS_INT(status) = 0;\r
-\r
- if (!PyArg_ParseTuple(args, "i:WSTOPSIG", &WAIT_STATUS_INT(status)))\r
- return NULL;\r
-\r
- return Py_BuildValue("i", WSTOPSIG(status));\r
-}\r
-#endif /* WSTOPSIG */\r
-\r
-#endif /* HAVE_SYS_WAIT_H */\r
-\r
-\r
-#if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)\r
-#include <sys/statvfs.h>\r
-\r
-static PyObject*\r
-_pystatvfs_fromstructstatvfs(struct statvfs st) {\r
- PyObject *v = PyStructSequence_New(&StatVFSResultType);\r
- if (v == NULL)\r
- return NULL;\r
-\r
-#if !defined(HAVE_LARGEFILE_SUPPORT)\r
- PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long) st.f_bsize));\r
- PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long) st.f_frsize));\r
- PyStructSequence_SET_ITEM(v, 2, PyInt_FromLong((long) st.f_blocks));\r
- PyStructSequence_SET_ITEM(v, 3, PyInt_FromLong((long) st.f_bfree));\r
- PyStructSequence_SET_ITEM(v, 4, PyInt_FromLong((long) st.f_bavail));\r
- PyStructSequence_SET_ITEM(v, 5, PyInt_FromLong((long) st.f_files));\r
- PyStructSequence_SET_ITEM(v, 6, PyInt_FromLong((long) st.f_ffree));\r
- PyStructSequence_SET_ITEM(v, 7, PyInt_FromLong((long) st.f_favail));\r
- PyStructSequence_SET_ITEM(v, 8, PyInt_FromLong((long) st.f_flag));\r
- PyStructSequence_SET_ITEM(v, 9, PyInt_FromLong((long) st.f_namemax));\r
-#else\r
- PyStructSequence_SET_ITEM(v, 0, PyInt_FromLong((long) st.f_bsize));\r
- PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long) st.f_frsize));\r
- PyStructSequence_SET_ITEM(v, 2,\r
- PyLong_FromLongLong((PY_LONG_LONG) st.f_blocks));\r
- PyStructSequence_SET_ITEM(v, 3,\r
- PyLong_FromLongLong((PY_LONG_LONG) st.f_bfree));\r
- PyStructSequence_SET_ITEM(v, 4,\r
- PyLong_FromLongLong((PY_LONG_LONG) st.f_bavail));\r
- PyStructSequence_SET_ITEM(v, 5,\r
- PyLong_FromLongLong((PY_LONG_LONG) st.f_files));\r
- PyStructSequence_SET_ITEM(v, 6,\r
- PyLong_FromLongLong((PY_LONG_LONG) st.f_ffree));\r
- PyStructSequence_SET_ITEM(v, 7,\r
- PyLong_FromLongLong((PY_LONG_LONG) st.f_favail));\r
- PyStructSequence_SET_ITEM(v, 8, PyInt_FromLong((long) st.f_flag));\r
- PyStructSequence_SET_ITEM(v, 9, PyInt_FromLong((long) st.f_namemax));\r
-#endif\r
-\r
- return v;\r
-}\r
-\r
-PyDoc_STRVAR(edk2_fstatvfs__doc__,\r
-"fstatvfs(fd) -> statvfs result\n\n\\r
-Perform an fstatvfs system call on the given fd.");\r
-\r
-static PyObject *\r
-edk2_fstatvfs(PyObject *self, PyObject *args)\r
-{\r
- int fd, res;\r
- struct statvfs st;\r
-\r
- if (!PyArg_ParseTuple(args, "i:fstatvfs", &fd))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = fstatvfs(fd, &st);\r
- Py_END_ALLOW_THREADS\r
- if (res != 0)\r
- return edk2_error();\r
-\r
- return _pystatvfs_fromstructstatvfs(st);\r
-}\r
-#endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */\r
-\r
-\r
-#if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)\r
-#include <sys/statvfs.h>\r
-\r
-PyDoc_STRVAR(edk2_statvfs__doc__,\r
-"statvfs(path) -> statvfs result\n\n\\r
-Perform a statvfs system call on the given path.");\r
-\r
-static PyObject *\r
-edk2_statvfs(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- int res;\r
- struct statvfs st;\r
- if (!PyArg_ParseTuple(args, "s:statvfs", &path))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- res = statvfs(path, &st);\r
- Py_END_ALLOW_THREADS\r
- if (res != 0)\r
- return edk2_error_with_filename(path);\r
-\r
- return _pystatvfs_fromstructstatvfs(st);\r
-}\r
-#endif /* HAVE_STATVFS */\r
-\r
-\r
-#ifdef HAVE_TEMPNAM\r
-PyDoc_STRVAR(edk2_tempnam__doc__,\r
-"tempnam([dir[, prefix]]) -> string\n\n\\r
-Return a unique name for a temporary file.\n\\r
-The directory and a prefix may be specified as strings; they may be omitted\n\\r
-or None if not needed.");\r
-\r
-static PyObject *\r
-edk2_tempnam(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result = NULL;\r
- char *dir = NULL;\r
- char *pfx = NULL;\r
- char *name;\r
-\r
- if (!PyArg_ParseTuple(args, "|zz:tempnam", &dir, &pfx))\r
- return NULL;\r
-\r
- if (PyErr_Warn(PyExc_RuntimeWarning,\r
- "tempnam is a potential security risk to your program") < 0)\r
- return NULL;\r
-\r
- if (PyErr_WarnPy3k("tempnam has been removed in 3.x; "\r
- "use the tempfile module", 1) < 0)\r
- return NULL;\r
-\r
- name = tempnam(dir, pfx);\r
- if (name == NULL)\r
- return PyErr_NoMemory();\r
- result = PyString_FromString(name);\r
- free(name);\r
- return result;\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_TMPFILE\r
-PyDoc_STRVAR(edk2_tmpfile__doc__,\r
-"tmpfile() -> file object\n\n\\r
-Create a temporary file with no directory entries.");\r
-\r
-static PyObject *\r
-edk2_tmpfile(PyObject *self, PyObject *noargs)\r
-{\r
- FILE *fp;\r
-\r
- if (PyErr_WarnPy3k("tmpfile has been removed in 3.x; "\r
- "use the tempfile module", 1) < 0)\r
- return NULL;\r
-\r
- fp = tmpfile();\r
- if (fp == NULL)\r
- return edk2_error();\r
- return PyFile_FromFile(fp, "<tmpfile>", "w+b", fclose);\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_TMPNAM\r
-PyDoc_STRVAR(edk2_tmpnam__doc__,\r
-"tmpnam() -> string\n\n\\r
-Return a unique name for a temporary file.");\r
-\r
-static PyObject *\r
-edk2_tmpnam(PyObject *self, PyObject *noargs)\r
-{\r
- char buffer[L_tmpnam];\r
- char *name;\r
-\r
- if (PyErr_Warn(PyExc_RuntimeWarning,\r
- "tmpnam is a potential security risk to your program") < 0)\r
- return NULL;\r
-\r
- if (PyErr_WarnPy3k("tmpnam has been removed in 3.x; "\r
- "use the tempfile module", 1) < 0)\r
- return NULL;\r
-\r
-#ifdef USE_TMPNAM_R\r
- name = tmpnam_r(buffer);\r
-#else\r
- name = tmpnam(buffer);\r
-#endif\r
- if (name == NULL) {\r
- PyObject *err = Py_BuildValue("is", 0,\r
-#ifdef USE_TMPNAM_R\r
- "unexpected NULL from tmpnam_r"\r
-#else\r
- "unexpected NULL from tmpnam"\r
-#endif\r
- );\r
- PyErr_SetObject(PyExc_OSError, err);\r
- Py_XDECREF(err);\r
- return NULL;\r
- }\r
- return PyString_FromString(buffer);\r
-}\r
-#endif\r
-\r
-PyDoc_STRVAR(edk2_abort__doc__,\r
-"abort() -> does not return!\n\n\\r
-Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\\r
-in the hardest way possible on the hosting operating system.");\r
-\r
-static PyObject *\r
-edk2_abort(PyObject *self, PyObject *noargs)\r
-{\r
- abort();\r
- /*NOTREACHED*/\r
- Py_FatalError("abort() called from Python code didn't abort!");\r
- return NULL;\r
-}\r
-\r
-static PyMethodDef edk2_methods[] = {\r
- {"access", edk2_access, METH_VARARGS, edk2_access__doc__},\r
-#ifdef HAVE_TTYNAME\r
- {"ttyname", edk2_ttyname, METH_VARARGS, edk2_ttyname__doc__},\r
-#endif\r
- {"chdir", edk2_chdir, METH_VARARGS, edk2_chdir__doc__},\r
-#ifdef HAVE_CHFLAGS\r
- {"chflags", edk2_chflags, METH_VARARGS, edk2_chflags__doc__},\r
-#endif /* HAVE_CHFLAGS */\r
- {"chmod", edk2_chmod, METH_VARARGS, edk2_chmod__doc__},\r
-#ifdef HAVE_FCHMOD\r
- {"fchmod", edk2_fchmod, METH_VARARGS, edk2_fchmod__doc__},\r
-#endif /* HAVE_FCHMOD */\r
-#ifdef HAVE_CHOWN\r
- {"chown", edk2_chown, METH_VARARGS, edk2_chown__doc__},\r
-#endif /* HAVE_CHOWN */\r
-#ifdef HAVE_LCHMOD\r
- {"lchmod", edk2_lchmod, METH_VARARGS, edk2_lchmod__doc__},\r
-#endif /* HAVE_LCHMOD */\r
-#ifdef HAVE_FCHOWN\r
- {"fchown", edk2_fchown, METH_VARARGS, edk2_fchown__doc__},\r
-#endif /* HAVE_FCHOWN */\r
-#ifdef HAVE_LCHFLAGS\r
- {"lchflags", edk2_lchflags, METH_VARARGS, edk2_lchflags__doc__},\r
-#endif /* HAVE_LCHFLAGS */\r
-#ifdef HAVE_LCHOWN\r
- {"lchown", edk2_lchown, METH_VARARGS, edk2_lchown__doc__},\r
-#endif /* HAVE_LCHOWN */\r
-#ifdef HAVE_CHROOT\r
- {"chroot", edk2_chroot, METH_VARARGS, edk2_chroot__doc__},\r
-#endif\r
-#ifdef HAVE_CTERMID\r
- {"ctermid", edk2_ctermid, METH_NOARGS, edk2_ctermid__doc__},\r
-#endif\r
-#ifdef HAVE_GETCWD\r
- {"getcwd", edk2_getcwd, METH_NOARGS, edk2_getcwd__doc__},\r
-#ifdef Py_USING_UNICODE\r
- {"getcwdu", edk2_getcwdu, METH_NOARGS, edk2_getcwdu__doc__},\r
-#endif\r
-#endif\r
-#ifdef HAVE_LINK\r
- {"link", edk2_link, METH_VARARGS, edk2_link__doc__},\r
-#endif /* HAVE_LINK */\r
- {"listdir", edk2_listdir, METH_VARARGS, edk2_listdir__doc__},\r
- {"lstat", edk2_lstat, METH_VARARGS, edk2_lstat__doc__},\r
- {"mkdir", edk2_mkdir, METH_VARARGS, edk2_mkdir__doc__},\r
-#ifdef HAVE_NICE\r
- {"nice", edk2_nice, METH_VARARGS, edk2_nice__doc__},\r
-#endif /* HAVE_NICE */\r
-#ifdef HAVE_READLINK\r
- {"readlink", edk2_readlink, METH_VARARGS, edk2_readlink__doc__},\r
-#endif /* HAVE_READLINK */\r
- {"rename", edk2_rename, METH_VARARGS, edk2_rename__doc__},\r
- {"rmdir", edk2_rmdir, METH_VARARGS, edk2_rmdir__doc__},\r
- {"stat", edk2_stat, METH_VARARGS, edk2_stat__doc__},\r
- //{"stat_float_times", stat_float_times, METH_VARARGS, stat_float_times__doc__},\r
-#ifdef HAVE_SYMLINK\r
- {"symlink", edk2_symlink, METH_VARARGS, edk2_symlink__doc__},\r
-#endif /* HAVE_SYMLINK */\r
-#ifdef HAVE_SYSTEM\r
- {"system", edk2_system, METH_VARARGS, edk2_system__doc__},\r
-#endif\r
- {"umask", edk2_umask, METH_VARARGS, edk2_umask__doc__},\r
-#ifdef HAVE_UNAME\r
- {"uname", edk2_uname, METH_NOARGS, edk2_uname__doc__},\r
-#endif /* HAVE_UNAME */\r
- {"unlink", edk2_unlink, METH_VARARGS, edk2_unlink__doc__},\r
- {"remove", edk2_unlink, METH_VARARGS, edk2_remove__doc__},\r
- {"utime", edk2_utime, METH_VARARGS, edk2_utime__doc__},\r
-#ifdef HAVE_TIMES\r
- {"times", edk2_times, METH_NOARGS, edk2_times__doc__},\r
-#endif /* HAVE_TIMES */\r
- {"_exit", edk2__exit, METH_VARARGS, edk2__exit__doc__},\r
-#ifdef HAVE_EXECV\r
- {"execv", edk2_execv, METH_VARARGS, edk2_execv__doc__},\r
- {"execve", edk2_execve, METH_VARARGS, edk2_execve__doc__},\r
-#endif /* HAVE_EXECV */\r
-#ifdef HAVE_SPAWNV\r
- {"spawnv", edk2_spawnv, METH_VARARGS, edk2_spawnv__doc__},\r
- {"spawnve", edk2_spawnve, METH_VARARGS, edk2_spawnve__doc__},\r
-#if defined(PYOS_OS2)\r
- {"spawnvp", edk2_spawnvp, METH_VARARGS, edk2_spawnvp__doc__},\r
- {"spawnvpe", edk2_spawnvpe, METH_VARARGS, edk2_spawnvpe__doc__},\r
-#endif /* PYOS_OS2 */\r
-#endif /* HAVE_SPAWNV */\r
-#ifdef HAVE_FORK1\r
- {"fork1", edk2_fork1, METH_NOARGS, edk2_fork1__doc__},\r
-#endif /* HAVE_FORK1 */\r
-#ifdef HAVE_FORK\r
- {"fork", edk2_fork, METH_NOARGS, edk2_fork__doc__},\r
-#endif /* HAVE_FORK */\r
-#if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)\r
- {"openpty", edk2_openpty, METH_NOARGS, edk2_openpty__doc__},\r
-#endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */\r
-#ifdef HAVE_FORKPTY\r
- {"forkpty", edk2_forkpty, METH_NOARGS, edk2_forkpty__doc__},\r
-#endif /* HAVE_FORKPTY */\r
- {"getpid", edk2_getpid, METH_NOARGS, edk2_getpid__doc__},\r
-#ifdef HAVE_GETPGRP\r
- {"getpgrp", edk2_getpgrp, METH_NOARGS, edk2_getpgrp__doc__},\r
-#endif /* HAVE_GETPGRP */\r
-#ifdef HAVE_GETPPID\r
- {"getppid", edk2_getppid, METH_NOARGS, edk2_getppid__doc__},\r
-#endif /* HAVE_GETPPID */\r
-#ifdef HAVE_GETLOGIN\r
- {"getlogin", edk2_getlogin, METH_NOARGS, edk2_getlogin__doc__},\r
-#endif\r
-#ifdef HAVE_KILL\r
- {"kill", edk2_kill, METH_VARARGS, edk2_kill__doc__},\r
-#endif /* HAVE_KILL */\r
-#ifdef HAVE_KILLPG\r
- {"killpg", edk2_killpg, METH_VARARGS, edk2_killpg__doc__},\r
-#endif /* HAVE_KILLPG */\r
-#ifdef HAVE_PLOCK\r
- {"plock", edk2_plock, METH_VARARGS, edk2_plock__doc__},\r
-#endif /* HAVE_PLOCK */\r
-#ifdef HAVE_POPEN\r
- {"popen", edk2_popen, METH_VARARGS, edk2_popen__doc__},\r
-#endif /* HAVE_POPEN */\r
-#ifdef HAVE_SETGROUPS\r
- {"setgroups", edk2_setgroups, METH_O, edk2_setgroups__doc__},\r
-#endif /* HAVE_SETGROUPS */\r
-#ifdef HAVE_INITGROUPS\r
- {"initgroups", edk2_initgroups, METH_VARARGS, edk2_initgroups__doc__},\r
-#endif /* HAVE_INITGROUPS */\r
-#ifdef HAVE_GETPGID\r
- {"getpgid", edk2_getpgid, METH_VARARGS, edk2_getpgid__doc__},\r
-#endif /* HAVE_GETPGID */\r
-#ifdef HAVE_SETPGRP\r
- {"setpgrp", edk2_setpgrp, METH_NOARGS, edk2_setpgrp__doc__},\r
-#endif /* HAVE_SETPGRP */\r
-#ifdef HAVE_WAIT\r
- {"wait", edk2_wait, METH_NOARGS, edk2_wait__doc__},\r
-#endif /* HAVE_WAIT */\r
-#ifdef HAVE_WAIT3\r
- {"wait3", edk2_wait3, METH_VARARGS, edk2_wait3__doc__},\r
-#endif /* HAVE_WAIT3 */\r
-#ifdef HAVE_WAIT4\r
- {"wait4", edk2_wait4, METH_VARARGS, edk2_wait4__doc__},\r
-#endif /* HAVE_WAIT4 */\r
-#if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)\r
- {"waitpid", edk2_waitpid, METH_VARARGS, edk2_waitpid__doc__},\r
-#endif /* HAVE_WAITPID */\r
-#ifdef HAVE_GETSID\r
- {"getsid", edk2_getsid, METH_VARARGS, edk2_getsid__doc__},\r
-#endif /* HAVE_GETSID */\r
-#ifdef HAVE_SETSID\r
- {"setsid", edk2_setsid, METH_NOARGS, edk2_setsid__doc__},\r
-#endif /* HAVE_SETSID */\r
-#ifdef HAVE_SETPGID\r
- {"setpgid", edk2_setpgid, METH_VARARGS, edk2_setpgid__doc__},\r
-#endif /* HAVE_SETPGID */\r
-#ifdef HAVE_TCGETPGRP\r
- {"tcgetpgrp", edk2_tcgetpgrp, METH_VARARGS, edk2_tcgetpgrp__doc__},\r
-#endif /* HAVE_TCGETPGRP */\r
-#ifdef HAVE_TCSETPGRP\r
- {"tcsetpgrp", edk2_tcsetpgrp, METH_VARARGS, edk2_tcsetpgrp__doc__},\r
-#endif /* HAVE_TCSETPGRP */\r
- {"open", edk2_open, METH_VARARGS, edk2_open__doc__},\r
- {"close", edk2_close, METH_VARARGS, edk2_close__doc__},\r
- {"closerange", edk2_closerange, METH_VARARGS, edk2_closerange__doc__},\r
- {"dup", edk2_dup, METH_VARARGS, edk2_dup__doc__},\r
- {"dup2", edk2_dup2, METH_VARARGS, edk2_dup2__doc__},\r
- {"lseek", edk2_lseek, METH_VARARGS, edk2_lseek__doc__},\r
- {"read", edk2_read, METH_VARARGS, edk2_read__doc__},\r
- {"write", edk2_write, METH_VARARGS, edk2_write__doc__},\r
- {"fstat", edk2_fstat, METH_VARARGS, edk2_fstat__doc__},\r
- {"fdopen", edk2_fdopen, METH_VARARGS, edk2_fdopen__doc__},\r
- {"isatty", edk2_isatty, METH_VARARGS, edk2_isatty__doc__},\r
-#ifdef HAVE_PIPE\r
- {"pipe", edk2_pipe, METH_NOARGS, edk2_pipe__doc__},\r
-#endif\r
-#ifdef HAVE_MKFIFO\r
- {"mkfifo", edk2_mkfifo, METH_VARARGS, edk2_mkfifo__doc__},\r
-#endif\r
-#if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)\r
- {"mknod", edk2_mknod, METH_VARARGS, edk2_mknod__doc__},\r
-#endif\r
-#ifdef HAVE_DEVICE_MACROS\r
- {"major", edk2_major, METH_VARARGS, edk2_major__doc__},\r
- {"minor", edk2_minor, METH_VARARGS, edk2_minor__doc__},\r
- {"makedev", edk2_makedev, METH_VARARGS, edk2_makedev__doc__},\r
-#endif\r
-#ifdef HAVE_FTRUNCATE\r
- {"ftruncate", edk2_ftruncate, METH_VARARGS, edk2_ftruncate__doc__},\r
-#endif\r
-#ifdef HAVE_PUTENV\r
- {"putenv", edk2_putenv, METH_VARARGS, edk2_putenv__doc__},\r
-#endif\r
-#ifdef HAVE_UNSETENV\r
- {"unsetenv", edk2_unsetenv, METH_VARARGS, edk2_unsetenv__doc__},\r
-#endif\r
- {"strerror", edk2_strerror, METH_VARARGS, edk2_strerror__doc__},\r
-#ifdef HAVE_FCHDIR\r
- {"fchdir", edk2_fchdir, METH_O, edk2_fchdir__doc__},\r
-#endif\r
-#ifdef HAVE_FSYNC\r
- {"fsync", edk2_fsync, METH_O, edk2_fsync__doc__},\r
-#endif\r
-#ifdef HAVE_FDATASYNC\r
- {"fdatasync", edk2_fdatasync, METH_O, edk2_fdatasync__doc__},\r
-#endif\r
-#ifdef HAVE_SYS_WAIT_H\r
-#ifdef WCOREDUMP\r
- {"WCOREDUMP", edk2_WCOREDUMP, METH_VARARGS, edk2_WCOREDUMP__doc__},\r
-#endif /* WCOREDUMP */\r
-#ifdef WIFCONTINUED\r
- {"WIFCONTINUED",edk2_WIFCONTINUED, METH_VARARGS, edk2_WIFCONTINUED__doc__},\r
-#endif /* WIFCONTINUED */\r
-#ifdef WIFSTOPPED\r
- {"WIFSTOPPED", edk2_WIFSTOPPED, METH_VARARGS, edk2_WIFSTOPPED__doc__},\r
-#endif /* WIFSTOPPED */\r
-#ifdef WIFSIGNALED\r
- {"WIFSIGNALED", edk2_WIFSIGNALED, METH_VARARGS, edk2_WIFSIGNALED__doc__},\r
-#endif /* WIFSIGNALED */\r
-#ifdef WIFEXITED\r
- {"WIFEXITED", edk2_WIFEXITED, METH_VARARGS, edk2_WIFEXITED__doc__},\r
-#endif /* WIFEXITED */\r
-#ifdef WEXITSTATUS\r
- {"WEXITSTATUS", edk2_WEXITSTATUS, METH_VARARGS, edk2_WEXITSTATUS__doc__},\r
-#endif /* WEXITSTATUS */\r
-#ifdef WTERMSIG\r
- {"WTERMSIG", edk2_WTERMSIG, METH_VARARGS, edk2_WTERMSIG__doc__},\r
-#endif /* WTERMSIG */\r
-#ifdef WSTOPSIG\r
- {"WSTOPSIG", edk2_WSTOPSIG, METH_VARARGS, edk2_WSTOPSIG__doc__},\r
-#endif /* WSTOPSIG */\r
-#endif /* HAVE_SYS_WAIT_H */\r
-#if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)\r
- {"fstatvfs", edk2_fstatvfs, METH_VARARGS, edk2_fstatvfs__doc__},\r
-#endif\r
-#if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)\r
- {"statvfs", edk2_statvfs, METH_VARARGS, edk2_statvfs__doc__},\r
-#endif\r
-#ifdef HAVE_TMPFILE\r
- {"tmpfile", edk2_tmpfile, METH_NOARGS, edk2_tmpfile__doc__},\r
-#endif\r
-#ifdef HAVE_TEMPNAM\r
- {"tempnam", edk2_tempnam, METH_VARARGS, edk2_tempnam__doc__},\r
-#endif\r
-#ifdef HAVE_TMPNAM\r
- {"tmpnam", edk2_tmpnam, METH_NOARGS, edk2_tmpnam__doc__},\r
-#endif\r
-#ifdef HAVE_CONFSTR\r
- {"confstr", edk2_confstr, METH_VARARGS, edk2_confstr__doc__},\r
-#endif\r
-#ifdef HAVE_SYSCONF\r
- {"sysconf", edk2_sysconf, METH_VARARGS, edk2_sysconf__doc__},\r
-#endif\r
-#ifdef HAVE_FPATHCONF\r
- {"fpathconf", edk2_fpathconf, METH_VARARGS, edk2_fpathconf__doc__},\r
-#endif\r
-#ifdef HAVE_PATHCONF\r
- {"pathconf", edk2_pathconf, METH_VARARGS, edk2_pathconf__doc__},\r
-#endif\r
- {"abort", edk2_abort, METH_NOARGS, edk2_abort__doc__},\r
-\r
- {NULL, NULL} /* Sentinel */\r
-};\r
-\r
-\r
-static int\r
-ins(PyObject *module, char *symbol, long value)\r
-{\r
- return PyModule_AddIntConstant(module, symbol, value);\r
-}\r
-\r
-static int\r
-all_ins(PyObject *d)\r
-{\r
-#ifdef F_OK\r
- if (ins(d, "F_OK", (long)F_OK)) return -1;\r
-#endif\r
-#ifdef R_OK\r
- if (ins(d, "R_OK", (long)R_OK)) return -1;\r
-#endif\r
-#ifdef W_OK\r
- if (ins(d, "W_OK", (long)W_OK)) return -1;\r
-#endif\r
-#ifdef X_OK\r
- if (ins(d, "X_OK", (long)X_OK)) return -1;\r
-#endif\r
-#ifdef NGROUPS_MAX\r
- if (ins(d, "NGROUPS_MAX", (long)NGROUPS_MAX)) return -1;\r
-#endif\r
-#ifdef TMP_MAX\r
- if (ins(d, "TMP_MAX", (long)TMP_MAX)) return -1;\r
-#endif\r
-#ifdef WCONTINUED\r
- if (ins(d, "WCONTINUED", (long)WCONTINUED)) return -1;\r
-#endif\r
-#ifdef WNOHANG\r
- if (ins(d, "WNOHANG", (long)WNOHANG)) return -1;\r
-#endif\r
-#ifdef WUNTRACED\r
- if (ins(d, "WUNTRACED", (long)WUNTRACED)) return -1;\r
-#endif\r
-#ifdef O_RDONLY\r
- if (ins(d, "O_RDONLY", (long)O_RDONLY)) return -1;\r
-#endif\r
-#ifdef O_WRONLY\r
- if (ins(d, "O_WRONLY", (long)O_WRONLY)) return -1;\r
-#endif\r
-#ifdef O_RDWR\r
- if (ins(d, "O_RDWR", (long)O_RDWR)) return -1;\r
-#endif\r
-#ifdef O_NDELAY\r
- if (ins(d, "O_NDELAY", (long)O_NDELAY)) return -1;\r
-#endif\r
-#ifdef O_NONBLOCK\r
- if (ins(d, "O_NONBLOCK", (long)O_NONBLOCK)) return -1;\r
-#endif\r
-#ifdef O_APPEND\r
- if (ins(d, "O_APPEND", (long)O_APPEND)) return -1;\r
-#endif\r
-#ifdef O_DSYNC\r
- if (ins(d, "O_DSYNC", (long)O_DSYNC)) return -1;\r
-#endif\r
-#ifdef O_RSYNC\r
- if (ins(d, "O_RSYNC", (long)O_RSYNC)) return -1;\r
-#endif\r
-#ifdef O_SYNC\r
- if (ins(d, "O_SYNC", (long)O_SYNC)) return -1;\r
-#endif\r
-#ifdef O_NOCTTY\r
- if (ins(d, "O_NOCTTY", (long)O_NOCTTY)) return -1;\r
-#endif\r
-#ifdef O_CREAT\r
- if (ins(d, "O_CREAT", (long)O_CREAT)) return -1;\r
-#endif\r
-#ifdef O_EXCL\r
- if (ins(d, "O_EXCL", (long)O_EXCL)) return -1;\r
-#endif\r
-#ifdef O_TRUNC\r
- if (ins(d, "O_TRUNC", (long)O_TRUNC)) return -1;\r
-#endif\r
-#ifdef O_BINARY\r
- if (ins(d, "O_BINARY", (long)O_BINARY)) return -1;\r
-#endif\r
-#ifdef O_TEXT\r
- if (ins(d, "O_TEXT", (long)O_TEXT)) return -1;\r
-#endif\r
-#ifdef O_LARGEFILE\r
- if (ins(d, "O_LARGEFILE", (long)O_LARGEFILE)) return -1;\r
-#endif\r
-#ifdef O_SHLOCK\r
- if (ins(d, "O_SHLOCK", (long)O_SHLOCK)) return -1;\r
-#endif\r
-#ifdef O_EXLOCK\r
- if (ins(d, "O_EXLOCK", (long)O_EXLOCK)) return -1;\r
-#endif\r
-\r
-/* MS Windows */\r
-#ifdef O_NOINHERIT\r
- /* Don't inherit in child processes. */\r
- if (ins(d, "O_NOINHERIT", (long)O_NOINHERIT)) return -1;\r
-#endif\r
-#ifdef _O_SHORT_LIVED\r
- /* Optimize for short life (keep in memory). */\r
- /* MS forgot to define this one with a non-underscore form too. */\r
- if (ins(d, "O_SHORT_LIVED", (long)_O_SHORT_LIVED)) return -1;\r
-#endif\r
-#ifdef O_TEMPORARY\r
- /* Automatically delete when last handle is closed. */\r
- if (ins(d, "O_TEMPORARY", (long)O_TEMPORARY)) return -1;\r
-#endif\r
-#ifdef O_RANDOM\r
- /* Optimize for random access. */\r
- if (ins(d, "O_RANDOM", (long)O_RANDOM)) return -1;\r
-#endif\r
-#ifdef O_SEQUENTIAL\r
- /* Optimize for sequential access. */\r
- if (ins(d, "O_SEQUENTIAL", (long)O_SEQUENTIAL)) return -1;\r
-#endif\r
-\r
-/* GNU extensions. */\r
-#ifdef O_ASYNC\r
- /* Send a SIGIO signal whenever input or output\r
- becomes available on file descriptor */\r
- if (ins(d, "O_ASYNC", (long)O_ASYNC)) return -1;\r
-#endif\r
-#ifdef O_DIRECT\r
- /* Direct disk access. */\r
- if (ins(d, "O_DIRECT", (long)O_DIRECT)) return -1;\r
-#endif\r
-#ifdef O_DIRECTORY\r
- /* Must be a directory. */\r
- if (ins(d, "O_DIRECTORY", (long)O_DIRECTORY)) return -1;\r
-#endif\r
-#ifdef O_NOFOLLOW\r
- /* Do not follow links. */\r
- if (ins(d, "O_NOFOLLOW", (long)O_NOFOLLOW)) return -1;\r
-#endif\r
-#ifdef O_NOATIME\r
- /* Do not update the access time. */\r
- if (ins(d, "O_NOATIME", (long)O_NOATIME)) return -1;\r
-#endif\r
-\r
- /* These come from sysexits.h */\r
-#ifdef EX_OK\r
- if (ins(d, "EX_OK", (long)EX_OK)) return -1;\r
-#endif /* EX_OK */\r
-#ifdef EX_USAGE\r
- if (ins(d, "EX_USAGE", (long)EX_USAGE)) return -1;\r
-#endif /* EX_USAGE */\r
-#ifdef EX_DATAERR\r
- if (ins(d, "EX_DATAERR", (long)EX_DATAERR)) return -1;\r
-#endif /* EX_DATAERR */\r
-#ifdef EX_NOINPUT\r
- if (ins(d, "EX_NOINPUT", (long)EX_NOINPUT)) return -1;\r
-#endif /* EX_NOINPUT */\r
-#ifdef EX_NOUSER\r
- if (ins(d, "EX_NOUSER", (long)EX_NOUSER)) return -1;\r
-#endif /* EX_NOUSER */\r
-#ifdef EX_NOHOST\r
- if (ins(d, "EX_NOHOST", (long)EX_NOHOST)) return -1;\r
-#endif /* EX_NOHOST */\r
-#ifdef EX_UNAVAILABLE\r
- if (ins(d, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE)) return -1;\r
-#endif /* EX_UNAVAILABLE */\r
-#ifdef EX_SOFTWARE\r
- if (ins(d, "EX_SOFTWARE", (long)EX_SOFTWARE)) return -1;\r
-#endif /* EX_SOFTWARE */\r
-#ifdef EX_OSERR\r
- if (ins(d, "EX_OSERR", (long)EX_OSERR)) return -1;\r
-#endif /* EX_OSERR */\r
-#ifdef EX_OSFILE\r
- if (ins(d, "EX_OSFILE", (long)EX_OSFILE)) return -1;\r
-#endif /* EX_OSFILE */\r
-#ifdef EX_CANTCREAT\r
- if (ins(d, "EX_CANTCREAT", (long)EX_CANTCREAT)) return -1;\r
-#endif /* EX_CANTCREAT */\r
-#ifdef EX_IOERR\r
- if (ins(d, "EX_IOERR", (long)EX_IOERR)) return -1;\r
-#endif /* EX_IOERR */\r
-#ifdef EX_TEMPFAIL\r
- if (ins(d, "EX_TEMPFAIL", (long)EX_TEMPFAIL)) return -1;\r
-#endif /* EX_TEMPFAIL */\r
-#ifdef EX_PROTOCOL\r
- if (ins(d, "EX_PROTOCOL", (long)EX_PROTOCOL)) return -1;\r
-#endif /* EX_PROTOCOL */\r
-#ifdef EX_NOPERM\r
- if (ins(d, "EX_NOPERM", (long)EX_NOPERM)) return -1;\r
-#endif /* EX_NOPERM */\r
-#ifdef EX_CONFIG\r
- if (ins(d, "EX_CONFIG", (long)EX_CONFIG)) return -1;\r
-#endif /* EX_CONFIG */\r
-#ifdef EX_NOTFOUND\r
- if (ins(d, "EX_NOTFOUND", (long)EX_NOTFOUND)) return -1;\r
-#endif /* EX_NOTFOUND */\r
-\r
-#ifdef HAVE_SPAWNV\r
- if (ins(d, "P_WAIT", (long)_P_WAIT)) return -1;\r
- if (ins(d, "P_NOWAIT", (long)_P_NOWAIT)) return -1;\r
- if (ins(d, "P_OVERLAY", (long)_OLD_P_OVERLAY)) return -1;\r
- if (ins(d, "P_NOWAITO", (long)_P_NOWAITO)) return -1;\r
- if (ins(d, "P_DETACH", (long)_P_DETACH)) return -1;\r
-#endif\r
- return 0;\r
-}\r
-\r
-#define INITFUNC initedk2\r
-#define MODNAME "edk2"\r
-\r
-PyMODINIT_FUNC\r
-INITFUNC(void)\r
-{\r
- PyObject *m;\r
-\r
-#ifndef UEFI_C_SOURCE\r
- PyObject *v;\r
-#endif\r
-\r
- m = Py_InitModule3(MODNAME,\r
- edk2_methods,\r
- edk2__doc__);\r
- if (m == NULL)\r
- return;\r
-\r
-#ifndef UEFI_C_SOURCE\r
- /* Initialize environ dictionary */\r
- v = convertenviron();\r
- Py_XINCREF(v);\r
- if (v == NULL || PyModule_AddObject(m, "environ", v) != 0)\r
- return;\r
- Py_DECREF(v);\r
-#endif /* UEFI_C_SOURCE */\r
-\r
- if (all_ins(m))\r
- return;\r
-\r
- Py_INCREF(PyExc_OSError);\r
- PyModule_AddObject(m, "error", PyExc_OSError);\r
-\r
-#ifdef HAVE_PUTENV\r
- if (edk2_putenv_garbage == NULL)\r
- edk2_putenv_garbage = PyDict_New();\r
-#endif\r
-\r
- if (!initialized) {\r
- stat_result_desc.name = MODNAME ".stat_result";\r
- stat_result_desc.fields[2].name = PyStructSequence_UnnamedField;\r
- stat_result_desc.fields[3].name = PyStructSequence_UnnamedField;\r
- stat_result_desc.fields[4].name = PyStructSequence_UnnamedField;\r
- PyStructSequence_InitType(&StatResultType, &stat_result_desc);\r
- structseq_new = StatResultType.tp_new;\r
- StatResultType.tp_new = statresult_new;\r
-\r
- //statvfs_result_desc.name = MODNAME ".statvfs_result";\r
- //PyStructSequence_InitType(&StatVFSResultType, &statvfs_result_desc);\r
-#ifdef NEED_TICKS_PER_SECOND\r
-# if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)\r
- ticks_per_second = sysconf(_SC_CLK_TCK);\r
-# elif defined(HZ)\r
- ticks_per_second = HZ;\r
-# else\r
- ticks_per_second = 60; /* magic fallback value; may be bogus */\r
-# endif\r
-#endif\r
- }\r
- Py_INCREF((PyObject*) &StatResultType);\r
- PyModule_AddObject(m, "stat_result", (PyObject*) &StatResultType);\r
- //Py_INCREF((PyObject*) &StatVFSResultType);\r
- //PyModule_AddObject(m, "statvfs_result",\r
- // (PyObject*) &StatVFSResultType);\r
- initialized = 1;\r
-\r
-}\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-\r
projects / mirror_edk2.git / blobdiff