/*********************************************************** Copyright (c) 2000, BeOpen.com. Copyright (c) 1995-2000, Corporation for National Research Initiatives. Copyright (c) 1990-1995, Stichting Mathematisch Centrum. All rights reserved. See the file "Misc/COPYRIGHT" for information on usage and redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES. ******************************************************************/ /* POSIX module implementation */ /* This file is also used for Windows NT and MS-Win. In that case the module actually calls itself 'nt', not 'posix', and a few functions are either unimplemented or implemented differently. The source assumes that for Windows NT, the macro 'MS_WIN32' is defined independent of the compiler used. Different compilers define their own feature test macro, e.g. '__BORLANDC__' or '_MSC_VER'. */ /* See also ../Dos/dosmodule.c */ static char posix__doc__ [] = "This module provides access to operating system functionality that is\n\ standardized by the C Standard and the POSIX standard (a thinly\n\ disguised Unix interface). Refer to the library manual and\n\ corresponding Unix manual entries for more information on calls."; #include "Python.h" #if defined(PYOS_OS2) #define INCL_DOS #define INCL_DOSERRORS #define INCL_DOSPROCESS #define INCL_NOPMAPI #include #endif #include #include #ifdef HAVE_SYS_WAIT_H #include /* For WNOHANG */ #endif #ifdef HAVE_SIGNAL_H #include #endif #include "mytime.h" /* For clock_t on some systems */ #ifdef HAVE_FCNTL_H #include #endif /* HAVE_FCNTL_H */ /* Various compilers have only certain posix functions */ /* XXX Gosh I wish these were all moved into config.h */ #if defined(PYCC_VACPP) && defined(PYOS_OS2) #include #else #if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */ #define HAVE_GETCWD 1 #define HAVE_OPENDIR 1 #define HAVE_SYSTEM 1 #if defined(__OS2__) #define HAVE_EXECV 1 #define HAVE_WAIT 1 #endif #include #else #ifdef __BORLANDC__ /* Borland compiler */ #define HAVE_EXECV 1 #define HAVE_GETCWD 1 #define HAVE_GETEGID 1 #define HAVE_GETEUID 1 #define HAVE_GETGID 1 #define HAVE_GETPPID 1 #define HAVE_GETUID 1 #define HAVE_KILL 1 #define HAVE_OPENDIR 1 #define HAVE_PIPE 1 #define HAVE_POPEN 1 #define HAVE_SYSTEM 1 #define HAVE_WAIT 1 #else #ifdef _MSC_VER /* Microsoft compiler */ #define HAVE_GETCWD 1 #ifdef MS_WIN32 #define HAVE_SPAWNV 1 #define HAVE_EXECV 1 #define HAVE_PIPE 1 #define HAVE_POPEN 1 #define HAVE_SYSTEM 1 #else /* 16-bit Windows */ #endif /* !MS_WIN32 */ #else /* all other compilers */ /* Unix functions that the configure script doesn't check for */ #define HAVE_EXECV 1 #define HAVE_FORK 1 #define HAVE_GETCWD 1 #define HAVE_GETEGID 1 #define HAVE_GETEUID 1 #define HAVE_GETGID 1 #define HAVE_GETPPID 1 #define HAVE_GETUID 1 #define HAVE_KILL 1 #define HAVE_OPENDIR 1 #define HAVE_PIPE 1 #define HAVE_POPEN 1 #define HAVE_SYSTEM 1 #define HAVE_WAIT 1 #define HAVE_TTYNAME 1 #endif /* _MSC_VER */ #endif /* __BORLANDC__ */ #endif /* ! __WATCOMC__ || __QNX__ */ #endif /* ! __IBMC__ */ #ifndef _MSC_VER #ifdef HAVE_UNISTD_H #include #endif #ifdef NeXT /* NeXT's and aren't worth much */ #undef HAVE_UNISTD_H #undef HAVE_UTIME_H #define HAVE_WAITPID /* #undef HAVE_GETCWD */ #define UNION_WAIT /* This should really be checked for by autoconf */ #endif #ifdef HAVE_UNISTD_H /* XXX These are for SunOS4.1.3 but shouldn't hurt elsewhere */ extern int rename(); extern int pclose(); extern int lstat(); extern int symlink(); extern int fsync(); #else /* !HAVE_UNISTD_H */ #if defined(PYCC_VACPP) extern int mkdir(char *); #else #if ( defined(__WATCOMC__) || defined(_MSC_VER) ) && !defined(__QNX__) extern int mkdir(const char *); #else extern int mkdir(const char *, mode_t); #endif #endif #if defined(__IBMC__) || defined(__IBMCPP__) extern int chdir(char *); extern int rmdir(char *); #else extern int chdir(const char *); extern int rmdir(const char *); #endif extern int chmod(const char *, mode_t); extern int chown(const char *, uid_t, gid_t); extern char *getcwd(char *, int); extern char *strerror(int); extern int link(const char *, const char *); extern int rename(const char *, const char *); extern int stat(const char *, struct stat *); extern int unlink(const char *); extern int pclose(FILE *); #ifdef HAVE_SYMLINK extern int symlink(const char *, const char *); #endif /* HAVE_SYMLINK */ #ifdef HAVE_LSTAT extern int lstat(const char *, struct stat *); #endif /* HAVE_LSTAT */ #endif /* !HAVE_UNISTD_H */ #endif /* !_MSC_VER */ #ifdef HAVE_UTIME_H #include #endif /* HAVE_UTIME_H */ #ifdef HAVE_SYS_UTIME_H #include #define HAVE_UTIME_H /* pretend we do for the rest of this file */ #endif /* HAVE_SYS_UTIME_H */ #ifdef HAVE_SYS_TIMES_H #include #endif /* HAVE_SYS_TIMES_H */ #ifdef HAVE_SYS_PARAM_H #include #endif /* HAVE_SYS_PARAM_H */ #ifdef HAVE_SYS_UTSNAME_H #include #endif /* HAVE_SYS_UTSNAME_H */ #ifndef MAXPATHLEN #define MAXPATHLEN 1024 #endif /* MAXPATHLEN */ #ifdef HAVE_DIRENT_H #include #define NAMLEN(dirent) strlen((dirent)->d_name) #else #if defined(__WATCOMC__) && !defined(__QNX__) #include #define NAMLEN(dirent) strlen((dirent)->d_name) #else #define dirent direct #define NAMLEN(dirent) (dirent)->d_namlen #endif #ifdef HAVE_SYS_NDIR_H #include #endif #ifdef HAVE_SYS_DIR_H #include #endif #ifdef HAVE_NDIR_H #include #endif #endif #ifdef _MSC_VER #include #include #include #define WINDOWS_LEAN_AND_MEAN #include #ifdef MS_WIN32 #define popen _popen #define pclose _pclose #else /* 16-bit Windows */ #include #include #endif /* MS_WIN32 */ #endif /* _MSC_VER */ #if defined(PYCC_VACPP) && defined(PYOS_OS2) #include #endif /* OS2 */ #ifdef UNION_WAIT /* Emulate some macros on systems that have a union instead of macros */ #ifndef WIFEXITED #define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump) #endif #ifndef WEXITSTATUS #define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1) #endif #ifndef WTERMSIG #define WTERMSIG(u_wait) ((u_wait).w_termsig) #endif #endif /* UNION_WAIT */ /* Don't use the "_r" form if we don't need it (also, won't have a prototype for it, at least on Solaris -- maybe others as well?). */ #if defined(HAVE_CTERMID_R) && defined(WITH_THREAD) #define USE_CTERMID_R #endif #if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD) #define USE_TMPNAM_R #endif /* choose the appropriate stat and fstat functions and return structs */ #undef STAT #ifdef MS_WIN64 # define STAT _stati64 # define FSTAT _fstati64 # define STRUCT_STAT struct _stati64 #else # define STAT stat # define FSTAT fstat # define STRUCT_STAT struct stat #endif /* Return a dictionary corresponding to the POSIX environment table */ #if !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) ) extern char **environ; #endif /* !_MSC_VER */ static PyObject * convertenviron() { PyObject *d; char **e; d = PyDict_New(); if (d == NULL) return NULL; if (environ == NULL) return d; /* This part ignores errors */ for (e = environ; *e != NULL; e++) { PyObject *k; PyObject *v; char *p = strchr(*e, '='); if (p == NULL) continue; k = PyString_FromStringAndSize(*e, (int)(p-*e)); if (k == NULL) { PyErr_Clear(); continue; } v = PyString_FromString(p+1); if (v == NULL) { PyErr_Clear(); Py_DECREF(k); continue; } if (PyDict_GetItem(d, k) == NULL) { if (PyDict_SetItem(d, k, v) != 0) PyErr_Clear(); } Py_DECREF(k); Py_DECREF(v); } #if defined(PYOS_OS2) { APIRET rc; char buffer[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */ rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH); if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */ PyObject *v = PyString_FromString(buffer); PyDict_SetItemString(d, "BEGINLIBPATH", v); Py_DECREF(v); } rc = DosQueryExtLIBPATH(buffer, END_LIBPATH); if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */ PyObject *v = PyString_FromString(buffer); PyDict_SetItemString(d, "ENDLIBPATH", v); Py_DECREF(v); } } #endif return d; } /* Set a POSIX-specific error from errno, and return NULL */ static PyObject * posix_error() { return PyErr_SetFromErrno(PyExc_OSError); } static PyObject * posix_error_with_filename(char* name) { return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name); } #ifdef MS_WIN32 static PyObject * win32_error(char* function, char* filename) { /* XXX this could be improved */ errno = GetLastError(); if (filename) return PyErr_SetFromErrnoWithFilename(PyExc_OSError, filename); else return PyErr_SetFromErrno(PyExc_OSError); } #endif #if defined(PYOS_OS2) /********************************************************************** * Helper Function to Trim and Format OS/2 Messages **********************************************************************/ static void os2_formatmsg(char *msgbuf, int msglen, char *reason) { msgbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */ if (strlen(msgbuf) > 0) { /* If Non-Empty Msg, Trim CRLF */ char *lastc = &msgbuf[ strlen(msgbuf)-1 ]; while (lastc > msgbuf && isspace(*lastc)) *lastc-- = '\0'; /* Trim Trailing Whitespace (CRLF) */ } /* Add Optional Reason Text */ if (reason) { strcat(msgbuf, " : "); strcat(msgbuf, reason); } } /********************************************************************** * Decode an OS/2 Operating System Error Code * * A convenience function to lookup an OS/2 error code and return a * text message we can use to raise a Python exception. * * Notes: * The messages for errors returned from the OS/2 kernel reside in * the file OSO001.MSG in the \OS2 directory hierarchy. * **********************************************************************/ static char * os2_strerror(char *msgbuf, int msgbuflen, int errorcode, char *reason) { APIRET rc; ULONG msglen; /* Retrieve Kernel-Related Error Message from OSO001.MSG File */ Py_BEGIN_ALLOW_THREADS rc = DosGetMessage(NULL, 0, msgbuf, msgbuflen, errorcode, "oso001.msg", &msglen); Py_END_ALLOW_THREADS if (rc == NO_ERROR) os2_formatmsg(msgbuf, msglen, reason); else sprintf(msgbuf, "unknown OS error #%d", errorcode); return msgbuf; } /* Set an OS/2-specific error and return NULL. OS/2 kernel errors are not in a global variable e.g. 'errno' nor are they congruent with posix error numbers. */ static PyObject * os2_error(int code) { char text[1024]; PyObject *v; os2_strerror(text, sizeof(text), code, ""); v = Py_BuildValue("(is)", code, text); if (v != NULL) { PyErr_SetObject(PyExc_OSError, v); Py_DECREF(v); } return NULL; /* Signal to Python that an Exception is Pending */ } #endif /* OS2 */ /* POSIX generic methods */ static PyObject * posix_int(PyObject *args, char *format, int (*func)(int)) { int fd; int res; if (!PyArg_ParseTuple(args, format, &fd)) return NULL; Py_BEGIN_ALLOW_THREADS res = (*func)(fd); Py_END_ALLOW_THREADS if (res < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } static PyObject * posix_1str(PyObject *args, char *format, int (*func)(const char*)) { char *path1; int res; if (!PyArg_ParseTuple(args, format, &path1)) return NULL; Py_BEGIN_ALLOW_THREADS res = (*func)(path1); Py_END_ALLOW_THREADS if (res < 0) return posix_error_with_filename(path1); Py_INCREF(Py_None); return Py_None; } static PyObject * posix_2str(PyObject *args, char *format, int (*func)(const char *, const char *)) { char *path1, *path2; int res; if (!PyArg_ParseTuple(args, format, &path1, &path2)) return NULL; Py_BEGIN_ALLOW_THREADS res = (*func)(path1, path2); Py_END_ALLOW_THREADS if (res != 0) /* XXX how to report both path1 and path2??? */ return posix_error(); Py_INCREF(Py_None); return Py_None; } static PyObject * posix_strint(PyObject *args, char *format, int (*func)(const char *, int)) { char *path; int i; int res; if (!PyArg_ParseTuple(args, format, &path, &i)) return NULL; Py_BEGIN_ALLOW_THREADS res = (*func)(path, i); Py_END_ALLOW_THREADS if (res < 0) return posix_error_with_filename(path); Py_INCREF(Py_None); return Py_None; } static PyObject * posix_strintint(PyObject *args, char *format, int (*func)(const char *, int, int)) { char *path; int i,i2; int res; if (!PyArg_ParseTuple(args, format, &path, &i, &i2)) return NULL; Py_BEGIN_ALLOW_THREADS res = (*func)(path, i, i2); Py_END_ALLOW_THREADS if (res < 0) return posix_error_with_filename(path); Py_INCREF(Py_None); return Py_None; } /* pack a system stat C structure into the Python stat tuple (used by posix_stat() and posix_fstat()) */ static PyObject* _pystat_fromstructstat(STRUCT_STAT st) { PyObject *v = PyTuple_New(10); if (v == NULL) return NULL; PyTuple_SetItem(v, 0, PyInt_FromLong((long)st.st_mode)); #ifdef HAVE_LARGEFILE_SUPPORT PyTuple_SetItem(v, 1, PyLong_FromLongLong((LONG_LONG)st.st_ino)); #else PyTuple_SetItem(v, 1, PyInt_FromLong((long)st.st_ino)); #endif #if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS) PyTuple_SetItem(v, 2, PyLong_FromLongLong((LONG_LONG)st.st_dev)); #else PyTuple_SetItem(v, 2, PyInt_FromLong((long)st.st_dev)); #endif PyTuple_SetItem(v, 3, PyInt_FromLong((long)st.st_nlink)); PyTuple_SetItem(v, 4, PyInt_FromLong((long)st.st_uid)); PyTuple_SetItem(v, 5, PyInt_FromLong((long)st.st_gid)); #ifdef HAVE_LARGEFILE_SUPPORT PyTuple_SetItem(v, 6, PyLong_FromLongLong((LONG_LONG)st.st_size)); #else PyTuple_SetItem(v, 6, PyInt_FromLong(st.st_size)); #endif #if SIZEOF_TIME_T > SIZEOF_LONG PyTuple_SetItem(v, 7, PyLong_FromLongLong((LONG_LONG)st.st_atime)); PyTuple_SetItem(v, 8, PyLong_FromLongLong((LONG_LONG)st.st_mtime)); PyTuple_SetItem(v, 9, PyLong_FromLongLong((LONG_LONG)st.st_ctime)); #else PyTuple_SetItem(v, 7, PyInt_FromLong((long)st.st_atime)); PyTuple_SetItem(v, 8, PyInt_FromLong((long)st.st_mtime)); PyTuple_SetItem(v, 9, PyInt_FromLong((long)st.st_ctime)); #endif if (PyErr_Occurred()) { Py_DECREF(v); return NULL; } return v; } static PyObject * posix_do_stat(PyObject *self, PyObject *args, char *format, int (*statfunc)(const char *, STRUCT_STAT *)) { STRUCT_STAT st; char *path; int res; #ifdef MS_WIN32 int pathlen; char pathcopy[MAX_PATH]; #endif /* MS_WIN32 */ if (!PyArg_ParseTuple(args, format, &path)) return NULL; #ifdef MS_WIN32 pathlen = strlen(path); /* the library call can blow up if the file name is too long! */ if (pathlen > MAX_PATH) { errno = ENAMETOOLONG; return posix_error(); } if ((pathlen > 0) && (path[pathlen-1] == '\\' || path[pathlen-1] == '/')) { /* exception for specific or current drive root */ if (!((pathlen == 1) || ((pathlen == 3) && (path[1] == ':') && (path[2] == '\\' || path[2] == '/')))) { strncpy(pathcopy, path, pathlen); pathcopy[pathlen-1] = '\0'; /* nuke the trailing backslash */ path = pathcopy; } } #endif /* MS_WIN32 */ Py_BEGIN_ALLOW_THREADS res = (*statfunc)(path, &st); Py_END_ALLOW_THREADS if (res != 0) return posix_error_with_filename(path); return _pystat_fromstructstat(st); } /* POSIX methods */ static char posix_access__doc__[] = "access(path, mode) -> 1 if granted, 0 otherwise\n\ Test for access to a file."; static PyObject * posix_access(PyObject *self, PyObject *args) { char *path; int mode; int res; if (!PyArg_ParseTuple(args, "si:access", &path, &mode)) return NULL; Py_BEGIN_ALLOW_THREADS res = access(path, mode); Py_END_ALLOW_THREADS return(PyInt_FromLong(res == 0 ? 1L : 0L)); } #ifndef F_OK #define F_OK 0 #endif #ifndef R_OK #define R_OK 4 #endif #ifndef W_OK #define W_OK 2 #endif #ifndef X_OK #define X_OK 1 #endif #ifdef HAVE_TTYNAME static char posix_ttyname__doc__[] = "ttyname(fd) -> String\n\ Return the name of the terminal device connected to 'fd'."; static PyObject * posix_ttyname(PyObject *self, PyObject *args) { int id; char *ret; if (!PyArg_ParseTuple(args, "i:ttyname", &id)) return NULL; ret = ttyname(id); if (ret == NULL) return(posix_error()); return(PyString_FromString(ret)); } #endif #ifdef HAVE_CTERMID static char posix_ctermid__doc__[] = "ctermid() -> String\n\ Return the name of the controlling terminal for this process."; static PyObject * posix_ctermid(PyObject *self, PyObject *args) { char *ret; char buffer[L_ctermid]; if (!PyArg_ParseTuple(args, ":ctermid")) return NULL; #ifdef USE_CTERMID_R ret = ctermid_r(buffer); #else ret = ctermid(buffer); #endif if (ret == NULL) return(posix_error()); return(PyString_FromString(buffer)); } #endif static char posix_chdir__doc__[] = "chdir(path) -> None\n\ Change the current working directory to the specified path."; static PyObject * posix_chdir(PyObject *self, PyObject *args) { return posix_1str(args, "s:chdir", chdir); } static char posix_chmod__doc__[] = "chmod(path, mode) -> None\n\ Change the access permissions of a file."; static PyObject * posix_chmod(PyObject *self, PyObject *args) { char *path; int i; int res; if (!PyArg_ParseTuple(args, "si", &path, &i)) return NULL; Py_BEGIN_ALLOW_THREADS res = chmod(path, i); Py_END_ALLOW_THREADS if (res < 0) return posix_error_with_filename(path); Py_INCREF(Py_None); return Py_None; } #ifdef HAVE_FSYNC static char posix_fsync__doc__[] = "fsync(fildes) -> None\n\ force write of file with filedescriptor to disk."; static PyObject * posix_fsync(PyObject *self, PyObject *args) { return posix_int(args, "i:fsync", fsync); } #endif /* HAVE_FSYNC */ #ifdef HAVE_FDATASYNC static char posix_fdatasync__doc__[] = "fdatasync(fildes) -> None\n\ force write of file with filedescriptor to disk.\n\ does not force update of metadata."; extern int fdatasync(int); /* Prototype just in case */ static PyObject * posix_fdatasync(PyObject *self, PyObject *args) { return posix_int(args, "i:fdatasync", fdatasync); } #endif /* HAVE_FDATASYNC */ #ifdef HAVE_CHOWN static char posix_chown__doc__[] = "chown(path, uid, gid) -> None\n\ Change the owner and group id of path to the numeric uid and gid."; static PyObject * posix_chown(PyObject *self, PyObject *args) { return posix_strintint(args, "sii:chown", chown); } #endif /* HAVE_CHOWN */ #ifdef HAVE_GETCWD static char posix_getcwd__doc__[] = "getcwd() -> path\n\ Return a string representing the current working directory."; static PyObject * posix_getcwd(PyObject *self, PyObject *args) { char buf[1026]; char *res; if (!PyArg_ParseTuple(args, ":getcwd")) return NULL; Py_BEGIN_ALLOW_THREADS res = getcwd(buf, sizeof buf); Py_END_ALLOW_THREADS if (res == NULL) return posix_error(); return PyString_FromString(buf); } #endif #ifdef HAVE_LINK static char posix_link__doc__[] = "link(src, dst) -> None\n\ Create a hard link to a file."; static PyObject * posix_link(PyObject *self, PyObject *args) { return posix_2str(args, "ss:link", link); } #endif /* HAVE_LINK */ static char posix_listdir__doc__[] = "listdir(path) -> list_of_strings\n\ Return a list containing the names of the entries in the directory.\n\ \n\ path: path of directory to list\n\ \n\ The list is in arbitrary order. It does not include the special\n\ entries '.' and '..' even if they are present in the directory."; static PyObject * posix_listdir(PyObject *self, PyObject *args) { /* XXX Should redo this putting the (now four) versions of opendir in separate files instead of having them all here... */ #if defined(MS_WIN32) && !defined(HAVE_OPENDIR) char *name; int len; PyObject *d, *v; HANDLE hFindFile; WIN32_FIND_DATA FileData; char namebuf[MAX_PATH+5]; if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len)) return NULL; if (len >= MAX_PATH) { PyErr_SetString(PyExc_ValueError, "path too long"); return NULL; } strcpy(namebuf, name); if (namebuf[len-1] != '/' && namebuf[len-1] != '\\') namebuf[len++] = '/'; strcpy(namebuf + len, "*.*"); if ((d = PyList_New(0)) == NULL) return NULL; hFindFile = FindFirstFile(namebuf, &FileData); if (hFindFile == INVALID_HANDLE_VALUE) { errno = GetLastError(); if (errno == ERROR_FILE_NOT_FOUND) return PyList_New(0); return win32_error("FindFirstFile", name); } do { if (FileData.cFileName[0] == '.' && (FileData.cFileName[1] == '\0' || FileData.cFileName[1] == '.' && FileData.cFileName[2] == '\0')) continue; v = PyString_FromString(FileData.cFileName); if (v == NULL) { Py_DECREF(d); d = NULL; break; } if (PyList_Append(d, v) != 0) { Py_DECREF(v); Py_DECREF(d); d = NULL; break; } Py_DECREF(v); } while (FindNextFile(hFindFile, &FileData) == TRUE); if (FindClose(hFindFile) == FALSE) return win32_error("FindClose", name); return d; #else /* !MS_WIN32 */ #ifdef _MSC_VER /* 16-bit Windows */ #ifndef MAX_PATH #define MAX_PATH 250 #endif char *name, *pt; int len; PyObject *d, *v; char namebuf[MAX_PATH+5]; struct _find_t ep; if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len)) return NULL; if (len >= MAX_PATH) { PyErr_SetString(PyExc_ValueError, "path too long"); return NULL; } strcpy(namebuf, name); for (pt = namebuf; *pt; pt++) if (*pt == '/') *pt = '\\'; if (namebuf[len-1] != '\\') namebuf[len++] = '\\'; strcpy(namebuf + len, "*.*"); if ((d = PyList_New(0)) == NULL) return NULL; if (_dos_findfirst(namebuf, _A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_SUBDIR, &ep) != 0) { errno = ENOENT; return posix_error_with_filename(name); } do { if (ep.name[0] == '.' && (ep.name[1] == '\0' || ep.name[1] == '.' && ep.name[2] == '\0')) continue; strcpy(namebuf, ep.name); for (pt = namebuf; *pt; pt++) if (isupper(*pt)) *pt = tolower(*pt); v = PyString_FromString(namebuf); if (v == NULL) { Py_DECREF(d); d = NULL; break; } if (PyList_Append(d, v) != 0) { Py_DECREF(v); Py_DECREF(d); d = NULL; break; } Py_DECREF(v); } while (_dos_findnext(&ep) == 0); return d; #else #if defined(PYOS_OS2) #ifndef MAX_PATH #define MAX_PATH CCHMAXPATH #endif char *name, *pt; int len; PyObject *d, *v; char namebuf[MAX_PATH+5]; HDIR hdir = 1; ULONG srchcnt = 1; FILEFINDBUF3 ep; APIRET rc; if (!PyArg_ParseTuple(args, "t#:listdir", &name, &len)) return NULL; if (len >= MAX_PATH) { PyErr_SetString(PyExc_ValueError, "path too long"); return NULL; } strcpy(namebuf, name); for (pt = namebuf; *pt; pt++) if (*pt == '/') *pt = '\\'; if (namebuf[len-1] != '\\') namebuf[len++] = '\\'; strcpy(namebuf + len, "*.*"); if ((d = PyList_New(0)) == NULL) return NULL; rc = DosFindFirst(namebuf, /* Wildcard Pattern to Match */ &hdir, /* Handle to Use While Search Directory */ FILE_READONLY | FILE_HIDDEN | FILE_SYSTEM | FILE_DIRECTORY, &ep, sizeof(ep), /* Structure to Receive Directory Entry */ &srchcnt, /* Max and Actual Count of Entries Per Iteration */ FIL_STANDARD); /* Format of Entry (EAs or Not) */ if (rc != NO_ERROR) { errno = ENOENT; return posix_error_with_filename(name); } if (srchcnt > 0) { /* If Directory is NOT Totally Empty, */ do { if (ep.achName[0] == '.' && (ep.achName[1] == '\0' || ep.achName[1] == '.' && ep.achName[2] == '\0')) continue; /* Skip Over "." and ".." Names */ strcpy(namebuf, ep.achName); /* Leave Case of Name Alone -- In Native Form */ /* (Removed Forced Lowercasing Code) */ v = PyString_FromString(namebuf); if (v == NULL) { Py_DECREF(d); d = NULL; break; } if (PyList_Append(d, v) != 0) { Py_DECREF(v); Py_DECREF(d); d = NULL; break; } Py_DECREF(v); } while (DosFindNext(hdir, &ep, sizeof(ep), &srchcnt) == NO_ERROR && srchcnt > 0); } return d; #else char *name; PyObject *d, *v; DIR *dirp; struct dirent *ep; if (!PyArg_ParseTuple(args, "s:listdir", &name)) return NULL; if ((dirp = opendir(name)) == NULL) { return posix_error_with_filename(name); } if ((d = PyList_New(0)) == NULL) { closedir(dirp); return NULL; } while ((ep = readdir(dirp)) != NULL) { if (ep->d_name[0] == '.' && (NAMLEN(ep) == 1 || (ep->d_name[1] == '.' && NAMLEN(ep) == 2))) continue; v = PyString_FromStringAndSize(ep->d_name, NAMLEN(ep)); if (v == NULL) { Py_DECREF(d); d = NULL; break; } if (PyList_Append(d, v) != 0) { Py_DECREF(v); Py_DECREF(d); d = NULL; break; } Py_DECREF(v); } closedir(dirp); return d; #endif /* !PYOS_OS2 */ #endif /* !_MSC_VER */ #endif /* !MS_WIN32 */ } static char posix_mkdir__doc__[] = "mkdir(path [, mode=0777]) -> None\n\ Create a directory."; static PyObject * posix_mkdir(PyObject *self, PyObject *args) { int res; char *path; int mode = 0777; if (!PyArg_ParseTuple(args, "s|i:mkdir", &path, &mode)) return NULL; Py_BEGIN_ALLOW_THREADS #if ( defined(__WATCOMC__) || defined(_MSC_VER) || defined(PYCC_VACPP) ) && !defined(__QNX__) res = mkdir(path); #else res = mkdir(path, mode); #endif Py_END_ALLOW_THREADS if (res < 0) return posix_error_with_filename(path); Py_INCREF(Py_None); return Py_None; } #ifdef HAVE_NICE static char posix_nice__doc__[] = "nice(inc) -> new_priority\n\ Decrease the priority of process and return new priority."; static PyObject * posix_nice(PyObject *self, PyObject *args) { int increment, value; if (!PyArg_ParseTuple(args, "i:nice", &increment)) return NULL; value = nice(increment); if (value == -1) return posix_error(); return PyInt_FromLong((long) value); } #endif /* HAVE_NICE */ static char posix_rename__doc__[] = "rename(old, new) -> None\n\ Rename a file or directory."; static PyObject * posix_rename(PyObject *self, PyObject *args) { return posix_2str(args, "ss:rename", rename); } static char posix_rmdir__doc__[] = "rmdir(path) -> None\n\ Remove a directory."; static PyObject * posix_rmdir(PyObject *self, PyObject *args) { return posix_1str(args, "s:rmdir", rmdir); } static char posix_stat__doc__[] = "stat(path) -> (mode,ino,dev,nlink,uid,gid,size,atime,mtime,ctime)\n\ Perform a stat system call on the given path."; static PyObject * posix_stat(PyObject *self, PyObject *args) { return posix_do_stat(self, args, "s:stat", STAT); } #ifdef HAVE_SYSTEM static char posix_system__doc__[] = "system(command) -> exit_status\n\ Execute the command (a string) in a subshell."; static PyObject * posix_system(PyObject *self, PyObject *args) { char *command; long sts; if (!PyArg_ParseTuple(args, "s:system", &command)) return NULL; Py_BEGIN_ALLOW_THREADS sts = system(command); Py_END_ALLOW_THREADS return PyInt_FromLong(sts); } #endif static char posix_umask__doc__[] = "umask(new_mask) -> old_mask\n\ Set the current numeric umask and return the previous umask."; static PyObject * posix_umask(PyObject *self, PyObject *args) { int i; if (!PyArg_ParseTuple(args, "i:umask", &i)) return NULL; i = umask(i); if (i < 0) return posix_error(); return PyInt_FromLong((long)i); } static char posix_unlink__doc__[] = "unlink(path) -> None\n\ Remove a file (same as remove(path))."; static char posix_remove__doc__[] = "remove(path) -> None\n\ Remove a file (same as unlink(path))."; static PyObject * posix_unlink(PyObject *self, PyObject *args) { return posix_1str(args, "s:remove", unlink); } #ifdef HAVE_UNAME static char posix_uname__doc__[] = "uname() -> (sysname, nodename, release, version, machine)\n\ Return a tuple identifying the current operating system."; static PyObject * posix_uname(PyObject *self, PyObject *args) { struct utsname u; int res; if (!PyArg_ParseTuple(args, ":uname")) return NULL; Py_BEGIN_ALLOW_THREADS res = uname(&u); Py_END_ALLOW_THREADS if (res < 0) return posix_error(); return Py_BuildValue("(sssss)", u.sysname, u.nodename, u.release, u.version, u.machine); } #endif /* HAVE_UNAME */ static char posix_utime__doc__[] = "utime(path, (atime, utime)) -> None\n\ utime(path, None) -> None\n\ Set the access and modified time of the file to the given values. If the\n\ second form is used, set the access and modified times to the current time."; static PyObject * posix_utime(PyObject *self, PyObject *args) { char *path; long atime, mtime; int res; PyObject* arg; /* XXX should define struct utimbuf instead, above */ #ifdef HAVE_UTIME_H struct utimbuf buf; #define ATIME buf.actime #define MTIME buf.modtime #define UTIME_ARG &buf #else /* HAVE_UTIME_H */ time_t buf[2]; #define ATIME buf[0] #define MTIME buf[1] #define UTIME_ARG buf #endif /* HAVE_UTIME_H */ if (!PyArg_ParseTuple(args, "sO:utime", &path, &arg)) return NULL; if (arg == Py_None) { /* optional time values not given */ Py_BEGIN_ALLOW_THREADS res = utime(path, NULL); Py_END_ALLOW_THREADS } else if (!PyArg_Parse(arg, "(ll)", &atime, &mtime)) { PyErr_SetString(PyExc_TypeError, "Second argument must be a 2-tuple of numbers."); return NULL; } else { ATIME = atime; MTIME = mtime; Py_BEGIN_ALLOW_THREADS res = utime(path, UTIME_ARG); Py_END_ALLOW_THREADS } if (res < 0) return posix_error_with_filename(path); Py_INCREF(Py_None); return Py_None; #undef UTIME_ARG #undef ATIME #undef MTIME } /* Process operations */ static char posix__exit__doc__[] = "_exit(status)\n\ Exit to the system with specified status, without normal exit processing."; static PyObject * posix__exit(PyObject *self, PyObject *args) { int sts; if (!PyArg_ParseTuple(args, "i:_exit", &sts)) return NULL; _exit(sts); return NULL; /* Make gcc -Wall happy */ } #ifdef HAVE_EXECV static char posix_execv__doc__[] = "execv(path, args)\n\ Execute an executable path with arguments, replacing current process.\n\ \n\ path: path of executable file\n\ args: tuple or list of strings"; static PyObject * posix_execv(PyObject *self, PyObject *args) { char *path; PyObject *argv; char **argvlist; int i, argc; PyObject *(*getitem)(PyObject *, int); /* execv has two arguments: (path, argv), where argv is a list or tuple of strings. */ if (!PyArg_ParseTuple(args, "sO:execv", &path, &argv)) return NULL; if (PyList_Check(argv)) { argc = PyList_Size(argv); getitem = PyList_GetItem; } else if (PyTuple_Check(argv)) { argc = PyTuple_Size(argv); getitem = PyTuple_GetItem; } else { PyErr_SetString(PyExc_TypeError, "argv must be tuple or list"); return NULL; } if (argc == 0) { PyErr_SetString(PyExc_ValueError, "empty argument list"); return NULL; } argvlist = PyMem_NEW(char *, argc+1); if (argvlist == NULL) return NULL; for (i = 0; i < argc; i++) { if (!PyArg_Parse((*getitem)(argv, i), "s", &argvlist[i])) { PyMem_DEL(argvlist); PyErr_SetString(PyExc_TypeError, "all arguments must be strings"); return NULL; } } argvlist[argc] = NULL; #ifdef BAD_EXEC_PROTOTYPES execv(path, (const char **) argvlist); #else /* BAD_EXEC_PROTOTYPES */ execv(path, argvlist); #endif /* BAD_EXEC_PROTOTYPES */ /* If we get here it's definitely an error */ PyMem_DEL(argvlist); return posix_error(); } static char posix_execve__doc__[] = "execve(path, args, env)\n\ Execute a path with arguments and environment, replacing current process.\n\ \n\ path: path of executable file\n\ args: tuple or list of arguments\n\ env: dictonary of strings mapping to strings"; static PyObject * posix_execve(PyObject *self, PyObject *args) { char *path; PyObject *argv, *env; char **argvlist; char **envlist; PyObject *key, *val, *keys=NULL, *vals=NULL; int i, pos, argc, envc; PyObject *(*getitem)(PyObject *, int); /* execve has three arguments: (path, argv, env), where argv is a list or tuple of strings and env is a dictionary like posix.environ. */ if (!PyArg_ParseTuple(args, "sOO:execve", &path, &argv, &env)) return NULL; if (PyList_Check(argv)) { argc = PyList_Size(argv); getitem = PyList_GetItem; } else if (PyTuple_Check(argv)) { argc = PyTuple_Size(argv); getitem = PyTuple_GetItem; } else { PyErr_SetString(PyExc_TypeError, "argv must be tuple or list"); return NULL; } if (!PyMapping_Check(env)) { PyErr_SetString(PyExc_TypeError, "env must be mapping object"); return NULL; } if (argc == 0) { PyErr_SetString(PyExc_ValueError, "empty argument list"); return NULL; } argvlist = PyMem_NEW(char *, argc+1); if (argvlist == NULL) { PyErr_NoMemory(); return NULL; } for (i = 0; i < argc; i++) { if (!PyArg_Parse((*getitem)(argv, i), "s;argv must be list of strings", &argvlist[i])) { goto fail_1; } } argvlist[argc] = NULL; i = PyMapping_Length(env); envlist = PyMem_NEW(char *, i + 1); if (envlist == NULL) { PyErr_NoMemory(); goto fail_1; } envc = 0; keys = PyMapping_Keys(env); vals = PyMapping_Values(env); if (!keys || !vals) goto fail_2; for (pos = 0; pos < i; pos++) { char *p, *k, *v; key = PyList_GetItem(keys, pos); val = PyList_GetItem(vals, pos); if (!key || !val) goto fail_2; if (!PyArg_Parse(key, "s;non-string key in env", &k) || !PyArg_Parse(val, "s;non-string value in env", &v)) { goto fail_2; } #if defined(PYOS_OS2) /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */ if (stricmp(k, "BEGINLIBPATH") != 0 && stricmp(k, "ENDLIBPATH") != 0) { #endif p = PyMem_NEW(char, PyString_Size(key)+PyString_Size(val) + 2); if (p == NULL) { PyErr_NoMemory(); goto fail_2; } sprintf(p, "%s=%s", k, v); envlist[envc++] = p; #if defined(PYOS_OS2) } #endif } envlist[envc] = 0; #ifdef BAD_EXEC_PROTOTYPES execve(path, (const char **)argvlist, envlist); #else /* BAD_EXEC_PROTOTYPES */ execve(path, argvlist, envlist); #endif /* BAD_EXEC_PROTOTYPES */ /* If we get here it's definitely an error */ (void) posix_error(); fail_2: while (--envc >= 0) PyMem_DEL(envlist[envc]); PyMem_DEL(envlist); fail_1: PyMem_DEL(argvlist); Py_XDECREF(vals); Py_XDECREF(keys); return NULL; } #endif /* HAVE_EXECV */ #ifdef HAVE_SPAWNV static char posix_spawnv__doc__[] = "spawnv(mode, path, args)\n\ Execute an executable path with arguments, replacing current process.\n\ \n\ mode: mode of process creation\n\ path: path of executable file\n\ args: tuple or list of strings"; static PyObject * posix_spawnv(PyObject *self, PyObject *args) { char *path; PyObject *argv; char **argvlist; int mode, i, argc; intptr_t spawnval; PyObject *(*getitem)(PyObject *, int); /* spawnv has three arguments: (mode, path, argv), where argv is a list or tuple of strings. */ if (!PyArg_ParseTuple(args, "isO:spawnv", &mode, &path, &argv)) return NULL; if (PyList_Check(argv)) { argc = PyList_Size(argv); getitem = PyList_GetItem; } else if (PyTuple_Check(argv)) { argc = PyTuple_Size(argv); getitem = PyTuple_GetItem; } else { PyErr_SetString(PyExc_TypeError, "argv must be tuple or list"); return NULL; } argvlist = PyMem_NEW(char *, argc+1); if (argvlist == NULL) return NULL; for (i = 0; i < argc; i++) { if (!PyArg_Parse((*getitem)(argv, i), "s", &argvlist[i])) { PyMem_DEL(argvlist); PyErr_SetString(PyExc_TypeError, "all arguments must be strings"); return NULL; } } argvlist[argc] = NULL; if (mode == _OLD_P_OVERLAY) mode = _P_OVERLAY; spawnval = _spawnv(mode, path, argvlist); PyMem_DEL(argvlist); if (spawnval == -1) return posix_error(); else #if SIZEOF_LONG == SIZEOF_VOID_P return Py_BuildValue("l", (long) spawnval); #else return Py_BuildValue("L", (LONG_LONG) spawnval); #endif } static char posix_spawnve__doc__[] = "spawnve(mode, path, args, env)\n\ Execute a path with arguments and environment, replacing current process.\n\ \n\ mode: mode of process creation\n\ path: path of executable file\n\ args: tuple or list of arguments\n\ env: dictonary of strings mapping to strings"; static PyObject * posix_spawnve(PyObject *self, PyObject *args) { char *path; PyObject *argv, *env; char **argvlist; char **envlist; PyObject *key, *val, *keys=NULL, *vals=NULL, *res=NULL; int mode, i, pos, argc, envc; intptr_t spawnval; PyObject *(*getitem)(PyObject *, int); /* spawnve has four arguments: (mode, path, argv, env), where argv is a list or tuple of strings and env is a dictionary like posix.environ. */ if (!PyArg_ParseTuple(args, "isOO:spawnve", &mode, &path, &argv, &env)) return NULL; if (PyList_Check(argv)) { argc = PyList_Size(argv); getitem = PyList_GetItem; } else if (PyTuple_Check(argv)) { argc = PyTuple_Size(argv); getitem = PyTuple_GetItem; } else { PyErr_SetString(PyExc_TypeError, "argv must be tuple or list"); return NULL; } if (!PyMapping_Check(env)) { PyErr_SetString(PyExc_TypeError, "env must be mapping object"); return NULL; } argvlist = PyMem_NEW(char *, argc+1); if (argvlist == NULL) { PyErr_NoMemory(); return NULL; } for (i = 0; i < argc; i++) { if (!PyArg_Parse((*getitem)(argv, i), "s;argv must be list of strings", &argvlist[i])) { goto fail_1; } } argvlist[argc] = NULL; i = PyMapping_Length(env); envlist = PyMem_NEW(char *, i + 1); if (envlist == NULL) { PyErr_NoMemory(); goto fail_1; } envc = 0; keys = PyMapping_Keys(env); vals = PyMapping_Values(env); if (!keys || !vals) goto fail_2; for (pos = 0; pos < i; pos++) { char *p, *k, *v; key = PyList_GetItem(keys, pos); val = PyList_GetItem(vals, pos); if (!key || !val) goto fail_2; if (!PyArg_Parse(key, "s;non-string key in env", &k) || !PyArg_Parse(val, "s;non-string value in env", &v)) { goto fail_2; } p = PyMem_NEW(char, PyString_Size(key)+PyString_Size(val) + 2); if (p == NULL) { PyErr_NoMemory(); goto fail_2; } sprintf(p, "%s=%s", k, v); envlist[envc++] = p; } envlist[envc] = 0; if (mode == _OLD_P_OVERLAY) mode = _P_OVERLAY; spawnval = _spawnve(mode, path, argvlist, envlist); if (spawnval == -1) (void) posix_error(); else #if SIZEOF_LONG == SIZEOF_VOID_P res = Py_BuildValue("l", (long) spawnval); #else res = Py_BuildValue("L", (LONG_LONG) spawnval); #endif fail_2: while (--envc >= 0) PyMem_DEL(envlist[envc]); PyMem_DEL(envlist); fail_1: PyMem_DEL(argvlist); Py_XDECREF(vals); Py_XDECREF(keys); return res; } #endif /* HAVE_SPAWNV */ #ifdef HAVE_FORK static char posix_fork__doc__[] = "fork() -> pid\n\ Fork a child process.\n\ \n\ Return 0 to child process and PID of child to parent process."; static PyObject * posix_fork(PyObject *self, PyObject *args) { int pid; if (!PyArg_ParseTuple(args, ":fork")) return NULL; pid = fork(); if (pid == -1) return posix_error(); if (pid == 0) PyOS_AfterFork(); return PyInt_FromLong((long)pid); } #endif #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) #ifdef HAVE_PTY_H #include #else #ifdef HAVE_LIBUTIL_H #include #else /* BSDI does not supply a prototype for the 'openpty' and 'forkpty' functions, eventhough they are included in libutil. */ #include extern int openpty(int *, int *, char *, struct termios *, struct winsize *); extern int forkpty(int *, char *, struct termios *, struct winsize *); #endif /* HAVE_LIBUTIL_H */ #endif /* HAVE_PTY_H */ #endif /* defined(HAVE_OPENPTY) or defined(HAVE_FORKPTY) */ #ifdef HAVE_OPENPTY static char posix_openpty__doc__[] = "openpty() -> (master_fd, slave_fd)\n\ Open a pseudo-terminal, returning open fd's for both master and slave end.\n"; static PyObject * posix_openpty(PyObject *self, PyObject *args) { int master_fd, slave_fd; if (!PyArg_ParseTuple(args, ":openpty")) return NULL; if (openpty(&master_fd, &slave_fd, NULL, NULL, NULL) != 0) return posix_error(); return Py_BuildValue("(ii)", master_fd, slave_fd); } #endif #ifdef HAVE_FORKPTY static char posix_forkpty__doc__[] = "forkpty() -> (pid, master_fd)\n\ Fork a new process with a new pseudo-terminal as controlling tty.\n\n\ Like fork(), return 0 as pid to child process, and PID of child to parent.\n\ To both, return fd of newly opened pseudo-terminal.\n"; static PyObject * posix_forkpty(PyObject *self, PyObject *args) { int master_fd, pid; if (!PyArg_ParseTuple(args, ":forkpty")) return NULL; pid = forkpty(&master_fd, NULL, NULL, NULL); if (pid == -1) return posix_error(); if (pid == 0) PyOS_AfterFork(); return Py_BuildValue("(ii)", pid, master_fd); } #endif #ifdef HAVE_GETEGID static char posix_getegid__doc__[] = "getegid() -> egid\n\ Return the current process's effective group id."; static PyObject * posix_getegid(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":getegid")) return NULL; return PyInt_FromLong((long)getegid()); } #endif #ifdef HAVE_GETEUID static char posix_geteuid__doc__[] = "geteuid() -> euid\n\ Return the current process's effective user id."; static PyObject * posix_geteuid(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":geteuid")) return NULL; return PyInt_FromLong((long)geteuid()); } #endif #ifdef HAVE_GETGID static char posix_getgid__doc__[] = "getgid() -> gid\n\ Return the current process's group id."; static PyObject * posix_getgid(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":getgid")) return NULL; return PyInt_FromLong((long)getgid()); } #endif static char posix_getpid__doc__[] = "getpid() -> pid\n\ Return the current process id"; static PyObject * posix_getpid(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":getpid")) return NULL; return PyInt_FromLong((long)getpid()); } #ifdef HAVE_GETGROUPS static char posix_getgroups__doc__[] = "\ getgroups() -> list of group IDs\n\ Return list of supplemental group IDs for the process."; static PyObject * posix_getgroups(PyObject *self, PyObject *args) { PyObject *result = NULL; if (PyArg_ParseTuple(args, ":getgroups")) { #ifdef NGROUPS_MAX #define MAX_GROUPS NGROUPS_MAX #else /* defined to be 16 on Solaris7, so this should be a small number */ #define MAX_GROUPS 64 #endif gid_t grouplist[MAX_GROUPS]; int n; n = getgroups(MAX_GROUPS, grouplist); if (n < 0) posix_error(); else { result = PyList_New(n); if (result != NULL) { PyObject *o; int i; for (i = 0; i < n; ++i) { o = PyInt_FromLong((long)grouplist[i]); if (o == NULL) { Py_DECREF(result); result = NULL; break; } PyList_SET_ITEM(result, i, o); } } } } return result; } #endif #ifdef HAVE_GETPGRP static char posix_getpgrp__doc__[] = "getpgrp() -> pgrp\n\ Return the current process group id."; static PyObject * posix_getpgrp(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":getpgrp")) return NULL; #ifdef GETPGRP_HAVE_ARG return PyInt_FromLong((long)getpgrp(0)); #else /* GETPGRP_HAVE_ARG */ return PyInt_FromLong((long)getpgrp()); #endif /* GETPGRP_HAVE_ARG */ } #endif /* HAVE_GETPGRP */ #ifdef HAVE_SETPGRP static char posix_setpgrp__doc__[] = "setpgrp() -> None\n\ Make this process a session leader."; static PyObject * posix_setpgrp(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":setpgrp")) return NULL; #ifdef SETPGRP_HAVE_ARG if (setpgrp(0, 0) < 0) #else /* SETPGRP_HAVE_ARG */ if (setpgrp() < 0) #endif /* SETPGRP_HAVE_ARG */ return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif /* HAVE_SETPGRP */ #ifdef HAVE_GETPPID static char posix_getppid__doc__[] = "getppid() -> ppid\n\ Return the parent's process id."; static PyObject * posix_getppid(self, args) PyObject *self; PyObject *args; { if (!PyArg_ParseTuple(args, ":getppid")) return NULL; return PyInt_FromLong((long)getppid()); } #endif #ifdef HAVE_GETLOGIN static char posix_getlogin__doc__[] = "\ getlogin() -> string\n\ Return the actual login name."; static PyObject * posix_getlogin(PyObject *self, PyObject *args) { PyObject *result = NULL; if (PyArg_ParseTuple(args, ":getlogin")) { char *name = getlogin(); if (name == NULL) posix_error(); else result = PyString_FromString(name); } return result; } #endif #ifdef HAVE_GETUID static char posix_getuid__doc__[] = "getuid() -> uid\n\ Return the current process's user id."; static PyObject * posix_getuid(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":getuid")) return NULL; return PyInt_FromLong((long)getuid()); } #endif #ifdef HAVE_KILL static char posix_kill__doc__[] = "kill(pid, sig) -> None\n\ Kill a process with a signal."; static PyObject * posix_kill(PyObject *self, PyObject *args) { int pid, sig; if (!PyArg_ParseTuple(args, "ii:kill", &pid, &sig)) return NULL; #if defined(PYOS_OS2) if (sig == XCPT_SIGNAL_INTR || sig == XCPT_SIGNAL_BREAK) { APIRET rc; if ((rc = DosSendSignalException(pid, sig)) != NO_ERROR) return os2_error(rc); } else if (sig == XCPT_SIGNAL_KILLPROC) { APIRET rc; if ((rc = DosKillProcess(DKP_PROCESS, pid)) != NO_ERROR) return os2_error(rc); } else return NULL; /* Unrecognized Signal Requested */ #else if (kill(pid, sig) == -1) return posix_error(); #endif Py_INCREF(Py_None); return Py_None; } #endif #ifdef HAVE_PLOCK #ifdef HAVE_SYS_LOCK_H #include #endif static char posix_plock__doc__[] = "plock(op) -> None\n\ Lock program segments into memory."; static PyObject * posix_plock(PyObject *self, PyObject *args) { int op; if (!PyArg_ParseTuple(args, "i:plock", &op)) return NULL; if (plock(op) == -1) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif #ifdef HAVE_POPEN static char posix_popen__doc__[] = "popen(command [, mode='r' [, bufsize]]) -> pipe\n\ Open a pipe to/from a command returning a file object."; #if defined(PYOS_OS2) static int async_system(const char *command) { char *p, errormsg[256], args[1024]; RESULTCODES rcodes; APIRET rc; char *shell = getenv("COMSPEC"); if (!shell) shell = "cmd"; strcpy(args, shell); p = &args[ strlen(args)+1 ]; strcpy(p, "/c "); strcat(p, command); p += strlen(p) + 1; *p = '\0'; rc = DosExecPgm(errormsg, sizeof(errormsg), EXEC_ASYNC, /* Execute Async w/o Wait for Results */ args, NULL, /* Inherit Parent's Environment */ &rcodes, shell); return rc; } static FILE * popen(const char *command, const char *mode, int pipesize, int *err) { HFILE rhan, whan; FILE *retfd = NULL; APIRET rc = DosCreatePipe(&rhan, &whan, pipesize); if (rc != NO_ERROR) { *err = rc; return NULL; /* ERROR - Unable to Create Anon Pipe */ } if (strchr(mode, 'r') != NULL) { /* Treat Command as a Data Source */ int oldfd = dup(1); /* Save STDOUT Handle in Another Handle */ DosEnterCritSec(); /* Stop Other Threads While Changing Handles */ close(1); /* Make STDOUT Available for Reallocation */ if (dup2(whan, 1) == 0) { /* Connect STDOUT to Pipe Write Side */ DosClose(whan); /* Close Now-Unused Pipe Write Handle */ if (async_system(command) == NO_ERROR) retfd = fdopen(rhan, mode); /* And Return Pipe Read Handle */ } dup2(oldfd, 1); /* Reconnect STDOUT to Original Handle */ DosExitCritSec(); /* Now Allow Other Threads to Run */ close(oldfd); /* And Close Saved STDOUT Handle */ return retfd; /* Return fd of Pipe or NULL if Error */ } else if (strchr(mode, 'w')) { /* Treat Command as a Data Sink */ int oldfd = dup(0); /* Save STDIN Handle in Another Handle */ DosEnterCritSec(); /* Stop Other Threads While Changing Handles */ close(0); /* Make STDIN Available for Reallocation */ if (dup2(rhan, 0) == 0) { /* Connect STDIN to Pipe Read Side */ DosClose(rhan); /* Close Now-Unused Pipe Read Handle */ if (async_system(command) == NO_ERROR) retfd = fdopen(whan, mode); /* And Return Pipe Write Handle */ } dup2(oldfd, 0); /* Reconnect STDIN to Original Handle */ DosExitCritSec(); /* Now Allow Other Threads to Run */ close(oldfd); /* And Close Saved STDIN Handle */ return retfd; /* Return fd of Pipe or NULL if Error */ } else { *err = ERROR_INVALID_ACCESS; return NULL; /* ERROR - Invalid Mode (Neither Read nor Write) */ } } static PyObject * posix_popen(PyObject *self, PyObject *args) { char *name; char *mode = "r"; int err, bufsize = -1; FILE *fp; PyObject *f; if (!PyArg_ParseTuple(args, "s|si:popen", &name, &mode, &bufsize)) return NULL; Py_BEGIN_ALLOW_THREADS fp = popen(name, mode, (bufsize > 0) ? bufsize : 4096, &err); Py_END_ALLOW_THREADS if (fp == NULL) return os2_error(err); f = PyFile_FromFile(fp, name, mode, fclose); if (f != NULL) PyFile_SetBufSize(f, bufsize); return f; } #elif defined(MS_WIN32) /* * Portable 'popen' replacement for Win32. * * Written by Bill Tutt . Minor tweaks * and 2.0 integration by Fredrik Lundh */ #include #include #include /* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */ #define POPEN_1 1 #define POPEN_2 2 #define POPEN_3 3 #define POPEN_4 4 static PyObject *_PyPopen(char *, int, int); /* popen that works from a GUI. * * The result of this function is a pipe (file) connected to the * processes stdin or stdout, depending on the requested mode. */ static PyObject * posix_popen(PyObject *self, PyObject *args) { int bufsize = -1; PyObject *f, *s; int tm = 0; char *cmdstring; char *mode = "r"; if (!PyArg_ParseTuple(args, "s|s:popen", &cmdstring, &mode)) return NULL; s = PyTuple_New(0); if (*mode == 'r') tm = _O_RDONLY; else if (*mode != 'w') { PyErr_SetString(PyExc_ValueError, "mode must be 'r' or 'w'"); return NULL; } else tm = _O_WRONLY; if (*(mode+1) == 't') f = _PyPopen(cmdstring, tm | _O_TEXT , POPEN_1); else if (*(mode+1) == 'b') f = _PyPopen(cmdstring, tm | _O_BINARY , POPEN_1); else f = _PyPopen(cmdstring, tm | _O_TEXT, POPEN_1); return f; } /* Variation on win32pipe.popen * * The result of this function is a pipe (file) connected to the * process's stdin, and a pipe connected to the process's stdout. */ static PyObject * win32_popen2(PyObject *self, PyObject *args) { PyObject *f; int tm=0; char *cmdstring; char *mode = "t"; if (!PyArg_ParseTuple(args, "s|s:popen2", &cmdstring, &mode)) return NULL; if (*mode == 't') tm = _O_TEXT; else if (*mode != 'b') { PyErr_SetString(PyExc_ValueError, "mode must be 't' or 'b'"); return NULL; } else tm = _O_BINARY; f = _PyPopen(cmdstring, tm , POPEN_2); return f; } /* * Variation on * The result of this function is 3 pipes - the process's stdin, * stdout and stderr * */ static PyObject * win32_popen3(PyObject *self, PyObject *args) { PyObject *f; int tm = 0; char *cmdstring; char *mode = "t"; if (!PyArg_ParseTuple(args, "s|s:Popen3", &cmdstring, &mode)) return NULL; if (*mode == 't') tm = _O_TEXT; else if (*mode != 'b') { PyErr_SetString(PyExc_ValueError, "mode must be 't' or 'b'"); return NULL; } else tm = _O_BINARY; f = _PyPopen(cmdstring, tm, POPEN_3); return f; } /* * Variation on win32pipe.popen * * The result of this function is 2 pipes - the processes stdin, * and stdout+stderr combined as a single pipe. */ static PyObject * win32_popen4(PyObject *self, PyObject *args) { PyObject *f; int tm = 0; char *cmdstring; char *mode = "t"; if (!PyArg_ParseTuple(args, "s|s:popen4", &cmdstring, &mode)) return NULL; if (*mode == 't') tm = _O_TEXT; else if (*mode != 'b') { PyErr_SetString(PyExc_ValueError, "mode must be 't' or 'b'"); return NULL; } else tm = _O_BINARY; f = _PyPopen(cmdstring, tm , POPEN_4); return f; } static int _PyPopenCreateProcess(char *cmdstring, HANDLE hStdin, HANDLE hStdout, HANDLE hStderr) { PROCESS_INFORMATION piProcInfo; STARTUPINFO siStartInfo; char *s1,*s2, *s3 = " /c "; const char *szConsoleSpawn = "w9xpopen.exe \""; int i; int x; if (i = GetEnvironmentVariable("COMSPEC",NULL,0)) { s1 = (char *)_alloca(i); if (!(x = GetEnvironmentVariable("COMSPEC", s1, i))) return x; if (GetVersion() < 0x80000000) { /* * NT/2000 */ x = i + strlen(s3) + strlen(cmdstring) + 1; s2 = (char *)_alloca(x); ZeroMemory(s2, x); sprintf(s2, "%s%s%s", s1, s3, cmdstring); } else { /* * Oh gag, we're on Win9x. Use the workaround listed in * KB: Q150956 */ char modulepath[256]; GetModuleFileName(NULL, modulepath, sizeof(modulepath)); for (i = x = 0; modulepath[i]; i++) if (modulepath[i] == '\\') x = i+1; modulepath[x] = '\0'; x = i + strlen(s3) + strlen(cmdstring) + 1 + strlen(modulepath) + strlen(szConsoleSpawn) + 1; s2 = (char *)_alloca(x); ZeroMemory(s2, x); sprintf( s2, "%s%s%s%s%s\"", modulepath, szConsoleSpawn, s1, s3, cmdstring); } } /* Could be an else here to try cmd.exe / command.com in the path Now we'll just error out.. */ else return -1; ZeroMemory(&siStartInfo, sizeof(STARTUPINFO)); siStartInfo.cb = sizeof(STARTUPINFO); siStartInfo.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW; siStartInfo.hStdInput = hStdin; siStartInfo.hStdOutput = hStdout; siStartInfo.hStdError = hStderr; siStartInfo.wShowWindow = SW_HIDE; if (CreateProcess(NULL, s2, NULL, NULL, TRUE, CREATE_NEW_CONSOLE, NULL, NULL, &siStartInfo, &piProcInfo) ) { /* Close the handles now so anyone waiting is woken. */ CloseHandle(piProcInfo.hProcess); CloseHandle(piProcInfo.hThread); return TRUE; } return FALSE; } /* The following code is based off of KB: Q190351 */ static PyObject * _PyPopen(char *cmdstring, int mode, int n) { HANDLE hChildStdinRd, hChildStdinWr, hChildStdoutRd, hChildStdoutWr, hChildStderrRd, hChildStderrWr, hChildStdinWrDup, hChildStdoutRdDup, hChildStderrRdDup; /* hChildStdoutWrDup; */ SECURITY_ATTRIBUTES saAttr; BOOL fSuccess; int fd1, fd2, fd3; FILE *f1, *f2, *f3; PyObject *f; saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) return win32_error("CreatePipe", NULL); /* Create new output read handle and the input write handle. Set * the inheritance properties to FALSE. Otherwise, the child inherits * the these handles; resulting in non-closeable handles to the pipes * being created. */ fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr, GetCurrentProcess(), &hChildStdinWrDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) return win32_error("DuplicateHandle", NULL); /* Close the inheritable version of ChildStdin that we're using. */ CloseHandle(hChildStdinWr); if (!CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) return win32_error("CreatePipe", NULL); fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd, GetCurrentProcess(), &hChildStdoutRdDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) return win32_error("DuplicateHandle", NULL); /* Close the inheritable version of ChildStdout that we're using. */ CloseHandle(hChildStdoutRd); if (n != POPEN_4) { if (!CreatePipe(&hChildStderrRd, &hChildStderrWr, &saAttr, 0)) return win32_error("CreatePipe", NULL); fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStderrRd, GetCurrentProcess(), &hChildStderrRdDup, 0, FALSE, DUPLICATE_SAME_ACCESS); if (!fSuccess) return win32_error("DuplicateHandle", NULL); /* Close the inheritable version of ChildStdErr that we're using. */ CloseHandle(hChildStderrRd); } switch (n) { case POPEN_1: switch (mode & (_O_RDONLY | _O_TEXT | _O_BINARY | _O_WRONLY)) { case _O_WRONLY | _O_TEXT: /* Case for writing to child Stdin in text mode. */ fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); f1 = _fdopen(fd1, "w"); f = PyFile_FromFile(f1, cmdstring, "w", fclose); PyFile_SetBufSize(f, 0); /* We don't care about these pipes anymore, so close them. */ CloseHandle(hChildStdoutRdDup); CloseHandle(hChildStderrRdDup); break; case _O_RDONLY | _O_TEXT: /* Case for reading from child Stdout in text mode. */ fd1 = _open_osfhandle((long)hChildStdoutRdDup, mode); f1 = _fdopen(fd1, "r"); f = PyFile_FromFile(f1, cmdstring, "r", fclose); PyFile_SetBufSize(f, 0); /* We don't care about these pipes anymore, so close them. */ CloseHandle(hChildStdinWrDup); CloseHandle(hChildStderrRdDup); break; case _O_RDONLY | _O_BINARY: /* Case for readinig from child Stdout in binary mode. */ fd1 = _open_osfhandle((long)hChildStdoutRdDup, mode); f1 = _fdopen(fd1, "rb"); f = PyFile_FromFile(f1, cmdstring, "rb", fclose); PyFile_SetBufSize(f, 0); /* We don't care about these pipes anymore, so close them. */ CloseHandle(hChildStdinWrDup); CloseHandle(hChildStderrRdDup); break; case _O_WRONLY | _O_BINARY: /* Case for writing to child Stdin in binary mode. */ fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); f1 = _fdopen(fd1, "wb"); f = PyFile_FromFile(f1, cmdstring, "wb", fclose); PyFile_SetBufSize(f, 0); /* We don't care about these pipes anymore, so close them. */ CloseHandle(hChildStdoutRdDup); CloseHandle(hChildStderrRdDup); break; } break; case POPEN_2: case POPEN_4: { char *m1, *m2; PyObject *p1, *p2; if (mode && _O_TEXT) { m1 = "r"; m2 = "w"; } else { m1 = "rb"; m2 = "wb"; } fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); f1 = _fdopen(fd1, m2); fd2 = _open_osfhandle((long)hChildStdoutRdDup, mode); f2 = _fdopen(fd2, m1); p1 = PyFile_FromFile(f1, cmdstring, m2, fclose); PyFile_SetBufSize(p1, 0); p2 = PyFile_FromFile(f2, cmdstring, m1, fclose); PyFile_SetBufSize(p2, 0); if (n != 4) CloseHandle(hChildStderrRdDup); f = Py_BuildValue("OO",p1,p2); break; } case POPEN_3: { char *m1, *m2; PyObject *p1, *p2, *p3; if (mode && _O_TEXT) { m1 = "r"; m2 = "w"; } else { m1 = "rb"; m2 = "wb"; } fd1 = _open_osfhandle((long)hChildStdinWrDup, mode); f1 = _fdopen(fd1, m2); fd2 = _open_osfhandle((long)hChildStdoutRdDup, mode); f2 = _fdopen(fd2, m1); fd3 = _open_osfhandle((long)hChildStderrRdDup, mode); f3 = _fdopen(fd3, m1); p1 = PyFile_FromFile(f1, cmdstring, m2, fclose); p2 = PyFile_FromFile(f2, cmdstring, m1, fclose); p3 = PyFile_FromFile(f3, cmdstring, m1, fclose); PyFile_SetBufSize(p1, 0); PyFile_SetBufSize(p2, 0); PyFile_SetBufSize(p3, 0); f = Py_BuildValue("OOO",p1,p2,p3); break; } } if (n == POPEN_4) { if (!_PyPopenCreateProcess(cmdstring, hChildStdinRd, hChildStdoutWr, hChildStdoutWr)) return win32_error("CreateProcess", NULL); } else { if (!_PyPopenCreateProcess(cmdstring, hChildStdinRd, hChildStdoutWr, hChildStderrWr)) return win32_error("CreateProcess", NULL); } /* Child is launched. Close the parents copy of those pipe * handles that only the child should have open. You need to * make sure that no handles to the write end of the output pipe * are maintained in this process or else the pipe will not close * when the child process exits and the ReadFile will hang. */ if (!CloseHandle(hChildStdinRd)) return win32_error("CloseHandle", NULL); if (!CloseHandle(hChildStdoutWr)) return win32_error("CloseHandle", NULL); if ((n != 4) && (!CloseHandle(hChildStderrWr))) return win32_error("CloseHandle", NULL); return f; } #else static PyObject * posix_popen(PyObject *self, PyObject *args) { char *name; char *mode = "r"; int bufsize = -1; FILE *fp; PyObject *f; if (!PyArg_ParseTuple(args, "s|si:popen", &name, &mode, &bufsize)) return NULL; Py_BEGIN_ALLOW_THREADS fp = popen(name, mode); Py_END_ALLOW_THREADS if (fp == NULL) return posix_error(); f = PyFile_FromFile(fp, name, mode, pclose); if (f != NULL) PyFile_SetBufSize(f, bufsize); return f; } #endif #endif /* HAVE_POPEN */ #ifdef HAVE_SETUID static char posix_setuid__doc__[] = "setuid(uid) -> None\n\ Set the current process's user id."; static PyObject * posix_setuid(PyObject *self, PyObject *args) { int uid; if (!PyArg_ParseTuple(args, "i:setuid", &uid)) return NULL; if (setuid(uid) < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif /* HAVE_SETUID */ #ifdef HAVE_SETGID static char posix_setgid__doc__[] = "setgid(gid) -> None\n\ Set the current process's group id."; static PyObject * posix_setgid(PyObject *self, PyObject *args) { int gid; if (!PyArg_ParseTuple(args, "i:setgid", &gid)) return NULL; if (setgid(gid) < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif /* HAVE_SETGID */ #ifdef HAVE_WAITPID static char posix_waitpid__doc__[] = "waitpid(pid, options) -> (pid, status)\n\ Wait for completion of a give child process."; static PyObject * posix_waitpid(PyObject *self, PyObject *args) { int pid, options; #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "ii:waitpid", &pid, &options)) return NULL; Py_BEGIN_ALLOW_THREADS #ifdef NeXT pid = wait4(pid, &status, options, NULL); #else pid = waitpid(pid, &status, options); #endif Py_END_ALLOW_THREADS if (pid == -1) return posix_error(); else return Py_BuildValue("ii", pid, status_i); } #endif /* HAVE_WAITPID */ #ifdef HAVE_WAIT static char posix_wait__doc__[] = "wait() -> (pid, status)\n\ Wait for completion of a child process."; static PyObject * posix_wait(PyObject *self, PyObject *args) { int pid; #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif if (!PyArg_ParseTuple(args, ":wait")) return NULL; status_i = 0; Py_BEGIN_ALLOW_THREADS pid = wait(&status); Py_END_ALLOW_THREADS if (pid == -1) return posix_error(); else return Py_BuildValue("ii", pid, status_i); #undef status_i } #endif static char posix_lstat__doc__[] = "lstat(path) -> (mode,ino,dev,nlink,uid,gid,size,atime,mtime,ctime)\n\ Like stat(path), but do not follow symbolic links."; static PyObject * posix_lstat(PyObject *self, PyObject *args) { #ifdef HAVE_LSTAT return posix_do_stat(self, args, "s:lstat", lstat); #else /* !HAVE_LSTAT */ return posix_do_stat(self, args, "s:lstat", STAT); #endif /* !HAVE_LSTAT */ } #ifdef HAVE_READLINK static char posix_readlink__doc__[] = "readlink(path) -> path\n\ Return a string representing the path to which the symbolic link points."; static PyObject * posix_readlink(PyObject *self, PyObject *args) { char buf[MAXPATHLEN]; char *path; int n; if (!PyArg_ParseTuple(args, "s:readlink", &path)) return NULL; Py_BEGIN_ALLOW_THREADS n = readlink(path, buf, (int) sizeof buf); Py_END_ALLOW_THREADS if (n < 0) return posix_error_with_filename(path); return PyString_FromStringAndSize(buf, n); } #endif /* HAVE_READLINK */ #ifdef HAVE_SYMLINK static char posix_symlink__doc__[] = "symlink(src, dst) -> None\n\ Create a symbolic link."; static PyObject * posix_symlink(PyObject *self, PyObject *args) { return posix_2str(args, "ss:symlink", symlink); } #endif /* HAVE_SYMLINK */ #ifdef HAVE_TIMES #ifndef HZ #define HZ 60 /* Universal constant :-) */ #endif /* HZ */ #if defined(PYCC_VACPP) && defined(PYOS_OS2) static long system_uptime() { ULONG value = 0; Py_BEGIN_ALLOW_THREADS DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &value, sizeof(value)); Py_END_ALLOW_THREADS return value; } static PyObject * posix_times(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":times")) return NULL; /* Currently Only Uptime is Provided -- Others Later */ return Py_BuildValue("ddddd", (double)0 /* t.tms_utime / HZ */, (double)0 /* t.tms_stime / HZ */, (double)0 /* t.tms_cutime / HZ */, (double)0 /* t.tms_cstime / HZ */, (double)system_uptime() / 1000); } #else /* not OS2 */ static PyObject * posix_times(PyObject *self, PyObject *args) { struct tms t; clock_t c; if (!PyArg_ParseTuple(args, ":times")) return NULL; errno = 0; c = times(&t); if (c == (clock_t) -1) return posix_error(); return Py_BuildValue("ddddd", (double)t.tms_utime / HZ, (double)t.tms_stime / HZ, (double)t.tms_cutime / HZ, (double)t.tms_cstime / HZ, (double)c / HZ); } #endif /* not OS2 */ #endif /* HAVE_TIMES */ #ifdef MS_WIN32 #define HAVE_TIMES /* so the method table will pick it up */ static PyObject * posix_times(PyObject *self, PyObject *args) { FILETIME create, exit, kernel, user; HANDLE hProc; if (!PyArg_ParseTuple(args, ":times")) return NULL; hProc = GetCurrentProcess(); GetProcessTimes(hProc, &create, &exit, &kernel, &user); /* The fields of a FILETIME structure are the hi and lo part of a 64-bit value expressed in 100 nanosecond units. 1e7 is one second in such units; 1e-7 the inverse. 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7. */ return Py_BuildValue( "ddddd", (double)(kernel.dwHighDateTime*429.4967296 + kernel.dwLowDateTime*1e-7), (double)(user.dwHighDateTime*429.4967296 + user.dwLowDateTime*1e-7), (double)0, (double)0, (double)0); } #endif /* MS_WIN32 */ #ifdef HAVE_TIMES static char posix_times__doc__[] = "times() -> (utime, stime, cutime, cstime, elapsed_time)\n\ Return a tuple of floating point numbers indicating process times."; #endif #ifdef HAVE_SETSID static char posix_setsid__doc__[] = "setsid() -> None\n\ Call the system call setsid()."; static PyObject * posix_setsid(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":setsid")) return NULL; if (setsid() < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif /* HAVE_SETSID */ #ifdef HAVE_SETPGID static char posix_setpgid__doc__[] = "setpgid(pid, pgrp) -> None\n\ Call the system call setpgid()."; static PyObject * posix_setpgid(PyObject *self, PyObject *args) { int pid, pgrp; if (!PyArg_ParseTuple(args, "ii:setpgid", &pid, &pgrp)) return NULL; if (setpgid(pid, pgrp) < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif /* HAVE_SETPGID */ #ifdef HAVE_TCGETPGRP static char posix_tcgetpgrp__doc__[] = "tcgetpgrp(fd) -> pgid\n\ Return the process group associated with the terminal given by a fd."; static PyObject * posix_tcgetpgrp(PyObject *self, PyObject *args) { int fd, pgid; if (!PyArg_ParseTuple(args, "i:tcgetpgrp", &fd)) return NULL; pgid = tcgetpgrp(fd); if (pgid < 0) return posix_error(); return PyInt_FromLong((long)pgid); } #endif /* HAVE_TCGETPGRP */ #ifdef HAVE_TCSETPGRP static char posix_tcsetpgrp__doc__[] = "tcsetpgrp(fd, pgid) -> None\n\ Set the process group associated with the terminal given by a fd."; static PyObject * posix_tcsetpgrp(PyObject *self, PyObject *args) { int fd, pgid; if (!PyArg_ParseTuple(args, "ii:tcsetpgrp", &fd, &pgid)) return NULL; if (tcsetpgrp(fd, pgid) < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif /* HAVE_TCSETPGRP */ /* Functions acting on file descriptors */ static char posix_open__doc__[] = "open(filename, flag [, mode=0777]) -> fd\n\ Open a file (for low level IO)."; static PyObject * posix_open(PyObject *self, PyObject *args) { char *file; int flag; int mode = 0777; int fd; if (!PyArg_ParseTuple(args, "si|i", &file, &flag, &mode)) return NULL; Py_BEGIN_ALLOW_THREADS fd = open(file, flag, mode); Py_END_ALLOW_THREADS if (fd < 0) return posix_error_with_filename(file); return PyInt_FromLong((long)fd); } static char posix_close__doc__[] = "close(fd) -> None\n\ Close a file descriptor (for low level IO)."; static PyObject * posix_close(PyObject *self, PyObject *args) { int fd, res; if (!PyArg_ParseTuple(args, "i:close", &fd)) return NULL; Py_BEGIN_ALLOW_THREADS res = close(fd); Py_END_ALLOW_THREADS if (res < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } static char posix_dup__doc__[] = "dup(fd) -> fd2\n\ Return a duplicate of a file descriptor."; static PyObject * posix_dup(PyObject *self, PyObject *args) { int fd; if (!PyArg_ParseTuple(args, "i:dup", &fd)) return NULL; Py_BEGIN_ALLOW_THREADS fd = dup(fd); Py_END_ALLOW_THREADS if (fd < 0) return posix_error(); return PyInt_FromLong((long)fd); } static char posix_dup2__doc__[] = "dup2(fd, fd2) -> None\n\ Duplicate file descriptor."; static PyObject * posix_dup2(PyObject *self, PyObject *args) { int fd, fd2, res; if (!PyArg_ParseTuple(args, "ii:dup2", &fd, &fd2)) return NULL; Py_BEGIN_ALLOW_THREADS res = dup2(fd, fd2); Py_END_ALLOW_THREADS if (res < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } static char posix_lseek__doc__[] = "lseek(fd, pos, how) -> newpos\n\ Set the current position of a file descriptor."; static PyObject * posix_lseek(PyObject *self, PyObject *args) { int fd, how; #ifdef MS_WIN64 LONG_LONG pos, res; #else off_t pos, res; #endif PyObject *posobj; if (!PyArg_ParseTuple(args, "iOi:lseek", &fd, &posobj, &how)) return NULL; #ifdef SEEK_SET /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */ switch (how) { case 0: how = SEEK_SET; break; case 1: how = SEEK_CUR; break; case 2: how = SEEK_END; break; } #endif /* SEEK_END */ #if !defined(HAVE_LARGEFILE_SUPPORT) pos = PyInt_AsLong(posobj); #else pos = PyLong_Check(posobj) ? PyLong_AsLongLong(posobj) : PyInt_AsLong(posobj); #endif if (PyErr_Occurred()) return NULL; Py_BEGIN_ALLOW_THREADS #ifdef MS_WIN64 res = _lseeki64(fd, pos, how); #else res = lseek(fd, pos, how); #endif Py_END_ALLOW_THREADS if (res < 0) return posix_error(); #if !defined(HAVE_LARGEFILE_SUPPORT) return PyInt_FromLong(res); #else return PyLong_FromLongLong(res); #endif } static char posix_read__doc__[] = "read(fd, buffersize) -> string\n\ Read a file descriptor."; static PyObject * posix_read(PyObject *self, PyObject *args) { int fd, size, n; PyObject *buffer; if (!PyArg_ParseTuple(args, "ii:read", &fd, &size)) return NULL; buffer = PyString_FromStringAndSize((char *)NULL, size); if (buffer == NULL) return NULL; Py_BEGIN_ALLOW_THREADS n = read(fd, PyString_AsString(buffer), size); Py_END_ALLOW_THREADS if (n < 0) { Py_DECREF(buffer); return posix_error(); } if (n != size) _PyString_Resize(&buffer, n); return buffer; } static char posix_write__doc__[] = "write(fd, string) -> byteswritten\n\ Write a string to a file descriptor."; static PyObject * posix_write(PyObject *self, PyObject *args) { int fd, size; char *buffer; if (!PyArg_ParseTuple(args, "is#:write", &fd, &buffer, &size)) return NULL; Py_BEGIN_ALLOW_THREADS size = write(fd, buffer, size); Py_END_ALLOW_THREADS if (size < 0) return posix_error(); return PyInt_FromLong((long)size); } static char posix_fstat__doc__[]= "fstat(fd) -> (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n\ Like stat(), but for an open file descriptor."; static PyObject * posix_fstat(PyObject *self, PyObject *args) { int fd; STRUCT_STAT st; int res; if (!PyArg_ParseTuple(args, "i:fstat", &fd)) return NULL; Py_BEGIN_ALLOW_THREADS res = FSTAT(fd, &st); Py_END_ALLOW_THREADS if (res != 0) return posix_error(); return _pystat_fromstructstat(st); } static char posix_fdopen__doc__[] = "fdopen(fd, [, mode='r' [, bufsize]]) -> file_object\n\ Return an open file object connected to a file descriptor."; static PyObject * posix_fdopen(PyObject *self, PyObject *args) { extern int fclose(FILE *); int fd; char *mode = "r"; int bufsize = -1; FILE *fp; PyObject *f; if (!PyArg_ParseTuple(args, "i|si", &fd, &mode, &bufsize)) return NULL; Py_BEGIN_ALLOW_THREADS fp = fdopen(fd, mode); Py_END_ALLOW_THREADS if (fp == NULL) return posix_error(); f = PyFile_FromFile(fp, "(fdopen)", mode, fclose); if (f != NULL) PyFile_SetBufSize(f, bufsize); return f; } #ifdef HAVE_PIPE static char posix_pipe__doc__[] = "pipe() -> (read_end, write_end)\n\ Create a pipe."; static PyObject * posix_pipe(PyObject *self, PyObject *args) { #if defined(PYOS_OS2) HFILE read, write; APIRET rc; if (!PyArg_ParseTuple(args, ":pipe")) return NULL; Py_BEGIN_ALLOW_THREADS rc = DosCreatePipe( &read, &write, 4096); Py_END_ALLOW_THREADS if (rc != NO_ERROR) return os2_error(rc); return Py_BuildValue("(ii)", read, write); #else #if !defined(MS_WIN32) int fds[2]; int res; if (!PyArg_ParseTuple(args, ":pipe")) return NULL; Py_BEGIN_ALLOW_THREADS res = pipe(fds); Py_END_ALLOW_THREADS if (res != 0) return posix_error(); return Py_BuildValue("(ii)", fds[0], fds[1]); #else /* MS_WIN32 */ HANDLE read, write; int read_fd, write_fd; BOOL ok; if (!PyArg_ParseTuple(args, ":pipe")) return NULL; Py_BEGIN_ALLOW_THREADS ok = CreatePipe(&read, &write, NULL, 0); Py_END_ALLOW_THREADS if (!ok) return win32_error("CreatePipe", NULL); read_fd = _open_osfhandle((intptr_t)read, 0); write_fd = _open_osfhandle((intptr_t)write, 1); return Py_BuildValue("(ii)", read_fd, write_fd); #endif /* MS_WIN32 */ #endif } #endif /* HAVE_PIPE */ #ifdef HAVE_MKFIFO static char posix_mkfifo__doc__[] = "mkfifo(file, [, mode=0666]) -> None\n\ Create a FIFO (a POSIX named pipe)."; static PyObject * posix_mkfifo(PyObject *self, PyObject *args) { char *file; int mode = 0666; int res; if (!PyArg_ParseTuple(args, "s|i:mkfifo", &file, &mode)) return NULL; Py_BEGIN_ALLOW_THREADS res = mkfifo(file, mode); Py_END_ALLOW_THREADS if (res < 0) return posix_error(); Py_INCREF(Py_None); return Py_None; } #endif #ifdef HAVE_FTRUNCATE static char posix_ftruncate__doc__[] = "ftruncate(fd, length) -> None\n\ Truncate a file to a specified length."; static PyObject * posix_ftruncate(PyObject *self, PyObject *args) { int fd; off_t length; int res; PyObject *lenobj; if (!PyArg_ParseTuple(args, "iO:ftruncate", &fd, &lenobj)) return NULL; #if !defined(HAVE_LARGEFILE_SUPPORT) length = PyInt_AsLong(lenobj); #else length = PyLong_Check(lenobj) ? PyLong_AsLongLong(lenobj) : PyInt_AsLong(lenobj); #endif if (PyErr_Occurred()) return NULL; Py_BEGIN_ALLOW_THREADS res = ftruncate(fd, length); Py_END_ALLOW_THREADS if (res < 0) { PyErr_SetFromErrno(PyExc_IOError); return NULL; } Py_INCREF(Py_None); return Py_None; } #endif #ifdef NeXT #define HAVE_PUTENV /* Steve Spicklemire got this putenv from NeXTAnswers */ static int putenv(char *newval) { extern char **environ; static int firstTime = 1; char **ep; char *cp; int esiz; char *np; if (!(np = strchr(newval, '='))) return 1; *np = '\0'; /* look it up */ for (ep=environ ; *ep ; ep++) { /* this should always be true... */ if (cp = strchr(*ep, '=')) { *cp = '\0'; if (!strcmp(*ep, newval)) { /* got it! */ *cp = '='; break; } *cp = '='; } else { *np = '='; return 1; } } *np = '='; if (*ep) { /* the string was already there: just replace it with the new one */ *ep = newval; return 0; } /* expand environ by one */ for (esiz=2, ep=environ ; *ep ; ep++) esiz++; if (firstTime) { char **epp; char **newenv; if (!(newenv = malloc(esiz * sizeof(char *)))) return 1; for (ep=environ, epp=newenv ; *ep ;) *epp++ = *ep++; *epp++ = newval; *epp = (char *) 0; environ = newenv; } else { if (!(environ = realloc(environ, esiz * sizeof(char *)))) return 1; environ[esiz - 2] = newval; environ[esiz - 1] = (char *) 0; firstTime = 0; } return 0; } #endif /* NeXT */ #ifdef HAVE_PUTENV static char posix_putenv__doc__[] = "putenv(key, value) -> None\n\ Change or add an environment variable."; #ifdef __BEOS__ /* We have putenv(), but not in the headers (as of PR2). - [cjh] */ int putenv( const char *str ); #endif /* Save putenv() parameters as values here, so we can collect them when they * get re-set with another call for the same key. */ static PyObject *posix_putenv_garbage; static PyObject * posix_putenv(PyObject *self, PyObject *args) { char *s1, *s2; char *new; PyObject *newstr; if (!PyArg_ParseTuple(args, "ss:putenv", &s1, &s2)) return NULL; #if defined(PYOS_OS2) if (stricmp(s1, "BEGINLIBPATH") == 0) { APIRET rc; if (strlen(s2) == 0) /* If New Value is an Empty String */ s2 = NULL; /* Then OS/2 API Wants a NULL to Undefine It */ rc = DosSetExtLIBPATH(s2, BEGIN_LIBPATH); if (rc != NO_ERROR) return os2_error(rc); } else if (stricmp(s1, "ENDLIBPATH") == 0) { APIRET rc; if (strlen(s2) == 0) /* If New Value is an Empty String */ s2 = NULL; /* Then OS/2 API Wants a NULL to Undefine It */ rc = DosSetExtLIBPATH(s2, END_LIBPATH); if (rc != NO_ERROR) return os2_error(rc); } else { #endif /* XXX This can leak memory -- not easy to fix :-( */ newstr = PyString_FromStringAndSize(NULL, strlen(s1) + strlen(s2) + 2); if (newstr == NULL) return PyErr_NoMemory(); new = PyString_AS_STRING(newstr); (void) sprintf(new, "%s=%s", s1, s2); if (putenv(new)) { posix_error(); return NULL; } /* Install the first arg and newstr in posix_putenv_garbage; * this will cause previous value to be collected. This has to * happen after the real putenv() call because the old value * was still accessible until then. */ if (PyDict_SetItem(posix_putenv_garbage, PyTuple_GET_ITEM(args, 0), newstr)) { /* really not much we can do; just leak */ PyErr_Clear(); } else { Py_DECREF(newstr); } #if defined(PYOS_OS2) } #endif Py_INCREF(Py_None); return Py_None; } #endif /* putenv */ #ifdef HAVE_STRERROR static char posix_strerror__doc__[] = "strerror(code) -> string\n\ Translate an error code to a message string."; PyObject * posix_strerror(PyObject *self, PyObject *args) { int code; char *message; if (!PyArg_ParseTuple(args, "i:strerror", &code)) return NULL; message = strerror(code); if (message == NULL) { PyErr_SetString(PyExc_ValueError, "strerror code out of range"); return NULL; } return PyString_FromString(message); } #endif /* strerror */ #ifdef HAVE_SYS_WAIT_H #ifdef WIFSTOPPED static char posix_WIFSTOPPED__doc__[] = "WIFSTOPPED(status) -> Boolean\n\ Return true if the process returning 'status' was stopped."; static PyObject * posix_WIFSTOPPED(PyObject *self, PyObject *args) { #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "i:WIFSTOPPED", &status_i)) { return NULL; } return Py_BuildValue("i", WIFSTOPPED(status)); #undef status_i } #endif /* WIFSTOPPED */ #ifdef WIFSIGNALED static char posix_WIFSIGNALED__doc__[] = "WIFSIGNALED(status) -> Boolean\n\ Return true if the process returning 'status' was terminated by a signal."; static PyObject * posix_WIFSIGNALED(PyObject *self, PyObject *args) { #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "i:WIFSIGNALED", &status_i)) { return NULL; } return Py_BuildValue("i", WIFSIGNALED(status)); #undef status_i } #endif /* WIFSIGNALED */ #ifdef WIFEXITED static char posix_WIFEXITED__doc__[] = "WIFEXITED(status) -> Boolean\n\ Return true if the process returning 'status' exited using the exit()\n\ system call."; static PyObject * posix_WIFEXITED(PyObject *self, PyObject *args) { #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "i:WIFEXITED", &status_i)) { return NULL; } return Py_BuildValue("i", WIFEXITED(status)); #undef status_i } #endif /* WIFEXITED */ #ifdef WEXITSTATUS static char posix_WEXITSTATUS__doc__[] = "WEXITSTATUS(status) -> integer\n\ Return the process return code from 'status'."; static PyObject * posix_WEXITSTATUS(PyObject *self, PyObject *args) { #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "i:WEXITSTATUS", &status_i)) { return NULL; } return Py_BuildValue("i", WEXITSTATUS(status)); #undef status_i } #endif /* WEXITSTATUS */ #ifdef WTERMSIG static char posix_WTERMSIG__doc__[] = "WTERMSIG(status) -> integer\n\ Return the signal that terminated the process that provided the 'status'\n\ value."; static PyObject * posix_WTERMSIG(PyObject *self, PyObject *args) { #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "i:WTERMSIG", &status_i)) { return NULL; } return Py_BuildValue("i", WTERMSIG(status)); #undef status_i } #endif /* WTERMSIG */ #ifdef WSTOPSIG static char posix_WSTOPSIG__doc__[] = "WSTOPSIG(status) -> integer\n\ Return the signal that stopped the process that provided the 'status' value."; static PyObject * posix_WSTOPSIG(PyObject *self, PyObject *args) { #ifdef UNION_WAIT union wait status; #define status_i (status.w_status) #else int status; #define status_i status #endif status_i = 0; if (!PyArg_ParseTuple(args, "i:WSTOPSIG", &status_i)) { return NULL; } return Py_BuildValue("i", WSTOPSIG(status)); #undef status_i } #endif /* WSTOPSIG */ #endif /* HAVE_SYS_WAIT_H */ #if defined(HAVE_FSTATVFS) #ifdef _SCO_DS /* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the needed definitions in sys/statvfs.h */ #define _SVID3 #endif #include static char posix_fstatvfs__doc__[] = "fstatvfs(fd) -> \n\ (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax)\n\ Perform an fstatvfs system call on the given fd."; static PyObject * posix_fstatvfs(PyObject *self, PyObject *args) { int fd, res; struct statvfs st; if (!PyArg_ParseTuple(args, "i:fstatvfs", &fd)) return NULL; Py_BEGIN_ALLOW_THREADS res = fstatvfs(fd, &st); Py_END_ALLOW_THREADS if (res != 0) return posix_error(); #if !defined(HAVE_LARGEFILE_SUPPORT) return Py_BuildValue("(llllllllll)", (long) st.f_bsize, (long) st.f_frsize, (long) st.f_blocks, (long) st.f_bfree, (long) st.f_bavail, (long) st.f_files, (long) st.f_ffree, (long) st.f_favail, (long) st.f_flag, (long) st.f_namemax); #else return Py_BuildValue("(llLLLLLLll)", (long) st.f_bsize, (long) st.f_frsize, (LONG_LONG) st.f_blocks, (LONG_LONG) st.f_bfree, (LONG_LONG) st.f_bavail, (LONG_LONG) st.f_files, (LONG_LONG) st.f_ffree, (LONG_LONG) st.f_favail, (long) st.f_flag, (long) st.f_namemax); #endif } #endif /* HAVE_FSTATVFS */ #if defined(HAVE_STATVFS) #include static char posix_statvfs__doc__[] = "statvfs(path) -> \n\ (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax)\n\ Perform a statvfs system call on the given path."; static PyObject * posix_statvfs(PyObject *self, PyObject *args) { char *path; int res; struct statvfs st; if (!PyArg_ParseTuple(args, "s:statvfs", &path)) return NULL; Py_BEGIN_ALLOW_THREADS res = statvfs(path, &st); Py_END_ALLOW_THREADS if (res != 0) return posix_error_with_filename(path); #if !defined(HAVE_LARGEFILE_SUPPORT) return Py_BuildValue("(llllllllll)", (long) st.f_bsize, (long) st.f_frsize, (long) st.f_blocks, (long) st.f_bfree, (long) st.f_bavail, (long) st.f_files, (long) st.f_ffree, (long) st.f_favail, (long) st.f_flag, (long) st.f_namemax); #else /* HAVE_LARGEFILE_SUPPORT */ return Py_BuildValue("(llLLLLLLll)", (long) st.f_bsize, (long) st.f_frsize, (LONG_LONG) st.f_blocks, (LONG_LONG) st.f_bfree, (LONG_LONG) st.f_bavail, (LONG_LONG) st.f_files, (LONG_LONG) st.f_ffree, (LONG_LONG) st.f_favail, (long) st.f_flag, (long) st.f_namemax); #endif } #endif /* HAVE_STATVFS */ #ifdef HAVE_TEMPNAM static char posix_tempnam__doc__[] = "\ tempnam([dir[, prefix]]) -> string\n\ Return a unique name for a temporary file.\n\ The directory and a short may be specified as strings; they may be omitted\n\ or None if not needed."; static PyObject * posix_tempnam(PyObject *self, PyObject *args) { PyObject *result = NULL; char *dir = NULL; char *pfx = NULL; char *name; if (!PyArg_ParseTuple(args, "|zz:tempnam", &dir, &pfx)) return NULL; name = tempnam(dir, pfx); if (name == NULL) return PyErr_NoMemory(); result = PyString_FromString(name); free(name); return result; } #endif #ifdef HAVE_TMPFILE static char posix_tmpfile__doc__[] = "\ tmpfile() -> file object\n\ Create a temporary file with no directory entries."; static PyObject * posix_tmpfile(PyObject *self, PyObject *args) { FILE *fp; if (!PyArg_ParseTuple(args, ":tmpfile")) return NULL; fp = tmpfile(); if (fp == NULL) return posix_error(); return PyFile_FromFile(fp, "", "w+", fclose); } #endif #ifdef HAVE_TMPNAM static char posix_tmpnam__doc__[] = "\ tmpnam() -> string\n\ Return a unique name for a temporary file."; static PyObject * posix_tmpnam(PyObject *self, PyObject *args) { char buffer[L_tmpnam]; char *name; if (!PyArg_ParseTuple(args, ":tmpnam")) return NULL; #ifdef USE_TMPNAM_R name = tmpnam_r(buffer); #else name = tmpnam(buffer); #endif if (name == NULL) { PyErr_SetObject(PyExc_OSError, Py_BuildValue("is", 0, #ifdef USE_TMPNAM_R "unexpected NULL from tmpnam_r" #else "unexpected NULL from tmpnam" #endif )); return NULL; } return PyString_FromString(buffer); } #endif /* This is used for fpathconf(), pathconf(), confstr() and sysconf(). * It maps strings representing configuration variable names to * integer values, allowing those functions to be called with the * magic names instead of poluting the module's namespace with tons of * rarely-used constants. There are three separate tables that use * these definitions. * * This code is always included, even if none of the interfaces that * need it are included. The #if hackery needed to avoid it would be * sufficiently pervasive that it's not worth the loss of readability. */ struct constdef { char *name; long value; }; static int conv_confname(PyObject *arg, int *valuep, struct constdef *table, size_t tablesize) { if (PyInt_Check(arg)) { *valuep = PyInt_AS_LONG(arg); return 1; } if (PyString_Check(arg)) { /* look up the value in the table using a binary search */ size_t lo = 0; size_t mid; size_t hi = tablesize; int cmp; char *confname = PyString_AS_STRING(arg); while (lo < hi) { mid = (lo + hi) / 2; cmp = strcmp(confname, table[mid].name); if (cmp < 0) hi = mid; else if (cmp > 0) lo = mid + 1; else { *valuep = table[mid].value; return 1; } } PyErr_SetString(PyExc_ValueError, "unrecognized configuration name"); } else PyErr_SetString(PyExc_TypeError, "configuration names must be strings or integers"); return 0; } #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF) static struct constdef posix_constants_pathconf[] = { #ifdef _PC_ABI_AIO_XFER_MAX {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX}, #endif #ifdef _PC_ABI_ASYNC_IO {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO}, #endif #ifdef _PC_ASYNC_IO {"PC_ASYNC_IO", _PC_ASYNC_IO}, #endif #ifdef _PC_CHOWN_RESTRICTED {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED}, #endif #ifdef _PC_FILESIZEBITS {"PC_FILESIZEBITS", _PC_FILESIZEBITS}, #endif #ifdef _PC_LAST {"PC_LAST", _PC_LAST}, #endif #ifdef _PC_LINK_MAX {"PC_LINK_MAX", _PC_LINK_MAX}, #endif #ifdef _PC_MAX_CANON {"PC_MAX_CANON", _PC_MAX_CANON}, #endif #ifdef _PC_MAX_INPUT {"PC_MAX_INPUT", _PC_MAX_INPUT}, #endif #ifdef _PC_NAME_MAX {"PC_NAME_MAX", _PC_NAME_MAX}, #endif #ifdef _PC_NO_TRUNC {"PC_NO_TRUNC", _PC_NO_TRUNC}, #endif #ifdef _PC_PATH_MAX {"PC_PATH_MAX", _PC_PATH_MAX}, #endif #ifdef _PC_PIPE_BUF {"PC_PIPE_BUF", _PC_PIPE_BUF}, #endif #ifdef _PC_PRIO_IO {"PC_PRIO_IO", _PC_PRIO_IO}, #endif #ifdef _PC_SOCK_MAXBUF {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF}, #endif #ifdef _PC_SYNC_IO {"PC_SYNC_IO", _PC_SYNC_IO}, #endif #ifdef _PC_VDISABLE {"PC_VDISABLE", _PC_VDISABLE}, #endif }; static int conv_path_confname(PyObject *arg, int *valuep) { return conv_confname(arg, valuep, posix_constants_pathconf, sizeof(posix_constants_pathconf) / sizeof(struct constdef)); } #endif #ifdef HAVE_FPATHCONF static char posix_fpathconf__doc__[] = "\ fpathconf(fd, name) -> integer\n\ Return the configuration limit name for the file descriptor fd.\n\ If there is no limit, return -1."; static PyObject * posix_fpathconf(PyObject *self, PyObject *args) { PyObject *result = NULL; int name, fd; if (PyArg_ParseTuple(args, "iO&:fpathconf", &fd, conv_path_confname, &name)) { long limit; errno = 0; limit = fpathconf(fd, name); if (limit == -1 && errno != 0) posix_error(); else result = PyInt_FromLong(limit); } return result; } #endif #ifdef HAVE_PATHCONF static char posix_pathconf__doc__[] = "\ pathconf(path, name) -> integer\n\ Return the configuration limit name for the file or directory path.\n\ If there is no limit, return -1."; static PyObject * posix_pathconf(PyObject *self, PyObject *args) { PyObject *result = NULL; int name; char *path; if (PyArg_ParseTuple(args, "sO&:pathconf", &path, conv_path_confname, &name)) { long limit; errno = 0; limit = pathconf(path, name); if (limit == -1 && errno != 0) { if (errno == EINVAL) /* could be a path or name problem */ posix_error(); else posix_error_with_filename(path); } else result = PyInt_FromLong(limit); } return result; } #endif #ifdef HAVE_CONFSTR static struct constdef posix_constants_confstr[] = { #ifdef _CS_ARCHITECTURE {"CS_ARCHITECTURE", _CS_ARCHITECTURE}, #endif #ifdef _CS_HOSTNAME {"CS_HOSTNAME", _CS_HOSTNAME}, #endif #ifdef _CS_HW_PROVIDER {"CS_HW_PROVIDER", _CS_HW_PROVIDER}, #endif #ifdef _CS_HW_SERIAL {"CS_HW_SERIAL", _CS_HW_SERIAL}, #endif #ifdef _CS_INITTAB_NAME {"CS_INITTAB_NAME", _CS_INITTAB_NAME}, #endif #ifdef _CS_LFS64_CFLAGS {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS}, #endif #ifdef _CS_LFS64_LDFLAGS {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS}, #endif #ifdef _CS_LFS64_LIBS {"CS_LFS64_LIBS", _CS_LFS64_LIBS}, #endif #ifdef _CS_LFS64_LINTFLAGS {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS}, #endif #ifdef _CS_LFS_CFLAGS {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS}, #endif #ifdef _CS_LFS_LDFLAGS {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS}, #endif #ifdef _CS_LFS_LIBS {"CS_LFS_LIBS", _CS_LFS_LIBS}, #endif #ifdef _CS_LFS_LINTFLAGS {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS}, #endif #ifdef _CS_MACHINE {"CS_MACHINE", _CS_MACHINE}, #endif #ifdef _CS_PATH {"CS_PATH", _CS_PATH}, #endif #ifdef _CS_RELEASE {"CS_RELEASE", _CS_RELEASE}, #endif #ifdef _CS_SRPC_DOMAIN {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN}, #endif #ifdef _CS_SYSNAME {"CS_SYSNAME", _CS_SYSNAME}, #endif #ifdef _CS_VERSION {"CS_VERSION", _CS_VERSION}, #endif #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS}, #endif #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS}, #endif #ifdef _CS_XBS5_ILP32_OFF32_LIBS {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS}, #endif #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS}, #endif #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS}, #endif #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS}, #endif #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS}, #endif #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS}, #endif #ifdef _CS_XBS5_LP64_OFF64_CFLAGS {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS}, #endif #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS}, #endif #ifdef _CS_XBS5_LP64_OFF64_LIBS {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS}, #endif #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS}, #endif #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS}, #endif #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS}, #endif #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS}, #endif #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS}, #endif #ifdef _MIPS_CS_AVAIL_PROCESSORS {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS}, #endif #ifdef _MIPS_CS_BASE {"MIPS_CS_BASE", _MIPS_CS_BASE}, #endif #ifdef _MIPS_CS_HOSTID {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID}, #endif #ifdef _MIPS_CS_HW_NAME {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME}, #endif #ifdef _MIPS_CS_NUM_PROCESSORS {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS}, #endif #ifdef _MIPS_CS_OSREL_MAJ {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ}, #endif #ifdef _MIPS_CS_OSREL_MIN {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN}, #endif #ifdef _MIPS_CS_OSREL_PATCH {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH}, #endif #ifdef _MIPS_CS_OS_NAME {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME}, #endif #ifdef _MIPS_CS_OS_PROVIDER {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER}, #endif #ifdef _MIPS_CS_PROCESSORS {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS}, #endif #ifdef _MIPS_CS_SERIAL {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL}, #endif #ifdef _MIPS_CS_VENDOR {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR}, #endif }; static int conv_confstr_confname(PyObject *arg, int *valuep) { return conv_confname(arg, valuep, posix_constants_confstr, sizeof(posix_constants_confstr) / sizeof(struct constdef)); } static char posix_confstr__doc__[] = "\ confstr(name) -> string\n\ Return a string-valued system configuration variable."; static PyObject * posix_confstr(PyObject *self, PyObject *args) { PyObject *result = NULL; int name; char buffer[64]; if (PyArg_ParseTuple(args, "O&:confstr", conv_confstr_confname, &name)) { int len = confstr(name, buffer, sizeof(buffer)); errno = 0; if (len == 0) { if (errno != 0) posix_error(); else result = PyString_FromString(""); } else { if (len >= sizeof(buffer)) { result = PyString_FromStringAndSize(NULL, len); if (result != NULL) confstr(name, PyString_AS_STRING(result), len+1); } else result = PyString_FromString(buffer); } } return result; } #endif #ifdef HAVE_SYSCONF static struct constdef posix_constants_sysconf[] = { #ifdef _SC_2_CHAR_TERM {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM}, #endif #ifdef _SC_2_C_BIND {"SC_2_C_BIND", _SC_2_C_BIND}, #endif #ifdef _SC_2_C_DEV {"SC_2_C_DEV", _SC_2_C_DEV}, #endif #ifdef _SC_2_C_VERSION {"SC_2_C_VERSION", _SC_2_C_VERSION}, #endif #ifdef _SC_2_FORT_DEV {"SC_2_FORT_DEV", _SC_2_FORT_DEV}, #endif #ifdef _SC_2_FORT_RUN {"SC_2_FORT_RUN", _SC_2_FORT_RUN}, #endif #ifdef _SC_2_LOCALEDEF {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF}, #endif #ifdef _SC_2_SW_DEV {"SC_2_SW_DEV", _SC_2_SW_DEV}, #endif #ifdef _SC_2_UPE {"SC_2_UPE", _SC_2_UPE}, #endif #ifdef _SC_2_VERSION {"SC_2_VERSION", _SC_2_VERSION}, #endif #ifdef _SC_ABI_ASYNCHRONOUS_IO {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO}, #endif #ifdef _SC_ACL {"SC_ACL", _SC_ACL}, #endif #ifdef _SC_AIO_LISTIO_MAX {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX}, #endif #ifdef _SC_AIO_MAX {"SC_AIO_MAX", _SC_AIO_MAX}, #endif #ifdef _SC_AIO_PRIO_DELTA_MAX {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX}, #endif #ifdef _SC_ARG_MAX {"SC_ARG_MAX", _SC_ARG_MAX}, #endif #ifdef _SC_ASYNCHRONOUS_IO {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO}, #endif #ifdef _SC_ATEXIT_MAX {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX}, #endif #ifdef _SC_AUDIT {"SC_AUDIT", _SC_AUDIT}, #endif #ifdef _SC_AVPHYS_PAGES {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES}, #endif #ifdef _SC_BC_BASE_MAX {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX}, #endif #ifdef _SC_BC_DIM_MAX {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX}, #endif #ifdef _SC_BC_SCALE_MAX {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX}, #endif #ifdef _SC_BC_STRING_MAX {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX}, #endif #ifdef _SC_CAP {"SC_CAP", _SC_CAP}, #endif #ifdef _SC_CHARCLASS_NAME_MAX {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX}, #endif #ifdef _SC_CHAR_BIT {"SC_CHAR_BIT", _SC_CHAR_BIT}, #endif #ifdef _SC_CHAR_MAX {"SC_CHAR_MAX", _SC_CHAR_MAX}, #endif #ifdef _SC_CHAR_MIN {"SC_CHAR_MIN", _SC_CHAR_MIN}, #endif #ifdef _SC_CHILD_MAX {"SC_CHILD_MAX", _SC_CHILD_MAX}, #endif #ifdef _SC_CLK_TCK {"SC_CLK_TCK", _SC_CLK_TCK}, #endif #ifdef _SC_COHER_BLKSZ {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ}, #endif #ifdef _SC_COLL_WEIGHTS_MAX {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX}, #endif #ifdef _SC_DCACHE_ASSOC {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC}, #endif #ifdef _SC_DCACHE_BLKSZ {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ}, #endif #ifdef _SC_DCACHE_LINESZ {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ}, #endif #ifdef _SC_DCACHE_SZ {"SC_DCACHE_SZ", _SC_DCACHE_SZ}, #endif #ifdef _SC_DCACHE_TBLKSZ {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ}, #endif #ifdef _SC_DELAYTIMER_MAX {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX}, #endif #ifdef _SC_EQUIV_CLASS_MAX {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX}, #endif #ifdef _SC_EXPR_NEST_MAX {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX}, #endif #ifdef _SC_FSYNC {"SC_FSYNC", _SC_FSYNC}, #endif #ifdef _SC_GETGR_R_SIZE_MAX {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX}, #endif #ifdef _SC_GETPW_R_SIZE_MAX {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX}, #endif #ifdef _SC_ICACHE_ASSOC {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC}, #endif #ifdef _SC_ICACHE_BLKSZ {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ}, #endif #ifdef _SC_ICACHE_LINESZ {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ}, #endif #ifdef _SC_ICACHE_SZ {"SC_ICACHE_SZ", _SC_ICACHE_SZ}, #endif #ifdef _SC_INF {"SC_INF", _SC_INF}, #endif #ifdef _SC_INT_MAX {"SC_INT_MAX", _SC_INT_MAX}, #endif #ifdef _SC_INT_MIN {"SC_INT_MIN", _SC_INT_MIN}, #endif #ifdef _SC_IOV_MAX {"SC_IOV_MAX", _SC_IOV_MAX}, #endif #ifdef _SC_IP_SECOPTS {"SC_IP_SECOPTS", _SC_IP_SECOPTS}, #endif #ifdef _SC_JOB_CONTROL {"SC_JOB_CONTROL", _SC_JOB_CONTROL}, #endif #ifdef _SC_KERN_POINTERS {"SC_KERN_POINTERS", _SC_KERN_POINTERS}, #endif #ifdef _SC_KERN_SIM {"SC_KERN_SIM", _SC_KERN_SIM}, #endif #ifdef _SC_LINE_MAX {"SC_LINE_MAX", _SC_LINE_MAX}, #endif #ifdef _SC_LOGIN_NAME_MAX {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX}, #endif #ifdef _SC_LOGNAME_MAX {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX}, #endif #ifdef _SC_LONG_BIT {"SC_LONG_BIT", _SC_LONG_BIT}, #endif #ifdef _SC_MAC {"SC_MAC", _SC_MAC}, #endif #ifdef _SC_MAPPED_FILES {"SC_MAPPED_FILES", _SC_MAPPED_FILES}, #endif #ifdef _SC_MAXPID {"SC_MAXPID", _SC_MAXPID}, #endif #ifdef _SC_MB_LEN_MAX {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX}, #endif #ifdef _SC_MEMLOCK {"SC_MEMLOCK", _SC_MEMLOCK}, #endif #ifdef _SC_MEMLOCK_RANGE {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE}, #endif #ifdef _SC_MEMORY_PROTECTION {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION}, #endif #ifdef _SC_MESSAGE_PASSING {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING}, #endif #ifdef _SC_MMAP_FIXED_ALIGNMENT {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT}, #endif #ifdef _SC_MQ_OPEN_MAX {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX}, #endif #ifdef _SC_MQ_PRIO_MAX {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX}, #endif #ifdef _SC_NACLS_MAX {"SC_NACLS_MAX", _SC_NACLS_MAX}, #endif #ifdef _SC_NGROUPS_MAX {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX}, #endif #ifdef _SC_NL_ARGMAX {"SC_NL_ARGMAX", _SC_NL_ARGMAX}, #endif #ifdef _SC_NL_LANGMAX {"SC_NL_LANGMAX", _SC_NL_LANGMAX}, #endif #ifdef _SC_NL_MSGMAX {"SC_NL_MSGMAX", _SC_NL_MSGMAX}, #endif #ifdef _SC_NL_NMAX {"SC_NL_NMAX", _SC_NL_NMAX}, #endif #ifdef _SC_NL_SETMAX {"SC_NL_SETMAX", _SC_NL_SETMAX}, #endif #ifdef _SC_NL_TEXTMAX {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX}, #endif #ifdef _SC_NPROCESSORS_CONF {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF}, #endif #ifdef _SC_NPROCESSORS_ONLN {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN}, #endif #ifdef _SC_NPROC_CONF {"SC_NPROC_CONF", _SC_NPROC_CONF}, #endif #ifdef _SC_NPROC_ONLN {"SC_NPROC_ONLN", _SC_NPROC_ONLN}, #endif #ifdef _SC_NZERO {"SC_NZERO", _SC_NZERO}, #endif #ifdef _SC_OPEN_MAX {"SC_OPEN_MAX", _SC_OPEN_MAX}, #endif #ifdef _SC_PAGESIZE {"SC_PAGESIZE", _SC_PAGESIZE}, #endif #ifdef _SC_PAGE_SIZE {"SC_PAGE_SIZE", _SC_PAGE_SIZE}, #endif #ifdef _SC_PASS_MAX {"SC_PASS_MAX", _SC_PASS_MAX}, #endif #ifdef _SC_PHYS_PAGES {"SC_PHYS_PAGES", _SC_PHYS_PAGES}, #endif #ifdef _SC_PII {"SC_PII", _SC_PII}, #endif #ifdef _SC_PII_INTERNET {"SC_PII_INTERNET", _SC_PII_INTERNET}, #endif #ifdef _SC_PII_INTERNET_DGRAM {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM}, #endif #ifdef _SC_PII_INTERNET_STREAM {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM}, #endif #ifdef _SC_PII_OSI {"SC_PII_OSI", _SC_PII_OSI}, #endif #ifdef _SC_PII_OSI_CLTS {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS}, #endif #ifdef _SC_PII_OSI_COTS {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS}, #endif #ifdef _SC_PII_OSI_M {"SC_PII_OSI_M", _SC_PII_OSI_M}, #endif #ifdef _SC_PII_SOCKET {"SC_PII_SOCKET", _SC_PII_SOCKET}, #endif #ifdef _SC_PII_XTI {"SC_PII_XTI", _SC_PII_XTI}, #endif #ifdef _SC_POLL {"SC_POLL", _SC_POLL}, #endif #ifdef _SC_PRIORITIZED_IO {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO}, #endif #ifdef _SC_PRIORITY_SCHEDULING {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING}, #endif #ifdef _SC_REALTIME_SIGNALS {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS}, #endif #ifdef _SC_RE_DUP_MAX {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX}, #endif #ifdef _SC_RTSIG_MAX {"SC_RTSIG_MAX", _SC_RTSIG_MAX}, #endif #ifdef _SC_SAVED_IDS {"SC_SAVED_IDS", _SC_SAVED_IDS}, #endif #ifdef _SC_SCHAR_MAX {"SC_SCHAR_MAX", _SC_SCHAR_MAX}, #endif #ifdef _SC_SCHAR_MIN {"SC_SCHAR_MIN", _SC_SCHAR_MIN}, #endif #ifdef _SC_SELECT {"SC_SELECT", _SC_SELECT}, #endif #ifdef _SC_SEMAPHORES {"SC_SEMAPHORES", _SC_SEMAPHORES}, #endif #ifdef _SC_SEM_NSEMS_MAX {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX}, #endif #ifdef _SC_SEM_VALUE_MAX {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX}, #endif #ifdef _SC_SHARED_MEMORY_OBJECTS {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS}, #endif #ifdef _SC_SHRT_MAX {"SC_SHRT_MAX", _SC_SHRT_MAX}, #endif #ifdef _SC_SHRT_MIN {"SC_SHRT_MIN", _SC_SHRT_MIN}, #endif #ifdef _SC_SIGQUEUE_MAX {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX}, #endif #ifdef _SC_SIGRT_MAX {"SC_SIGRT_MAX", _SC_SIGRT_MAX}, #endif #ifdef _SC_SIGRT_MIN {"SC_SIGRT_MIN", _SC_SIGRT_MIN}, #endif #ifdef _SC_SOFTPOWER {"SC_SOFTPOWER", _SC_SOFTPOWER}, #endif #ifdef _SC_SPLIT_CACHE {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE}, #endif #ifdef _SC_SSIZE_MAX {"SC_SSIZE_MAX", _SC_SSIZE_MAX}, #endif #ifdef _SC_STACK_PROT {"SC_STACK_PROT", _SC_STACK_PROT}, #endif #ifdef _SC_STREAM_MAX {"SC_STREAM_MAX", _SC_STREAM_MAX}, #endif #ifdef _SC_SYNCHRONIZED_IO {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO}, #endif #ifdef _SC_THREADS {"SC_THREADS", _SC_THREADS}, #endif #ifdef _SC_THREAD_ATTR_STACKADDR {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR}, #endif #ifdef _SC_THREAD_ATTR_STACKSIZE {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE}, #endif #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS}, #endif #ifdef _SC_THREAD_KEYS_MAX {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX}, #endif #ifdef _SC_THREAD_PRIORITY_SCHEDULING {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING}, #endif #ifdef _SC_THREAD_PRIO_INHERIT {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT}, #endif #ifdef _SC_THREAD_PRIO_PROTECT {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT}, #endif #ifdef _SC_THREAD_PROCESS_SHARED {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED}, #endif #ifdef _SC_THREAD_SAFE_FUNCTIONS {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS}, #endif #ifdef _SC_THREAD_STACK_MIN {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN}, #endif #ifdef _SC_THREAD_THREADS_MAX {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX}, #endif #ifdef _SC_TIMERS {"SC_TIMERS", _SC_TIMERS}, #endif #ifdef _SC_TIMER_MAX {"SC_TIMER_MAX", _SC_TIMER_MAX}, #endif #ifdef _SC_TTY_NAME_MAX {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX}, #endif #ifdef _SC_TZNAME_MAX {"SC_TZNAME_MAX", _SC_TZNAME_MAX}, #endif #ifdef _SC_T_IOV_MAX {"SC_T_IOV_MAX", _SC_T_IOV_MAX}, #endif #ifdef _SC_UCHAR_MAX {"SC_UCHAR_MAX", _SC_UCHAR_MAX}, #endif #ifdef _SC_UINT_MAX {"SC_UINT_MAX", _SC_UINT_MAX}, #endif #ifdef _SC_UIO_MAXIOV {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV}, #endif #ifdef _SC_ULONG_MAX {"SC_ULONG_MAX", _SC_ULONG_MAX}, #endif #ifdef _SC_USHRT_MAX {"SC_USHRT_MAX", _SC_USHRT_MAX}, #endif #ifdef _SC_VERSION {"SC_VERSION", _SC_VERSION}, #endif #ifdef _SC_WORD_BIT {"SC_WORD_BIT", _SC_WORD_BIT}, #endif #ifdef _SC_XBS5_ILP32_OFF32 {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32}, #endif #ifdef _SC_XBS5_ILP32_OFFBIG {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG}, #endif #ifdef _SC_XBS5_LP64_OFF64 {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64}, #endif #ifdef _SC_XBS5_LPBIG_OFFBIG {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG}, #endif #ifdef _SC_XOPEN_CRYPT {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT}, #endif #ifdef _SC_XOPEN_ENH_I18N {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N}, #endif #ifdef _SC_XOPEN_LEGACY {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY}, #endif #ifdef _SC_XOPEN_REALTIME {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME}, #endif #ifdef _SC_XOPEN_REALTIME_THREADS {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS}, #endif #ifdef _SC_XOPEN_SHM {"SC_XOPEN_SHM", _SC_XOPEN_SHM}, #endif #ifdef _SC_XOPEN_UNIX {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX}, #endif #ifdef _SC_XOPEN_VERSION {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION}, #endif #ifdef _SC_XOPEN_XCU_VERSION {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION}, #endif #ifdef _SC_XOPEN_XPG2 {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2}, #endif #ifdef _SC_XOPEN_XPG3 {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3}, #endif #ifdef _SC_XOPEN_XPG4 {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4}, #endif }; static int conv_sysconf_confname(PyObject *arg, int *valuep) { return conv_confname(arg, valuep, posix_constants_sysconf, sizeof(posix_constants_sysconf) / sizeof(struct constdef)); } static char posix_sysconf__doc__[] = "\ sysconf(name) -> integer\n\ Return an integer-valued system configuration variable."; static PyObject * posix_sysconf(PyObject *self, PyObject *args) { PyObject *result = NULL; int name; if (PyArg_ParseTuple(args, "O&:sysconf", conv_sysconf_confname, &name)) { int value; errno = 0; value = sysconf(name); if (value == -1 && errno != 0) posix_error(); else result = PyInt_FromLong(value); } return result; } #endif /* This code is used to ensure that the tables of configuration value names * are in sorted order as required by conv_confname(), and also to build the * the exported dictionaries that are used to publish information about the * names available on the host platform. * * Sorting the table at runtime ensures that the table is properly ordered * when used, even for platforms we're not able to test on. It also makes * it easier to add additional entries to the tables. */ static int cmp_constdefs(const void *v1, const void *v2) { const struct constdef *c1 = (const struct constdef *) v1; const struct constdef *c2 = (const struct constdef *) v2; return strcmp(c1->name, c2->name); } static int setup_confname_table(struct constdef *table, size_t tablesize, char *tablename, PyObject *moddict) { PyObject *d = NULL; size_t i; int status; qsort(table, tablesize, sizeof(struct constdef), cmp_constdefs); d = PyDict_New(); if (d == NULL) return -1; for (i=0; i < tablesize; ++i) { PyObject *o = PyInt_FromLong(table[i].value); if (o == NULL || PyDict_SetItemString(d, table[i].name, o) == -1) { Py_XDECREF(o); Py_DECREF(d); return -1; } Py_DECREF(o); } status = PyDict_SetItemString(moddict, tablename, d); Py_DECREF(d); return status; } /* Return -1 on failure, 0 on success. */ static int setup_confname_tables(PyObject *moddict) { #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF) if (setup_confname_table(posix_constants_pathconf, sizeof(posix_constants_pathconf) / sizeof(struct constdef), "pathconf_names", moddict)) return -1; #endif #ifdef HAVE_CONFSTR if (setup_confname_table(posix_constants_confstr, sizeof(posix_constants_confstr) / sizeof(struct constdef), "confstr_names", moddict)) return -1; #endif #ifdef HAVE_SYSCONF if (setup_confname_table(posix_constants_sysconf, sizeof(posix_constants_sysconf) / sizeof(struct constdef), "sysconf_names", moddict)) return -1; #endif return 0; } static char posix_abort__doc__[] = "\ abort() -> does not return!\n\ Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\ in the hardest way possible on the hosting operating system."; static PyObject * posix_abort(PyObject *self, PyObject *args) { if (!PyArg_ParseTuple(args, ":abort")) return NULL; abort(); /*NOTREACHED*/ Py_FatalError("abort() called from Python code didn't abort!"); return NULL; } static PyMethodDef posix_methods[] = { {"access", posix_access, METH_VARARGS, posix_access__doc__}, #ifdef HAVE_TTYNAME {"ttyname", posix_ttyname, METH_VARARGS, posix_ttyname__doc__}, #endif {"chdir", posix_chdir, METH_VARARGS, posix_chdir__doc__}, {"chmod", posix_chmod, METH_VARARGS, posix_chmod__doc__}, #ifdef HAVE_CHOWN {"chown", posix_chown, METH_VARARGS, posix_chown__doc__}, #endif /* HAVE_CHOWN */ #ifdef HAVE_CTERMID {"ctermid", posix_ctermid, METH_VARARGS, posix_ctermid__doc__}, #endif #ifdef HAVE_GETCWD {"getcwd", posix_getcwd, METH_VARARGS, posix_getcwd__doc__}, #endif #ifdef HAVE_LINK {"link", posix_link, METH_VARARGS, posix_link__doc__}, #endif /* HAVE_LINK */ {"listdir", posix_listdir, METH_VARARGS, posix_listdir__doc__}, {"lstat", posix_lstat, METH_VARARGS, posix_lstat__doc__}, {"mkdir", posix_mkdir, METH_VARARGS, posix_mkdir__doc__}, #ifdef HAVE_NICE {"nice", posix_nice, METH_VARARGS, posix_nice__doc__}, #endif /* HAVE_NICE */ #ifdef HAVE_READLINK {"readlink", posix_readlink, METH_VARARGS, posix_readlink__doc__}, #endif /* HAVE_READLINK */ {"rename", posix_rename, METH_VARARGS, posix_rename__doc__}, {"rmdir", posix_rmdir, METH_VARARGS, posix_rmdir__doc__}, {"stat", posix_stat, METH_VARARGS, posix_stat__doc__}, #ifdef HAVE_SYMLINK {"symlink", posix_symlink, METH_VARARGS, posix_symlink__doc__}, #endif /* HAVE_SYMLINK */ #ifdef HAVE_SYSTEM {"system", posix_system, METH_VARARGS, posix_system__doc__}, #endif {"umask", posix_umask, METH_VARARGS, posix_umask__doc__}, #ifdef HAVE_UNAME {"uname", posix_uname, METH_VARARGS, posix_uname__doc__}, #endif /* HAVE_UNAME */ {"unlink", posix_unlink, METH_VARARGS, posix_unlink__doc__}, {"remove", posix_unlink, METH_VARARGS, posix_remove__doc__}, {"utime", posix_utime, METH_VARARGS, posix_utime__doc__}, #ifdef HAVE_TIMES {"times", posix_times, METH_VARARGS, posix_times__doc__}, #endif /* HAVE_TIMES */ {"_exit", posix__exit, METH_VARARGS, posix__exit__doc__}, #ifdef HAVE_EXECV {"execv", posix_execv, METH_VARARGS, posix_execv__doc__}, {"execve", posix_execve, METH_VARARGS, posix_execve__doc__}, #endif /* HAVE_EXECV */ #ifdef HAVE_SPAWNV {"spawnv", posix_spawnv, METH_VARARGS, posix_spawnv__doc__}, {"spawnve", posix_spawnve, METH_VARARGS, posix_spawnve__doc__}, #endif /* HAVE_SPAWNV */ #ifdef HAVE_FORK {"fork", posix_fork, METH_VARARGS, posix_fork__doc__}, #endif /* HAVE_FORK */ #ifdef HAVE_OPENPTY {"openpty", posix_openpty, METH_VARARGS, posix_openpty__doc__}, #endif /* HAVE_OPENPTY */ #ifdef HAVE_FORKPTY {"forkpty", posix_forkpty, METH_VARARGS, posix_forkpty__doc__}, #endif /* HAVE_FORKPTY */ #ifdef HAVE_GETEGID {"getegid", posix_getegid, METH_VARARGS, posix_getegid__doc__}, #endif /* HAVE_GETEGID */ #ifdef HAVE_GETEUID {"geteuid", posix_geteuid, METH_VARARGS, posix_geteuid__doc__}, #endif /* HAVE_GETEUID */ #ifdef HAVE_GETGID {"getgid", posix_getgid, METH_VARARGS, posix_getgid__doc__}, #endif /* HAVE_GETGID */ #ifdef HAVE_GETGROUPS {"getgroups", posix_getgroups, METH_VARARGS, posix_getgroups__doc__}, #endif {"getpid", posix_getpid, METH_VARARGS, posix_getpid__doc__}, #ifdef HAVE_GETPGRP {"getpgrp", posix_getpgrp, METH_VARARGS, posix_getpgrp__doc__}, #endif /* HAVE_GETPGRP */ #ifdef HAVE_GETPPID {"getppid", posix_getppid, METH_VARARGS, posix_getppid__doc__}, #endif /* HAVE_GETPPID */ #ifdef HAVE_GETUID {"getuid", posix_getuid, METH_VARARGS, posix_getuid__doc__}, #endif /* HAVE_GETUID */ #ifdef HAVE_GETLOGIN {"getlogin", posix_getlogin, METH_VARARGS, posix_getlogin__doc__}, #endif #ifdef HAVE_KILL {"kill", posix_kill, METH_VARARGS, posix_kill__doc__}, #endif /* HAVE_KILL */ #ifdef HAVE_PLOCK {"plock", posix_plock, METH_VARARGS, posix_plock__doc__}, #endif /* HAVE_PLOCK */ #ifdef HAVE_POPEN {"popen", posix_popen, METH_VARARGS, posix_popen__doc__}, #ifdef MS_WIN32 {"popen2", win32_popen2, METH_VARARGS}, {"popen3", win32_popen3, METH_VARARGS}, {"popen4", win32_popen4, METH_VARARGS}, #endif #endif /* HAVE_POPEN */ #ifdef HAVE_SETUID {"setuid", posix_setuid, METH_VARARGS, posix_setuid__doc__}, #endif /* HAVE_SETUID */ #ifdef HAVE_SETGID {"setgid", posix_setgid, METH_VARARGS, posix_setgid__doc__}, #endif /* HAVE_SETGID */ #ifdef HAVE_SETPGRP {"setpgrp", posix_setpgrp, METH_VARARGS, posix_setpgrp__doc__}, #endif /* HAVE_SETPGRP */ #ifdef HAVE_WAIT {"wait", posix_wait, METH_VARARGS, posix_wait__doc__}, #endif /* HAVE_WAIT */ #ifdef HAVE_WAITPID {"waitpid", posix_waitpid, METH_VARARGS, posix_waitpid__doc__}, #endif /* HAVE_WAITPID */ #ifdef HAVE_SETSID {"setsid", posix_setsid, METH_VARARGS, posix_setsid__doc__}, #endif /* HAVE_SETSID */ #ifdef HAVE_SETPGID {"setpgid", posix_setpgid, METH_VARARGS, posix_setpgid__doc__}, #endif /* HAVE_SETPGID */ #ifdef HAVE_TCGETPGRP {"tcgetpgrp", posix_tcgetpgrp, METH_VARARGS, posix_tcgetpgrp__doc__}, #endif /* HAVE_TCGETPGRP */ #ifdef HAVE_TCSETPGRP {"tcsetpgrp", posix_tcsetpgrp, METH_VARARGS, posix_tcsetpgrp__doc__}, #endif /* HAVE_TCSETPGRP */ {"open", posix_open, METH_VARARGS, posix_open__doc__}, {"close", posix_close, METH_VARARGS, posix_close__doc__}, {"dup", posix_dup, METH_VARARGS, posix_dup__doc__}, {"dup2", posix_dup2, METH_VARARGS, posix_dup2__doc__}, {"lseek", posix_lseek, METH_VARARGS, posix_lseek__doc__}, {"read", posix_read, METH_VARARGS, posix_read__doc__}, {"write", posix_write, METH_VARARGS, posix_write__doc__}, {"fstat", posix_fstat, METH_VARARGS, posix_fstat__doc__}, {"fdopen", posix_fdopen, METH_VARARGS, posix_fdopen__doc__}, #ifdef HAVE_PIPE {"pipe", posix_pipe, METH_VARARGS, posix_pipe__doc__}, #endif #ifdef HAVE_MKFIFO {"mkfifo", posix_mkfifo, METH_VARARGS, posix_mkfifo__doc__}, #endif #ifdef HAVE_FTRUNCATE {"ftruncate", posix_ftruncate, METH_VARARGS, posix_ftruncate__doc__}, #endif #ifdef HAVE_PUTENV {"putenv", posix_putenv, METH_VARARGS, posix_putenv__doc__}, #endif #ifdef HAVE_STRERROR {"strerror", posix_strerror, METH_VARARGS, posix_strerror__doc__}, #endif #ifdef HAVE_FSYNC {"fsync", posix_fsync, METH_VARARGS, posix_fsync__doc__}, #endif #ifdef HAVE_FDATASYNC {"fdatasync", posix_fdatasync, METH_VARARGS, posix_fdatasync__doc__}, #endif #ifdef HAVE_SYS_WAIT_H #ifdef WIFSTOPPED {"WIFSTOPPED", posix_WIFSTOPPED, METH_VARARGS, posix_WIFSTOPPED__doc__}, #endif /* WIFSTOPPED */ #ifdef WIFSIGNALED {"WIFSIGNALED", posix_WIFSIGNALED, METH_VARARGS, posix_WIFSIGNALED__doc__}, #endif /* WIFSIGNALED */ #ifdef WIFEXITED {"WIFEXITED", posix_WIFEXITED, METH_VARARGS, posix_WIFEXITED__doc__}, #endif /* WIFEXITED */ #ifdef WEXITSTATUS {"WEXITSTATUS", posix_WEXITSTATUS, METH_VARARGS, posix_WEXITSTATUS__doc__}, #endif /* WEXITSTATUS */ #ifdef WTERMSIG {"WTERMSIG", posix_WTERMSIG, METH_VARARGS, posix_WTERMSIG__doc__}, #endif /* WTERMSIG */ #ifdef WSTOPSIG {"WSTOPSIG", posix_WSTOPSIG, METH_VARARGS, posix_WSTOPSIG__doc__}, #endif /* WSTOPSIG */ #endif /* HAVE_SYS_WAIT_H */ #ifdef HAVE_FSTATVFS {"fstatvfs", posix_fstatvfs, METH_VARARGS, posix_fstatvfs__doc__}, #endif #ifdef HAVE_STATVFS {"statvfs", posix_statvfs, METH_VARARGS, posix_statvfs__doc__}, #endif #ifdef HAVE_TMPNAM {"tmpfile", posix_tmpfile, METH_VARARGS, posix_tmpfile__doc__}, #endif #ifdef HAVE_TEMPNAM {"tempnam", posix_tempnam, METH_VARARGS, posix_tempnam__doc__}, #endif #ifdef HAVE_TMPNAM {"tmpnam", posix_tmpnam, METH_VARARGS, posix_tmpnam__doc__}, #endif #ifdef HAVE_CONFSTR {"confstr", posix_confstr, METH_VARARGS, posix_confstr__doc__}, #endif #ifdef HAVE_SYSCONF {"sysconf", posix_sysconf, METH_VARARGS, posix_sysconf__doc__}, #endif #ifdef HAVE_FPATHCONF {"fpathconf", posix_fpathconf, METH_VARARGS, posix_fpathconf__doc__}, #endif #ifdef HAVE_PATHCONF {"pathconf", posix_pathconf, METH_VARARGS, posix_pathconf__doc__}, #endif {"abort", posix_abort, METH_VARARGS, posix_abort__doc__}, {NULL, NULL} /* Sentinel */ }; static int ins(PyObject *d, char *symbol, long value) { PyObject* v = PyInt_FromLong(value); if (!v || PyDict_SetItemString(d, symbol, v) < 0) return -1; /* triggers fatal error */ Py_DECREF(v); return 0; } #if defined(PYOS_OS2) /* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */ static int insertvalues(PyObject *d) { APIRET rc; ULONG values[QSV_MAX+1]; PyObject *v; char *ver, tmp[10]; Py_BEGIN_ALLOW_THREADS rc = DosQuerySysInfo(1, QSV_MAX, &values[1], sizeof(values)); Py_END_ALLOW_THREADS if (rc != NO_ERROR) { os2_error(rc); return -1; } if (ins(d, "meminstalled", values[QSV_TOTPHYSMEM])) return -1; if (ins(d, "memkernel", values[QSV_TOTRESMEM])) return -1; if (ins(d, "memvirtual", values[QSV_TOTAVAILMEM])) return -1; if (ins(d, "maxpathlen", values[QSV_MAX_PATH_LENGTH])) return -1; if (ins(d, "maxnamelen", values[QSV_MAX_COMP_LENGTH])) return -1; if (ins(d, "revision", values[QSV_VERSION_REVISION])) return -1; if (ins(d, "timeslice", values[QSV_MIN_SLICE])) return -1; switch (values[QSV_VERSION_MINOR]) { case 0: ver = "2.00"; break; case 10: ver = "2.10"; break; case 11: ver = "2.11"; break; case 30: ver = "3.00"; break; case 40: ver = "4.00"; break; case 50: ver = "5.00"; break; default: sprintf(tmp, "%d-%d", values[QSV_VERSION_MAJOR], values[QSV_VERSION_MINOR]); ver = &tmp[0]; } /* Add Indicator of the Version of the Operating System */ v = PyString_FromString(ver); if (!v || PyDict_SetItemString(d, "version", v) < 0) return -1; Py_DECREF(v); /* Add Indicator of Which Drive was Used to Boot the System */ tmp[0] = 'A' + values[QSV_BOOT_DRIVE] - 1; tmp[1] = ':'; tmp[2] = '\0'; v = PyString_FromString(tmp); if (!v || PyDict_SetItemString(d, "bootdrive", v) < 0) return -1; Py_DECREF(v); return 0; } #endif static int all_ins(d) PyObject* d; { #ifdef F_OK if (ins(d, "F_OK", (long)F_OK)) return -1; #endif #ifdef R_OK if (ins(d, "R_OK", (long)R_OK)) return -1; #endif #ifdef W_OK if (ins(d, "W_OK", (long)W_OK)) return -1; #endif #ifdef X_OK if (ins(d, "X_OK", (long)X_OK)) return -1; #endif #ifdef NGROUPS_MAX if (ins(d, "NGROUPS_MAX", (long)NGROUPS_MAX)) return -1; #endif #ifdef TMP_MAX if (ins(d, "TMP_MAX", (long)TMP_MAX)) return -1; #endif #ifdef WNOHANG if (ins(d, "WNOHANG", (long)WNOHANG)) return -1; #endif #ifdef O_RDONLY if (ins(d, "O_RDONLY", (long)O_RDONLY)) return -1; #endif #ifdef O_WRONLY if (ins(d, "O_WRONLY", (long)O_WRONLY)) return -1; #endif #ifdef O_RDWR if (ins(d, "O_RDWR", (long)O_RDWR)) return -1; #endif #ifdef O_NDELAY if (ins(d, "O_NDELAY", (long)O_NDELAY)) return -1; #endif #ifdef O_NONBLOCK if (ins(d, "O_NONBLOCK", (long)O_NONBLOCK)) return -1; #endif #ifdef O_APPEND if (ins(d, "O_APPEND", (long)O_APPEND)) return -1; #endif #ifdef O_DSYNC if (ins(d, "O_DSYNC", (long)O_DSYNC)) return -1; #endif #ifdef O_RSYNC if (ins(d, "O_RSYNC", (long)O_RSYNC)) return -1; #endif #ifdef O_SYNC if (ins(d, "O_SYNC", (long)O_SYNC)) return -1; #endif #ifdef O_NOCTTY if (ins(d, "O_NOCTTY", (long)O_NOCTTY)) return -1; #endif #ifdef O_CREAT if (ins(d, "O_CREAT", (long)O_CREAT)) return -1; #endif #ifdef O_EXCL if (ins(d, "O_EXCL", (long)O_EXCL)) return -1; #endif #ifdef O_TRUNC if (ins(d, "O_TRUNC", (long)O_TRUNC)) return -1; #endif #ifdef O_BINARY if (ins(d, "O_BINARY", (long)O_BINARY)) return -1; #endif #ifdef O_TEXT if (ins(d, "O_TEXT", (long)O_TEXT)) return -1; #endif #ifdef HAVE_SPAWNV if (ins(d, "P_WAIT", (long)_P_WAIT)) return -1; if (ins(d, "P_NOWAIT", (long)_P_NOWAIT)) return -1; if (ins(d, "P_OVERLAY", (long)_OLD_P_OVERLAY)) return -1; if (ins(d, "P_NOWAITO", (long)_P_NOWAITO)) return -1; if (ins(d, "P_DETACH", (long)_P_DETACH)) return -1; #endif #if defined(PYOS_OS2) if (insertvalues(d)) return -1; #endif return 0; } #if ( defined(_MSC_VER) || defined(__WATCOMC__) ) && !defined(__QNX__) #define INITFUNC initnt #define MODNAME "nt" #else #if defined(PYOS_OS2) #define INITFUNC initos2 #define MODNAME "os2" #else #define INITFUNC initposix #define MODNAME "posix" #endif #endif DL_EXPORT(void) INITFUNC() { PyObject *m, *d, *v; m = Py_InitModule4(MODNAME, posix_methods, posix__doc__, (PyObject *)NULL, PYTHON_API_VERSION); d = PyModule_GetDict(m); /* Initialize environ dictionary */ v = convertenviron(); if (v == NULL || PyDict_SetItemString(d, "environ", v) != 0) return; Py_DECREF(v); if (all_ins(d)) return; if (setup_confname_tables(d)) return; PyDict_SetItemString(d, "error", PyExc_OSError); #ifdef HAVE_PUTENV posix_putenv_garbage = PyDict_New(); #endif }