+++ /dev/null
-\r
-/* POSIX module implementation */\r
-\r
-/* This file is also used for Windows NT/MS-Win and OS/2. In that case the\r
- module actually calls itself 'nt' or 'os2', not 'posix', and a few\r
- functions are either unimplemented or implemented differently. The source\r
- assumes that for Windows NT, the macro 'MS_WINDOWS' is defined independent\r
- of the compiler used. Different compilers define their own feature\r
- test macro, e.g. '__BORLANDC__' or '_MSC_VER'. For OS/2, the compiler\r
- independent macro PYOS_OS2 should be defined. On OS/2 the default\r
- compiler is assumed to be IBM's VisualAge C++ (VACPP). PYCC_GCC is used\r
- as the compiler specific macro for the EMX port of gcc to OS/2. */\r
-\r
-/* See also ../Dos/dosmodule.c */\r
-\r
-#ifdef __APPLE__\r
- /*\r
- * Step 1 of support for weak-linking a number of symbols existing on\r
- * OSX 10.4 and later, see the comment in the #ifdef __APPLE__ block\r
- * at the end of this file for more information.\r
- */\r
-# pragma weak lchown\r
-# pragma weak statvfs\r
-# pragma weak fstatvfs\r
-\r
-#endif /* __APPLE__ */\r
-\r
-#define PY_SSIZE_T_CLEAN\r
-\r
-#include "Python.h"\r
-#include "structseq.h"\r
-\r
-#if defined(__VMS)\r
-# include <unixio.h>\r
-#endif /* defined(__VMS) */\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-PyDoc_STRVAR(posix__doc__,\r
-"This module provides access to operating system 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 Unix manual 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
-#if defined(PYOS_OS2)\r
-#define INCL_DOS\r
-#define INCL_DOSERRORS\r
-#define INCL_DOSPROCESS\r
-#define INCL_NOPMAPI\r
-#include <os2.h>\r
-#if defined(PYCC_GCC)\r
-#include <ctype.h>\r
-#include <io.h>\r
-#include <stdio.h>\r
-#include <process.h>\r
-#endif\r
-#include "osdefs.h"\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
-/* Various compilers have only certain posix functions */\r
-/* XXX Gosh I wish these were all moved into pyconfig.h */\r
-#if defined(PYCC_VACPP) && defined(PYOS_OS2)\r
-#include <process.h>\r
-#else\r
-#if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */\r
-#define HAVE_GETCWD 1\r
-#define HAVE_OPENDIR 1\r
-#define HAVE_SYSTEM 1\r
-#if defined(__OS2__)\r
-#define HAVE_EXECV 1\r
-#define HAVE_WAIT 1\r
-#endif\r
-#include <process.h>\r
-#else\r
-#ifdef __BORLANDC__ /* Borland compiler */\r
-#define HAVE_EXECV 1\r
-#define HAVE_GETCWD 1\r
-#define HAVE_OPENDIR 1\r
-#define HAVE_PIPE 1\r
-#define HAVE_POPEN 1\r
-#define HAVE_SYSTEM 1\r
-#define HAVE_WAIT 1\r
-#else\r
-#ifdef _MSC_VER /* Microsoft compiler */\r
-#define HAVE_GETCWD 1\r
-#define HAVE_SPAWNV 1\r
-#define HAVE_EXECV 1\r
-#define HAVE_PIPE 1\r
-#define HAVE_POPEN 1\r
-#define HAVE_SYSTEM 1\r
-#define HAVE_CWAIT 1\r
-#define HAVE_FSYNC 1\r
-#define fsync _commit\r
-#else\r
-#if defined(PYOS_OS2) && defined(PYCC_GCC) || defined(__VMS)\r
-/* Everything needed is defined in PC/os2emx/pyconfig.h or vms/pyconfig.h */\r
-#else /* all other compilers */\r
-/* Unix functions that the configure script doesn't check for */\r
-#define HAVE_EXECV 1\r
-#define HAVE_FORK 1\r
-#if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */\r
-#define HAVE_FORK1 1\r
-#endif\r
-#define HAVE_GETCWD 1\r
-#define HAVE_GETEGID 1\r
-#define HAVE_GETEUID 1\r
-#define HAVE_GETGID 1\r
-#define HAVE_GETPPID 1\r
-#define HAVE_GETUID 1\r
-#define HAVE_KILL 1\r
-#define HAVE_OPENDIR 1\r
-#define HAVE_PIPE 1\r
-#ifndef __rtems__\r
-#define HAVE_POPEN 1\r
-#endif\r
-#define HAVE_SYSTEM 1\r
-#define HAVE_WAIT 1\r
-#define HAVE_TTYNAME 1\r
-#endif /* PYOS_OS2 && PYCC_GCC && __VMS */\r
-#endif /* _MSC_VER */\r
-#endif /* __BORLANDC__ */\r
-#endif /* ! __WATCOMC__ || __QNX__ */\r
-#endif /* ! __IBMC__ */\r
-\r
-#ifndef _MSC_VER\r
-\r
-#if defined(__sgi)&&_COMPILER_VERSION>=700\r
-/* declare ctermid_r if compiling with MIPSPro 7.x in ANSI C mode\r
- (default) */\r
-extern char *ctermid_r(char *);\r
-#endif\r
-\r
-#ifndef HAVE_UNISTD_H\r
-#if defined(PYCC_VACPP)\r
-extern int mkdir(char *);\r
-#else\r
-#if ( defined(__WATCOMC__) || defined(_MSC_VER) ) && !defined(__QNX__)\r
-extern int mkdir(const char *);\r
-#else\r
-extern int mkdir(const char *, mode_t);\r
-#endif\r
-#endif\r
-#if defined(__IBMC__) || defined(__IBMCPP__)\r
-extern int chdir(char *);\r
-extern int rmdir(char *);\r
-#else\r
-extern int chdir(const char *);\r
-extern int rmdir(const char *);\r
-#endif\r
-#ifdef __BORLANDC__\r
-extern int chmod(const char *, int);\r
-#else\r
-extern int chmod(const char *, mode_t);\r
-#endif\r
-/*#ifdef HAVE_FCHMOD\r
-extern int fchmod(int, mode_t);\r
-#endif*/\r
-/*#ifdef HAVE_LCHMOD\r
-extern int lchmod(const char *, mode_t);\r
-#endif*/\r
-extern int chown(const char *, uid_t, gid_t);\r
-extern char *getcwd(char *, int);\r
-extern char *strerror(int);\r
-extern int link(const char *, const char *);\r
-extern int rename(const char *, const char *);\r
-extern int stat(const char *, struct stat *);\r
-extern int unlink(const char *);\r
-extern int pclose(FILE *);\r
-#ifdef HAVE_SYMLINK\r
-extern int symlink(const char *, const char *);\r
-#endif /* HAVE_SYMLINK */\r
-#ifdef HAVE_LSTAT\r
-extern int lstat(const char *, struct stat *);\r
-#endif /* HAVE_LSTAT */\r
-#endif /* !HAVE_UNISTD_H */\r
-\r
-#endif /* !_MSC_VER */\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) strlen((dirent)->d_name)\r
-#else\r
-#if defined(__WATCOMC__) && !defined(__QNX__)\r
-#include <direct.h>\r
-#define NAMLEN(dirent) strlen((dirent)->d_name)\r
-#else\r
-#define dirent direct\r
-#define NAMLEN(dirent) (dirent)->d_namlen\r
-#endif\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
-#ifdef _MSC_VER\r
-#ifdef HAVE_DIRECT_H\r
-#include <direct.h>\r
-#endif\r
-#ifdef HAVE_IO_H\r
-#include <io.h>\r
-#endif\r
-#ifdef HAVE_PROCESS_H\r
-#include <process.h>\r
-#endif\r
-#include "osdefs.h"\r
-#include <malloc.h>\r
-#include <windows.h>\r
-#include <shellapi.h> /* for ShellExecute() */\r
-#define popen _popen\r
-#define pclose _pclose\r
-#endif /* _MSC_VER */\r
-\r
-#if defined(PYCC_VACPP) && defined(PYOS_OS2)\r
-#include <io.h>\r
-#endif /* OS2 */\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
-#ifdef UNION_WAIT\r
-/* Emulate some macros on systems that have a union instead of macros */\r
-\r
-#ifndef WIFEXITED\r
-#define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump)\r
-#endif\r
-\r
-#ifndef WEXITSTATUS\r
-#define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1)\r
-#endif\r
-\r
-#ifndef WTERMSIG\r
-#define WTERMSIG(u_wait) ((u_wait).w_termsig)\r
-#endif\r
-\r
-#define WAIT_TYPE union wait\r
-#define WAIT_STATUS_INT(s) (s.w_status)\r
-\r
-#else /* !UNION_WAIT */\r
-#define WAIT_TYPE int\r
-#define WAIT_STATUS_INT(s) (s)\r
-#endif /* UNION_WAIT */\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
-#if defined(MS_WIN64) || defined(MS_WINDOWS)\r
-# define STAT win32_stat\r
-# define FSTAT win32_fstat\r
-# define STRUCT_STAT struct win32_stat\r
-#else\r
-# define STAT stat\r
-# define FSTAT fstat\r
-# define STRUCT_STAT struct stat\r
-#endif\r
-\r
-#if defined(MAJOR_IN_MKDEV)\r
-#include <sys/mkdev.h>\r
-#else\r
-#if defined(MAJOR_IN_SYSMACROS)\r
-#include <sys/sysmacros.h>\r
-#endif\r
-#if defined(HAVE_MKNOD) && defined(HAVE_SYS_MKDEV_H)\r
-#include <sys/mkdev.h>\r
-#endif\r
-#endif\r
-\r
-#if defined _MSC_VER && _MSC_VER >= 1400\r
-/* Microsoft CRT in VS2005 and higher will verify that a filehandle is\r
- * valid and throw an assertion if it isn't.\r
- * Normally, an invalid fd is likely to be a C program error and therefore\r
- * an assertion can be useful, but it does contradict the POSIX standard\r
- * which for write(2) states:\r
- * "Otherwise, -1 shall be returned and errno set to indicate the error."\r
- * "[EBADF] The fildes argument is not a valid file descriptor open for\r
- * writing."\r
- * Furthermore, python allows the user to enter any old integer\r
- * as a fd and should merely raise a python exception on error.\r
- * The Microsoft CRT doesn't provide an official way to check for the\r
- * validity of a file descriptor, but we can emulate its internal behaviour\r
- * by using the exported __pinfo data member and knowledge of the\r
- * internal structures involved.\r
- * The structures below must be updated for each version of visual studio\r
- * according to the file internal.h in the CRT source, until MS comes\r
- * up with a less hacky way to do this.\r
- * (all of this is to avoid globally modifying the CRT behaviour using\r
- * _set_invalid_parameter_handler() and _CrtSetReportMode())\r
- */\r
-/* The actual size of the structure is determined at runtime.\r
- * Only the first items must be present.\r
- */\r
-typedef struct {\r
- intptr_t osfhnd;\r
- char osfile;\r
-} my_ioinfo;\r
-\r
-extern __declspec(dllimport) char * __pioinfo[];\r
-#define IOINFO_L2E 5\r
-#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)\r
-#define IOINFO_ARRAYS 64\r
-#define _NHANDLE_ (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS)\r
-#define FOPEN 0x01\r
-#define _NO_CONSOLE_FILENO (intptr_t)-2\r
-\r
-/* This function emulates what the windows CRT does to validate file handles */\r
-int\r
-_PyVerify_fd(int fd)\r
-{\r
- const int i1 = fd >> IOINFO_L2E;\r
- const int i2 = fd & ((1 << IOINFO_L2E) - 1);\r
-\r
- static int sizeof_ioinfo = 0;\r
-\r
- /* Determine the actual size of the ioinfo structure,\r
- * as used by the CRT loaded in memory\r
- */\r
- if (sizeof_ioinfo == 0 && __pioinfo[0] != NULL) {\r
- sizeof_ioinfo = _msize(__pioinfo[0]) / IOINFO_ARRAY_ELTS;\r
- }\r
- if (sizeof_ioinfo == 0) {\r
- /* This should not happen... */\r
- goto fail;\r
- }\r
-\r
- /* See that it isn't a special CLEAR fileno */\r
- if (fd != _NO_CONSOLE_FILENO) {\r
- /* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead\r
- * we check pointer validity and other info\r
- */\r
- if (0 <= i1 && i1 < IOINFO_ARRAYS && __pioinfo[i1] != NULL) {\r
- /* finally, check that the file is open */\r
- my_ioinfo* info = (my_ioinfo*)(__pioinfo[i1] + i2 * sizeof_ioinfo);\r
- if (info->osfile & FOPEN) {\r
- return 1;\r
- }\r
- }\r
- }\r
- fail:\r
- errno = EBADF;\r
- return 0;\r
-}\r
-\r
-/* the special case of checking dup2. The target fd must be in a sensible range */\r
-static int\r
-_PyVerify_fd_dup2(int fd1, int fd2)\r
-{\r
- if (!_PyVerify_fd(fd1))\r
- return 0;\r
- if (fd2 == _NO_CONSOLE_FILENO)\r
- return 0;\r
- if ((unsigned)fd2 < _NHANDLE_)\r
- return 1;\r
- else\r
- return 0;\r
-}\r
-#else\r
-/* dummy version. _PyVerify_fd() is already defined in fileobject.h */\r
-#define _PyVerify_fd_dup2(A, B) (1)\r
-#endif\r
-\r
-/* Return a dictionary corresponding to the POSIX environment table */\r
-#ifdef WITH_NEXT_FRAMEWORK\r
-/* On Darwin/MacOSX a shared library or framework has no access to\r
-** environ directly, we must obtain it with _NSGetEnviron().\r
-*/\r
-#include <crt_externs.h>\r
-static char **environ;\r
-#elif !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )\r
-extern char **environ;\r
-#endif /* !_MSC_VER */\r
-\r
-static PyObject *\r
-convertenviron(void)\r
-{\r
- PyObject *d;\r
- char **e;\r
-#if defined(PYOS_OS2)\r
- APIRET rc;\r
- char buffer[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */\r
-#endif\r
- d = PyDict_New();\r
- if (d == NULL)\r
- return NULL;\r
-#ifdef WITH_NEXT_FRAMEWORK\r
- if (environ == NULL)\r
- environ = *_NSGetEnviron();\r
-#endif\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
-#if defined(PYOS_OS2)\r
- rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);\r
- if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */\r
- PyObject *v = PyString_FromString(buffer);\r
- PyDict_SetItemString(d, "BEGINLIBPATH", v);\r
- Py_DECREF(v);\r
- }\r
- rc = DosQueryExtLIBPATH(buffer, END_LIBPATH);\r
- if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */\r
- PyObject *v = PyString_FromString(buffer);\r
- PyDict_SetItemString(d, "ENDLIBPATH", v);\r
- Py_DECREF(v);\r
- }\r
-#endif\r
- return d;\r
-}\r
-\r
-\r
-/* Set a POSIX-specific error from errno, and return NULL */\r
-\r
-static PyObject *\r
-posix_error(void)\r
-{\r
- return PyErr_SetFromErrno(PyExc_OSError);\r
-}\r
-static PyObject *\r
-posix_error_with_filename(char* name)\r
-{\r
- return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);\r
-}\r
-\r
-#ifdef MS_WINDOWS\r
-static PyObject *\r
-posix_error_with_unicode_filename(Py_UNICODE* name)\r
-{\r
- return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError, name);\r
-}\r
-#endif /* MS_WINDOWS */\r
-\r
-\r
-static PyObject *\r
-posix_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
-#ifdef MS_WINDOWS\r
-static PyObject *\r
-win32_error(char* function, char* filename)\r
-{\r
- /* XXX We should pass the function name along in the future.\r
- (_winreg.c also wants to pass the function name.)\r
- This would however require an additional param to the\r
- Windows error object, which is non-trivial.\r
- */\r
- errno = GetLastError();\r
- if (filename)\r
- return PyErr_SetFromWindowsErrWithFilename(errno, filename);\r
- else\r
- return PyErr_SetFromWindowsErr(errno);\r
-}\r
-\r
-static PyObject *\r
-win32_error_unicode(char* function, Py_UNICODE* filename)\r
-{\r
- /* XXX - see win32_error for comments on 'function' */\r
- errno = GetLastError();\r
- if (filename)\r
- return PyErr_SetFromWindowsErrWithUnicodeFilename(errno, filename);\r
- else\r
- return PyErr_SetFromWindowsErr(errno);\r
-}\r
-\r
-static int\r
-convert_to_unicode(PyObject **param)\r
-{\r
- if (PyUnicode_CheckExact(*param))\r
- Py_INCREF(*param);\r
- else if (PyUnicode_Check(*param))\r
- /* For a Unicode subtype that's not a Unicode object,\r
- return a true Unicode object with the same data. */\r
- *param = PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(*param),\r
- PyUnicode_GET_SIZE(*param));\r
- else\r
- *param = PyUnicode_FromEncodedObject(*param,\r
- Py_FileSystemDefaultEncoding,\r
- "strict");\r
- return (*param) != NULL;\r
-}\r
-\r
-#endif /* MS_WINDOWS */\r
-\r
-#if defined(PYOS_OS2)\r
-/**********************************************************************\r
- * Helper Function to Trim and Format OS/2 Messages\r
- **********************************************************************/\r
-static void\r
-os2_formatmsg(char *msgbuf, int msglen, char *reason)\r
-{\r
- msgbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */\r
-\r
- if (strlen(msgbuf) > 0) { /* If Non-Empty Msg, Trim CRLF */\r
- char *lastc = &msgbuf[ strlen(msgbuf)-1 ];\r
-\r
- while (lastc > msgbuf && isspace(Py_CHARMASK(*lastc)))\r
- *lastc-- = '\0'; /* Trim Trailing Whitespace (CRLF) */\r
- }\r
-\r
- /* Add Optional Reason Text */\r
- if (reason) {\r
- strcat(msgbuf, " : ");\r
- strcat(msgbuf, reason);\r
- }\r
-}\r
-\r
-/**********************************************************************\r
- * Decode an OS/2 Operating System Error Code\r
- *\r
- * A convenience function to lookup an OS/2 error code and return a\r
- * text message we can use to raise a Python exception.\r
- *\r
- * Notes:\r
- * The messages for errors returned from the OS/2 kernel reside in\r
- * the file OSO001.MSG in the \OS2 directory hierarchy.\r
- *\r
- **********************************************************************/\r
-static char *\r
-os2_strerror(char *msgbuf, int msgbuflen, int errorcode, char *reason)\r
-{\r
- APIRET rc;\r
- ULONG msglen;\r
-\r
- /* Retrieve Kernel-Related Error Message from OSO001.MSG File */\r
- Py_BEGIN_ALLOW_THREADS\r
- rc = DosGetMessage(NULL, 0, msgbuf, msgbuflen,\r
- errorcode, "oso001.msg", &msglen);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (rc == NO_ERROR)\r
- os2_formatmsg(msgbuf, msglen, reason);\r
- else\r
- PyOS_snprintf(msgbuf, msgbuflen,\r
- "unknown OS error #%d", errorcode);\r
-\r
- return msgbuf;\r
-}\r
-\r
-/* Set an OS/2-specific error and return NULL. OS/2 kernel\r
- errors are not in a global variable e.g. 'errno' nor are\r
- they congruent with posix error numbers. */\r
-\r
-static PyObject *\r
-os2_error(int code)\r
-{\r
- char text[1024];\r
- PyObject *v;\r
-\r
- os2_strerror(text, sizeof(text), code, "");\r
-\r
- v = Py_BuildValue("(is)", code, text);\r
- if (v != NULL) {\r
- PyErr_SetObject(PyExc_OSError, v);\r
- Py_DECREF(v);\r
- }\r
- return NULL; /* Signal to Python that an Exception is Pending */\r
-}\r
-\r
-#endif /* OS2 */\r
-\r
-/* POSIX generic methods */\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = (*func)(fd);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-static PyObject *\r
-posix_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 posix_error_with_allocated_filename(path1);\r
- PyMem_Free(path1);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-#ifdef MS_WINDOWS\r
-static PyObject*\r
-win32_1str(PyObject* args, char* func,\r
- char* format, BOOL (__stdcall *funcA)(LPCSTR),\r
- char* wformat, BOOL (__stdcall *funcW)(LPWSTR))\r
-{\r
- PyObject *uni;\r
- char *ansi;\r
- BOOL result;\r
-\r
- if (!PyArg_ParseTuple(args, wformat, &uni))\r
- PyErr_Clear();\r
- else {\r
- Py_BEGIN_ALLOW_THREADS\r
- result = funcW(PyUnicode_AsUnicode(uni));\r
- Py_END_ALLOW_THREADS\r
- if (!result)\r
- return win32_error_unicode(func, PyUnicode_AsUnicode(uni));\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- if (!PyArg_ParseTuple(args, format, &ansi))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- result = funcA(ansi);\r
- Py_END_ALLOW_THREADS\r
- if (!result)\r
- return win32_error(func, ansi);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-\r
-}\r
-\r
-/* This is a reimplementation of the C library's chdir function,\r
- but one that produces Win32 errors instead of DOS error codes.\r
- chdir is essentially a wrapper around SetCurrentDirectory; however,\r
- it also needs to set "magic" environment variables indicating\r
- the per-drive current directory, which are of the form =<drive>: */\r
-static BOOL __stdcall\r
-win32_chdir(LPCSTR path)\r
-{\r
- char new_path[MAX_PATH+1];\r
- int result;\r
- char env[4] = "=x:";\r
-\r
- if(!SetCurrentDirectoryA(path))\r
- return FALSE;\r
- result = GetCurrentDirectoryA(MAX_PATH+1, new_path);\r
- if (!result)\r
- return FALSE;\r
- /* In the ANSI API, there should not be any paths longer\r
- than MAX_PATH. */\r
- assert(result <= MAX_PATH+1);\r
- if (strncmp(new_path, "\\\\", 2) == 0 ||\r
- strncmp(new_path, "//", 2) == 0)\r
- /* UNC path, nothing to do. */\r
- return TRUE;\r
- env[1] = new_path[0];\r
- return SetEnvironmentVariableA(env, new_path);\r
-}\r
-\r
-/* The Unicode version differs from the ANSI version\r
- since the current directory might exceed MAX_PATH characters */\r
-static BOOL __stdcall\r
-win32_wchdir(LPCWSTR path)\r
-{\r
- wchar_t _new_path[MAX_PATH+1], *new_path = _new_path;\r
- int result;\r
- wchar_t env[4] = L"=x:";\r
-\r
- if(!SetCurrentDirectoryW(path))\r
- return FALSE;\r
- result = GetCurrentDirectoryW(MAX_PATH+1, new_path);\r
- if (!result)\r
- return FALSE;\r
- if (result > MAX_PATH+1) {\r
- new_path = malloc(result * sizeof(wchar_t));\r
- if (!new_path) {\r
- SetLastError(ERROR_OUTOFMEMORY);\r
- return FALSE;\r
- }\r
- result = GetCurrentDirectoryW(result, new_path);\r
- if (!result) {\r
- free(new_path);\r
- return FALSE;\r
- }\r
- }\r
- if (wcsncmp(new_path, L"\\\\", 2) == 0 ||\r
- wcsncmp(new_path, L"//", 2) == 0)\r
- /* UNC path, nothing to do. */\r
- return TRUE;\r
- env[1] = new_path[0];\r
- result = SetEnvironmentVariableW(env, new_path);\r
- if (new_path != _new_path)\r
- free(new_path);\r
- return result;\r
-}\r
-#endif\r
-\r
-#ifdef MS_WINDOWS\r
-/* The CRT of Windows has a number of flaws wrt. its stat() implementation:\r
- - time stamps are restricted to second resolution\r
- - file modification times suffer from forth-and-back conversions between\r
- UTC and local time\r
- Therefore, we implement our own stat, based on the Win32 API directly.\r
-*/\r
-#define HAVE_STAT_NSEC 1\r
-\r
-struct win32_stat{\r
- int st_dev;\r
- __int64 st_ino;\r
- unsigned short st_mode;\r
- int st_nlink;\r
- int st_uid;\r
- int st_gid;\r
- int st_rdev;\r
- __int64 st_size;\r
- time_t st_atime;\r
- int st_atime_nsec;\r
- time_t st_mtime;\r
- int st_mtime_nsec;\r
- time_t st_ctime;\r
- int st_ctime_nsec;\r
-};\r
-\r
-static __int64 secs_between_epochs = 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */\r
-\r
-static void\r
-FILE_TIME_to_time_t_nsec(FILETIME *in_ptr, time_t *time_out, int* nsec_out)\r
-{\r
- /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */\r
- /* Cannot simply cast and dereference in_ptr,\r
- since it might not be aligned properly */\r
- __int64 in;\r
- memcpy(&in, in_ptr, sizeof(in));\r
- *nsec_out = (int)(in % 10000000) * 100; /* FILETIME is in units of 100 nsec. */\r
- *time_out = Py_SAFE_DOWNCAST((in / 10000000) - secs_between_epochs, __int64, time_t);\r
-}\r
-\r
-static void\r
-time_t_to_FILE_TIME(time_t time_in, int nsec_in, FILETIME *out_ptr)\r
-{\r
- /* XXX endianness */\r
- __int64 out;\r
- out = time_in + secs_between_epochs;\r
- out = out * 10000000 + nsec_in / 100;\r
- memcpy(out_ptr, &out, sizeof(out));\r
-}\r
-\r
-/* Below, we *know* that ugo+r is 0444 */\r
-#if _S_IREAD != 0400\r
-#error Unsupported C library\r
-#endif\r
-static int\r
-attributes_to_mode(DWORD attr)\r
-{\r
- int m = 0;\r
- if (attr & FILE_ATTRIBUTE_DIRECTORY)\r
- m |= _S_IFDIR | 0111; /* IFEXEC for user,group,other */\r
- else\r
- m |= _S_IFREG;\r
- if (attr & FILE_ATTRIBUTE_READONLY)\r
- m |= 0444;\r
- else\r
- m |= 0666;\r
- return m;\r
-}\r
-\r
-static int\r
-attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA *info, struct win32_stat *result)\r
-{\r
- memset(result, 0, sizeof(*result));\r
- result->st_mode = attributes_to_mode(info->dwFileAttributes);\r
- result->st_size = (((__int64)info->nFileSizeHigh)<<32) + info->nFileSizeLow;\r
- FILE_TIME_to_time_t_nsec(&info->ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);\r
- FILE_TIME_to_time_t_nsec(&info->ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);\r
- FILE_TIME_to_time_t_nsec(&info->ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);\r
-\r
- return 0;\r
-}\r
-\r
-static BOOL\r
-attributes_from_dir(LPCSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)\r
-{\r
- HANDLE hFindFile;\r
- WIN32_FIND_DATAA FileData;\r
- hFindFile = FindFirstFileA(pszFile, &FileData);\r
- if (hFindFile == INVALID_HANDLE_VALUE)\r
- return FALSE;\r
- FindClose(hFindFile);\r
- pfad->dwFileAttributes = FileData.dwFileAttributes;\r
- pfad->ftCreationTime = FileData.ftCreationTime;\r
- pfad->ftLastAccessTime = FileData.ftLastAccessTime;\r
- pfad->ftLastWriteTime = FileData.ftLastWriteTime;\r
- pfad->nFileSizeHigh = FileData.nFileSizeHigh;\r
- pfad->nFileSizeLow = FileData.nFileSizeLow;\r
- return TRUE;\r
-}\r
-\r
-static BOOL\r
-attributes_from_dir_w(LPCWSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)\r
-{\r
- HANDLE hFindFile;\r
- WIN32_FIND_DATAW FileData;\r
- hFindFile = FindFirstFileW(pszFile, &FileData);\r
- if (hFindFile == INVALID_HANDLE_VALUE)\r
- return FALSE;\r
- FindClose(hFindFile);\r
- pfad->dwFileAttributes = FileData.dwFileAttributes;\r
- pfad->ftCreationTime = FileData.ftCreationTime;\r
- pfad->ftLastAccessTime = FileData.ftLastAccessTime;\r
- pfad->ftLastWriteTime = FileData.ftLastWriteTime;\r
- pfad->nFileSizeHigh = FileData.nFileSizeHigh;\r
- pfad->nFileSizeLow = FileData.nFileSizeLow;\r
- return TRUE;\r
-}\r
-\r
-static int\r
-win32_stat(const char* path, struct win32_stat *result)\r
-{\r
- WIN32_FILE_ATTRIBUTE_DATA info;\r
- int code;\r
- char *dot;\r
- if (!GetFileAttributesExA(path, GetFileExInfoStandard, &info)) {\r
- if (GetLastError() != ERROR_SHARING_VIOLATION) {\r
- /* Protocol violation: we explicitly clear errno, instead of\r
- setting it to a POSIX error. Callers should use GetLastError. */\r
- errno = 0;\r
- return -1;\r
- } else {\r
- /* Could not get attributes on open file. Fall back to\r
- reading the directory. */\r
- if (!attributes_from_dir(path, &info)) {\r
- /* Very strange. This should not fail now */\r
- errno = 0;\r
- return -1;\r
- }\r
- }\r
- }\r
- code = attribute_data_to_stat(&info, result);\r
- if (code != 0)\r
- return code;\r
- /* Set S_IFEXEC if it is an .exe, .bat, ... */\r
- dot = strrchr(path, '.');\r
- if (dot) {\r
- if (stricmp(dot, ".bat") == 0 ||\r
- stricmp(dot, ".cmd") == 0 ||\r
- stricmp(dot, ".exe") == 0 ||\r
- stricmp(dot, ".com") == 0)\r
- result->st_mode |= 0111;\r
- }\r
- return code;\r
-}\r
-\r
-static int\r
-win32_wstat(const wchar_t* path, struct win32_stat *result)\r
-{\r
- int code;\r
- const wchar_t *dot;\r
- WIN32_FILE_ATTRIBUTE_DATA info;\r
- if (!GetFileAttributesExW(path, GetFileExInfoStandard, &info)) {\r
- if (GetLastError() != ERROR_SHARING_VIOLATION) {\r
- /* Protocol violation: we explicitly clear errno, instead of\r
- setting it to a POSIX error. Callers should use GetLastError. */\r
- errno = 0;\r
- return -1;\r
- } else {\r
- /* Could not get attributes on open file. Fall back to\r
- reading the directory. */\r
- if (!attributes_from_dir_w(path, &info)) {\r
- /* Very strange. This should not fail now */\r
- errno = 0;\r
- return -1;\r
- }\r
- }\r
- }\r
- code = attribute_data_to_stat(&info, result);\r
- if (code < 0)\r
- return code;\r
- /* Set IFEXEC if it is an .exe, .bat, ... */\r
- dot = wcsrchr(path, '.');\r
- if (dot) {\r
- if (_wcsicmp(dot, L".bat") == 0 ||\r
- _wcsicmp(dot, L".cmd") == 0 ||\r
- _wcsicmp(dot, L".exe") == 0 ||\r
- _wcsicmp(dot, L".com") == 0)\r
- result->st_mode |= 0111;\r
- }\r
- return code;\r
-}\r
-\r
-static int\r
-win32_fstat(int file_number, struct win32_stat *result)\r
-{\r
- BY_HANDLE_FILE_INFORMATION info;\r
- HANDLE h;\r
- int type;\r
-\r
- h = (HANDLE)_get_osfhandle(file_number);\r
-\r
- /* Protocol violation: we explicitly clear errno, instead of\r
- setting it to a POSIX error. Callers should use GetLastError. */\r
- errno = 0;\r
-\r
- if (h == INVALID_HANDLE_VALUE) {\r
- /* This is really a C library error (invalid file handle).\r
- We set the Win32 error to the closes one matching. */\r
- SetLastError(ERROR_INVALID_HANDLE);\r
- return -1;\r
- }\r
- memset(result, 0, sizeof(*result));\r
-\r
- type = GetFileType(h);\r
- if (type == FILE_TYPE_UNKNOWN) {\r
- DWORD error = GetLastError();\r
- if (error != 0) {\r
- return -1;\r
- }\r
- /* else: valid but unknown file */\r
- }\r
-\r
- if (type != FILE_TYPE_DISK) {\r
- if (type == FILE_TYPE_CHAR)\r
- result->st_mode = _S_IFCHR;\r
- else if (type == FILE_TYPE_PIPE)\r
- result->st_mode = _S_IFIFO;\r
- return 0;\r
- }\r
-\r
- if (!GetFileInformationByHandle(h, &info)) {\r
- return -1;\r
- }\r
-\r
- /* similar to stat() */\r
- result->st_mode = attributes_to_mode(info.dwFileAttributes);\r
- result->st_size = (((__int64)info.nFileSizeHigh)<<32) + info.nFileSizeLow;\r
- FILE_TIME_to_time_t_nsec(&info.ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);\r
- FILE_TIME_to_time_t_nsec(&info.ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);\r
- FILE_TIME_to_time_t_nsec(&info.ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);\r
- /* specific to fstat() */\r
- result->st_nlink = info.nNumberOfLinks;\r
- result->st_ino = (((__int64)info.nFileIndexHigh)<<32) + info.nFileIndexLow;\r
- return 0;\r
-}\r
-\r
-#endif /* MS_WINDOWS */\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 13\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
-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 int initialized;\r
-static PyTypeObject StatResultType;\r
-static PyTypeObject StatVFSResultType;\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
-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
- 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
-\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 posix_stat() and posix_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
-#ifdef HAVE_LARGEFILE_SUPPORT\r
- PyStructSequence_SET_ITEM(v, 1,\r
- PyLong_FromLongLong((PY_LONG_LONG)st->st_ino));\r
-#else\r
- PyStructSequence_SET_ITEM(v, 1, PyInt_FromLong((long)st->st_ino));\r
-#endif\r
-#if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)\r
- PyStructSequence_SET_ITEM(v, 2,\r
- PyLong_FromLongLong((PY_LONG_LONG)st->st_dev));\r
-#else\r
- PyStructSequence_SET_ITEM(v, 2, PyInt_FromLong((long)st->st_dev));\r
-#endif\r
- PyStructSequence_SET_ITEM(v, 3, PyInt_FromLong((long)st->st_nlink));\r
- PyStructSequence_SET_ITEM(v, 4, PyInt_FromLong((long)st->st_uid));\r
- PyStructSequence_SET_ITEM(v, 5, PyInt_FromLong((long)st->st_gid));\r
-#ifdef HAVE_LARGEFILE_SUPPORT\r
- PyStructSequence_SET_ITEM(v, 6,\r
- PyLong_FromLongLong((PY_LONG_LONG)st->st_size));\r
-#else\r
- PyStructSequence_SET_ITEM(v, 6, PyInt_FromLong(st->st_size));\r
-#endif\r
-\r
-#if defined(HAVE_STAT_TV_NSEC)\r
- ansec = st->st_atim.tv_nsec;\r
- mnsec = st->st_mtim.tv_nsec;\r
- cnsec = st->st_ctim.tv_nsec;\r
-#elif defined(HAVE_STAT_TV_NSEC2)\r
- ansec = st->st_atimespec.tv_nsec;\r
- mnsec = st->st_mtimespec.tv_nsec;\r
- cnsec = st->st_ctimespec.tv_nsec;\r
-#elif defined(HAVE_STAT_NSEC)\r
- ansec = st->st_atime_nsec;\r
- mnsec = st->st_mtime_nsec;\r
- cnsec = st->st_ctime_nsec;\r
-#else\r
- ansec = mnsec = cnsec = 0;\r
-#endif\r
- fill_time(v, 7, st->st_atime, ansec);\r
- fill_time(v, 8, st->st_mtime, mnsec);\r
- fill_time(v, 9, st->st_ctime, 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
-#ifdef MS_WINDOWS\r
-\r
-/* IsUNCRoot -- test whether the supplied path is of the form \\SERVER\SHARE\,\r
- where / can be used in place of \ and the trailing slash is optional.\r
- Both SERVER and SHARE must have at least one character.\r
-*/\r
-\r
-#define ISSLASHA(c) ((c) == '\\' || (c) == '/')\r
-#define ISSLASHW(c) ((c) == L'\\' || (c) == L'/')\r
-#ifndef ARRAYSIZE\r
-#define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))\r
-#endif\r
-\r
-static BOOL\r
-IsUNCRootA(char *path, int pathlen)\r
-{\r
- #define ISSLASH ISSLASHA\r
-\r
- int i, share;\r
-\r
- if (pathlen < 5 || !ISSLASH(path[0]) || !ISSLASH(path[1]))\r
- /* minimum UNCRoot is \\x\y */\r
- return FALSE;\r
- for (i = 2; i < pathlen ; i++)\r
- if (ISSLASH(path[i])) break;\r
- if (i == 2 || i == pathlen)\r
- /* do not allow \\\SHARE or \\SERVER */\r
- return FALSE;\r
- share = i+1;\r
- for (i = share; i < pathlen; i++)\r
- if (ISSLASH(path[i])) break;\r
- return (i != share && (i == pathlen || i == pathlen-1));\r
-\r
- #undef ISSLASH\r
-}\r
-\r
-static BOOL\r
-IsUNCRootW(Py_UNICODE *path, int pathlen)\r
-{\r
- #define ISSLASH ISSLASHW\r
-\r
- int i, share;\r
-\r
- if (pathlen < 5 || !ISSLASH(path[0]) || !ISSLASH(path[1]))\r
- /* minimum UNCRoot is \\x\y */\r
- return FALSE;\r
- for (i = 2; i < pathlen ; i++)\r
- if (ISSLASH(path[i])) break;\r
- if (i == 2 || i == pathlen)\r
- /* do not allow \\\SHARE or \\SERVER */\r
- return FALSE;\r
- share = i+1;\r
- for (i = share; i < pathlen; i++)\r
- if (ISSLASH(path[i])) break;\r
- return (i != share && (i == pathlen || i == pathlen-1));\r
-\r
- #undef ISSLASH\r
-}\r
-#endif /* MS_WINDOWS */\r
-\r
-static PyObject *\r
-posix_do_stat(PyObject *self, PyObject *args,\r
- char *format,\r
-#ifdef __VMS\r
- int (*statfunc)(const char *, STRUCT_STAT *, ...),\r
-#else\r
- int (*statfunc)(const char *, STRUCT_STAT *),\r
-#endif\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
-#ifdef MS_WINDOWS\r
- PyUnicodeObject *po;\r
- if (PyArg_ParseTuple(args, wformat, &po)) {\r
- Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- /* PyUnicode_AS_UNICODE result OK without\r
- thread lock as it is a simple dereference. */\r
- res = wstatfunc(wpath, &st);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (res != 0)\r
- return win32_error_unicode("stat", wpath);\r
- return _pystat_fromstructstat(&st);\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
-#endif\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
-#ifdef MS_WINDOWS\r
- result = win32_error("stat", pathfree);\r
-#else\r
- result = posix_error_with_filename(pathfree);\r
-#endif\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(posix_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
-posix_access(PyObject *self, PyObject *args)\r
-{\r
- char *path;\r
- int mode;\r
-\r
-#ifdef MS_WINDOWS\r
- DWORD attr;\r
- PyUnicodeObject *po;\r
- if (PyArg_ParseTuple(args, "Ui:access", &po, &mode)) {\r
- Py_BEGIN_ALLOW_THREADS\r
- /* PyUnicode_AS_UNICODE OK without thread lock as\r
- it is a simple dereference. */\r
- attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));\r
- Py_END_ALLOW_THREADS\r
- goto finish;\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
- if (!PyArg_ParseTuple(args, "eti:access",\r
- Py_FileSystemDefaultEncoding, &path, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- attr = GetFileAttributesA(path);\r
- Py_END_ALLOW_THREADS\r
- PyMem_Free(path);\r
-finish:\r
- if (attr == 0xFFFFFFFF)\r
- /* File does not exist, or cannot read attributes */\r
- return PyBool_FromLong(0);\r
- /* Access is possible if either write access wasn't requested, or\r
- the file isn't read-only, or if it's a directory, as there are\r
- no read-only directories on Windows. */\r
- return PyBool_FromLong(!(mode & 2)\r
- || !(attr & FILE_ATTRIBUTE_READONLY)\r
- || (attr & FILE_ATTRIBUTE_DIRECTORY));\r
-#else /* MS_WINDOWS */\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
-#endif /* MS_WINDOWS */\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
-#ifdef HAVE_TTYNAME\r
-PyDoc_STRVAR(posix_ttyname__doc__,\r
-"ttyname(fd) -> string\n\n\\r
-Return the name of the terminal device connected to 'fd'.");\r
-\r
-static PyObject *\r
-posix_ttyname(PyObject *self, PyObject *args)\r
-{\r
- int id;\r
- char *ret;\r
-\r
- if (!PyArg_ParseTuple(args, "i:ttyname", &id))\r
- return NULL;\r
-\r
-#if defined(__VMS)\r
- /* file descriptor 0 only, the default input device (stdin) */\r
- if (id == 0) {\r
- ret = ttyname();\r
- }\r
- else {\r
- ret = NULL;\r
- }\r
-#else\r
- ret = ttyname(id);\r
-#endif\r
- if (ret == NULL)\r
- return posix_error();\r
- return PyString_FromString(ret);\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_CTERMID\r
-PyDoc_STRVAR(posix_ctermid__doc__,\r
-"ctermid() -> string\n\n\\r
-Return the name of the controlling terminal for this process.");\r
-\r
-static PyObject *\r
-posix_ctermid(PyObject *self, PyObject *noargs)\r
-{\r
- char *ret;\r
- char buffer[L_ctermid];\r
-\r
-#ifdef USE_CTERMID_R\r
- ret = ctermid_r(buffer);\r
-#else\r
- ret = ctermid(buffer);\r
-#endif\r
- if (ret == NULL)\r
- return posix_error();\r
- return PyString_FromString(buffer);\r
-}\r
-#endif\r
-\r
-PyDoc_STRVAR(posix_chdir__doc__,\r
-"chdir(path)\n\n\\r
-Change the current working directory to the specified path.");\r
-\r
-static PyObject *\r
-posix_chdir(PyObject *self, PyObject *args)\r
-{\r
-#ifdef MS_WINDOWS\r
- return win32_1str(args, "chdir", "s:chdir", win32_chdir, "U:chdir", win32_wchdir);\r
-#elif defined(PYOS_OS2) && defined(PYCC_GCC)\r
- return posix_1str(args, "et:chdir", _chdir2);\r
-#elif defined(__VMS)\r
- return posix_1str(args, "et:chdir", (int (*)(const char *))chdir);\r
-#else\r
- return posix_1str(args, "et:chdir", chdir);\r
-#endif\r
-}\r
-\r
-#ifdef HAVE_FCHDIR\r
-PyDoc_STRVAR(posix_fchdir__doc__,\r
-"fchdir(fildes)\n\n\\r
-Change to the directory of the given file descriptor. fildes must be\n\\r
-opened on a directory, not a file.");\r
-\r
-static PyObject *\r
-posix_fchdir(PyObject *self, PyObject *fdobj)\r
-{\r
- return posix_fildes(fdobj, fchdir);\r
-}\r
-#endif /* HAVE_FCHDIR */\r
-\r
-\r
-PyDoc_STRVAR(posix_chmod__doc__,\r
-"chmod(path, mode)\n\n\\r
-Change the access permissions of a file.");\r
-\r
-static PyObject *\r
-posix_chmod(PyObject *self, PyObject *args)\r
-{\r
- char *path = NULL;\r
- int i;\r
- int res;\r
-#ifdef MS_WINDOWS\r
- DWORD attr;\r
- PyUnicodeObject *po;\r
- if (PyArg_ParseTuple(args, "Ui|:chmod", &po, &i)) {\r
- Py_BEGIN_ALLOW_THREADS\r
- attr = GetFileAttributesW(PyUnicode_AS_UNICODE(po));\r
- if (attr != 0xFFFFFFFF) {\r
- if (i & _S_IWRITE)\r
- attr &= ~FILE_ATTRIBUTE_READONLY;\r
- else\r
- attr |= FILE_ATTRIBUTE_READONLY;\r
- res = SetFileAttributesW(PyUnicode_AS_UNICODE(po), attr);\r
- }\r
- else\r
- res = 0;\r
- Py_END_ALLOW_THREADS\r
- if (!res)\r
- return win32_error_unicode("chmod",\r
- PyUnicode_AS_UNICODE(po));\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
-\r
- if (!PyArg_ParseTuple(args, "eti:chmod", Py_FileSystemDefaultEncoding,\r
- &path, &i))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- attr = GetFileAttributesA(path);\r
- if (attr != 0xFFFFFFFF) {\r
- if (i & _S_IWRITE)\r
- attr &= ~FILE_ATTRIBUTE_READONLY;\r
- else\r
- attr |= FILE_ATTRIBUTE_READONLY;\r
- res = SetFileAttributesA(path, attr);\r
- }\r
- else\r
- res = 0;\r
- Py_END_ALLOW_THREADS\r
- if (!res) {\r
- win32_error("chmod", path);\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-#else /* MS_WINDOWS */\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 posix_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-#endif\r
-}\r
-\r
-#ifdef HAVE_FCHMOD\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_error();\r
- Py_RETURN_NONE;\r
-}\r
-#endif /* HAVE_FCHMOD */\r
-\r
-#ifdef HAVE_LCHMOD\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_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(posix_chflags__doc__,\r
-"chflags(path, flags)\n\n\\r
-Set file flags.");\r
-\r
-static PyObject *\r
-posix_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 posix_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(posix_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
-posix_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 posix_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(posix_chroot__doc__,\r
-"chroot(path)\n\n\\r
-Change root directory to path.");\r
-\r
-static PyObject *\r
-posix_chroot(PyObject *self, PyObject *args)\r
-{\r
- return posix_1str(args, "et:chroot", chroot);\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_FSYNC\r
-PyDoc_STRVAR(posix_fsync__doc__,\r
-"fsync(fildes)\n\n\\r
-force write of file with filedescriptor to disk.");\r
-\r
-static PyObject *\r
-posix_fsync(PyObject *self, PyObject *fdobj)\r
-{\r
- return posix_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(posix_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
-posix_fdatasync(PyObject *self, PyObject *fdobj)\r
-{\r
- return posix_fildes(fdobj, fdatasync);\r
-}\r
-#endif /* HAVE_FDATASYNC */\r
-\r
-\r
-#ifdef HAVE_CHOWN\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_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(posix_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
-posix_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 posix_error();\r
- Py_RETURN_NONE;\r
-}\r
-#endif /* HAVE_FCHOWN */\r
-\r
-#ifdef HAVE_LCHOWN\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_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(posix_getcwd__doc__,\r
-"getcwd() -> path\n\n\\r
-Return a string representing the current working directory.");\r
-\r
-#if (defined(__sun) && defined(__SVR4)) || defined(__OpenBSD__)\r
-/* Issue 9185: getcwd() returns NULL/ERANGE indefinitely. */\r
-static PyObject *\r
-posix_getcwd(PyObject *self, PyObject *noargs)\r
-{\r
- char buf[PATH_MAX+2];\r
- char *res;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = getcwd(buf, sizeof buf);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (res == NULL)\r
- return posix_error();\r
-\r
- return PyString_FromString(buf);\r
-}\r
-#else\r
-static PyObject *\r
-posix_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
-#if defined(PYOS_OS2) && defined(PYCC_GCC)\r
- res = _getcwd2(tmpbuf, bufsize);\r
-#else\r
- res = getcwd(tmpbuf, bufsize);\r
-#endif\r
-\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 posix_error();\r
-\r
- dynamic_return = PyString_FromString(tmpbuf);\r
- free(tmpbuf);\r
-\r
- return dynamic_return;\r
-}\r
-#endif /* getcwd() NULL/ERANGE workaround. */\r
-\r
-#ifdef Py_USING_UNICODE\r
-PyDoc_STRVAR(posix_getcwdu__doc__,\r
-"getcwdu() -> path\n\n\\r
-Return a unicode string representing the current working directory.");\r
-\r
-static PyObject *\r
-posix_getcwdu(PyObject *self, PyObject *noargs)\r
-{\r
- char buf[1026];\r
- char *res;\r
-\r
-#ifdef MS_WINDOWS\r
- DWORD len;\r
- wchar_t wbuf[1026];\r
- wchar_t *wbuf2 = wbuf;\r
- PyObject *resobj;\r
- Py_BEGIN_ALLOW_THREADS\r
- len = GetCurrentDirectoryW(sizeof wbuf/ sizeof wbuf[0], wbuf);\r
- /* If the buffer is large enough, len does not include the\r
- terminating \0. If the buffer is too small, len includes\r
- the space needed for the terminator. */\r
- if (len >= sizeof wbuf/ sizeof wbuf[0]) {\r
- wbuf2 = malloc(len * sizeof(wchar_t));\r
- if (wbuf2)\r
- len = GetCurrentDirectoryW(len, wbuf2);\r
- }\r
- Py_END_ALLOW_THREADS\r
- if (!wbuf2) {\r
- PyErr_NoMemory();\r
- return NULL;\r
- }\r
- if (!len) {\r
- if (wbuf2 != wbuf) free(wbuf2);\r
- return win32_error("getcwdu", NULL);\r
- }\r
- resobj = PyUnicode_FromWideChar(wbuf2, len);\r
- if (wbuf2 != wbuf) free(wbuf2);\r
- return resobj;\r
-#endif /* MS_WINDOWS */\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
-#if defined(PYOS_OS2) && defined(PYCC_GCC)\r
- res = _getcwd2(buf, sizeof buf);\r
-#else\r
- res = getcwd(buf, sizeof buf);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
- if (res == NULL)\r
- return posix_error();\r
- return PyUnicode_Decode(buf, strlen(buf), Py_FileSystemDefaultEncoding,"strict");\r
-}\r
-#endif /* Py_USING_UNICODE */\r
-#endif /* HAVE_GETCWD */\r
-\r
-\r
-#ifdef HAVE_LINK\r
-PyDoc_STRVAR(posix_link__doc__,\r
-"link(src, dst)\n\n\\r
-Create a hard link to a file.");\r
-\r
-static PyObject *\r
-posix_link(PyObject *self, PyObject *args)\r
-{\r
- return posix_2str(args, "etet:link", link);\r
-}\r
-#endif /* HAVE_LINK */\r
-\r
-\r
-PyDoc_STRVAR(posix_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
-posix_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
-#if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)\r
-\r
- PyObject *d, *v;\r
- HANDLE hFindFile;\r
- BOOL result;\r
- WIN32_FIND_DATA FileData;\r
- char namebuf[MAX_PATH+5]; /* Overallocate for \\*.*\0 */\r
- char *bufptr = namebuf;\r
- Py_ssize_t len = sizeof(namebuf)-5; /* only claim to have space for MAX_PATH */\r
-\r
- PyObject *po;\r
- if (PyArg_ParseTuple(args, "U:listdir", &po)) {\r
- WIN32_FIND_DATAW wFileData;\r
- Py_UNICODE *wnamebuf;\r
- /* Overallocate for \\*.*\0 */\r
- len = PyUnicode_GET_SIZE(po);\r
- wnamebuf = malloc((len + 5) * sizeof(wchar_t));\r
- if (!wnamebuf) {\r
- PyErr_NoMemory();\r
- return NULL;\r
- }\r
- wcscpy(wnamebuf, PyUnicode_AS_UNICODE(po));\r
- if (len > 0) {\r
- Py_UNICODE wch = wnamebuf[len-1];\r
- if (wch != L'/' && wch != L'\\' && wch != L':')\r
- wnamebuf[len++] = L'\\';\r
- wcscpy(wnamebuf + len, L"*.*");\r
- }\r
- if ((d = PyList_New(0)) == NULL) {\r
- free(wnamebuf);\r
- return NULL;\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- hFindFile = FindFirstFileW(wnamebuf, &wFileData);\r
- Py_END_ALLOW_THREADS\r
- if (hFindFile == INVALID_HANDLE_VALUE) {\r
- int error = GetLastError();\r
- if (error == ERROR_FILE_NOT_FOUND) {\r
- free(wnamebuf);\r
- return d;\r
- }\r
- Py_DECREF(d);\r
- win32_error_unicode("FindFirstFileW", wnamebuf);\r
- free(wnamebuf);\r
- return NULL;\r
- }\r
- do {\r
- /* Skip over . and .. */\r
- if (wcscmp(wFileData.cFileName, L".") != 0 &&\r
- wcscmp(wFileData.cFileName, L"..") != 0) {\r
- v = PyUnicode_FromUnicode(wFileData.cFileName, wcslen(wFileData.cFileName));\r
- if (v == NULL) {\r
- Py_DECREF(d);\r
- d = NULL;\r
- break;\r
- }\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
- result = FindNextFileW(hFindFile, &wFileData);\r
- Py_END_ALLOW_THREADS\r
- /* FindNextFile sets error to ERROR_NO_MORE_FILES if\r
- it got to the end of the directory. */\r
- if (!result && GetLastError() != ERROR_NO_MORE_FILES) {\r
- Py_DECREF(d);\r
- win32_error_unicode("FindNextFileW", wnamebuf);\r
- FindClose(hFindFile);\r
- free(wnamebuf);\r
- return NULL;\r
- }\r
- } while (result == TRUE);\r
-\r
- if (FindClose(hFindFile) == FALSE) {\r
- Py_DECREF(d);\r
- win32_error_unicode("FindClose", wnamebuf);\r
- free(wnamebuf);\r
- return NULL;\r
- }\r
- free(wnamebuf);\r
- return d;\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
-\r
- if (!PyArg_ParseTuple(args, "et#:listdir",\r
- Py_FileSystemDefaultEncoding, &bufptr, &len))\r
- return NULL;\r
- if (len > 0) {\r
- char ch = namebuf[len-1];\r
- if (ch != SEP && ch != ALTSEP && ch != ':')\r
- namebuf[len++] = '/';\r
- strcpy(namebuf + len, "*.*");\r
- }\r
-\r
- if ((d = PyList_New(0)) == NULL)\r
- return NULL;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- hFindFile = FindFirstFile(namebuf, &FileData);\r
- Py_END_ALLOW_THREADS\r
- if (hFindFile == INVALID_HANDLE_VALUE) {\r
- int error = GetLastError();\r
- if (error == ERROR_FILE_NOT_FOUND)\r
- return d;\r
- Py_DECREF(d);\r
- return win32_error("FindFirstFile", namebuf);\r
- }\r
- do {\r
- /* Skip over . and .. */\r
- if (strcmp(FileData.cFileName, ".") != 0 &&\r
- strcmp(FileData.cFileName, "..") != 0) {\r
- v = PyString_FromString(FileData.cFileName);\r
- if (v == NULL) {\r
- Py_DECREF(d);\r
- d = NULL;\r
- break;\r
- }\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
- result = FindNextFile(hFindFile, &FileData);\r
- Py_END_ALLOW_THREADS\r
- /* FindNextFile sets error to ERROR_NO_MORE_FILES if\r
- it got to the end of the directory. */\r
- if (!result && GetLastError() != ERROR_NO_MORE_FILES) {\r
- Py_DECREF(d);\r
- win32_error("FindNextFile", namebuf);\r
- FindClose(hFindFile);\r
- return NULL;\r
- }\r
- } while (result == TRUE);\r
-\r
- if (FindClose(hFindFile) == FALSE) {\r
- Py_DECREF(d);\r
- return win32_error("FindClose", namebuf);\r
- }\r
-\r
- return d;\r
-\r
-#elif defined(PYOS_OS2)\r
-\r
-#ifndef MAX_PATH\r
-#define MAX_PATH CCHMAXPATH\r
-#endif\r
- char *name, *pt;\r
- Py_ssize_t len;\r
- PyObject *d, *v;\r
- char namebuf[MAX_PATH+5];\r
- HDIR hdir = 1;\r
- ULONG srchcnt = 1;\r
- FILEFINDBUF3 ep;\r
- APIRET rc;\r
-\r
- if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len))\r
- return NULL;\r
- if (len >= MAX_PATH) {\r
- PyErr_SetString(PyExc_ValueError, "path too long");\r
- return NULL;\r
- }\r
- strcpy(namebuf, name);\r
- for (pt = namebuf; *pt; pt++)\r
- if (*pt == ALTSEP)\r
- *pt = SEP;\r
- if (namebuf[len-1] != SEP)\r
- namebuf[len++] = SEP;\r
- strcpy(namebuf + len, "*.*");\r
-\r
- if ((d = PyList_New(0)) == NULL)\r
- return NULL;\r
-\r
- rc = DosFindFirst(namebuf, /* Wildcard Pattern to Match */\r
- &hdir, /* Handle to Use While Search Directory */\r
- FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY,\r
- &ep, sizeof(ep), /* Structure to Receive Directory Entry */\r
- &srchcnt, /* Max and Actual Count of Entries Per Iteration */\r
- FIL_STANDARD); /* Format of Entry (EAs or Not) */\r
-\r
- if (rc != NO_ERROR) {\r
- errno = ENOENT;\r
- return posix_error_with_filename(name);\r
- }\r
-\r
- if (srchcnt > 0) { /* If Directory is NOT Totally Empty, */\r
- do {\r
- if (ep.achName[0] == '.'\r
- && (ep.achName[1] == '\0' || (ep.achName[1] == '.' && ep.achName[2] == '\0')))\r
- continue; /* Skip Over "." and ".." Names */\r
-\r
- strcpy(namebuf, ep.achName);\r
-\r
- /* Leave Case of Name Alone -- In Native Form */\r
- /* (Removed Forced Lowercasing Code) */\r
-\r
- v = PyString_FromString(namebuf);\r
- if (v == NULL) {\r
- Py_DECREF(d);\r
- d = NULL;\r
- break;\r
- }\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
- } while (DosFindNext(hdir, &ep, sizeof(ep), &srchcnt) == NO_ERROR && srchcnt > 0);\r
- }\r
-\r
- return d;\r
-#else\r
-\r
- char *name = NULL;\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 posix_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
- 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) {\r
- break;\r
- } else {\r
- Py_BEGIN_ALLOW_THREADS\r
- closedir(dirp);\r
- Py_END_ALLOW_THREADS\r
- Py_DECREF(d);\r
- return posix_error_with_allocated_filename(name);\r
- }\r
- }\r
- if (ep->d_name[0] == '.' &&\r
- (NAMLEN(ep) == 1 ||\r
- (ep->d_name[1] == '.' && NAMLEN(ep) == 2)))\r
- continue;\r
- v = PyString_FromStringAndSize(ep->d_name, NAMLEN(ep));\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
-\r
- return d;\r
-\r
-#endif /* which OS */\r
-} /* end of posix_listdir */\r
-\r
-#ifdef MS_WINDOWS\r
-/* A helper function for abspath on win32 */\r
-static PyObject *\r
-posix__getfullpathname(PyObject *self, PyObject *args)\r
-{\r
- /* assume encoded strings won't more than double no of chars */\r
- char inbuf[MAX_PATH*2];\r
- char *inbufp = inbuf;\r
- Py_ssize_t insize = sizeof(inbuf);\r
- char outbuf[MAX_PATH*2];\r
- char *temp;\r
-\r
- PyUnicodeObject *po;\r
- if (PyArg_ParseTuple(args, "U|:_getfullpathname", &po)) {\r
- Py_UNICODE *wpath = PyUnicode_AS_UNICODE(po);\r
- Py_UNICODE woutbuf[MAX_PATH*2], *woutbufp = woutbuf;\r
- Py_UNICODE *wtemp;\r
- DWORD result;\r
- PyObject *v;\r
- result = GetFullPathNameW(wpath,\r
- sizeof(woutbuf)/sizeof(woutbuf[0]),\r
- woutbuf, &wtemp);\r
- if (result > sizeof(woutbuf)/sizeof(woutbuf[0])) {\r
- woutbufp = malloc(result * sizeof(Py_UNICODE));\r
- if (!woutbufp)\r
- return PyErr_NoMemory();\r
- result = GetFullPathNameW(wpath, result, woutbufp, &wtemp);\r
- }\r
- if (result)\r
- v = PyUnicode_FromUnicode(woutbufp, wcslen(woutbufp));\r
- else\r
- v = win32_error_unicode("GetFullPathNameW", wpath);\r
- if (woutbufp != woutbuf)\r
- free(woutbufp);\r
- return v;\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
-\r
- if (!PyArg_ParseTuple (args, "et#:_getfullpathname",\r
- Py_FileSystemDefaultEncoding, &inbufp,\r
- &insize))\r
- return NULL;\r
- if (!GetFullPathName(inbuf, sizeof(outbuf)/sizeof(outbuf[0]),\r
- outbuf, &temp))\r
- return win32_error("GetFullPathName", inbuf);\r
- if (PyUnicode_Check(PyTuple_GetItem(args, 0))) {\r
- return PyUnicode_Decode(outbuf, strlen(outbuf),\r
- Py_FileSystemDefaultEncoding, NULL);\r
- }\r
- return PyString_FromString(outbuf);\r
-} /* end of posix__getfullpathname */\r
-#endif /* MS_WINDOWS */\r
-\r
-PyDoc_STRVAR(posix_mkdir__doc__,\r
-"mkdir(path [, mode=0777])\n\n\\r
-Create a directory.");\r
-\r
-static PyObject *\r
-posix_mkdir(PyObject *self, PyObject *args)\r
-{\r
- int res;\r
- char *path = NULL;\r
- int mode = 0777;\r
-\r
-#ifdef MS_WINDOWS\r
- PyUnicodeObject *po;\r
- if (PyArg_ParseTuple(args, "U|i:mkdir", &po, &mode)) {\r
- Py_BEGIN_ALLOW_THREADS\r
- /* PyUnicode_AS_UNICODE OK without thread lock as\r
- it is a simple dereference. */\r
- res = CreateDirectoryW(PyUnicode_AS_UNICODE(po), NULL);\r
- Py_END_ALLOW_THREADS\r
- if (!res)\r
- return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po));\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
- if (!PyArg_ParseTuple(args, "et|i:mkdir",\r
- Py_FileSystemDefaultEncoding, &path, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- /* PyUnicode_AS_UNICODE OK without thread lock as\r
- it is a simple dereference. */\r
- res = CreateDirectoryA(path, NULL);\r
- Py_END_ALLOW_THREADS\r
- if (!res) {\r
- win32_error("mkdir", path);\r
- PyMem_Free(path);\r
- return NULL;\r
- }\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-#else /* MS_WINDOWS */\r
-\r
- if (!PyArg_ParseTuple(args, "et|i:mkdir",\r
- Py_FileSystemDefaultEncoding, &path, &mode))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
-#if ( defined(__WATCOMC__) || defined(PYCC_VACPP) ) && !defined(__QNX__)\r
- res = mkdir(path);\r
-#else\r
- res = mkdir(path, mode);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_error_with_allocated_filename(path);\r
- PyMem_Free(path);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-#endif /* MS_WINDOWS */\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(posix_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
-posix_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 posix_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 posix_error();\r
- return PyInt_FromLong((long) value);\r
-}\r
-#endif /* HAVE_NICE */\r
-\r
-PyDoc_STRVAR(posix_rename__doc__,\r
-"rename(old, new)\n\n\\r
-Rename a file or directory.");\r
-\r
-static PyObject *\r
-posix_rename(PyObject *self, PyObject *args)\r
-{\r
-#ifdef MS_WINDOWS\r
- PyObject *o1, *o2;\r
- char *p1, *p2;\r
- BOOL result;\r
- if (!PyArg_ParseTuple(args, "OO:rename", &o1, &o2))\r
- goto error;\r
- if (!convert_to_unicode(&o1))\r
- goto error;\r
- if (!convert_to_unicode(&o2)) {\r
- Py_DECREF(o1);\r
- goto error;\r
- }\r
- Py_BEGIN_ALLOW_THREADS\r
- result = MoveFileW(PyUnicode_AsUnicode(o1),\r
- PyUnicode_AsUnicode(o2));\r
- Py_END_ALLOW_THREADS\r
- Py_DECREF(o1);\r
- Py_DECREF(o2);\r
- if (!result)\r
- return win32_error("rename", NULL);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-error:\r
- PyErr_Clear();\r
- if (!PyArg_ParseTuple(args, "ss:rename", &p1, &p2))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- result = MoveFileA(p1, p2);\r
- Py_END_ALLOW_THREADS\r
- if (!result)\r
- return win32_error("rename", NULL);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-#else\r
- return posix_2str(args, "etet:rename", rename);\r
-#endif\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_rmdir__doc__,\r
-"rmdir(path)\n\n\\r
-Remove a directory.");\r
-\r
-static PyObject *\r
-posix_rmdir(PyObject *self, PyObject *args)\r
-{\r
-#ifdef MS_WINDOWS\r
- return win32_1str(args, "rmdir", "s:rmdir", RemoveDirectoryA, "U:rmdir", RemoveDirectoryW);\r
-#else\r
- return posix_1str(args, "et:rmdir", rmdir);\r
-#endif\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_stat__doc__,\r
-"stat(path) -> stat result\n\n\\r
-Perform a stat system call on the given path.");\r
-\r
-static PyObject *\r
-posix_stat(PyObject *self, PyObject *args)\r
-{\r
-#ifdef MS_WINDOWS\r
- return posix_do_stat(self, args, "et:stat", STAT, "U:stat", win32_wstat);\r
-#else\r
- return posix_do_stat(self, args, "et:stat", STAT, NULL, NULL);\r
-#endif\r
-}\r
-\r
-\r
-#ifdef HAVE_SYSTEM\r
-PyDoc_STRVAR(posix_system__doc__,\r
-"system(command) -> exit_status\n\n\\r
-Execute the command (a string) in a subshell.");\r
-\r
-static PyObject *\r
-posix_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(posix_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
-posix_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 posix_error();\r
- return PyInt_FromLong((long)i);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_unlink__doc__,\r
-"unlink(path)\n\n\\r
-Remove a file (same as remove(path)).");\r
-\r
-PyDoc_STRVAR(posix_remove__doc__,\r
-"remove(path)\n\n\\r
-Remove a file (same as unlink(path)).");\r
-\r
-static PyObject *\r
-posix_unlink(PyObject *self, PyObject *args)\r
-{\r
-#ifdef MS_WINDOWS\r
- return win32_1str(args, "remove", "s:remove", DeleteFileA, "U:remove", DeleteFileW);\r
-#else\r
- return posix_1str(args, "et:remove", unlink);\r
-#endif\r
-}\r
-\r
-\r
-#ifdef HAVE_UNAME\r
-PyDoc_STRVAR(posix_uname__doc__,\r
-"uname() -> (sysname, nodename, release, version, machine)\n\n\\r
-Return a tuple identifying the current operating system.");\r
-\r
-static PyObject *\r
-posix_uname(PyObject *self, PyObject *noargs)\r
-{\r
- struct utsname u;\r
- int res;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- res = uname(&u);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_error();\r
- return Py_BuildValue("(sssss)",\r
- u.sysname,\r
- u.nodename,\r
- u.release,\r
- u.version,\r
- u.machine);\r
-}\r
-#endif /* HAVE_UNAME */\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(posix_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
-posix_utime(PyObject *self, PyObject *args)\r
-{\r
-#ifdef MS_WINDOWS\r
- PyObject *arg;\r
- PyUnicodeObject *obwpath;\r
- wchar_t *wpath = NULL;\r
- char *apath = NULL;\r
- HANDLE hFile;\r
- time_t atimesec, mtimesec;\r
- long ausec, musec;\r
- FILETIME atime, mtime;\r
- PyObject *result = NULL;\r
-\r
- if (PyArg_ParseTuple(args, "UO|:utime", &obwpath, &arg)) {\r
- wpath = PyUnicode_AS_UNICODE(obwpath);\r
- Py_BEGIN_ALLOW_THREADS\r
- hFile = CreateFileW(wpath, FILE_WRITE_ATTRIBUTES, 0,\r
- NULL, OPEN_EXISTING,\r
- FILE_FLAG_BACKUP_SEMANTICS, NULL);\r
- Py_END_ALLOW_THREADS\r
- if (hFile == INVALID_HANDLE_VALUE)\r
- return win32_error_unicode("utime", wpath);\r
- } else\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
-\r
- if (!wpath) {\r
- if (!PyArg_ParseTuple(args, "etO:utime",\r
- Py_FileSystemDefaultEncoding, &apath, &arg))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- hFile = CreateFileA(apath, FILE_WRITE_ATTRIBUTES, 0,\r
- NULL, OPEN_EXISTING,\r
- FILE_FLAG_BACKUP_SEMANTICS, NULL);\r
- Py_END_ALLOW_THREADS\r
- if (hFile == INVALID_HANDLE_VALUE) {\r
- win32_error("utime", apath);\r
- PyMem_Free(apath);\r
- return NULL;\r
- }\r
- PyMem_Free(apath);\r
- }\r
-\r
- if (arg == Py_None) {\r
- SYSTEMTIME now;\r
- GetSystemTime(&now);\r
- if (!SystemTimeToFileTime(&now, &mtime) ||\r
- !SystemTimeToFileTime(&now, &atime)) {\r
- win32_error("utime", NULL);\r
- goto done;\r
- }\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
- goto done;\r
- }\r
- else {\r
- if (extract_time(PyTuple_GET_ITEM(arg, 0),\r
- &atimesec, &ausec) == -1)\r
- goto done;\r
- time_t_to_FILE_TIME(atimesec, 1000*ausec, &atime);\r
- if (extract_time(PyTuple_GET_ITEM(arg, 1),\r
- &mtimesec, &musec) == -1)\r
- goto done;\r
- time_t_to_FILE_TIME(mtimesec, 1000*musec, &mtime);\r
- }\r
- if (!SetFileTime(hFile, NULL, &atime, &mtime)) {\r
- /* Avoid putting the file name into the error here,\r
- as that may confuse the user into believing that\r
- something is wrong with the file, when it also\r
- could be the time stamp that gives a problem. */\r
- win32_error("utime", NULL);\r
- goto done;\r
- }\r
- Py_INCREF(Py_None);\r
- result = Py_None;\r
-done:\r
- CloseHandle(hFile);\r
- return result;\r
-#else /* MS_WINDOWS */\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 posix_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
-#endif /* MS_WINDOWS */\r
-}\r
-\r
-\r
-/* Process operations */\r
-\r
-PyDoc_STRVAR(posix__exit__doc__,\r
-"_exit(status)\n\n\\r
-Exit to the system with specified status, without normal exit processing.");\r
-\r
-static PyObject *\r
-posix__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(posix_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
-posix_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 posix_error();\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_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
-posix_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) posix_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(posix_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
-posix_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 posix_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(posix_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
-posix_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) posix_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(posix_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
-posix_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 posix_error();\r
- else\r
- return Py_BuildValue("l", (long) spawnval);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_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
-posix_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) posix_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(posix_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
-posix_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 posix_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(posix_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
-posix_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 posix_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(posix_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
-posix_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 posix_error();\r
-#elif defined(HAVE__GETPTY)\r
- slave_name = _getpty(&master_fd, O_RDWR, 0666, 0);\r
- if (slave_name == NULL)\r
- return posix_error();\r
-\r
- slave_fd = open(slave_name, O_RDWR);\r
- if (slave_fd < 0)\r
- return posix_error();\r
-#else\r
- master_fd = open(DEV_PTY_FILE, O_RDWR | O_NOCTTY); /* open master */\r
- if (master_fd < 0)\r
- return posix_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 posix_error();\r
- }\r
- /* unlock slave */\r
- if (unlockpt(master_fd) < 0) {\r
- PyOS_setsig(SIGCHLD, sig_saved);\r
- return posix_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 posix_error();\r
- slave_fd = open(slave_name, O_RDWR | O_NOCTTY); /* open slave */\r
- if (slave_fd < 0)\r
- return posix_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(posix_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
-posix_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 posix_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
-#ifdef HAVE_GETEGID\r
-PyDoc_STRVAR(posix_getegid__doc__,\r
-"getegid() -> egid\n\n\\r
-Return the current process's effective group id.");\r
-\r
-static PyObject *\r
-posix_getegid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyInt_FromLong((long)getegid());\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_GETEUID\r
-PyDoc_STRVAR(posix_geteuid__doc__,\r
-"geteuid() -> euid\n\n\\r
-Return the current process's effective user id.");\r
-\r
-static PyObject *\r
-posix_geteuid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyInt_FromLong((long)geteuid());\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_GETGID\r
-PyDoc_STRVAR(posix_getgid__doc__,\r
-"getgid() -> gid\n\n\\r
-Return the current process's group id.");\r
-\r
-static PyObject *\r
-posix_getgid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyInt_FromLong((long)getgid());\r
-}\r
-#endif\r
-\r
-\r
-PyDoc_STRVAR(posix_getpid__doc__,\r
-"getpid() -> pid\n\n\\r
-Return the current process id");\r
-\r
-static PyObject *\r
-posix_getpid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyLong_FromPid(getpid());\r
-}\r
-\r
-\r
-#ifdef HAVE_GETGROUPS\r
-PyDoc_STRVAR(posix_getgroups__doc__,\r
-"getgroups() -> list of group IDs\n\n\\r
-Return list of supplemental group IDs for the process.");\r
-\r
-static PyObject *\r
-posix_getgroups(PyObject *self, PyObject *noargs)\r
-{\r
- PyObject *result = NULL;\r
-\r
-#ifdef NGROUPS_MAX\r
-#define MAX_GROUPS NGROUPS_MAX\r
-#else\r
- /* defined to be 16 on Solaris7, so this should be a small number */\r
-#define MAX_GROUPS 64\r
-#endif\r
- gid_t grouplist[MAX_GROUPS];\r
-\r
- /* On MacOSX getgroups(2) can return more than MAX_GROUPS results \r
- * This is a helper variable to store the intermediate result when\r
- * that happens.\r
- *\r
- * To keep the code readable the OSX behaviour is unconditional,\r
- * according to the POSIX spec this should be safe on all unix-y\r
- * systems.\r
- */\r
- gid_t* alt_grouplist = grouplist;\r
- int n;\r
-\r
- n = getgroups(MAX_GROUPS, grouplist);\r
- if (n < 0) {\r
- if (errno == EINVAL) {\r
- n = getgroups(0, NULL);\r
- if (n == -1) {\r
- return posix_error();\r
- }\r
- if (n == 0) {\r
- /* Avoid malloc(0) */\r
- alt_grouplist = grouplist;\r
- } else {\r
- alt_grouplist = PyMem_Malloc(n * sizeof(gid_t));\r
- if (alt_grouplist == NULL) {\r
- errno = EINVAL;\r
- return posix_error();\r
- }\r
- n = getgroups(n, alt_grouplist);\r
- if (n == -1) {\r
- PyMem_Free(alt_grouplist);\r
- return posix_error();\r
- }\r
- }\r
- } else {\r
- return posix_error();\r
- }\r
- }\r
- result = PyList_New(n);\r
- if (result != NULL) {\r
- int i;\r
- for (i = 0; i < n; ++i) {\r
- PyObject *o = PyInt_FromLong((long)alt_grouplist[i]);\r
- if (o == NULL) {\r
- Py_DECREF(result);\r
- result = NULL;\r
- break;\r
- }\r
- PyList_SET_ITEM(result, i, o);\r
- }\r
- }\r
-\r
- if (alt_grouplist != grouplist) {\r
- PyMem_Free(alt_grouplist);\r
- }\r
-\r
- return result;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_INITGROUPS\r
-PyDoc_STRVAR(posix_initgroups__doc__,\r
-"initgroups(username, gid) -> None\n\n\\r
-Call the system initgroups() to initialize the group access list with all of\n\\r
-the groups of which the specified username is a member, plus the specified\n\\r
-group id.");\r
-\r
-static PyObject *\r
-posix_initgroups(PyObject *self, PyObject *args)\r
-{\r
- char *username;\r
- long gid;\r
-\r
- if (!PyArg_ParseTuple(args, "sl:initgroups", &username, &gid))\r
- return NULL;\r
-\r
- if (initgroups(username, (gid_t) gid) == -1)\r
- return PyErr_SetFromErrno(PyExc_OSError);\r
-\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_GETPGID\r
-PyDoc_STRVAR(posix_getpgid__doc__,\r
-"getpgid(pid) -> pgid\n\n\\r
-Call the system call getpgid().");\r
-\r
-static PyObject *\r
-posix_getpgid(PyObject *self, PyObject *args)\r
-{\r
- pid_t pid, pgid;\r
- if (!PyArg_ParseTuple(args, PARSE_PID ":getpgid", &pid))\r
- return NULL;\r
- pgid = getpgid(pid);\r
- if (pgid < 0)\r
- return posix_error();\r
- return PyLong_FromPid(pgid);\r
-}\r
-#endif /* HAVE_GETPGID */\r
-\r
-\r
-#ifdef HAVE_GETPGRP\r
-PyDoc_STRVAR(posix_getpgrp__doc__,\r
-"getpgrp() -> pgrp\n\n\\r
-Return the current process group id.");\r
-\r
-static PyObject *\r
-posix_getpgrp(PyObject *self, PyObject *noargs)\r
-{\r
-#ifdef GETPGRP_HAVE_ARG\r
- return PyLong_FromPid(getpgrp(0));\r
-#else /* GETPGRP_HAVE_ARG */\r
- return PyLong_FromPid(getpgrp());\r
-#endif /* GETPGRP_HAVE_ARG */\r
-}\r
-#endif /* HAVE_GETPGRP */\r
-\r
-\r
-#ifdef HAVE_SETPGRP\r
-PyDoc_STRVAR(posix_setpgrp__doc__,\r
-"setpgrp()\n\n\\r
-Make this process the process group leader.");\r
-\r
-static PyObject *\r
-posix_setpgrp(PyObject *self, PyObject *noargs)\r
-{\r
-#ifdef SETPGRP_HAVE_ARG\r
- if (setpgrp(0, 0) < 0)\r
-#else /* SETPGRP_HAVE_ARG */\r
- if (setpgrp() < 0)\r
-#endif /* SETPGRP_HAVE_ARG */\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-#endif /* HAVE_SETPGRP */\r
-\r
-#ifdef HAVE_GETPPID\r
-PyDoc_STRVAR(posix_getppid__doc__,\r
-"getppid() -> ppid\n\n\\r
-Return the parent's process id.");\r
-\r
-static PyObject *\r
-posix_getppid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyLong_FromPid(getppid());\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_GETLOGIN\r
-PyDoc_STRVAR(posix_getlogin__doc__,\r
-"getlogin() -> string\n\n\\r
-Return the actual login name.");\r
-\r
-static PyObject *\r
-posix_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
- posix_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_GETUID\r
-PyDoc_STRVAR(posix_getuid__doc__,\r
-"getuid() -> uid\n\n\\r
-Return the current process's user id.");\r
-\r
-static PyObject *\r
-posix_getuid(PyObject *self, PyObject *noargs)\r
-{\r
- return PyInt_FromLong((long)getuid());\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_KILL\r
-PyDoc_STRVAR(posix_kill__doc__,\r
-"kill(pid, sig)\n\n\\r
-Kill a process with a signal.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
-#endif\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_KILLPG\r
-PyDoc_STRVAR(posix_killpg__doc__,\r
-"killpg(pgid, sig)\n\n\\r
-Kill a process group with a signal.");\r
-\r
-static PyObject *\r
-posix_killpg(PyObject *self, PyObject *args)\r
-{\r
- int sig;\r
- pid_t pgid;\r
- /* XXX some man pages make the `pgid` parameter an int, others\r
- a pid_t. Since getpgrp() returns a pid_t, we assume killpg should\r
- take the same type. Moreover, pid_t is always at least as wide as\r
- int (else compilation of this module fails), which is safe. */\r
- if (!PyArg_ParseTuple(args, PARSE_PID "i:killpg", &pgid, &sig))\r
- return NULL;\r
- if (killpg(pgid, sig) == -1)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef MS_WINDOWS\r
-PyDoc_STRVAR(win32_kill__doc__,\r
-"kill(pid, sig)\n\n\\r
-Kill a process with a signal.");\r
-\r
-static PyObject *\r
-win32_kill(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result;\r
- DWORD pid, sig, err;\r
- HANDLE handle;\r
-\r
- if (!PyArg_ParseTuple(args, "kk:kill", &pid, &sig))\r
- return NULL;\r
-\r
- /* Console processes which share a common console can be sent CTRL+C or\r
- CTRL+BREAK events, provided they handle said events. */\r
- if (sig == CTRL_C_EVENT || sig == CTRL_BREAK_EVENT) {\r
- if (GenerateConsoleCtrlEvent(sig, pid) == 0) {\r
- err = GetLastError();\r
- return PyErr_SetFromWindowsErr(err);\r
- }\r
- else\r
- Py_RETURN_NONE;\r
- }\r
-\r
- /* If the signal is outside of what GenerateConsoleCtrlEvent can use,\r
- attempt to open and terminate the process. */\r
- handle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);\r
- if (handle == NULL) {\r
- err = GetLastError();\r
- return PyErr_SetFromWindowsErr(err);\r
- }\r
-\r
- if (TerminateProcess(handle, sig) == 0) {\r
- err = GetLastError();\r
- result = PyErr_SetFromWindowsErr(err);\r
- } else {\r
- Py_INCREF(Py_None);\r
- result = Py_None;\r
- }\r
-\r
- CloseHandle(handle);\r
- return result;\r
-}\r
-#endif /* MS_WINDOWS */\r
-\r
-#ifdef HAVE_PLOCK\r
-\r
-#ifdef HAVE_SYS_LOCK_H\r
-#include <sys/lock.h>\r
-#endif\r
-\r
-PyDoc_STRVAR(posix_plock__doc__,\r
-"plock(op)\n\n\\r
-Lock program segments into memory.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_POPEN\r
-PyDoc_STRVAR(posix_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
-#if defined(PYOS_OS2)\r
-#if defined(PYCC_VACPP)\r
-static int\r
-async_system(const char *command)\r
-{\r
- char errormsg[256], args[1024];\r
- RESULTCODES rcodes;\r
- APIRET rc;\r
-\r
- char *shell = getenv("COMSPEC");\r
- if (!shell)\r
- shell = "cmd";\r
-\r
- /* avoid overflowing the argument buffer */\r
- if (strlen(shell) + 3 + strlen(command) >= 1024)\r
- return ERROR_NOT_ENOUGH_MEMORY\r
-\r
- args[0] = '\0';\r
- strcat(args, shell);\r
- strcat(args, "/c ");\r
- strcat(args, command);\r
-\r
- /* execute asynchronously, inheriting the environment */\r
- rc = DosExecPgm(errormsg,\r
- sizeof(errormsg),\r
- EXEC_ASYNC,\r
- args,\r
- NULL,\r
- &rcodes,\r
- shell);\r
- return rc;\r
-}\r
-\r
-static FILE *\r
-popen(const char *command, const char *mode, int pipesize, int *err)\r
-{\r
- int oldfd, tgtfd;\r
- HFILE pipeh[2];\r
- APIRET rc;\r
-\r
- /* mode determines which of stdin or stdout is reconnected to\r
- * the pipe to the child\r
- */\r
- if (strchr(mode, 'r') != NULL) {\r
- tgt_fd = 1; /* stdout */\r
- } else if (strchr(mode, 'w')) {\r
- tgt_fd = 0; /* stdin */\r
- } else {\r
- *err = ERROR_INVALID_ACCESS;\r
- return NULL;\r
- }\r
-\r
- /* setup the pipe */\r
- if ((rc = DosCreatePipe(&pipeh[0], &pipeh[1], pipesize)) != NO_ERROR) {\r
- *err = rc;\r
- return NULL;\r
- }\r
-\r
- /* prevent other threads accessing stdio */\r
- DosEnterCritSec();\r
-\r
- /* reconnect stdio and execute child */\r
- oldfd = dup(tgtfd);\r
- close(tgtfd);\r
- if (dup2(pipeh[tgtfd], tgtfd) == 0) {\r
- DosClose(pipeh[tgtfd]);\r
- rc = async_system(command);\r
- }\r
-\r
- /* restore stdio */\r
- dup2(oldfd, tgtfd);\r
- close(oldfd);\r
-\r
- /* allow other threads access to stdio */\r
- DosExitCritSec();\r
-\r
- /* if execution of child was successful return file stream */\r
- if (rc == NO_ERROR)\r
- return fdopen(pipeh[1 - tgtfd], mode);\r
- else {\r
- DosClose(pipeh[1 - tgtfd]);\r
- *err = rc;\r
- return NULL;\r
- }\r
-}\r
-\r
-static PyObject *\r
-posix_popen(PyObject *self, PyObject *args)\r
-{\r
- char *name;\r
- char *mode = "r";\r
- int err, bufsize = -1;\r
- FILE *fp;\r
- PyObject *f;\r
- if (!PyArg_ParseTuple(args, "s|si:popen", &name, &mode, &bufsize))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- fp = popen(name, mode, (bufsize > 0) ? bufsize : 4096, &err);\r
- Py_END_ALLOW_THREADS\r
- if (fp == NULL)\r
- return os2_error(err);\r
-\r
- f = PyFile_FromFile(fp, name, mode, fclose);\r
- if (f != NULL)\r
- PyFile_SetBufSize(f, bufsize);\r
- return f;\r
-}\r
-\r
-#elif defined(PYCC_GCC)\r
-\r
-/* standard posix version of popen() support */\r
-static PyObject *\r
-posix_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
- Py_BEGIN_ALLOW_THREADS\r
- fp = popen(name, mode);\r
- Py_END_ALLOW_THREADS\r
- if (fp == NULL)\r
- return posix_error();\r
- f = PyFile_FromFile(fp, name, mode, pclose);\r
- if (f != NULL)\r
- PyFile_SetBufSize(f, bufsize);\r
- return f;\r
-}\r
-\r
-/* fork() under OS/2 has lots'o'warts\r
- * EMX supports pipe() and spawn*() so we can synthesize popen[234]()\r
- * most of this code is a ripoff of the win32 code, but using the\r
- * capabilities of EMX's C library routines\r
- */\r
-\r
-/* These tell _PyPopen() whether to return 1, 2, or 3 file objects. */\r
-#define POPEN_1 1\r
-#define POPEN_2 2\r
-#define POPEN_3 3\r
-#define POPEN_4 4\r
-\r
-static PyObject *_PyPopen(char *, int, int, int);\r
-static int _PyPclose(FILE *file);\r
-\r
-/*\r
- * Internal dictionary mapping popen* file pointers to process handles,\r
- * for use when retrieving the process exit code. See _PyPclose() below\r
- * for more information on this dictionary's use.\r
- */\r
-static PyObject *_PyPopenProcs = NULL;\r
-\r
-/* os2emx version of popen2()\r
- *\r
- * The result of this function is a pipe (file) connected to the\r
- * process's stdin, and a pipe connected to the process's stdout.\r
- */\r
-\r
-static PyObject *\r
-os2emx_popen2(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm=0;\r
-\r
- char *cmdstring;\r
- char *mode = "t";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen2", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 't')\r
- tm = O_TEXT;\r
- else if (*mode != 'b') {\r
- PyErr_SetString(PyExc_ValueError, "mode must be 't' or 'b'");\r
- return NULL;\r
- } else\r
- tm = O_BINARY;\r
-\r
- f = _PyPopen(cmdstring, tm, POPEN_2, bufsize);\r
-\r
- return f;\r
-}\r
-\r
-/*\r
- * Variation on os2emx.popen2\r
- *\r
- * The result of this function is 3 pipes - the process's stdin,\r
- * stdout and stderr\r
- */\r
-\r
-static PyObject *\r
-os2emx_popen3(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm = 0;\r
-\r
- char *cmdstring;\r
- char *mode = "t";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen3", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 't')\r
- tm = O_TEXT;\r
- else if (*mode != 'b') {\r
- PyErr_SetString(PyExc_ValueError, "mode must be 't' or 'b'");\r
- return NULL;\r
- } else\r
- tm = O_BINARY;\r
-\r
- f = _PyPopen(cmdstring, tm, POPEN_3, bufsize);\r
-\r
- return f;\r
-}\r
-\r
-/*\r
- * Variation on os2emx.popen2\r
- *\r
- * The result of this function is 2 pipes - the processes stdin,\r
- * and stdout+stderr combined as a single pipe.\r
- */\r
-\r
-static PyObject *\r
-os2emx_popen4(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm = 0;\r
-\r
- char *cmdstring;\r
- char *mode = "t";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen4", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 't')\r
- tm = O_TEXT;\r
- else if (*mode != 'b') {\r
- PyErr_SetString(PyExc_ValueError, "mode must be 't' or 'b'");\r
- return NULL;\r
- } else\r
- tm = O_BINARY;\r
-\r
- f = _PyPopen(cmdstring, tm, POPEN_4, bufsize);\r
-\r
- return f;\r
-}\r
-\r
-/* a couple of structures for convenient handling of multiple\r
- * file handles and pipes\r
- */\r
-struct file_ref\r
-{\r
- int handle;\r
- int flags;\r
-};\r
-\r
-struct pipe_ref\r
-{\r
- int rd;\r
- int wr;\r
-};\r
-\r
-/* The following code is derived from the win32 code */\r
-\r
-static PyObject *\r
-_PyPopen(char *cmdstring, int mode, int n, int bufsize)\r
-{\r
- struct file_ref stdio[3];\r
- struct pipe_ref p_fd[3];\r
- FILE *p_s[3];\r
- int file_count, i, pipe_err;\r
- pid_t pipe_pid;\r
- char *shell, *sh_name, *opt, *rd_mode, *wr_mode;\r
- PyObject *f, *p_f[3];\r
-\r
- /* file modes for subsequent fdopen's on pipe handles */\r
- if (mode == O_TEXT)\r
- {\r
- rd_mode = "rt";\r
- wr_mode = "wt";\r
- }\r
- else\r
- {\r
- rd_mode = "rb";\r
- wr_mode = "wb";\r
- }\r
-\r
- /* prepare shell references */\r
- if ((shell = getenv("EMXSHELL")) == NULL)\r
- if ((shell = getenv("COMSPEC")) == NULL)\r
- {\r
- errno = ENOENT;\r
- return posix_error();\r
- }\r
-\r
- sh_name = _getname(shell);\r
- if (stricmp(sh_name, "cmd.exe") == 0 || stricmp(sh_name, "4os2.exe") == 0)\r
- opt = "/c";\r
- else\r
- opt = "-c";\r
-\r
- /* save current stdio fds + their flags, and set not inheritable */\r
- i = pipe_err = 0;\r
- while (pipe_err >= 0 && i < 3)\r
- {\r
- pipe_err = stdio[i].handle = dup(i);\r
- stdio[i].flags = fcntl(i, F_GETFD, 0);\r
- fcntl(stdio[i].handle, F_SETFD, stdio[i].flags | FD_CLOEXEC);\r
- i++;\r
- }\r
- if (pipe_err < 0)\r
- {\r
- /* didn't get them all saved - clean up and bail out */\r
- int saved_err = errno;\r
- while (i-- > 0)\r
- {\r
- close(stdio[i].handle);\r
- }\r
- errno = saved_err;\r
- return posix_error();\r
- }\r
-\r
- /* create pipe ends */\r
- file_count = 2;\r
- if (n == POPEN_3)\r
- file_count = 3;\r
- i = pipe_err = 0;\r
- while ((pipe_err == 0) && (i < file_count))\r
- pipe_err = pipe((int *)&p_fd[i++]);\r
- if (pipe_err < 0)\r
- {\r
- /* didn't get them all made - clean up and bail out */\r
- while (i-- > 0)\r
- {\r
- close(p_fd[i].wr);\r
- close(p_fd[i].rd);\r
- }\r
- errno = EPIPE;\r
- return posix_error();\r
- }\r
-\r
- /* change the actual standard IO streams over temporarily,\r
- * making the retained pipe ends non-inheritable\r
- */\r
- pipe_err = 0;\r
-\r
- /* - stdin */\r
- if (dup2(p_fd[0].rd, 0) == 0)\r
- {\r
- close(p_fd[0].rd);\r
- i = fcntl(p_fd[0].wr, F_GETFD, 0);\r
- fcntl(p_fd[0].wr, F_SETFD, i | FD_CLOEXEC);\r
- if ((p_s[0] = fdopen(p_fd[0].wr, wr_mode)) == NULL)\r
- {\r
- close(p_fd[0].wr);\r
- pipe_err = -1;\r
- }\r
- }\r
- else\r
- {\r
- pipe_err = -1;\r
- }\r
-\r
- /* - stdout */\r
- if (pipe_err == 0)\r
- {\r
- if (dup2(p_fd[1].wr, 1) == 1)\r
- {\r
- close(p_fd[1].wr);\r
- i = fcntl(p_fd[1].rd, F_GETFD, 0);\r
- fcntl(p_fd[1].rd, F_SETFD, i | FD_CLOEXEC);\r
- if ((p_s[1] = fdopen(p_fd[1].rd, rd_mode)) == NULL)\r
- {\r
- close(p_fd[1].rd);\r
- pipe_err = -1;\r
- }\r
- }\r
- else\r
- {\r
- pipe_err = -1;\r
- }\r
- }\r
-\r
- /* - stderr, as required */\r
- if (pipe_err == 0)\r
- switch (n)\r
- {\r
- case POPEN_3:\r
- {\r
- if (dup2(p_fd[2].wr, 2) == 2)\r
- {\r
- close(p_fd[2].wr);\r
- i = fcntl(p_fd[2].rd, F_GETFD, 0);\r
- fcntl(p_fd[2].rd, F_SETFD, i | FD_CLOEXEC);\r
- if ((p_s[2] = fdopen(p_fd[2].rd, rd_mode)) == NULL)\r
- {\r
- close(p_fd[2].rd);\r
- pipe_err = -1;\r
- }\r
- }\r
- else\r
- {\r
- pipe_err = -1;\r
- }\r
- break;\r
- }\r
-\r
- case POPEN_4:\r
- {\r
- if (dup2(1, 2) != 2)\r
- {\r
- pipe_err = -1;\r
- }\r
- break;\r
- }\r
- }\r
-\r
- /* spawn the child process */\r
- if (pipe_err == 0)\r
- {\r
- pipe_pid = spawnlp(P_NOWAIT, shell, shell, opt, cmdstring, (char *)0);\r
- if (pipe_pid == -1)\r
- {\r
- pipe_err = -1;\r
- }\r
- else\r
- {\r
- /* save the PID into the FILE structure\r
- * NOTE: this implementation doesn't actually\r
- * take advantage of this, but do it for\r
- * completeness - AIM Apr01\r
- */\r
- for (i = 0; i < file_count; i++)\r
- p_s[i]->_pid = pipe_pid;\r
- }\r
- }\r
-\r
- /* reset standard IO to normal */\r
- for (i = 0; i < 3; i++)\r
- {\r
- dup2(stdio[i].handle, i);\r
- fcntl(i, F_SETFD, stdio[i].flags);\r
- close(stdio[i].handle);\r
- }\r
-\r
- /* if any remnant problems, clean up and bail out */\r
- if (pipe_err < 0)\r
- {\r
- for (i = 0; i < 3; i++)\r
- {\r
- close(p_fd[i].rd);\r
- close(p_fd[i].wr);\r
- }\r
- errno = EPIPE;\r
- return posix_error_with_filename(cmdstring);\r
- }\r
-\r
- /* build tuple of file objects to return */\r
- if ((p_f[0] = PyFile_FromFile(p_s[0], cmdstring, wr_mode, _PyPclose)) != NULL)\r
- PyFile_SetBufSize(p_f[0], bufsize);\r
- if ((p_f[1] = PyFile_FromFile(p_s[1], cmdstring, rd_mode, _PyPclose)) != NULL)\r
- PyFile_SetBufSize(p_f[1], bufsize);\r
- if (n == POPEN_3)\r
- {\r
- if ((p_f[2] = PyFile_FromFile(p_s[2], cmdstring, rd_mode, _PyPclose)) != NULL)\r
- PyFile_SetBufSize(p_f[0], bufsize);\r
- f = PyTuple_Pack(3, p_f[0], p_f[1], p_f[2]);\r
- }\r
- else\r
- f = PyTuple_Pack(2, p_f[0], p_f[1]);\r
-\r
- /*\r
- * Insert the files we've created into the process dictionary\r
- * all referencing the list with the process handle and the\r
- * initial number of files (see description below in _PyPclose).\r
- * Since if _PyPclose later tried to wait on a process when all\r
- * handles weren't closed, it could create a deadlock with the\r
- * child, we spend some energy here to try to ensure that we\r
- * either insert all file handles into the dictionary or none\r
- * at all. It's a little clumsy with the various popen modes\r
- * and variable number of files involved.\r
- */\r
- if (!_PyPopenProcs)\r
- {\r
- _PyPopenProcs = PyDict_New();\r
- }\r
-\r
- if (_PyPopenProcs)\r
- {\r
- PyObject *procObj, *pidObj, *intObj, *fileObj[3];\r
- int ins_rc[3];\r
-\r
- fileObj[0] = fileObj[1] = fileObj[2] = NULL;\r
- ins_rc[0] = ins_rc[1] = ins_rc[2] = 0;\r
-\r
- procObj = PyList_New(2);\r
- pidObj = PyLong_FromPid(pipe_pid);\r
- intObj = PyInt_FromLong((long) file_count);\r
-\r
- if (procObj && pidObj && intObj)\r
- {\r
- PyList_SetItem(procObj, 0, pidObj);\r
- PyList_SetItem(procObj, 1, intObj);\r
-\r
- fileObj[0] = PyLong_FromVoidPtr(p_s[0]);\r
- if (fileObj[0])\r
- {\r
- ins_rc[0] = PyDict_SetItem(_PyPopenProcs,\r
- fileObj[0],\r
- procObj);\r
- }\r
- fileObj[1] = PyLong_FromVoidPtr(p_s[1]);\r
- if (fileObj[1])\r
- {\r
- ins_rc[1] = PyDict_SetItem(_PyPopenProcs,\r
- fileObj[1],\r
- procObj);\r
- }\r
- if (file_count >= 3)\r
- {\r
- fileObj[2] = PyLong_FromVoidPtr(p_s[2]);\r
- if (fileObj[2])\r
- {\r
- ins_rc[2] = PyDict_SetItem(_PyPopenProcs,\r
- fileObj[2],\r
- procObj);\r
- }\r
- }\r
-\r
- if (ins_rc[0] < 0 || !fileObj[0] ||\r
- ins_rc[1] < 0 || (file_count > 1 && !fileObj[1]) ||\r
- ins_rc[2] < 0 || (file_count > 2 && !fileObj[2]))\r
- {\r
- /* Something failed - remove any dictionary\r
- * entries that did make it.\r
- */\r
- if (!ins_rc[0] && fileObj[0])\r
- {\r
- PyDict_DelItem(_PyPopenProcs,\r
- fileObj[0]);\r
- }\r
- if (!ins_rc[1] && fileObj[1])\r
- {\r
- PyDict_DelItem(_PyPopenProcs,\r
- fileObj[1]);\r
- }\r
- if (!ins_rc[2] && fileObj[2])\r
- {\r
- PyDict_DelItem(_PyPopenProcs,\r
- fileObj[2]);\r
- }\r
- }\r
- }\r
-\r
- /*\r
- * Clean up our localized references for the dictionary keys\r
- * and value since PyDict_SetItem will Py_INCREF any copies\r
- * that got placed in the dictionary.\r
- */\r
- Py_XDECREF(procObj);\r
- Py_XDECREF(fileObj[0]);\r
- Py_XDECREF(fileObj[1]);\r
- Py_XDECREF(fileObj[2]);\r
- }\r
-\r
- /* Child is launched. */\r
- return f;\r
-}\r
-\r
-/*\r
- * Wrapper for fclose() to use for popen* files, so we can retrieve the\r
- * exit code for the child process and return as a result of the close.\r
- *\r
- * This function uses the _PyPopenProcs dictionary in order to map the\r
- * input file pointer to information about the process that was\r
- * originally created by the popen* call that created the file pointer.\r
- * The dictionary uses the file pointer as a key (with one entry\r
- * inserted for each file returned by the original popen* call) and a\r
- * single list object as the value for all files from a single call.\r
- * The list object contains the Win32 process handle at [0], and a file\r
- * count at [1], which is initialized to the total number of file\r
- * handles using that list.\r
- *\r
- * This function closes whichever handle it is passed, and decrements\r
- * the file count in the dictionary for the process handle pointed to\r
- * by this file. On the last close (when the file count reaches zero),\r
- * this function will wait for the child process and then return its\r
- * exit code as the result of the close() operation. This permits the\r
- * files to be closed in any order - it is always the close() of the\r
- * final handle that will return the exit code.\r
- *\r
- * NOTE: This function is currently called with the GIL released.\r
- * hence we use the GILState API to manage our state.\r
- */\r
-\r
-static int _PyPclose(FILE *file)\r
-{\r
- int result;\r
- int exit_code;\r
- pid_t pipe_pid;\r
- PyObject *procObj, *pidObj, *intObj, *fileObj;\r
- int file_count;\r
-#ifdef WITH_THREAD\r
- PyGILState_STATE state;\r
-#endif\r
-\r
- /* Close the file handle first, to ensure it can't block the\r
- * child from exiting if it's the last handle.\r
- */\r
- result = fclose(file);\r
-\r
-#ifdef WITH_THREAD\r
- state = PyGILState_Ensure();\r
-#endif\r
- if (_PyPopenProcs)\r
- {\r
- if ((fileObj = PyLong_FromVoidPtr(file)) != NULL &&\r
- (procObj = PyDict_GetItem(_PyPopenProcs,\r
- fileObj)) != NULL &&\r
- (pidObj = PyList_GetItem(procObj,0)) != NULL &&\r
- (intObj = PyList_GetItem(procObj,1)) != NULL)\r
- {\r
- pipe_pid = (pid_t) PyLong_AsPid(pidObj);\r
- file_count = (int) PyInt_AsLong(intObj);\r
-\r
- if (file_count > 1)\r
- {\r
- /* Still other files referencing process */\r
- file_count--;\r
- PyList_SetItem(procObj,1,\r
- PyInt_FromLong((long) file_count));\r
- }\r
- else\r
- {\r
- /* Last file for this process */\r
- if (result != EOF &&\r
- waitpid(pipe_pid, &exit_code, 0) == pipe_pid)\r
- {\r
- /* extract exit status */\r
- if (WIFEXITED(exit_code))\r
- {\r
- result = WEXITSTATUS(exit_code);\r
- }\r
- else\r
- {\r
- errno = EPIPE;\r
- result = -1;\r
- }\r
- }\r
- else\r
- {\r
- /* Indicate failure - this will cause the file object\r
- * to raise an I/O error and translate the last\r
- * error code from errno. We do have a problem with\r
- * last errors that overlap the normal errno table,\r
- * but that's a consistent problem with the file object.\r
- */\r
- result = -1;\r
- }\r
- }\r
-\r
- /* Remove this file pointer from dictionary */\r
- PyDict_DelItem(_PyPopenProcs, fileObj);\r
-\r
- if (PyDict_Size(_PyPopenProcs) == 0)\r
- {\r
- Py_DECREF(_PyPopenProcs);\r
- _PyPopenProcs = NULL;\r
- }\r
-\r
- } /* if object retrieval ok */\r
-\r
- Py_XDECREF(fileObj);\r
- } /* if _PyPopenProcs */\r
-\r
-#ifdef WITH_THREAD\r
- PyGILState_Release(state);\r
-#endif\r
- return result;\r
-}\r
-\r
-#endif /* PYCC_??? */\r
-\r
-#elif defined(MS_WINDOWS)\r
-\r
-/*\r
- * Portable 'popen' replacement for Win32.\r
- *\r
- * Written by Bill Tutt <billtut@microsoft.com>. Minor tweaks\r
- * and 2.0 integration by Fredrik Lundh <fredrik@pythonware.com>\r
- * Return code handling by David Bolen <db3l@fitlinxx.com>.\r
- */\r
-\r
-#include <malloc.h>\r
-#include <io.h>\r
-#include <fcntl.h>\r
-\r
-/* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */\r
-#define POPEN_1 1\r
-#define POPEN_2 2\r
-#define POPEN_3 3\r
-#define POPEN_4 4\r
-\r
-static PyObject *_PyPopen(char *, int, int);\r
-static int _PyPclose(FILE *file);\r
-\r
-/*\r
- * Internal dictionary mapping popen* file pointers to process handles,\r
- * for use when retrieving the process exit code. See _PyPclose() below\r
- * for more information on this dictionary's use.\r
- */\r
-static PyObject *_PyPopenProcs = NULL;\r
-\r
-\r
-/* popen that works from a GUI.\r
- *\r
- * The result of this function is a pipe (file) connected to the\r
- * processes stdin or stdout, depending on the requested mode.\r
- */\r
-\r
-static PyObject *\r
-posix_popen(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm = 0;\r
-\r
- char *cmdstring;\r
- char *mode = "r";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 'r')\r
- tm = _O_RDONLY;\r
- else if (*mode != 'w') {\r
- PyErr_SetString(PyExc_ValueError, "popen() arg 2 must be 'r' or 'w'");\r
- return NULL;\r
- } else\r
- tm = _O_WRONLY;\r
-\r
- if (bufsize != -1) {\r
- PyErr_SetString(PyExc_ValueError, "popen() arg 3 must be -1");\r
- return NULL;\r
- }\r
-\r
- if (*(mode+1) == 't')\r
- f = _PyPopen(cmdstring, tm | _O_TEXT, POPEN_1);\r
- else if (*(mode+1) == 'b')\r
- f = _PyPopen(cmdstring, tm | _O_BINARY, POPEN_1);\r
- else\r
- f = _PyPopen(cmdstring, tm | _O_TEXT, POPEN_1);\r
-\r
- return f;\r
-}\r
-\r
-/* Variation on win32pipe.popen\r
- *\r
- * The result of this function is a pipe (file) connected to the\r
- * process's stdin, and a pipe connected to the process's stdout.\r
- */\r
-\r
-static PyObject *\r
-win32_popen2(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm=0;\r
-\r
- char *cmdstring;\r
- char *mode = "t";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen2", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 't')\r
- tm = _O_TEXT;\r
- else if (*mode != 'b') {\r
- PyErr_SetString(PyExc_ValueError, "popen2() arg 2 must be 't' or 'b'");\r
- return NULL;\r
- } else\r
- tm = _O_BINARY;\r
-\r
- if (bufsize != -1) {\r
- PyErr_SetString(PyExc_ValueError, "popen2() arg 3 must be -1");\r
- return NULL;\r
- }\r
-\r
- f = _PyPopen(cmdstring, tm, POPEN_2);\r
-\r
- return f;\r
-}\r
-\r
-/*\r
- * Variation on <om win32pipe.popen>\r
- *\r
- * The result of this function is 3 pipes - the process's stdin,\r
- * stdout and stderr\r
- */\r
-\r
-static PyObject *\r
-win32_popen3(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm = 0;\r
-\r
- char *cmdstring;\r
- char *mode = "t";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen3", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 't')\r
- tm = _O_TEXT;\r
- else if (*mode != 'b') {\r
- PyErr_SetString(PyExc_ValueError, "popen3() arg 2 must be 't' or 'b'");\r
- return NULL;\r
- } else\r
- tm = _O_BINARY;\r
-\r
- if (bufsize != -1) {\r
- PyErr_SetString(PyExc_ValueError, "popen3() arg 3 must be -1");\r
- return NULL;\r
- }\r
-\r
- f = _PyPopen(cmdstring, tm, POPEN_3);\r
-\r
- return f;\r
-}\r
-\r
-/*\r
- * Variation on win32pipe.popen\r
- *\r
- * The result of this function is 2 pipes - the processes stdin,\r
- * and stdout+stderr combined as a single pipe.\r
- */\r
-\r
-static PyObject *\r
-win32_popen4(PyObject *self, PyObject *args)\r
-{\r
- PyObject *f;\r
- int tm = 0;\r
-\r
- char *cmdstring;\r
- char *mode = "t";\r
- int bufsize = -1;\r
- if (!PyArg_ParseTuple(args, "s|si:popen4", &cmdstring, &mode, &bufsize))\r
- return NULL;\r
-\r
- if (*mode == 't')\r
- tm = _O_TEXT;\r
- else if (*mode != 'b') {\r
- PyErr_SetString(PyExc_ValueError, "popen4() arg 2 must be 't' or 'b'");\r
- return NULL;\r
- } else\r
- tm = _O_BINARY;\r
-\r
- if (bufsize != -1) {\r
- PyErr_SetString(PyExc_ValueError, "popen4() arg 3 must be -1");\r
- return NULL;\r
- }\r
-\r
- f = _PyPopen(cmdstring, tm, POPEN_4);\r
-\r
- return f;\r
-}\r
-\r
-static BOOL\r
-_PyPopenCreateProcess(char *cmdstring,\r
- HANDLE hStdin,\r
- HANDLE hStdout,\r
- HANDLE hStderr,\r
- HANDLE *hProcess)\r
-{\r
- PROCESS_INFORMATION piProcInfo;\r
- STARTUPINFO siStartInfo;\r
- DWORD dwProcessFlags = 0; /* no NEW_CONSOLE by default for Ctrl+C handling */\r
- char *s1,*s2, *s3 = " /c ";\r
- const char *szConsoleSpawn = "w9xpopen.exe";\r
- int i;\r
- Py_ssize_t x;\r
-\r
- if (i = GetEnvironmentVariable("COMSPEC",NULL,0)) {\r
- char *comshell;\r
-\r
- s1 = (char *)alloca(i);\r
- if (!(x = GetEnvironmentVariable("COMSPEC", s1, i)))\r
- /* x < i, so x fits into an integer */\r
- return (int)x;\r
-\r
- /* Explicitly check if we are using COMMAND.COM. If we are\r
- * then use the w9xpopen hack.\r
- */\r
- comshell = s1 + x;\r
- while (comshell >= s1 && *comshell != '\\')\r
- --comshell;\r
- ++comshell;\r
-\r
- if (GetVersion() < 0x80000000 &&\r
- _stricmp(comshell, "command.com") != 0) {\r
- /* NT/2000 and not using command.com. */\r
- x = i + strlen(s3) + strlen(cmdstring) + 1;\r
- s2 = (char *)alloca(x);\r
- ZeroMemory(s2, x);\r
- PyOS_snprintf(s2, x, "%s%s%s", s1, s3, cmdstring);\r
- }\r
- else {\r
- /*\r
- * Oh gag, we're on Win9x or using COMMAND.COM. Use\r
- * the workaround listed in KB: Q150956\r
- */\r
- char modulepath[_MAX_PATH];\r
- struct stat statinfo;\r
- GetModuleFileName(NULL, modulepath, sizeof(modulepath));\r
- for (x = i = 0; modulepath[i]; i++)\r
- if (modulepath[i] == SEP)\r
- x = i+1;\r
- modulepath[x] = '\0';\r
- /* Create the full-name to w9xpopen, so we can test it exists */\r
- strncat(modulepath,\r
- szConsoleSpawn,\r
- (sizeof(modulepath)/sizeof(modulepath[0]))\r
- -strlen(modulepath));\r
- if (stat(modulepath, &statinfo) != 0) {\r
- size_t mplen = sizeof(modulepath)/sizeof(modulepath[0]);\r
- /* Eeek - file-not-found - possibly an embedding\r
- situation - see if we can locate it in sys.prefix\r
- */\r
- strncpy(modulepath,\r
- Py_GetExecPrefix(),\r
- mplen);\r
- modulepath[mplen-1] = '\0';\r
- if (modulepath[strlen(modulepath)-1] != '\\')\r
- strcat(modulepath, "\\");\r
- strncat(modulepath,\r
- szConsoleSpawn,\r
- mplen-strlen(modulepath));\r
- /* No where else to look - raise an easily identifiable\r
- error, rather than leaving Windows to report\r
- "file not found" - as the user is probably blissfully\r
- unaware this shim EXE is used, and it will confuse them.\r
- (well, it confused me for a while ;-)\r
- */\r
- if (stat(modulepath, &statinfo) != 0) {\r
- PyErr_Format(PyExc_RuntimeError,\r
- "Can not locate '%s' which is needed "\r
- "for popen to work with your shell "\r
- "or platform.",\r
- szConsoleSpawn);\r
- return FALSE;\r
- }\r
- }\r
- x = i + strlen(s3) + strlen(cmdstring) + 1 +\r
- strlen(modulepath) +\r
- strlen(szConsoleSpawn) + 1;\r
-\r
- s2 = (char *)alloca(x);\r
- ZeroMemory(s2, x);\r
- /* To maintain correct argument passing semantics,\r
- we pass the command-line as it stands, and allow\r
- quoting to be applied. w9xpopen.exe will then\r
- use its argv vector, and re-quote the necessary\r
- args for the ultimate child process.\r
- */\r
- PyOS_snprintf(\r
- s2, x,\r
- "\"%s\" %s%s%s",\r
- modulepath,\r
- s1,\r
- s3,\r
- cmdstring);\r
- /* Not passing CREATE_NEW_CONSOLE has been known to\r
- cause random failures on win9x. Specifically a\r
- dialog:\r
- "Your program accessed mem currently in use at xxx"\r
- and a hopeful warning about the stability of your\r
- system.\r
- Cost is Ctrl+C won't kill children, but anyone\r
- who cares can have a go!\r
- */\r
- dwProcessFlags |= CREATE_NEW_CONSOLE;\r
- }\r
- }\r
-\r
- /* Could be an else here to try cmd.exe / command.com in the path\r
- Now we'll just error out.. */\r
- else {\r
- PyErr_SetString(PyExc_RuntimeError,\r
- "Cannot locate a COMSPEC environment variable to "\r
- "use as the shell");\r
- return FALSE;\r
- }\r
-\r
- ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));\r
- siStartInfo.cb = sizeof(STARTUPINFO);\r
- siStartInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;\r
- siStartInfo.hStdInput = hStdin;\r
- siStartInfo.hStdOutput = hStdout;\r
- siStartInfo.hStdError = hStderr;\r
- siStartInfo.wShowWindow = SW_HIDE;\r
-\r
- if (CreateProcess(NULL,\r
- s2,\r
- NULL,\r
- NULL,\r
- TRUE,\r
- dwProcessFlags,\r
- NULL,\r
- NULL,\r
- &siStartInfo,\r
- &piProcInfo) ) {\r
- /* Close the handles now so anyone waiting is woken. */\r
- CloseHandle(piProcInfo.hThread);\r
-\r
- /* Return process handle */\r
- *hProcess = piProcInfo.hProcess;\r
- return TRUE;\r
- }\r
- win32_error("CreateProcess", s2);\r
- return FALSE;\r
-}\r
-\r
-/* The following code is based off of KB: Q190351 */\r
-\r
-static PyObject *\r
-_PyPopen(char *cmdstring, int mode, int n)\r
-{\r
- HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr,\r
- hChildStderrRd, hChildStderrWr, hChildStdinWrDup, hChildStdoutRdDup,\r
- hChildStderrRdDup, hProcess; /* hChildStdoutWrDup; */\r
-\r
- SECURITY_ATTRIBUTES saAttr;\r
- BOOL fSuccess;\r
- int fd1, fd2, fd3;\r
- FILE *f1, *f2, *f3;\r
- long file_count;\r
- PyObject *f;\r
-\r
- saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);\r
- saAttr.bInheritHandle = TRUE;\r
- saAttr.lpSecurityDescriptor = NULL;\r
-\r
- if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0))\r
- return win32_error("CreatePipe", NULL);\r
-\r
- /* Create new output read handle and the input write handle. Set\r
- * the inheritance properties to FALSE. Otherwise, the child inherits\r
- * these handles; resulting in non-closeable handles to the pipes\r
- * being created. */\r
- fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr,\r
- GetCurrentProcess(), &hChildStdinWrDup, 0,\r
- FALSE,\r
- DUPLICATE_SAME_ACCESS);\r
- if (!fSuccess)\r
- return win32_error("DuplicateHandle", NULL);\r
-\r
- /* Close the inheritable version of ChildStdin\r
- that we're using. */\r
- CloseHandle(hChildStdinWr);\r
-\r
- if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0))\r
- return win32_error("CreatePipe", NULL);\r
-\r
- fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,\r
- GetCurrentProcess(), &hChildStdoutRdDup, 0,\r
- FALSE, DUPLICATE_SAME_ACCESS);\r
- if (!fSuccess)\r
- return win32_error("DuplicateHandle", NULL);\r
-\r
- /* Close the inheritable version of ChildStdout\r
- that we're using. */\r
- CloseHandle(hChildStdoutRd);\r
-\r
- if (n != POPEN_4) {\r
- if (!CreatePipe(&hChildStderrRd, &hChildStderrWr, &saAttr, 0))\r
- return win32_error("CreatePipe", NULL);\r
- fSuccess = DuplicateHandle(GetCurrentProcess(),\r
- hChildStderrRd,\r
- GetCurrentProcess(),\r
- &hChildStderrRdDup, 0,\r
- FALSE, DUPLICATE_SAME_ACCESS);\r
- if (!fSuccess)\r
- return win32_error("DuplicateHandle", NULL);\r
- /* Close the inheritable version of ChildStdErr that we're using. */\r
- CloseHandle(hChildStderrRd);\r
- }\r
-\r
- switch (n) {\r
- case POPEN_1:\r
- switch (mode & (_O_RDONLY | _O_TEXT | _O_BINARY | _O_WRONLY)) {\r
- case _O_WRONLY | _O_TEXT:\r
- /* Case for writing to child Stdin in text mode. */\r
- fd1 = _open_osfhandle((Py_intptr_t)hChildStdinWrDup, mode);\r
- f1 = _fdopen(fd1, "w");\r
- f = PyFile_FromFile(f1, cmdstring, "w", _PyPclose);\r
- PyFile_SetBufSize(f, 0);\r
- /* We don't care about these pipes anymore, so close them. */\r
- CloseHandle(hChildStdoutRdDup);\r
- CloseHandle(hChildStderrRdDup);\r
- break;\r
-\r
- case _O_RDONLY | _O_TEXT:\r
- /* Case for reading from child Stdout in text mode. */\r
- fd1 = _open_osfhandle((Py_intptr_t)hChildStdoutRdDup, mode);\r
- f1 = _fdopen(fd1, "r");\r
- f = PyFile_FromFile(f1, cmdstring, "r", _PyPclose);\r
- PyFile_SetBufSize(f, 0);\r
- /* We don't care about these pipes anymore, so close them. */\r
- CloseHandle(hChildStdinWrDup);\r
- CloseHandle(hChildStderrRdDup);\r
- break;\r
-\r
- case _O_RDONLY | _O_BINARY:\r
- /* Case for readinig from child Stdout in binary mode. */\r
- fd1 = _open_osfhandle((Py_intptr_t)hChildStdoutRdDup, mode);\r
- f1 = _fdopen(fd1, "rb");\r
- f = PyFile_FromFile(f1, cmdstring, "rb", _PyPclose);\r
- PyFile_SetBufSize(f, 0);\r
- /* We don't care about these pipes anymore, so close them. */\r
- CloseHandle(hChildStdinWrDup);\r
- CloseHandle(hChildStderrRdDup);\r
- break;\r
-\r
- case _O_WRONLY | _O_BINARY:\r
- /* Case for writing to child Stdin in binary mode. */\r
- fd1 = _open_osfhandle((Py_intptr_t)hChildStdinWrDup, mode);\r
- f1 = _fdopen(fd1, "wb");\r
- f = PyFile_FromFile(f1, cmdstring, "wb", _PyPclose);\r
- PyFile_SetBufSize(f, 0);\r
- /* We don't care about these pipes anymore, so close them. */\r
- CloseHandle(hChildStdoutRdDup);\r
- CloseHandle(hChildStderrRdDup);\r
- break;\r
- }\r
- file_count = 1;\r
- break;\r
-\r
- case POPEN_2:\r
- case POPEN_4:\r
- {\r
- char *m1, *m2;\r
- PyObject *p1, *p2;\r
-\r
- if (mode & _O_TEXT) {\r
- m1 = "r";\r
- m2 = "w";\r
- } else {\r
- m1 = "rb";\r
- m2 = "wb";\r
- }\r
-\r
- fd1 = _open_osfhandle((Py_intptr_t)hChildStdinWrDup, mode);\r
- f1 = _fdopen(fd1, m2);\r
- fd2 = _open_osfhandle((Py_intptr_t)hChildStdoutRdDup, mode);\r
- f2 = _fdopen(fd2, m1);\r
- p1 = PyFile_FromFile(f1, cmdstring, m2, _PyPclose);\r
- PyFile_SetBufSize(p1, 0);\r
- p2 = PyFile_FromFile(f2, cmdstring, m1, _PyPclose);\r
- PyFile_SetBufSize(p2, 0);\r
-\r
- if (n != 4)\r
- CloseHandle(hChildStderrRdDup);\r
-\r
- f = PyTuple_Pack(2,p1,p2);\r
- Py_XDECREF(p1);\r
- Py_XDECREF(p2);\r
- file_count = 2;\r
- break;\r
- }\r
-\r
- case POPEN_3:\r
- {\r
- char *m1, *m2;\r
- PyObject *p1, *p2, *p3;\r
-\r
- if (mode & _O_TEXT) {\r
- m1 = "r";\r
- m2 = "w";\r
- } else {\r
- m1 = "rb";\r
- m2 = "wb";\r
- }\r
-\r
- fd1 = _open_osfhandle((Py_intptr_t)hChildStdinWrDup, mode);\r
- f1 = _fdopen(fd1, m2);\r
- fd2 = _open_osfhandle((Py_intptr_t)hChildStdoutRdDup, mode);\r
- f2 = _fdopen(fd2, m1);\r
- fd3 = _open_osfhandle((Py_intptr_t)hChildStderrRdDup, mode);\r
- f3 = _fdopen(fd3, m1);\r
- p1 = PyFile_FromFile(f1, cmdstring, m2, _PyPclose);\r
- p2 = PyFile_FromFile(f2, cmdstring, m1, _PyPclose);\r
- p3 = PyFile_FromFile(f3, cmdstring, m1, _PyPclose);\r
- PyFile_SetBufSize(p1, 0);\r
- PyFile_SetBufSize(p2, 0);\r
- PyFile_SetBufSize(p3, 0);\r
- f = PyTuple_Pack(3,p1,p2,p3);\r
- Py_XDECREF(p1);\r
- Py_XDECREF(p2);\r
- Py_XDECREF(p3);\r
- file_count = 3;\r
- break;\r
- }\r
- }\r
-\r
- if (n == POPEN_4) {\r
- if (!_PyPopenCreateProcess(cmdstring,\r
- hChildStdinRd,\r
- hChildStdoutWr,\r
- hChildStdoutWr,\r
- &hProcess))\r
- return NULL;\r
- }\r
- else {\r
- if (!_PyPopenCreateProcess(cmdstring,\r
- hChildStdinRd,\r
- hChildStdoutWr,\r
- hChildStderrWr,\r
- &hProcess))\r
- return NULL;\r
- }\r
-\r
- /*\r
- * Insert the files we've created into the process dictionary\r
- * all referencing the list with the process handle and the\r
- * initial number of files (see description below in _PyPclose).\r
- * Since if _PyPclose later tried to wait on a process when all\r
- * handles weren't closed, it could create a deadlock with the\r
- * child, we spend some energy here to try to ensure that we\r
- * either insert all file handles into the dictionary or none\r
- * at all. It's a little clumsy with the various popen modes\r
- * and variable number of files involved.\r
- */\r
- if (!_PyPopenProcs) {\r
- _PyPopenProcs = PyDict_New();\r
- }\r
-\r
- if (_PyPopenProcs) {\r
- PyObject *procObj, *hProcessObj, *intObj, *fileObj[3];\r
- int ins_rc[3];\r
-\r
- fileObj[0] = fileObj[1] = fileObj[2] = NULL;\r
- ins_rc[0] = ins_rc[1] = ins_rc[2] = 0;\r
-\r
- procObj = PyList_New(2);\r
- hProcessObj = PyLong_FromVoidPtr(hProcess);\r
- intObj = PyInt_FromLong(file_count);\r
-\r
- if (procObj && hProcessObj && intObj) {\r
- PyList_SetItem(procObj,0,hProcessObj);\r
- PyList_SetItem(procObj,1,intObj);\r
-\r
- fileObj[0] = PyLong_FromVoidPtr(f1);\r
- if (fileObj[0]) {\r
- ins_rc[0] = PyDict_SetItem(_PyPopenProcs,\r
- fileObj[0],\r
- procObj);\r
- }\r
- if (file_count >= 2) {\r
- fileObj[1] = PyLong_FromVoidPtr(f2);\r
- if (fileObj[1]) {\r
- ins_rc[1] = PyDict_SetItem(_PyPopenProcs,\r
- fileObj[1],\r
- procObj);\r
- }\r
- }\r
- if (file_count >= 3) {\r
- fileObj[2] = PyLong_FromVoidPtr(f3);\r
- if (fileObj[2]) {\r
- ins_rc[2] = PyDict_SetItem(_PyPopenProcs,\r
- fileObj[2],\r
- procObj);\r
- }\r
- }\r
-\r
- if (ins_rc[0] < 0 || !fileObj[0] ||\r
- ins_rc[1] < 0 || (file_count > 1 && !fileObj[1]) ||\r
- ins_rc[2] < 0 || (file_count > 2 && !fileObj[2])) {\r
- /* Something failed - remove any dictionary\r
- * entries that did make it.\r
- */\r
- if (!ins_rc[0] && fileObj[0]) {\r
- PyDict_DelItem(_PyPopenProcs,\r
- fileObj[0]);\r
- }\r
- if (!ins_rc[1] && fileObj[1]) {\r
- PyDict_DelItem(_PyPopenProcs,\r
- fileObj[1]);\r
- }\r
- if (!ins_rc[2] && fileObj[2]) {\r
- PyDict_DelItem(_PyPopenProcs,\r
- fileObj[2]);\r
- }\r
- }\r
- }\r
-\r
- /*\r
- * Clean up our localized references for the dictionary keys\r
- * and value since PyDict_SetItem will Py_INCREF any copies\r
- * that got placed in the dictionary.\r
- */\r
- Py_XDECREF(procObj);\r
- Py_XDECREF(fileObj[0]);\r
- Py_XDECREF(fileObj[1]);\r
- Py_XDECREF(fileObj[2]);\r
- }\r
-\r
- /* Child is launched. Close the parents copy of those pipe\r
- * handles that only the child should have open. You need to\r
- * make sure that no handles to the write end of the output pipe\r
- * are maintained in this process or else the pipe will not close\r
- * when the child process exits and the ReadFile will hang. */\r
-\r
- if (!CloseHandle(hChildStdinRd))\r
- return win32_error("CloseHandle", NULL);\r
-\r
- if (!CloseHandle(hChildStdoutWr))\r
- return win32_error("CloseHandle", NULL);\r
-\r
- if ((n != 4) && (!CloseHandle(hChildStderrWr)))\r
- return win32_error("CloseHandle", NULL);\r
-\r
- return f;\r
-}\r
-\r
-/*\r
- * Wrapper for fclose() to use for popen* files, so we can retrieve the\r
- * exit code for the child process and return as a result of the close.\r
- *\r
- * This function uses the _PyPopenProcs dictionary in order to map the\r
- * input file pointer to information about the process that was\r
- * originally created by the popen* call that created the file pointer.\r
- * The dictionary uses the file pointer as a key (with one entry\r
- * inserted for each file returned by the original popen* call) and a\r
- * single list object as the value for all files from a single call.\r
- * The list object contains the Win32 process handle at [0], and a file\r
- * count at [1], which is initialized to the total number of file\r
- * handles using that list.\r
- *\r
- * This function closes whichever handle it is passed, and decrements\r
- * the file count in the dictionary for the process handle pointed to\r
- * by this file. On the last close (when the file count reaches zero),\r
- * this function will wait for the child process and then return its\r
- * exit code as the result of the close() operation. This permits the\r
- * files to be closed in any order - it is always the close() of the\r
- * final handle that will return the exit code.\r
- *\r
- * NOTE: This function is currently called with the GIL released.\r
- * hence we use the GILState API to manage our state.\r
- */\r
-\r
-static int _PyPclose(FILE *file)\r
-{\r
- int result;\r
- DWORD exit_code;\r
- HANDLE hProcess;\r
- PyObject *procObj, *hProcessObj, *intObj, *fileObj;\r
- long file_count;\r
-#ifdef WITH_THREAD\r
- PyGILState_STATE state;\r
-#endif\r
-\r
- /* Close the file handle first, to ensure it can't block the\r
- * child from exiting if it's the last handle.\r
- */\r
- result = fclose(file);\r
-#ifdef WITH_THREAD\r
- state = PyGILState_Ensure();\r
-#endif\r
- if (_PyPopenProcs) {\r
- if ((fileObj = PyLong_FromVoidPtr(file)) != NULL &&\r
- (procObj = PyDict_GetItem(_PyPopenProcs,\r
- fileObj)) != NULL &&\r
- (hProcessObj = PyList_GetItem(procObj,0)) != NULL &&\r
- (intObj = PyList_GetItem(procObj,1)) != NULL) {\r
-\r
- hProcess = PyLong_AsVoidPtr(hProcessObj);\r
- file_count = PyInt_AsLong(intObj);\r
-\r
- if (file_count > 1) {\r
- /* Still other files referencing process */\r
- file_count--;\r
- PyList_SetItem(procObj,1,\r
- PyInt_FromLong(file_count));\r
- } else {\r
- /* Last file for this process */\r
- if (result != EOF &&\r
- WaitForSingleObject(hProcess, INFINITE) != WAIT_FAILED &&\r
- GetExitCodeProcess(hProcess, &exit_code)) {\r
- /* Possible truncation here in 16-bit environments, but\r
- * real exit codes are just the lower byte in any event.\r
- */\r
- result = exit_code;\r
- } else {\r
- /* Indicate failure - this will cause the file object\r
- * to raise an I/O error and translate the last Win32\r
- * error code from errno. We do have a problem with\r
- * last errors that overlap the normal errno table,\r
- * but that's a consistent problem with the file object.\r
- */\r
- if (result != EOF) {\r
- /* If the error wasn't from the fclose(), then\r
- * set errno for the file object error handling.\r
- */\r
- errno = GetLastError();\r
- }\r
- result = -1;\r
- }\r
-\r
- /* Free up the native handle at this point */\r
- CloseHandle(hProcess);\r
- }\r
-\r
- /* Remove this file pointer from dictionary */\r
- PyDict_DelItem(_PyPopenProcs, fileObj);\r
-\r
- if (PyDict_Size(_PyPopenProcs) == 0) {\r
- Py_DECREF(_PyPopenProcs);\r
- _PyPopenProcs = NULL;\r
- }\r
-\r
- } /* if object retrieval ok */\r
-\r
- Py_XDECREF(fileObj);\r
- } /* if _PyPopenProcs */\r
-\r
-#ifdef WITH_THREAD\r
- PyGILState_Release(state);\r
-#endif\r
- return result;\r
-}\r
-\r
-#else /* which OS? */\r
-static PyObject *\r
-posix_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 posix_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 /* PYOS_??? */\r
-#endif /* HAVE_POPEN */\r
-\r
-\r
-#ifdef HAVE_SETUID\r
-PyDoc_STRVAR(posix_setuid__doc__,\r
-"setuid(uid)\n\n\\r
-Set the current process's user id.");\r
-\r
-static PyObject *\r
-posix_setuid(PyObject *self, PyObject *args)\r
-{\r
- long uid_arg;\r
- uid_t uid;\r
- if (!PyArg_ParseTuple(args, "l:setuid", &uid_arg))\r
- return NULL;\r
- uid = uid_arg;\r
- if (uid != uid_arg) {\r
- PyErr_SetString(PyExc_OverflowError, "user id too big");\r
- return NULL;\r
- }\r
- if (setuid(uid) < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETUID */\r
-\r
-\r
-#ifdef HAVE_SETEUID\r
-PyDoc_STRVAR(posix_seteuid__doc__,\r
-"seteuid(uid)\n\n\\r
-Set the current process's effective user id.");\r
-\r
-static PyObject *\r
-posix_seteuid (PyObject *self, PyObject *args)\r
-{\r
- long euid_arg;\r
- uid_t euid;\r
- if (!PyArg_ParseTuple(args, "l", &euid_arg))\r
- return NULL;\r
- euid = euid_arg;\r
- if (euid != euid_arg) {\r
- PyErr_SetString(PyExc_OverflowError, "user id too big");\r
- return NULL;\r
- }\r
- if (seteuid(euid) < 0) {\r
- return posix_error();\r
- } else {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-}\r
-#endif /* HAVE_SETEUID */\r
-\r
-#ifdef HAVE_SETEGID\r
-PyDoc_STRVAR(posix_setegid__doc__,\r
-"setegid(gid)\n\n\\r
-Set the current process's effective group id.");\r
-\r
-static PyObject *\r
-posix_setegid (PyObject *self, PyObject *args)\r
-{\r
- long egid_arg;\r
- gid_t egid;\r
- if (!PyArg_ParseTuple(args, "l", &egid_arg))\r
- return NULL;\r
- egid = egid_arg;\r
- if (egid != egid_arg) {\r
- PyErr_SetString(PyExc_OverflowError, "group id too big");\r
- return NULL;\r
- }\r
- if (setegid(egid) < 0) {\r
- return posix_error();\r
- } else {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-}\r
-#endif /* HAVE_SETEGID */\r
-\r
-#ifdef HAVE_SETREUID\r
-PyDoc_STRVAR(posix_setreuid__doc__,\r
-"setreuid(ruid, euid)\n\n\\r
-Set the current process's real and effective user ids.");\r
-\r
-static PyObject *\r
-posix_setreuid (PyObject *self, PyObject *args)\r
-{\r
- long ruid_arg, euid_arg;\r
- uid_t ruid, euid;\r
- if (!PyArg_ParseTuple(args, "ll", &ruid_arg, &euid_arg))\r
- return NULL;\r
- if (ruid_arg == -1)\r
- ruid = (uid_t)-1; /* let the compiler choose how -1 fits */\r
- else\r
- ruid = ruid_arg; /* otherwise, assign from our long */\r
- if (euid_arg == -1)\r
- euid = (uid_t)-1;\r
- else\r
- euid = euid_arg;\r
- if ((euid_arg != -1 && euid != euid_arg) ||\r
- (ruid_arg != -1 && ruid != ruid_arg)) {\r
- PyErr_SetString(PyExc_OverflowError, "user id too big");\r
- return NULL;\r
- }\r
- if (setreuid(ruid, euid) < 0) {\r
- return posix_error();\r
- } else {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-}\r
-#endif /* HAVE_SETREUID */\r
-\r
-#ifdef HAVE_SETREGID\r
-PyDoc_STRVAR(posix_setregid__doc__,\r
-"setregid(rgid, egid)\n\n\\r
-Set the current process's real and effective group ids.");\r
-\r
-static PyObject *\r
-posix_setregid (PyObject *self, PyObject *args)\r
-{\r
- long rgid_arg, egid_arg;\r
- gid_t rgid, egid;\r
- if (!PyArg_ParseTuple(args, "ll", &rgid_arg, &egid_arg))\r
- return NULL;\r
- if (rgid_arg == -1)\r
- rgid = (gid_t)-1; /* let the compiler choose how -1 fits */\r
- else\r
- rgid = rgid_arg; /* otherwise, assign from our long */\r
- if (egid_arg == -1)\r
- egid = (gid_t)-1;\r
- else\r
- egid = egid_arg;\r
- if ((egid_arg != -1 && egid != egid_arg) ||\r
- (rgid_arg != -1 && rgid != rgid_arg)) {\r
- PyErr_SetString(PyExc_OverflowError, "group id too big");\r
- return NULL;\r
- }\r
- if (setregid(rgid, egid) < 0) {\r
- return posix_error();\r
- } else {\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
- }\r
-}\r
-#endif /* HAVE_SETREGID */\r
-\r
-#ifdef HAVE_SETGID\r
-PyDoc_STRVAR(posix_setgid__doc__,\r
-"setgid(gid)\n\n\\r
-Set the current process's group id.");\r
-\r
-static PyObject *\r
-posix_setgid(PyObject *self, PyObject *args)\r
-{\r
- long gid_arg;\r
- gid_t gid;\r
- if (!PyArg_ParseTuple(args, "l:setgid", &gid_arg))\r
- return NULL;\r
- gid = gid_arg;\r
- if (gid != gid_arg) {\r
- PyErr_SetString(PyExc_OverflowError, "group id too big");\r
- return NULL;\r
- }\r
- if (setgid(gid) < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETGID */\r
-\r
-#ifdef HAVE_SETGROUPS\r
-PyDoc_STRVAR(posix_setgroups__doc__,\r
-"setgroups(list)\n\n\\r
-Set the groups of the current process to list.");\r
-\r
-static PyObject *\r
-posix_setgroups(PyObject *self, PyObject *groups)\r
-{\r
- int i, len;\r
- gid_t grouplist[MAX_GROUPS];\r
-\r
- if (!PySequence_Check(groups)) {\r
- PyErr_SetString(PyExc_TypeError, "setgroups argument must be a sequence");\r
- return NULL;\r
- }\r
- len = PySequence_Size(groups);\r
- if (len > MAX_GROUPS) {\r
- PyErr_SetString(PyExc_ValueError, "too many groups");\r
- return NULL;\r
- }\r
- for(i = 0; i < len; i++) {\r
- PyObject *elem;\r
- elem = PySequence_GetItem(groups, i);\r
- if (!elem)\r
- return NULL;\r
- if (!PyInt_Check(elem)) {\r
- if (!PyLong_Check(elem)) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "groups must be integers");\r
- Py_DECREF(elem);\r
- return NULL;\r
- } else {\r
- unsigned long x = PyLong_AsUnsignedLong(elem);\r
- if (PyErr_Occurred()) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "group id too big");\r
- Py_DECREF(elem);\r
- return NULL;\r
- }\r
- grouplist[i] = x;\r
- /* read back to see if it fits in gid_t */\r
- if (grouplist[i] != x) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "group id too big");\r
- Py_DECREF(elem);\r
- return NULL;\r
- }\r
- }\r
- } else {\r
- long x = PyInt_AsLong(elem);\r
- grouplist[i] = x;\r
- if (grouplist[i] != x) {\r
- PyErr_SetString(PyExc_TypeError,\r
- "group id too big");\r
- Py_DECREF(elem);\r
- return NULL;\r
- }\r
- }\r
- Py_DECREF(elem);\r
- }\r
-\r
- if (setgroups(len, grouplist) < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETGROUPS */\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 posix_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(posix_wait3__doc__,\r
-"wait3(options) -> (pid, status, rusage)\n\n\\r
-Wait for completion of a child process.");\r
-\r
-static PyObject *\r
-posix_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(posix_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
-posix_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(posix_waitpid__doc__,\r
-"waitpid(pid, options) -> (pid, status)\n\n\\r
-Wait for completion of a given child process.");\r
-\r
-static PyObject *\r
-posix_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 posix_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(posix_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
-posix_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 posix_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(posix_wait__doc__,\r
-"wait() -> (pid, status)\n\n\\r
-Wait for completion of a child process.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
-\r
- return Py_BuildValue("Ni", PyLong_FromPid(pid), WAIT_STATUS_INT(status));\r
-}\r
-#endif\r
-\r
-\r
-PyDoc_STRVAR(posix_lstat__doc__,\r
-"lstat(path) -> stat result\n\n\\r
-Like stat(path), but do not follow symbolic links.");\r
-\r
-static PyObject *\r
-posix_lstat(PyObject *self, PyObject *args)\r
-{\r
-#ifdef HAVE_LSTAT\r
- return posix_do_stat(self, args, "et:lstat", lstat, NULL, NULL);\r
-#else /* !HAVE_LSTAT */\r
-#ifdef MS_WINDOWS\r
- return posix_do_stat(self, args, "et:lstat", STAT, "U:lstat", win32_wstat);\r
-#else\r
- return posix_do_stat(self, args, "et:lstat", STAT, NULL, NULL);\r
-#endif\r
-#endif /* !HAVE_LSTAT */\r
-}\r
-\r
-\r
-#ifdef HAVE_READLINK\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_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(posix_symlink__doc__,\r
-"symlink(src, dst)\n\n\\r
-Create a symbolic link pointing to src named dst.");\r
-\r
-static PyObject *\r
-posix_symlink(PyObject *self, PyObject *args)\r
-{\r
- return posix_2str(args, "etet:symlink", symlink);\r
-}\r
-#endif /* HAVE_SYMLINK */\r
-\r
-\r
-#ifdef HAVE_TIMES\r
-#if defined(PYCC_VACPP) && defined(PYOS_OS2)\r
-static long\r
-system_uptime(void)\r
-{\r
- ULONG value = 0;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &value, sizeof(value));\r
- Py_END_ALLOW_THREADS\r
-\r
- return value;\r
-}\r
-\r
-static PyObject *\r
-posix_times(PyObject *self, PyObject *noargs)\r
-{\r
- /* Currently Only Uptime is Provided -- Others Later */\r
- return Py_BuildValue("ddddd",\r
- (double)0 /* t.tms_utime / HZ */,\r
- (double)0 /* t.tms_stime / HZ */,\r
- (double)0 /* t.tms_cutime / HZ */,\r
- (double)0 /* t.tms_cstime / HZ */,\r
- (double)system_uptime() / 1000);\r
-}\r
-#else /* not OS2 */\r
-#define NEED_TICKS_PER_SECOND\r
-static long ticks_per_second = -1;\r
-static PyObject *\r
-posix_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 posix_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 /* not OS2 */\r
-#endif /* HAVE_TIMES */\r
-\r
-\r
-#ifdef MS_WINDOWS\r
-#define HAVE_TIMES /* so the method table will pick it up */\r
-static PyObject *\r
-posix_times(PyObject *self, PyObject *noargs)\r
-{\r
- FILETIME create, exit, kernel, user;\r
- HANDLE hProc;\r
- hProc = GetCurrentProcess();\r
- GetProcessTimes(hProc, &create, &exit, &kernel, &user);\r
- /* The fields of a FILETIME structure are the hi and lo part\r
- of a 64-bit value expressed in 100 nanosecond units.\r
- 1e7 is one second in such units; 1e-7 the inverse.\r
- 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.\r
- */\r
- return Py_BuildValue(\r
- "ddddd",\r
- (double)(user.dwHighDateTime*429.4967296 +\r
- user.dwLowDateTime*1e-7),\r
- (double)(kernel.dwHighDateTime*429.4967296 +\r
- kernel.dwLowDateTime*1e-7),\r
- (double)0,\r
- (double)0,\r
- (double)0);\r
-}\r
-#endif /* MS_WINDOWS */\r
-\r
-#ifdef HAVE_TIMES\r
-PyDoc_STRVAR(posix_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(posix_getsid__doc__,\r
-"getsid(pid) -> sid\n\n\\r
-Call the system call getsid().");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- return PyInt_FromLong((long)sid);\r
-}\r
-#endif /* HAVE_GETSID */\r
-\r
-\r
-#ifdef HAVE_SETSID\r
-PyDoc_STRVAR(posix_setsid__doc__,\r
-"setsid()\n\n\\r
-Call the system call setsid().");\r
-\r
-static PyObject *\r
-posix_setsid(PyObject *self, PyObject *noargs)\r
-{\r
- if (setsid() < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETSID */\r
-\r
-#ifdef HAVE_SETPGID\r
-PyDoc_STRVAR(posix_setpgid__doc__,\r
-"setpgid(pid, pgrp)\n\n\\r
-Call the system call setpgid().");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* HAVE_SETPGID */\r
-\r
-\r
-#ifdef HAVE_TCGETPGRP\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_error();\r
- return PyLong_FromPid(pgid);\r
-}\r
-#endif /* HAVE_TCGETPGRP */\r
-\r
-\r
-#ifdef HAVE_TCSETPGRP\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_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(posix_open__doc__,\r
-"open(filename, flag [, mode=0777]) -> fd\n\n\\r
-Open a file (for low level IO).");\r
-\r
-static PyObject *\r
-posix_open(PyObject *self, PyObject *args)\r
-{\r
- char *file = NULL;\r
- int flag;\r
- int mode = 0777;\r
- int fd;\r
-\r
-#ifdef MS_WINDOWS\r
- PyUnicodeObject *po;\r
- if (PyArg_ParseTuple(args, "Ui|i:mkdir", &po, &flag, &mode)) {\r
- Py_BEGIN_ALLOW_THREADS\r
- /* PyUnicode_AS_UNICODE OK without thread\r
- lock as it is a simple dereference. */\r
- fd = _wopen(PyUnicode_AS_UNICODE(po), flag, mode);\r
- Py_END_ALLOW_THREADS\r
- if (fd < 0)\r
- return posix_error();\r
- return PyInt_FromLong((long)fd);\r
- }\r
- /* Drop the argument parsing error as narrow strings\r
- are also valid. */\r
- PyErr_Clear();\r
-#endif\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 posix_error_with_allocated_filename(file);\r
- PyMem_Free(file);\r
- return PyInt_FromLong((long)fd);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_close__doc__,\r
-"close(fd)\n\n\\r
-Close a file descriptor (for low level IO).");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = close(fd);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_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
-posix_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(posix_dup__doc__,\r
-"dup(fd) -> fd2\n\n\\r
-Return a duplicate of a file descriptor.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- fd = dup(fd);\r
- Py_END_ALLOW_THREADS\r
- if (fd < 0)\r
- return posix_error();\r
- return PyInt_FromLong((long)fd);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_dup2__doc__,\r
-"dup2(old_fd, new_fd)\n\n\\r
-Duplicate file descriptor.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = dup2(fd, fd2);\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_lseek__doc__,\r
-"lseek(fd, pos, how) -> newpos\n\n\\r
-Set the current position of a file descriptor.");\r
-\r
-static PyObject *\r
-posix_lseek(PyObject *self, PyObject *args)\r
-{\r
- int fd, how;\r
-#if defined(MS_WIN64) || defined(MS_WINDOWS)\r
- PY_LONG_LONG pos, res;\r
-#else\r
- off_t pos, res;\r
-#endif\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 posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
-#if defined(MS_WIN64) || defined(MS_WINDOWS)\r
- res = _lseeki64(fd, pos, how);\r
-#else\r
- res = lseek(fd, pos, how);\r
-#endif\r
- Py_END_ALLOW_THREADS\r
- if (res < 0)\r
- return posix_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(posix_read__doc__,\r
-"read(fd, buffersize) -> string\n\n\\r
-Read a file descriptor.");\r
-\r
-static PyObject *\r
-posix_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 posix_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 posix_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 posix_error();\r
- }\r
- if (n != size)\r
- _PyString_Resize(&buffer, n);\r
- return buffer;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_write__doc__,\r
-"write(fd, string) -> byteswritten\n\n\\r
-Write a string to a file descriptor.");\r
-\r
-static PyObject *\r
-posix_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 posix_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 posix_error();\r
- return PyInt_FromSsize_t(size);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_fstat__doc__,\r
-"fstat(fd) -> stat result\n\n\\r
-Like stat(), but for an open file descriptor.");\r
-\r
-static PyObject *\r
-posix_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
-#ifdef __VMS\r
- /* on OpenVMS we must ensure that all bytes are written to the file */\r
- fsync(fd);\r
-#endif\r
- if (!_PyVerify_fd(fd))\r
- return posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
- res = FSTAT(fd, &st);\r
- Py_END_ALLOW_THREADS\r
- if (res != 0) {\r
-#ifdef MS_WINDOWS\r
- return win32_error("fstat", NULL);\r
-#else\r
- return posix_error();\r
-#endif\r
- }\r
-\r
- return _pystat_fromstructstat(&st);\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_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
-posix_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 posix_error();\r
- Py_BEGIN_ALLOW_THREADS\r
-#if !defined(MS_WINDOWS) && 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 posix_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(posix_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
-posix_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(posix_pipe__doc__,\r
-"pipe() -> (read_end, write_end)\n\n\\r
-Create a pipe.");\r
-\r
-static PyObject *\r
-posix_pipe(PyObject *self, PyObject *noargs)\r
-{\r
-#if defined(PYOS_OS2)\r
- HFILE read, write;\r
- APIRET rc;\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- rc = DosCreatePipe( &read, &write, 4096);\r
- Py_END_ALLOW_THREADS\r
- if (rc != NO_ERROR)\r
- return os2_error(rc);\r
-\r
- return Py_BuildValue("(ii)", read, write);\r
-#else\r
-#if !defined(MS_WINDOWS)\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 posix_error();\r
- return Py_BuildValue("(ii)", fds[0], fds[1]);\r
-#else /* MS_WINDOWS */\r
- HANDLE read, write;\r
- int read_fd, write_fd;\r
- BOOL ok;\r
- Py_BEGIN_ALLOW_THREADS\r
- ok = CreatePipe(&read, &write, NULL, 0);\r
- Py_END_ALLOW_THREADS\r
- if (!ok)\r
- return win32_error("CreatePipe", NULL);\r
- read_fd = _open_osfhandle((Py_intptr_t)read, 0);\r
- write_fd = _open_osfhandle((Py_intptr_t)write, 1);\r
- return Py_BuildValue("(ii)", read_fd, write_fd);\r
-#endif /* MS_WINDOWS */\r
-#endif\r
-}\r
-#endif /* HAVE_PIPE */\r
-\r
-\r
-#ifdef HAVE_MKFIFO\r
-PyDoc_STRVAR(posix_mkfifo__doc__,\r
-"mkfifo(filename [, mode=0666])\n\n\\r
-Create a FIFO (a POSIX named pipe).");\r
-\r
-static PyObject *\r
-posix_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 posix_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(posix_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
-posix_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 posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_DEVICE_MACROS\r
-PyDoc_STRVAR(posix_major__doc__,\r
-"major(device) -> major number\n\\r
-Extracts a device major number from a raw device number.");\r
-\r
-static PyObject *\r
-posix_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(posix_minor__doc__,\r
-"minor(device) -> minor number\n\\r
-Extracts a device minor number from a raw device number.");\r
-\r
-static PyObject *\r
-posix_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(posix_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
-posix_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(posix_ftruncate__doc__,\r
-"ftruncate(fd, length)\n\n\\r
-Truncate a file to a specified length.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_PUTENV\r
-PyDoc_STRVAR(posix_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 *posix_putenv_garbage;\r
-\r
-static PyObject *\r
-posix_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
-#if defined(PYOS_OS2)\r
- if (stricmp(s1, "BEGINLIBPATH") == 0) {\r
- APIRET rc;\r
-\r
- rc = DosSetExtLIBPATH(s2, BEGIN_LIBPATH);\r
- if (rc != NO_ERROR)\r
- return os2_error(rc);\r
-\r
- } else if (stricmp(s1, "ENDLIBPATH") == 0) {\r
- APIRET rc;\r
-\r
- rc = DosSetExtLIBPATH(s2, END_LIBPATH);\r
- if (rc != NO_ERROR)\r
- return os2_error(rc);\r
- } else {\r
-#endif\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
- posix_error();\r
- return NULL;\r
- }\r
- /* Install the first arg and newstr in posix_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(posix_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
-#if defined(PYOS_OS2)\r
- }\r
-#endif\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* putenv */\r
-\r
-#ifdef HAVE_UNSETENV\r
-PyDoc_STRVAR(posix_unsetenv__doc__,\r
-"unsetenv(key)\n\n\\r
-Delete an environment variable.");\r
-\r
-static PyObject *\r
-posix_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 posix_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(posix_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(posix_strerror__doc__,\r
-"strerror(code) -> string\n\n\\r
-Translate an error code to a message string.");\r
-\r
-static PyObject *\r
-posix_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(posix_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
-posix_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(posix_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
-posix_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(posix_WIFSTOPPED__doc__,\r
-"WIFSTOPPED(status) -> bool\n\n\\r
-Return True if the process returning 'status' was stopped.");\r
-\r
-static PyObject *\r
-posix_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(posix_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
-posix_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(posix_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
-posix_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(posix_WEXITSTATUS__doc__,\r
-"WEXITSTATUS(status) -> integer\n\n\\r
-Return the process return code from 'status'.");\r
-\r
-static PyObject *\r
-posix_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(posix_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
-posix_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(posix_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
-posix_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
-#ifdef _SCO_DS\r
-/* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the\r
- needed definitions in sys/statvfs.h */\r
-#define _SVID3\r
-#endif\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(posix_fstatvfs__doc__,\r
-"fstatvfs(fd) -> statvfs result\n\n\\r
-Perform an fstatvfs system call on the given fd.");\r
-\r
-static PyObject *\r
-posix_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 posix_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(posix_statvfs__doc__,\r
-"statvfs(path) -> statvfs result\n\n\\r
-Perform a statvfs system call on the given path.");\r
-\r
-static PyObject *\r
-posix_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 posix_error_with_filename(path);\r
-\r
- return _pystatvfs_fromstructstatvfs(st);\r
-}\r
-#endif /* HAVE_STATVFS */\r
-\r
-\r
-#ifdef HAVE_TEMPNAM\r
-PyDoc_STRVAR(posix_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
-posix_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
-#ifdef MS_WINDOWS\r
- name = _tempnam(dir, pfx);\r
-#else\r
- name = tempnam(dir, pfx);\r
-#endif\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(posix_tmpfile__doc__,\r
-"tmpfile() -> file object\n\n\\r
-Create a temporary file with no directory entries.");\r
-\r
-static PyObject *\r
-posix_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 posix_error();\r
- return PyFile_FromFile(fp, "<tmpfile>", "w+b", fclose);\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_TMPNAM\r
-PyDoc_STRVAR(posix_tmpnam__doc__,\r
-"tmpnam() -> string\n\n\\r
-Return a unique name for a temporary file.");\r
-\r
-static PyObject *\r
-posix_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
-\r
-/* This is used for fpathconf(), pathconf(), confstr() and sysconf().\r
- * It maps strings representing configuration variable names to\r
- * integer values, allowing those functions to be called with the\r
- * magic names instead of polluting the module's namespace with tons of\r
- * rarely-used constants. There are three separate tables that use\r
- * these definitions.\r
- *\r
- * This code is always included, even if none of the interfaces that\r
- * need it are included. The #if hackery needed to avoid it would be\r
- * sufficiently pervasive that it's not worth the loss of readability.\r
- */\r
-struct constdef {\r
- char *name;\r
- long value;\r
-};\r
-\r
-static int\r
-conv_confname(PyObject *arg, int *valuep, struct constdef *table,\r
- size_t tablesize)\r
-{\r
- if (PyInt_Check(arg)) {\r
- *valuep = PyInt_AS_LONG(arg);\r
- return 1;\r
- }\r
- if (PyString_Check(arg)) {\r
- /* look up the value in the table using a binary search */\r
- size_t lo = 0;\r
- size_t mid;\r
- size_t hi = tablesize;\r
- int cmp;\r
- char *confname = PyString_AS_STRING(arg);\r
- while (lo < hi) {\r
- mid = (lo + hi) / 2;\r
- cmp = strcmp(confname, table[mid].name);\r
- if (cmp < 0)\r
- hi = mid;\r
- else if (cmp > 0)\r
- lo = mid + 1;\r
- else {\r
- *valuep = table[mid].value;\r
- return 1;\r
- }\r
- }\r
- PyErr_SetString(PyExc_ValueError, "unrecognized configuration name");\r
- }\r
- else\r
- PyErr_SetString(PyExc_TypeError,\r
- "configuration names must be strings or integers");\r
- return 0;\r
-}\r
-\r
-\r
-#if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)\r
-static struct constdef posix_constants_pathconf[] = {\r
-#ifdef _PC_ABI_AIO_XFER_MAX\r
- {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX},\r
-#endif\r
-#ifdef _PC_ABI_ASYNC_IO\r
- {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO},\r
-#endif\r
-#ifdef _PC_ASYNC_IO\r
- {"PC_ASYNC_IO", _PC_ASYNC_IO},\r
-#endif\r
-#ifdef _PC_CHOWN_RESTRICTED\r
- {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED},\r
-#endif\r
-#ifdef _PC_FILESIZEBITS\r
- {"PC_FILESIZEBITS", _PC_FILESIZEBITS},\r
-#endif\r
-#ifdef _PC_LAST\r
- {"PC_LAST", _PC_LAST},\r
-#endif\r
-#ifdef _PC_LINK_MAX\r
- {"PC_LINK_MAX", _PC_LINK_MAX},\r
-#endif\r
-#ifdef _PC_MAX_CANON\r
- {"PC_MAX_CANON", _PC_MAX_CANON},\r
-#endif\r
-#ifdef _PC_MAX_INPUT\r
- {"PC_MAX_INPUT", _PC_MAX_INPUT},\r
-#endif\r
-#ifdef _PC_NAME_MAX\r
- {"PC_NAME_MAX", _PC_NAME_MAX},\r
-#endif\r
-#ifdef _PC_NO_TRUNC\r
- {"PC_NO_TRUNC", _PC_NO_TRUNC},\r
-#endif\r
-#ifdef _PC_PATH_MAX\r
- {"PC_PATH_MAX", _PC_PATH_MAX},\r
-#endif\r
-#ifdef _PC_PIPE_BUF\r
- {"PC_PIPE_BUF", _PC_PIPE_BUF},\r
-#endif\r
-#ifdef _PC_PRIO_IO\r
- {"PC_PRIO_IO", _PC_PRIO_IO},\r
-#endif\r
-#ifdef _PC_SOCK_MAXBUF\r
- {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF},\r
-#endif\r
-#ifdef _PC_SYNC_IO\r
- {"PC_SYNC_IO", _PC_SYNC_IO},\r
-#endif\r
-#ifdef _PC_VDISABLE\r
- {"PC_VDISABLE", _PC_VDISABLE},\r
-#endif\r
-};\r
-\r
-static int\r
-conv_path_confname(PyObject *arg, int *valuep)\r
-{\r
- return conv_confname(arg, valuep, posix_constants_pathconf,\r
- sizeof(posix_constants_pathconf)\r
- / sizeof(struct constdef));\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_FPATHCONF\r
-PyDoc_STRVAR(posix_fpathconf__doc__,\r
-"fpathconf(fd, name) -> integer\n\n\\r
-Return the configuration limit name for the file descriptor fd.\n\\r
-If there is no limit, return -1.");\r
-\r
-static PyObject *\r
-posix_fpathconf(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result = NULL;\r
- int name, fd;\r
-\r
- if (PyArg_ParseTuple(args, "iO&:fpathconf", &fd,\r
- conv_path_confname, &name)) {\r
- long limit;\r
-\r
- errno = 0;\r
- limit = fpathconf(fd, name);\r
- if (limit == -1 && errno != 0)\r
- posix_error();\r
- else\r
- result = PyInt_FromLong(limit);\r
- }\r
- return result;\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_PATHCONF\r
-PyDoc_STRVAR(posix_pathconf__doc__,\r
-"pathconf(path, name) -> integer\n\n\\r
-Return the configuration limit name for the file or directory path.\n\\r
-If there is no limit, return -1.");\r
-\r
-static PyObject *\r
-posix_pathconf(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result = NULL;\r
- int name;\r
- char *path;\r
-\r
- if (PyArg_ParseTuple(args, "sO&:pathconf", &path,\r
- conv_path_confname, &name)) {\r
- long limit;\r
-\r
- errno = 0;\r
- limit = pathconf(path, name);\r
- if (limit == -1 && errno != 0) {\r
- if (errno == EINVAL)\r
- /* could be a path or name problem */\r
- posix_error();\r
- else\r
- posix_error_with_filename(path);\r
- }\r
- else\r
- result = PyInt_FromLong(limit);\r
- }\r
- return result;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_CONFSTR\r
-static struct constdef posix_constants_confstr[] = {\r
-#ifdef _CS_ARCHITECTURE\r
- {"CS_ARCHITECTURE", _CS_ARCHITECTURE},\r
-#endif\r
-#ifdef _CS_HOSTNAME\r
- {"CS_HOSTNAME", _CS_HOSTNAME},\r
-#endif\r
-#ifdef _CS_HW_PROVIDER\r
- {"CS_HW_PROVIDER", _CS_HW_PROVIDER},\r
-#endif\r
-#ifdef _CS_HW_SERIAL\r
- {"CS_HW_SERIAL", _CS_HW_SERIAL},\r
-#endif\r
-#ifdef _CS_INITTAB_NAME\r
- {"CS_INITTAB_NAME", _CS_INITTAB_NAME},\r
-#endif\r
-#ifdef _CS_LFS64_CFLAGS\r
- {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS},\r
-#endif\r
-#ifdef _CS_LFS64_LDFLAGS\r
- {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS},\r
-#endif\r
-#ifdef _CS_LFS64_LIBS\r
- {"CS_LFS64_LIBS", _CS_LFS64_LIBS},\r
-#endif\r
-#ifdef _CS_LFS64_LINTFLAGS\r
- {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS},\r
-#endif\r
-#ifdef _CS_LFS_CFLAGS\r
- {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS},\r
-#endif\r
-#ifdef _CS_LFS_LDFLAGS\r
- {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS},\r
-#endif\r
-#ifdef _CS_LFS_LIBS\r
- {"CS_LFS_LIBS", _CS_LFS_LIBS},\r
-#endif\r
-#ifdef _CS_LFS_LINTFLAGS\r
- {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS},\r
-#endif\r
-#ifdef _CS_MACHINE\r
- {"CS_MACHINE", _CS_MACHINE},\r
-#endif\r
-#ifdef _CS_PATH\r
- {"CS_PATH", _CS_PATH},\r
-#endif\r
-#ifdef _CS_RELEASE\r
- {"CS_RELEASE", _CS_RELEASE},\r
-#endif\r
-#ifdef _CS_SRPC_DOMAIN\r
- {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN},\r
-#endif\r
-#ifdef _CS_SYSNAME\r
- {"CS_SYSNAME", _CS_SYSNAME},\r
-#endif\r
-#ifdef _CS_VERSION\r
- {"CS_VERSION", _CS_VERSION},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFF32_CFLAGS\r
- {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS\r
- {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFF32_LIBS\r
- {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS\r
- {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS\r
- {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS\r
- {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFFBIG_LIBS\r
- {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS},\r
-#endif\r
-#ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS\r
- {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_LP64_OFF64_CFLAGS\r
- {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_LP64_OFF64_LDFLAGS\r
- {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_LP64_OFF64_LIBS\r
- {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS},\r
-#endif\r
-#ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS\r
- {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS\r
- {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS\r
- {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS},\r
-#endif\r
-#ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS\r
- {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS},\r
-#endif\r
-#ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS\r
- {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS},\r
-#endif\r
-#ifdef _MIPS_CS_AVAIL_PROCESSORS\r
- {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS},\r
-#endif\r
-#ifdef _MIPS_CS_BASE\r
- {"MIPS_CS_BASE", _MIPS_CS_BASE},\r
-#endif\r
-#ifdef _MIPS_CS_HOSTID\r
- {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID},\r
-#endif\r
-#ifdef _MIPS_CS_HW_NAME\r
- {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME},\r
-#endif\r
-#ifdef _MIPS_CS_NUM_PROCESSORS\r
- {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS},\r
-#endif\r
-#ifdef _MIPS_CS_OSREL_MAJ\r
- {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ},\r
-#endif\r
-#ifdef _MIPS_CS_OSREL_MIN\r
- {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN},\r
-#endif\r
-#ifdef _MIPS_CS_OSREL_PATCH\r
- {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH},\r
-#endif\r
-#ifdef _MIPS_CS_OS_NAME\r
- {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME},\r
-#endif\r
-#ifdef _MIPS_CS_OS_PROVIDER\r
- {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER},\r
-#endif\r
-#ifdef _MIPS_CS_PROCESSORS\r
- {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS},\r
-#endif\r
-#ifdef _MIPS_CS_SERIAL\r
- {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL},\r
-#endif\r
-#ifdef _MIPS_CS_VENDOR\r
- {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR},\r
-#endif\r
-};\r
-\r
-static int\r
-conv_confstr_confname(PyObject *arg, int *valuep)\r
-{\r
- return conv_confname(arg, valuep, posix_constants_confstr,\r
- sizeof(posix_constants_confstr)\r
- / sizeof(struct constdef));\r
-}\r
-\r
-PyDoc_STRVAR(posix_confstr__doc__,\r
-"confstr(name) -> string\n\n\\r
-Return a string-valued system configuration variable.");\r
-\r
-static PyObject *\r
-posix_confstr(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result = NULL;\r
- int name;\r
- char buffer[256];\r
-\r
- if (PyArg_ParseTuple(args, "O&:confstr", conv_confstr_confname, &name)) {\r
- int len;\r
-\r
- errno = 0;\r
- len = confstr(name, buffer, sizeof(buffer));\r
- if (len == 0) {\r
- if (errno) {\r
- posix_error();\r
- }\r
- else {\r
- result = Py_None;\r
- Py_INCREF(Py_None);\r
- }\r
- }\r
- else {\r
- if ((unsigned int)len >= sizeof(buffer)) {\r
- result = PyString_FromStringAndSize(NULL, len-1);\r
- if (result != NULL)\r
- confstr(name, PyString_AS_STRING(result), len);\r
- }\r
- else\r
- result = PyString_FromStringAndSize(buffer, len-1);\r
- }\r
- }\r
- return result;\r
-}\r
-#endif\r
-\r
-\r
-#ifdef HAVE_SYSCONF\r
-static struct constdef posix_constants_sysconf[] = {\r
-#ifdef _SC_2_CHAR_TERM\r
- {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM},\r
-#endif\r
-#ifdef _SC_2_C_BIND\r
- {"SC_2_C_BIND", _SC_2_C_BIND},\r
-#endif\r
-#ifdef _SC_2_C_DEV\r
- {"SC_2_C_DEV", _SC_2_C_DEV},\r
-#endif\r
-#ifdef _SC_2_C_VERSION\r
- {"SC_2_C_VERSION", _SC_2_C_VERSION},\r
-#endif\r
-#ifdef _SC_2_FORT_DEV\r
- {"SC_2_FORT_DEV", _SC_2_FORT_DEV},\r
-#endif\r
-#ifdef _SC_2_FORT_RUN\r
- {"SC_2_FORT_RUN", _SC_2_FORT_RUN},\r
-#endif\r
-#ifdef _SC_2_LOCALEDEF\r
- {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF},\r
-#endif\r
-#ifdef _SC_2_SW_DEV\r
- {"SC_2_SW_DEV", _SC_2_SW_DEV},\r
-#endif\r
-#ifdef _SC_2_UPE\r
- {"SC_2_UPE", _SC_2_UPE},\r
-#endif\r
-#ifdef _SC_2_VERSION\r
- {"SC_2_VERSION", _SC_2_VERSION},\r
-#endif\r
-#ifdef _SC_ABI_ASYNCHRONOUS_IO\r
- {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO},\r
-#endif\r
-#ifdef _SC_ACL\r
- {"SC_ACL", _SC_ACL},\r
-#endif\r
-#ifdef _SC_AIO_LISTIO_MAX\r
- {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX},\r
-#endif\r
-#ifdef _SC_AIO_MAX\r
- {"SC_AIO_MAX", _SC_AIO_MAX},\r
-#endif\r
-#ifdef _SC_AIO_PRIO_DELTA_MAX\r
- {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX},\r
-#endif\r
-#ifdef _SC_ARG_MAX\r
- {"SC_ARG_MAX", _SC_ARG_MAX},\r
-#endif\r
-#ifdef _SC_ASYNCHRONOUS_IO\r
- {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO},\r
-#endif\r
-#ifdef _SC_ATEXIT_MAX\r
- {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX},\r
-#endif\r
-#ifdef _SC_AUDIT\r
- {"SC_AUDIT", _SC_AUDIT},\r
-#endif\r
-#ifdef _SC_AVPHYS_PAGES\r
- {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES},\r
-#endif\r
-#ifdef _SC_BC_BASE_MAX\r
- {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX},\r
-#endif\r
-#ifdef _SC_BC_DIM_MAX\r
- {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX},\r
-#endif\r
-#ifdef _SC_BC_SCALE_MAX\r
- {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX},\r
-#endif\r
-#ifdef _SC_BC_STRING_MAX\r
- {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX},\r
-#endif\r
-#ifdef _SC_CAP\r
- {"SC_CAP", _SC_CAP},\r
-#endif\r
-#ifdef _SC_CHARCLASS_NAME_MAX\r
- {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX},\r
-#endif\r
-#ifdef _SC_CHAR_BIT\r
- {"SC_CHAR_BIT", _SC_CHAR_BIT},\r
-#endif\r
-#ifdef _SC_CHAR_MAX\r
- {"SC_CHAR_MAX", _SC_CHAR_MAX},\r
-#endif\r
-#ifdef _SC_CHAR_MIN\r
- {"SC_CHAR_MIN", _SC_CHAR_MIN},\r
-#endif\r
-#ifdef _SC_CHILD_MAX\r
- {"SC_CHILD_MAX", _SC_CHILD_MAX},\r
-#endif\r
-#ifdef _SC_CLK_TCK\r
- {"SC_CLK_TCK", _SC_CLK_TCK},\r
-#endif\r
-#ifdef _SC_COHER_BLKSZ\r
- {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ},\r
-#endif\r
-#ifdef _SC_COLL_WEIGHTS_MAX\r
- {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX},\r
-#endif\r
-#ifdef _SC_DCACHE_ASSOC\r
- {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC},\r
-#endif\r
-#ifdef _SC_DCACHE_BLKSZ\r
- {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ},\r
-#endif\r
-#ifdef _SC_DCACHE_LINESZ\r
- {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ},\r
-#endif\r
-#ifdef _SC_DCACHE_SZ\r
- {"SC_DCACHE_SZ", _SC_DCACHE_SZ},\r
-#endif\r
-#ifdef _SC_DCACHE_TBLKSZ\r
- {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ},\r
-#endif\r
-#ifdef _SC_DELAYTIMER_MAX\r
- {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX},\r
-#endif\r
-#ifdef _SC_EQUIV_CLASS_MAX\r
- {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX},\r
-#endif\r
-#ifdef _SC_EXPR_NEST_MAX\r
- {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX},\r
-#endif\r
-#ifdef _SC_FSYNC\r
- {"SC_FSYNC", _SC_FSYNC},\r
-#endif\r
-#ifdef _SC_GETGR_R_SIZE_MAX\r
- {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX},\r
-#endif\r
-#ifdef _SC_GETPW_R_SIZE_MAX\r
- {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX},\r
-#endif\r
-#ifdef _SC_ICACHE_ASSOC\r
- {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC},\r
-#endif\r
-#ifdef _SC_ICACHE_BLKSZ\r
- {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ},\r
-#endif\r
-#ifdef _SC_ICACHE_LINESZ\r
- {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ},\r
-#endif\r
-#ifdef _SC_ICACHE_SZ\r
- {"SC_ICACHE_SZ", _SC_ICACHE_SZ},\r
-#endif\r
-#ifdef _SC_INF\r
- {"SC_INF", _SC_INF},\r
-#endif\r
-#ifdef _SC_INT_MAX\r
- {"SC_INT_MAX", _SC_INT_MAX},\r
-#endif\r
-#ifdef _SC_INT_MIN\r
- {"SC_INT_MIN", _SC_INT_MIN},\r
-#endif\r
-#ifdef _SC_IOV_MAX\r
- {"SC_IOV_MAX", _SC_IOV_MAX},\r
-#endif\r
-#ifdef _SC_IP_SECOPTS\r
- {"SC_IP_SECOPTS", _SC_IP_SECOPTS},\r
-#endif\r
-#ifdef _SC_JOB_CONTROL\r
- {"SC_JOB_CONTROL", _SC_JOB_CONTROL},\r
-#endif\r
-#ifdef _SC_KERN_POINTERS\r
- {"SC_KERN_POINTERS", _SC_KERN_POINTERS},\r
-#endif\r
-#ifdef _SC_KERN_SIM\r
- {"SC_KERN_SIM", _SC_KERN_SIM},\r
-#endif\r
-#ifdef _SC_LINE_MAX\r
- {"SC_LINE_MAX", _SC_LINE_MAX},\r
-#endif\r
-#ifdef _SC_LOGIN_NAME_MAX\r
- {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX},\r
-#endif\r
-#ifdef _SC_LOGNAME_MAX\r
- {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX},\r
-#endif\r
-#ifdef _SC_LONG_BIT\r
- {"SC_LONG_BIT", _SC_LONG_BIT},\r
-#endif\r
-#ifdef _SC_MAC\r
- {"SC_MAC", _SC_MAC},\r
-#endif\r
-#ifdef _SC_MAPPED_FILES\r
- {"SC_MAPPED_FILES", _SC_MAPPED_FILES},\r
-#endif\r
-#ifdef _SC_MAXPID\r
- {"SC_MAXPID", _SC_MAXPID},\r
-#endif\r
-#ifdef _SC_MB_LEN_MAX\r
- {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX},\r
-#endif\r
-#ifdef _SC_MEMLOCK\r
- {"SC_MEMLOCK", _SC_MEMLOCK},\r
-#endif\r
-#ifdef _SC_MEMLOCK_RANGE\r
- {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE},\r
-#endif\r
-#ifdef _SC_MEMORY_PROTECTION\r
- {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION},\r
-#endif\r
-#ifdef _SC_MESSAGE_PASSING\r
- {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING},\r
-#endif\r
-#ifdef _SC_MMAP_FIXED_ALIGNMENT\r
- {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT},\r
-#endif\r
-#ifdef _SC_MQ_OPEN_MAX\r
- {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX},\r
-#endif\r
-#ifdef _SC_MQ_PRIO_MAX\r
- {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX},\r
-#endif\r
-#ifdef _SC_NACLS_MAX\r
- {"SC_NACLS_MAX", _SC_NACLS_MAX},\r
-#endif\r
-#ifdef _SC_NGROUPS_MAX\r
- {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX},\r
-#endif\r
-#ifdef _SC_NL_ARGMAX\r
- {"SC_NL_ARGMAX", _SC_NL_ARGMAX},\r
-#endif\r
-#ifdef _SC_NL_LANGMAX\r
- {"SC_NL_LANGMAX", _SC_NL_LANGMAX},\r
-#endif\r
-#ifdef _SC_NL_MSGMAX\r
- {"SC_NL_MSGMAX", _SC_NL_MSGMAX},\r
-#endif\r
-#ifdef _SC_NL_NMAX\r
- {"SC_NL_NMAX", _SC_NL_NMAX},\r
-#endif\r
-#ifdef _SC_NL_SETMAX\r
- {"SC_NL_SETMAX", _SC_NL_SETMAX},\r
-#endif\r
-#ifdef _SC_NL_TEXTMAX\r
- {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX},\r
-#endif\r
-#ifdef _SC_NPROCESSORS_CONF\r
- {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF},\r
-#endif\r
-#ifdef _SC_NPROCESSORS_ONLN\r
- {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN},\r
-#endif\r
-#ifdef _SC_NPROC_CONF\r
- {"SC_NPROC_CONF", _SC_NPROC_CONF},\r
-#endif\r
-#ifdef _SC_NPROC_ONLN\r
- {"SC_NPROC_ONLN", _SC_NPROC_ONLN},\r
-#endif\r
-#ifdef _SC_NZERO\r
- {"SC_NZERO", _SC_NZERO},\r
-#endif\r
-#ifdef _SC_OPEN_MAX\r
- {"SC_OPEN_MAX", _SC_OPEN_MAX},\r
-#endif\r
-#ifdef _SC_PAGESIZE\r
- {"SC_PAGESIZE", _SC_PAGESIZE},\r
-#endif\r
-#ifdef _SC_PAGE_SIZE\r
- {"SC_PAGE_SIZE", _SC_PAGE_SIZE},\r
-#endif\r
-#ifdef _SC_PASS_MAX\r
- {"SC_PASS_MAX", _SC_PASS_MAX},\r
-#endif\r
-#ifdef _SC_PHYS_PAGES\r
- {"SC_PHYS_PAGES", _SC_PHYS_PAGES},\r
-#endif\r
-#ifdef _SC_PII\r
- {"SC_PII", _SC_PII},\r
-#endif\r
-#ifdef _SC_PII_INTERNET\r
- {"SC_PII_INTERNET", _SC_PII_INTERNET},\r
-#endif\r
-#ifdef _SC_PII_INTERNET_DGRAM\r
- {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM},\r
-#endif\r
-#ifdef _SC_PII_INTERNET_STREAM\r
- {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM},\r
-#endif\r
-#ifdef _SC_PII_OSI\r
- {"SC_PII_OSI", _SC_PII_OSI},\r
-#endif\r
-#ifdef _SC_PII_OSI_CLTS\r
- {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS},\r
-#endif\r
-#ifdef _SC_PII_OSI_COTS\r
- {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS},\r
-#endif\r
-#ifdef _SC_PII_OSI_M\r
- {"SC_PII_OSI_M", _SC_PII_OSI_M},\r
-#endif\r
-#ifdef _SC_PII_SOCKET\r
- {"SC_PII_SOCKET", _SC_PII_SOCKET},\r
-#endif\r
-#ifdef _SC_PII_XTI\r
- {"SC_PII_XTI", _SC_PII_XTI},\r
-#endif\r
-#ifdef _SC_POLL\r
- {"SC_POLL", _SC_POLL},\r
-#endif\r
-#ifdef _SC_PRIORITIZED_IO\r
- {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO},\r
-#endif\r
-#ifdef _SC_PRIORITY_SCHEDULING\r
- {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING},\r
-#endif\r
-#ifdef _SC_REALTIME_SIGNALS\r
- {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS},\r
-#endif\r
-#ifdef _SC_RE_DUP_MAX\r
- {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX},\r
-#endif\r
-#ifdef _SC_RTSIG_MAX\r
- {"SC_RTSIG_MAX", _SC_RTSIG_MAX},\r
-#endif\r
-#ifdef _SC_SAVED_IDS\r
- {"SC_SAVED_IDS", _SC_SAVED_IDS},\r
-#endif\r
-#ifdef _SC_SCHAR_MAX\r
- {"SC_SCHAR_MAX", _SC_SCHAR_MAX},\r
-#endif\r
-#ifdef _SC_SCHAR_MIN\r
- {"SC_SCHAR_MIN", _SC_SCHAR_MIN},\r
-#endif\r
-#ifdef _SC_SELECT\r
- {"SC_SELECT", _SC_SELECT},\r
-#endif\r
-#ifdef _SC_SEMAPHORES\r
- {"SC_SEMAPHORES", _SC_SEMAPHORES},\r
-#endif\r
-#ifdef _SC_SEM_NSEMS_MAX\r
- {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX},\r
-#endif\r
-#ifdef _SC_SEM_VALUE_MAX\r
- {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX},\r
-#endif\r
-#ifdef _SC_SHARED_MEMORY_OBJECTS\r
- {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS},\r
-#endif\r
-#ifdef _SC_SHRT_MAX\r
- {"SC_SHRT_MAX", _SC_SHRT_MAX},\r
-#endif\r
-#ifdef _SC_SHRT_MIN\r
- {"SC_SHRT_MIN", _SC_SHRT_MIN},\r
-#endif\r
-#ifdef _SC_SIGQUEUE_MAX\r
- {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX},\r
-#endif\r
-#ifdef _SC_SIGRT_MAX\r
- {"SC_SIGRT_MAX", _SC_SIGRT_MAX},\r
-#endif\r
-#ifdef _SC_SIGRT_MIN\r
- {"SC_SIGRT_MIN", _SC_SIGRT_MIN},\r
-#endif\r
-#ifdef _SC_SOFTPOWER\r
- {"SC_SOFTPOWER", _SC_SOFTPOWER},\r
-#endif\r
-#ifdef _SC_SPLIT_CACHE\r
- {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE},\r
-#endif\r
-#ifdef _SC_SSIZE_MAX\r
- {"SC_SSIZE_MAX", _SC_SSIZE_MAX},\r
-#endif\r
-#ifdef _SC_STACK_PROT\r
- {"SC_STACK_PROT", _SC_STACK_PROT},\r
-#endif\r
-#ifdef _SC_STREAM_MAX\r
- {"SC_STREAM_MAX", _SC_STREAM_MAX},\r
-#endif\r
-#ifdef _SC_SYNCHRONIZED_IO\r
- {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO},\r
-#endif\r
-#ifdef _SC_THREADS\r
- {"SC_THREADS", _SC_THREADS},\r
-#endif\r
-#ifdef _SC_THREAD_ATTR_STACKADDR\r
- {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR},\r
-#endif\r
-#ifdef _SC_THREAD_ATTR_STACKSIZE\r
- {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE},\r
-#endif\r
-#ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS\r
- {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS},\r
-#endif\r
-#ifdef _SC_THREAD_KEYS_MAX\r
- {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX},\r
-#endif\r
-#ifdef _SC_THREAD_PRIORITY_SCHEDULING\r
- {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING},\r
-#endif\r
-#ifdef _SC_THREAD_PRIO_INHERIT\r
- {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT},\r
-#endif\r
-#ifdef _SC_THREAD_PRIO_PROTECT\r
- {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT},\r
-#endif\r
-#ifdef _SC_THREAD_PROCESS_SHARED\r
- {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED},\r
-#endif\r
-#ifdef _SC_THREAD_SAFE_FUNCTIONS\r
- {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS},\r
-#endif\r
-#ifdef _SC_THREAD_STACK_MIN\r
- {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN},\r
-#endif\r
-#ifdef _SC_THREAD_THREADS_MAX\r
- {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX},\r
-#endif\r
-#ifdef _SC_TIMERS\r
- {"SC_TIMERS", _SC_TIMERS},\r
-#endif\r
-#ifdef _SC_TIMER_MAX\r
- {"SC_TIMER_MAX", _SC_TIMER_MAX},\r
-#endif\r
-#ifdef _SC_TTY_NAME_MAX\r
- {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX},\r
-#endif\r
-#ifdef _SC_TZNAME_MAX\r
- {"SC_TZNAME_MAX", _SC_TZNAME_MAX},\r
-#endif\r
-#ifdef _SC_T_IOV_MAX\r
- {"SC_T_IOV_MAX", _SC_T_IOV_MAX},\r
-#endif\r
-#ifdef _SC_UCHAR_MAX\r
- {"SC_UCHAR_MAX", _SC_UCHAR_MAX},\r
-#endif\r
-#ifdef _SC_UINT_MAX\r
- {"SC_UINT_MAX", _SC_UINT_MAX},\r
-#endif\r
-#ifdef _SC_UIO_MAXIOV\r
- {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV},\r
-#endif\r
-#ifdef _SC_ULONG_MAX\r
- {"SC_ULONG_MAX", _SC_ULONG_MAX},\r
-#endif\r
-#ifdef _SC_USHRT_MAX\r
- {"SC_USHRT_MAX", _SC_USHRT_MAX},\r
-#endif\r
-#ifdef _SC_VERSION\r
- {"SC_VERSION", _SC_VERSION},\r
-#endif\r
-#ifdef _SC_WORD_BIT\r
- {"SC_WORD_BIT", _SC_WORD_BIT},\r
-#endif\r
-#ifdef _SC_XBS5_ILP32_OFF32\r
- {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32},\r
-#endif\r
-#ifdef _SC_XBS5_ILP32_OFFBIG\r
- {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG},\r
-#endif\r
-#ifdef _SC_XBS5_LP64_OFF64\r
- {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64},\r
-#endif\r
-#ifdef _SC_XBS5_LPBIG_OFFBIG\r
- {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG},\r
-#endif\r
-#ifdef _SC_XOPEN_CRYPT\r
- {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT},\r
-#endif\r
-#ifdef _SC_XOPEN_ENH_I18N\r
- {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N},\r
-#endif\r
-#ifdef _SC_XOPEN_LEGACY\r
- {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY},\r
-#endif\r
-#ifdef _SC_XOPEN_REALTIME\r
- {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME},\r
-#endif\r
-#ifdef _SC_XOPEN_REALTIME_THREADS\r
- {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS},\r
-#endif\r
-#ifdef _SC_XOPEN_SHM\r
- {"SC_XOPEN_SHM", _SC_XOPEN_SHM},\r
-#endif\r
-#ifdef _SC_XOPEN_UNIX\r
- {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX},\r
-#endif\r
-#ifdef _SC_XOPEN_VERSION\r
- {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION},\r
-#endif\r
-#ifdef _SC_XOPEN_XCU_VERSION\r
- {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION},\r
-#endif\r
-#ifdef _SC_XOPEN_XPG2\r
- {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2},\r
-#endif\r
-#ifdef _SC_XOPEN_XPG3\r
- {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3},\r
-#endif\r
-#ifdef _SC_XOPEN_XPG4\r
- {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4},\r
-#endif\r
-};\r
-\r
-static int\r
-conv_sysconf_confname(PyObject *arg, int *valuep)\r
-{\r
- return conv_confname(arg, valuep, posix_constants_sysconf,\r
- sizeof(posix_constants_sysconf)\r
- / sizeof(struct constdef));\r
-}\r
-\r
-PyDoc_STRVAR(posix_sysconf__doc__,\r
-"sysconf(name) -> integer\n\n\\r
-Return an integer-valued system configuration variable.");\r
-\r
-static PyObject *\r
-posix_sysconf(PyObject *self, PyObject *args)\r
-{\r
- PyObject *result = NULL;\r
- int name;\r
-\r
- if (PyArg_ParseTuple(args, "O&:sysconf", conv_sysconf_confname, &name)) {\r
- int value;\r
-\r
- errno = 0;\r
- value = sysconf(name);\r
- if (value == -1 && errno != 0)\r
- posix_error();\r
- else\r
- result = PyInt_FromLong(value);\r
- }\r
- return result;\r
-}\r
-#endif\r
-\r
-\r
-/* This code is used to ensure that the tables of configuration value names\r
- * are in sorted order as required by conv_confname(), and also to build the\r
- * the exported dictionaries that are used to publish information about the\r
- * names available on the host platform.\r
- *\r
- * Sorting the table at runtime ensures that the table is properly ordered\r
- * when used, even for platforms we're not able to test on. It also makes\r
- * it easier to add additional entries to the tables.\r
- */\r
-\r
-static int\r
-cmp_constdefs(const void *v1, const void *v2)\r
-{\r
- const struct constdef *c1 =\r
- (const struct constdef *) v1;\r
- const struct constdef *c2 =\r
- (const struct constdef *) v2;\r
-\r
- return strcmp(c1->name, c2->name);\r
-}\r
-\r
-static int\r
-setup_confname_table(struct constdef *table, size_t tablesize,\r
- char *tablename, PyObject *module)\r
-{\r
- PyObject *d = NULL;\r
- size_t i;\r
-\r
- qsort(table, tablesize, sizeof(struct constdef), cmp_constdefs);\r
- d = PyDict_New();\r
- if (d == NULL)\r
- return -1;\r
-\r
- for (i=0; i < tablesize; ++i) {\r
- PyObject *o = PyInt_FromLong(table[i].value);\r
- if (o == NULL || PyDict_SetItemString(d, table[i].name, o) == -1) {\r
- Py_XDECREF(o);\r
- Py_DECREF(d);\r
- return -1;\r
- }\r
- Py_DECREF(o);\r
- }\r
- return PyModule_AddObject(module, tablename, d);\r
-}\r
-\r
-/* Return -1 on failure, 0 on success. */\r
-static int\r
-setup_confname_tables(PyObject *module)\r
-{\r
-#if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)\r
- if (setup_confname_table(posix_constants_pathconf,\r
- sizeof(posix_constants_pathconf)\r
- / sizeof(struct constdef),\r
- "pathconf_names", module))\r
- return -1;\r
-#endif\r
-#ifdef HAVE_CONFSTR\r
- if (setup_confname_table(posix_constants_confstr,\r
- sizeof(posix_constants_confstr)\r
- / sizeof(struct constdef),\r
- "confstr_names", module))\r
- return -1;\r
-#endif\r
-#ifdef HAVE_SYSCONF\r
- if (setup_confname_table(posix_constants_sysconf,\r
- sizeof(posix_constants_sysconf)\r
- / sizeof(struct constdef),\r
- "sysconf_names", module))\r
- return -1;\r
-#endif\r
- return 0;\r
-}\r
-\r
-\r
-PyDoc_STRVAR(posix_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
-posix_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
-#ifdef MS_WINDOWS\r
-PyDoc_STRVAR(win32_startfile__doc__,\r
-"startfile(filepath [, operation]) - Start a file with its associated\n\\r
-application.\n\\r
-\n\\r
-When \"operation\" is not specified or \"open\", this acts like\n\\r
-double-clicking the file in Explorer, or giving the file name as an\n\\r
-argument to the DOS \"start\" command: the file is opened with whatever\n\\r
-application (if any) its extension is associated.\n\\r
-When another \"operation\" is given, it specifies what should be done with\n\\r
-the file. A typical operation is \"print\".\n\\r
-\n\\r
-startfile returns as soon as the associated application is launched.\n\\r
-There is no option to wait for the application to close, and no way\n\\r
-to retrieve the application's exit status.\n\\r
-\n\\r
-The filepath is relative to the current directory. If you want to use\n\\r
-an absolute path, make sure the first character is not a slash (\"/\");\n\\r
-the underlying Win32 ShellExecute function doesn't work if it is.");\r
-\r
-static PyObject *\r
-win32_startfile(PyObject *self, PyObject *args)\r
-{\r
- char *filepath;\r
- char *operation = NULL;\r
- HINSTANCE rc;\r
-\r
- PyObject *unipath, *woperation = NULL;\r
- if (!PyArg_ParseTuple(args, "U|s:startfile",\r
- &unipath, &operation)) {\r
- PyErr_Clear();\r
- goto normal;\r
- }\r
-\r
- if (operation) {\r
- woperation = PyUnicode_DecodeASCII(operation,\r
- strlen(operation), NULL);\r
- if (!woperation) {\r
- PyErr_Clear();\r
- operation = NULL;\r
- goto normal;\r
- }\r
- }\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- rc = ShellExecuteW((HWND)0, woperation ? PyUnicode_AS_UNICODE(woperation) : 0,\r
- PyUnicode_AS_UNICODE(unipath),\r
- NULL, NULL, SW_SHOWNORMAL);\r
- Py_END_ALLOW_THREADS\r
-\r
- Py_XDECREF(woperation);\r
- if (rc <= (HINSTANCE)32) {\r
- PyObject *errval = win32_error_unicode("startfile",\r
- PyUnicode_AS_UNICODE(unipath));\r
- return errval;\r
- }\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-\r
-normal:\r
- if (!PyArg_ParseTuple(args, "et|s:startfile",\r
- Py_FileSystemDefaultEncoding, &filepath,\r
- &operation))\r
- return NULL;\r
- Py_BEGIN_ALLOW_THREADS\r
- rc = ShellExecute((HWND)0, operation, filepath,\r
- NULL, NULL, SW_SHOWNORMAL);\r
- Py_END_ALLOW_THREADS\r
- if (rc <= (HINSTANCE)32) {\r
- PyObject *errval = win32_error("startfile", filepath);\r
- PyMem_Free(filepath);\r
- return errval;\r
- }\r
- PyMem_Free(filepath);\r
- Py_INCREF(Py_None);\r
- return Py_None;\r
-}\r
-#endif /* MS_WINDOWS */\r
-\r
-#ifdef HAVE_GETLOADAVG\r
-PyDoc_STRVAR(posix_getloadavg__doc__,\r
-"getloadavg() -> (float, float, float)\n\n\\r
-Return the number of processes in the system run queue averaged over\n\\r
-the last 1, 5, and 15 minutes or raises OSError if the load average\n\\r
-was unobtainable");\r
-\r
-static PyObject *\r
-posix_getloadavg(PyObject *self, PyObject *noargs)\r
-{\r
- double loadavg[3];\r
- if (getloadavg(loadavg, 3)!=3) {\r
- PyErr_SetString(PyExc_OSError, "Load averages are unobtainable");\r
- return NULL;\r
- } else\r
- return Py_BuildValue("ddd", loadavg[0], loadavg[1], loadavg[2]);\r
-}\r
-#endif\r
-\r
-#ifdef MS_WINDOWS\r
-\r
-PyDoc_STRVAR(win32_urandom__doc__,\r
-"urandom(n) -> str\n\n\\r
-Return a string of n random bytes suitable for cryptographic use.");\r
-\r
-typedef BOOL (WINAPI *CRYPTACQUIRECONTEXTA)(HCRYPTPROV *phProv,\\r
- LPCSTR pszContainer, LPCSTR pszProvider, DWORD dwProvType,\\r
- DWORD dwFlags );\r
-typedef BOOL (WINAPI *CRYPTGENRANDOM)(HCRYPTPROV hProv, DWORD dwLen,\\r
- BYTE *pbBuffer );\r
-\r
-static CRYPTGENRANDOM pCryptGenRandom = NULL;\r
-/* This handle is never explicitly released. Instead, the operating\r
- system will release it when the process terminates. */\r
-static HCRYPTPROV hCryptProv = 0;\r
-\r
-static PyObject*\r
-win32_urandom(PyObject *self, PyObject *args)\r
-{\r
- int howMany;\r
- PyObject* result;\r
-\r
- /* Read arguments */\r
- if (! PyArg_ParseTuple(args, "i:urandom", &howMany))\r
- return NULL;\r
- if (howMany < 0)\r
- return PyErr_Format(PyExc_ValueError,\r
- "negative argument not allowed");\r
-\r
- if (hCryptProv == 0) {\r
- HINSTANCE hAdvAPI32 = NULL;\r
- CRYPTACQUIRECONTEXTA pCryptAcquireContext = NULL;\r
-\r
- /* Obtain handle to the DLL containing CryptoAPI\r
- This should not fail */\r
- hAdvAPI32 = GetModuleHandle("advapi32.dll");\r
- if(hAdvAPI32 == NULL)\r
- return win32_error("GetModuleHandle", NULL);\r
-\r
- /* Obtain pointers to the CryptoAPI functions\r
- This will fail on some early versions of Win95 */\r
- pCryptAcquireContext = (CRYPTACQUIRECONTEXTA)GetProcAddress(\r
- hAdvAPI32,\r
- "CryptAcquireContextA");\r
- if (pCryptAcquireContext == NULL)\r
- return PyErr_Format(PyExc_NotImplementedError,\r
- "CryptAcquireContextA not found");\r
-\r
- pCryptGenRandom = (CRYPTGENRANDOM)GetProcAddress(\r
- hAdvAPI32, "CryptGenRandom");\r
- if (pCryptGenRandom == NULL)\r
- return PyErr_Format(PyExc_NotImplementedError,\r
- "CryptGenRandom not found");\r
-\r
- /* Acquire context */\r
- if (! pCryptAcquireContext(&hCryptProv, NULL, NULL,\r
- PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))\r
- return win32_error("CryptAcquireContext", NULL);\r
- }\r
-\r
- /* Allocate bytes */\r
- result = PyString_FromStringAndSize(NULL, howMany);\r
- if (result != NULL) {\r
- /* Get random data */\r
- memset(PyString_AS_STRING(result), 0, howMany); /* zero seed */\r
- if (! pCryptGenRandom(hCryptProv, howMany, (unsigned char*)\r
- PyString_AS_STRING(result))) {\r
- Py_DECREF(result);\r
- return win32_error("CryptGenRandom", NULL);\r
- }\r
- }\r
- return result;\r
-}\r
-#endif\r
-\r
-#ifdef __VMS\r
-/* Use openssl random routine */\r
-#include <openssl/rand.h>\r
-PyDoc_STRVAR(vms_urandom__doc__,\r
-"urandom(n) -> str\n\n\\r
-Return a string of n random bytes suitable for cryptographic use.");\r
-\r
-static PyObject*\r
-vms_urandom(PyObject *self, PyObject *args)\r
-{\r
- int howMany;\r
- PyObject* result;\r
-\r
- /* Read arguments */\r
- if (! PyArg_ParseTuple(args, "i:urandom", &howMany))\r
- return NULL;\r
- if (howMany < 0)\r
- return PyErr_Format(PyExc_ValueError,\r
- "negative argument not allowed");\r
-\r
- /* Allocate bytes */\r
- result = PyString_FromStringAndSize(NULL, howMany);\r
- if (result != NULL) {\r
- /* Get random data */\r
- if (RAND_pseudo_bytes((unsigned char*)\r
- PyString_AS_STRING(result),\r
- howMany) < 0) {\r
- Py_DECREF(result);\r
- return PyErr_Format(PyExc_ValueError,\r
- "RAND_pseudo_bytes");\r
- }\r
- }\r
- return result;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_SETRESUID\r
-PyDoc_STRVAR(posix_setresuid__doc__,\r
-"setresuid(ruid, euid, suid)\n\n\\r
-Set the current process's real, effective, and saved user ids.");\r
-\r
-static PyObject*\r
-posix_setresuid (PyObject *self, PyObject *args)\r
-{\r
- /* We assume uid_t is no larger than a long. */\r
- long ruid, euid, suid;\r
- if (!PyArg_ParseTuple(args, "lll", &ruid, &euid, &suid))\r
- return NULL;\r
- if (setresuid(ruid, euid, suid) < 0)\r
- return posix_error();\r
- Py_RETURN_NONE;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_SETRESGID\r
-PyDoc_STRVAR(posix_setresgid__doc__,\r
-"setresgid(rgid, egid, sgid)\n\n\\r
-Set the current process's real, effective, and saved group ids.");\r
-\r
-static PyObject*\r
-posix_setresgid (PyObject *self, PyObject *args)\r
-{\r
- /* We assume uid_t is no larger than a long. */\r
- long rgid, egid, sgid;\r
- if (!PyArg_ParseTuple(args, "lll", &rgid, &egid, &sgid))\r
- return NULL;\r
- if (setresgid(rgid, egid, sgid) < 0)\r
- return posix_error();\r
- Py_RETURN_NONE;\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_GETRESUID\r
-PyDoc_STRVAR(posix_getresuid__doc__,\r
-"getresuid() -> (ruid, euid, suid)\n\n\\r
-Get tuple of the current process's real, effective, and saved user ids.");\r
-\r
-static PyObject*\r
-posix_getresuid (PyObject *self, PyObject *noargs)\r
-{\r
- uid_t ruid, euid, suid;\r
- long l_ruid, l_euid, l_suid;\r
- if (getresuid(&ruid, &euid, &suid) < 0)\r
- return posix_error();\r
- /* Force the values into long's as we don't know the size of uid_t. */\r
- l_ruid = ruid;\r
- l_euid = euid;\r
- l_suid = suid;\r
- return Py_BuildValue("(lll)", l_ruid, l_euid, l_suid);\r
-}\r
-#endif\r
-\r
-#ifdef HAVE_GETRESGID\r
-PyDoc_STRVAR(posix_getresgid__doc__,\r
-"getresgid() -> (rgid, egid, sgid)\n\n\\r
-Get tuple of the current process's real, effective, and saved group ids.");\r
-\r
-static PyObject*\r
-posix_getresgid (PyObject *self, PyObject *noargs)\r
-{\r
- uid_t rgid, egid, sgid;\r
- long l_rgid, l_egid, l_sgid;\r
- if (getresgid(&rgid, &egid, &sgid) < 0)\r
- return posix_error();\r
- /* Force the values into long's as we don't know the size of uid_t. */\r
- l_rgid = rgid;\r
- l_egid = egid;\r
- l_sgid = sgid;\r
- return Py_BuildValue("(lll)", l_rgid, l_egid, l_sgid);\r
-}\r
-#endif\r
-\r
-static PyMethodDef posix_methods[] = {\r
- {"access", posix_access, METH_VARARGS, posix_access__doc__},\r
-#ifdef HAVE_TTYNAME\r
- {"ttyname", posix_ttyname, METH_VARARGS, posix_ttyname__doc__},\r
-#endif\r
- {"chdir", posix_chdir, METH_VARARGS, posix_chdir__doc__},\r
-#ifdef HAVE_CHFLAGS\r
- {"chflags", posix_chflags, METH_VARARGS, posix_chflags__doc__},\r
-#endif /* HAVE_CHFLAGS */\r
- {"chmod", posix_chmod, METH_VARARGS, posix_chmod__doc__},\r
-#ifdef HAVE_FCHMOD\r
- {"fchmod", posix_fchmod, METH_VARARGS, posix_fchmod__doc__},\r
-#endif /* HAVE_FCHMOD */\r
-#ifdef HAVE_CHOWN\r
- {"chown", posix_chown, METH_VARARGS, posix_chown__doc__},\r
-#endif /* HAVE_CHOWN */\r
-#ifdef HAVE_LCHMOD\r
- {"lchmod", posix_lchmod, METH_VARARGS, posix_lchmod__doc__},\r
-#endif /* HAVE_LCHMOD */\r
-#ifdef HAVE_FCHOWN\r
- {"fchown", posix_fchown, METH_VARARGS, posix_fchown__doc__},\r
-#endif /* HAVE_FCHOWN */\r
-#ifdef HAVE_LCHFLAGS\r
- {"lchflags", posix_lchflags, METH_VARARGS, posix_lchflags__doc__},\r
-#endif /* HAVE_LCHFLAGS */\r
-#ifdef HAVE_LCHOWN\r
- {"lchown", posix_lchown, METH_VARARGS, posix_lchown__doc__},\r
-#endif /* HAVE_LCHOWN */\r
-#ifdef HAVE_CHROOT\r
- {"chroot", posix_chroot, METH_VARARGS, posix_chroot__doc__},\r
-#endif\r
-#ifdef HAVE_CTERMID\r
- {"ctermid", posix_ctermid, METH_NOARGS, posix_ctermid__doc__},\r
-#endif\r
-#ifdef HAVE_GETCWD\r
- {"getcwd", posix_getcwd, METH_NOARGS, posix_getcwd__doc__},\r
-#ifdef Py_USING_UNICODE\r
- {"getcwdu", posix_getcwdu, METH_NOARGS, posix_getcwdu__doc__},\r
-#endif\r
-#endif\r
-#ifdef HAVE_LINK\r
- {"link", posix_link, METH_VARARGS, posix_link__doc__},\r
-#endif /* HAVE_LINK */\r
- {"listdir", posix_listdir, METH_VARARGS, posix_listdir__doc__},\r
- {"lstat", posix_lstat, METH_VARARGS, posix_lstat__doc__},\r
- {"mkdir", posix_mkdir, METH_VARARGS, posix_mkdir__doc__},\r
-#ifdef HAVE_NICE\r
- {"nice", posix_nice, METH_VARARGS, posix_nice__doc__},\r
-#endif /* HAVE_NICE */\r
-#ifdef HAVE_READLINK\r
- {"readlink", posix_readlink, METH_VARARGS, posix_readlink__doc__},\r
-#endif /* HAVE_READLINK */\r
- {"rename", posix_rename, METH_VARARGS, posix_rename__doc__},\r
- {"rmdir", posix_rmdir, METH_VARARGS, posix_rmdir__doc__},\r
- {"stat", posix_stat, METH_VARARGS, posix_stat__doc__},\r
- {"stat_float_times", stat_float_times, METH_VARARGS, stat_float_times__doc__},\r
-#ifdef HAVE_SYMLINK\r
- {"symlink", posix_symlink, METH_VARARGS, posix_symlink__doc__},\r
-#endif /* HAVE_SYMLINK */\r
-#ifdef HAVE_SYSTEM\r
- {"system", posix_system, METH_VARARGS, posix_system__doc__},\r
-#endif\r
- {"umask", posix_umask, METH_VARARGS, posix_umask__doc__},\r
-#ifdef HAVE_UNAME\r
- {"uname", posix_uname, METH_NOARGS, posix_uname__doc__},\r
-#endif /* HAVE_UNAME */\r
- {"unlink", posix_unlink, METH_VARARGS, posix_unlink__doc__},\r
- {"remove", posix_unlink, METH_VARARGS, posix_remove__doc__},\r
- {"utime", posix_utime, METH_VARARGS, posix_utime__doc__},\r
-#ifdef HAVE_TIMES\r
- {"times", posix_times, METH_NOARGS, posix_times__doc__},\r
-#endif /* HAVE_TIMES */\r
- {"_exit", posix__exit, METH_VARARGS, posix__exit__doc__},\r
-#ifdef HAVE_EXECV\r
- {"execv", posix_execv, METH_VARARGS, posix_execv__doc__},\r
- {"execve", posix_execve, METH_VARARGS, posix_execve__doc__},\r
-#endif /* HAVE_EXECV */\r
-#ifdef HAVE_SPAWNV\r
- {"spawnv", posix_spawnv, METH_VARARGS, posix_spawnv__doc__},\r
- {"spawnve", posix_spawnve, METH_VARARGS, posix_spawnve__doc__},\r
-#if defined(PYOS_OS2)\r
- {"spawnvp", posix_spawnvp, METH_VARARGS, posix_spawnvp__doc__},\r
- {"spawnvpe", posix_spawnvpe, METH_VARARGS, posix_spawnvpe__doc__},\r
-#endif /* PYOS_OS2 */\r
-#endif /* HAVE_SPAWNV */\r
-#ifdef HAVE_FORK1\r
- {"fork1", posix_fork1, METH_NOARGS, posix_fork1__doc__},\r
-#endif /* HAVE_FORK1 */\r
-#ifdef HAVE_FORK\r
- {"fork", posix_fork, METH_NOARGS, posix_fork__doc__},\r
-#endif /* HAVE_FORK */\r
-#if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)\r
- {"openpty", posix_openpty, METH_NOARGS, posix_openpty__doc__},\r
-#endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */\r
-#ifdef HAVE_FORKPTY\r
- {"forkpty", posix_forkpty, METH_NOARGS, posix_forkpty__doc__},\r
-#endif /* HAVE_FORKPTY */\r
-#ifdef HAVE_GETEGID\r
- {"getegid", posix_getegid, METH_NOARGS, posix_getegid__doc__},\r
-#endif /* HAVE_GETEGID */\r
-#ifdef HAVE_GETEUID\r
- {"geteuid", posix_geteuid, METH_NOARGS, posix_geteuid__doc__},\r
-#endif /* HAVE_GETEUID */\r
-#ifdef HAVE_GETGID\r
- {"getgid", posix_getgid, METH_NOARGS, posix_getgid__doc__},\r
-#endif /* HAVE_GETGID */\r
-#ifdef HAVE_GETGROUPS\r
- {"getgroups", posix_getgroups, METH_NOARGS, posix_getgroups__doc__},\r
-#endif\r
- {"getpid", posix_getpid, METH_NOARGS, posix_getpid__doc__},\r
-#ifdef HAVE_GETPGRP\r
- {"getpgrp", posix_getpgrp, METH_NOARGS, posix_getpgrp__doc__},\r
-#endif /* HAVE_GETPGRP */\r
-#ifdef HAVE_GETPPID\r
- {"getppid", posix_getppid, METH_NOARGS, posix_getppid__doc__},\r
-#endif /* HAVE_GETPPID */\r
-#ifdef HAVE_GETUID\r
- {"getuid", posix_getuid, METH_NOARGS, posix_getuid__doc__},\r
-#endif /* HAVE_GETUID */\r
-#ifdef HAVE_GETLOGIN\r
- {"getlogin", posix_getlogin, METH_NOARGS, posix_getlogin__doc__},\r
-#endif\r
-#ifdef HAVE_KILL\r
- {"kill", posix_kill, METH_VARARGS, posix_kill__doc__},\r
-#endif /* HAVE_KILL */\r
-#ifdef HAVE_KILLPG\r
- {"killpg", posix_killpg, METH_VARARGS, posix_killpg__doc__},\r
-#endif /* HAVE_KILLPG */\r
-#ifdef HAVE_PLOCK\r
- {"plock", posix_plock, METH_VARARGS, posix_plock__doc__},\r
-#endif /* HAVE_PLOCK */\r
-#ifdef HAVE_POPEN\r
- {"popen", posix_popen, METH_VARARGS, posix_popen__doc__},\r
-#ifdef MS_WINDOWS\r
- {"popen2", win32_popen2, METH_VARARGS},\r
- {"popen3", win32_popen3, METH_VARARGS},\r
- {"popen4", win32_popen4, METH_VARARGS},\r
- {"startfile", win32_startfile, METH_VARARGS, win32_startfile__doc__},\r
- {"kill", win32_kill, METH_VARARGS, win32_kill__doc__},\r
-#else\r
-#if defined(PYOS_OS2) && defined(PYCC_GCC)\r
- {"popen2", os2emx_popen2, METH_VARARGS},\r
- {"popen3", os2emx_popen3, METH_VARARGS},\r
- {"popen4", os2emx_popen4, METH_VARARGS},\r
-#endif\r
-#endif\r
-#endif /* HAVE_POPEN */\r
-#ifdef HAVE_SETUID\r
- {"setuid", posix_setuid, METH_VARARGS, posix_setuid__doc__},\r
-#endif /* HAVE_SETUID */\r
-#ifdef HAVE_SETEUID\r
- {"seteuid", posix_seteuid, METH_VARARGS, posix_seteuid__doc__},\r
-#endif /* HAVE_SETEUID */\r
-#ifdef HAVE_SETEGID\r
- {"setegid", posix_setegid, METH_VARARGS, posix_setegid__doc__},\r
-#endif /* HAVE_SETEGID */\r
-#ifdef HAVE_SETREUID\r
- {"setreuid", posix_setreuid, METH_VARARGS, posix_setreuid__doc__},\r
-#endif /* HAVE_SETREUID */\r
-#ifdef HAVE_SETREGID\r
- {"setregid", posix_setregid, METH_VARARGS, posix_setregid__doc__},\r
-#endif /* HAVE_SETREGID */\r
-#ifdef HAVE_SETGID\r
- {"setgid", posix_setgid, METH_VARARGS, posix_setgid__doc__},\r
-#endif /* HAVE_SETGID */\r
-#ifdef HAVE_SETGROUPS\r
- {"setgroups", posix_setgroups, METH_O, posix_setgroups__doc__},\r
-#endif /* HAVE_SETGROUPS */\r
-#ifdef HAVE_INITGROUPS\r
- {"initgroups", posix_initgroups, METH_VARARGS, posix_initgroups__doc__},\r
-#endif /* HAVE_INITGROUPS */\r
-#ifdef HAVE_GETPGID\r
- {"getpgid", posix_getpgid, METH_VARARGS, posix_getpgid__doc__},\r
-#endif /* HAVE_GETPGID */\r
-#ifdef HAVE_SETPGRP\r
- {"setpgrp", posix_setpgrp, METH_NOARGS, posix_setpgrp__doc__},\r
-#endif /* HAVE_SETPGRP */\r
-#ifdef HAVE_WAIT\r
- {"wait", posix_wait, METH_NOARGS, posix_wait__doc__},\r
-#endif /* HAVE_WAIT */\r
-#ifdef HAVE_WAIT3\r
- {"wait3", posix_wait3, METH_VARARGS, posix_wait3__doc__},\r
-#endif /* HAVE_WAIT3 */\r
-#ifdef HAVE_WAIT4\r
- {"wait4", posix_wait4, METH_VARARGS, posix_wait4__doc__},\r
-#endif /* HAVE_WAIT4 */\r
-#if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)\r
- {"waitpid", posix_waitpid, METH_VARARGS, posix_waitpid__doc__},\r
-#endif /* HAVE_WAITPID */\r
-#ifdef HAVE_GETSID\r
- {"getsid", posix_getsid, METH_VARARGS, posix_getsid__doc__},\r
-#endif /* HAVE_GETSID */\r
-#ifdef HAVE_SETSID\r
- {"setsid", posix_setsid, METH_NOARGS, posix_setsid__doc__},\r
-#endif /* HAVE_SETSID */\r
-#ifdef HAVE_SETPGID\r
- {"setpgid", posix_setpgid, METH_VARARGS, posix_setpgid__doc__},\r
-#endif /* HAVE_SETPGID */\r
-#ifdef HAVE_TCGETPGRP\r
- {"tcgetpgrp", posix_tcgetpgrp, METH_VARARGS, posix_tcgetpgrp__doc__},\r
-#endif /* HAVE_TCGETPGRP */\r
-#ifdef HAVE_TCSETPGRP\r
- {"tcsetpgrp", posix_tcsetpgrp, METH_VARARGS, posix_tcsetpgrp__doc__},\r
-#endif /* HAVE_TCSETPGRP */\r
- {"open", posix_open, METH_VARARGS, posix_open__doc__},\r
- {"close", posix_close, METH_VARARGS, posix_close__doc__},\r
- {"closerange", posix_closerange, METH_VARARGS, posix_closerange__doc__},\r
- {"dup", posix_dup, METH_VARARGS, posix_dup__doc__},\r
- {"dup2", posix_dup2, METH_VARARGS, posix_dup2__doc__},\r
- {"lseek", posix_lseek, METH_VARARGS, posix_lseek__doc__},\r
- {"read", posix_read, METH_VARARGS, posix_read__doc__},\r
- {"write", posix_write, METH_VARARGS, posix_write__doc__},\r
- {"fstat", posix_fstat, METH_VARARGS, posix_fstat__doc__},\r
- {"fdopen", posix_fdopen, METH_VARARGS, posix_fdopen__doc__},\r
- {"isatty", posix_isatty, METH_VARARGS, posix_isatty__doc__},\r
-#ifdef HAVE_PIPE\r
- {"pipe", posix_pipe, METH_NOARGS, posix_pipe__doc__},\r
-#endif\r
-#ifdef HAVE_MKFIFO\r
- {"mkfifo", posix_mkfifo, METH_VARARGS, posix_mkfifo__doc__},\r
-#endif\r
-#if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)\r
- {"mknod", posix_mknod, METH_VARARGS, posix_mknod__doc__},\r
-#endif\r
-#ifdef HAVE_DEVICE_MACROS\r
- {"major", posix_major, METH_VARARGS, posix_major__doc__},\r
- {"minor", posix_minor, METH_VARARGS, posix_minor__doc__},\r
- {"makedev", posix_makedev, METH_VARARGS, posix_makedev__doc__},\r
-#endif\r
-#ifdef HAVE_FTRUNCATE\r
- {"ftruncate", posix_ftruncate, METH_VARARGS, posix_ftruncate__doc__},\r
-#endif\r
-#ifdef HAVE_PUTENV\r
- {"putenv", posix_putenv, METH_VARARGS, posix_putenv__doc__},\r
-#endif\r
-#ifdef HAVE_UNSETENV\r
- {"unsetenv", posix_unsetenv, METH_VARARGS, posix_unsetenv__doc__},\r
-#endif\r
- {"strerror", posix_strerror, METH_VARARGS, posix_strerror__doc__},\r
-#ifdef HAVE_FCHDIR\r
- {"fchdir", posix_fchdir, METH_O, posix_fchdir__doc__},\r
-#endif\r
-#ifdef HAVE_FSYNC\r
- {"fsync", posix_fsync, METH_O, posix_fsync__doc__},\r
-#endif\r
-#ifdef HAVE_FDATASYNC\r
- {"fdatasync", posix_fdatasync, METH_O, posix_fdatasync__doc__},\r
-#endif\r
-#ifdef HAVE_SYS_WAIT_H\r
-#ifdef WCOREDUMP\r
- {"WCOREDUMP", posix_WCOREDUMP, METH_VARARGS, posix_WCOREDUMP__doc__},\r
-#endif /* WCOREDUMP */\r
-#ifdef WIFCONTINUED\r
- {"WIFCONTINUED",posix_WIFCONTINUED, METH_VARARGS, posix_WIFCONTINUED__doc__},\r
-#endif /* WIFCONTINUED */\r
-#ifdef WIFSTOPPED\r
- {"WIFSTOPPED", posix_WIFSTOPPED, METH_VARARGS, posix_WIFSTOPPED__doc__},\r
-#endif /* WIFSTOPPED */\r
-#ifdef WIFSIGNALED\r
- {"WIFSIGNALED", posix_WIFSIGNALED, METH_VARARGS, posix_WIFSIGNALED__doc__},\r
-#endif /* WIFSIGNALED */\r
-#ifdef WIFEXITED\r
- {"WIFEXITED", posix_WIFEXITED, METH_VARARGS, posix_WIFEXITED__doc__},\r
-#endif /* WIFEXITED */\r
-#ifdef WEXITSTATUS\r
- {"WEXITSTATUS", posix_WEXITSTATUS, METH_VARARGS, posix_WEXITSTATUS__doc__},\r
-#endif /* WEXITSTATUS */\r
-#ifdef WTERMSIG\r
- {"WTERMSIG", posix_WTERMSIG, METH_VARARGS, posix_WTERMSIG__doc__},\r
-#endif /* WTERMSIG */\r
-#ifdef WSTOPSIG\r
- {"WSTOPSIG", posix_WSTOPSIG, METH_VARARGS, posix_WSTOPSIG__doc__},\r
-#endif /* WSTOPSIG */\r
-#endif /* HAVE_SYS_WAIT_H */\r
-#if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)\r
- {"fstatvfs", posix_fstatvfs, METH_VARARGS, posix_fstatvfs__doc__},\r
-#endif\r
-#if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)\r
- {"statvfs", posix_statvfs, METH_VARARGS, posix_statvfs__doc__},\r
-#endif\r
-#ifdef HAVE_TMPFILE\r
- {"tmpfile", posix_tmpfile, METH_NOARGS, posix_tmpfile__doc__},\r
-#endif\r
-#ifdef HAVE_TEMPNAM\r
- {"tempnam", posix_tempnam, METH_VARARGS, posix_tempnam__doc__},\r
-#endif\r
-#ifdef HAVE_TMPNAM\r
- {"tmpnam", posix_tmpnam, METH_NOARGS, posix_tmpnam__doc__},\r
-#endif\r
-#ifdef HAVE_CONFSTR\r
- {"confstr", posix_confstr, METH_VARARGS, posix_confstr__doc__},\r
-#endif\r
-#ifdef HAVE_SYSCONF\r
- {"sysconf", posix_sysconf, METH_VARARGS, posix_sysconf__doc__},\r
-#endif\r
-#ifdef HAVE_FPATHCONF\r
- {"fpathconf", posix_fpathconf, METH_VARARGS, posix_fpathconf__doc__},\r
-#endif\r
-#ifdef HAVE_PATHCONF\r
- {"pathconf", posix_pathconf, METH_VARARGS, posix_pathconf__doc__},\r
-#endif\r
- {"abort", posix_abort, METH_NOARGS, posix_abort__doc__},\r
-#ifdef MS_WINDOWS\r
- {"_getfullpathname", posix__getfullpathname, METH_VARARGS, NULL},\r
-#endif\r
-#ifdef HAVE_GETLOADAVG\r
- {"getloadavg", posix_getloadavg, METH_NOARGS, posix_getloadavg__doc__},\r
-#endif\r
- #ifdef MS_WINDOWS\r
- {"urandom", win32_urandom, METH_VARARGS, win32_urandom__doc__},\r
- #endif\r
- #ifdef __VMS\r
- {"urandom", vms_urandom, METH_VARARGS, vms_urandom__doc__},\r
- #endif\r
-#ifdef HAVE_SETRESUID\r
- {"setresuid", posix_setresuid, METH_VARARGS, posix_setresuid__doc__},\r
-#endif\r
-#ifdef HAVE_SETRESGID\r
- {"setresgid", posix_setresgid, METH_VARARGS, posix_setresgid__doc__},\r
-#endif\r
-#ifdef HAVE_GETRESUID\r
- {"getresuid", posix_getresuid, METH_NOARGS, posix_getresuid__doc__},\r
-#endif\r
-#ifdef HAVE_GETRESGID\r
- {"getresgid", posix_getresgid, METH_NOARGS, posix_getresgid__doc__},\r
-#endif\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
-#if defined(PYOS_OS2)\r
-/* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */\r
-static int insertvalues(PyObject *module)\r
-{\r
- APIRET rc;\r
- ULONG values[QSV_MAX+1];\r
- PyObject *v;\r
- char *ver, tmp[50];\r
-\r
- Py_BEGIN_ALLOW_THREADS\r
- rc = DosQuerySysInfo(1L, QSV_MAX, &values[1], sizeof(ULONG) * QSV_MAX);\r
- Py_END_ALLOW_THREADS\r
-\r
- if (rc != NO_ERROR) {\r
- os2_error(rc);\r
- return -1;\r
- }\r
-\r
- if (ins(module, "meminstalled", values[QSV_TOTPHYSMEM])) return -1;\r
- if (ins(module, "memkernel", values[QSV_TOTRESMEM])) return -1;\r
- if (ins(module, "memvirtual", values[QSV_TOTAVAILMEM])) return -1;\r
- if (ins(module, "maxpathlen", values[QSV_MAX_PATH_LENGTH])) return -1;\r
- if (ins(module, "maxnamelen", values[QSV_MAX_COMP_LENGTH])) return -1;\r
- if (ins(module, "revision", values[QSV_VERSION_REVISION])) return -1;\r
- if (ins(module, "timeslice", values[QSV_MIN_SLICE])) return -1;\r
-\r
- switch (values[QSV_VERSION_MINOR]) {\r
- case 0: ver = "2.00"; break;\r
- case 10: ver = "2.10"; break;\r
- case 11: ver = "2.11"; break;\r
- case 30: ver = "3.00"; break;\r
- case 40: ver = "4.00"; break;\r
- case 50: ver = "5.00"; break;\r
- default:\r
- PyOS_snprintf(tmp, sizeof(tmp),\r
- "%d-%d", values[QSV_VERSION_MAJOR],\r
- values[QSV_VERSION_MINOR]);\r
- ver = &tmp[0];\r
- }\r
-\r
- /* Add Indicator of the Version of the Operating System */\r
- if (PyModule_AddStringConstant(module, "version", tmp) < 0)\r
- return -1;\r
-\r
- /* Add Indicator of Which Drive was Used to Boot the System */\r
- tmp[0] = 'A' + values[QSV_BOOT_DRIVE] - 1;\r
- tmp[1] = ':';\r
- tmp[2] = '\0';\r
-\r
- return PyModule_AddStringConstant(module, "bootdrive", tmp);\r
-}\r
-#endif\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 defined(PYOS_OS2) && defined(PYCC_GCC)\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)P_OVERLAY)) return -1;\r
- if (ins(d, "P_DEBUG", (long)P_DEBUG)) return -1;\r
- if (ins(d, "P_SESSION", (long)P_SESSION)) return -1;\r
- if (ins(d, "P_DETACH", (long)P_DETACH)) return -1;\r
- if (ins(d, "P_PM", (long)P_PM)) return -1;\r
- if (ins(d, "P_DEFAULT", (long)P_DEFAULT)) return -1;\r
- if (ins(d, "P_MINIMIZE", (long)P_MINIMIZE)) return -1;\r
- if (ins(d, "P_MAXIMIZE", (long)P_MAXIMIZE)) return -1;\r
- if (ins(d, "P_FULLSCREEN", (long)P_FULLSCREEN)) return -1;\r
- if (ins(d, "P_WINDOWED", (long)P_WINDOWED)) return -1;\r
- if (ins(d, "P_FOREGROUND", (long)P_FOREGROUND)) return -1;\r
- if (ins(d, "P_BACKGROUND", (long)P_BACKGROUND)) return -1;\r
- if (ins(d, "P_NOCLOSE", (long)P_NOCLOSE)) return -1;\r
- if (ins(d, "P_NOSESSION", (long)P_NOSESSION)) return -1;\r
- if (ins(d, "P_QUOTE", (long)P_QUOTE)) return -1;\r
- if (ins(d, "P_TILDE", (long)P_TILDE)) return -1;\r
- if (ins(d, "P_UNRELATED", (long)P_UNRELATED)) return -1;\r
- if (ins(d, "P_DEBUGDESC", (long)P_DEBUGDESC)) return -1;\r
-#else\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
-#endif\r
-\r
-#if defined(PYOS_OS2)\r
- if (insertvalues(d)) return -1;\r
-#endif\r
- return 0;\r
-}\r
-\r
-\r
-#if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)) && !defined(__QNX__)\r
-#define INITFUNC initnt\r
-#define MODNAME "nt"\r
-\r
-#elif defined(PYOS_OS2)\r
-#define INITFUNC initos2\r
-#define MODNAME "os2"\r
-\r
-#else\r
-#define INITFUNC initposix\r
-#define MODNAME "posix"\r
-#endif\r
-\r
-PyMODINIT_FUNC\r
-INITFUNC(void)\r
-{\r
- PyObject *m, *v;\r
-\r
- m = Py_InitModule3(MODNAME,\r
- posix_methods,\r
- posix__doc__);\r
- if (m == NULL)\r
- return;\r
-\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
-\r
- if (all_ins(m))\r
- return;\r
-\r
- if (setup_confname_tables(m))\r
- return;\r
-\r
- Py_INCREF(PyExc_OSError);\r
- PyModule_AddObject(m, "error", PyExc_OSError);\r
-\r
-#ifdef HAVE_PUTENV\r
- if (posix_putenv_garbage == NULL)\r
- posix_putenv_garbage = PyDict_New();\r
-#endif\r
-\r
- if (!initialized) {\r
- stat_result_desc.name = MODNAME ".stat_result";\r
- stat_result_desc.fields[7].name = PyStructSequence_UnnamedField;\r
- stat_result_desc.fields[8].name = PyStructSequence_UnnamedField;\r
- stat_result_desc.fields[9].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
-#ifdef __APPLE__\r
- /*\r
- * Step 2 of weak-linking support on Mac OS X.\r
- *\r
- * The code below removes functions that are not available on the\r
- * currently active platform.\r
- *\r
- * This block allow one to use a python binary that was build on\r
- * OSX 10.4 on OSX 10.3, without loosing access to new APIs on\r
- * OSX 10.4.\r
- */\r
-#ifdef HAVE_FSTATVFS\r
- if (fstatvfs == NULL) {\r
- if (PyObject_DelAttrString(m, "fstatvfs") == -1) {\r
- return;\r
- }\r
- }\r
-#endif /* HAVE_FSTATVFS */\r
-\r
-#ifdef HAVE_STATVFS\r
- if (statvfs == NULL) {\r
- if (PyObject_DelAttrString(m, "statvfs") == -1) {\r
- return;\r
- }\r
- }\r
-#endif /* HAVE_STATVFS */\r
-\r
-# ifdef HAVE_LCHOWN\r
- if (lchown == NULL) {\r
- if (PyObject_DelAttrString(m, "lchown") == -1) {\r
- return;\r
- }\r
- }\r
-#endif /* HAVE_LCHOWN */\r
-\r
-\r
-#endif /* __APPLE__ */\r
-\r
-}\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-\r
projects / mirror_edk2.git / blobdiff