2 /* POSIX module implementation */
4 /* This file is also used for Windows NT/MS-Win and OS/2. In that case the
5 module actually calls itself 'nt' or 'os2', not 'posix', and a few
6 functions are either unimplemented or implemented differently. The source
7 assumes that for Windows NT, the macro 'MS_WINDOWS' is defined independent
8 of the compiler used. Different compilers define their own feature
9 test macro, e.g. '__BORLANDC__' or '_MSC_VER'. For OS/2, the compiler
10 independent macro PYOS_OS2 should be defined. On OS/2 the default
11 compiler is assumed to be IBM's VisualAge C++ (VACPP). PYCC_GCC is used
12 as the compiler specific macro for the EMX port of gcc to OS/2. */
14 /* See also ../Dos/dosmodule.c */
18 * Step 1 of support for weak-linking a number of symbols existing on
19 * OSX 10.4 and later, see the comment in the #ifdef __APPLE__ block
20 * at the end of this file for more information.
24 # pragma weak fstatvfs
26 #endif /* __APPLE__ */
28 #define PY_SSIZE_T_CLEAN
31 #include "structseq.h"
35 #endif /* defined(__VMS) */
41 PyDoc_STRVAR(posix__doc__
,
42 "This module provides access to operating system functionality that is\n\
43 standardized by the C Standard and the POSIX standard (a thinly\n\
44 disguised Unix interface). Refer to the library manual and\n\
45 corresponding Unix manual entries for more information on calls.");
47 #ifndef Py_USING_UNICODE
48 /* This is used in signatures of functions. */
49 #define Py_UNICODE void
54 #define INCL_DOSERRORS
55 #define INCL_DOSPROCESS
67 #ifdef HAVE_SYS_TYPES_H
68 #include <sys/types.h>
69 #endif /* HAVE_SYS_TYPES_H */
71 #ifdef HAVE_SYS_STAT_H
73 #endif /* HAVE_SYS_STAT_H */
75 #ifdef HAVE_SYS_WAIT_H
76 #include <sys/wait.h> /* For WNOHANG */
85 #endif /* HAVE_FCNTL_H */
91 #ifdef HAVE_SYSEXITS_H
93 #endif /* HAVE_SYSEXITS_H */
95 #ifdef HAVE_SYS_LOADAVG_H
96 #include <sys/loadavg.h>
99 /* Various compilers have only certain posix functions */
100 /* XXX Gosh I wish these were all moved into pyconfig.h */
101 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
104 #if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */
105 #define HAVE_GETCWD 1
106 #define HAVE_OPENDIR 1
107 #define HAVE_SYSTEM 1
114 #ifdef __BORLANDC__ /* Borland compiler */
116 #define HAVE_GETCWD 1
117 #define HAVE_OPENDIR 1
120 #define HAVE_SYSTEM 1
123 #ifdef _MSC_VER /* Microsoft compiler */
124 #define HAVE_GETCWD 1
125 #define HAVE_SPAWNV 1
129 #define HAVE_SYSTEM 1
132 #define fsync _commit
134 #if defined(PYOS_OS2) && defined(PYCC_GCC) || defined(__VMS)
135 /* Everything needed is defined in PC/os2emx/pyconfig.h or vms/pyconfig.h */
136 #else /* all other compilers */
137 /* Unix functions that the configure script doesn't check for */
140 #if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */
143 #define HAVE_GETCWD 1
144 #define HAVE_GETEGID 1
145 #define HAVE_GETEUID 1
146 #define HAVE_GETGID 1
147 #define HAVE_GETPPID 1
148 #define HAVE_GETUID 1
150 #define HAVE_OPENDIR 1
155 #define HAVE_SYSTEM 1
157 #define HAVE_TTYNAME 1
158 #endif /* PYOS_OS2 && PYCC_GCC && __VMS */
159 #endif /* _MSC_VER */
160 #endif /* __BORLANDC__ */
161 #endif /* ! __WATCOMC__ || __QNX__ */
162 #endif /* ! __IBMC__ */
166 #if defined(__sgi)&&_COMPILER_VERSION>=700
167 /* declare ctermid_r if compiling with MIPSPro 7.x in ANSI C mode
169 extern char *ctermid_r(char *);
172 #ifndef HAVE_UNISTD_H
173 #if defined(PYCC_VACPP)
174 extern int mkdir(char *);
176 #if ( defined(__WATCOMC__) || defined(_MSC_VER) ) && !defined(__QNX__)
177 extern int mkdir(const char *);
179 extern int mkdir(const char *, mode_t
);
182 #if defined(__IBMC__) || defined(__IBMCPP__)
183 extern int chdir(char *);
184 extern int rmdir(char *);
186 extern int chdir(const char *);
187 extern int rmdir(const char *);
190 extern int chmod(const char *, int);
192 extern int chmod(const char *, mode_t
);
195 extern int fchmod(int, mode_t);
198 extern int lchmod(const char *, mode_t);
200 extern int chown(const char *, uid_t
, gid_t
);
201 extern char *getcwd(char *, int);
202 extern char *strerror(int);
203 extern int link(const char *, const char *);
204 extern int rename(const char *, const char *);
205 extern int stat(const char *, struct stat
*);
206 extern int unlink(const char *);
207 extern int pclose(FILE *);
209 extern int symlink(const char *, const char *);
210 #endif /* HAVE_SYMLINK */
212 extern int lstat(const char *, struct stat
*);
213 #endif /* HAVE_LSTAT */
214 #endif /* !HAVE_UNISTD_H */
216 #endif /* !_MSC_VER */
220 #endif /* HAVE_UTIME_H */
222 #ifdef HAVE_SYS_UTIME_H
223 #include <sys/utime.h>
224 #define HAVE_UTIME_H /* pretend we do for the rest of this file */
225 #endif /* HAVE_SYS_UTIME_H */
227 #ifdef HAVE_SYS_TIMES_H
228 #include <sys/times.h>
229 #endif /* HAVE_SYS_TIMES_H */
231 #ifdef HAVE_SYS_PARAM_H
232 #include <sys/param.h>
233 #endif /* HAVE_SYS_PARAM_H */
235 #ifdef HAVE_SYS_UTSNAME_H
236 #include <sys/utsname.h>
237 #endif /* HAVE_SYS_UTSNAME_H */
241 #define NAMLEN(dirent) strlen((dirent)->d_name)
243 #if defined(__WATCOMC__) && !defined(__QNX__)
245 #define NAMLEN(dirent) strlen((dirent)->d_name)
247 #define dirent direct
248 #define NAMLEN(dirent) (dirent)->d_namlen
250 #ifdef HAVE_SYS_NDIR_H
251 #include <sys/ndir.h>
253 #ifdef HAVE_SYS_DIR_H
268 #ifdef HAVE_PROCESS_H
273 #include <shellapi.h> /* for ShellExecute() */
275 #define pclose _pclose
276 #endif /* _MSC_VER */
278 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
283 #if defined(PATH_MAX) && PATH_MAX > 1024
284 #define MAXPATHLEN PATH_MAX
286 #define MAXPATHLEN 1024
288 #endif /* MAXPATHLEN */
291 /* Emulate some macros on systems that have a union instead of macros */
294 #define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump)
298 #define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1)
302 #define WTERMSIG(u_wait) ((u_wait).w_termsig)
305 #define WAIT_TYPE union wait
306 #define WAIT_STATUS_INT(s) (s.w_status)
308 #else /* !UNION_WAIT */
309 #define WAIT_TYPE int
310 #define WAIT_STATUS_INT(s) (s)
311 #endif /* UNION_WAIT */
313 /* Don't use the "_r" form if we don't need it (also, won't have a
314 prototype for it, at least on Solaris -- maybe others as well?). */
315 #if defined(HAVE_CTERMID_R) && defined(WITH_THREAD)
316 #define USE_CTERMID_R
319 #if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD)
323 /* choose the appropriate stat and fstat functions and return structs */
325 #if defined(MS_WIN64) || defined(MS_WINDOWS)
326 # define STAT win32_stat
327 # define FSTAT win32_fstat
328 # define STRUCT_STAT struct win32_stat
332 # define STRUCT_STAT struct stat
335 #if defined(MAJOR_IN_MKDEV)
336 #include <sys/mkdev.h>
338 #if defined(MAJOR_IN_SYSMACROS)
339 #include <sys/sysmacros.h>
341 #if defined(HAVE_MKNOD) && defined(HAVE_SYS_MKDEV_H)
342 #include <sys/mkdev.h>
346 /* Return a dictionary corresponding to the POSIX environment table */
347 #ifdef WITH_NEXT_FRAMEWORK
348 /* On Darwin/MacOSX a shared library or framework has no access to
349 ** environ directly, we must obtain it with _NSGetEnviron().
351 #include <crt_externs.h>
352 static char **environ
;
353 #elif !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )
354 extern char **environ
;
355 #endif /* !_MSC_VER */
365 #ifdef WITH_NEXT_FRAMEWORK
367 environ
= *_NSGetEnviron();
371 /* This part ignores errors */
372 for (e
= environ
; *e
!= NULL
; e
++) {
375 char *p
= strchr(*e
, '=');
378 k
= PyString_FromStringAndSize(*e
, (int)(p
-*e
));
383 v
= PyString_FromString(p
+1);
389 if (PyDict_GetItem(d
, k
) == NULL
) {
390 if (PyDict_SetItem(d
, k
, v
) != 0)
396 #if defined(PYOS_OS2)
399 char buffer
[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */
401 rc
= DosQueryExtLIBPATH(buffer
, BEGIN_LIBPATH
);
402 if (rc
== NO_ERROR
) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
403 PyObject
*v
= PyString_FromString(buffer
);
404 PyDict_SetItemString(d
, "BEGINLIBPATH", v
);
407 rc
= DosQueryExtLIBPATH(buffer
, END_LIBPATH
);
408 if (rc
== NO_ERROR
) { /* (not a typo, envname is NOT 'END_LIBPATH') */
409 PyObject
*v
= PyString_FromString(buffer
);
410 PyDict_SetItemString(d
, "ENDLIBPATH", v
);
419 /* Set a POSIX-specific error from errno, and return NULL */
424 return PyErr_SetFromErrno(PyExc_OSError
);
427 posix_error_with_filename(char* name
)
429 return PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
432 #ifdef Py_WIN_WIDE_FILENAMES
434 posix_error_with_unicode_filename(Py_UNICODE
* name
)
436 return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError
, name
);
438 #endif /* Py_WIN_WIDE_FILENAMES */
442 posix_error_with_allocated_filename(char* name
)
444 PyObject
*rc
= PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
451 win32_error(char* function
, char* filename
)
453 /* XXX We should pass the function name along in the future.
454 (_winreg.c also wants to pass the function name.)
455 This would however require an additional param to the
456 Windows error object, which is non-trivial.
458 errno
= GetLastError();
460 return PyErr_SetFromWindowsErrWithFilename(errno
, filename
);
462 return PyErr_SetFromWindowsErr(errno
);
465 #ifdef Py_WIN_WIDE_FILENAMES
467 win32_error_unicode(char* function
, Py_UNICODE
* filename
)
469 /* XXX - see win32_error for comments on 'function' */
470 errno
= GetLastError();
472 return PyErr_SetFromWindowsErrWithUnicodeFilename(errno
, filename
);
474 return PyErr_SetFromWindowsErr(errno
);
477 static PyObject
*_PyUnicode_FromFileSystemEncodedObject(register PyObject
*obj
)
481 /* Function suitable for O& conversion */
483 convert_to_unicode(PyObject
*arg
, void* _param
)
485 PyObject
**param
= (PyObject
**)_param
;
486 if (PyUnicode_CheckExact(arg
)) {
490 else if (PyUnicode_Check(arg
)) {
491 /* For a Unicode subtype that's not a Unicode object,
492 return a true Unicode object with the same data. */
493 *param
= PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(arg
),
494 PyUnicode_GET_SIZE(arg
));
495 return *param
!= NULL
;
498 *param
= PyUnicode_FromEncodedObject(arg
,
499 Py_FileSystemDefaultEncoding
,
501 return (*param
) != NULL
;
504 #endif /* Py_WIN_WIDE_FILENAMES */
508 #if defined(PYOS_OS2)
509 /**********************************************************************
510 * Helper Function to Trim and Format OS/2 Messages
511 **********************************************************************/
513 os2_formatmsg(char *msgbuf
, int msglen
, char *reason
)
515 msgbuf
[msglen
] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
517 if (strlen(msgbuf
) > 0) { /* If Non-Empty Msg, Trim CRLF */
518 char *lastc
= &msgbuf
[ strlen(msgbuf
)-1 ];
520 while (lastc
> msgbuf
&& isspace(Py_CHARMASK(*lastc
)))
521 *lastc
-- = '\0'; /* Trim Trailing Whitespace (CRLF) */
524 /* Add Optional Reason Text */
526 strcat(msgbuf
, " : ");
527 strcat(msgbuf
, reason
);
531 /**********************************************************************
532 * Decode an OS/2 Operating System Error Code
534 * A convenience function to lookup an OS/2 error code and return a
535 * text message we can use to raise a Python exception.
538 * The messages for errors returned from the OS/2 kernel reside in
539 * the file OSO001.MSG in the \OS2 directory hierarchy.
541 **********************************************************************/
543 os2_strerror(char *msgbuf
, int msgbuflen
, int errorcode
, char *reason
)
548 /* Retrieve Kernel-Related Error Message from OSO001.MSG File */
549 Py_BEGIN_ALLOW_THREADS
550 rc
= DosGetMessage(NULL
, 0, msgbuf
, msgbuflen
,
551 errorcode
, "oso001.msg", &msglen
);
555 os2_formatmsg(msgbuf
, msglen
, reason
);
557 PyOS_snprintf(msgbuf
, msgbuflen
,
558 "unknown OS error #%d", errorcode
);
563 /* Set an OS/2-specific error and return NULL. OS/2 kernel
564 errors are not in a global variable e.g. 'errno' nor are
565 they congruent with posix error numbers. */
567 static PyObject
* os2_error(int code
)
572 os2_strerror(text
, sizeof(text
), code
, "");
574 v
= Py_BuildValue("(is)", code
, text
);
576 PyErr_SetObject(PyExc_OSError
, v
);
579 return NULL
; /* Signal to Python that an Exception is Pending */
584 /* POSIX generic methods */
587 posix_fildes(PyObject
*fdobj
, int (*func
)(int))
591 fd
= PyObject_AsFileDescriptor(fdobj
);
594 Py_BEGIN_ALLOW_THREADS
598 return posix_error();
603 #ifdef Py_WIN_WIDE_FILENAMES
605 unicode_file_names(void)
607 static int canusewide
= -1;
608 if (canusewide
== -1) {
609 /* As per doc for ::GetVersion(), this is the correct test for
610 the Windows NT family. */
611 canusewide
= (GetVersion() < 0x80000000) ? 1 : 0;
618 posix_1str(PyObject
*args
, char *format
, int (*func
)(const char*))
622 if (!PyArg_ParseTuple(args
, format
,
623 Py_FileSystemDefaultEncoding
, &path1
))
625 Py_BEGIN_ALLOW_THREADS
626 res
= (*func
)(path1
);
629 return posix_error_with_allocated_filename(path1
);
636 posix_2str(PyObject
*args
,
638 int (*func
)(const char *, const char *))
640 char *path1
= NULL
, *path2
= NULL
;
642 if (!PyArg_ParseTuple(args
, format
,
643 Py_FileSystemDefaultEncoding
, &path1
,
644 Py_FileSystemDefaultEncoding
, &path2
))
646 Py_BEGIN_ALLOW_THREADS
647 res
= (*func
)(path1
, path2
);
652 /* XXX how to report both path1 and path2??? */
653 return posix_error();
658 #ifdef Py_WIN_WIDE_FILENAMES
660 win32_1str(PyObject
* args
, char* func
,
661 char* format
, BOOL (__stdcall
*funcA
)(LPCSTR
),
662 char* wformat
, BOOL (__stdcall
*funcW
)(LPWSTR
))
667 if (unicode_file_names()) {
668 if (!PyArg_ParseTuple(args
, wformat
, &uni
))
671 Py_BEGIN_ALLOW_THREADS
672 result
= funcW(PyUnicode_AsUnicode(uni
));
675 return win32_error_unicode(func
, PyUnicode_AsUnicode(uni
));
680 if (!PyArg_ParseTuple(args
, format
, &ansi
))
682 Py_BEGIN_ALLOW_THREADS
683 result
= funcA(ansi
);
686 return win32_error(func
, ansi
);
692 /* This is a reimplementation of the C library's chdir function,
693 but one that produces Win32 errors instead of DOS error codes.
694 chdir is essentially a wrapper around SetCurrentDirectory; however,
695 it also needs to set "magic" environment variables indicating
696 the per-drive current directory, which are of the form =<drive>: */
698 win32_chdir(LPCSTR path
)
700 char new_path
[MAX_PATH
+1];
704 if(!SetCurrentDirectoryA(path
))
706 result
= GetCurrentDirectoryA(MAX_PATH
+1, new_path
);
709 /* In the ANSI API, there should not be any paths longer
711 assert(result
<= MAX_PATH
+1);
712 if (strncmp(new_path
, "\\\\", 2) == 0 ||
713 strncmp(new_path
, "//", 2) == 0)
714 /* UNC path, nothing to do. */
716 env
[1] = new_path
[0];
717 return SetEnvironmentVariableA(env
, new_path
);
720 /* The Unicode version differs from the ANSI version
721 since the current directory might exceed MAX_PATH characters */
723 win32_wchdir(LPCWSTR path
)
725 wchar_t _new_path
[MAX_PATH
+1], *new_path
= _new_path
;
727 wchar_t env
[4] = L
"=x:";
729 if(!SetCurrentDirectoryW(path
))
731 result
= GetCurrentDirectoryW(MAX_PATH
+1, new_path
);
734 if (result
> MAX_PATH
+1) {
735 new_path
= malloc(result
);
737 SetLastError(ERROR_OUTOFMEMORY
);
741 if (wcsncmp(new_path
, L
"\\\\", 2) == 0 ||
742 wcsncmp(new_path
, L
"//", 2) == 0)
743 /* UNC path, nothing to do. */
745 env
[1] = new_path
[0];
746 result
= SetEnvironmentVariableW(env
, new_path
);
747 if (new_path
!= _new_path
)
754 /* The CRT of Windows has a number of flaws wrt. its stat() implementation:
755 - time stamps are restricted to second resolution
756 - file modification times suffer from forth-and-back conversions between
758 Therefore, we implement our own stat, based on the Win32 API directly.
760 #define HAVE_STAT_NSEC 1
765 unsigned short st_mode
;
779 static __int64 secs_between_epochs
= 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */
782 FILE_TIME_to_time_t_nsec(FILETIME
*in_ptr
, int *time_out
, int* nsec_out
)
784 /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */
785 /* Cannot simply cast and dereference in_ptr,
786 since it might not be aligned properly */
788 memcpy(&in
, in_ptr
, sizeof(in
));
789 *nsec_out
= (int)(in
% 10000000) * 100; /* FILETIME is in units of 100 nsec. */
790 /* XXX Win32 supports time stamps past 2038; we currently don't */
791 *time_out
= Py_SAFE_DOWNCAST((in
/ 10000000) - secs_between_epochs
, __int64
, int);
795 time_t_to_FILE_TIME(int time_in
, int nsec_in
, FILETIME
*out_ptr
)
799 out
= time_in
+ secs_between_epochs
;
800 out
= out
* 10000000 + nsec_in
/ 100;
801 memcpy(out_ptr
, &out
, sizeof(out
));
804 /* Below, we *know* that ugo+r is 0444 */
806 #error Unsupported C library
809 attributes_to_mode(DWORD attr
)
812 if (attr
& FILE_ATTRIBUTE_DIRECTORY
)
813 m
|= _S_IFDIR
| 0111; /* IFEXEC for user,group,other */
816 if (attr
& FILE_ATTRIBUTE_READONLY
)
824 attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA
*info
, struct win32_stat
*result
)
826 memset(result
, 0, sizeof(*result
));
827 result
->st_mode
= attributes_to_mode(info
->dwFileAttributes
);
828 result
->st_size
= (((__int64
)info
->nFileSizeHigh
)<<32) + info
->nFileSizeLow
;
829 FILE_TIME_to_time_t_nsec(&info
->ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
830 FILE_TIME_to_time_t_nsec(&info
->ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
831 FILE_TIME_to_time_t_nsec(&info
->ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
836 /* Emulate GetFileAttributesEx[AW] on Windows 95 */
837 static int checked
= 0;
838 static BOOL (CALLBACK
*gfaxa
)(LPCSTR
, GET_FILEEX_INFO_LEVELS
, LPVOID
);
839 static BOOL (CALLBACK
*gfaxw
)(LPCWSTR
, GET_FILEEX_INFO_LEVELS
, LPVOID
);
847 hKernel32
= GetModuleHandle("KERNEL32");
848 *(FARPROC
*)&gfaxa
= GetProcAddress(hKernel32
, "GetFileAttributesExA");
849 *(FARPROC
*)&gfaxw
= GetProcAddress(hKernel32
, "GetFileAttributesExW");
853 attributes_from_dir(LPCSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
856 WIN32_FIND_DATAA FileData
;
857 hFindFile
= FindFirstFileA(pszFile
, &FileData
);
858 if (hFindFile
== INVALID_HANDLE_VALUE
)
860 FindClose(hFindFile
);
861 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
862 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
863 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
864 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
865 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
866 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
871 attributes_from_dir_w(LPCWSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
874 WIN32_FIND_DATAW FileData
;
875 hFindFile
= FindFirstFileW(pszFile
, &FileData
);
876 if (hFindFile
== INVALID_HANDLE_VALUE
)
878 FindClose(hFindFile
);
879 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
880 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
881 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
882 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
883 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
884 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
889 Py_GetFileAttributesExA(LPCSTR pszFile
,
890 GET_FILEEX_INFO_LEVELS level
,
894 LPWIN32_FILE_ATTRIBUTE_DATA pfad
= pv
;
895 /* First try to use the system's implementation, if that is
896 available and either succeeds to gives an error other than
897 that it isn't implemented. */
900 result
= gfaxa(pszFile
, level
, pv
);
901 if (result
|| GetLastError() != ERROR_CALL_NOT_IMPLEMENTED
)
904 /* It's either not present, or not implemented.
905 Emulate using FindFirstFile. */
906 if (level
!= GetFileExInfoStandard
) {
907 SetLastError(ERROR_INVALID_PARAMETER
);
910 /* Use GetFileAttributes to validate that the file name
911 does not contain wildcards (which FindFirstFile would
913 if (GetFileAttributesA(pszFile
) == 0xFFFFFFFF)
915 return attributes_from_dir(pszFile
, pfad
);
919 Py_GetFileAttributesExW(LPCWSTR pszFile
,
920 GET_FILEEX_INFO_LEVELS level
,
924 LPWIN32_FILE_ATTRIBUTE_DATA pfad
= pv
;
925 /* First try to use the system's implementation, if that is
926 available and either succeeds to gives an error other than
927 that it isn't implemented. */
930 result
= gfaxw(pszFile
, level
, pv
);
931 if (result
|| GetLastError() != ERROR_CALL_NOT_IMPLEMENTED
)
934 /* It's either not present, or not implemented.
935 Emulate using FindFirstFile. */
936 if (level
!= GetFileExInfoStandard
) {
937 SetLastError(ERROR_INVALID_PARAMETER
);
940 /* Use GetFileAttributes to validate that the file name
941 does not contain wildcards (which FindFirstFile would
943 if (GetFileAttributesW(pszFile
) == 0xFFFFFFFF)
945 return attributes_from_dir_w(pszFile
, pfad
);
949 win32_stat(const char* path
, struct win32_stat
*result
)
951 WIN32_FILE_ATTRIBUTE_DATA info
;
954 /* XXX not supported on Win95 and NT 3.x */
955 if (!Py_GetFileAttributesExA(path
, GetFileExInfoStandard
, &info
)) {
956 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
957 /* Protocol violation: we explicitly clear errno, instead of
958 setting it to a POSIX error. Callers should use GetLastError. */
962 /* Could not get attributes on open file. Fall back to
963 reading the directory. */
964 if (!attributes_from_dir(path
, &info
)) {
965 /* Very strange. This should not fail now */
971 code
= attribute_data_to_stat(&info
, result
);
974 /* Set S_IFEXEC if it is an .exe, .bat, ... */
975 dot
= strrchr(path
, '.');
977 if (stricmp(dot
, ".bat") == 0 ||
978 stricmp(dot
, ".cmd") == 0 ||
979 stricmp(dot
, ".exe") == 0 ||
980 stricmp(dot
, ".com") == 0)
981 result
->st_mode
|= 0111;
987 win32_wstat(const wchar_t* path
, struct win32_stat
*result
)
991 WIN32_FILE_ATTRIBUTE_DATA info
;
992 /* XXX not supported on Win95 and NT 3.x */
993 if (!Py_GetFileAttributesExW(path
, GetFileExInfoStandard
, &info
)) {
994 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
995 /* Protocol violation: we explicitly clear errno, instead of
996 setting it to a POSIX error. Callers should use GetLastError. */
1000 /* Could not get attributes on open file. Fall back to
1001 reading the directory. */
1002 if (!attributes_from_dir_w(path
, &info
)) {
1003 /* Very strange. This should not fail now */
1009 code
= attribute_data_to_stat(&info
, result
);
1012 /* Set IFEXEC if it is an .exe, .bat, ... */
1013 dot
= wcsrchr(path
, '.');
1015 if (_wcsicmp(dot
, L
".bat") == 0 ||
1016 _wcsicmp(dot
, L
".cmd") == 0 ||
1017 _wcsicmp(dot
, L
".exe") == 0 ||
1018 _wcsicmp(dot
, L
".com") == 0)
1019 result
->st_mode
|= 0111;
1025 win32_fstat(int file_number
, struct win32_stat
*result
)
1027 BY_HANDLE_FILE_INFORMATION info
;
1031 h
= (HANDLE
)_get_osfhandle(file_number
);
1033 /* Protocol violation: we explicitly clear errno, instead of
1034 setting it to a POSIX error. Callers should use GetLastError. */
1037 if (h
== INVALID_HANDLE_VALUE
) {
1038 /* This is really a C library error (invalid file handle).
1039 We set the Win32 error to the closes one matching. */
1040 SetLastError(ERROR_INVALID_HANDLE
);
1043 memset(result
, 0, sizeof(*result
));
1045 type
= GetFileType(h
);
1046 if (type
== FILE_TYPE_UNKNOWN
) {
1047 DWORD error
= GetLastError();
1051 /* else: valid but unknown file */
1054 if (type
!= FILE_TYPE_DISK
) {
1055 if (type
== FILE_TYPE_CHAR
)
1056 result
->st_mode
= _S_IFCHR
;
1057 else if (type
== FILE_TYPE_PIPE
)
1058 result
->st_mode
= _S_IFIFO
;
1062 if (!GetFileInformationByHandle(h
, &info
)) {
1066 /* similar to stat() */
1067 result
->st_mode
= attributes_to_mode(info
.dwFileAttributes
);
1068 result
->st_size
= (((__int64
)info
.nFileSizeHigh
)<<32) + info
.nFileSizeLow
;
1069 FILE_TIME_to_time_t_nsec(&info
.ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
1070 FILE_TIME_to_time_t_nsec(&info
.ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
1071 FILE_TIME_to_time_t_nsec(&info
.ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
1072 /* specific to fstat() */
1073 result
->st_nlink
= info
.nNumberOfLinks
;
1074 result
->st_ino
= (((__int64
)info
.nFileIndexHigh
)<<32) + info
.nFileIndexLow
;
1078 #endif /* MS_WINDOWS */
1080 PyDoc_STRVAR(stat_result__doc__
,
1081 "stat_result: Result from stat or lstat.\n\n\
1082 This object may be accessed either as a tuple of\n\
1083 (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n\
1084 or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\
1086 Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n\
1087 or st_flags, they are available as attributes only.\n\
1089 See os.stat for more information.");
1091 static PyStructSequence_Field stat_result_fields
[] = {
1092 {"st_mode", "protection bits"},
1093 {"st_ino", "inode"},
1094 {"st_dev", "device"},
1095 {"st_nlink", "number of hard links"},
1096 {"st_uid", "user ID of owner"},
1097 {"st_gid", "group ID of owner"},
1098 {"st_size", "total size, in bytes"},
1099 /* The NULL is replaced with PyStructSequence_UnnamedField later. */
1100 {NULL
, "integer time of last access"},
1101 {NULL
, "integer time of last modification"},
1102 {NULL
, "integer time of last change"},
1103 {"st_atime", "time of last access"},
1104 {"st_mtime", "time of last modification"},
1105 {"st_ctime", "time of last change"},
1106 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1107 {"st_blksize", "blocksize for filesystem I/O"},
1109 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1110 {"st_blocks", "number of blocks allocated"},
1112 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1113 {"st_rdev", "device type (if inode device)"},
1115 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1116 {"st_flags", "user defined flags for file"},
1118 #ifdef HAVE_STRUCT_STAT_ST_GEN
1119 {"st_gen", "generation number"},
1121 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1122 {"st_birthtime", "time of creation"},
1127 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1128 #define ST_BLKSIZE_IDX 13
1130 #define ST_BLKSIZE_IDX 12
1133 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1134 #define ST_BLOCKS_IDX (ST_BLKSIZE_IDX+1)
1136 #define ST_BLOCKS_IDX ST_BLKSIZE_IDX
1139 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1140 #define ST_RDEV_IDX (ST_BLOCKS_IDX+1)
1142 #define ST_RDEV_IDX ST_BLOCKS_IDX
1145 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1146 #define ST_FLAGS_IDX (ST_RDEV_IDX+1)
1148 #define ST_FLAGS_IDX ST_RDEV_IDX
1151 #ifdef HAVE_STRUCT_STAT_ST_GEN
1152 #define ST_GEN_IDX (ST_FLAGS_IDX+1)
1154 #define ST_GEN_IDX ST_FLAGS_IDX
1157 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1158 #define ST_BIRTHTIME_IDX (ST_GEN_IDX+1)
1160 #define ST_BIRTHTIME_IDX ST_GEN_IDX
1163 static PyStructSequence_Desc stat_result_desc
= {
1164 "stat_result", /* name */
1165 stat_result__doc__
, /* doc */
1170 PyDoc_STRVAR(statvfs_result__doc__
,
1171 "statvfs_result: Result from statvfs or fstatvfs.\n\n\
1172 This object may be accessed either as a tuple of\n\
1173 (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n\
1174 or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\
1176 See os.statvfs for more information.");
1178 static PyStructSequence_Field statvfs_result_fields
[] = {
1192 static PyStructSequence_Desc statvfs_result_desc
= {
1193 "statvfs_result", /* name */
1194 statvfs_result__doc__
, /* doc */
1195 statvfs_result_fields
,
1199 static int initialized
;
1200 static PyTypeObject StatResultType
;
1201 static PyTypeObject StatVFSResultType
;
1202 static newfunc structseq_new
;
1205 statresult_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1207 PyStructSequence
*result
;
1210 result
= (PyStructSequence
*)structseq_new(type
, args
, kwds
);
1213 /* If we have been initialized from a tuple,
1214 st_?time might be set to None. Initialize it
1215 from the int slots. */
1216 for (i
= 7; i
<= 9; i
++) {
1217 if (result
->ob_item
[i
+3] == Py_None
) {
1219 Py_INCREF(result
->ob_item
[i
]);
1220 result
->ob_item
[i
+3] = result
->ob_item
[i
];
1223 return (PyObject
*)result
;
1228 /* If true, st_?time is float. */
1229 static int _stat_float_times
= 1;
1231 PyDoc_STRVAR(stat_float_times__doc__
,
1232 "stat_float_times([newval]) -> oldval\n\n\
1233 Determine whether os.[lf]stat represents time stamps as float objects.\n\
1234 If newval is True, future calls to stat() return floats, if it is False,\n\
1235 future calls return ints. \n\
1236 If newval is omitted, return the current setting.\n");
1239 stat_float_times(PyObject
* self
, PyObject
*args
)
1242 if (!PyArg_ParseTuple(args
, "|i:stat_float_times", &newval
))
1245 /* Return old value */
1246 return PyBool_FromLong(_stat_float_times
);
1247 _stat_float_times
= newval
;
1253 fill_time(PyObject
*v
, int index
, time_t sec
, unsigned long nsec
)
1255 PyObject
*fval
,*ival
;
1256 #if SIZEOF_TIME_T > SIZEOF_LONG
1257 ival
= PyLong_FromLongLong((PY_LONG_LONG
)sec
);
1259 ival
= PyInt_FromLong((long)sec
);
1263 if (_stat_float_times
) {
1264 fval
= PyFloat_FromDouble(sec
+ 1e-9*nsec
);
1269 PyStructSequence_SET_ITEM(v
, index
, ival
);
1270 PyStructSequence_SET_ITEM(v
, index
+3, fval
);
1273 /* pack a system stat C structure into the Python stat tuple
1274 (used by posix_stat() and posix_fstat()) */
1276 _pystat_fromstructstat(STRUCT_STAT
*st
)
1278 unsigned long ansec
, mnsec
, cnsec
;
1279 PyObject
*v
= PyStructSequence_New(&StatResultType
);
1283 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long)st
->st_mode
));
1284 #ifdef HAVE_LARGEFILE_SUPPORT
1285 PyStructSequence_SET_ITEM(v
, 1,
1286 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_ino
));
1288 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long)st
->st_ino
));
1290 #if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
1291 PyStructSequence_SET_ITEM(v
, 2,
1292 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_dev
));
1294 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long)st
->st_dev
));
1296 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long)st
->st_nlink
));
1297 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long)st
->st_uid
));
1298 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long)st
->st_gid
));
1299 #ifdef HAVE_LARGEFILE_SUPPORT
1300 PyStructSequence_SET_ITEM(v
, 6,
1301 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_size
));
1303 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong(st
->st_size
));
1306 #if defined(HAVE_STAT_TV_NSEC)
1307 ansec
= st
->st_atim
.tv_nsec
;
1308 mnsec
= st
->st_mtim
.tv_nsec
;
1309 cnsec
= st
->st_ctim
.tv_nsec
;
1310 #elif defined(HAVE_STAT_TV_NSEC2)
1311 ansec
= st
->st_atimespec
.tv_nsec
;
1312 mnsec
= st
->st_mtimespec
.tv_nsec
;
1313 cnsec
= st
->st_ctimespec
.tv_nsec
;
1314 #elif defined(HAVE_STAT_NSEC)
1315 ansec
= st
->st_atime_nsec
;
1316 mnsec
= st
->st_mtime_nsec
;
1317 cnsec
= st
->st_ctime_nsec
;
1319 ansec
= mnsec
= cnsec
= 0;
1321 fill_time(v
, 7, st
->st_atime
, ansec
);
1322 fill_time(v
, 8, st
->st_mtime
, mnsec
);
1323 fill_time(v
, 9, st
->st_ctime
, cnsec
);
1325 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1326 PyStructSequence_SET_ITEM(v
, ST_BLKSIZE_IDX
,
1327 PyInt_FromLong((long)st
->st_blksize
));
1329 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1330 PyStructSequence_SET_ITEM(v
, ST_BLOCKS_IDX
,
1331 PyInt_FromLong((long)st
->st_blocks
));
1333 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1334 PyStructSequence_SET_ITEM(v
, ST_RDEV_IDX
,
1335 PyInt_FromLong((long)st
->st_rdev
));
1337 #ifdef HAVE_STRUCT_STAT_ST_GEN
1338 PyStructSequence_SET_ITEM(v
, ST_GEN_IDX
,
1339 PyInt_FromLong((long)st
->st_gen
));
1341 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1344 unsigned long bsec
,bnsec
;
1345 bsec
= (long)st
->st_birthtime
;
1346 #ifdef HAVE_STAT_TV_NSEC2
1347 bnsec
= st
->st_birthtimespec
.tv_nsec
;
1351 if (_stat_float_times
) {
1352 val
= PyFloat_FromDouble(bsec
+ 1e-9*bnsec
);
1354 val
= PyInt_FromLong((long)bsec
);
1356 PyStructSequence_SET_ITEM(v
, ST_BIRTHTIME_IDX
,
1360 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1361 PyStructSequence_SET_ITEM(v
, ST_FLAGS_IDX
,
1362 PyInt_FromLong((long)st
->st_flags
));
1365 if (PyErr_Occurred()) {
1375 /* IsUNCRoot -- test whether the supplied path is of the form \\SERVER\SHARE\,
1376 where / can be used in place of \ and the trailing slash is optional.
1377 Both SERVER and SHARE must have at least one character.
1380 #define ISSLASHA(c) ((c) == '\\' || (c) == '/')
1381 #define ISSLASHW(c) ((c) == L'\\' || (c) == L'/')
1383 #define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
1387 IsUNCRootA(char *path
, int pathlen
)
1389 #define ISSLASH ISSLASHA
1393 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1394 /* minimum UNCRoot is \\x\y */
1396 for (i
= 2; i
< pathlen
; i
++)
1397 if (ISSLASH(path
[i
])) break;
1398 if (i
== 2 || i
== pathlen
)
1399 /* do not allow \\\SHARE or \\SERVER */
1402 for (i
= share
; i
< pathlen
; i
++)
1403 if (ISSLASH(path
[i
])) break;
1404 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1409 #ifdef Py_WIN_WIDE_FILENAMES
1411 IsUNCRootW(Py_UNICODE
*path
, int pathlen
)
1413 #define ISSLASH ISSLASHW
1417 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1418 /* minimum UNCRoot is \\x\y */
1420 for (i
= 2; i
< pathlen
; i
++)
1421 if (ISSLASH(path
[i
])) break;
1422 if (i
== 2 || i
== pathlen
)
1423 /* do not allow \\\SHARE or \\SERVER */
1426 for (i
= share
; i
< pathlen
; i
++)
1427 if (ISSLASH(path
[i
])) break;
1428 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1432 #endif /* Py_WIN_WIDE_FILENAMES */
1433 #endif /* MS_WINDOWS */
1436 posix_do_stat(PyObject
*self
, PyObject
*args
,
1439 int (*statfunc
)(const char *, STRUCT_STAT
*, ...),
1441 int (*statfunc
)(const char *, STRUCT_STAT
*),
1444 int (*wstatfunc
)(const Py_UNICODE
*, STRUCT_STAT
*))
1447 char *path
= NULL
; /* pass this to stat; do not free() it */
1448 char *pathfree
= NULL
; /* this memory must be free'd */
1452 #ifdef Py_WIN_WIDE_FILENAMES
1453 /* If on wide-character-capable OS see if argument
1454 is Unicode and if so use wide API. */
1455 if (unicode_file_names()) {
1456 PyUnicodeObject
*po
;
1457 if (PyArg_ParseTuple(args
, wformat
, &po
)) {
1458 Py_UNICODE
*wpath
= PyUnicode_AS_UNICODE(po
);
1460 Py_BEGIN_ALLOW_THREADS
1461 /* PyUnicode_AS_UNICODE result OK without
1462 thread lock as it is a simple dereference. */
1463 res
= wstatfunc(wpath
, &st
);
1464 Py_END_ALLOW_THREADS
1467 return win32_error_unicode("stat", wpath
);
1468 return _pystat_fromstructstat(&st
);
1470 /* Drop the argument parsing error as narrow strings
1476 if (!PyArg_ParseTuple(args
, format
,
1477 Py_FileSystemDefaultEncoding
, &path
))
1481 Py_BEGIN_ALLOW_THREADS
1482 res
= (*statfunc
)(path
, &st
);
1483 Py_END_ALLOW_THREADS
1487 result
= win32_error("stat", pathfree
);
1489 result
= posix_error_with_filename(pathfree
);
1493 result
= _pystat_fromstructstat(&st
);
1495 PyMem_Free(pathfree
);
1501 PyDoc_STRVAR(posix_access__doc__
,
1502 "access(path, mode) -> True if granted, False otherwise\n\n\
1503 Use the real uid/gid to test for access to a path. Note that most\n\
1504 operations will use the effective uid/gid, therefore this routine can\n\
1505 be used in a suid/sgid environment to test if the invoking user has the\n\
1506 specified access to the path. The mode argument can be F_OK to test\n\
1507 existence, or the inclusive-OR of R_OK, W_OK, and X_OK.");
1510 posix_access(PyObject
*self
, PyObject
*args
)
1515 #ifdef Py_WIN_WIDE_FILENAMES
1517 if (unicode_file_names()) {
1518 PyUnicodeObject
*po
;
1519 if (PyArg_ParseTuple(args
, "Ui:access", &po
, &mode
)) {
1520 Py_BEGIN_ALLOW_THREADS
1521 /* PyUnicode_AS_UNICODE OK without thread lock as
1522 it is a simple dereference. */
1523 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1524 Py_END_ALLOW_THREADS
1527 /* Drop the argument parsing error as narrow strings
1531 if (!PyArg_ParseTuple(args
, "eti:access",
1532 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1534 Py_BEGIN_ALLOW_THREADS
1535 attr
= GetFileAttributesA(path
);
1536 Py_END_ALLOW_THREADS
1539 if (attr
== 0xFFFFFFFF)
1540 /* File does not exist, or cannot read attributes */
1541 return PyBool_FromLong(0);
1542 /* Access is possible if either write access wasn't requested, or
1543 the file isn't read-only, or if it's a directory, as there are
1544 no read-only directories on Windows. */
1545 return PyBool_FromLong(!(mode
& 2)
1546 || !(attr
& FILE_ATTRIBUTE_READONLY
)
1547 || (attr
& FILE_ATTRIBUTE_DIRECTORY
));
1550 if (!PyArg_ParseTuple(args
, "eti:access",
1551 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1553 Py_BEGIN_ALLOW_THREADS
1554 res
= access(path
, mode
);
1555 Py_END_ALLOW_THREADS
1557 return PyBool_FromLong(res
== 0);
1575 PyDoc_STRVAR(posix_ttyname__doc__
,
1576 "ttyname(fd) -> string\n\n\
1577 Return the name of the terminal device connected to 'fd'.");
1580 posix_ttyname(PyObject
*self
, PyObject
*args
)
1585 if (!PyArg_ParseTuple(args
, "i:ttyname", &id
))
1589 /* file descriptor 0 only, the default input device (stdin) */
1600 return posix_error();
1601 return PyString_FromString(ret
);
1606 PyDoc_STRVAR(posix_ctermid__doc__
,
1607 "ctermid() -> string\n\n\
1608 Return the name of the controlling terminal for this process.");
1611 posix_ctermid(PyObject
*self
, PyObject
*noargs
)
1614 char buffer
[L_ctermid
];
1616 #ifdef USE_CTERMID_R
1617 ret
= ctermid_r(buffer
);
1619 ret
= ctermid(buffer
);
1622 return posix_error();
1623 return PyString_FromString(buffer
);
1627 PyDoc_STRVAR(posix_chdir__doc__
,
1629 Change the current working directory to the specified path.");
1632 posix_chdir(PyObject
*self
, PyObject
*args
)
1635 return win32_1str(args
, "chdir", "s:chdir", win32_chdir
, "U:chdir", win32_wchdir
);
1636 #elif defined(PYOS_OS2) && defined(PYCC_GCC)
1637 return posix_1str(args
, "et:chdir", _chdir2
);
1638 #elif defined(__VMS)
1639 return posix_1str(args
, "et:chdir", (int (*)(const char *))chdir
);
1641 return posix_1str(args
, "et:chdir", chdir
);
1646 PyDoc_STRVAR(posix_fchdir__doc__
,
1647 "fchdir(fildes)\n\n\
1648 Change to the directory of the given file descriptor. fildes must be\n\
1649 opened on a directory, not a file.");
1652 posix_fchdir(PyObject
*self
, PyObject
*fdobj
)
1654 return posix_fildes(fdobj
, fchdir
);
1656 #endif /* HAVE_FCHDIR */
1659 PyDoc_STRVAR(posix_chmod__doc__
,
1660 "chmod(path, mode)\n\n\
1661 Change the access permissions of a file.");
1664 posix_chmod(PyObject
*self
, PyObject
*args
)
1669 #ifdef Py_WIN_WIDE_FILENAMES
1671 if (unicode_file_names()) {
1672 PyUnicodeObject
*po
;
1673 if (PyArg_ParseTuple(args
, "Ui|:chmod", &po
, &i
)) {
1674 Py_BEGIN_ALLOW_THREADS
1675 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1676 if (attr
!= 0xFFFFFFFF) {
1678 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1680 attr
|= FILE_ATTRIBUTE_READONLY
;
1681 res
= SetFileAttributesW(PyUnicode_AS_UNICODE(po
), attr
);
1685 Py_END_ALLOW_THREADS
1687 return win32_error_unicode("chmod",
1688 PyUnicode_AS_UNICODE(po
));
1692 /* Drop the argument parsing error as narrow strings
1696 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1699 Py_BEGIN_ALLOW_THREADS
1700 attr
= GetFileAttributesA(path
);
1701 if (attr
!= 0xFFFFFFFF) {
1703 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1705 attr
|= FILE_ATTRIBUTE_READONLY
;
1706 res
= SetFileAttributesA(path
, attr
);
1710 Py_END_ALLOW_THREADS
1712 win32_error("chmod", path
);
1719 #else /* Py_WIN_WIDE_FILENAMES */
1720 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1723 Py_BEGIN_ALLOW_THREADS
1724 res
= chmod(path
, i
);
1725 Py_END_ALLOW_THREADS
1727 return posix_error_with_allocated_filename(path
);
1735 PyDoc_STRVAR(posix_fchmod__doc__
,
1736 "fchmod(fd, mode)\n\n\
1737 Change the access permissions of the file given by file\n\
1741 posix_fchmod(PyObject
*self
, PyObject
*args
)
1744 if (!PyArg_ParseTuple(args
, "ii:fchmod", &fd
, &mode
))
1746 Py_BEGIN_ALLOW_THREADS
1747 res
= fchmod(fd
, mode
);
1748 Py_END_ALLOW_THREADS
1750 return posix_error();
1753 #endif /* HAVE_FCHMOD */
1756 PyDoc_STRVAR(posix_lchmod__doc__
,
1757 "lchmod(path, mode)\n\n\
1758 Change the access permissions of a file. If path is a symlink, this\n\
1759 affects the link itself rather than the target.");
1762 posix_lchmod(PyObject
*self
, PyObject
*args
)
1767 if (!PyArg_ParseTuple(args
, "eti:lchmod", Py_FileSystemDefaultEncoding
,
1770 Py_BEGIN_ALLOW_THREADS
1771 res
= lchmod(path
, i
);
1772 Py_END_ALLOW_THREADS
1774 return posix_error_with_allocated_filename(path
);
1778 #endif /* HAVE_LCHMOD */
1782 PyDoc_STRVAR(posix_chflags__doc__
,
1783 "chflags(path, flags)\n\n\
1787 posix_chflags(PyObject
*self
, PyObject
*args
)
1790 unsigned long flags
;
1792 if (!PyArg_ParseTuple(args
, "etk:chflags",
1793 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1795 Py_BEGIN_ALLOW_THREADS
1796 res
= chflags(path
, flags
);
1797 Py_END_ALLOW_THREADS
1799 return posix_error_with_allocated_filename(path
);
1804 #endif /* HAVE_CHFLAGS */
1806 #ifdef HAVE_LCHFLAGS
1807 PyDoc_STRVAR(posix_lchflags__doc__
,
1808 "lchflags(path, flags)\n\n\
1810 This function will not follow symbolic links.");
1813 posix_lchflags(PyObject
*self
, PyObject
*args
)
1816 unsigned long flags
;
1818 if (!PyArg_ParseTuple(args
, "etk:lchflags",
1819 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1821 Py_BEGIN_ALLOW_THREADS
1822 res
= lchflags(path
, flags
);
1823 Py_END_ALLOW_THREADS
1825 return posix_error_with_allocated_filename(path
);
1830 #endif /* HAVE_LCHFLAGS */
1833 PyDoc_STRVAR(posix_chroot__doc__
,
1835 Change root directory to path.");
1838 posix_chroot(PyObject
*self
, PyObject
*args
)
1840 return posix_1str(args
, "et:chroot", chroot
);
1845 PyDoc_STRVAR(posix_fsync__doc__
,
1847 force write of file with filedescriptor to disk.");
1850 posix_fsync(PyObject
*self
, PyObject
*fdobj
)
1852 return posix_fildes(fdobj
, fsync
);
1854 #endif /* HAVE_FSYNC */
1856 #ifdef HAVE_FDATASYNC
1859 extern int fdatasync(int); /* On HP-UX, in libc but not in unistd.h */
1862 PyDoc_STRVAR(posix_fdatasync__doc__
,
1863 "fdatasync(fildes)\n\n\
1864 force write of file with filedescriptor to disk.\n\
1865 does not force update of metadata.");
1868 posix_fdatasync(PyObject
*self
, PyObject
*fdobj
)
1870 return posix_fildes(fdobj
, fdatasync
);
1872 #endif /* HAVE_FDATASYNC */
1876 PyDoc_STRVAR(posix_chown__doc__
,
1877 "chown(path, uid, gid)\n\n\
1878 Change the owner and group id of path to the numeric uid and gid.");
1881 posix_chown(PyObject
*self
, PyObject
*args
)
1886 if (!PyArg_ParseTuple(args
, "etll:chown",
1887 Py_FileSystemDefaultEncoding
, &path
,
1890 Py_BEGIN_ALLOW_THREADS
1891 res
= chown(path
, (uid_t
) uid
, (gid_t
) gid
);
1892 Py_END_ALLOW_THREADS
1894 return posix_error_with_allocated_filename(path
);
1899 #endif /* HAVE_CHOWN */
1902 PyDoc_STRVAR(posix_fchown__doc__
,
1903 "fchown(fd, uid, gid)\n\n\
1904 Change the owner and group id of the file given by file descriptor\n\
1905 fd to the numeric uid and gid.");
1908 posix_fchown(PyObject
*self
, PyObject
*args
)
1912 if (!PyArg_ParseTuple(args
, "iii:chown", &fd
, &uid
, &gid
))
1914 Py_BEGIN_ALLOW_THREADS
1915 res
= fchown(fd
, (uid_t
) uid
, (gid_t
) gid
);
1916 Py_END_ALLOW_THREADS
1918 return posix_error();
1921 #endif /* HAVE_FCHOWN */
1924 PyDoc_STRVAR(posix_lchown__doc__
,
1925 "lchown(path, uid, gid)\n\n\
1926 Change the owner and group id of path to the numeric uid and gid.\n\
1927 This function will not follow symbolic links.");
1930 posix_lchown(PyObject
*self
, PyObject
*args
)
1935 if (!PyArg_ParseTuple(args
, "etii:lchown",
1936 Py_FileSystemDefaultEncoding
, &path
,
1939 Py_BEGIN_ALLOW_THREADS
1940 res
= lchown(path
, (uid_t
) uid
, (gid_t
) gid
);
1941 Py_END_ALLOW_THREADS
1943 return posix_error_with_allocated_filename(path
);
1948 #endif /* HAVE_LCHOWN */
1952 PyDoc_STRVAR(posix_getcwd__doc__
,
1953 "getcwd() -> path\n\n\
1954 Return a string representing the current working directory.");
1957 posix_getcwd(PyObject
*self
, PyObject
*noargs
)
1962 Py_BEGIN_ALLOW_THREADS
1963 #if defined(PYOS_OS2) && defined(PYCC_GCC)
1964 res
= _getcwd2(buf
, sizeof buf
);
1966 res
= getcwd(buf
, sizeof buf
);
1968 Py_END_ALLOW_THREADS
1970 return posix_error();
1971 return PyString_FromString(buf
);
1974 #ifdef Py_USING_UNICODE
1975 PyDoc_STRVAR(posix_getcwdu__doc__
,
1976 "getcwdu() -> path\n\n\
1977 Return a unicode string representing the current working directory.");
1980 posix_getcwdu(PyObject
*self
, PyObject
*noargs
)
1985 #ifdef Py_WIN_WIDE_FILENAMES
1987 if (unicode_file_names()) {
1989 wchar_t *wbuf2
= wbuf
;
1991 Py_BEGIN_ALLOW_THREADS
1992 len
= GetCurrentDirectoryW(sizeof wbuf
/ sizeof wbuf
[0], wbuf
);
1993 /* If the buffer is large enough, len does not include the
1994 terminating \0. If the buffer is too small, len includes
1995 the space needed for the terminator. */
1996 if (len
>= sizeof wbuf
/ sizeof wbuf
[0]) {
1997 wbuf2
= malloc(len
* sizeof(wchar_t));
1999 len
= GetCurrentDirectoryW(len
, wbuf2
);
2001 Py_END_ALLOW_THREADS
2007 if (wbuf2
!= wbuf
) free(wbuf2
);
2008 return win32_error("getcwdu", NULL
);
2010 resobj
= PyUnicode_FromWideChar(wbuf2
, len
);
2011 if (wbuf2
!= wbuf
) free(wbuf2
);
2016 Py_BEGIN_ALLOW_THREADS
2017 #if defined(PYOS_OS2) && defined(PYCC_GCC)
2018 res
= _getcwd2(buf
, sizeof buf
);
2020 res
= getcwd(buf
, sizeof buf
);
2022 Py_END_ALLOW_THREADS
2024 return posix_error();
2025 return PyUnicode_Decode(buf
, strlen(buf
), Py_FileSystemDefaultEncoding
,"strict");
2032 PyDoc_STRVAR(posix_link__doc__
,
2033 "link(src, dst)\n\n\
2034 Create a hard link to a file.");
2037 posix_link(PyObject
*self
, PyObject
*args
)
2039 return posix_2str(args
, "etet:link", link
);
2041 #endif /* HAVE_LINK */
2044 PyDoc_STRVAR(posix_listdir__doc__
,
2045 "listdir(path) -> list_of_strings\n\n\
2046 Return a list containing the names of the entries in the directory.\n\
2048 path: path of directory to list\n\
2050 The list is in arbitrary order. It does not include the special\n\
2051 entries '.' and '..' even if they are present in the directory.");
2054 posix_listdir(PyObject
*self
, PyObject
*args
)
2056 /* XXX Should redo this putting the (now four) versions of opendir
2057 in separate files instead of having them all here... */
2058 #if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)
2063 WIN32_FIND_DATA FileData
;
2064 char namebuf
[MAX_PATH
+5]; /* Overallocate for \\*.*\0 */
2065 char *bufptr
= namebuf
;
2066 Py_ssize_t len
= sizeof(namebuf
)-5; /* only claim to have space for MAX_PATH */
2068 #ifdef Py_WIN_WIDE_FILENAMES
2069 /* If on wide-character-capable OS see if argument
2070 is Unicode and if so use wide API. */
2071 if (unicode_file_names()) {
2073 if (PyArg_ParseTuple(args
, "U:listdir", &po
)) {
2074 WIN32_FIND_DATAW wFileData
;
2075 Py_UNICODE
*wnamebuf
;
2077 /* Overallocate for \\*.*\0 */
2078 len
= PyUnicode_GET_SIZE(po
);
2079 wnamebuf
= malloc((len
+ 5) * sizeof(wchar_t));
2084 wcscpy(wnamebuf
, PyUnicode_AS_UNICODE(po
));
2085 wch
= len
> 0 ? wnamebuf
[len
-1] : '\0';
2086 if (wch
!= L
'/' && wch
!= L
'\\' && wch
!= L
':')
2087 wnamebuf
[len
++] = L
'\\';
2088 wcscpy(wnamebuf
+ len
, L
"*.*");
2089 if ((d
= PyList_New(0)) == NULL
) {
2093 hFindFile
= FindFirstFileW(wnamebuf
, &wFileData
);
2094 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2095 int error
= GetLastError();
2096 if (error
== ERROR_FILE_NOT_FOUND
) {
2101 win32_error_unicode("FindFirstFileW", wnamebuf
);
2106 /* Skip over . and .. */
2107 if (wcscmp(wFileData
.cFileName
, L
".") != 0 &&
2108 wcscmp(wFileData
.cFileName
, L
"..") != 0) {
2109 v
= PyUnicode_FromUnicode(wFileData
.cFileName
, wcslen(wFileData
.cFileName
));
2115 if (PyList_Append(d
, v
) != 0) {
2123 Py_BEGIN_ALLOW_THREADS
2124 result
= FindNextFileW(hFindFile
, &wFileData
);
2125 Py_END_ALLOW_THREADS
2126 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2127 it got to the end of the directory. */
2128 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2130 win32_error_unicode("FindNextFileW", wnamebuf
);
2131 FindClose(hFindFile
);
2135 } while (result
== TRUE
);
2137 if (FindClose(hFindFile
) == FALSE
) {
2139 win32_error_unicode("FindClose", wnamebuf
);
2146 /* Drop the argument parsing error as narrow strings
2152 if (!PyArg_ParseTuple(args
, "et#:listdir",
2153 Py_FileSystemDefaultEncoding
, &bufptr
, &len
))
2156 char ch
= namebuf
[len
-1];
2157 if (ch
!= SEP
&& ch
!= ALTSEP
&& ch
!= ':')
2158 namebuf
[len
++] = '/';
2160 strcpy(namebuf
+ len
, "*.*");
2162 if ((d
= PyList_New(0)) == NULL
)
2165 hFindFile
= FindFirstFile(namebuf
, &FileData
);
2166 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2167 int error
= GetLastError();
2168 if (error
== ERROR_FILE_NOT_FOUND
)
2171 return win32_error("FindFirstFile", namebuf
);
2174 /* Skip over . and .. */
2175 if (strcmp(FileData
.cFileName
, ".") != 0 &&
2176 strcmp(FileData
.cFileName
, "..") != 0) {
2177 v
= PyString_FromString(FileData
.cFileName
);
2183 if (PyList_Append(d
, v
) != 0) {
2191 Py_BEGIN_ALLOW_THREADS
2192 result
= FindNextFile(hFindFile
, &FileData
);
2193 Py_END_ALLOW_THREADS
2194 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2195 it got to the end of the directory. */
2196 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2198 win32_error("FindNextFile", namebuf
);
2199 FindClose(hFindFile
);
2202 } while (result
== TRUE
);
2204 if (FindClose(hFindFile
) == FALSE
) {
2206 return win32_error("FindClose", namebuf
);
2211 #elif defined(PYOS_OS2)
2214 #define MAX_PATH CCHMAXPATH
2219 char namebuf
[MAX_PATH
+5];
2225 if (!PyArg_ParseTuple(args
, "t#:listdir", &name
, &len
))
2227 if (len
>= MAX_PATH
) {
2228 PyErr_SetString(PyExc_ValueError
, "path too long");
2231 strcpy(namebuf
, name
);
2232 for (pt
= namebuf
; *pt
; pt
++)
2235 if (namebuf
[len
-1] != SEP
)
2236 namebuf
[len
++] = SEP
;
2237 strcpy(namebuf
+ len
, "*.*");
2239 if ((d
= PyList_New(0)) == NULL
)
2242 rc
= DosFindFirst(namebuf
, /* Wildcard Pattern to Match */
2243 &hdir
, /* Handle to Use While Search Directory */
2244 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
2245 &ep
, sizeof(ep
), /* Structure to Receive Directory Entry */
2246 &srchcnt
, /* Max and Actual Count of Entries Per Iteration */
2247 FIL_STANDARD
); /* Format of Entry (EAs or Not) */
2249 if (rc
!= NO_ERROR
) {
2251 return posix_error_with_filename(name
);
2254 if (srchcnt
> 0) { /* If Directory is NOT Totally Empty, */
2256 if (ep
.achName
[0] == '.'
2257 && (ep
.achName
[1] == '\0' || (ep
.achName
[1] == '.' && ep
.achName
[2] == '\0')))
2258 continue; /* Skip Over "." and ".." Names */
2260 strcpy(namebuf
, ep
.achName
);
2262 /* Leave Case of Name Alone -- In Native Form */
2263 /* (Removed Forced Lowercasing Code) */
2265 v
= PyString_FromString(namebuf
);
2271 if (PyList_Append(d
, v
) != 0) {
2278 } while (DosFindNext(hdir
, &ep
, sizeof(ep
), &srchcnt
) == NO_ERROR
&& srchcnt
> 0);
2288 int arg_is_unicode
= 1;
2291 if (!PyArg_ParseTuple(args
, "U:listdir", &v
)) {
2295 if (!PyArg_ParseTuple(args
, "et:listdir", Py_FileSystemDefaultEncoding
, &name
))
2297 if ((dirp
= opendir(name
)) == NULL
) {
2298 return posix_error_with_allocated_filename(name
);
2300 if ((d
= PyList_New(0)) == NULL
) {
2306 Py_BEGIN_ALLOW_THREADS
2308 Py_END_ALLOW_THREADS
2311 if (ep
->d_name
[0] == '.' &&
2313 (ep
->d_name
[1] == '.' && NAMLEN(ep
) == 2)))
2315 v
= PyString_FromStringAndSize(ep
->d_name
, NAMLEN(ep
));
2321 #ifdef Py_USING_UNICODE
2322 if (arg_is_unicode
) {
2325 w
= PyUnicode_FromEncodedObject(v
,
2326 Py_FileSystemDefaultEncoding
,
2333 /* fall back to the original byte string, as
2334 discussed in patch #683592 */
2339 if (PyList_Append(d
, v
) != 0) {
2347 if (errno
!= 0 && d
!= NULL
) {
2348 /* readdir() returned NULL and set errno */
2351 return posix_error_with_allocated_filename(name
);
2358 #endif /* which OS */
2359 } /* end of posix_listdir */
2362 /* A helper function for abspath on win32 */
2364 posix__getfullpathname(PyObject
*self
, PyObject
*args
)
2366 /* assume encoded strings wont more than double no of chars */
2367 char inbuf
[MAX_PATH
*2];
2368 char *inbufp
= inbuf
;
2369 Py_ssize_t insize
= sizeof(inbuf
);
2370 char outbuf
[MAX_PATH
*2];
2372 #ifdef Py_WIN_WIDE_FILENAMES
2373 if (unicode_file_names()) {
2374 PyUnicodeObject
*po
;
2375 if (PyArg_ParseTuple(args
, "U|:_getfullpathname", &po
)) {
2376 Py_UNICODE woutbuf
[MAX_PATH
*2];
2378 if (!GetFullPathNameW(PyUnicode_AS_UNICODE(po
),
2379 sizeof(woutbuf
)/sizeof(woutbuf
[0]),
2381 return win32_error("GetFullPathName", "");
2382 return PyUnicode_FromUnicode(woutbuf
, wcslen(woutbuf
));
2384 /* Drop the argument parsing error as narrow strings
2389 if (!PyArg_ParseTuple (args
, "et#:_getfullpathname",
2390 Py_FileSystemDefaultEncoding
, &inbufp
,
2393 if (!GetFullPathName(inbuf
, sizeof(outbuf
)/sizeof(outbuf
[0]),
2395 return win32_error("GetFullPathName", inbuf
);
2396 if (PyUnicode_Check(PyTuple_GetItem(args
, 0))) {
2397 return PyUnicode_Decode(outbuf
, strlen(outbuf
),
2398 Py_FileSystemDefaultEncoding
, NULL
);
2400 return PyString_FromString(outbuf
);
2401 } /* end of posix__getfullpathname */
2402 #endif /* MS_WINDOWS */
2404 PyDoc_STRVAR(posix_mkdir__doc__
,
2405 "mkdir(path [, mode=0777])\n\n\
2406 Create a directory.");
2409 posix_mkdir(PyObject
*self
, PyObject
*args
)
2415 #ifdef Py_WIN_WIDE_FILENAMES
2416 if (unicode_file_names()) {
2417 PyUnicodeObject
*po
;
2418 if (PyArg_ParseTuple(args
, "U|i:mkdir", &po
, &mode
)) {
2419 Py_BEGIN_ALLOW_THREADS
2420 /* PyUnicode_AS_UNICODE OK without thread lock as
2421 it is a simple dereference. */
2422 res
= CreateDirectoryW(PyUnicode_AS_UNICODE(po
), NULL
);
2423 Py_END_ALLOW_THREADS
2425 return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po
));
2429 /* Drop the argument parsing error as narrow strings
2433 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2434 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2436 Py_BEGIN_ALLOW_THREADS
2437 /* PyUnicode_AS_UNICODE OK without thread lock as
2438 it is a simple dereference. */
2439 res
= CreateDirectoryA(path
, NULL
);
2440 Py_END_ALLOW_THREADS
2442 win32_error("mkdir", path
);
2451 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2452 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2454 Py_BEGIN_ALLOW_THREADS
2455 #if ( defined(__WATCOMC__) || defined(PYCC_VACPP) ) && !defined(__QNX__)
2458 res
= mkdir(path
, mode
);
2460 Py_END_ALLOW_THREADS
2462 return posix_error_with_allocated_filename(path
);
2470 /* sys/resource.h is needed for at least: wait3(), wait4(), broken nice. */
2471 #if defined(HAVE_SYS_RESOURCE_H)
2472 #include <sys/resource.h>
2477 PyDoc_STRVAR(posix_nice__doc__
,
2478 "nice(inc) -> new_priority\n\n\
2479 Decrease the priority of process by inc and return the new priority.");
2482 posix_nice(PyObject
*self
, PyObject
*args
)
2484 int increment
, value
;
2486 if (!PyArg_ParseTuple(args
, "i:nice", &increment
))
2489 /* There are two flavours of 'nice': one that returns the new
2490 priority (as required by almost all standards out there) and the
2491 Linux/FreeBSD/BSDI one, which returns '0' on success and advices
2492 the use of getpriority() to get the new priority.
2494 If we are of the nice family that returns the new priority, we
2495 need to clear errno before the call, and check if errno is filled
2496 before calling posix_error() on a returnvalue of -1, because the
2497 -1 may be the actual new priority! */
2500 value
= nice(increment
);
2501 #if defined(HAVE_BROKEN_NICE) && defined(HAVE_GETPRIORITY)
2503 value
= getpriority(PRIO_PROCESS
, 0);
2505 if (value
== -1 && errno
!= 0)
2506 /* either nice() or getpriority() returned an error */
2507 return posix_error();
2508 return PyInt_FromLong((long) value
);
2510 #endif /* HAVE_NICE */
2512 PyDoc_STRVAR(posix_rename__doc__
,
2513 "rename(old, new)\n\n\
2514 Rename a file or directory.");
2517 posix_rename(PyObject
*self
, PyObject
*args
)
2523 if (unicode_file_names()) {
2524 if (!PyArg_ParseTuple(args
, "O&O&:rename",
2525 convert_to_unicode
, &o1
,
2526 convert_to_unicode
, &o2
))
2529 Py_BEGIN_ALLOW_THREADS
2530 result
= MoveFileW(PyUnicode_AsUnicode(o1
),
2531 PyUnicode_AsUnicode(o2
));
2532 Py_END_ALLOW_THREADS
2536 return win32_error("rename", NULL
);
2541 if (!PyArg_ParseTuple(args
, "ss:rename", &p1
, &p2
))
2543 Py_BEGIN_ALLOW_THREADS
2544 result
= MoveFileA(p1
, p2
);
2545 Py_END_ALLOW_THREADS
2547 return win32_error("rename", NULL
);
2551 return posix_2str(args
, "etet:rename", rename
);
2556 PyDoc_STRVAR(posix_rmdir__doc__
,
2558 Remove a directory.");
2561 posix_rmdir(PyObject
*self
, PyObject
*args
)
2564 return win32_1str(args
, "rmdir", "s:rmdir", RemoveDirectoryA
, "U:rmdir", RemoveDirectoryW
);
2566 return posix_1str(args
, "et:rmdir", rmdir
);
2571 PyDoc_STRVAR(posix_stat__doc__
,
2572 "stat(path) -> stat result\n\n\
2573 Perform a stat system call on the given path.");
2576 posix_stat(PyObject
*self
, PyObject
*args
)
2579 return posix_do_stat(self
, args
, "et:stat", STAT
, "U:stat", win32_wstat
);
2581 return posix_do_stat(self
, args
, "et:stat", STAT
, NULL
, NULL
);
2587 PyDoc_STRVAR(posix_system__doc__
,
2588 "system(command) -> exit_status\n\n\
2589 Execute the command (a string) in a subshell.");
2592 posix_system(PyObject
*self
, PyObject
*args
)
2596 if (!PyArg_ParseTuple(args
, "s:system", &command
))
2598 Py_BEGIN_ALLOW_THREADS
2599 sts
= system(command
);
2600 Py_END_ALLOW_THREADS
2601 return PyInt_FromLong(sts
);
2606 PyDoc_STRVAR(posix_umask__doc__
,
2607 "umask(new_mask) -> old_mask\n\n\
2608 Set the current numeric umask and return the previous umask.");
2611 posix_umask(PyObject
*self
, PyObject
*args
)
2614 if (!PyArg_ParseTuple(args
, "i:umask", &i
))
2618 return posix_error();
2619 return PyInt_FromLong((long)i
);
2623 PyDoc_STRVAR(posix_unlink__doc__
,
2625 Remove a file (same as remove(path)).");
2627 PyDoc_STRVAR(posix_remove__doc__
,
2629 Remove a file (same as unlink(path)).");
2632 posix_unlink(PyObject
*self
, PyObject
*args
)
2635 return win32_1str(args
, "remove", "s:remove", DeleteFileA
, "U:remove", DeleteFileW
);
2637 return posix_1str(args
, "et:remove", unlink
);
2643 PyDoc_STRVAR(posix_uname__doc__
,
2644 "uname() -> (sysname, nodename, release, version, machine)\n\n\
2645 Return a tuple identifying the current operating system.");
2648 posix_uname(PyObject
*self
, PyObject
*noargs
)
2653 Py_BEGIN_ALLOW_THREADS
2655 Py_END_ALLOW_THREADS
2657 return posix_error();
2658 return Py_BuildValue("(sssss)",
2665 #endif /* HAVE_UNAME */
2668 extract_time(PyObject
*t
, long* sec
, long* usec
)
2671 if (PyFloat_Check(t
)) {
2672 double tval
= PyFloat_AsDouble(t
);
2673 PyObject
*intobj
= Py_TYPE(t
)->tp_as_number
->nb_int(t
);
2676 intval
= PyInt_AsLong(intobj
);
2678 if (intval
== -1 && PyErr_Occurred())
2681 *usec
= (long)((tval
- intval
) * 1e6
); /* can't exceed 1000000 */
2683 /* If rounding gave us a negative number,
2688 intval
= PyInt_AsLong(t
);
2689 if (intval
== -1 && PyErr_Occurred())
2696 PyDoc_STRVAR(posix_utime__doc__
,
2697 "utime(path, (atime, mtime))\n\
2698 utime(path, None)\n\n\
2699 Set the access and modified time of the file to the given values. If the\n\
2700 second form is used, set the access and modified times to the current time.");
2703 posix_utime(PyObject
*self
, PyObject
*args
)
2705 #ifdef Py_WIN_WIDE_FILENAMES
2707 PyUnicodeObject
*obwpath
;
2708 wchar_t *wpath
= NULL
;
2711 long atimesec
, mtimesec
, ausec
, musec
;
2712 FILETIME atime
, mtime
;
2713 PyObject
*result
= NULL
;
2715 if (unicode_file_names()) {
2716 if (PyArg_ParseTuple(args
, "UO|:utime", &obwpath
, &arg
)) {
2717 wpath
= PyUnicode_AS_UNICODE(obwpath
);
2718 Py_BEGIN_ALLOW_THREADS
2719 hFile
= CreateFileW(wpath
, FILE_WRITE_ATTRIBUTES
, 0,
2720 NULL
, OPEN_EXISTING
,
2721 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2722 Py_END_ALLOW_THREADS
2723 if (hFile
== INVALID_HANDLE_VALUE
)
2724 return win32_error_unicode("utime", wpath
);
2726 /* Drop the argument parsing error as narrow strings
2731 if (!PyArg_ParseTuple(args
, "etO:utime",
2732 Py_FileSystemDefaultEncoding
, &apath
, &arg
))
2734 Py_BEGIN_ALLOW_THREADS
2735 hFile
= CreateFileA(apath
, FILE_WRITE_ATTRIBUTES
, 0,
2736 NULL
, OPEN_EXISTING
,
2737 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2738 Py_END_ALLOW_THREADS
2739 if (hFile
== INVALID_HANDLE_VALUE
) {
2740 win32_error("utime", apath
);
2747 if (arg
== Py_None
) {
2749 GetSystemTime(&now
);
2750 if (!SystemTimeToFileTime(&now
, &mtime
) ||
2751 !SystemTimeToFileTime(&now
, &atime
)) {
2752 win32_error("utime", NULL
);
2756 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2757 PyErr_SetString(PyExc_TypeError
,
2758 "utime() arg 2 must be a tuple (atime, mtime)");
2762 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2763 &atimesec
, &ausec
) == -1)
2765 time_t_to_FILE_TIME(atimesec
, 1000*ausec
, &atime
);
2766 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2767 &mtimesec
, &musec
) == -1)
2769 time_t_to_FILE_TIME(mtimesec
, 1000*musec
, &mtime
);
2771 if (!SetFileTime(hFile
, NULL
, &atime
, &mtime
)) {
2772 /* Avoid putting the file name into the error here,
2773 as that may confuse the user into believing that
2774 something is wrong with the file, when it also
2775 could be the time stamp that gives a problem. */
2776 win32_error("utime", NULL
);
2783 #else /* Py_WIN_WIDE_FILENAMES */
2786 long atime
, mtime
, ausec
, musec
;
2790 #if defined(HAVE_UTIMES)
2791 struct timeval buf
[2];
2792 #define ATIME buf[0].tv_sec
2793 #define MTIME buf[1].tv_sec
2794 #elif defined(HAVE_UTIME_H)
2795 /* XXX should define struct utimbuf instead, above */
2797 #define ATIME buf.actime
2798 #define MTIME buf.modtime
2799 #define UTIME_ARG &buf
2800 #else /* HAVE_UTIMES */
2802 #define ATIME buf[0]
2803 #define MTIME buf[1]
2804 #define UTIME_ARG buf
2805 #endif /* HAVE_UTIMES */
2808 if (!PyArg_ParseTuple(args
, "etO:utime",
2809 Py_FileSystemDefaultEncoding
, &path
, &arg
))
2811 if (arg
== Py_None
) {
2812 /* optional time values not given */
2813 Py_BEGIN_ALLOW_THREADS
2814 res
= utime(path
, NULL
);
2815 Py_END_ALLOW_THREADS
2817 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2818 PyErr_SetString(PyExc_TypeError
,
2819 "utime() arg 2 must be a tuple (atime, mtime)");
2824 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2825 &atime
, &ausec
) == -1) {
2829 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2830 &mtime
, &musec
) == -1) {
2837 buf
[0].tv_usec
= ausec
;
2838 buf
[1].tv_usec
= musec
;
2839 Py_BEGIN_ALLOW_THREADS
2840 res
= utimes(path
, buf
);
2841 Py_END_ALLOW_THREADS
2843 Py_BEGIN_ALLOW_THREADS
2844 res
= utime(path
, UTIME_ARG
);
2845 Py_END_ALLOW_THREADS
2846 #endif /* HAVE_UTIMES */
2849 return posix_error_with_allocated_filename(path
);
2857 #endif /* Py_WIN_WIDE_FILENAMES */
2861 /* Process operations */
2863 PyDoc_STRVAR(posix__exit__doc__
,
2865 Exit to the system with specified status, without normal exit processing.");
2868 posix__exit(PyObject
*self
, PyObject
*args
)
2871 if (!PyArg_ParseTuple(args
, "i:_exit", &sts
))
2874 return NULL
; /* Make gcc -Wall happy */
2877 #if defined(HAVE_EXECV) || defined(HAVE_SPAWNV)
2879 free_string_array(char **array
, Py_ssize_t count
)
2882 for (i
= 0; i
< count
; i
++)
2883 PyMem_Free(array
[i
]);
2890 PyDoc_STRVAR(posix_execv__doc__
,
2891 "execv(path, args)\n\n\
2892 Execute an executable path with arguments, replacing current process.\n\
2894 path: path of executable file\n\
2895 args: tuple or list of strings");
2898 posix_execv(PyObject
*self
, PyObject
*args
)
2904 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
2906 /* execv has two arguments: (path, argv), where
2907 argv is a list or tuple of strings. */
2909 if (!PyArg_ParseTuple(args
, "etO:execv",
2910 Py_FileSystemDefaultEncoding
,
2913 if (PyList_Check(argv
)) {
2914 argc
= PyList_Size(argv
);
2915 getitem
= PyList_GetItem
;
2917 else if (PyTuple_Check(argv
)) {
2918 argc
= PyTuple_Size(argv
);
2919 getitem
= PyTuple_GetItem
;
2922 PyErr_SetString(PyExc_TypeError
, "execv() arg 2 must be a tuple or list");
2927 argvlist
= PyMem_NEW(char *, argc
+1);
2928 if (argvlist
== NULL
) {
2930 return PyErr_NoMemory();
2932 for (i
= 0; i
< argc
; i
++) {
2933 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
2934 Py_FileSystemDefaultEncoding
,
2936 free_string_array(argvlist
, i
);
2937 PyErr_SetString(PyExc_TypeError
,
2938 "execv() arg 2 must contain only strings");
2944 argvlist
[argc
] = NULL
;
2946 execv(path
, argvlist
);
2948 /* If we get here it's definitely an error */
2950 free_string_array(argvlist
, argc
);
2952 return posix_error();
2956 PyDoc_STRVAR(posix_execve__doc__
,
2957 "execve(path, args, env)\n\n\
2958 Execute a path with arguments and environment, replacing current process.\n\
2960 path: path of executable file\n\
2961 args: tuple or list of arguments\n\
2962 env: dictionary of strings mapping to strings");
2965 posix_execve(PyObject
*self
, PyObject
*args
)
2968 PyObject
*argv
, *env
;
2971 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
;
2972 Py_ssize_t i
, pos
, argc
, envc
;
2973 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
2974 Py_ssize_t lastarg
= 0;
2976 /* execve has three arguments: (path, argv, env), where
2977 argv is a list or tuple of strings and env is a dictionary
2978 like posix.environ. */
2980 if (!PyArg_ParseTuple(args
, "etOO:execve",
2981 Py_FileSystemDefaultEncoding
,
2982 &path
, &argv
, &env
))
2984 if (PyList_Check(argv
)) {
2985 argc
= PyList_Size(argv
);
2986 getitem
= PyList_GetItem
;
2988 else if (PyTuple_Check(argv
)) {
2989 argc
= PyTuple_Size(argv
);
2990 getitem
= PyTuple_GetItem
;
2993 PyErr_SetString(PyExc_TypeError
,
2994 "execve() arg 2 must be a tuple or list");
2997 if (!PyMapping_Check(env
)) {
2998 PyErr_SetString(PyExc_TypeError
,
2999 "execve() arg 3 must be a mapping object");
3003 argvlist
= PyMem_NEW(char *, argc
+1);
3004 if (argvlist
== NULL
) {
3008 for (i
= 0; i
< argc
; i
++) {
3009 if (!PyArg_Parse((*getitem
)(argv
, i
),
3010 "et;execve() arg 2 must contain only strings",
3011 Py_FileSystemDefaultEncoding
,
3019 argvlist
[argc
] = NULL
;
3021 i
= PyMapping_Size(env
);
3024 envlist
= PyMem_NEW(char *, i
+ 1);
3025 if (envlist
== NULL
) {
3030 keys
= PyMapping_Keys(env
);
3031 vals
= PyMapping_Values(env
);
3034 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3035 PyErr_SetString(PyExc_TypeError
,
3036 "execve(): env.keys() or env.values() is not a list");
3040 for (pos
= 0; pos
< i
; pos
++) {
3044 key
= PyList_GetItem(keys
, pos
);
3045 val
= PyList_GetItem(vals
, pos
);
3051 "s;execve() arg 3 contains a non-string key",
3055 "s;execve() arg 3 contains a non-string value",
3061 #if defined(PYOS_OS2)
3062 /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
3063 if (stricmp(k
, "BEGINLIBPATH") != 0 && stricmp(k
, "ENDLIBPATH") != 0) {
3065 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3066 p
= PyMem_NEW(char, len
);
3071 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3072 envlist
[envc
++] = p
;
3073 #if defined(PYOS_OS2)
3079 execve(path
, argvlist
, envlist
);
3081 /* If we get here it's definitely an error */
3083 (void) posix_error();
3087 PyMem_DEL(envlist
[envc
]);
3090 free_string_array(argvlist
, lastarg
);
3097 #endif /* HAVE_EXECV */
3101 PyDoc_STRVAR(posix_spawnv__doc__
,
3102 "spawnv(mode, path, args)\n\n\
3103 Execute the program 'path' in a new process.\n\
3105 mode: mode of process creation\n\
3106 path: path of executable file\n\
3107 args: tuple or list of strings");
3110 posix_spawnv(PyObject
*self
, PyObject
*args
)
3117 Py_intptr_t spawnval
;
3118 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3120 /* spawnv has three arguments: (mode, path, argv), where
3121 argv is a list or tuple of strings. */
3123 if (!PyArg_ParseTuple(args
, "ietO:spawnv", &mode
,
3124 Py_FileSystemDefaultEncoding
,
3127 if (PyList_Check(argv
)) {
3128 argc
= PyList_Size(argv
);
3129 getitem
= PyList_GetItem
;
3131 else if (PyTuple_Check(argv
)) {
3132 argc
= PyTuple_Size(argv
);
3133 getitem
= PyTuple_GetItem
;
3136 PyErr_SetString(PyExc_TypeError
,
3137 "spawnv() arg 2 must be a tuple or list");
3142 argvlist
= PyMem_NEW(char *, argc
+1);
3143 if (argvlist
== NULL
) {
3145 return PyErr_NoMemory();
3147 for (i
= 0; i
< argc
; i
++) {
3148 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3149 Py_FileSystemDefaultEncoding
,
3151 free_string_array(argvlist
, i
);
3154 "spawnv() arg 2 must contain only strings");
3159 argvlist
[argc
] = NULL
;
3161 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3162 Py_BEGIN_ALLOW_THREADS
3163 spawnval
= spawnv(mode
, path
, argvlist
);
3164 Py_END_ALLOW_THREADS
3166 if (mode
== _OLD_P_OVERLAY
)
3169 Py_BEGIN_ALLOW_THREADS
3170 spawnval
= _spawnv(mode
, path
, argvlist
);
3171 Py_END_ALLOW_THREADS
3174 free_string_array(argvlist
, argc
);
3178 return posix_error();
3180 #if SIZEOF_LONG == SIZEOF_VOID_P
3181 return Py_BuildValue("l", (long) spawnval
);
3183 return Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3188 PyDoc_STRVAR(posix_spawnve__doc__
,
3189 "spawnve(mode, path, args, env)\n\n\
3190 Execute the program 'path' in a new process.\n\
3192 mode: mode of process creation\n\
3193 path: path of executable file\n\
3194 args: tuple or list of arguments\n\
3195 env: dictionary of strings mapping to strings");
3198 posix_spawnve(PyObject
*self
, PyObject
*args
)
3201 PyObject
*argv
, *env
;
3204 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3205 int mode
, pos
, envc
;
3207 Py_intptr_t spawnval
;
3208 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3209 Py_ssize_t lastarg
= 0;
3211 /* spawnve has four arguments: (mode, path, argv, env), where
3212 argv is a list or tuple of strings and env is a dictionary
3213 like posix.environ. */
3215 if (!PyArg_ParseTuple(args
, "ietOO:spawnve", &mode
,
3216 Py_FileSystemDefaultEncoding
,
3217 &path
, &argv
, &env
))
3219 if (PyList_Check(argv
)) {
3220 argc
= PyList_Size(argv
);
3221 getitem
= PyList_GetItem
;
3223 else if (PyTuple_Check(argv
)) {
3224 argc
= PyTuple_Size(argv
);
3225 getitem
= PyTuple_GetItem
;
3228 PyErr_SetString(PyExc_TypeError
,
3229 "spawnve() arg 2 must be a tuple or list");
3232 if (!PyMapping_Check(env
)) {
3233 PyErr_SetString(PyExc_TypeError
,
3234 "spawnve() arg 3 must be a mapping object");
3238 argvlist
= PyMem_NEW(char *, argc
+1);
3239 if (argvlist
== NULL
) {
3243 for (i
= 0; i
< argc
; i
++) {
3244 if (!PyArg_Parse((*getitem
)(argv
, i
),
3245 "et;spawnve() arg 2 must contain only strings",
3246 Py_FileSystemDefaultEncoding
,
3254 argvlist
[argc
] = NULL
;
3256 i
= PyMapping_Size(env
);
3259 envlist
= PyMem_NEW(char *, i
+ 1);
3260 if (envlist
== NULL
) {
3265 keys
= PyMapping_Keys(env
);
3266 vals
= PyMapping_Values(env
);
3269 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3270 PyErr_SetString(PyExc_TypeError
,
3271 "spawnve(): env.keys() or env.values() is not a list");
3275 for (pos
= 0; pos
< i
; pos
++) {
3279 key
= PyList_GetItem(keys
, pos
);
3280 val
= PyList_GetItem(vals
, pos
);
3286 "s;spawnve() arg 3 contains a non-string key",
3290 "s;spawnve() arg 3 contains a non-string value",
3295 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3296 p
= PyMem_NEW(char, len
);
3301 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3302 envlist
[envc
++] = p
;
3306 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3307 Py_BEGIN_ALLOW_THREADS
3308 spawnval
= spawnve(mode
, path
, argvlist
, envlist
);
3309 Py_END_ALLOW_THREADS
3311 if (mode
== _OLD_P_OVERLAY
)
3314 Py_BEGIN_ALLOW_THREADS
3315 spawnval
= _spawnve(mode
, path
, argvlist
, envlist
);
3316 Py_END_ALLOW_THREADS
3320 (void) posix_error();
3322 #if SIZEOF_LONG == SIZEOF_VOID_P
3323 res
= Py_BuildValue("l", (long) spawnval
);
3325 res
= Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3330 PyMem_DEL(envlist
[envc
]);
3333 free_string_array(argvlist
, lastarg
);
3341 /* OS/2 supports spawnvp & spawnvpe natively */
3342 #if defined(PYOS_OS2)
3343 PyDoc_STRVAR(posix_spawnvp__doc__
,
3344 "spawnvp(mode, file, args)\n\n\
3345 Execute the program 'file' in a new process, using the environment\n\
3346 search path to find the file.\n\
3348 mode: mode of process creation\n\
3349 file: executable file name\n\
3350 args: tuple or list of strings");
3353 posix_spawnvp(PyObject
*self
, PyObject
*args
)
3359 Py_intptr_t spawnval
;
3360 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3362 /* spawnvp has three arguments: (mode, path, argv), where
3363 argv is a list or tuple of strings. */
3365 if (!PyArg_ParseTuple(args
, "ietO:spawnvp", &mode
,
3366 Py_FileSystemDefaultEncoding
,
3369 if (PyList_Check(argv
)) {
3370 argc
= PyList_Size(argv
);
3371 getitem
= PyList_GetItem
;
3373 else if (PyTuple_Check(argv
)) {
3374 argc
= PyTuple_Size(argv
);
3375 getitem
= PyTuple_GetItem
;
3378 PyErr_SetString(PyExc_TypeError
,
3379 "spawnvp() arg 2 must be a tuple or list");
3384 argvlist
= PyMem_NEW(char *, argc
+1);
3385 if (argvlist
== NULL
) {
3387 return PyErr_NoMemory();
3389 for (i
= 0; i
< argc
; i
++) {
3390 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3391 Py_FileSystemDefaultEncoding
,
3393 free_string_array(argvlist
, i
);
3396 "spawnvp() arg 2 must contain only strings");
3401 argvlist
[argc
] = NULL
;
3403 Py_BEGIN_ALLOW_THREADS
3404 #if defined(PYCC_GCC)
3405 spawnval
= spawnvp(mode
, path
, argvlist
);
3407 spawnval
= _spawnvp(mode
, path
, argvlist
);
3409 Py_END_ALLOW_THREADS
3411 free_string_array(argvlist
, argc
);
3415 return posix_error();
3417 return Py_BuildValue("l", (long) spawnval
);
3421 PyDoc_STRVAR(posix_spawnvpe__doc__
,
3422 "spawnvpe(mode, file, args, env)\n\n\
3423 Execute the program 'file' in a new process, using the environment\n\
3424 search path to find the file.\n\
3426 mode: mode of process creation\n\
3427 file: executable file name\n\
3428 args: tuple or list of arguments\n\
3429 env: dictionary of strings mapping to strings");
3432 posix_spawnvpe(PyObject
*self
, PyObject
*args
)
3435 PyObject
*argv
, *env
;
3438 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3439 int mode
, i
, pos
, argc
, envc
;
3440 Py_intptr_t spawnval
;
3441 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3444 /* spawnvpe has four arguments: (mode, path, argv, env), where
3445 argv is a list or tuple of strings and env is a dictionary
3446 like posix.environ. */
3448 if (!PyArg_ParseTuple(args
, "ietOO:spawnvpe", &mode
,
3449 Py_FileSystemDefaultEncoding
,
3450 &path
, &argv
, &env
))
3452 if (PyList_Check(argv
)) {
3453 argc
= PyList_Size(argv
);
3454 getitem
= PyList_GetItem
;
3456 else if (PyTuple_Check(argv
)) {
3457 argc
= PyTuple_Size(argv
);
3458 getitem
= PyTuple_GetItem
;
3461 PyErr_SetString(PyExc_TypeError
,
3462 "spawnvpe() arg 2 must be a tuple or list");
3465 if (!PyMapping_Check(env
)) {
3466 PyErr_SetString(PyExc_TypeError
,
3467 "spawnvpe() arg 3 must be a mapping object");
3471 argvlist
= PyMem_NEW(char *, argc
+1);
3472 if (argvlist
== NULL
) {
3476 for (i
= 0; i
< argc
; i
++) {
3477 if (!PyArg_Parse((*getitem
)(argv
, i
),
3478 "et;spawnvpe() arg 2 must contain only strings",
3479 Py_FileSystemDefaultEncoding
,
3487 argvlist
[argc
] = NULL
;
3489 i
= PyMapping_Size(env
);
3492 envlist
= PyMem_NEW(char *, i
+ 1);
3493 if (envlist
== NULL
) {
3498 keys
= PyMapping_Keys(env
);
3499 vals
= PyMapping_Values(env
);
3502 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3503 PyErr_SetString(PyExc_TypeError
,
3504 "spawnvpe(): env.keys() or env.values() is not a list");
3508 for (pos
= 0; pos
< i
; pos
++) {
3512 key
= PyList_GetItem(keys
, pos
);
3513 val
= PyList_GetItem(vals
, pos
);
3519 "s;spawnvpe() arg 3 contains a non-string key",
3523 "s;spawnvpe() arg 3 contains a non-string value",
3528 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3529 p
= PyMem_NEW(char, len
);
3534 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3535 envlist
[envc
++] = p
;
3539 Py_BEGIN_ALLOW_THREADS
3540 #if defined(PYCC_GCC)
3541 spawnval
= spawnvpe(mode
, path
, argvlist
, envlist
);
3543 spawnval
= _spawnvpe(mode
, path
, argvlist
, envlist
);
3545 Py_END_ALLOW_THREADS
3548 (void) posix_error();
3550 res
= Py_BuildValue("l", (long) spawnval
);
3554 PyMem_DEL(envlist
[envc
]);
3557 free_string_array(argvlist
, lastarg
);
3564 #endif /* PYOS_OS2 */
3565 #endif /* HAVE_SPAWNV */
3569 PyDoc_STRVAR(posix_fork1__doc__
,
3570 "fork1() -> pid\n\n\
3571 Fork a child process with a single multiplexed (i.e., not bound) thread.\n\
3573 Return 0 to child process and PID of child to parent process.");
3576 posix_fork1(PyObject
*self
, PyObject
*noargs
)
3578 pid_t pid
= fork1();
3580 return posix_error();
3582 return PyInt_FromLong(pid
);
3588 PyDoc_STRVAR(posix_fork__doc__
,
3590 Fork a child process.\n\
3591 Return 0 to child process and PID of child to parent process.");
3594 posix_fork(PyObject
*self
, PyObject
*noargs
)
3598 return posix_error();
3601 return PyInt_FromLong(pid
);
3605 /* AIX uses /dev/ptc but is otherwise the same as /dev/ptmx */
3606 /* IRIX has both /dev/ptc and /dev/ptmx, use ptmx */
3607 #if defined(HAVE_DEV_PTC) && !defined(HAVE_DEV_PTMX)
3608 #define DEV_PTY_FILE "/dev/ptc"
3609 #define HAVE_DEV_PTMX
3611 #define DEV_PTY_FILE "/dev/ptmx"
3614 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX)
3618 #ifdef HAVE_LIBUTIL_H
3619 #include <libutil.h>
3620 #endif /* HAVE_LIBUTIL_H */
3621 #endif /* HAVE_PTY_H */
3622 #ifdef HAVE_STROPTS_H
3623 #include <stropts.h>
3625 #endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX */
3627 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
3628 PyDoc_STRVAR(posix_openpty__doc__
,
3629 "openpty() -> (master_fd, slave_fd)\n\n\
3630 Open a pseudo-terminal, returning open fd's for both master and slave end.\n");
3633 posix_openpty(PyObject
*self
, PyObject
*noargs
)
3635 int master_fd
, slave_fd
;
3636 #ifndef HAVE_OPENPTY
3639 #if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)
3640 PyOS_sighandler_t sig_saved
;
3642 extern char *ptsname(int fildes
);
3647 if (openpty(&master_fd
, &slave_fd
, NULL
, NULL
, NULL
) != 0)
3648 return posix_error();
3649 #elif defined(HAVE__GETPTY)
3650 slave_name
= _getpty(&master_fd
, O_RDWR
, 0666, 0);
3651 if (slave_name
== NULL
)
3652 return posix_error();
3654 slave_fd
= open(slave_name
, O_RDWR
);
3656 return posix_error();
3658 master_fd
= open(DEV_PTY_FILE
, O_RDWR
| O_NOCTTY
); /* open master */
3660 return posix_error();
3661 sig_saved
= PyOS_setsig(SIGCHLD
, SIG_DFL
);
3662 /* change permission of slave */
3663 if (grantpt(master_fd
) < 0) {
3664 PyOS_setsig(SIGCHLD
, sig_saved
);
3665 return posix_error();
3668 if (unlockpt(master_fd
) < 0) {
3669 PyOS_setsig(SIGCHLD
, sig_saved
);
3670 return posix_error();
3672 PyOS_setsig(SIGCHLD
, sig_saved
);
3673 slave_name
= ptsname(master_fd
); /* get name of slave */
3674 if (slave_name
== NULL
)
3675 return posix_error();
3676 slave_fd
= open(slave_name
, O_RDWR
| O_NOCTTY
); /* open slave */
3678 return posix_error();
3679 #if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)
3680 ioctl(slave_fd
, I_PUSH
, "ptem"); /* push ptem */
3681 ioctl(slave_fd
, I_PUSH
, "ldterm"); /* push ldterm */
3683 ioctl(slave_fd
, I_PUSH
, "ttcompat"); /* push ttcompat */
3685 #endif /* HAVE_CYGWIN */
3686 #endif /* HAVE_OPENPTY */
3688 return Py_BuildValue("(ii)", master_fd
, slave_fd
);
3691 #endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */
3694 PyDoc_STRVAR(posix_forkpty__doc__
,
3695 "forkpty() -> (pid, master_fd)\n\n\
3696 Fork a new process with a new pseudo-terminal as controlling tty.\n\n\
3697 Like fork(), return 0 as pid to child process, and PID of child to parent.\n\
3698 To both, return fd of newly opened pseudo-terminal.\n");
3701 posix_forkpty(PyObject
*self
, PyObject
*noargs
)
3706 pid
= forkpty(&master_fd
, NULL
, NULL
, NULL
);
3708 return posix_error();
3711 return Py_BuildValue("(li)", pid
, master_fd
);
3716 PyDoc_STRVAR(posix_getegid__doc__
,
3717 "getegid() -> egid\n\n\
3718 Return the current process's effective group id.");
3721 posix_getegid(PyObject
*self
, PyObject
*noargs
)
3723 return PyInt_FromLong((long)getegid());
3729 PyDoc_STRVAR(posix_geteuid__doc__
,
3730 "geteuid() -> euid\n\n\
3731 Return the current process's effective user id.");
3734 posix_geteuid(PyObject
*self
, PyObject
*noargs
)
3736 return PyInt_FromLong((long)geteuid());
3742 PyDoc_STRVAR(posix_getgid__doc__
,
3743 "getgid() -> gid\n\n\
3744 Return the current process's group id.");
3747 posix_getgid(PyObject
*self
, PyObject
*noargs
)
3749 return PyInt_FromLong((long)getgid());
3754 PyDoc_STRVAR(posix_getpid__doc__
,
3755 "getpid() -> pid\n\n\
3756 Return the current process id");
3759 posix_getpid(PyObject
*self
, PyObject
*noargs
)
3761 return PyInt_FromLong((long)getpid());
3765 #ifdef HAVE_GETGROUPS
3766 PyDoc_STRVAR(posix_getgroups__doc__
,
3767 "getgroups() -> list of group IDs\n\n\
3768 Return list of supplemental group IDs for the process.");
3771 posix_getgroups(PyObject
*self
, PyObject
*noargs
)
3773 PyObject
*result
= NULL
;
3776 #define MAX_GROUPS NGROUPS_MAX
3778 /* defined to be 16 on Solaris7, so this should be a small number */
3779 #define MAX_GROUPS 64
3781 gid_t grouplist
[MAX_GROUPS
];
3784 n
= getgroups(MAX_GROUPS
, grouplist
);
3788 result
= PyList_New(n
);
3789 if (result
!= NULL
) {
3791 for (i
= 0; i
< n
; ++i
) {
3792 PyObject
*o
= PyInt_FromLong((long)grouplist
[i
]);
3798 PyList_SET_ITEM(result
, i
, o
);
3808 PyDoc_STRVAR(posix_getpgid__doc__
,
3809 "getpgid(pid) -> pgid\n\n\
3810 Call the system call getpgid().");
3813 posix_getpgid(PyObject
*self
, PyObject
*args
)
3816 if (!PyArg_ParseTuple(args
, "i:getpgid", &pid
))
3818 pgid
= getpgid(pid
);
3820 return posix_error();
3821 return PyInt_FromLong((long)pgid
);
3823 #endif /* HAVE_GETPGID */
3827 PyDoc_STRVAR(posix_getpgrp__doc__
,
3828 "getpgrp() -> pgrp\n\n\
3829 Return the current process group id.");
3832 posix_getpgrp(PyObject
*self
, PyObject
*noargs
)
3834 #ifdef GETPGRP_HAVE_ARG
3835 return PyInt_FromLong((long)getpgrp(0));
3836 #else /* GETPGRP_HAVE_ARG */
3837 return PyInt_FromLong((long)getpgrp());
3838 #endif /* GETPGRP_HAVE_ARG */
3840 #endif /* HAVE_GETPGRP */
3844 PyDoc_STRVAR(posix_setpgrp__doc__
,
3846 Make this process a session leader.");
3849 posix_setpgrp(PyObject
*self
, PyObject
*noargs
)
3851 #ifdef SETPGRP_HAVE_ARG
3852 if (setpgrp(0, 0) < 0)
3853 #else /* SETPGRP_HAVE_ARG */
3855 #endif /* SETPGRP_HAVE_ARG */
3856 return posix_error();
3861 #endif /* HAVE_SETPGRP */
3864 PyDoc_STRVAR(posix_getppid__doc__
,
3865 "getppid() -> ppid\n\n\
3866 Return the parent's process id.");
3869 posix_getppid(PyObject
*self
, PyObject
*noargs
)
3871 return PyInt_FromLong(getppid());
3876 #ifdef HAVE_GETLOGIN
3877 PyDoc_STRVAR(posix_getlogin__doc__
,
3878 "getlogin() -> string\n\n\
3879 Return the actual login name.");
3882 posix_getlogin(PyObject
*self
, PyObject
*noargs
)
3884 PyObject
*result
= NULL
;
3886 int old_errno
= errno
;
3894 PyErr_SetString(PyExc_OSError
,
3895 "unable to determine login name");
3898 result
= PyString_FromString(name
);
3906 PyDoc_STRVAR(posix_getuid__doc__
,
3907 "getuid() -> uid\n\n\
3908 Return the current process's user id.");
3911 posix_getuid(PyObject
*self
, PyObject
*noargs
)
3913 return PyInt_FromLong((long)getuid());
3919 PyDoc_STRVAR(posix_kill__doc__
,
3920 "kill(pid, sig)\n\n\
3921 Kill a process with a signal.");
3924 posix_kill(PyObject
*self
, PyObject
*args
)
3928 if (!PyArg_ParseTuple(args
, "ii:kill", &pid
, &sig
))
3930 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
3931 if (sig
== XCPT_SIGNAL_INTR
|| sig
== XCPT_SIGNAL_BREAK
) {
3933 if ((rc
= DosSendSignalException(pid
, sig
)) != NO_ERROR
)
3934 return os2_error(rc
);
3936 } else if (sig
== XCPT_SIGNAL_KILLPROC
) {
3938 if ((rc
= DosKillProcess(DKP_PROCESS
, pid
)) != NO_ERROR
)
3939 return os2_error(rc
);
3942 return NULL
; /* Unrecognized Signal Requested */
3944 if (kill(pid
, sig
) == -1)
3945 return posix_error();
3953 PyDoc_STRVAR(posix_killpg__doc__
,
3954 "killpg(pgid, sig)\n\n\
3955 Kill a process group with a signal.");
3958 posix_killpg(PyObject
*self
, PyObject
*args
)
3961 if (!PyArg_ParseTuple(args
, "ii:killpg", &pgid
, &sig
))
3963 if (killpg(pgid
, sig
) == -1)
3964 return posix_error();
3972 #ifdef HAVE_SYS_LOCK_H
3973 #include <sys/lock.h>
3976 PyDoc_STRVAR(posix_plock__doc__
,
3978 Lock program segments into memory.");
3981 posix_plock(PyObject
*self
, PyObject
*args
)
3984 if (!PyArg_ParseTuple(args
, "i:plock", &op
))
3986 if (plock(op
) == -1)
3987 return posix_error();
3995 PyDoc_STRVAR(posix_popen__doc__
,
3996 "popen(command [, mode='r' [, bufsize]]) -> pipe\n\n\
3997 Open a pipe to/from a command returning a file object.");
3999 #if defined(PYOS_OS2)
4000 #if defined(PYCC_VACPP)
4002 async_system(const char *command
)
4004 char errormsg
[256], args
[1024];
4008 char *shell
= getenv("COMSPEC");
4012 /* avoid overflowing the argument buffer */
4013 if (strlen(shell
) + 3 + strlen(command
) >= 1024)
4014 return ERROR_NOT_ENOUGH_MEMORY
4017 strcat(args
, shell
);
4018 strcat(args
, "/c ");
4019 strcat(args
, command
);
4021 /* execute asynchronously, inheriting the environment */
4022 rc
= DosExecPgm(errormsg
,
4033 popen(const char *command
, const char *mode
, int pipesize
, int *err
)
4039 /* mode determines which of stdin or stdout is reconnected to
4040 * the pipe to the child
4042 if (strchr(mode
, 'r') != NULL
) {
4043 tgt_fd
= 1; /* stdout */
4044 } else if (strchr(mode
, 'w')) {
4045 tgt_fd
= 0; /* stdin */
4047 *err
= ERROR_INVALID_ACCESS
;
4051 /* setup the pipe */
4052 if ((rc
= DosCreatePipe(&pipeh
[0], &pipeh
[1], pipesize
)) != NO_ERROR
) {
4057 /* prevent other threads accessing stdio */
4060 /* reconnect stdio and execute child */
4063 if (dup2(pipeh
[tgtfd
], tgtfd
) == 0) {
4064 DosClose(pipeh
[tgtfd
]);
4065 rc
= async_system(command
);
4072 /* allow other threads access to stdio */
4075 /* if execution of child was successful return file stream */
4077 return fdopen(pipeh
[1 - tgtfd
], mode
);
4079 DosClose(pipeh
[1 - tgtfd
]);
4086 posix_popen(PyObject
*self
, PyObject
*args
)
4090 int err
, bufsize
= -1;
4093 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4095 Py_BEGIN_ALLOW_THREADS
4096 fp
= popen(name
, mode
, (bufsize
> 0) ? bufsize
: 4096, &err
);
4097 Py_END_ALLOW_THREADS
4099 return os2_error(err
);
4101 f
= PyFile_FromFile(fp
, name
, mode
, fclose
);
4103 PyFile_SetBufSize(f
, bufsize
);
4107 #elif defined(PYCC_GCC)
4109 /* standard posix version of popen() support */
4111 posix_popen(PyObject
*self
, PyObject
*args
)
4118 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4120 Py_BEGIN_ALLOW_THREADS
4121 fp
= popen(name
, mode
);
4122 Py_END_ALLOW_THREADS
4124 return posix_error();
4125 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
4127 PyFile_SetBufSize(f
, bufsize
);
4131 /* fork() under OS/2 has lots'o'warts
4132 * EMX supports pipe() and spawn*() so we can synthesize popen[234]()
4133 * most of this code is a ripoff of the win32 code, but using the
4134 * capabilities of EMX's C library routines
4137 /* These tell _PyPopen() whether to return 1, 2, or 3 file objects. */
4143 static PyObject
*_PyPopen(char *, int, int, int);
4144 static int _PyPclose(FILE *file
);
4147 * Internal dictionary mapping popen* file pointers to process handles,
4148 * for use when retrieving the process exit code. See _PyPclose() below
4149 * for more information on this dictionary's use.
4151 static PyObject
*_PyPopenProcs
= NULL
;
4153 /* os2emx version of popen2()
4155 * The result of this function is a pipe (file) connected to the
4156 * process's stdin, and a pipe connected to the process's stdout.
4160 os2emx_popen2(PyObject
*self
, PyObject
*args
)
4168 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4173 else if (*mode
!= 'b') {
4174 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4179 f
= _PyPopen(cmdstring
, tm
, POPEN_2
, bufsize
);
4185 * Variation on os2emx.popen2
4187 * The result of this function is 3 pipes - the process's stdin,
4192 os2emx_popen3(PyObject
*self
, PyObject
*args
)
4200 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4205 else if (*mode
!= 'b') {
4206 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4211 f
= _PyPopen(cmdstring
, tm
, POPEN_3
, bufsize
);
4217 * Variation on os2emx.popen2
4219 * The result of this function is 2 pipes - the processes stdin,
4220 * and stdout+stderr combined as a single pipe.
4224 os2emx_popen4(PyObject
*self
, PyObject
*args
)
4232 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4237 else if (*mode
!= 'b') {
4238 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4243 f
= _PyPopen(cmdstring
, tm
, POPEN_4
, bufsize
);
4248 /* a couple of structures for convenient handling of multiple
4249 * file handles and pipes
4263 /* The following code is derived from the win32 code */
4266 _PyPopen(char *cmdstring
, int mode
, int n
, int bufsize
)
4268 struct file_ref stdio
[3];
4269 struct pipe_ref p_fd
[3];
4271 int file_count
, i
, pipe_err
;
4273 char *shell
, *sh_name
, *opt
, *rd_mode
, *wr_mode
;
4274 PyObject
*f
, *p_f
[3];
4276 /* file modes for subsequent fdopen's on pipe handles */
4288 /* prepare shell references */
4289 if ((shell
= getenv("EMXSHELL")) == NULL
)
4290 if ((shell
= getenv("COMSPEC")) == NULL
)
4293 return posix_error();
4296 sh_name
= _getname(shell
);
4297 if (stricmp(sh_name
, "cmd.exe") == 0 || stricmp(sh_name
, "4os2.exe") == 0)
4302 /* save current stdio fds + their flags, and set not inheritable */
4304 while (pipe_err
>= 0 && i
< 3)
4306 pipe_err
= stdio
[i
].handle
= dup(i
);
4307 stdio
[i
].flags
= fcntl(i
, F_GETFD
, 0);
4308 fcntl(stdio
[i
].handle
, F_SETFD
, stdio
[i
].flags
| FD_CLOEXEC
);
4313 /* didn't get them all saved - clean up and bail out */
4314 int saved_err
= errno
;
4317 close(stdio
[i
].handle
);
4320 return posix_error();
4323 /* create pipe ends */
4328 while ((pipe_err
== 0) && (i
< file_count
))
4329 pipe_err
= pipe((int *)&p_fd
[i
++]);
4332 /* didn't get them all made - clean up and bail out */
4339 return posix_error();
4342 /* change the actual standard IO streams over temporarily,
4343 * making the retained pipe ends non-inheritable
4348 if (dup2(p_fd
[0].rd
, 0) == 0)
4351 i
= fcntl(p_fd
[0].wr
, F_GETFD
, 0);
4352 fcntl(p_fd
[0].wr
, F_SETFD
, i
| FD_CLOEXEC
);
4353 if ((p_s
[0] = fdopen(p_fd
[0].wr
, wr_mode
)) == NULL
)
4367 if (dup2(p_fd
[1].wr
, 1) == 1)
4370 i
= fcntl(p_fd
[1].rd
, F_GETFD
, 0);
4371 fcntl(p_fd
[1].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4372 if ((p_s
[1] = fdopen(p_fd
[1].rd
, rd_mode
)) == NULL
)
4384 /* - stderr, as required */
4390 if (dup2(p_fd
[2].wr
, 2) == 2)
4393 i
= fcntl(p_fd
[2].rd
, F_GETFD
, 0);
4394 fcntl(p_fd
[2].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4395 if ((p_s
[2] = fdopen(p_fd
[2].rd
, rd_mode
)) == NULL
)
4410 if (dup2(1, 2) != 2)
4418 /* spawn the child process */
4421 pipe_pid
= spawnlp(P_NOWAIT
, shell
, shell
, opt
, cmdstring
, (char *)0);
4428 /* save the PID into the FILE structure
4429 * NOTE: this implementation doesn't actually
4430 * take advantage of this, but do it for
4431 * completeness - AIM Apr01
4433 for (i
= 0; i
< file_count
; i
++)
4434 p_s
[i
]->_pid
= pipe_pid
;
4438 /* reset standard IO to normal */
4439 for (i
= 0; i
< 3; i
++)
4441 dup2(stdio
[i
].handle
, i
);
4442 fcntl(i
, F_SETFD
, stdio
[i
].flags
);
4443 close(stdio
[i
].handle
);
4446 /* if any remnant problems, clean up and bail out */
4449 for (i
= 0; i
< 3; i
++)
4455 return posix_error_with_filename(cmdstring
);
4458 /* build tuple of file objects to return */
4459 if ((p_f
[0] = PyFile_FromFile(p_s
[0], cmdstring
, wr_mode
, _PyPclose
)) != NULL
)
4460 PyFile_SetBufSize(p_f
[0], bufsize
);
4461 if ((p_f
[1] = PyFile_FromFile(p_s
[1], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4462 PyFile_SetBufSize(p_f
[1], bufsize
);
4465 if ((p_f
[2] = PyFile_FromFile(p_s
[2], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4466 PyFile_SetBufSize(p_f
[0], bufsize
);
4467 f
= PyTuple_Pack(3, p_f
[0], p_f
[1], p_f
[2]);
4470 f
= PyTuple_Pack(2, p_f
[0], p_f
[1]);
4473 * Insert the files we've created into the process dictionary
4474 * all referencing the list with the process handle and the
4475 * initial number of files (see description below in _PyPclose).
4476 * Since if _PyPclose later tried to wait on a process when all
4477 * handles weren't closed, it could create a deadlock with the
4478 * child, we spend some energy here to try to ensure that we
4479 * either insert all file handles into the dictionary or none
4480 * at all. It's a little clumsy with the various popen modes
4481 * and variable number of files involved.
4485 _PyPopenProcs
= PyDict_New();
4490 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
[3];
4493 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
4494 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
4496 procObj
= PyList_New(2);
4497 pidObj
= PyInt_FromLong((long) pipe_pid
);
4498 intObj
= PyInt_FromLong((long) file_count
);
4500 if (procObj
&& pidObj
&& intObj
)
4502 PyList_SetItem(procObj
, 0, pidObj
);
4503 PyList_SetItem(procObj
, 1, intObj
);
4505 fileObj
[0] = PyLong_FromVoidPtr(p_s
[0]);
4508 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
4512 fileObj
[1] = PyLong_FromVoidPtr(p_s
[1]);
4515 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
4519 if (file_count
>= 3)
4521 fileObj
[2] = PyLong_FromVoidPtr(p_s
[2]);
4524 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
4530 if (ins_rc
[0] < 0 || !fileObj
[0] ||
4531 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
4532 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2]))
4534 /* Something failed - remove any dictionary
4535 * entries that did make it.
4537 if (!ins_rc
[0] && fileObj
[0])
4539 PyDict_DelItem(_PyPopenProcs
,
4542 if (!ins_rc
[1] && fileObj
[1])
4544 PyDict_DelItem(_PyPopenProcs
,
4547 if (!ins_rc
[2] && fileObj
[2])
4549 PyDict_DelItem(_PyPopenProcs
,
4556 * Clean up our localized references for the dictionary keys
4557 * and value since PyDict_SetItem will Py_INCREF any copies
4558 * that got placed in the dictionary.
4560 Py_XDECREF(procObj
);
4561 Py_XDECREF(fileObj
[0]);
4562 Py_XDECREF(fileObj
[1]);
4563 Py_XDECREF(fileObj
[2]);
4566 /* Child is launched. */
4571 * Wrapper for fclose() to use for popen* files, so we can retrieve the
4572 * exit code for the child process and return as a result of the close.
4574 * This function uses the _PyPopenProcs dictionary in order to map the
4575 * input file pointer to information about the process that was
4576 * originally created by the popen* call that created the file pointer.
4577 * The dictionary uses the file pointer as a key (with one entry
4578 * inserted for each file returned by the original popen* call) and a
4579 * single list object as the value for all files from a single call.
4580 * The list object contains the Win32 process handle at [0], and a file
4581 * count at [1], which is initialized to the total number of file
4582 * handles using that list.
4584 * This function closes whichever handle it is passed, and decrements
4585 * the file count in the dictionary for the process handle pointed to
4586 * by this file. On the last close (when the file count reaches zero),
4587 * this function will wait for the child process and then return its
4588 * exit code as the result of the close() operation. This permits the
4589 * files to be closed in any order - it is always the close() of the
4590 * final handle that will return the exit code.
4592 * NOTE: This function is currently called with the GIL released.
4593 * hence we use the GILState API to manage our state.
4596 static int _PyPclose(FILE *file
)
4601 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
;
4604 PyGILState_STATE state
;
4607 /* Close the file handle first, to ensure it can't block the
4608 * child from exiting if it's the last handle.
4610 result
= fclose(file
);
4613 state
= PyGILState_Ensure();
4617 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
4618 (procObj
= PyDict_GetItem(_PyPopenProcs
,
4619 fileObj
)) != NULL
&&
4620 (pidObj
= PyList_GetItem(procObj
,0)) != NULL
&&
4621 (intObj
= PyList_GetItem(procObj
,1)) != NULL
)
4623 pipe_pid
= (int) PyInt_AsLong(pidObj
);
4624 file_count
= (int) PyInt_AsLong(intObj
);
4628 /* Still other files referencing process */
4630 PyList_SetItem(procObj
,1,
4631 PyInt_FromLong((long) file_count
));
4635 /* Last file for this process */
4636 if (result
!= EOF
&&
4637 waitpid(pipe_pid
, &exit_code
, 0) == pipe_pid
)
4639 /* extract exit status */
4640 if (WIFEXITED(exit_code
))
4642 result
= WEXITSTATUS(exit_code
);
4652 /* Indicate failure - this will cause the file object
4653 * to raise an I/O error and translate the last
4654 * error code from errno. We do have a problem with
4655 * last errors that overlap the normal errno table,
4656 * but that's a consistent problem with the file object.
4662 /* Remove this file pointer from dictionary */
4663 PyDict_DelItem(_PyPopenProcs
, fileObj
);
4665 if (PyDict_Size(_PyPopenProcs
) == 0)
4667 Py_DECREF(_PyPopenProcs
);
4668 _PyPopenProcs
= NULL
;
4671 } /* if object retrieval ok */
4673 Py_XDECREF(fileObj
);
4674 } /* if _PyPopenProcs */
4677 PyGILState_Release(state
);
4682 #endif /* PYCC_??? */
4684 #elif defined(MS_WINDOWS)
4687 * Portable 'popen' replacement for Win32.
4689 * Written by Bill Tutt <billtut@microsoft.com>. Minor tweaks
4690 * and 2.0 integration by Fredrik Lundh <fredrik@pythonware.com>
4691 * Return code handling by David Bolen <db3l@fitlinxx.com>.
4698 /* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */
4704 static PyObject
*_PyPopen(char *, int, int);
4705 static int _PyPclose(FILE *file
);
4708 * Internal dictionary mapping popen* file pointers to process handles,
4709 * for use when retrieving the process exit code. See _PyPclose() below
4710 * for more information on this dictionary's use.
4712 static PyObject
*_PyPopenProcs
= NULL
;
4715 /* popen that works from a GUI.
4717 * The result of this function is a pipe (file) connected to the
4718 * processes stdin or stdout, depending on the requested mode.
4722 posix_popen(PyObject
*self
, PyObject
*args
)
4730 if (!PyArg_ParseTuple(args
, "s|si:popen", &cmdstring
, &mode
, &bufsize
))
4735 else if (*mode
!= 'w') {
4736 PyErr_SetString(PyExc_ValueError
, "popen() arg 2 must be 'r' or 'w'");
4741 if (bufsize
!= -1) {
4742 PyErr_SetString(PyExc_ValueError
, "popen() arg 3 must be -1");
4746 if (*(mode
+1) == 't')
4747 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4748 else if (*(mode
+1) == 'b')
4749 f
= _PyPopen(cmdstring
, tm
| _O_BINARY
, POPEN_1
);
4751 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4756 /* Variation on win32pipe.popen
4758 * The result of this function is a pipe (file) connected to the
4759 * process's stdin, and a pipe connected to the process's stdout.
4763 win32_popen2(PyObject
*self
, PyObject
*args
)
4771 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4776 else if (*mode
!= 'b') {
4777 PyErr_SetString(PyExc_ValueError
, "popen2() arg 2 must be 't' or 'b'");
4782 if (bufsize
!= -1) {
4783 PyErr_SetString(PyExc_ValueError
, "popen2() arg 3 must be -1");
4787 f
= _PyPopen(cmdstring
, tm
, POPEN_2
);
4793 * Variation on <om win32pipe.popen>
4795 * The result of this function is 3 pipes - the process's stdin,
4800 win32_popen3(PyObject
*self
, PyObject
*args
)
4808 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4813 else if (*mode
!= 'b') {
4814 PyErr_SetString(PyExc_ValueError
, "popen3() arg 2 must be 't' or 'b'");
4819 if (bufsize
!= -1) {
4820 PyErr_SetString(PyExc_ValueError
, "popen3() arg 3 must be -1");
4824 f
= _PyPopen(cmdstring
, tm
, POPEN_3
);
4830 * Variation on win32pipe.popen
4832 * The result of this function is 2 pipes - the processes stdin,
4833 * and stdout+stderr combined as a single pipe.
4837 win32_popen4(PyObject
*self
, PyObject
*args
)
4845 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4850 else if (*mode
!= 'b') {
4851 PyErr_SetString(PyExc_ValueError
, "popen4() arg 2 must be 't' or 'b'");
4856 if (bufsize
!= -1) {
4857 PyErr_SetString(PyExc_ValueError
, "popen4() arg 3 must be -1");
4861 f
= _PyPopen(cmdstring
, tm
, POPEN_4
);
4867 _PyPopenCreateProcess(char *cmdstring
,
4873 PROCESS_INFORMATION piProcInfo
;
4874 STARTUPINFO siStartInfo
;
4875 DWORD dwProcessFlags
= 0; /* no NEW_CONSOLE by default for Ctrl+C handling */
4876 char *s1
,*s2
, *s3
= " /c ";
4877 const char *szConsoleSpawn
= "w9xpopen.exe";
4881 if (i
= GetEnvironmentVariable("COMSPEC",NULL
,0)) {
4884 s1
= (char *)alloca(i
);
4885 if (!(x
= GetEnvironmentVariable("COMSPEC", s1
, i
)))
4886 /* x < i, so x fits into an integer */
4889 /* Explicitly check if we are using COMMAND.COM. If we are
4890 * then use the w9xpopen hack.
4893 while (comshell
>= s1
&& *comshell
!= '\\')
4897 if (GetVersion() < 0x80000000 &&
4898 _stricmp(comshell
, "command.com") != 0) {
4899 /* NT/2000 and not using command.com. */
4900 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1;
4901 s2
= (char *)alloca(x
);
4903 PyOS_snprintf(s2
, x
, "%s%s%s", s1
, s3
, cmdstring
);
4907 * Oh gag, we're on Win9x or using COMMAND.COM. Use
4908 * the workaround listed in KB: Q150956
4910 char modulepath
[_MAX_PATH
];
4911 struct stat statinfo
;
4912 GetModuleFileName(NULL
, modulepath
, sizeof(modulepath
));
4913 for (x
= i
= 0; modulepath
[i
]; i
++)
4914 if (modulepath
[i
] == SEP
)
4916 modulepath
[x
] = '\0';
4917 /* Create the full-name to w9xpopen, so we can test it exists */
4920 (sizeof(modulepath
)/sizeof(modulepath
[0]))
4921 -strlen(modulepath
));
4922 if (stat(modulepath
, &statinfo
) != 0) {
4923 size_t mplen
= sizeof(modulepath
)/sizeof(modulepath
[0]);
4924 /* Eeek - file-not-found - possibly an embedding
4925 situation - see if we can locate it in sys.prefix
4930 modulepath
[mplen
-1] = '\0';
4931 if (modulepath
[strlen(modulepath
)-1] != '\\')
4932 strcat(modulepath
, "\\");
4935 mplen
-strlen(modulepath
));
4936 /* No where else to look - raise an easily identifiable
4937 error, rather than leaving Windows to report
4938 "file not found" - as the user is probably blissfully
4939 unaware this shim EXE is used, and it will confuse them.
4940 (well, it confused me for a while ;-)
4942 if (stat(modulepath
, &statinfo
) != 0) {
4943 PyErr_Format(PyExc_RuntimeError
,
4944 "Can not locate '%s' which is needed "
4945 "for popen to work with your shell "
4951 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1 +
4952 strlen(modulepath
) +
4953 strlen(szConsoleSpawn
) + 1;
4955 s2
= (char *)alloca(x
);
4957 /* To maintain correct argument passing semantics,
4958 we pass the command-line as it stands, and allow
4959 quoting to be applied. w9xpopen.exe will then
4960 use its argv vector, and re-quote the necessary
4961 args for the ultimate child process.
4970 /* Not passing CREATE_NEW_CONSOLE has been known to
4971 cause random failures on win9x. Specifically a
4973 "Your program accessed mem currently in use at xxx"
4974 and a hopeful warning about the stability of your
4976 Cost is Ctrl+C wont kill children, but anyone
4977 who cares can have a go!
4979 dwProcessFlags
|= CREATE_NEW_CONSOLE
;
4983 /* Could be an else here to try cmd.exe / command.com in the path
4984 Now we'll just error out.. */
4986 PyErr_SetString(PyExc_RuntimeError
,
4987 "Cannot locate a COMSPEC environment variable to "
4988 "use as the shell");
4992 ZeroMemory(&siStartInfo
, sizeof(STARTUPINFO
));
4993 siStartInfo
.cb
= sizeof(STARTUPINFO
);
4994 siStartInfo
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
4995 siStartInfo
.hStdInput
= hStdin
;
4996 siStartInfo
.hStdOutput
= hStdout
;
4997 siStartInfo
.hStdError
= hStderr
;
4998 siStartInfo
.wShowWindow
= SW_HIDE
;
5000 if (CreateProcess(NULL
,
5010 /* Close the handles now so anyone waiting is woken. */
5011 CloseHandle(piProcInfo
.hThread
);
5013 /* Return process handle */
5014 *hProcess
= piProcInfo
.hProcess
;
5017 win32_error("CreateProcess", s2
);
5021 /* The following code is based off of KB: Q190351 */
5024 _PyPopen(char *cmdstring
, int mode
, int n
)
5026 HANDLE hChildStdinRd
, hChildStdinWr
, hChildStdoutRd
, hChildStdoutWr
,
5027 hChildStderrRd
, hChildStderrWr
, hChildStdinWrDup
, hChildStdoutRdDup
,
5028 hChildStderrRdDup
, hProcess
; /* hChildStdoutWrDup; */
5030 SECURITY_ATTRIBUTES saAttr
;
5037 saAttr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
5038 saAttr
.bInheritHandle
= TRUE
;
5039 saAttr
.lpSecurityDescriptor
= NULL
;
5041 if (!CreatePipe(&hChildStdinRd
, &hChildStdinWr
, &saAttr
, 0))
5042 return win32_error("CreatePipe", NULL
);
5044 /* Create new output read handle and the input write handle. Set
5045 * the inheritance properties to FALSE. Otherwise, the child inherits
5046 * these handles; resulting in non-closeable handles to the pipes
5048 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdinWr
,
5049 GetCurrentProcess(), &hChildStdinWrDup
, 0,
5051 DUPLICATE_SAME_ACCESS
);
5053 return win32_error("DuplicateHandle", NULL
);
5055 /* Close the inheritable version of ChildStdin
5056 that we're using. */
5057 CloseHandle(hChildStdinWr
);
5059 if (!CreatePipe(&hChildStdoutRd
, &hChildStdoutWr
, &saAttr
, 0))
5060 return win32_error("CreatePipe", NULL
);
5062 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdoutRd
,
5063 GetCurrentProcess(), &hChildStdoutRdDup
, 0,
5064 FALSE
, DUPLICATE_SAME_ACCESS
);
5066 return win32_error("DuplicateHandle", NULL
);
5068 /* Close the inheritable version of ChildStdout
5069 that we're using. */
5070 CloseHandle(hChildStdoutRd
);
5073 if (!CreatePipe(&hChildStderrRd
, &hChildStderrWr
, &saAttr
, 0))
5074 return win32_error("CreatePipe", NULL
);
5075 fSuccess
= DuplicateHandle(GetCurrentProcess(),
5077 GetCurrentProcess(),
5078 &hChildStderrRdDup
, 0,
5079 FALSE
, DUPLICATE_SAME_ACCESS
);
5081 return win32_error("DuplicateHandle", NULL
);
5082 /* Close the inheritable version of ChildStdErr that we're using. */
5083 CloseHandle(hChildStderrRd
);
5088 switch (mode
& (_O_RDONLY
| _O_TEXT
| _O_BINARY
| _O_WRONLY
)) {
5089 case _O_WRONLY
| _O_TEXT
:
5090 /* Case for writing to child Stdin in text mode. */
5091 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5092 f1
= _fdopen(fd1
, "w");
5093 f
= PyFile_FromFile(f1
, cmdstring
, "w", _PyPclose
);
5094 PyFile_SetBufSize(f
, 0);
5095 /* We don't care about these pipes anymore, so close them. */
5096 CloseHandle(hChildStdoutRdDup
);
5097 CloseHandle(hChildStderrRdDup
);
5100 case _O_RDONLY
| _O_TEXT
:
5101 /* Case for reading from child Stdout in text mode. */
5102 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5103 f1
= _fdopen(fd1
, "r");
5104 f
= PyFile_FromFile(f1
, cmdstring
, "r", _PyPclose
);
5105 PyFile_SetBufSize(f
, 0);
5106 /* We don't care about these pipes anymore, so close them. */
5107 CloseHandle(hChildStdinWrDup
);
5108 CloseHandle(hChildStderrRdDup
);
5111 case _O_RDONLY
| _O_BINARY
:
5112 /* Case for readinig from child Stdout in binary mode. */
5113 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5114 f1
= _fdopen(fd1
, "rb");
5115 f
= PyFile_FromFile(f1
, cmdstring
, "rb", _PyPclose
);
5116 PyFile_SetBufSize(f
, 0);
5117 /* We don't care about these pipes anymore, so close them. */
5118 CloseHandle(hChildStdinWrDup
);
5119 CloseHandle(hChildStderrRdDup
);
5122 case _O_WRONLY
| _O_BINARY
:
5123 /* Case for writing to child Stdin in binary mode. */
5124 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5125 f1
= _fdopen(fd1
, "wb");
5126 f
= PyFile_FromFile(f1
, cmdstring
, "wb", _PyPclose
);
5127 PyFile_SetBufSize(f
, 0);
5128 /* We don't care about these pipes anymore, so close them. */
5129 CloseHandle(hChildStdoutRdDup
);
5130 CloseHandle(hChildStderrRdDup
);
5142 if (mode
& _O_TEXT
) {
5150 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5151 f1
= _fdopen(fd1
, m2
);
5152 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5153 f2
= _fdopen(fd2
, m1
);
5154 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5155 PyFile_SetBufSize(p1
, 0);
5156 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5157 PyFile_SetBufSize(p2
, 0);
5160 CloseHandle(hChildStderrRdDup
);
5162 f
= PyTuple_Pack(2,p1
,p2
);
5172 PyObject
*p1
, *p2
, *p3
;
5174 if (mode
& _O_TEXT
) {
5182 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5183 f1
= _fdopen(fd1
, m2
);
5184 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5185 f2
= _fdopen(fd2
, m1
);
5186 fd3
= _open_osfhandle((Py_intptr_t
)hChildStderrRdDup
, mode
);
5187 f3
= _fdopen(fd3
, m1
);
5188 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5189 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5190 p3
= PyFile_FromFile(f3
, cmdstring
, m1
, _PyPclose
);
5191 PyFile_SetBufSize(p1
, 0);
5192 PyFile_SetBufSize(p2
, 0);
5193 PyFile_SetBufSize(p3
, 0);
5194 f
= PyTuple_Pack(3,p1
,p2
,p3
);
5204 if (!_PyPopenCreateProcess(cmdstring
,
5212 if (!_PyPopenCreateProcess(cmdstring
,
5221 * Insert the files we've created into the process dictionary
5222 * all referencing the list with the process handle and the
5223 * initial number of files (see description below in _PyPclose).
5224 * Since if _PyPclose later tried to wait on a process when all
5225 * handles weren't closed, it could create a deadlock with the
5226 * child, we spend some energy here to try to ensure that we
5227 * either insert all file handles into the dictionary or none
5228 * at all. It's a little clumsy with the various popen modes
5229 * and variable number of files involved.
5231 if (!_PyPopenProcs
) {
5232 _PyPopenProcs
= PyDict_New();
5235 if (_PyPopenProcs
) {
5236 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
[3];
5239 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
5240 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
5242 procObj
= PyList_New(2);
5243 hProcessObj
= PyLong_FromVoidPtr(hProcess
);
5244 intObj
= PyInt_FromLong(file_count
);
5246 if (procObj
&& hProcessObj
&& intObj
) {
5247 PyList_SetItem(procObj
,0,hProcessObj
);
5248 PyList_SetItem(procObj
,1,intObj
);
5250 fileObj
[0] = PyLong_FromVoidPtr(f1
);
5252 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
5256 if (file_count
>= 2) {
5257 fileObj
[1] = PyLong_FromVoidPtr(f2
);
5259 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
5264 if (file_count
>= 3) {
5265 fileObj
[2] = PyLong_FromVoidPtr(f3
);
5267 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
5273 if (ins_rc
[0] < 0 || !fileObj
[0] ||
5274 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
5275 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2])) {
5276 /* Something failed - remove any dictionary
5277 * entries that did make it.
5279 if (!ins_rc
[0] && fileObj
[0]) {
5280 PyDict_DelItem(_PyPopenProcs
,
5283 if (!ins_rc
[1] && fileObj
[1]) {
5284 PyDict_DelItem(_PyPopenProcs
,
5287 if (!ins_rc
[2] && fileObj
[2]) {
5288 PyDict_DelItem(_PyPopenProcs
,
5295 * Clean up our localized references for the dictionary keys
5296 * and value since PyDict_SetItem will Py_INCREF any copies
5297 * that got placed in the dictionary.
5299 Py_XDECREF(procObj
);
5300 Py_XDECREF(fileObj
[0]);
5301 Py_XDECREF(fileObj
[1]);
5302 Py_XDECREF(fileObj
[2]);
5305 /* Child is launched. Close the parents copy of those pipe
5306 * handles that only the child should have open. You need to
5307 * make sure that no handles to the write end of the output pipe
5308 * are maintained in this process or else the pipe will not close
5309 * when the child process exits and the ReadFile will hang. */
5311 if (!CloseHandle(hChildStdinRd
))
5312 return win32_error("CloseHandle", NULL
);
5314 if (!CloseHandle(hChildStdoutWr
))
5315 return win32_error("CloseHandle", NULL
);
5317 if ((n
!= 4) && (!CloseHandle(hChildStderrWr
)))
5318 return win32_error("CloseHandle", NULL
);
5324 * Wrapper for fclose() to use for popen* files, so we can retrieve the
5325 * exit code for the child process and return as a result of the close.
5327 * This function uses the _PyPopenProcs dictionary in order to map the
5328 * input file pointer to information about the process that was
5329 * originally created by the popen* call that created the file pointer.
5330 * The dictionary uses the file pointer as a key (with one entry
5331 * inserted for each file returned by the original popen* call) and a
5332 * single list object as the value for all files from a single call.
5333 * The list object contains the Win32 process handle at [0], and a file
5334 * count at [1], which is initialized to the total number of file
5335 * handles using that list.
5337 * This function closes whichever handle it is passed, and decrements
5338 * the file count in the dictionary for the process handle pointed to
5339 * by this file. On the last close (when the file count reaches zero),
5340 * this function will wait for the child process and then return its
5341 * exit code as the result of the close() operation. This permits the
5342 * files to be closed in any order - it is always the close() of the
5343 * final handle that will return the exit code.
5345 * NOTE: This function is currently called with the GIL released.
5346 * hence we use the GILState API to manage our state.
5349 static int _PyPclose(FILE *file
)
5354 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
;
5357 PyGILState_STATE state
;
5360 /* Close the file handle first, to ensure it can't block the
5361 * child from exiting if it's the last handle.
5363 result
= fclose(file
);
5365 state
= PyGILState_Ensure();
5367 if (_PyPopenProcs
) {
5368 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
5369 (procObj
= PyDict_GetItem(_PyPopenProcs
,
5370 fileObj
)) != NULL
&&
5371 (hProcessObj
= PyList_GetItem(procObj
,0)) != NULL
&&
5372 (intObj
= PyList_GetItem(procObj
,1)) != NULL
) {
5374 hProcess
= PyLong_AsVoidPtr(hProcessObj
);
5375 file_count
= PyInt_AsLong(intObj
);
5377 if (file_count
> 1) {
5378 /* Still other files referencing process */
5380 PyList_SetItem(procObj
,1,
5381 PyInt_FromLong(file_count
));
5383 /* Last file for this process */
5384 if (result
!= EOF
&&
5385 WaitForSingleObject(hProcess
, INFINITE
) != WAIT_FAILED
&&
5386 GetExitCodeProcess(hProcess
, &exit_code
)) {
5387 /* Possible truncation here in 16-bit environments, but
5388 * real exit codes are just the lower byte in any event.
5392 /* Indicate failure - this will cause the file object
5393 * to raise an I/O error and translate the last Win32
5394 * error code from errno. We do have a problem with
5395 * last errors that overlap the normal errno table,
5396 * but that's a consistent problem with the file object.
5398 if (result
!= EOF
) {
5399 /* If the error wasn't from the fclose(), then
5400 * set errno for the file object error handling.
5402 errno
= GetLastError();
5407 /* Free up the native handle at this point */
5408 CloseHandle(hProcess
);
5411 /* Remove this file pointer from dictionary */
5412 PyDict_DelItem(_PyPopenProcs
, fileObj
);
5414 if (PyDict_Size(_PyPopenProcs
) == 0) {
5415 Py_DECREF(_PyPopenProcs
);
5416 _PyPopenProcs
= NULL
;
5419 } /* if object retrieval ok */
5421 Py_XDECREF(fileObj
);
5422 } /* if _PyPopenProcs */
5425 PyGILState_Release(state
);
5430 #else /* which OS? */
5432 posix_popen(PyObject
*self
, PyObject
*args
)
5439 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
5441 /* Strip mode of binary or text modifiers */
5442 if (strcmp(mode
, "rb") == 0 || strcmp(mode
, "rt") == 0)
5444 else if (strcmp(mode
, "wb") == 0 || strcmp(mode
, "wt") == 0)
5446 Py_BEGIN_ALLOW_THREADS
5447 fp
= popen(name
, mode
);
5448 Py_END_ALLOW_THREADS
5450 return posix_error();
5451 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
5453 PyFile_SetBufSize(f
, bufsize
);
5457 #endif /* PYOS_??? */
5458 #endif /* HAVE_POPEN */
5462 PyDoc_STRVAR(posix_setuid__doc__
,
5464 Set the current process's user id.");
5467 posix_setuid(PyObject
*self
, PyObject
*args
)
5470 if (!PyArg_ParseTuple(args
, "i:setuid", &uid
))
5472 if (setuid(uid
) < 0)
5473 return posix_error();
5477 #endif /* HAVE_SETUID */
5481 PyDoc_STRVAR(posix_seteuid__doc__
,
5483 Set the current process's effective user id.");
5486 posix_seteuid (PyObject
*self
, PyObject
*args
)
5489 if (!PyArg_ParseTuple(args
, "i", &euid
)) {
5491 } else if (seteuid(euid
) < 0) {
5492 return posix_error();
5498 #endif /* HAVE_SETEUID */
5501 PyDoc_STRVAR(posix_setegid__doc__
,
5503 Set the current process's effective group id.");
5506 posix_setegid (PyObject
*self
, PyObject
*args
)
5509 if (!PyArg_ParseTuple(args
, "i", &egid
)) {
5511 } else if (setegid(egid
) < 0) {
5512 return posix_error();
5518 #endif /* HAVE_SETEGID */
5520 #ifdef HAVE_SETREUID
5521 PyDoc_STRVAR(posix_setreuid__doc__
,
5522 "setreuid(ruid, euid)\n\n\
5523 Set the current process's real and effective user ids.");
5526 posix_setreuid (PyObject
*self
, PyObject
*args
)
5529 if (!PyArg_ParseTuple(args
, "ii", &ruid
, &euid
)) {
5531 } else if (setreuid(ruid
, euid
) < 0) {
5532 return posix_error();
5538 #endif /* HAVE_SETREUID */
5540 #ifdef HAVE_SETREGID
5541 PyDoc_STRVAR(posix_setregid__doc__
,
5542 "setregid(rgid, egid)\n\n\
5543 Set the current process's real and effective group ids.");
5546 posix_setregid (PyObject
*self
, PyObject
*args
)
5549 if (!PyArg_ParseTuple(args
, "ii", &rgid
, &egid
)) {
5551 } else if (setregid(rgid
, egid
) < 0) {
5552 return posix_error();
5558 #endif /* HAVE_SETREGID */
5561 PyDoc_STRVAR(posix_setgid__doc__
,
5563 Set the current process's group id.");
5566 posix_setgid(PyObject
*self
, PyObject
*args
)
5569 if (!PyArg_ParseTuple(args
, "i:setgid", &gid
))
5571 if (setgid(gid
) < 0)
5572 return posix_error();
5576 #endif /* HAVE_SETGID */
5578 #ifdef HAVE_SETGROUPS
5579 PyDoc_STRVAR(posix_setgroups__doc__
,
5580 "setgroups(list)\n\n\
5581 Set the groups of the current process to list.");
5584 posix_setgroups(PyObject
*self
, PyObject
*groups
)
5587 gid_t grouplist
[MAX_GROUPS
];
5589 if (!PySequence_Check(groups
)) {
5590 PyErr_SetString(PyExc_TypeError
, "setgroups argument must be a sequence");
5593 len
= PySequence_Size(groups
);
5594 if (len
> MAX_GROUPS
) {
5595 PyErr_SetString(PyExc_ValueError
, "too many groups");
5598 for(i
= 0; i
< len
; i
++) {
5600 elem
= PySequence_GetItem(groups
, i
);
5603 if (!PyInt_Check(elem
)) {
5604 if (!PyLong_Check(elem
)) {
5605 PyErr_SetString(PyExc_TypeError
,
5606 "groups must be integers");
5610 unsigned long x
= PyLong_AsUnsignedLong(elem
);
5611 if (PyErr_Occurred()) {
5612 PyErr_SetString(PyExc_TypeError
,
5613 "group id too big");
5618 /* read back the value to see if it fitted in gid_t */
5619 if (grouplist
[i
] != x
) {
5620 PyErr_SetString(PyExc_TypeError
,
5621 "group id too big");
5627 long x
= PyInt_AsLong(elem
);
5629 if (grouplist
[i
] != x
) {
5630 PyErr_SetString(PyExc_TypeError
,
5631 "group id too big");
5639 if (setgroups(len
, grouplist
) < 0)
5640 return posix_error();
5644 #endif /* HAVE_SETGROUPS */
5646 #if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
5648 wait_helper(pid_t pid
, int status
, struct rusage
*ru
)
5651 static PyObject
*struct_rusage
;
5654 return posix_error();
5656 if (struct_rusage
== NULL
) {
5657 PyObject
*m
= PyImport_ImportModuleNoBlock("resource");
5660 struct_rusage
= PyObject_GetAttrString(m
, "struct_rusage");
5662 if (struct_rusage
== NULL
)
5666 /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
5667 result
= PyStructSequence_New((PyTypeObject
*) struct_rusage
);
5672 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
5675 PyStructSequence_SET_ITEM(result
, 0,
5676 PyFloat_FromDouble(doubletime(ru
->ru_utime
)));
5677 PyStructSequence_SET_ITEM(result
, 1,
5678 PyFloat_FromDouble(doubletime(ru
->ru_stime
)));
5679 #define SET_INT(result, index, value)\
5680 PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))
5681 SET_INT(result
, 2, ru
->ru_maxrss
);
5682 SET_INT(result
, 3, ru
->ru_ixrss
);
5683 SET_INT(result
, 4, ru
->ru_idrss
);
5684 SET_INT(result
, 5, ru
->ru_isrss
);
5685 SET_INT(result
, 6, ru
->ru_minflt
);
5686 SET_INT(result
, 7, ru
->ru_majflt
);
5687 SET_INT(result
, 8, ru
->ru_nswap
);
5688 SET_INT(result
, 9, ru
->ru_inblock
);
5689 SET_INT(result
, 10, ru
->ru_oublock
);
5690 SET_INT(result
, 11, ru
->ru_msgsnd
);
5691 SET_INT(result
, 12, ru
->ru_msgrcv
);
5692 SET_INT(result
, 13, ru
->ru_nsignals
);
5693 SET_INT(result
, 14, ru
->ru_nvcsw
);
5694 SET_INT(result
, 15, ru
->ru_nivcsw
);
5697 if (PyErr_Occurred()) {
5702 return Py_BuildValue("iiN", pid
, status
, result
);
5704 #endif /* HAVE_WAIT3 || HAVE_WAIT4 */
5707 PyDoc_STRVAR(posix_wait3__doc__
,
5708 "wait3(options) -> (pid, status, rusage)\n\n\
5709 Wait for completion of a child process.");
5712 posix_wait3(PyObject
*self
, PyObject
*args
)
5718 WAIT_STATUS_INT(status
) = 0;
5720 if (!PyArg_ParseTuple(args
, "i:wait3", &options
))
5723 Py_BEGIN_ALLOW_THREADS
5724 pid
= wait3(&status
, options
, &ru
);
5725 Py_END_ALLOW_THREADS
5727 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5729 #endif /* HAVE_WAIT3 */
5732 PyDoc_STRVAR(posix_wait4__doc__
,
5733 "wait4(pid, options) -> (pid, status, rusage)\n\n\
5734 Wait for completion of a given child process.");
5737 posix_wait4(PyObject
*self
, PyObject
*args
)
5743 WAIT_STATUS_INT(status
) = 0;
5745 if (!PyArg_ParseTuple(args
, "ii:wait4", &pid
, &options
))
5748 Py_BEGIN_ALLOW_THREADS
5749 pid
= wait4(pid
, &status
, options
, &ru
);
5750 Py_END_ALLOW_THREADS
5752 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5754 #endif /* HAVE_WAIT4 */
5757 PyDoc_STRVAR(posix_waitpid__doc__
,
5758 "waitpid(pid, options) -> (pid, status)\n\n\
5759 Wait for completion of a given child process.");
5762 posix_waitpid(PyObject
*self
, PyObject
*args
)
5767 WAIT_STATUS_INT(status
) = 0;
5769 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5771 Py_BEGIN_ALLOW_THREADS
5772 pid
= waitpid(pid
, &status
, options
);
5773 Py_END_ALLOW_THREADS
5775 return posix_error();
5777 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5780 #elif defined(HAVE_CWAIT)
5782 /* MS C has a variant of waitpid() that's usable for most purposes. */
5783 PyDoc_STRVAR(posix_waitpid__doc__
,
5784 "waitpid(pid, options) -> (pid, status << 8)\n\n"
5785 "Wait for completion of a given process. options is ignored on Windows.");
5788 posix_waitpid(PyObject
*self
, PyObject
*args
)
5791 int status
, options
;
5793 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5795 Py_BEGIN_ALLOW_THREADS
5796 pid
= _cwait(&status
, pid
, options
);
5797 Py_END_ALLOW_THREADS
5799 return posix_error();
5801 /* shift the status left a byte so this is more like the POSIX waitpid */
5802 return Py_BuildValue("ii", pid
, status
<< 8);
5804 #endif /* HAVE_WAITPID || HAVE_CWAIT */
5807 PyDoc_STRVAR(posix_wait__doc__
,
5808 "wait() -> (pid, status)\n\n\
5809 Wait for completion of a child process.");
5812 posix_wait(PyObject
*self
, PyObject
*noargs
)
5816 WAIT_STATUS_INT(status
) = 0;
5818 Py_BEGIN_ALLOW_THREADS
5819 pid
= wait(&status
);
5820 Py_END_ALLOW_THREADS
5822 return posix_error();
5824 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5829 PyDoc_STRVAR(posix_lstat__doc__
,
5830 "lstat(path) -> stat result\n\n\
5831 Like stat(path), but do not follow symbolic links.");
5834 posix_lstat(PyObject
*self
, PyObject
*args
)
5837 return posix_do_stat(self
, args
, "et:lstat", lstat
, NULL
, NULL
);
5838 #else /* !HAVE_LSTAT */
5840 return posix_do_stat(self
, args
, "et:lstat", STAT
, "U:lstat", win32_wstat
);
5842 return posix_do_stat(self
, args
, "et:lstat", STAT
, NULL
, NULL
);
5844 #endif /* !HAVE_LSTAT */
5848 #ifdef HAVE_READLINK
5849 PyDoc_STRVAR(posix_readlink__doc__
,
5850 "readlink(path) -> path\n\n\
5851 Return a string representing the path to which the symbolic link points.");
5854 posix_readlink(PyObject
*self
, PyObject
*args
)
5857 char buf
[MAXPATHLEN
];
5860 #ifdef Py_USING_UNICODE
5861 int arg_is_unicode
= 0;
5864 if (!PyArg_ParseTuple(args
, "et:readlink",
5865 Py_FileSystemDefaultEncoding
, &path
))
5867 #ifdef Py_USING_UNICODE
5868 v
= PySequence_GetItem(args
, 0);
5874 if (PyUnicode_Check(v
)) {
5880 Py_BEGIN_ALLOW_THREADS
5881 n
= readlink(path
, buf
, (int) sizeof buf
);
5882 Py_END_ALLOW_THREADS
5884 return posix_error_with_allocated_filename(path
);
5887 v
= PyString_FromStringAndSize(buf
, n
);
5888 #ifdef Py_USING_UNICODE
5889 if (arg_is_unicode
) {
5892 w
= PyUnicode_FromEncodedObject(v
,
5893 Py_FileSystemDefaultEncoding
,
5900 /* fall back to the original byte string, as
5901 discussed in patch #683592 */
5908 #endif /* HAVE_READLINK */
5912 PyDoc_STRVAR(posix_symlink__doc__
,
5913 "symlink(src, dst)\n\n\
5914 Create a symbolic link pointing to src named dst.");
5917 posix_symlink(PyObject
*self
, PyObject
*args
)
5919 return posix_2str(args
, "etet:symlink", symlink
);
5921 #endif /* HAVE_SYMLINK */
5926 #define HZ 60 /* Universal constant :-) */
5929 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
5935 Py_BEGIN_ALLOW_THREADS
5936 DosQuerySysInfo(QSV_MS_COUNT
, QSV_MS_COUNT
, &value
, sizeof(value
));
5937 Py_END_ALLOW_THREADS
5943 posix_times(PyObject
*self
, PyObject
*noargs
)
5945 /* Currently Only Uptime is Provided -- Others Later */
5946 return Py_BuildValue("ddddd",
5947 (double)0 /* t.tms_utime / HZ */,
5948 (double)0 /* t.tms_stime / HZ */,
5949 (double)0 /* t.tms_cutime / HZ */,
5950 (double)0 /* t.tms_cstime / HZ */,
5951 (double)system_uptime() / 1000);
5955 posix_times(PyObject
*self
, PyObject
*noargs
)
5961 if (c
== (clock_t) -1)
5962 return posix_error();
5963 return Py_BuildValue("ddddd",
5964 (double)t
.tms_utime
/ HZ
,
5965 (double)t
.tms_stime
/ HZ
,
5966 (double)t
.tms_cutime
/ HZ
,
5967 (double)t
.tms_cstime
/ HZ
,
5970 #endif /* not OS2 */
5971 #endif /* HAVE_TIMES */
5975 #define HAVE_TIMES /* so the method table will pick it up */
5977 posix_times(PyObject
*self
, PyObject
*noargs
)
5979 FILETIME create
, exit
, kernel
, user
;
5981 hProc
= GetCurrentProcess();
5982 GetProcessTimes(hProc
, &create
, &exit
, &kernel
, &user
);
5983 /* The fields of a FILETIME structure are the hi and lo part
5984 of a 64-bit value expressed in 100 nanosecond units.
5985 1e7 is one second in such units; 1e-7 the inverse.
5986 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
5988 return Py_BuildValue(
5990 (double)(user
.dwHighDateTime
*429.4967296 +
5991 user
.dwLowDateTime
*1e-7),
5992 (double)(kernel
.dwHighDateTime
*429.4967296 +
5993 kernel
.dwLowDateTime
*1e-7),
5998 #endif /* MS_WINDOWS */
6001 PyDoc_STRVAR(posix_times__doc__
,
6002 "times() -> (utime, stime, cutime, cstime, elapsed_time)\n\n\
6003 Return a tuple of floating point numbers indicating process times.");
6008 PyDoc_STRVAR(posix_getsid__doc__
,
6009 "getsid(pid) -> sid\n\n\
6010 Call the system call getsid().");
6013 posix_getsid(PyObject
*self
, PyObject
*args
)
6017 if (!PyArg_ParseTuple(args
, "i:getsid", &pid
))
6021 return posix_error();
6022 return PyInt_FromLong((long)sid
);
6024 #endif /* HAVE_GETSID */
6028 PyDoc_STRVAR(posix_setsid__doc__
,
6030 Call the system call setsid().");
6033 posix_setsid(PyObject
*self
, PyObject
*noargs
)
6036 return posix_error();
6040 #endif /* HAVE_SETSID */
6043 PyDoc_STRVAR(posix_setpgid__doc__
,
6044 "setpgid(pid, pgrp)\n\n\
6045 Call the system call setpgid().");
6048 posix_setpgid(PyObject
*self
, PyObject
*args
)
6052 if (!PyArg_ParseTuple(args
, "ii:setpgid", &pid
, &pgrp
))
6054 if (setpgid(pid
, pgrp
) < 0)
6055 return posix_error();
6059 #endif /* HAVE_SETPGID */
6062 #ifdef HAVE_TCGETPGRP
6063 PyDoc_STRVAR(posix_tcgetpgrp__doc__
,
6064 "tcgetpgrp(fd) -> pgid\n\n\
6065 Return the process group associated with the terminal given by a fd.");
6068 posix_tcgetpgrp(PyObject
*self
, PyObject
*args
)
6072 if (!PyArg_ParseTuple(args
, "i:tcgetpgrp", &fd
))
6074 pgid
= tcgetpgrp(fd
);
6076 return posix_error();
6077 return PyInt_FromLong((long)pgid
);
6079 #endif /* HAVE_TCGETPGRP */
6082 #ifdef HAVE_TCSETPGRP
6083 PyDoc_STRVAR(posix_tcsetpgrp__doc__
,
6084 "tcsetpgrp(fd, pgid)\n\n\
6085 Set the process group associated with the terminal given by a fd.");
6088 posix_tcsetpgrp(PyObject
*self
, PyObject
*args
)
6091 if (!PyArg_ParseTuple(args
, "ii:tcsetpgrp", &fd
, &pgid
))
6093 if (tcsetpgrp(fd
, pgid
) < 0)
6094 return posix_error();
6098 #endif /* HAVE_TCSETPGRP */
6100 /* Functions acting on file descriptors */
6102 PyDoc_STRVAR(posix_open__doc__
,
6103 "open(filename, flag [, mode=0777]) -> fd\n\n\
6104 Open a file (for low level IO).");
6107 posix_open(PyObject
*self
, PyObject
*args
)
6115 if (unicode_file_names()) {
6116 PyUnicodeObject
*po
;
6117 if (PyArg_ParseTuple(args
, "Ui|i:mkdir", &po
, &flag
, &mode
)) {
6118 Py_BEGIN_ALLOW_THREADS
6119 /* PyUnicode_AS_UNICODE OK without thread
6120 lock as it is a simple dereference. */
6121 fd
= _wopen(PyUnicode_AS_UNICODE(po
), flag
, mode
);
6122 Py_END_ALLOW_THREADS
6124 return posix_error();
6125 return PyInt_FromLong((long)fd
);
6127 /* Drop the argument parsing error as narrow strings
6133 if (!PyArg_ParseTuple(args
, "eti|i",
6134 Py_FileSystemDefaultEncoding
, &file
,
6138 Py_BEGIN_ALLOW_THREADS
6139 fd
= open(file
, flag
, mode
);
6140 Py_END_ALLOW_THREADS
6142 return posix_error_with_allocated_filename(file
);
6144 return PyInt_FromLong((long)fd
);
6148 PyDoc_STRVAR(posix_close__doc__
,
6150 Close a file descriptor (for low level IO).");
6153 posix_close(PyObject
*self
, PyObject
*args
)
6156 if (!PyArg_ParseTuple(args
, "i:close", &fd
))
6158 Py_BEGIN_ALLOW_THREADS
6160 Py_END_ALLOW_THREADS
6162 return posix_error();
6168 PyDoc_STRVAR(posix_closerange__doc__
,
6169 "closerange(fd_low, fd_high)\n\n\
6170 Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
6173 posix_closerange(PyObject
*self
, PyObject
*args
)
6175 int fd_from
, fd_to
, i
;
6176 if (!PyArg_ParseTuple(args
, "ii:closerange", &fd_from
, &fd_to
))
6178 Py_BEGIN_ALLOW_THREADS
6179 for (i
= fd_from
; i
< fd_to
; i
++)
6181 Py_END_ALLOW_THREADS
6186 PyDoc_STRVAR(posix_dup__doc__
,
6187 "dup(fd) -> fd2\n\n\
6188 Return a duplicate of a file descriptor.");
6191 posix_dup(PyObject
*self
, PyObject
*args
)
6194 if (!PyArg_ParseTuple(args
, "i:dup", &fd
))
6196 Py_BEGIN_ALLOW_THREADS
6198 Py_END_ALLOW_THREADS
6200 return posix_error();
6201 return PyInt_FromLong((long)fd
);
6205 PyDoc_STRVAR(posix_dup2__doc__
,
6206 "dup2(old_fd, new_fd)\n\n\
6207 Duplicate file descriptor.");
6210 posix_dup2(PyObject
*self
, PyObject
*args
)
6213 if (!PyArg_ParseTuple(args
, "ii:dup2", &fd
, &fd2
))
6215 Py_BEGIN_ALLOW_THREADS
6216 res
= dup2(fd
, fd2
);
6217 Py_END_ALLOW_THREADS
6219 return posix_error();
6225 PyDoc_STRVAR(posix_lseek__doc__
,
6226 "lseek(fd, pos, how) -> newpos\n\n\
6227 Set the current position of a file descriptor.");
6230 posix_lseek(PyObject
*self
, PyObject
*args
)
6233 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6234 PY_LONG_LONG pos
, res
;
6239 if (!PyArg_ParseTuple(args
, "iOi:lseek", &fd
, &posobj
, &how
))
6242 /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
6244 case 0: how
= SEEK_SET
; break;
6245 case 1: how
= SEEK_CUR
; break;
6246 case 2: how
= SEEK_END
; break;
6248 #endif /* SEEK_END */
6250 #if !defined(HAVE_LARGEFILE_SUPPORT)
6251 pos
= PyInt_AsLong(posobj
);
6253 pos
= PyLong_Check(posobj
) ?
6254 PyLong_AsLongLong(posobj
) : PyInt_AsLong(posobj
);
6256 if (PyErr_Occurred())
6259 Py_BEGIN_ALLOW_THREADS
6260 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6261 res
= _lseeki64(fd
, pos
, how
);
6263 res
= lseek(fd
, pos
, how
);
6265 Py_END_ALLOW_THREADS
6267 return posix_error();
6269 #if !defined(HAVE_LARGEFILE_SUPPORT)
6270 return PyInt_FromLong(res
);
6272 return PyLong_FromLongLong(res
);
6277 PyDoc_STRVAR(posix_read__doc__
,
6278 "read(fd, buffersize) -> string\n\n\
6279 Read a file descriptor.");
6282 posix_read(PyObject
*self
, PyObject
*args
)
6286 if (!PyArg_ParseTuple(args
, "ii:read", &fd
, &size
))
6290 return posix_error();
6292 buffer
= PyString_FromStringAndSize((char *)NULL
, size
);
6295 Py_BEGIN_ALLOW_THREADS
6296 n
= read(fd
, PyString_AsString(buffer
), size
);
6297 Py_END_ALLOW_THREADS
6300 return posix_error();
6303 _PyString_Resize(&buffer
, n
);
6308 PyDoc_STRVAR(posix_write__doc__
,
6309 "write(fd, string) -> byteswritten\n\n\
6310 Write a string to a file descriptor.");
6313 posix_write(PyObject
*self
, PyObject
*args
)
6319 if (!PyArg_ParseTuple(args
, "is#:write", &fd
, &buffer
, &size
))
6321 Py_BEGIN_ALLOW_THREADS
6322 size
= write(fd
, buffer
, (size_t)size
);
6323 Py_END_ALLOW_THREADS
6325 return posix_error();
6326 return PyInt_FromSsize_t(size
);
6330 PyDoc_STRVAR(posix_fstat__doc__
,
6331 "fstat(fd) -> stat result\n\n\
6332 Like stat(), but for an open file descriptor.");
6335 posix_fstat(PyObject
*self
, PyObject
*args
)
6340 if (!PyArg_ParseTuple(args
, "i:fstat", &fd
))
6343 /* on OpenVMS we must ensure that all bytes are written to the file */
6346 Py_BEGIN_ALLOW_THREADS
6347 res
= FSTAT(fd
, &st
);
6348 Py_END_ALLOW_THREADS
6351 return win32_error("fstat", NULL
);
6353 return posix_error();
6357 return _pystat_fromstructstat(&st
);
6361 PyDoc_STRVAR(posix_fdopen__doc__
,
6362 "fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\n\
6363 Return an open file object connected to a file descriptor.");
6366 posix_fdopen(PyObject
*self
, PyObject
*args
)
6369 char *orgmode
= "r";
6374 if (!PyArg_ParseTuple(args
, "i|si", &fd
, &orgmode
, &bufsize
))
6377 /* Sanitize mode. See fileobject.c */
6378 mode
= PyMem_MALLOC(strlen(orgmode
)+3);
6383 strcpy(mode
, orgmode
);
6384 if (_PyFile_SanitizeMode(mode
)) {
6388 Py_BEGIN_ALLOW_THREADS
6389 #if !defined(MS_WINDOWS) && defined(HAVE_FCNTL_H)
6390 if (mode
[0] == 'a') {
6391 /* try to make sure the O_APPEND flag is set */
6393 flags
= fcntl(fd
, F_GETFL
);
6395 fcntl(fd
, F_SETFL
, flags
| O_APPEND
);
6396 fp
= fdopen(fd
, mode
);
6397 if (fp
== NULL
&& flags
!= -1)
6398 /* restore old mode if fdopen failed */
6399 fcntl(fd
, F_SETFL
, flags
);
6401 fp
= fdopen(fd
, mode
);
6404 fp
= fdopen(fd
, mode
);
6406 Py_END_ALLOW_THREADS
6409 return posix_error();
6410 f
= PyFile_FromFile(fp
, "<fdopen>", orgmode
, fclose
);
6412 PyFile_SetBufSize(f
, bufsize
);
6416 PyDoc_STRVAR(posix_isatty__doc__
,
6417 "isatty(fd) -> bool\n\n\
6418 Return True if the file descriptor 'fd' is an open file descriptor\n\
6419 connected to the slave end of a terminal.");
6422 posix_isatty(PyObject
*self
, PyObject
*args
)
6425 if (!PyArg_ParseTuple(args
, "i:isatty", &fd
))
6427 return PyBool_FromLong(isatty(fd
));
6431 PyDoc_STRVAR(posix_pipe__doc__
,
6432 "pipe() -> (read_end, write_end)\n\n\
6436 posix_pipe(PyObject
*self
, PyObject
*noargs
)
6438 #if defined(PYOS_OS2)
6442 Py_BEGIN_ALLOW_THREADS
6443 rc
= DosCreatePipe( &read
, &write
, 4096);
6444 Py_END_ALLOW_THREADS
6446 return os2_error(rc
);
6448 return Py_BuildValue("(ii)", read
, write
);
6450 #if !defined(MS_WINDOWS)
6453 Py_BEGIN_ALLOW_THREADS
6455 Py_END_ALLOW_THREADS
6457 return posix_error();
6458 return Py_BuildValue("(ii)", fds
[0], fds
[1]);
6459 #else /* MS_WINDOWS */
6461 int read_fd
, write_fd
;
6463 Py_BEGIN_ALLOW_THREADS
6464 ok
= CreatePipe(&read
, &write
, NULL
, 0);
6465 Py_END_ALLOW_THREADS
6467 return win32_error("CreatePipe", NULL
);
6468 read_fd
= _open_osfhandle((Py_intptr_t
)read
, 0);
6469 write_fd
= _open_osfhandle((Py_intptr_t
)write
, 1);
6470 return Py_BuildValue("(ii)", read_fd
, write_fd
);
6471 #endif /* MS_WINDOWS */
6474 #endif /* HAVE_PIPE */
6478 PyDoc_STRVAR(posix_mkfifo__doc__
,
6479 "mkfifo(filename [, mode=0666])\n\n\
6480 Create a FIFO (a POSIX named pipe).");
6483 posix_mkfifo(PyObject
*self
, PyObject
*args
)
6488 if (!PyArg_ParseTuple(args
, "s|i:mkfifo", &filename
, &mode
))
6490 Py_BEGIN_ALLOW_THREADS
6491 res
= mkfifo(filename
, mode
);
6492 Py_END_ALLOW_THREADS
6494 return posix_error();
6501 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
6502 PyDoc_STRVAR(posix_mknod__doc__
,
6503 "mknod(filename [, mode=0600, device])\n\n\
6504 Create a filesystem node (file, device special file or named pipe)\n\
6505 named filename. mode specifies both the permissions to use and the\n\
6506 type of node to be created, being combined (bitwise OR) with one of\n\
6507 S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\n\
6508 device defines the newly created device special file (probably using\n\
6509 os.makedev()), otherwise it is ignored.");
6513 posix_mknod(PyObject
*self
, PyObject
*args
)
6519 if (!PyArg_ParseTuple(args
, "s|ii:mknod", &filename
, &mode
, &device
))
6521 Py_BEGIN_ALLOW_THREADS
6522 res
= mknod(filename
, mode
, device
);
6523 Py_END_ALLOW_THREADS
6525 return posix_error();
6531 #ifdef HAVE_DEVICE_MACROS
6532 PyDoc_STRVAR(posix_major__doc__
,
6533 "major(device) -> major number\n\
6534 Extracts a device major number from a raw device number.");
6537 posix_major(PyObject
*self
, PyObject
*args
)
6540 if (!PyArg_ParseTuple(args
, "i:major", &device
))
6542 return PyInt_FromLong((long)major(device
));
6545 PyDoc_STRVAR(posix_minor__doc__
,
6546 "minor(device) -> minor number\n\
6547 Extracts a device minor number from a raw device number.");
6550 posix_minor(PyObject
*self
, PyObject
*args
)
6553 if (!PyArg_ParseTuple(args
, "i:minor", &device
))
6555 return PyInt_FromLong((long)minor(device
));
6558 PyDoc_STRVAR(posix_makedev__doc__
,
6559 "makedev(major, minor) -> device number\n\
6560 Composes a raw device number from the major and minor device numbers.");
6563 posix_makedev(PyObject
*self
, PyObject
*args
)
6566 if (!PyArg_ParseTuple(args
, "ii:makedev", &major
, &minor
))
6568 return PyInt_FromLong((long)makedev(major
, minor
));
6570 #endif /* device macros */
6573 #ifdef HAVE_FTRUNCATE
6574 PyDoc_STRVAR(posix_ftruncate__doc__
,
6575 "ftruncate(fd, length)\n\n\
6576 Truncate a file to a specified length.");
6579 posix_ftruncate(PyObject
*self
, PyObject
*args
)
6586 if (!PyArg_ParseTuple(args
, "iO:ftruncate", &fd
, &lenobj
))
6589 #if !defined(HAVE_LARGEFILE_SUPPORT)
6590 length
= PyInt_AsLong(lenobj
);
6592 length
= PyLong_Check(lenobj
) ?
6593 PyLong_AsLongLong(lenobj
) : PyInt_AsLong(lenobj
);
6595 if (PyErr_Occurred())
6598 Py_BEGIN_ALLOW_THREADS
6599 res
= ftruncate(fd
, length
);
6600 Py_END_ALLOW_THREADS
6602 PyErr_SetFromErrno(PyExc_IOError
);
6611 PyDoc_STRVAR(posix_putenv__doc__
,
6612 "putenv(key, value)\n\n\
6613 Change or add an environment variable.");
6615 /* Save putenv() parameters as values here, so we can collect them when they
6616 * get re-set with another call for the same key. */
6617 static PyObject
*posix_putenv_garbage
;
6620 posix_putenv(PyObject
*self
, PyObject
*args
)
6627 if (!PyArg_ParseTuple(args
, "ss:putenv", &s1
, &s2
))
6630 #if defined(PYOS_OS2)
6631 if (stricmp(s1
, "BEGINLIBPATH") == 0) {
6634 rc
= DosSetExtLIBPATH(s2
, BEGIN_LIBPATH
);
6636 return os2_error(rc
);
6638 } else if (stricmp(s1
, "ENDLIBPATH") == 0) {
6641 rc
= DosSetExtLIBPATH(s2
, END_LIBPATH
);
6643 return os2_error(rc
);
6647 /* XXX This can leak memory -- not easy to fix :-( */
6648 len
= strlen(s1
) + strlen(s2
) + 2;
6649 /* len includes space for a trailing \0; the size arg to
6650 PyString_FromStringAndSize does not count that */
6651 newstr
= PyString_FromStringAndSize(NULL
, (int)len
- 1);
6653 return PyErr_NoMemory();
6654 newenv
= PyString_AS_STRING(newstr
);
6655 PyOS_snprintf(newenv
, len
, "%s=%s", s1
, s2
);
6656 if (putenv(newenv
)) {
6661 /* Install the first arg and newstr in posix_putenv_garbage;
6662 * this will cause previous value to be collected. This has to
6663 * happen after the real putenv() call because the old value
6664 * was still accessible until then. */
6665 if (PyDict_SetItem(posix_putenv_garbage
,
6666 PyTuple_GET_ITEM(args
, 0), newstr
)) {
6667 /* really not much we can do; just leak */
6674 #if defined(PYOS_OS2)
6682 #ifdef HAVE_UNSETENV
6683 PyDoc_STRVAR(posix_unsetenv__doc__
,
6685 Delete an environment variable.");
6688 posix_unsetenv(PyObject
*self
, PyObject
*args
)
6692 if (!PyArg_ParseTuple(args
, "s:unsetenv", &s1
))
6697 /* Remove the key from posix_putenv_garbage;
6698 * this will cause it to be collected. This has to
6699 * happen after the real unsetenv() call because the
6700 * old value was still accessible until then.
6702 if (PyDict_DelItem(posix_putenv_garbage
,
6703 PyTuple_GET_ITEM(args
, 0))) {
6704 /* really not much we can do; just leak */
6711 #endif /* unsetenv */
6713 PyDoc_STRVAR(posix_strerror__doc__
,
6714 "strerror(code) -> string\n\n\
6715 Translate an error code to a message string.");
6718 posix_strerror(PyObject
*self
, PyObject
*args
)
6722 if (!PyArg_ParseTuple(args
, "i:strerror", &code
))
6724 message
= strerror(code
);
6725 if (message
== NULL
) {
6726 PyErr_SetString(PyExc_ValueError
,
6727 "strerror() argument out of range");
6730 return PyString_FromString(message
);
6734 #ifdef HAVE_SYS_WAIT_H
6737 PyDoc_STRVAR(posix_WCOREDUMP__doc__
,
6738 "WCOREDUMP(status) -> bool\n\n\
6739 Return True if the process returning 'status' was dumped to a core file.");
6742 posix_WCOREDUMP(PyObject
*self
, PyObject
*args
)
6745 WAIT_STATUS_INT(status
) = 0;
6747 if (!PyArg_ParseTuple(args
, "i:WCOREDUMP", &WAIT_STATUS_INT(status
)))
6750 return PyBool_FromLong(WCOREDUMP(status
));
6752 #endif /* WCOREDUMP */
6755 PyDoc_STRVAR(posix_WIFCONTINUED__doc__
,
6756 "WIFCONTINUED(status) -> bool\n\n\
6757 Return True if the process returning 'status' was continued from a\n\
6758 job control stop.");
6761 posix_WIFCONTINUED(PyObject
*self
, PyObject
*args
)
6764 WAIT_STATUS_INT(status
) = 0;
6766 if (!PyArg_ParseTuple(args
, "i:WCONTINUED", &WAIT_STATUS_INT(status
)))
6769 return PyBool_FromLong(WIFCONTINUED(status
));
6771 #endif /* WIFCONTINUED */
6774 PyDoc_STRVAR(posix_WIFSTOPPED__doc__
,
6775 "WIFSTOPPED(status) -> bool\n\n\
6776 Return True if the process returning 'status' was stopped.");
6779 posix_WIFSTOPPED(PyObject
*self
, PyObject
*args
)
6782 WAIT_STATUS_INT(status
) = 0;
6784 if (!PyArg_ParseTuple(args
, "i:WIFSTOPPED", &WAIT_STATUS_INT(status
)))
6787 return PyBool_FromLong(WIFSTOPPED(status
));
6789 #endif /* WIFSTOPPED */
6792 PyDoc_STRVAR(posix_WIFSIGNALED__doc__
,
6793 "WIFSIGNALED(status) -> bool\n\n\
6794 Return True if the process returning 'status' was terminated by a signal.");
6797 posix_WIFSIGNALED(PyObject
*self
, PyObject
*args
)
6800 WAIT_STATUS_INT(status
) = 0;
6802 if (!PyArg_ParseTuple(args
, "i:WIFSIGNALED", &WAIT_STATUS_INT(status
)))
6805 return PyBool_FromLong(WIFSIGNALED(status
));
6807 #endif /* WIFSIGNALED */
6810 PyDoc_STRVAR(posix_WIFEXITED__doc__
,
6811 "WIFEXITED(status) -> bool\n\n\
6812 Return true if the process returning 'status' exited using the exit()\n\
6816 posix_WIFEXITED(PyObject
*self
, PyObject
*args
)
6819 WAIT_STATUS_INT(status
) = 0;
6821 if (!PyArg_ParseTuple(args
, "i:WIFEXITED", &WAIT_STATUS_INT(status
)))
6824 return PyBool_FromLong(WIFEXITED(status
));
6826 #endif /* WIFEXITED */
6829 PyDoc_STRVAR(posix_WEXITSTATUS__doc__
,
6830 "WEXITSTATUS(status) -> integer\n\n\
6831 Return the process return code from 'status'.");
6834 posix_WEXITSTATUS(PyObject
*self
, PyObject
*args
)
6837 WAIT_STATUS_INT(status
) = 0;
6839 if (!PyArg_ParseTuple(args
, "i:WEXITSTATUS", &WAIT_STATUS_INT(status
)))
6842 return Py_BuildValue("i", WEXITSTATUS(status
));
6844 #endif /* WEXITSTATUS */
6847 PyDoc_STRVAR(posix_WTERMSIG__doc__
,
6848 "WTERMSIG(status) -> integer\n\n\
6849 Return the signal that terminated the process that provided the 'status'\n\
6853 posix_WTERMSIG(PyObject
*self
, PyObject
*args
)
6856 WAIT_STATUS_INT(status
) = 0;
6858 if (!PyArg_ParseTuple(args
, "i:WTERMSIG", &WAIT_STATUS_INT(status
)))
6861 return Py_BuildValue("i", WTERMSIG(status
));
6863 #endif /* WTERMSIG */
6866 PyDoc_STRVAR(posix_WSTOPSIG__doc__
,
6867 "WSTOPSIG(status) -> integer\n\n\
6868 Return the signal that stopped the process that provided\n\
6869 the 'status' value.");
6872 posix_WSTOPSIG(PyObject
*self
, PyObject
*args
)
6875 WAIT_STATUS_INT(status
) = 0;
6877 if (!PyArg_ParseTuple(args
, "i:WSTOPSIG", &WAIT_STATUS_INT(status
)))
6880 return Py_BuildValue("i", WSTOPSIG(status
));
6882 #endif /* WSTOPSIG */
6884 #endif /* HAVE_SYS_WAIT_H */
6887 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
6889 /* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the
6890 needed definitions in sys/statvfs.h */
6893 #include <sys/statvfs.h>
6896 _pystatvfs_fromstructstatvfs(struct statvfs st
) {
6897 PyObject
*v
= PyStructSequence_New(&StatVFSResultType
);
6901 #if !defined(HAVE_LARGEFILE_SUPPORT)
6902 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
6903 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
6904 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long) st
.f_blocks
));
6905 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long) st
.f_bfree
));
6906 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long) st
.f_bavail
));
6907 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long) st
.f_files
));
6908 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong((long) st
.f_ffree
));
6909 PyStructSequence_SET_ITEM(v
, 7, PyInt_FromLong((long) st
.f_favail
));
6910 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
6911 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
6913 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
6914 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
6915 PyStructSequence_SET_ITEM(v
, 2,
6916 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_blocks
));
6917 PyStructSequence_SET_ITEM(v
, 3,
6918 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bfree
));
6919 PyStructSequence_SET_ITEM(v
, 4,
6920 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bavail
));
6921 PyStructSequence_SET_ITEM(v
, 5,
6922 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_files
));
6923 PyStructSequence_SET_ITEM(v
, 6,
6924 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_ffree
));
6925 PyStructSequence_SET_ITEM(v
, 7,
6926 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_favail
));
6927 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
6928 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
6934 PyDoc_STRVAR(posix_fstatvfs__doc__
,
6935 "fstatvfs(fd) -> statvfs result\n\n\
6936 Perform an fstatvfs system call on the given fd.");
6939 posix_fstatvfs(PyObject
*self
, PyObject
*args
)
6944 if (!PyArg_ParseTuple(args
, "i:fstatvfs", &fd
))
6946 Py_BEGIN_ALLOW_THREADS
6947 res
= fstatvfs(fd
, &st
);
6948 Py_END_ALLOW_THREADS
6950 return posix_error();
6952 return _pystatvfs_fromstructstatvfs(st
);
6954 #endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */
6957 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
6958 #include <sys/statvfs.h>
6960 PyDoc_STRVAR(posix_statvfs__doc__
,
6961 "statvfs(path) -> statvfs result\n\n\
6962 Perform a statvfs system call on the given path.");
6965 posix_statvfs(PyObject
*self
, PyObject
*args
)
6970 if (!PyArg_ParseTuple(args
, "s:statvfs", &path
))
6972 Py_BEGIN_ALLOW_THREADS
6973 res
= statvfs(path
, &st
);
6974 Py_END_ALLOW_THREADS
6976 return posix_error_with_filename(path
);
6978 return _pystatvfs_fromstructstatvfs(st
);
6980 #endif /* HAVE_STATVFS */
6984 PyDoc_STRVAR(posix_tempnam__doc__
,
6985 "tempnam([dir[, prefix]]) -> string\n\n\
6986 Return a unique name for a temporary file.\n\
6987 The directory and a prefix may be specified as strings; they may be omitted\n\
6988 or None if not needed.");
6991 posix_tempnam(PyObject
*self
, PyObject
*args
)
6993 PyObject
*result
= NULL
;
6998 if (!PyArg_ParseTuple(args
, "|zz:tempnam", &dir
, &pfx
))
7001 if (PyErr_Warn(PyExc_RuntimeWarning
,
7002 "tempnam is a potential security risk to your program") < 0)
7006 name
= _tempnam(dir
, pfx
);
7008 name
= tempnam(dir
, pfx
);
7011 return PyErr_NoMemory();
7012 result
= PyString_FromString(name
);
7020 PyDoc_STRVAR(posix_tmpfile__doc__
,
7021 "tmpfile() -> file object\n\n\
7022 Create a temporary file with no directory entries.");
7025 posix_tmpfile(PyObject
*self
, PyObject
*noargs
)
7031 return posix_error();
7032 return PyFile_FromFile(fp
, "<tmpfile>", "w+b", fclose
);
7038 PyDoc_STRVAR(posix_tmpnam__doc__
,
7039 "tmpnam() -> string\n\n\
7040 Return a unique name for a temporary file.");
7043 posix_tmpnam(PyObject
*self
, PyObject
*noargs
)
7045 char buffer
[L_tmpnam
];
7048 if (PyErr_Warn(PyExc_RuntimeWarning
,
7049 "tmpnam is a potential security risk to your program") < 0)
7053 name
= tmpnam_r(buffer
);
7055 name
= tmpnam(buffer
);
7058 PyObject
*err
= Py_BuildValue("is", 0,
7060 "unexpected NULL from tmpnam_r"
7062 "unexpected NULL from tmpnam"
7065 PyErr_SetObject(PyExc_OSError
, err
);
7069 return PyString_FromString(buffer
);
7074 /* This is used for fpathconf(), pathconf(), confstr() and sysconf().
7075 * It maps strings representing configuration variable names to
7076 * integer values, allowing those functions to be called with the
7077 * magic names instead of polluting the module's namespace with tons of
7078 * rarely-used constants. There are three separate tables that use
7079 * these definitions.
7081 * This code is always included, even if none of the interfaces that
7082 * need it are included. The #if hackery needed to avoid it would be
7083 * sufficiently pervasive that it's not worth the loss of readability.
7091 conv_confname(PyObject
*arg
, int *valuep
, struct constdef
*table
,
7094 if (PyInt_Check(arg
)) {
7095 *valuep
= PyInt_AS_LONG(arg
);
7098 if (PyString_Check(arg
)) {
7099 /* look up the value in the table using a binary search */
7102 size_t hi
= tablesize
;
7104 char *confname
= PyString_AS_STRING(arg
);
7106 mid
= (lo
+ hi
) / 2;
7107 cmp
= strcmp(confname
, table
[mid
].name
);
7113 *valuep
= table
[mid
].value
;
7117 PyErr_SetString(PyExc_ValueError
, "unrecognized configuration name");
7120 PyErr_SetString(PyExc_TypeError
,
7121 "configuration names must be strings or integers");
7126 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
7127 static struct constdef posix_constants_pathconf
[] = {
7128 #ifdef _PC_ABI_AIO_XFER_MAX
7129 {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX
},
7131 #ifdef _PC_ABI_ASYNC_IO
7132 {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO
},
7135 {"PC_ASYNC_IO", _PC_ASYNC_IO
},
7137 #ifdef _PC_CHOWN_RESTRICTED
7138 {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED
},
7140 #ifdef _PC_FILESIZEBITS
7141 {"PC_FILESIZEBITS", _PC_FILESIZEBITS
},
7144 {"PC_LAST", _PC_LAST
},
7147 {"PC_LINK_MAX", _PC_LINK_MAX
},
7149 #ifdef _PC_MAX_CANON
7150 {"PC_MAX_CANON", _PC_MAX_CANON
},
7152 #ifdef _PC_MAX_INPUT
7153 {"PC_MAX_INPUT", _PC_MAX_INPUT
},
7156 {"PC_NAME_MAX", _PC_NAME_MAX
},
7159 {"PC_NO_TRUNC", _PC_NO_TRUNC
},
7162 {"PC_PATH_MAX", _PC_PATH_MAX
},
7165 {"PC_PIPE_BUF", _PC_PIPE_BUF
},
7168 {"PC_PRIO_IO", _PC_PRIO_IO
},
7170 #ifdef _PC_SOCK_MAXBUF
7171 {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF
},
7174 {"PC_SYNC_IO", _PC_SYNC_IO
},
7177 {"PC_VDISABLE", _PC_VDISABLE
},
7182 conv_path_confname(PyObject
*arg
, int *valuep
)
7184 return conv_confname(arg
, valuep
, posix_constants_pathconf
,
7185 sizeof(posix_constants_pathconf
)
7186 / sizeof(struct constdef
));
7190 #ifdef HAVE_FPATHCONF
7191 PyDoc_STRVAR(posix_fpathconf__doc__
,
7192 "fpathconf(fd, name) -> integer\n\n\
7193 Return the configuration limit name for the file descriptor fd.\n\
7194 If there is no limit, return -1.");
7197 posix_fpathconf(PyObject
*self
, PyObject
*args
)
7199 PyObject
*result
= NULL
;
7202 if (PyArg_ParseTuple(args
, "iO&:fpathconf", &fd
,
7203 conv_path_confname
, &name
)) {
7207 limit
= fpathconf(fd
, name
);
7208 if (limit
== -1 && errno
!= 0)
7211 result
= PyInt_FromLong(limit
);
7218 #ifdef HAVE_PATHCONF
7219 PyDoc_STRVAR(posix_pathconf__doc__
,
7220 "pathconf(path, name) -> integer\n\n\
7221 Return the configuration limit name for the file or directory path.\n\
7222 If there is no limit, return -1.");
7225 posix_pathconf(PyObject
*self
, PyObject
*args
)
7227 PyObject
*result
= NULL
;
7231 if (PyArg_ParseTuple(args
, "sO&:pathconf", &path
,
7232 conv_path_confname
, &name
)) {
7236 limit
= pathconf(path
, name
);
7237 if (limit
== -1 && errno
!= 0) {
7238 if (errno
== EINVAL
)
7239 /* could be a path or name problem */
7242 posix_error_with_filename(path
);
7245 result
= PyInt_FromLong(limit
);
7252 static struct constdef posix_constants_confstr
[] = {
7253 #ifdef _CS_ARCHITECTURE
7254 {"CS_ARCHITECTURE", _CS_ARCHITECTURE
},
7257 {"CS_HOSTNAME", _CS_HOSTNAME
},
7259 #ifdef _CS_HW_PROVIDER
7260 {"CS_HW_PROVIDER", _CS_HW_PROVIDER
},
7262 #ifdef _CS_HW_SERIAL
7263 {"CS_HW_SERIAL", _CS_HW_SERIAL
},
7265 #ifdef _CS_INITTAB_NAME
7266 {"CS_INITTAB_NAME", _CS_INITTAB_NAME
},
7268 #ifdef _CS_LFS64_CFLAGS
7269 {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS
},
7271 #ifdef _CS_LFS64_LDFLAGS
7272 {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS
},
7274 #ifdef _CS_LFS64_LIBS
7275 {"CS_LFS64_LIBS", _CS_LFS64_LIBS
},
7277 #ifdef _CS_LFS64_LINTFLAGS
7278 {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS
},
7280 #ifdef _CS_LFS_CFLAGS
7281 {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS
},
7283 #ifdef _CS_LFS_LDFLAGS
7284 {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS
},
7287 {"CS_LFS_LIBS", _CS_LFS_LIBS
},
7289 #ifdef _CS_LFS_LINTFLAGS
7290 {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS
},
7293 {"CS_MACHINE", _CS_MACHINE
},
7296 {"CS_PATH", _CS_PATH
},
7299 {"CS_RELEASE", _CS_RELEASE
},
7301 #ifdef _CS_SRPC_DOMAIN
7302 {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN
},
7305 {"CS_SYSNAME", _CS_SYSNAME
},
7308 {"CS_VERSION", _CS_VERSION
},
7310 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
7311 {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS
},
7313 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
7314 {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS
},
7316 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
7317 {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS
},
7319 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
7320 {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS
},
7322 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
7323 {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS
},
7325 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
7326 {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS
},
7328 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
7329 {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS
},
7331 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
7332 {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
},
7334 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
7335 {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS
},
7337 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
7338 {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS
},
7340 #ifdef _CS_XBS5_LP64_OFF64_LIBS
7341 {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS
},
7343 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
7344 {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS
},
7346 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
7347 {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS
},
7349 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
7350 {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
},
7352 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
7353 {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS
},
7355 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
7356 {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
},
7358 #ifdef _MIPS_CS_AVAIL_PROCESSORS
7359 {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS
},
7361 #ifdef _MIPS_CS_BASE
7362 {"MIPS_CS_BASE", _MIPS_CS_BASE
},
7364 #ifdef _MIPS_CS_HOSTID
7365 {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID
},
7367 #ifdef _MIPS_CS_HW_NAME
7368 {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME
},
7370 #ifdef _MIPS_CS_NUM_PROCESSORS
7371 {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS
},
7373 #ifdef _MIPS_CS_OSREL_MAJ
7374 {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ
},
7376 #ifdef _MIPS_CS_OSREL_MIN
7377 {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN
},
7379 #ifdef _MIPS_CS_OSREL_PATCH
7380 {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH
},
7382 #ifdef _MIPS_CS_OS_NAME
7383 {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME
},
7385 #ifdef _MIPS_CS_OS_PROVIDER
7386 {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER
},
7388 #ifdef _MIPS_CS_PROCESSORS
7389 {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS
},
7391 #ifdef _MIPS_CS_SERIAL
7392 {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL
},
7394 #ifdef _MIPS_CS_VENDOR
7395 {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR
},
7400 conv_confstr_confname(PyObject
*arg
, int *valuep
)
7402 return conv_confname(arg
, valuep
, posix_constants_confstr
,
7403 sizeof(posix_constants_confstr
)
7404 / sizeof(struct constdef
));
7407 PyDoc_STRVAR(posix_confstr__doc__
,
7408 "confstr(name) -> string\n\n\
7409 Return a string-valued system configuration variable.");
7412 posix_confstr(PyObject
*self
, PyObject
*args
)
7414 PyObject
*result
= NULL
;
7418 if (PyArg_ParseTuple(args
, "O&:confstr", conv_confstr_confname
, &name
)) {
7422 len
= confstr(name
, buffer
, sizeof(buffer
));
7433 if ((unsigned int)len
>= sizeof(buffer
)) {
7434 result
= PyString_FromStringAndSize(NULL
, len
-1);
7436 confstr(name
, PyString_AS_STRING(result
), len
);
7439 result
= PyString_FromStringAndSize(buffer
, len
-1);
7448 static struct constdef posix_constants_sysconf
[] = {
7449 #ifdef _SC_2_CHAR_TERM
7450 {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM
},
7453 {"SC_2_C_BIND", _SC_2_C_BIND
},
7456 {"SC_2_C_DEV", _SC_2_C_DEV
},
7458 #ifdef _SC_2_C_VERSION
7459 {"SC_2_C_VERSION", _SC_2_C_VERSION
},
7461 #ifdef _SC_2_FORT_DEV
7462 {"SC_2_FORT_DEV", _SC_2_FORT_DEV
},
7464 #ifdef _SC_2_FORT_RUN
7465 {"SC_2_FORT_RUN", _SC_2_FORT_RUN
},
7467 #ifdef _SC_2_LOCALEDEF
7468 {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF
},
7471 {"SC_2_SW_DEV", _SC_2_SW_DEV
},
7474 {"SC_2_UPE", _SC_2_UPE
},
7476 #ifdef _SC_2_VERSION
7477 {"SC_2_VERSION", _SC_2_VERSION
},
7479 #ifdef _SC_ABI_ASYNCHRONOUS_IO
7480 {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO
},
7483 {"SC_ACL", _SC_ACL
},
7485 #ifdef _SC_AIO_LISTIO_MAX
7486 {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX
},
7489 {"SC_AIO_MAX", _SC_AIO_MAX
},
7491 #ifdef _SC_AIO_PRIO_DELTA_MAX
7492 {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX
},
7495 {"SC_ARG_MAX", _SC_ARG_MAX
},
7497 #ifdef _SC_ASYNCHRONOUS_IO
7498 {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO
},
7500 #ifdef _SC_ATEXIT_MAX
7501 {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX
},
7504 {"SC_AUDIT", _SC_AUDIT
},
7506 #ifdef _SC_AVPHYS_PAGES
7507 {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES
},
7509 #ifdef _SC_BC_BASE_MAX
7510 {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX
},
7512 #ifdef _SC_BC_DIM_MAX
7513 {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX
},
7515 #ifdef _SC_BC_SCALE_MAX
7516 {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX
},
7518 #ifdef _SC_BC_STRING_MAX
7519 {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX
},
7522 {"SC_CAP", _SC_CAP
},
7524 #ifdef _SC_CHARCLASS_NAME_MAX
7525 {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX
},
7528 {"SC_CHAR_BIT", _SC_CHAR_BIT
},
7531 {"SC_CHAR_MAX", _SC_CHAR_MAX
},
7534 {"SC_CHAR_MIN", _SC_CHAR_MIN
},
7536 #ifdef _SC_CHILD_MAX
7537 {"SC_CHILD_MAX", _SC_CHILD_MAX
},
7540 {"SC_CLK_TCK", _SC_CLK_TCK
},
7542 #ifdef _SC_COHER_BLKSZ
7543 {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ
},
7545 #ifdef _SC_COLL_WEIGHTS_MAX
7546 {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX
},
7548 #ifdef _SC_DCACHE_ASSOC
7549 {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC
},
7551 #ifdef _SC_DCACHE_BLKSZ
7552 {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ
},
7554 #ifdef _SC_DCACHE_LINESZ
7555 {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ
},
7557 #ifdef _SC_DCACHE_SZ
7558 {"SC_DCACHE_SZ", _SC_DCACHE_SZ
},
7560 #ifdef _SC_DCACHE_TBLKSZ
7561 {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ
},
7563 #ifdef _SC_DELAYTIMER_MAX
7564 {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX
},
7566 #ifdef _SC_EQUIV_CLASS_MAX
7567 {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX
},
7569 #ifdef _SC_EXPR_NEST_MAX
7570 {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX
},
7573 {"SC_FSYNC", _SC_FSYNC
},
7575 #ifdef _SC_GETGR_R_SIZE_MAX
7576 {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX
},
7578 #ifdef _SC_GETPW_R_SIZE_MAX
7579 {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX
},
7581 #ifdef _SC_ICACHE_ASSOC
7582 {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC
},
7584 #ifdef _SC_ICACHE_BLKSZ
7585 {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ
},
7587 #ifdef _SC_ICACHE_LINESZ
7588 {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ
},
7590 #ifdef _SC_ICACHE_SZ
7591 {"SC_ICACHE_SZ", _SC_ICACHE_SZ
},
7594 {"SC_INF", _SC_INF
},
7597 {"SC_INT_MAX", _SC_INT_MAX
},
7600 {"SC_INT_MIN", _SC_INT_MIN
},
7603 {"SC_IOV_MAX", _SC_IOV_MAX
},
7605 #ifdef _SC_IP_SECOPTS
7606 {"SC_IP_SECOPTS", _SC_IP_SECOPTS
},
7608 #ifdef _SC_JOB_CONTROL
7609 {"SC_JOB_CONTROL", _SC_JOB_CONTROL
},
7611 #ifdef _SC_KERN_POINTERS
7612 {"SC_KERN_POINTERS", _SC_KERN_POINTERS
},
7615 {"SC_KERN_SIM", _SC_KERN_SIM
},
7618 {"SC_LINE_MAX", _SC_LINE_MAX
},
7620 #ifdef _SC_LOGIN_NAME_MAX
7621 {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX
},
7623 #ifdef _SC_LOGNAME_MAX
7624 {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX
},
7627 {"SC_LONG_BIT", _SC_LONG_BIT
},
7630 {"SC_MAC", _SC_MAC
},
7632 #ifdef _SC_MAPPED_FILES
7633 {"SC_MAPPED_FILES", _SC_MAPPED_FILES
},
7636 {"SC_MAXPID", _SC_MAXPID
},
7638 #ifdef _SC_MB_LEN_MAX
7639 {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX
},
7642 {"SC_MEMLOCK", _SC_MEMLOCK
},
7644 #ifdef _SC_MEMLOCK_RANGE
7645 {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE
},
7647 #ifdef _SC_MEMORY_PROTECTION
7648 {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION
},
7650 #ifdef _SC_MESSAGE_PASSING
7651 {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING
},
7653 #ifdef _SC_MMAP_FIXED_ALIGNMENT
7654 {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT
},
7656 #ifdef _SC_MQ_OPEN_MAX
7657 {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX
},
7659 #ifdef _SC_MQ_PRIO_MAX
7660 {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX
},
7662 #ifdef _SC_NACLS_MAX
7663 {"SC_NACLS_MAX", _SC_NACLS_MAX
},
7665 #ifdef _SC_NGROUPS_MAX
7666 {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX
},
7668 #ifdef _SC_NL_ARGMAX
7669 {"SC_NL_ARGMAX", _SC_NL_ARGMAX
},
7671 #ifdef _SC_NL_LANGMAX
7672 {"SC_NL_LANGMAX", _SC_NL_LANGMAX
},
7674 #ifdef _SC_NL_MSGMAX
7675 {"SC_NL_MSGMAX", _SC_NL_MSGMAX
},
7678 {"SC_NL_NMAX", _SC_NL_NMAX
},
7680 #ifdef _SC_NL_SETMAX
7681 {"SC_NL_SETMAX", _SC_NL_SETMAX
},
7683 #ifdef _SC_NL_TEXTMAX
7684 {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX
},
7686 #ifdef _SC_NPROCESSORS_CONF
7687 {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF
},
7689 #ifdef _SC_NPROCESSORS_ONLN
7690 {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN
},
7692 #ifdef _SC_NPROC_CONF
7693 {"SC_NPROC_CONF", _SC_NPROC_CONF
},
7695 #ifdef _SC_NPROC_ONLN
7696 {"SC_NPROC_ONLN", _SC_NPROC_ONLN
},
7699 {"SC_NZERO", _SC_NZERO
},
7702 {"SC_OPEN_MAX", _SC_OPEN_MAX
},
7705 {"SC_PAGESIZE", _SC_PAGESIZE
},
7707 #ifdef _SC_PAGE_SIZE
7708 {"SC_PAGE_SIZE", _SC_PAGE_SIZE
},
7711 {"SC_PASS_MAX", _SC_PASS_MAX
},
7713 #ifdef _SC_PHYS_PAGES
7714 {"SC_PHYS_PAGES", _SC_PHYS_PAGES
},
7717 {"SC_PII", _SC_PII
},
7719 #ifdef _SC_PII_INTERNET
7720 {"SC_PII_INTERNET", _SC_PII_INTERNET
},
7722 #ifdef _SC_PII_INTERNET_DGRAM
7723 {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM
},
7725 #ifdef _SC_PII_INTERNET_STREAM
7726 {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM
},
7729 {"SC_PII_OSI", _SC_PII_OSI
},
7731 #ifdef _SC_PII_OSI_CLTS
7732 {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS
},
7734 #ifdef _SC_PII_OSI_COTS
7735 {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS
},
7737 #ifdef _SC_PII_OSI_M
7738 {"SC_PII_OSI_M", _SC_PII_OSI_M
},
7740 #ifdef _SC_PII_SOCKET
7741 {"SC_PII_SOCKET", _SC_PII_SOCKET
},
7744 {"SC_PII_XTI", _SC_PII_XTI
},
7747 {"SC_POLL", _SC_POLL
},
7749 #ifdef _SC_PRIORITIZED_IO
7750 {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO
},
7752 #ifdef _SC_PRIORITY_SCHEDULING
7753 {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING
},
7755 #ifdef _SC_REALTIME_SIGNALS
7756 {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS
},
7758 #ifdef _SC_RE_DUP_MAX
7759 {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX
},
7761 #ifdef _SC_RTSIG_MAX
7762 {"SC_RTSIG_MAX", _SC_RTSIG_MAX
},
7764 #ifdef _SC_SAVED_IDS
7765 {"SC_SAVED_IDS", _SC_SAVED_IDS
},
7767 #ifdef _SC_SCHAR_MAX
7768 {"SC_SCHAR_MAX", _SC_SCHAR_MAX
},
7770 #ifdef _SC_SCHAR_MIN
7771 {"SC_SCHAR_MIN", _SC_SCHAR_MIN
},
7774 {"SC_SELECT", _SC_SELECT
},
7776 #ifdef _SC_SEMAPHORES
7777 {"SC_SEMAPHORES", _SC_SEMAPHORES
},
7779 #ifdef _SC_SEM_NSEMS_MAX
7780 {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX
},
7782 #ifdef _SC_SEM_VALUE_MAX
7783 {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX
},
7785 #ifdef _SC_SHARED_MEMORY_OBJECTS
7786 {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS
},
7789 {"SC_SHRT_MAX", _SC_SHRT_MAX
},
7792 {"SC_SHRT_MIN", _SC_SHRT_MIN
},
7794 #ifdef _SC_SIGQUEUE_MAX
7795 {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX
},
7797 #ifdef _SC_SIGRT_MAX
7798 {"SC_SIGRT_MAX", _SC_SIGRT_MAX
},
7800 #ifdef _SC_SIGRT_MIN
7801 {"SC_SIGRT_MIN", _SC_SIGRT_MIN
},
7803 #ifdef _SC_SOFTPOWER
7804 {"SC_SOFTPOWER", _SC_SOFTPOWER
},
7806 #ifdef _SC_SPLIT_CACHE
7807 {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE
},
7809 #ifdef _SC_SSIZE_MAX
7810 {"SC_SSIZE_MAX", _SC_SSIZE_MAX
},
7812 #ifdef _SC_STACK_PROT
7813 {"SC_STACK_PROT", _SC_STACK_PROT
},
7815 #ifdef _SC_STREAM_MAX
7816 {"SC_STREAM_MAX", _SC_STREAM_MAX
},
7818 #ifdef _SC_SYNCHRONIZED_IO
7819 {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO
},
7822 {"SC_THREADS", _SC_THREADS
},
7824 #ifdef _SC_THREAD_ATTR_STACKADDR
7825 {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR
},
7827 #ifdef _SC_THREAD_ATTR_STACKSIZE
7828 {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE
},
7830 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
7831 {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS
},
7833 #ifdef _SC_THREAD_KEYS_MAX
7834 {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX
},
7836 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
7837 {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING
},
7839 #ifdef _SC_THREAD_PRIO_INHERIT
7840 {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT
},
7842 #ifdef _SC_THREAD_PRIO_PROTECT
7843 {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT
},
7845 #ifdef _SC_THREAD_PROCESS_SHARED
7846 {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED
},
7848 #ifdef _SC_THREAD_SAFE_FUNCTIONS
7849 {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS
},
7851 #ifdef _SC_THREAD_STACK_MIN
7852 {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN
},
7854 #ifdef _SC_THREAD_THREADS_MAX
7855 {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX
},
7858 {"SC_TIMERS", _SC_TIMERS
},
7860 #ifdef _SC_TIMER_MAX
7861 {"SC_TIMER_MAX", _SC_TIMER_MAX
},
7863 #ifdef _SC_TTY_NAME_MAX
7864 {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX
},
7866 #ifdef _SC_TZNAME_MAX
7867 {"SC_TZNAME_MAX", _SC_TZNAME_MAX
},
7869 #ifdef _SC_T_IOV_MAX
7870 {"SC_T_IOV_MAX", _SC_T_IOV_MAX
},
7872 #ifdef _SC_UCHAR_MAX
7873 {"SC_UCHAR_MAX", _SC_UCHAR_MAX
},
7876 {"SC_UINT_MAX", _SC_UINT_MAX
},
7878 #ifdef _SC_UIO_MAXIOV
7879 {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV
},
7881 #ifdef _SC_ULONG_MAX
7882 {"SC_ULONG_MAX", _SC_ULONG_MAX
},
7884 #ifdef _SC_USHRT_MAX
7885 {"SC_USHRT_MAX", _SC_USHRT_MAX
},
7888 {"SC_VERSION", _SC_VERSION
},
7891 {"SC_WORD_BIT", _SC_WORD_BIT
},
7893 #ifdef _SC_XBS5_ILP32_OFF32
7894 {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32
},
7896 #ifdef _SC_XBS5_ILP32_OFFBIG
7897 {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG
},
7899 #ifdef _SC_XBS5_LP64_OFF64
7900 {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64
},
7902 #ifdef _SC_XBS5_LPBIG_OFFBIG
7903 {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG
},
7905 #ifdef _SC_XOPEN_CRYPT
7906 {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT
},
7908 #ifdef _SC_XOPEN_ENH_I18N
7909 {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N
},
7911 #ifdef _SC_XOPEN_LEGACY
7912 {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY
},
7914 #ifdef _SC_XOPEN_REALTIME
7915 {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME
},
7917 #ifdef _SC_XOPEN_REALTIME_THREADS
7918 {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS
},
7920 #ifdef _SC_XOPEN_SHM
7921 {"SC_XOPEN_SHM", _SC_XOPEN_SHM
},
7923 #ifdef _SC_XOPEN_UNIX
7924 {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX
},
7926 #ifdef _SC_XOPEN_VERSION
7927 {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION
},
7929 #ifdef _SC_XOPEN_XCU_VERSION
7930 {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION
},
7932 #ifdef _SC_XOPEN_XPG2
7933 {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2
},
7935 #ifdef _SC_XOPEN_XPG3
7936 {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3
},
7938 #ifdef _SC_XOPEN_XPG4
7939 {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4
},
7944 conv_sysconf_confname(PyObject
*arg
, int *valuep
)
7946 return conv_confname(arg
, valuep
, posix_constants_sysconf
,
7947 sizeof(posix_constants_sysconf
)
7948 / sizeof(struct constdef
));
7951 PyDoc_STRVAR(posix_sysconf__doc__
,
7952 "sysconf(name) -> integer\n\n\
7953 Return an integer-valued system configuration variable.");
7956 posix_sysconf(PyObject
*self
, PyObject
*args
)
7958 PyObject
*result
= NULL
;
7961 if (PyArg_ParseTuple(args
, "O&:sysconf", conv_sysconf_confname
, &name
)) {
7965 value
= sysconf(name
);
7966 if (value
== -1 && errno
!= 0)
7969 result
= PyInt_FromLong(value
);
7976 /* This code is used to ensure that the tables of configuration value names
7977 * are in sorted order as required by conv_confname(), and also to build the
7978 * the exported dictionaries that are used to publish information about the
7979 * names available on the host platform.
7981 * Sorting the table at runtime ensures that the table is properly ordered
7982 * when used, even for platforms we're not able to test on. It also makes
7983 * it easier to add additional entries to the tables.
7987 cmp_constdefs(const void *v1
, const void *v2
)
7989 const struct constdef
*c1
=
7990 (const struct constdef
*) v1
;
7991 const struct constdef
*c2
=
7992 (const struct constdef
*) v2
;
7994 return strcmp(c1
->name
, c2
->name
);
7998 setup_confname_table(struct constdef
*table
, size_t tablesize
,
7999 char *tablename
, PyObject
*module
)
8004 qsort(table
, tablesize
, sizeof(struct constdef
), cmp_constdefs
);
8009 for (i
=0; i
< tablesize
; ++i
) {
8010 PyObject
*o
= PyInt_FromLong(table
[i
].value
);
8011 if (o
== NULL
|| PyDict_SetItemString(d
, table
[i
].name
, o
) == -1) {
8018 return PyModule_AddObject(module
, tablename
, d
);
8021 /* Return -1 on failure, 0 on success. */
8023 setup_confname_tables(PyObject
*module
)
8025 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
8026 if (setup_confname_table(posix_constants_pathconf
,
8027 sizeof(posix_constants_pathconf
)
8028 / sizeof(struct constdef
),
8029 "pathconf_names", module
))
8033 if (setup_confname_table(posix_constants_confstr
,
8034 sizeof(posix_constants_confstr
)
8035 / sizeof(struct constdef
),
8036 "confstr_names", module
))
8040 if (setup_confname_table(posix_constants_sysconf
,
8041 sizeof(posix_constants_sysconf
)
8042 / sizeof(struct constdef
),
8043 "sysconf_names", module
))
8050 PyDoc_STRVAR(posix_abort__doc__
,
8051 "abort() -> does not return!\n\n\
8052 Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\
8053 in the hardest way possible on the hosting operating system.");
8056 posix_abort(PyObject
*self
, PyObject
*noargs
)
8060 Py_FatalError("abort() called from Python code didn't abort!");
8065 PyDoc_STRVAR(win32_startfile__doc__
,
8066 "startfile(filepath [, operation]) - Start a file with its associated\n\
8069 When \"operation\" is not specified or \"open\", this acts like\n\
8070 double-clicking the file in Explorer, or giving the file name as an\n\
8071 argument to the DOS \"start\" command: the file is opened with whatever\n\
8072 application (if any) its extension is associated.\n\
8073 When another \"operation\" is given, it specifies what should be done with\n\
8074 the file. A typical operation is \"print\".\n\
8076 startfile returns as soon as the associated application is launched.\n\
8077 There is no option to wait for the application to close, and no way\n\
8078 to retrieve the application's exit status.\n\
8080 The filepath is relative to the current directory. If you want to use\n\
8081 an absolute path, make sure the first character is not a slash (\"/\");\n\
8082 the underlying Win32 ShellExecute function doesn't work if it is.");
8085 win32_startfile(PyObject
*self
, PyObject
*args
)
8088 char *operation
= NULL
;
8090 #ifdef Py_WIN_WIDE_FILENAMES
8091 if (unicode_file_names()) {
8092 PyObject
*unipath
, *woperation
= NULL
;
8093 if (!PyArg_ParseTuple(args
, "U|s:startfile",
8094 &unipath
, &operation
)) {
8101 woperation
= PyUnicode_DecodeASCII(operation
,
8102 strlen(operation
), NULL
);
8110 Py_BEGIN_ALLOW_THREADS
8111 rc
= ShellExecuteW((HWND
)0, woperation
? PyUnicode_AS_UNICODE(woperation
) : 0,
8112 PyUnicode_AS_UNICODE(unipath
),
8113 NULL
, NULL
, SW_SHOWNORMAL
);
8114 Py_END_ALLOW_THREADS
8116 Py_XDECREF(woperation
);
8117 if (rc
<= (HINSTANCE
)32) {
8118 PyObject
*errval
= win32_error_unicode("startfile",
8119 PyUnicode_AS_UNICODE(unipath
));
8128 if (!PyArg_ParseTuple(args
, "et|s:startfile",
8129 Py_FileSystemDefaultEncoding
, &filepath
,
8132 Py_BEGIN_ALLOW_THREADS
8133 rc
= ShellExecute((HWND
)0, operation
, filepath
,
8134 NULL
, NULL
, SW_SHOWNORMAL
);
8135 Py_END_ALLOW_THREADS
8136 if (rc
<= (HINSTANCE
)32) {
8137 PyObject
*errval
= win32_error("startfile", filepath
);
8138 PyMem_Free(filepath
);
8141 PyMem_Free(filepath
);
8147 #ifdef HAVE_GETLOADAVG
8148 PyDoc_STRVAR(posix_getloadavg__doc__
,
8149 "getloadavg() -> (float, float, float)\n\n\
8150 Return the number of processes in the system run queue averaged over\n\
8151 the last 1, 5, and 15 minutes or raises OSError if the load average\n\
8155 posix_getloadavg(PyObject
*self
, PyObject
*noargs
)
8158 if (getloadavg(loadavg
, 3)!=3) {
8159 PyErr_SetString(PyExc_OSError
, "Load averages are unobtainable");
8162 return Py_BuildValue("ddd", loadavg
[0], loadavg
[1], loadavg
[2]);
8168 PyDoc_STRVAR(win32_urandom__doc__
,
8169 "urandom(n) -> str\n\n\
8170 Return a string of n random bytes suitable for cryptographic use.");
8172 typedef BOOL (WINAPI
*CRYPTACQUIRECONTEXTA
)(HCRYPTPROV
*phProv
,\
8173 LPCSTR pszContainer
, LPCSTR pszProvider
, DWORD dwProvType
,\
8175 typedef BOOL (WINAPI
*CRYPTGENRANDOM
)(HCRYPTPROV hProv
, DWORD dwLen
,\
8178 static CRYPTGENRANDOM pCryptGenRandom
= NULL
;
8179 /* This handle is never explicitly released. Instead, the operating
8180 system will release it when the process terminates. */
8181 static HCRYPTPROV hCryptProv
= 0;
8184 win32_urandom(PyObject
*self
, PyObject
*args
)
8189 /* Read arguments */
8190 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8193 return PyErr_Format(PyExc_ValueError
,
8194 "negative argument not allowed");
8196 if (hCryptProv
== 0) {
8197 HINSTANCE hAdvAPI32
= NULL
;
8198 CRYPTACQUIRECONTEXTA pCryptAcquireContext
= NULL
;
8200 /* Obtain handle to the DLL containing CryptoAPI
8201 This should not fail */
8202 hAdvAPI32
= GetModuleHandle("advapi32.dll");
8203 if(hAdvAPI32
== NULL
)
8204 return win32_error("GetModuleHandle", NULL
);
8206 /* Obtain pointers to the CryptoAPI functions
8207 This will fail on some early versions of Win95 */
8208 pCryptAcquireContext
= (CRYPTACQUIRECONTEXTA
)GetProcAddress(
8210 "CryptAcquireContextA");
8211 if (pCryptAcquireContext
== NULL
)
8212 return PyErr_Format(PyExc_NotImplementedError
,
8213 "CryptAcquireContextA not found");
8215 pCryptGenRandom
= (CRYPTGENRANDOM
)GetProcAddress(
8216 hAdvAPI32
, "CryptGenRandom");
8217 if (pCryptGenRandom
== NULL
)
8218 return PyErr_Format(PyExc_NotImplementedError
,
8219 "CryptGenRandom not found");
8221 /* Acquire context */
8222 if (! pCryptAcquireContext(&hCryptProv
, NULL
, NULL
,
8223 PROV_RSA_FULL
, CRYPT_VERIFYCONTEXT
))
8224 return win32_error("CryptAcquireContext", NULL
);
8227 /* Allocate bytes */
8228 result
= PyString_FromStringAndSize(NULL
, howMany
);
8229 if (result
!= NULL
) {
8230 /* Get random data */
8231 if (! pCryptGenRandom(hCryptProv
, howMany
, (unsigned char*)
8232 PyString_AS_STRING(result
))) {
8234 return win32_error("CryptGenRandom", NULL
);
8242 /* Use openssl random routine */
8243 #include <openssl/rand.h>
8244 PyDoc_STRVAR(vms_urandom__doc__
,
8245 "urandom(n) -> str\n\n\
8246 Return a string of n random bytes suitable for cryptographic use.");
8249 vms_urandom(PyObject
*self
, PyObject
*args
)
8254 /* Read arguments */
8255 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8258 return PyErr_Format(PyExc_ValueError
,
8259 "negative argument not allowed");
8261 /* Allocate bytes */
8262 result
= PyString_FromStringAndSize(NULL
, howMany
);
8263 if (result
!= NULL
) {
8264 /* Get random data */
8265 if (RAND_pseudo_bytes((unsigned char*)
8266 PyString_AS_STRING(result
),
8269 return PyErr_Format(PyExc_ValueError
,
8270 "RAND_pseudo_bytes");
8277 static PyMethodDef posix_methods
[] = {
8278 {"access", posix_access
, METH_VARARGS
, posix_access__doc__
},
8280 {"ttyname", posix_ttyname
, METH_VARARGS
, posix_ttyname__doc__
},
8282 {"chdir", posix_chdir
, METH_VARARGS
, posix_chdir__doc__
},
8284 {"chflags", posix_chflags
, METH_VARARGS
, posix_chflags__doc__
},
8285 #endif /* HAVE_CHFLAGS */
8286 {"chmod", posix_chmod
, METH_VARARGS
, posix_chmod__doc__
},
8288 {"fchmod", posix_fchmod
, METH_VARARGS
, posix_fchmod__doc__
},
8289 #endif /* HAVE_FCHMOD */
8291 {"chown", posix_chown
, METH_VARARGS
, posix_chown__doc__
},
8292 #endif /* HAVE_CHOWN */
8294 {"lchmod", posix_lchmod
, METH_VARARGS
, posix_lchmod__doc__
},
8295 #endif /* HAVE_LCHMOD */
8297 {"fchown", posix_fchown
, METH_VARARGS
, posix_fchown__doc__
},
8298 #endif /* HAVE_FCHOWN */
8299 #ifdef HAVE_LCHFLAGS
8300 {"lchflags", posix_lchflags
, METH_VARARGS
, posix_lchflags__doc__
},
8301 #endif /* HAVE_LCHFLAGS */
8303 {"lchown", posix_lchown
, METH_VARARGS
, posix_lchown__doc__
},
8304 #endif /* HAVE_LCHOWN */
8306 {"chroot", posix_chroot
, METH_VARARGS
, posix_chroot__doc__
},
8309 {"ctermid", posix_ctermid
, METH_NOARGS
, posix_ctermid__doc__
},
8312 {"getcwd", posix_getcwd
, METH_NOARGS
, posix_getcwd__doc__
},
8313 #ifdef Py_USING_UNICODE
8314 {"getcwdu", posix_getcwdu
, METH_NOARGS
, posix_getcwdu__doc__
},
8318 {"link", posix_link
, METH_VARARGS
, posix_link__doc__
},
8319 #endif /* HAVE_LINK */
8320 {"listdir", posix_listdir
, METH_VARARGS
, posix_listdir__doc__
},
8321 {"lstat", posix_lstat
, METH_VARARGS
, posix_lstat__doc__
},
8322 {"mkdir", posix_mkdir
, METH_VARARGS
, posix_mkdir__doc__
},
8324 {"nice", posix_nice
, METH_VARARGS
, posix_nice__doc__
},
8325 #endif /* HAVE_NICE */
8326 #ifdef HAVE_READLINK
8327 {"readlink", posix_readlink
, METH_VARARGS
, posix_readlink__doc__
},
8328 #endif /* HAVE_READLINK */
8329 {"rename", posix_rename
, METH_VARARGS
, posix_rename__doc__
},
8330 {"rmdir", posix_rmdir
, METH_VARARGS
, posix_rmdir__doc__
},
8331 {"stat", posix_stat
, METH_VARARGS
, posix_stat__doc__
},
8332 {"stat_float_times", stat_float_times
, METH_VARARGS
, stat_float_times__doc__
},
8334 {"symlink", posix_symlink
, METH_VARARGS
, posix_symlink__doc__
},
8335 #endif /* HAVE_SYMLINK */
8337 {"system", posix_system
, METH_VARARGS
, posix_system__doc__
},
8339 {"umask", posix_umask
, METH_VARARGS
, posix_umask__doc__
},
8341 {"uname", posix_uname
, METH_NOARGS
, posix_uname__doc__
},
8342 #endif /* HAVE_UNAME */
8343 {"unlink", posix_unlink
, METH_VARARGS
, posix_unlink__doc__
},
8344 {"remove", posix_unlink
, METH_VARARGS
, posix_remove__doc__
},
8345 {"utime", posix_utime
, METH_VARARGS
, posix_utime__doc__
},
8347 {"times", posix_times
, METH_NOARGS
, posix_times__doc__
},
8348 #endif /* HAVE_TIMES */
8349 {"_exit", posix__exit
, METH_VARARGS
, posix__exit__doc__
},
8351 {"execv", posix_execv
, METH_VARARGS
, posix_execv__doc__
},
8352 {"execve", posix_execve
, METH_VARARGS
, posix_execve__doc__
},
8353 #endif /* HAVE_EXECV */
8355 {"spawnv", posix_spawnv
, METH_VARARGS
, posix_spawnv__doc__
},
8356 {"spawnve", posix_spawnve
, METH_VARARGS
, posix_spawnve__doc__
},
8357 #if defined(PYOS_OS2)
8358 {"spawnvp", posix_spawnvp
, METH_VARARGS
, posix_spawnvp__doc__
},
8359 {"spawnvpe", posix_spawnvpe
, METH_VARARGS
, posix_spawnvpe__doc__
},
8360 #endif /* PYOS_OS2 */
8361 #endif /* HAVE_SPAWNV */
8363 {"fork1", posix_fork1
, METH_NOARGS
, posix_fork1__doc__
},
8364 #endif /* HAVE_FORK1 */
8366 {"fork", posix_fork
, METH_NOARGS
, posix_fork__doc__
},
8367 #endif /* HAVE_FORK */
8368 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
8369 {"openpty", posix_openpty
, METH_NOARGS
, posix_openpty__doc__
},
8370 #endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */
8372 {"forkpty", posix_forkpty
, METH_NOARGS
, posix_forkpty__doc__
},
8373 #endif /* HAVE_FORKPTY */
8375 {"getegid", posix_getegid
, METH_NOARGS
, posix_getegid__doc__
},
8376 #endif /* HAVE_GETEGID */
8378 {"geteuid", posix_geteuid
, METH_NOARGS
, posix_geteuid__doc__
},
8379 #endif /* HAVE_GETEUID */
8381 {"getgid", posix_getgid
, METH_NOARGS
, posix_getgid__doc__
},
8382 #endif /* HAVE_GETGID */
8383 #ifdef HAVE_GETGROUPS
8384 {"getgroups", posix_getgroups
, METH_NOARGS
, posix_getgroups__doc__
},
8386 {"getpid", posix_getpid
, METH_NOARGS
, posix_getpid__doc__
},
8388 {"getpgrp", posix_getpgrp
, METH_NOARGS
, posix_getpgrp__doc__
},
8389 #endif /* HAVE_GETPGRP */
8391 {"getppid", posix_getppid
, METH_NOARGS
, posix_getppid__doc__
},
8392 #endif /* HAVE_GETPPID */
8394 {"getuid", posix_getuid
, METH_NOARGS
, posix_getuid__doc__
},
8395 #endif /* HAVE_GETUID */
8396 #ifdef HAVE_GETLOGIN
8397 {"getlogin", posix_getlogin
, METH_NOARGS
, posix_getlogin__doc__
},
8400 {"kill", posix_kill
, METH_VARARGS
, posix_kill__doc__
},
8401 #endif /* HAVE_KILL */
8403 {"killpg", posix_killpg
, METH_VARARGS
, posix_killpg__doc__
},
8404 #endif /* HAVE_KILLPG */
8406 {"plock", posix_plock
, METH_VARARGS
, posix_plock__doc__
},
8407 #endif /* HAVE_PLOCK */
8409 {"popen", posix_popen
, METH_VARARGS
, posix_popen__doc__
},
8411 {"popen2", win32_popen2
, METH_VARARGS
},
8412 {"popen3", win32_popen3
, METH_VARARGS
},
8413 {"popen4", win32_popen4
, METH_VARARGS
},
8414 {"startfile", win32_startfile
, METH_VARARGS
, win32_startfile__doc__
},
8416 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8417 {"popen2", os2emx_popen2
, METH_VARARGS
},
8418 {"popen3", os2emx_popen3
, METH_VARARGS
},
8419 {"popen4", os2emx_popen4
, METH_VARARGS
},
8422 #endif /* HAVE_POPEN */
8424 {"setuid", posix_setuid
, METH_VARARGS
, posix_setuid__doc__
},
8425 #endif /* HAVE_SETUID */
8427 {"seteuid", posix_seteuid
, METH_VARARGS
, posix_seteuid__doc__
},
8428 #endif /* HAVE_SETEUID */
8430 {"setegid", posix_setegid
, METH_VARARGS
, posix_setegid__doc__
},
8431 #endif /* HAVE_SETEGID */
8432 #ifdef HAVE_SETREUID
8433 {"setreuid", posix_setreuid
, METH_VARARGS
, posix_setreuid__doc__
},
8434 #endif /* HAVE_SETREUID */
8435 #ifdef HAVE_SETREGID
8436 {"setregid", posix_setregid
, METH_VARARGS
, posix_setregid__doc__
},
8437 #endif /* HAVE_SETREGID */
8439 {"setgid", posix_setgid
, METH_VARARGS
, posix_setgid__doc__
},
8440 #endif /* HAVE_SETGID */
8441 #ifdef HAVE_SETGROUPS
8442 {"setgroups", posix_setgroups
, METH_O
, posix_setgroups__doc__
},
8443 #endif /* HAVE_SETGROUPS */
8445 {"getpgid", posix_getpgid
, METH_VARARGS
, posix_getpgid__doc__
},
8446 #endif /* HAVE_GETPGID */
8448 {"setpgrp", posix_setpgrp
, METH_NOARGS
, posix_setpgrp__doc__
},
8449 #endif /* HAVE_SETPGRP */
8451 {"wait", posix_wait
, METH_NOARGS
, posix_wait__doc__
},
8452 #endif /* HAVE_WAIT */
8454 {"wait3", posix_wait3
, METH_VARARGS
, posix_wait3__doc__
},
8455 #endif /* HAVE_WAIT3 */
8457 {"wait4", posix_wait4
, METH_VARARGS
, posix_wait4__doc__
},
8458 #endif /* HAVE_WAIT4 */
8459 #if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)
8460 {"waitpid", posix_waitpid
, METH_VARARGS
, posix_waitpid__doc__
},
8461 #endif /* HAVE_WAITPID */
8463 {"getsid", posix_getsid
, METH_VARARGS
, posix_getsid__doc__
},
8464 #endif /* HAVE_GETSID */
8466 {"setsid", posix_setsid
, METH_NOARGS
, posix_setsid__doc__
},
8467 #endif /* HAVE_SETSID */
8469 {"setpgid", posix_setpgid
, METH_VARARGS
, posix_setpgid__doc__
},
8470 #endif /* HAVE_SETPGID */
8471 #ifdef HAVE_TCGETPGRP
8472 {"tcgetpgrp", posix_tcgetpgrp
, METH_VARARGS
, posix_tcgetpgrp__doc__
},
8473 #endif /* HAVE_TCGETPGRP */
8474 #ifdef HAVE_TCSETPGRP
8475 {"tcsetpgrp", posix_tcsetpgrp
, METH_VARARGS
, posix_tcsetpgrp__doc__
},
8476 #endif /* HAVE_TCSETPGRP */
8477 {"open", posix_open
, METH_VARARGS
, posix_open__doc__
},
8478 {"close", posix_close
, METH_VARARGS
, posix_close__doc__
},
8479 {"closerange", posix_closerange
, METH_VARARGS
, posix_closerange__doc__
},
8480 {"dup", posix_dup
, METH_VARARGS
, posix_dup__doc__
},
8481 {"dup2", posix_dup2
, METH_VARARGS
, posix_dup2__doc__
},
8482 {"lseek", posix_lseek
, METH_VARARGS
, posix_lseek__doc__
},
8483 {"read", posix_read
, METH_VARARGS
, posix_read__doc__
},
8484 {"write", posix_write
, METH_VARARGS
, posix_write__doc__
},
8485 {"fstat", posix_fstat
, METH_VARARGS
, posix_fstat__doc__
},
8486 {"fdopen", posix_fdopen
, METH_VARARGS
, posix_fdopen__doc__
},
8487 {"isatty", posix_isatty
, METH_VARARGS
, posix_isatty__doc__
},
8489 {"pipe", posix_pipe
, METH_NOARGS
, posix_pipe__doc__
},
8492 {"mkfifo", posix_mkfifo
, METH_VARARGS
, posix_mkfifo__doc__
},
8494 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
8495 {"mknod", posix_mknod
, METH_VARARGS
, posix_mknod__doc__
},
8497 #ifdef HAVE_DEVICE_MACROS
8498 {"major", posix_major
, METH_VARARGS
, posix_major__doc__
},
8499 {"minor", posix_minor
, METH_VARARGS
, posix_minor__doc__
},
8500 {"makedev", posix_makedev
, METH_VARARGS
, posix_makedev__doc__
},
8502 #ifdef HAVE_FTRUNCATE
8503 {"ftruncate", posix_ftruncate
, METH_VARARGS
, posix_ftruncate__doc__
},
8506 {"putenv", posix_putenv
, METH_VARARGS
, posix_putenv__doc__
},
8508 #ifdef HAVE_UNSETENV
8509 {"unsetenv", posix_unsetenv
, METH_VARARGS
, posix_unsetenv__doc__
},
8511 {"strerror", posix_strerror
, METH_VARARGS
, posix_strerror__doc__
},
8513 {"fchdir", posix_fchdir
, METH_O
, posix_fchdir__doc__
},
8516 {"fsync", posix_fsync
, METH_O
, posix_fsync__doc__
},
8518 #ifdef HAVE_FDATASYNC
8519 {"fdatasync", posix_fdatasync
, METH_O
, posix_fdatasync__doc__
},
8521 #ifdef HAVE_SYS_WAIT_H
8523 {"WCOREDUMP", posix_WCOREDUMP
, METH_VARARGS
, posix_WCOREDUMP__doc__
},
8524 #endif /* WCOREDUMP */
8526 {"WIFCONTINUED",posix_WIFCONTINUED
, METH_VARARGS
, posix_WIFCONTINUED__doc__
},
8527 #endif /* WIFCONTINUED */
8529 {"WIFSTOPPED", posix_WIFSTOPPED
, METH_VARARGS
, posix_WIFSTOPPED__doc__
},
8530 #endif /* WIFSTOPPED */
8532 {"WIFSIGNALED", posix_WIFSIGNALED
, METH_VARARGS
, posix_WIFSIGNALED__doc__
},
8533 #endif /* WIFSIGNALED */
8535 {"WIFEXITED", posix_WIFEXITED
, METH_VARARGS
, posix_WIFEXITED__doc__
},
8536 #endif /* WIFEXITED */
8538 {"WEXITSTATUS", posix_WEXITSTATUS
, METH_VARARGS
, posix_WEXITSTATUS__doc__
},
8539 #endif /* WEXITSTATUS */
8541 {"WTERMSIG", posix_WTERMSIG
, METH_VARARGS
, posix_WTERMSIG__doc__
},
8542 #endif /* WTERMSIG */
8544 {"WSTOPSIG", posix_WSTOPSIG
, METH_VARARGS
, posix_WSTOPSIG__doc__
},
8545 #endif /* WSTOPSIG */
8546 #endif /* HAVE_SYS_WAIT_H */
8547 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
8548 {"fstatvfs", posix_fstatvfs
, METH_VARARGS
, posix_fstatvfs__doc__
},
8550 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
8551 {"statvfs", posix_statvfs
, METH_VARARGS
, posix_statvfs__doc__
},
8554 {"tmpfile", posix_tmpfile
, METH_NOARGS
, posix_tmpfile__doc__
},
8557 {"tempnam", posix_tempnam
, METH_VARARGS
, posix_tempnam__doc__
},
8560 {"tmpnam", posix_tmpnam
, METH_NOARGS
, posix_tmpnam__doc__
},
8563 {"confstr", posix_confstr
, METH_VARARGS
, posix_confstr__doc__
},
8566 {"sysconf", posix_sysconf
, METH_VARARGS
, posix_sysconf__doc__
},
8568 #ifdef HAVE_FPATHCONF
8569 {"fpathconf", posix_fpathconf
, METH_VARARGS
, posix_fpathconf__doc__
},
8571 #ifdef HAVE_PATHCONF
8572 {"pathconf", posix_pathconf
, METH_VARARGS
, posix_pathconf__doc__
},
8574 {"abort", posix_abort
, METH_NOARGS
, posix_abort__doc__
},
8576 {"_getfullpathname", posix__getfullpathname
, METH_VARARGS
, NULL
},
8578 #ifdef HAVE_GETLOADAVG
8579 {"getloadavg", posix_getloadavg
, METH_NOARGS
, posix_getloadavg__doc__
},
8582 {"urandom", win32_urandom
, METH_VARARGS
, win32_urandom__doc__
},
8585 {"urandom", vms_urandom
, METH_VARARGS
, vms_urandom__doc__
},
8587 {NULL
, NULL
} /* Sentinel */
8592 ins(PyObject
*module
, char *symbol
, long value
)
8594 return PyModule_AddIntConstant(module
, symbol
, value
);
8597 #if defined(PYOS_OS2)
8598 /* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */
8599 static int insertvalues(PyObject
*module
)
8602 ULONG values
[QSV_MAX
+1];
8606 Py_BEGIN_ALLOW_THREADS
8607 rc
= DosQuerySysInfo(1L, QSV_MAX
, &values
[1], sizeof(ULONG
) * QSV_MAX
);
8608 Py_END_ALLOW_THREADS
8610 if (rc
!= NO_ERROR
) {
8615 if (ins(module
, "meminstalled", values
[QSV_TOTPHYSMEM
])) return -1;
8616 if (ins(module
, "memkernel", values
[QSV_TOTRESMEM
])) return -1;
8617 if (ins(module
, "memvirtual", values
[QSV_TOTAVAILMEM
])) return -1;
8618 if (ins(module
, "maxpathlen", values
[QSV_MAX_PATH_LENGTH
])) return -1;
8619 if (ins(module
, "maxnamelen", values
[QSV_MAX_COMP_LENGTH
])) return -1;
8620 if (ins(module
, "revision", values
[QSV_VERSION_REVISION
])) return -1;
8621 if (ins(module
, "timeslice", values
[QSV_MIN_SLICE
])) return -1;
8623 switch (values
[QSV_VERSION_MINOR
]) {
8624 case 0: ver
= "2.00"; break;
8625 case 10: ver
= "2.10"; break;
8626 case 11: ver
= "2.11"; break;
8627 case 30: ver
= "3.00"; break;
8628 case 40: ver
= "4.00"; break;
8629 case 50: ver
= "5.00"; break;
8631 PyOS_snprintf(tmp
, sizeof(tmp
),
8632 "%d-%d", values
[QSV_VERSION_MAJOR
],
8633 values
[QSV_VERSION_MINOR
]);
8637 /* Add Indicator of the Version of the Operating System */
8638 if (PyModule_AddStringConstant(module
, "version", tmp
) < 0)
8641 /* Add Indicator of Which Drive was Used to Boot the System */
8642 tmp
[0] = 'A' + values
[QSV_BOOT_DRIVE
] - 1;
8646 return PyModule_AddStringConstant(module
, "bootdrive", tmp
);
8651 all_ins(PyObject
*d
)
8654 if (ins(d
, "F_OK", (long)F_OK
)) return -1;
8657 if (ins(d
, "R_OK", (long)R_OK
)) return -1;
8660 if (ins(d
, "W_OK", (long)W_OK
)) return -1;
8663 if (ins(d
, "X_OK", (long)X_OK
)) return -1;
8666 if (ins(d
, "NGROUPS_MAX", (long)NGROUPS_MAX
)) return -1;
8669 if (ins(d
, "TMP_MAX", (long)TMP_MAX
)) return -1;
8672 if (ins(d
, "WCONTINUED", (long)WCONTINUED
)) return -1;
8675 if (ins(d
, "WNOHANG", (long)WNOHANG
)) return -1;
8678 if (ins(d
, "WUNTRACED", (long)WUNTRACED
)) return -1;
8681 if (ins(d
, "O_RDONLY", (long)O_RDONLY
)) return -1;
8684 if (ins(d
, "O_WRONLY", (long)O_WRONLY
)) return -1;
8687 if (ins(d
, "O_RDWR", (long)O_RDWR
)) return -1;
8690 if (ins(d
, "O_NDELAY", (long)O_NDELAY
)) return -1;
8693 if (ins(d
, "O_NONBLOCK", (long)O_NONBLOCK
)) return -1;
8696 if (ins(d
, "O_APPEND", (long)O_APPEND
)) return -1;
8699 if (ins(d
, "O_DSYNC", (long)O_DSYNC
)) return -1;
8702 if (ins(d
, "O_RSYNC", (long)O_RSYNC
)) return -1;
8705 if (ins(d
, "O_SYNC", (long)O_SYNC
)) return -1;
8708 if (ins(d
, "O_NOCTTY", (long)O_NOCTTY
)) return -1;
8711 if (ins(d
, "O_CREAT", (long)O_CREAT
)) return -1;
8714 if (ins(d
, "O_EXCL", (long)O_EXCL
)) return -1;
8717 if (ins(d
, "O_TRUNC", (long)O_TRUNC
)) return -1;
8720 if (ins(d
, "O_BINARY", (long)O_BINARY
)) return -1;
8723 if (ins(d
, "O_TEXT", (long)O_TEXT
)) return -1;
8726 if (ins(d
, "O_LARGEFILE", (long)O_LARGEFILE
)) return -1;
8729 if (ins(d
, "O_SHLOCK", (long)O_SHLOCK
)) return -1;
8732 if (ins(d
, "O_EXLOCK", (long)O_EXLOCK
)) return -1;
8737 /* Don't inherit in child processes. */
8738 if (ins(d
, "O_NOINHERIT", (long)O_NOINHERIT
)) return -1;
8740 #ifdef _O_SHORT_LIVED
8741 /* Optimize for short life (keep in memory). */
8742 /* MS forgot to define this one with a non-underscore form too. */
8743 if (ins(d
, "O_SHORT_LIVED", (long)_O_SHORT_LIVED
)) return -1;
8746 /* Automatically delete when last handle is closed. */
8747 if (ins(d
, "O_TEMPORARY", (long)O_TEMPORARY
)) return -1;
8750 /* Optimize for random access. */
8751 if (ins(d
, "O_RANDOM", (long)O_RANDOM
)) return -1;
8754 /* Optimize for sequential access. */
8755 if (ins(d
, "O_SEQUENTIAL", (long)O_SEQUENTIAL
)) return -1;
8758 /* GNU extensions. */
8760 /* Direct disk access. */
8761 if (ins(d
, "O_DIRECT", (long)O_DIRECT
)) return -1;
8764 /* Must be a directory. */
8765 if (ins(d
, "O_DIRECTORY", (long)O_DIRECTORY
)) return -1;
8768 /* Do not follow links. */
8769 if (ins(d
, "O_NOFOLLOW", (long)O_NOFOLLOW
)) return -1;
8772 /* Do not update the access time. */
8773 if (ins(d
, "O_NOATIME", (long)O_NOATIME
)) return -1;
8776 /* These come from sysexits.h */
8778 if (ins(d
, "EX_OK", (long)EX_OK
)) return -1;
8781 if (ins(d
, "EX_USAGE", (long)EX_USAGE
)) return -1;
8782 #endif /* EX_USAGE */
8784 if (ins(d
, "EX_DATAERR", (long)EX_DATAERR
)) return -1;
8785 #endif /* EX_DATAERR */
8787 if (ins(d
, "EX_NOINPUT", (long)EX_NOINPUT
)) return -1;
8788 #endif /* EX_NOINPUT */
8790 if (ins(d
, "EX_NOUSER", (long)EX_NOUSER
)) return -1;
8791 #endif /* EX_NOUSER */
8793 if (ins(d
, "EX_NOHOST", (long)EX_NOHOST
)) return -1;
8794 #endif /* EX_NOHOST */
8795 #ifdef EX_UNAVAILABLE
8796 if (ins(d
, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE
)) return -1;
8797 #endif /* EX_UNAVAILABLE */
8799 if (ins(d
, "EX_SOFTWARE", (long)EX_SOFTWARE
)) return -1;
8800 #endif /* EX_SOFTWARE */
8802 if (ins(d
, "EX_OSERR", (long)EX_OSERR
)) return -1;
8803 #endif /* EX_OSERR */
8805 if (ins(d
, "EX_OSFILE", (long)EX_OSFILE
)) return -1;
8806 #endif /* EX_OSFILE */
8808 if (ins(d
, "EX_CANTCREAT", (long)EX_CANTCREAT
)) return -1;
8809 #endif /* EX_CANTCREAT */
8811 if (ins(d
, "EX_IOERR", (long)EX_IOERR
)) return -1;
8812 #endif /* EX_IOERR */
8814 if (ins(d
, "EX_TEMPFAIL", (long)EX_TEMPFAIL
)) return -1;
8815 #endif /* EX_TEMPFAIL */
8817 if (ins(d
, "EX_PROTOCOL", (long)EX_PROTOCOL
)) return -1;
8818 #endif /* EX_PROTOCOL */
8820 if (ins(d
, "EX_NOPERM", (long)EX_NOPERM
)) return -1;
8821 #endif /* EX_NOPERM */
8823 if (ins(d
, "EX_CONFIG", (long)EX_CONFIG
)) return -1;
8824 #endif /* EX_CONFIG */
8826 if (ins(d
, "EX_NOTFOUND", (long)EX_NOTFOUND
)) return -1;
8827 #endif /* EX_NOTFOUND */
8830 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8831 if (ins(d
, "P_WAIT", (long)P_WAIT
)) return -1;
8832 if (ins(d
, "P_NOWAIT", (long)P_NOWAIT
)) return -1;
8833 if (ins(d
, "P_OVERLAY", (long)P_OVERLAY
)) return -1;
8834 if (ins(d
, "P_DEBUG", (long)P_DEBUG
)) return -1;
8835 if (ins(d
, "P_SESSION", (long)P_SESSION
)) return -1;
8836 if (ins(d
, "P_DETACH", (long)P_DETACH
)) return -1;
8837 if (ins(d
, "P_PM", (long)P_PM
)) return -1;
8838 if (ins(d
, "P_DEFAULT", (long)P_DEFAULT
)) return -1;
8839 if (ins(d
, "P_MINIMIZE", (long)P_MINIMIZE
)) return -1;
8840 if (ins(d
, "P_MAXIMIZE", (long)P_MAXIMIZE
)) return -1;
8841 if (ins(d
, "P_FULLSCREEN", (long)P_FULLSCREEN
)) return -1;
8842 if (ins(d
, "P_WINDOWED", (long)P_WINDOWED
)) return -1;
8843 if (ins(d
, "P_FOREGROUND", (long)P_FOREGROUND
)) return -1;
8844 if (ins(d
, "P_BACKGROUND", (long)P_BACKGROUND
)) return -1;
8845 if (ins(d
, "P_NOCLOSE", (long)P_NOCLOSE
)) return -1;
8846 if (ins(d
, "P_NOSESSION", (long)P_NOSESSION
)) return -1;
8847 if (ins(d
, "P_QUOTE", (long)P_QUOTE
)) return -1;
8848 if (ins(d
, "P_TILDE", (long)P_TILDE
)) return -1;
8849 if (ins(d
, "P_UNRELATED", (long)P_UNRELATED
)) return -1;
8850 if (ins(d
, "P_DEBUGDESC", (long)P_DEBUGDESC
)) return -1;
8852 if (ins(d
, "P_WAIT", (long)_P_WAIT
)) return -1;
8853 if (ins(d
, "P_NOWAIT", (long)_P_NOWAIT
)) return -1;
8854 if (ins(d
, "P_OVERLAY", (long)_OLD_P_OVERLAY
)) return -1;
8855 if (ins(d
, "P_NOWAITO", (long)_P_NOWAITO
)) return -1;
8856 if (ins(d
, "P_DETACH", (long)_P_DETACH
)) return -1;
8860 #if defined(PYOS_OS2)
8861 if (insertvalues(d
)) return -1;
8867 #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)) && !defined(__QNX__)
8868 #define INITFUNC initnt
8869 #define MODNAME "nt"
8871 #elif defined(PYOS_OS2)
8872 #define INITFUNC initos2
8873 #define MODNAME "os2"
8876 #define INITFUNC initposix
8877 #define MODNAME "posix"
8885 m
= Py_InitModule3(MODNAME
,
8891 /* Initialize environ dictionary */
8892 v
= convertenviron();
8894 if (v
== NULL
|| PyModule_AddObject(m
, "environ", v
) != 0)
8901 if (setup_confname_tables(m
))
8904 Py_INCREF(PyExc_OSError
);
8905 PyModule_AddObject(m
, "error", PyExc_OSError
);
8908 if (posix_putenv_garbage
== NULL
)
8909 posix_putenv_garbage
= PyDict_New();
8913 stat_result_desc
.name
= MODNAME
".stat_result";
8914 stat_result_desc
.fields
[7].name
= PyStructSequence_UnnamedField
;
8915 stat_result_desc
.fields
[8].name
= PyStructSequence_UnnamedField
;
8916 stat_result_desc
.fields
[9].name
= PyStructSequence_UnnamedField
;
8917 PyStructSequence_InitType(&StatResultType
, &stat_result_desc
);
8918 structseq_new
= StatResultType
.tp_new
;
8919 StatResultType
.tp_new
= statresult_new
;
8921 statvfs_result_desc
.name
= MODNAME
".statvfs_result";
8922 PyStructSequence_InitType(&StatVFSResultType
, &statvfs_result_desc
);
8924 Py_INCREF((PyObject
*) &StatResultType
);
8925 PyModule_AddObject(m
, "stat_result", (PyObject
*) &StatResultType
);
8926 Py_INCREF((PyObject
*) &StatVFSResultType
);
8927 PyModule_AddObject(m
, "statvfs_result",
8928 (PyObject
*) &StatVFSResultType
);
8933 * Step 2 of weak-linking support on Mac OS X.
8935 * The code below removes functions that are not available on the
8936 * currently active platform.
8938 * This block allow one to use a python binary that was build on
8939 * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
8942 #ifdef HAVE_FSTATVFS
8943 if (fstatvfs
== NULL
) {
8944 if (PyObject_DelAttrString(m
, "fstatvfs") == -1) {
8948 #endif /* HAVE_FSTATVFS */
8951 if (statvfs
== NULL
) {
8952 if (PyObject_DelAttrString(m
, "statvfs") == -1) {
8956 #endif /* HAVE_STATVFS */
8959 if (lchown
== NULL
) {
8960 if (PyObject_DelAttrString(m
, "lchown") == -1) {
8964 #endif /* HAVE_LCHOWN */
8967 #endif /* __APPLE__ */