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
, "etii: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
= spawnve(mode
, path
, argvlist
, envlist
);
3543 spawnval
= _spawnve(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
)
3580 return posix_error();
3582 return PyInt_FromLong((long)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((long)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
)
3703 int master_fd
= -1, pid
;
3705 pid
= forkpty(&master_fd
, NULL
, NULL
, NULL
);
3707 return posix_error();
3710 return Py_BuildValue("(ii)", pid
, master_fd
);
3715 PyDoc_STRVAR(posix_getegid__doc__
,
3716 "getegid() -> egid\n\n\
3717 Return the current process's effective group id.");
3720 posix_getegid(PyObject
*self
, PyObject
*noargs
)
3722 return PyInt_FromLong((long)getegid());
3728 PyDoc_STRVAR(posix_geteuid__doc__
,
3729 "geteuid() -> euid\n\n\
3730 Return the current process's effective user id.");
3733 posix_geteuid(PyObject
*self
, PyObject
*noargs
)
3735 return PyInt_FromLong((long)geteuid());
3741 PyDoc_STRVAR(posix_getgid__doc__
,
3742 "getgid() -> gid\n\n\
3743 Return the current process's group id.");
3746 posix_getgid(PyObject
*self
, PyObject
*noargs
)
3748 return PyInt_FromLong((long)getgid());
3753 PyDoc_STRVAR(posix_getpid__doc__
,
3754 "getpid() -> pid\n\n\
3755 Return the current process id");
3758 posix_getpid(PyObject
*self
, PyObject
*noargs
)
3760 return PyInt_FromLong((long)getpid());
3764 #ifdef HAVE_GETGROUPS
3765 PyDoc_STRVAR(posix_getgroups__doc__
,
3766 "getgroups() -> list of group IDs\n\n\
3767 Return list of supplemental group IDs for the process.");
3770 posix_getgroups(PyObject
*self
, PyObject
*noargs
)
3772 PyObject
*result
= NULL
;
3775 #define MAX_GROUPS NGROUPS_MAX
3777 /* defined to be 16 on Solaris7, so this should be a small number */
3778 #define MAX_GROUPS 64
3780 gid_t grouplist
[MAX_GROUPS
];
3783 n
= getgroups(MAX_GROUPS
, grouplist
);
3787 result
= PyList_New(n
);
3788 if (result
!= NULL
) {
3790 for (i
= 0; i
< n
; ++i
) {
3791 PyObject
*o
= PyInt_FromLong((long)grouplist
[i
]);
3797 PyList_SET_ITEM(result
, i
, o
);
3807 PyDoc_STRVAR(posix_getpgid__doc__
,
3808 "getpgid(pid) -> pgid\n\n\
3809 Call the system call getpgid().");
3812 posix_getpgid(PyObject
*self
, PyObject
*args
)
3815 if (!PyArg_ParseTuple(args
, "i:getpgid", &pid
))
3817 pgid
= getpgid(pid
);
3819 return posix_error();
3820 return PyInt_FromLong((long)pgid
);
3822 #endif /* HAVE_GETPGID */
3826 PyDoc_STRVAR(posix_getpgrp__doc__
,
3827 "getpgrp() -> pgrp\n\n\
3828 Return the current process group id.");
3831 posix_getpgrp(PyObject
*self
, PyObject
*noargs
)
3833 #ifdef GETPGRP_HAVE_ARG
3834 return PyInt_FromLong((long)getpgrp(0));
3835 #else /* GETPGRP_HAVE_ARG */
3836 return PyInt_FromLong((long)getpgrp());
3837 #endif /* GETPGRP_HAVE_ARG */
3839 #endif /* HAVE_GETPGRP */
3843 PyDoc_STRVAR(posix_setpgrp__doc__
,
3845 Make this process a session leader.");
3848 posix_setpgrp(PyObject
*self
, PyObject
*noargs
)
3850 #ifdef SETPGRP_HAVE_ARG
3851 if (setpgrp(0, 0) < 0)
3852 #else /* SETPGRP_HAVE_ARG */
3854 #endif /* SETPGRP_HAVE_ARG */
3855 return posix_error();
3860 #endif /* HAVE_SETPGRP */
3863 PyDoc_STRVAR(posix_getppid__doc__
,
3864 "getppid() -> ppid\n\n\
3865 Return the parent's process id.");
3868 posix_getppid(PyObject
*self
, PyObject
*noargs
)
3870 return PyInt_FromLong((long)getppid());
3875 #ifdef HAVE_GETLOGIN
3876 PyDoc_STRVAR(posix_getlogin__doc__
,
3877 "getlogin() -> string\n\n\
3878 Return the actual login name.");
3881 posix_getlogin(PyObject
*self
, PyObject
*noargs
)
3883 PyObject
*result
= NULL
;
3885 int old_errno
= errno
;
3893 PyErr_SetString(PyExc_OSError
,
3894 "unable to determine login name");
3897 result
= PyString_FromString(name
);
3905 PyDoc_STRVAR(posix_getuid__doc__
,
3906 "getuid() -> uid\n\n\
3907 Return the current process's user id.");
3910 posix_getuid(PyObject
*self
, PyObject
*noargs
)
3912 return PyInt_FromLong((long)getuid());
3918 PyDoc_STRVAR(posix_kill__doc__
,
3919 "kill(pid, sig)\n\n\
3920 Kill a process with a signal.");
3923 posix_kill(PyObject
*self
, PyObject
*args
)
3926 if (!PyArg_ParseTuple(args
, "ii:kill", &pid
, &sig
))
3928 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
3929 if (sig
== XCPT_SIGNAL_INTR
|| sig
== XCPT_SIGNAL_BREAK
) {
3931 if ((rc
= DosSendSignalException(pid
, sig
)) != NO_ERROR
)
3932 return os2_error(rc
);
3934 } else if (sig
== XCPT_SIGNAL_KILLPROC
) {
3936 if ((rc
= DosKillProcess(DKP_PROCESS
, pid
)) != NO_ERROR
)
3937 return os2_error(rc
);
3940 return NULL
; /* Unrecognized Signal Requested */
3942 if (kill(pid
, sig
) == -1)
3943 return posix_error();
3951 PyDoc_STRVAR(posix_killpg__doc__
,
3952 "killpg(pgid, sig)\n\n\
3953 Kill a process group with a signal.");
3956 posix_killpg(PyObject
*self
, PyObject
*args
)
3959 if (!PyArg_ParseTuple(args
, "ii:killpg", &pgid
, &sig
))
3961 if (killpg(pgid
, sig
) == -1)
3962 return posix_error();
3970 #ifdef HAVE_SYS_LOCK_H
3971 #include <sys/lock.h>
3974 PyDoc_STRVAR(posix_plock__doc__
,
3976 Lock program segments into memory.");
3979 posix_plock(PyObject
*self
, PyObject
*args
)
3982 if (!PyArg_ParseTuple(args
, "i:plock", &op
))
3984 if (plock(op
) == -1)
3985 return posix_error();
3993 PyDoc_STRVAR(posix_popen__doc__
,
3994 "popen(command [, mode='r' [, bufsize]]) -> pipe\n\n\
3995 Open a pipe to/from a command returning a file object.");
3997 #if defined(PYOS_OS2)
3998 #if defined(PYCC_VACPP)
4000 async_system(const char *command
)
4002 char errormsg
[256], args
[1024];
4006 char *shell
= getenv("COMSPEC");
4010 /* avoid overflowing the argument buffer */
4011 if (strlen(shell
) + 3 + strlen(command
) >= 1024)
4012 return ERROR_NOT_ENOUGH_MEMORY
4015 strcat(args
, shell
);
4016 strcat(args
, "/c ");
4017 strcat(args
, command
);
4019 /* execute asynchronously, inheriting the environment */
4020 rc
= DosExecPgm(errormsg
,
4031 popen(const char *command
, const char *mode
, int pipesize
, int *err
)
4037 /* mode determines which of stdin or stdout is reconnected to
4038 * the pipe to the child
4040 if (strchr(mode
, 'r') != NULL
) {
4041 tgt_fd
= 1; /* stdout */
4042 } else if (strchr(mode
, 'w')) {
4043 tgt_fd
= 0; /* stdin */
4045 *err
= ERROR_INVALID_ACCESS
;
4049 /* setup the pipe */
4050 if ((rc
= DosCreatePipe(&pipeh
[0], &pipeh
[1], pipesize
)) != NO_ERROR
) {
4055 /* prevent other threads accessing stdio */
4058 /* reconnect stdio and execute child */
4061 if (dup2(pipeh
[tgtfd
], tgtfd
) == 0) {
4062 DosClose(pipeh
[tgtfd
]);
4063 rc
= async_system(command
);
4070 /* allow other threads access to stdio */
4073 /* if execution of child was successful return file stream */
4075 return fdopen(pipeh
[1 - tgtfd
], mode
);
4077 DosClose(pipeh
[1 - tgtfd
]);
4084 posix_popen(PyObject
*self
, PyObject
*args
)
4088 int err
, bufsize
= -1;
4091 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4093 Py_BEGIN_ALLOW_THREADS
4094 fp
= popen(name
, mode
, (bufsize
> 0) ? bufsize
: 4096, &err
);
4095 Py_END_ALLOW_THREADS
4097 return os2_error(err
);
4099 f
= PyFile_FromFile(fp
, name
, mode
, fclose
);
4101 PyFile_SetBufSize(f
, bufsize
);
4105 #elif defined(PYCC_GCC)
4107 /* standard posix version of popen() support */
4109 posix_popen(PyObject
*self
, PyObject
*args
)
4116 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4118 Py_BEGIN_ALLOW_THREADS
4119 fp
= popen(name
, mode
);
4120 Py_END_ALLOW_THREADS
4122 return posix_error();
4123 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
4125 PyFile_SetBufSize(f
, bufsize
);
4129 /* fork() under OS/2 has lots'o'warts
4130 * EMX supports pipe() and spawn*() so we can synthesize popen[234]()
4131 * most of this code is a ripoff of the win32 code, but using the
4132 * capabilities of EMX's C library routines
4135 /* These tell _PyPopen() whether to return 1, 2, or 3 file objects. */
4141 static PyObject
*_PyPopen(char *, int, int, int);
4142 static int _PyPclose(FILE *file
);
4145 * Internal dictionary mapping popen* file pointers to process handles,
4146 * for use when retrieving the process exit code. See _PyPclose() below
4147 * for more information on this dictionary's use.
4149 static PyObject
*_PyPopenProcs
= NULL
;
4151 /* os2emx version of popen2()
4153 * The result of this function is a pipe (file) connected to the
4154 * process's stdin, and a pipe connected to the process's stdout.
4158 os2emx_popen2(PyObject
*self
, PyObject
*args
)
4166 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4171 else if (*mode
!= 'b') {
4172 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4177 f
= _PyPopen(cmdstring
, tm
, POPEN_2
, bufsize
);
4183 * Variation on os2emx.popen2
4185 * The result of this function is 3 pipes - the process's stdin,
4190 os2emx_popen3(PyObject
*self
, PyObject
*args
)
4198 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4203 else if (*mode
!= 'b') {
4204 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4209 f
= _PyPopen(cmdstring
, tm
, POPEN_3
, bufsize
);
4215 * Variation on os2emx.popen2
4217 * The result of this function is 2 pipes - the processes stdin,
4218 * and stdout+stderr combined as a single pipe.
4222 os2emx_popen4(PyObject
*self
, PyObject
*args
)
4230 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4235 else if (*mode
!= 'b') {
4236 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4241 f
= _PyPopen(cmdstring
, tm
, POPEN_4
, bufsize
);
4246 /* a couple of structures for convenient handling of multiple
4247 * file handles and pipes
4261 /* The following code is derived from the win32 code */
4264 _PyPopen(char *cmdstring
, int mode
, int n
, int bufsize
)
4266 struct file_ref stdio
[3];
4267 struct pipe_ref p_fd
[3];
4269 int file_count
, i
, pipe_err
, pipe_pid
;
4270 char *shell
, *sh_name
, *opt
, *rd_mode
, *wr_mode
;
4271 PyObject
*f
, *p_f
[3];
4273 /* file modes for subsequent fdopen's on pipe handles */
4285 /* prepare shell references */
4286 if ((shell
= getenv("EMXSHELL")) == NULL
)
4287 if ((shell
= getenv("COMSPEC")) == NULL
)
4290 return posix_error();
4293 sh_name
= _getname(shell
);
4294 if (stricmp(sh_name
, "cmd.exe") == 0 || stricmp(sh_name
, "4os2.exe") == 0)
4299 /* save current stdio fds + their flags, and set not inheritable */
4301 while (pipe_err
>= 0 && i
< 3)
4303 pipe_err
= stdio
[i
].handle
= dup(i
);
4304 stdio
[i
].flags
= fcntl(i
, F_GETFD
, 0);
4305 fcntl(stdio
[i
].handle
, F_SETFD
, stdio
[i
].flags
| FD_CLOEXEC
);
4310 /* didn't get them all saved - clean up and bail out */
4311 int saved_err
= errno
;
4314 close(stdio
[i
].handle
);
4317 return posix_error();
4320 /* create pipe ends */
4325 while ((pipe_err
== 0) && (i
< file_count
))
4326 pipe_err
= pipe((int *)&p_fd
[i
++]);
4329 /* didn't get them all made - clean up and bail out */
4336 return posix_error();
4339 /* change the actual standard IO streams over temporarily,
4340 * making the retained pipe ends non-inheritable
4345 if (dup2(p_fd
[0].rd
, 0) == 0)
4348 i
= fcntl(p_fd
[0].wr
, F_GETFD
, 0);
4349 fcntl(p_fd
[0].wr
, F_SETFD
, i
| FD_CLOEXEC
);
4350 if ((p_s
[0] = fdopen(p_fd
[0].wr
, wr_mode
)) == NULL
)
4364 if (dup2(p_fd
[1].wr
, 1) == 1)
4367 i
= fcntl(p_fd
[1].rd
, F_GETFD
, 0);
4368 fcntl(p_fd
[1].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4369 if ((p_s
[1] = fdopen(p_fd
[1].rd
, rd_mode
)) == NULL
)
4381 /* - stderr, as required */
4387 if (dup2(p_fd
[2].wr
, 2) == 2)
4390 i
= fcntl(p_fd
[2].rd
, F_GETFD
, 0);
4391 fcntl(p_fd
[2].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4392 if ((p_s
[2] = fdopen(p_fd
[2].rd
, rd_mode
)) == NULL
)
4407 if (dup2(1, 2) != 2)
4415 /* spawn the child process */
4418 pipe_pid
= spawnlp(P_NOWAIT
, shell
, shell
, opt
, cmdstring
, (char *)0);
4425 /* save the PID into the FILE structure
4426 * NOTE: this implementation doesn't actually
4427 * take advantage of this, but do it for
4428 * completeness - AIM Apr01
4430 for (i
= 0; i
< file_count
; i
++)
4431 p_s
[i
]->_pid
= pipe_pid
;
4435 /* reset standard IO to normal */
4436 for (i
= 0; i
< 3; i
++)
4438 dup2(stdio
[i
].handle
, i
);
4439 fcntl(i
, F_SETFD
, stdio
[i
].flags
);
4440 close(stdio
[i
].handle
);
4443 /* if any remnant problems, clean up and bail out */
4446 for (i
= 0; i
< 3; i
++)
4452 return posix_error_with_filename(cmdstring
);
4455 /* build tuple of file objects to return */
4456 if ((p_f
[0] = PyFile_FromFile(p_s
[0], cmdstring
, wr_mode
, _PyPclose
)) != NULL
)
4457 PyFile_SetBufSize(p_f
[0], bufsize
);
4458 if ((p_f
[1] = PyFile_FromFile(p_s
[1], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4459 PyFile_SetBufSize(p_f
[1], bufsize
);
4462 if ((p_f
[2] = PyFile_FromFile(p_s
[2], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4463 PyFile_SetBufSize(p_f
[0], bufsize
);
4464 f
= PyTuple_Pack(3, p_f
[0], p_f
[1], p_f
[2]);
4467 f
= PyTuple_Pack(2, p_f
[0], p_f
[1]);
4470 * Insert the files we've created into the process dictionary
4471 * all referencing the list with the process handle and the
4472 * initial number of files (see description below in _PyPclose).
4473 * Since if _PyPclose later tried to wait on a process when all
4474 * handles weren't closed, it could create a deadlock with the
4475 * child, we spend some energy here to try to ensure that we
4476 * either insert all file handles into the dictionary or none
4477 * at all. It's a little clumsy with the various popen modes
4478 * and variable number of files involved.
4482 _PyPopenProcs
= PyDict_New();
4487 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
[3];
4490 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
4491 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
4493 procObj
= PyList_New(2);
4494 pidObj
= PyInt_FromLong((long) pipe_pid
);
4495 intObj
= PyInt_FromLong((long) file_count
);
4497 if (procObj
&& pidObj
&& intObj
)
4499 PyList_SetItem(procObj
, 0, pidObj
);
4500 PyList_SetItem(procObj
, 1, intObj
);
4502 fileObj
[0] = PyLong_FromVoidPtr(p_s
[0]);
4505 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
4509 fileObj
[1] = PyLong_FromVoidPtr(p_s
[1]);
4512 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
4516 if (file_count
>= 3)
4518 fileObj
[2] = PyLong_FromVoidPtr(p_s
[2]);
4521 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
4527 if (ins_rc
[0] < 0 || !fileObj
[0] ||
4528 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
4529 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2]))
4531 /* Something failed - remove any dictionary
4532 * entries that did make it.
4534 if (!ins_rc
[0] && fileObj
[0])
4536 PyDict_DelItem(_PyPopenProcs
,
4539 if (!ins_rc
[1] && fileObj
[1])
4541 PyDict_DelItem(_PyPopenProcs
,
4544 if (!ins_rc
[2] && fileObj
[2])
4546 PyDict_DelItem(_PyPopenProcs
,
4553 * Clean up our localized references for the dictionary keys
4554 * and value since PyDict_SetItem will Py_INCREF any copies
4555 * that got placed in the dictionary.
4557 Py_XDECREF(procObj
);
4558 Py_XDECREF(fileObj
[0]);
4559 Py_XDECREF(fileObj
[1]);
4560 Py_XDECREF(fileObj
[2]);
4563 /* Child is launched. */
4568 * Wrapper for fclose() to use for popen* files, so we can retrieve the
4569 * exit code for the child process and return as a result of the close.
4571 * This function uses the _PyPopenProcs dictionary in order to map the
4572 * input file pointer to information about the process that was
4573 * originally created by the popen* call that created the file pointer.
4574 * The dictionary uses the file pointer as a key (with one entry
4575 * inserted for each file returned by the original popen* call) and a
4576 * single list object as the value for all files from a single call.
4577 * The list object contains the Win32 process handle at [0], and a file
4578 * count at [1], which is initialized to the total number of file
4579 * handles using that list.
4581 * This function closes whichever handle it is passed, and decrements
4582 * the file count in the dictionary for the process handle pointed to
4583 * by this file. On the last close (when the file count reaches zero),
4584 * this function will wait for the child process and then return its
4585 * exit code as the result of the close() operation. This permits the
4586 * files to be closed in any order - it is always the close() of the
4587 * final handle that will return the exit code.
4589 * NOTE: This function is currently called with the GIL released.
4590 * hence we use the GILState API to manage our state.
4593 static int _PyPclose(FILE *file
)
4598 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
;
4601 PyGILState_STATE state
;
4604 /* Close the file handle first, to ensure it can't block the
4605 * child from exiting if it's the last handle.
4607 result
= fclose(file
);
4610 state
= PyGILState_Ensure();
4614 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
4615 (procObj
= PyDict_GetItem(_PyPopenProcs
,
4616 fileObj
)) != NULL
&&
4617 (pidObj
= PyList_GetItem(procObj
,0)) != NULL
&&
4618 (intObj
= PyList_GetItem(procObj
,1)) != NULL
)
4620 pipe_pid
= (int) PyInt_AsLong(pidObj
);
4621 file_count
= (int) PyInt_AsLong(intObj
);
4625 /* Still other files referencing process */
4627 PyList_SetItem(procObj
,1,
4628 PyInt_FromLong((long) file_count
));
4632 /* Last file for this process */
4633 if (result
!= EOF
&&
4634 waitpid(pipe_pid
, &exit_code
, 0) == pipe_pid
)
4636 /* extract exit status */
4637 if (WIFEXITED(exit_code
))
4639 result
= WEXITSTATUS(exit_code
);
4649 /* Indicate failure - this will cause the file object
4650 * to raise an I/O error and translate the last
4651 * error code from errno. We do have a problem with
4652 * last errors that overlap the normal errno table,
4653 * but that's a consistent problem with the file object.
4659 /* Remove this file pointer from dictionary */
4660 PyDict_DelItem(_PyPopenProcs
, fileObj
);
4662 if (PyDict_Size(_PyPopenProcs
) == 0)
4664 Py_DECREF(_PyPopenProcs
);
4665 _PyPopenProcs
= NULL
;
4668 } /* if object retrieval ok */
4670 Py_XDECREF(fileObj
);
4671 } /* if _PyPopenProcs */
4674 PyGILState_Release(state
);
4679 #endif /* PYCC_??? */
4681 #elif defined(MS_WINDOWS)
4684 * Portable 'popen' replacement for Win32.
4686 * Written by Bill Tutt <billtut@microsoft.com>. Minor tweaks
4687 * and 2.0 integration by Fredrik Lundh <fredrik@pythonware.com>
4688 * Return code handling by David Bolen <db3l@fitlinxx.com>.
4695 /* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */
4701 static PyObject
*_PyPopen(char *, int, int);
4702 static int _PyPclose(FILE *file
);
4705 * Internal dictionary mapping popen* file pointers to process handles,
4706 * for use when retrieving the process exit code. See _PyPclose() below
4707 * for more information on this dictionary's use.
4709 static PyObject
*_PyPopenProcs
= NULL
;
4712 /* popen that works from a GUI.
4714 * The result of this function is a pipe (file) connected to the
4715 * processes stdin or stdout, depending on the requested mode.
4719 posix_popen(PyObject
*self
, PyObject
*args
)
4727 if (!PyArg_ParseTuple(args
, "s|si:popen", &cmdstring
, &mode
, &bufsize
))
4732 else if (*mode
!= 'w') {
4733 PyErr_SetString(PyExc_ValueError
, "popen() arg 2 must be 'r' or 'w'");
4738 if (bufsize
!= -1) {
4739 PyErr_SetString(PyExc_ValueError
, "popen() arg 3 must be -1");
4743 if (*(mode
+1) == 't')
4744 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4745 else if (*(mode
+1) == 'b')
4746 f
= _PyPopen(cmdstring
, tm
| _O_BINARY
, POPEN_1
);
4748 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4753 /* Variation on win32pipe.popen
4755 * The result of this function is a pipe (file) connected to the
4756 * process's stdin, and a pipe connected to the process's stdout.
4760 win32_popen2(PyObject
*self
, PyObject
*args
)
4768 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4773 else if (*mode
!= 'b') {
4774 PyErr_SetString(PyExc_ValueError
, "popen2() arg 2 must be 't' or 'b'");
4779 if (bufsize
!= -1) {
4780 PyErr_SetString(PyExc_ValueError
, "popen2() arg 3 must be -1");
4784 f
= _PyPopen(cmdstring
, tm
, POPEN_2
);
4790 * Variation on <om win32pipe.popen>
4792 * The result of this function is 3 pipes - the process's stdin,
4797 win32_popen3(PyObject
*self
, PyObject
*args
)
4805 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4810 else if (*mode
!= 'b') {
4811 PyErr_SetString(PyExc_ValueError
, "popen3() arg 2 must be 't' or 'b'");
4816 if (bufsize
!= -1) {
4817 PyErr_SetString(PyExc_ValueError
, "popen3() arg 3 must be -1");
4821 f
= _PyPopen(cmdstring
, tm
, POPEN_3
);
4827 * Variation on win32pipe.popen
4829 * The result of this function is 2 pipes - the processes stdin,
4830 * and stdout+stderr combined as a single pipe.
4834 win32_popen4(PyObject
*self
, PyObject
*args
)
4842 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4847 else if (*mode
!= 'b') {
4848 PyErr_SetString(PyExc_ValueError
, "popen4() arg 2 must be 't' or 'b'");
4853 if (bufsize
!= -1) {
4854 PyErr_SetString(PyExc_ValueError
, "popen4() arg 3 must be -1");
4858 f
= _PyPopen(cmdstring
, tm
, POPEN_4
);
4864 _PyPopenCreateProcess(char *cmdstring
,
4870 PROCESS_INFORMATION piProcInfo
;
4871 STARTUPINFO siStartInfo
;
4872 DWORD dwProcessFlags
= 0; /* no NEW_CONSOLE by default for Ctrl+C handling */
4873 char *s1
,*s2
, *s3
= " /c ";
4874 const char *szConsoleSpawn
= "w9xpopen.exe";
4878 if (i
= GetEnvironmentVariable("COMSPEC",NULL
,0)) {
4881 s1
= (char *)alloca(i
);
4882 if (!(x
= GetEnvironmentVariable("COMSPEC", s1
, i
)))
4883 /* x < i, so x fits into an integer */
4886 /* Explicitly check if we are using COMMAND.COM. If we are
4887 * then use the w9xpopen hack.
4890 while (comshell
>= s1
&& *comshell
!= '\\')
4894 if (GetVersion() < 0x80000000 &&
4895 _stricmp(comshell
, "command.com") != 0) {
4896 /* NT/2000 and not using command.com. */
4897 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1;
4898 s2
= (char *)alloca(x
);
4900 PyOS_snprintf(s2
, x
, "%s%s%s", s1
, s3
, cmdstring
);
4904 * Oh gag, we're on Win9x or using COMMAND.COM. Use
4905 * the workaround listed in KB: Q150956
4907 char modulepath
[_MAX_PATH
];
4908 struct stat statinfo
;
4909 GetModuleFileName(NULL
, modulepath
, sizeof(modulepath
));
4910 for (x
= i
= 0; modulepath
[i
]; i
++)
4911 if (modulepath
[i
] == SEP
)
4913 modulepath
[x
] = '\0';
4914 /* Create the full-name to w9xpopen, so we can test it exists */
4917 (sizeof(modulepath
)/sizeof(modulepath
[0]))
4918 -strlen(modulepath
));
4919 if (stat(modulepath
, &statinfo
) != 0) {
4920 size_t mplen
= sizeof(modulepath
)/sizeof(modulepath
[0]);
4921 /* Eeek - file-not-found - possibly an embedding
4922 situation - see if we can locate it in sys.prefix
4927 modulepath
[mplen
-1] = '\0';
4928 if (modulepath
[strlen(modulepath
)-1] != '\\')
4929 strcat(modulepath
, "\\");
4932 mplen
-strlen(modulepath
));
4933 /* No where else to look - raise an easily identifiable
4934 error, rather than leaving Windows to report
4935 "file not found" - as the user is probably blissfully
4936 unaware this shim EXE is used, and it will confuse them.
4937 (well, it confused me for a while ;-)
4939 if (stat(modulepath
, &statinfo
) != 0) {
4940 PyErr_Format(PyExc_RuntimeError
,
4941 "Can not locate '%s' which is needed "
4942 "for popen to work with your shell "
4948 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1 +
4949 strlen(modulepath
) +
4950 strlen(szConsoleSpawn
) + 1;
4952 s2
= (char *)alloca(x
);
4954 /* To maintain correct argument passing semantics,
4955 we pass the command-line as it stands, and allow
4956 quoting to be applied. w9xpopen.exe will then
4957 use its argv vector, and re-quote the necessary
4958 args for the ultimate child process.
4967 /* Not passing CREATE_NEW_CONSOLE has been known to
4968 cause random failures on win9x. Specifically a
4970 "Your program accessed mem currently in use at xxx"
4971 and a hopeful warning about the stability of your
4973 Cost is Ctrl+C wont kill children, but anyone
4974 who cares can have a go!
4976 dwProcessFlags
|= CREATE_NEW_CONSOLE
;
4980 /* Could be an else here to try cmd.exe / command.com in the path
4981 Now we'll just error out.. */
4983 PyErr_SetString(PyExc_RuntimeError
,
4984 "Cannot locate a COMSPEC environment variable to "
4985 "use as the shell");
4989 ZeroMemory(&siStartInfo
, sizeof(STARTUPINFO
));
4990 siStartInfo
.cb
= sizeof(STARTUPINFO
);
4991 siStartInfo
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
4992 siStartInfo
.hStdInput
= hStdin
;
4993 siStartInfo
.hStdOutput
= hStdout
;
4994 siStartInfo
.hStdError
= hStderr
;
4995 siStartInfo
.wShowWindow
= SW_HIDE
;
4997 if (CreateProcess(NULL
,
5007 /* Close the handles now so anyone waiting is woken. */
5008 CloseHandle(piProcInfo
.hThread
);
5010 /* Return process handle */
5011 *hProcess
= piProcInfo
.hProcess
;
5014 win32_error("CreateProcess", s2
);
5018 /* The following code is based off of KB: Q190351 */
5021 _PyPopen(char *cmdstring
, int mode
, int n
)
5023 HANDLE hChildStdinRd
, hChildStdinWr
, hChildStdoutRd
, hChildStdoutWr
,
5024 hChildStderrRd
, hChildStderrWr
, hChildStdinWrDup
, hChildStdoutRdDup
,
5025 hChildStderrRdDup
, hProcess
; /* hChildStdoutWrDup; */
5027 SECURITY_ATTRIBUTES saAttr
;
5034 saAttr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
5035 saAttr
.bInheritHandle
= TRUE
;
5036 saAttr
.lpSecurityDescriptor
= NULL
;
5038 if (!CreatePipe(&hChildStdinRd
, &hChildStdinWr
, &saAttr
, 0))
5039 return win32_error("CreatePipe", NULL
);
5041 /* Create new output read handle and the input write handle. Set
5042 * the inheritance properties to FALSE. Otherwise, the child inherits
5043 * these handles; resulting in non-closeable handles to the pipes
5045 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdinWr
,
5046 GetCurrentProcess(), &hChildStdinWrDup
, 0,
5048 DUPLICATE_SAME_ACCESS
);
5050 return win32_error("DuplicateHandle", NULL
);
5052 /* Close the inheritable version of ChildStdin
5053 that we're using. */
5054 CloseHandle(hChildStdinWr
);
5056 if (!CreatePipe(&hChildStdoutRd
, &hChildStdoutWr
, &saAttr
, 0))
5057 return win32_error("CreatePipe", NULL
);
5059 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdoutRd
,
5060 GetCurrentProcess(), &hChildStdoutRdDup
, 0,
5061 FALSE
, DUPLICATE_SAME_ACCESS
);
5063 return win32_error("DuplicateHandle", NULL
);
5065 /* Close the inheritable version of ChildStdout
5066 that we're using. */
5067 CloseHandle(hChildStdoutRd
);
5070 if (!CreatePipe(&hChildStderrRd
, &hChildStderrWr
, &saAttr
, 0))
5071 return win32_error("CreatePipe", NULL
);
5072 fSuccess
= DuplicateHandle(GetCurrentProcess(),
5074 GetCurrentProcess(),
5075 &hChildStderrRdDup
, 0,
5076 FALSE
, DUPLICATE_SAME_ACCESS
);
5078 return win32_error("DuplicateHandle", NULL
);
5079 /* Close the inheritable version of ChildStdErr that we're using. */
5080 CloseHandle(hChildStderrRd
);
5085 switch (mode
& (_O_RDONLY
| _O_TEXT
| _O_BINARY
| _O_WRONLY
)) {
5086 case _O_WRONLY
| _O_TEXT
:
5087 /* Case for writing to child Stdin in text mode. */
5088 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5089 f1
= _fdopen(fd1
, "w");
5090 f
= PyFile_FromFile(f1
, cmdstring
, "w", _PyPclose
);
5091 PyFile_SetBufSize(f
, 0);
5092 /* We don't care about these pipes anymore, so close them. */
5093 CloseHandle(hChildStdoutRdDup
);
5094 CloseHandle(hChildStderrRdDup
);
5097 case _O_RDONLY
| _O_TEXT
:
5098 /* Case for reading from child Stdout in text mode. */
5099 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5100 f1
= _fdopen(fd1
, "r");
5101 f
= PyFile_FromFile(f1
, cmdstring
, "r", _PyPclose
);
5102 PyFile_SetBufSize(f
, 0);
5103 /* We don't care about these pipes anymore, so close them. */
5104 CloseHandle(hChildStdinWrDup
);
5105 CloseHandle(hChildStderrRdDup
);
5108 case _O_RDONLY
| _O_BINARY
:
5109 /* Case for readinig from child Stdout in binary mode. */
5110 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5111 f1
= _fdopen(fd1
, "rb");
5112 f
= PyFile_FromFile(f1
, cmdstring
, "rb", _PyPclose
);
5113 PyFile_SetBufSize(f
, 0);
5114 /* We don't care about these pipes anymore, so close them. */
5115 CloseHandle(hChildStdinWrDup
);
5116 CloseHandle(hChildStderrRdDup
);
5119 case _O_WRONLY
| _O_BINARY
:
5120 /* Case for writing to child Stdin in binary mode. */
5121 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5122 f1
= _fdopen(fd1
, "wb");
5123 f
= PyFile_FromFile(f1
, cmdstring
, "wb", _PyPclose
);
5124 PyFile_SetBufSize(f
, 0);
5125 /* We don't care about these pipes anymore, so close them. */
5126 CloseHandle(hChildStdoutRdDup
);
5127 CloseHandle(hChildStderrRdDup
);
5139 if (mode
& _O_TEXT
) {
5147 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5148 f1
= _fdopen(fd1
, m2
);
5149 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5150 f2
= _fdopen(fd2
, m1
);
5151 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5152 PyFile_SetBufSize(p1
, 0);
5153 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5154 PyFile_SetBufSize(p2
, 0);
5157 CloseHandle(hChildStderrRdDup
);
5159 f
= PyTuple_Pack(2,p1
,p2
);
5169 PyObject
*p1
, *p2
, *p3
;
5171 if (mode
& _O_TEXT
) {
5179 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5180 f1
= _fdopen(fd1
, m2
);
5181 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5182 f2
= _fdopen(fd2
, m1
);
5183 fd3
= _open_osfhandle((Py_intptr_t
)hChildStderrRdDup
, mode
);
5184 f3
= _fdopen(fd3
, m1
);
5185 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5186 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5187 p3
= PyFile_FromFile(f3
, cmdstring
, m1
, _PyPclose
);
5188 PyFile_SetBufSize(p1
, 0);
5189 PyFile_SetBufSize(p2
, 0);
5190 PyFile_SetBufSize(p3
, 0);
5191 f
= PyTuple_Pack(3,p1
,p2
,p3
);
5201 if (!_PyPopenCreateProcess(cmdstring
,
5209 if (!_PyPopenCreateProcess(cmdstring
,
5218 * Insert the files we've created into the process dictionary
5219 * all referencing the list with the process handle and the
5220 * initial number of files (see description below in _PyPclose).
5221 * Since if _PyPclose later tried to wait on a process when all
5222 * handles weren't closed, it could create a deadlock with the
5223 * child, we spend some energy here to try to ensure that we
5224 * either insert all file handles into the dictionary or none
5225 * at all. It's a little clumsy with the various popen modes
5226 * and variable number of files involved.
5228 if (!_PyPopenProcs
) {
5229 _PyPopenProcs
= PyDict_New();
5232 if (_PyPopenProcs
) {
5233 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
[3];
5236 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
5237 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
5239 procObj
= PyList_New(2);
5240 hProcessObj
= PyLong_FromVoidPtr(hProcess
);
5241 intObj
= PyInt_FromLong(file_count
);
5243 if (procObj
&& hProcessObj
&& intObj
) {
5244 PyList_SetItem(procObj
,0,hProcessObj
);
5245 PyList_SetItem(procObj
,1,intObj
);
5247 fileObj
[0] = PyLong_FromVoidPtr(f1
);
5249 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
5253 if (file_count
>= 2) {
5254 fileObj
[1] = PyLong_FromVoidPtr(f2
);
5256 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
5261 if (file_count
>= 3) {
5262 fileObj
[2] = PyLong_FromVoidPtr(f3
);
5264 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
5270 if (ins_rc
[0] < 0 || !fileObj
[0] ||
5271 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
5272 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2])) {
5273 /* Something failed - remove any dictionary
5274 * entries that did make it.
5276 if (!ins_rc
[0] && fileObj
[0]) {
5277 PyDict_DelItem(_PyPopenProcs
,
5280 if (!ins_rc
[1] && fileObj
[1]) {
5281 PyDict_DelItem(_PyPopenProcs
,
5284 if (!ins_rc
[2] && fileObj
[2]) {
5285 PyDict_DelItem(_PyPopenProcs
,
5292 * Clean up our localized references for the dictionary keys
5293 * and value since PyDict_SetItem will Py_INCREF any copies
5294 * that got placed in the dictionary.
5296 Py_XDECREF(procObj
);
5297 Py_XDECREF(fileObj
[0]);
5298 Py_XDECREF(fileObj
[1]);
5299 Py_XDECREF(fileObj
[2]);
5302 /* Child is launched. Close the parents copy of those pipe
5303 * handles that only the child should have open. You need to
5304 * make sure that no handles to the write end of the output pipe
5305 * are maintained in this process or else the pipe will not close
5306 * when the child process exits and the ReadFile will hang. */
5308 if (!CloseHandle(hChildStdinRd
))
5309 return win32_error("CloseHandle", NULL
);
5311 if (!CloseHandle(hChildStdoutWr
))
5312 return win32_error("CloseHandle", NULL
);
5314 if ((n
!= 4) && (!CloseHandle(hChildStderrWr
)))
5315 return win32_error("CloseHandle", NULL
);
5321 * Wrapper for fclose() to use for popen* files, so we can retrieve the
5322 * exit code for the child process and return as a result of the close.
5324 * This function uses the _PyPopenProcs dictionary in order to map the
5325 * input file pointer to information about the process that was
5326 * originally created by the popen* call that created the file pointer.
5327 * The dictionary uses the file pointer as a key (with one entry
5328 * inserted for each file returned by the original popen* call) and a
5329 * single list object as the value for all files from a single call.
5330 * The list object contains the Win32 process handle at [0], and a file
5331 * count at [1], which is initialized to the total number of file
5332 * handles using that list.
5334 * This function closes whichever handle it is passed, and decrements
5335 * the file count in the dictionary for the process handle pointed to
5336 * by this file. On the last close (when the file count reaches zero),
5337 * this function will wait for the child process and then return its
5338 * exit code as the result of the close() operation. This permits the
5339 * files to be closed in any order - it is always the close() of the
5340 * final handle that will return the exit code.
5342 * NOTE: This function is currently called with the GIL released.
5343 * hence we use the GILState API to manage our state.
5346 static int _PyPclose(FILE *file
)
5351 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
;
5354 PyGILState_STATE state
;
5357 /* Close the file handle first, to ensure it can't block the
5358 * child from exiting if it's the last handle.
5360 result
= fclose(file
);
5362 state
= PyGILState_Ensure();
5364 if (_PyPopenProcs
) {
5365 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
5366 (procObj
= PyDict_GetItem(_PyPopenProcs
,
5367 fileObj
)) != NULL
&&
5368 (hProcessObj
= PyList_GetItem(procObj
,0)) != NULL
&&
5369 (intObj
= PyList_GetItem(procObj
,1)) != NULL
) {
5371 hProcess
= PyLong_AsVoidPtr(hProcessObj
);
5372 file_count
= PyInt_AsLong(intObj
);
5374 if (file_count
> 1) {
5375 /* Still other files referencing process */
5377 PyList_SetItem(procObj
,1,
5378 PyInt_FromLong(file_count
));
5380 /* Last file for this process */
5381 if (result
!= EOF
&&
5382 WaitForSingleObject(hProcess
, INFINITE
) != WAIT_FAILED
&&
5383 GetExitCodeProcess(hProcess
, &exit_code
)) {
5384 /* Possible truncation here in 16-bit environments, but
5385 * real exit codes are just the lower byte in any event.
5389 /* Indicate failure - this will cause the file object
5390 * to raise an I/O error and translate the last Win32
5391 * error code from errno. We do have a problem with
5392 * last errors that overlap the normal errno table,
5393 * but that's a consistent problem with the file object.
5395 if (result
!= EOF
) {
5396 /* If the error wasn't from the fclose(), then
5397 * set errno for the file object error handling.
5399 errno
= GetLastError();
5404 /* Free up the native handle at this point */
5405 CloseHandle(hProcess
);
5408 /* Remove this file pointer from dictionary */
5409 PyDict_DelItem(_PyPopenProcs
, fileObj
);
5411 if (PyDict_Size(_PyPopenProcs
) == 0) {
5412 Py_DECREF(_PyPopenProcs
);
5413 _PyPopenProcs
= NULL
;
5416 } /* if object retrieval ok */
5418 Py_XDECREF(fileObj
);
5419 } /* if _PyPopenProcs */
5422 PyGILState_Release(state
);
5427 #else /* which OS? */
5429 posix_popen(PyObject
*self
, PyObject
*args
)
5436 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
5438 /* Strip mode of binary or text modifiers */
5439 if (strcmp(mode
, "rb") == 0 || strcmp(mode
, "rt") == 0)
5441 else if (strcmp(mode
, "wb") == 0 || strcmp(mode
, "wt") == 0)
5443 Py_BEGIN_ALLOW_THREADS
5444 fp
= popen(name
, mode
);
5445 Py_END_ALLOW_THREADS
5447 return posix_error();
5448 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
5450 PyFile_SetBufSize(f
, bufsize
);
5454 #endif /* PYOS_??? */
5455 #endif /* HAVE_POPEN */
5459 PyDoc_STRVAR(posix_setuid__doc__
,
5461 Set the current process's user id.");
5464 posix_setuid(PyObject
*self
, PyObject
*args
)
5467 if (!PyArg_ParseTuple(args
, "i:setuid", &uid
))
5469 if (setuid(uid
) < 0)
5470 return posix_error();
5474 #endif /* HAVE_SETUID */
5478 PyDoc_STRVAR(posix_seteuid__doc__
,
5480 Set the current process's effective user id.");
5483 posix_seteuid (PyObject
*self
, PyObject
*args
)
5486 if (!PyArg_ParseTuple(args
, "i", &euid
)) {
5488 } else if (seteuid(euid
) < 0) {
5489 return posix_error();
5495 #endif /* HAVE_SETEUID */
5498 PyDoc_STRVAR(posix_setegid__doc__
,
5500 Set the current process's effective group id.");
5503 posix_setegid (PyObject
*self
, PyObject
*args
)
5506 if (!PyArg_ParseTuple(args
, "i", &egid
)) {
5508 } else if (setegid(egid
) < 0) {
5509 return posix_error();
5515 #endif /* HAVE_SETEGID */
5517 #ifdef HAVE_SETREUID
5518 PyDoc_STRVAR(posix_setreuid__doc__
,
5519 "setreuid(ruid, euid)\n\n\
5520 Set the current process's real and effective user ids.");
5523 posix_setreuid (PyObject
*self
, PyObject
*args
)
5526 if (!PyArg_ParseTuple(args
, "ii", &ruid
, &euid
)) {
5528 } else if (setreuid(ruid
, euid
) < 0) {
5529 return posix_error();
5535 #endif /* HAVE_SETREUID */
5537 #ifdef HAVE_SETREGID
5538 PyDoc_STRVAR(posix_setregid__doc__
,
5539 "setregid(rgid, egid)\n\n\
5540 Set the current process's real and effective group ids.");
5543 posix_setregid (PyObject
*self
, PyObject
*args
)
5546 if (!PyArg_ParseTuple(args
, "ii", &rgid
, &egid
)) {
5548 } else if (setregid(rgid
, egid
) < 0) {
5549 return posix_error();
5555 #endif /* HAVE_SETREGID */
5558 PyDoc_STRVAR(posix_setgid__doc__
,
5560 Set the current process's group id.");
5563 posix_setgid(PyObject
*self
, PyObject
*args
)
5566 if (!PyArg_ParseTuple(args
, "i:setgid", &gid
))
5568 if (setgid(gid
) < 0)
5569 return posix_error();
5573 #endif /* HAVE_SETGID */
5575 #ifdef HAVE_SETGROUPS
5576 PyDoc_STRVAR(posix_setgroups__doc__
,
5577 "setgroups(list)\n\n\
5578 Set the groups of the current process to list.");
5581 posix_setgroups(PyObject
*self
, PyObject
*groups
)
5584 gid_t grouplist
[MAX_GROUPS
];
5586 if (!PySequence_Check(groups
)) {
5587 PyErr_SetString(PyExc_TypeError
, "setgroups argument must be a sequence");
5590 len
= PySequence_Size(groups
);
5591 if (len
> MAX_GROUPS
) {
5592 PyErr_SetString(PyExc_ValueError
, "too many groups");
5595 for(i
= 0; i
< len
; i
++) {
5597 elem
= PySequence_GetItem(groups
, i
);
5600 if (!PyInt_Check(elem
)) {
5601 if (!PyLong_Check(elem
)) {
5602 PyErr_SetString(PyExc_TypeError
,
5603 "groups must be integers");
5607 unsigned long x
= PyLong_AsUnsignedLong(elem
);
5608 if (PyErr_Occurred()) {
5609 PyErr_SetString(PyExc_TypeError
,
5610 "group id too big");
5615 /* read back the value to see if it fitted in gid_t */
5616 if (grouplist
[i
] != x
) {
5617 PyErr_SetString(PyExc_TypeError
,
5618 "group id too big");
5624 long x
= PyInt_AsLong(elem
);
5626 if (grouplist
[i
] != x
) {
5627 PyErr_SetString(PyExc_TypeError
,
5628 "group id too big");
5636 if (setgroups(len
, grouplist
) < 0)
5637 return posix_error();
5641 #endif /* HAVE_SETGROUPS */
5643 #if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
5645 wait_helper(int pid
, int status
, struct rusage
*ru
)
5648 static PyObject
*struct_rusage
;
5651 return posix_error();
5653 if (struct_rusage
== NULL
) {
5654 PyObject
*m
= PyImport_ImportModuleNoBlock("resource");
5657 struct_rusage
= PyObject_GetAttrString(m
, "struct_rusage");
5659 if (struct_rusage
== NULL
)
5663 /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
5664 result
= PyStructSequence_New((PyTypeObject
*) struct_rusage
);
5669 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
5672 PyStructSequence_SET_ITEM(result
, 0,
5673 PyFloat_FromDouble(doubletime(ru
->ru_utime
)));
5674 PyStructSequence_SET_ITEM(result
, 1,
5675 PyFloat_FromDouble(doubletime(ru
->ru_stime
)));
5676 #define SET_INT(result, index, value)\
5677 PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))
5678 SET_INT(result
, 2, ru
->ru_maxrss
);
5679 SET_INT(result
, 3, ru
->ru_ixrss
);
5680 SET_INT(result
, 4, ru
->ru_idrss
);
5681 SET_INT(result
, 5, ru
->ru_isrss
);
5682 SET_INT(result
, 6, ru
->ru_minflt
);
5683 SET_INT(result
, 7, ru
->ru_majflt
);
5684 SET_INT(result
, 8, ru
->ru_nswap
);
5685 SET_INT(result
, 9, ru
->ru_inblock
);
5686 SET_INT(result
, 10, ru
->ru_oublock
);
5687 SET_INT(result
, 11, ru
->ru_msgsnd
);
5688 SET_INT(result
, 12, ru
->ru_msgrcv
);
5689 SET_INT(result
, 13, ru
->ru_nsignals
);
5690 SET_INT(result
, 14, ru
->ru_nvcsw
);
5691 SET_INT(result
, 15, ru
->ru_nivcsw
);
5694 if (PyErr_Occurred()) {
5699 return Py_BuildValue("iiN", pid
, status
, result
);
5701 #endif /* HAVE_WAIT3 || HAVE_WAIT4 */
5704 PyDoc_STRVAR(posix_wait3__doc__
,
5705 "wait3(options) -> (pid, status, rusage)\n\n\
5706 Wait for completion of a child process.");
5709 posix_wait3(PyObject
*self
, PyObject
*args
)
5714 WAIT_STATUS_INT(status
) = 0;
5716 if (!PyArg_ParseTuple(args
, "i:wait3", &options
))
5719 Py_BEGIN_ALLOW_THREADS
5720 pid
= wait3(&status
, options
, &ru
);
5721 Py_END_ALLOW_THREADS
5723 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5725 #endif /* HAVE_WAIT3 */
5728 PyDoc_STRVAR(posix_wait4__doc__
,
5729 "wait4(pid, options) -> (pid, status, rusage)\n\n\
5730 Wait for completion of a given child process.");
5733 posix_wait4(PyObject
*self
, PyObject
*args
)
5738 WAIT_STATUS_INT(status
) = 0;
5740 if (!PyArg_ParseTuple(args
, "ii:wait4", &pid
, &options
))
5743 Py_BEGIN_ALLOW_THREADS
5744 pid
= wait4(pid
, &status
, options
, &ru
);
5745 Py_END_ALLOW_THREADS
5747 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5749 #endif /* HAVE_WAIT4 */
5752 PyDoc_STRVAR(posix_waitpid__doc__
,
5753 "waitpid(pid, options) -> (pid, status)\n\n\
5754 Wait for completion of a given child process.");
5757 posix_waitpid(PyObject
*self
, PyObject
*args
)
5761 WAIT_STATUS_INT(status
) = 0;
5763 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5765 Py_BEGIN_ALLOW_THREADS
5766 pid
= waitpid(pid
, &status
, options
);
5767 Py_END_ALLOW_THREADS
5769 return posix_error();
5771 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5774 #elif defined(HAVE_CWAIT)
5776 /* MS C has a variant of waitpid() that's usable for most purposes. */
5777 PyDoc_STRVAR(posix_waitpid__doc__
,
5778 "waitpid(pid, options) -> (pid, status << 8)\n\n"
5779 "Wait for completion of a given process. options is ignored on Windows.");
5782 posix_waitpid(PyObject
*self
, PyObject
*args
)
5785 int status
, options
;
5787 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5789 Py_BEGIN_ALLOW_THREADS
5790 pid
= _cwait(&status
, pid
, options
);
5791 Py_END_ALLOW_THREADS
5793 return posix_error();
5795 /* shift the status left a byte so this is more like the POSIX waitpid */
5796 return Py_BuildValue("ii", pid
, status
<< 8);
5798 #endif /* HAVE_WAITPID || HAVE_CWAIT */
5801 PyDoc_STRVAR(posix_wait__doc__
,
5802 "wait() -> (pid, status)\n\n\
5803 Wait for completion of a child process.");
5806 posix_wait(PyObject
*self
, PyObject
*noargs
)
5810 WAIT_STATUS_INT(status
) = 0;
5812 Py_BEGIN_ALLOW_THREADS
5813 pid
= wait(&status
);
5814 Py_END_ALLOW_THREADS
5816 return posix_error();
5818 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5823 PyDoc_STRVAR(posix_lstat__doc__
,
5824 "lstat(path) -> stat result\n\n\
5825 Like stat(path), but do not follow symbolic links.");
5828 posix_lstat(PyObject
*self
, PyObject
*args
)
5831 return posix_do_stat(self
, args
, "et:lstat", lstat
, NULL
, NULL
);
5832 #else /* !HAVE_LSTAT */
5834 return posix_do_stat(self
, args
, "et:lstat", STAT
, "U:lstat", win32_wstat
);
5836 return posix_do_stat(self
, args
, "et:lstat", STAT
, NULL
, NULL
);
5838 #endif /* !HAVE_LSTAT */
5842 #ifdef HAVE_READLINK
5843 PyDoc_STRVAR(posix_readlink__doc__
,
5844 "readlink(path) -> path\n\n\
5845 Return a string representing the path to which the symbolic link points.");
5848 posix_readlink(PyObject
*self
, PyObject
*args
)
5851 char buf
[MAXPATHLEN
];
5854 #ifdef Py_USING_UNICODE
5855 int arg_is_unicode
= 0;
5858 if (!PyArg_ParseTuple(args
, "et:readlink",
5859 Py_FileSystemDefaultEncoding
, &path
))
5861 #ifdef Py_USING_UNICODE
5862 v
= PySequence_GetItem(args
, 0);
5868 if (PyUnicode_Check(v
)) {
5874 Py_BEGIN_ALLOW_THREADS
5875 n
= readlink(path
, buf
, (int) sizeof buf
);
5876 Py_END_ALLOW_THREADS
5878 return posix_error_with_allocated_filename(path
);
5881 v
= PyString_FromStringAndSize(buf
, n
);
5882 #ifdef Py_USING_UNICODE
5883 if (arg_is_unicode
) {
5886 w
= PyUnicode_FromEncodedObject(v
,
5887 Py_FileSystemDefaultEncoding
,
5894 /* fall back to the original byte string, as
5895 discussed in patch #683592 */
5902 #endif /* HAVE_READLINK */
5906 PyDoc_STRVAR(posix_symlink__doc__
,
5907 "symlink(src, dst)\n\n\
5908 Create a symbolic link pointing to src named dst.");
5911 posix_symlink(PyObject
*self
, PyObject
*args
)
5913 return posix_2str(args
, "etet:symlink", symlink
);
5915 #endif /* HAVE_SYMLINK */
5920 #define HZ 60 /* Universal constant :-) */
5923 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
5929 Py_BEGIN_ALLOW_THREADS
5930 DosQuerySysInfo(QSV_MS_COUNT
, QSV_MS_COUNT
, &value
, sizeof(value
));
5931 Py_END_ALLOW_THREADS
5937 posix_times(PyObject
*self
, PyObject
*noargs
)
5939 /* Currently Only Uptime is Provided -- Others Later */
5940 return Py_BuildValue("ddddd",
5941 (double)0 /* t.tms_utime / HZ */,
5942 (double)0 /* t.tms_stime / HZ */,
5943 (double)0 /* t.tms_cutime / HZ */,
5944 (double)0 /* t.tms_cstime / HZ */,
5945 (double)system_uptime() / 1000);
5949 posix_times(PyObject
*self
, PyObject
*noargs
)
5955 if (c
== (clock_t) -1)
5956 return posix_error();
5957 return Py_BuildValue("ddddd",
5958 (double)t
.tms_utime
/ HZ
,
5959 (double)t
.tms_stime
/ HZ
,
5960 (double)t
.tms_cutime
/ HZ
,
5961 (double)t
.tms_cstime
/ HZ
,
5964 #endif /* not OS2 */
5965 #endif /* HAVE_TIMES */
5969 #define HAVE_TIMES /* so the method table will pick it up */
5971 posix_times(PyObject
*self
, PyObject
*noargs
)
5973 FILETIME create
, exit
, kernel
, user
;
5975 hProc
= GetCurrentProcess();
5976 GetProcessTimes(hProc
, &create
, &exit
, &kernel
, &user
);
5977 /* The fields of a FILETIME structure are the hi and lo part
5978 of a 64-bit value expressed in 100 nanosecond units.
5979 1e7 is one second in such units; 1e-7 the inverse.
5980 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
5982 return Py_BuildValue(
5984 (double)(kernel
.dwHighDateTime
*429.4967296 +
5985 kernel
.dwLowDateTime
*1e-7),
5986 (double)(user
.dwHighDateTime
*429.4967296 +
5987 user
.dwLowDateTime
*1e-7),
5992 #endif /* MS_WINDOWS */
5995 PyDoc_STRVAR(posix_times__doc__
,
5996 "times() -> (utime, stime, cutime, cstime, elapsed_time)\n\n\
5997 Return a tuple of floating point numbers indicating process times.");
6002 PyDoc_STRVAR(posix_getsid__doc__
,
6003 "getsid(pid) -> sid\n\n\
6004 Call the system call getsid().");
6007 posix_getsid(PyObject
*self
, PyObject
*args
)
6010 if (!PyArg_ParseTuple(args
, "i:getsid", &pid
))
6014 return posix_error();
6015 return PyInt_FromLong((long)sid
);
6017 #endif /* HAVE_GETSID */
6021 PyDoc_STRVAR(posix_setsid__doc__
,
6023 Call the system call setsid().");
6026 posix_setsid(PyObject
*self
, PyObject
*noargs
)
6029 return posix_error();
6033 #endif /* HAVE_SETSID */
6036 PyDoc_STRVAR(posix_setpgid__doc__
,
6037 "setpgid(pid, pgrp)\n\n\
6038 Call the system call setpgid().");
6041 posix_setpgid(PyObject
*self
, PyObject
*args
)
6044 if (!PyArg_ParseTuple(args
, "ii:setpgid", &pid
, &pgrp
))
6046 if (setpgid(pid
, pgrp
) < 0)
6047 return posix_error();
6051 #endif /* HAVE_SETPGID */
6054 #ifdef HAVE_TCGETPGRP
6055 PyDoc_STRVAR(posix_tcgetpgrp__doc__
,
6056 "tcgetpgrp(fd) -> pgid\n\n\
6057 Return the process group associated with the terminal given by a fd.");
6060 posix_tcgetpgrp(PyObject
*self
, PyObject
*args
)
6063 if (!PyArg_ParseTuple(args
, "i:tcgetpgrp", &fd
))
6065 pgid
= tcgetpgrp(fd
);
6067 return posix_error();
6068 return PyInt_FromLong((long)pgid
);
6070 #endif /* HAVE_TCGETPGRP */
6073 #ifdef HAVE_TCSETPGRP
6074 PyDoc_STRVAR(posix_tcsetpgrp__doc__
,
6075 "tcsetpgrp(fd, pgid)\n\n\
6076 Set the process group associated with the terminal given by a fd.");
6079 posix_tcsetpgrp(PyObject
*self
, PyObject
*args
)
6082 if (!PyArg_ParseTuple(args
, "ii:tcsetpgrp", &fd
, &pgid
))
6084 if (tcsetpgrp(fd
, pgid
) < 0)
6085 return posix_error();
6089 #endif /* HAVE_TCSETPGRP */
6091 /* Functions acting on file descriptors */
6093 PyDoc_STRVAR(posix_open__doc__
,
6094 "open(filename, flag [, mode=0777]) -> fd\n\n\
6095 Open a file (for low level IO).");
6098 posix_open(PyObject
*self
, PyObject
*args
)
6106 if (unicode_file_names()) {
6107 PyUnicodeObject
*po
;
6108 if (PyArg_ParseTuple(args
, "Ui|i:mkdir", &po
, &flag
, &mode
)) {
6109 Py_BEGIN_ALLOW_THREADS
6110 /* PyUnicode_AS_UNICODE OK without thread
6111 lock as it is a simple dereference. */
6112 fd
= _wopen(PyUnicode_AS_UNICODE(po
), flag
, mode
);
6113 Py_END_ALLOW_THREADS
6115 return posix_error();
6116 return PyInt_FromLong((long)fd
);
6118 /* Drop the argument parsing error as narrow strings
6124 if (!PyArg_ParseTuple(args
, "eti|i",
6125 Py_FileSystemDefaultEncoding
, &file
,
6129 Py_BEGIN_ALLOW_THREADS
6130 fd
= open(file
, flag
, mode
);
6131 Py_END_ALLOW_THREADS
6133 return posix_error_with_allocated_filename(file
);
6135 return PyInt_FromLong((long)fd
);
6139 PyDoc_STRVAR(posix_close__doc__
,
6141 Close a file descriptor (for low level IO).");
6144 posix_close(PyObject
*self
, PyObject
*args
)
6147 if (!PyArg_ParseTuple(args
, "i:close", &fd
))
6149 Py_BEGIN_ALLOW_THREADS
6151 Py_END_ALLOW_THREADS
6153 return posix_error();
6159 PyDoc_STRVAR(posix_dup__doc__
,
6160 "dup(fd) -> fd2\n\n\
6161 Return a duplicate of a file descriptor.");
6164 posix_dup(PyObject
*self
, PyObject
*args
)
6167 if (!PyArg_ParseTuple(args
, "i:dup", &fd
))
6169 Py_BEGIN_ALLOW_THREADS
6171 Py_END_ALLOW_THREADS
6173 return posix_error();
6174 return PyInt_FromLong((long)fd
);
6178 PyDoc_STRVAR(posix_dup2__doc__
,
6179 "dup2(old_fd, new_fd)\n\n\
6180 Duplicate file descriptor.");
6183 posix_dup2(PyObject
*self
, PyObject
*args
)
6186 if (!PyArg_ParseTuple(args
, "ii:dup2", &fd
, &fd2
))
6188 Py_BEGIN_ALLOW_THREADS
6189 res
= dup2(fd
, fd2
);
6190 Py_END_ALLOW_THREADS
6192 return posix_error();
6198 PyDoc_STRVAR(posix_lseek__doc__
,
6199 "lseek(fd, pos, how) -> newpos\n\n\
6200 Set the current position of a file descriptor.");
6203 posix_lseek(PyObject
*self
, PyObject
*args
)
6206 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6207 PY_LONG_LONG pos
, res
;
6212 if (!PyArg_ParseTuple(args
, "iOi:lseek", &fd
, &posobj
, &how
))
6215 /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
6217 case 0: how
= SEEK_SET
; break;
6218 case 1: how
= SEEK_CUR
; break;
6219 case 2: how
= SEEK_END
; break;
6221 #endif /* SEEK_END */
6223 #if !defined(HAVE_LARGEFILE_SUPPORT)
6224 pos
= PyInt_AsLong(posobj
);
6226 pos
= PyLong_Check(posobj
) ?
6227 PyLong_AsLongLong(posobj
) : PyInt_AsLong(posobj
);
6229 if (PyErr_Occurred())
6232 Py_BEGIN_ALLOW_THREADS
6233 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6234 res
= _lseeki64(fd
, pos
, how
);
6236 res
= lseek(fd
, pos
, how
);
6238 Py_END_ALLOW_THREADS
6240 return posix_error();
6242 #if !defined(HAVE_LARGEFILE_SUPPORT)
6243 return PyInt_FromLong(res
);
6245 return PyLong_FromLongLong(res
);
6250 PyDoc_STRVAR(posix_read__doc__
,
6251 "read(fd, buffersize) -> string\n\n\
6252 Read a file descriptor.");
6255 posix_read(PyObject
*self
, PyObject
*args
)
6259 if (!PyArg_ParseTuple(args
, "ii:read", &fd
, &size
))
6263 return posix_error();
6265 buffer
= PyString_FromStringAndSize((char *)NULL
, size
);
6268 Py_BEGIN_ALLOW_THREADS
6269 n
= read(fd
, PyString_AsString(buffer
), size
);
6270 Py_END_ALLOW_THREADS
6273 return posix_error();
6276 _PyString_Resize(&buffer
, n
);
6281 PyDoc_STRVAR(posix_write__doc__
,
6282 "write(fd, string) -> byteswritten\n\n\
6283 Write a string to a file descriptor.");
6286 posix_write(PyObject
*self
, PyObject
*args
)
6292 if (!PyArg_ParseTuple(args
, "is#:write", &fd
, &buffer
, &size
))
6294 Py_BEGIN_ALLOW_THREADS
6295 size
= write(fd
, buffer
, (size_t)size
);
6296 Py_END_ALLOW_THREADS
6298 return posix_error();
6299 return PyInt_FromSsize_t(size
);
6303 PyDoc_STRVAR(posix_fstat__doc__
,
6304 "fstat(fd) -> stat result\n\n\
6305 Like stat(), but for an open file descriptor.");
6308 posix_fstat(PyObject
*self
, PyObject
*args
)
6313 if (!PyArg_ParseTuple(args
, "i:fstat", &fd
))
6316 /* on OpenVMS we must ensure that all bytes are written to the file */
6319 Py_BEGIN_ALLOW_THREADS
6320 res
= FSTAT(fd
, &st
);
6321 Py_END_ALLOW_THREADS
6324 return win32_error("fstat", NULL
);
6326 return posix_error();
6330 return _pystat_fromstructstat(&st
);
6334 PyDoc_STRVAR(posix_fdopen__doc__
,
6335 "fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\n\
6336 Return an open file object connected to a file descriptor.");
6339 posix_fdopen(PyObject
*self
, PyObject
*args
)
6342 char *orgmode
= "r";
6347 if (!PyArg_ParseTuple(args
, "i|si", &fd
, &orgmode
, &bufsize
))
6350 /* Sanitize mode. See fileobject.c */
6351 mode
= PyMem_MALLOC(strlen(orgmode
)+3);
6356 strcpy(mode
, orgmode
);
6357 if (_PyFile_SanitizeMode(mode
)) {
6361 Py_BEGIN_ALLOW_THREADS
6362 #if !defined(MS_WINDOWS) && defined(HAVE_FCNTL_H)
6363 if (mode
[0] == 'a') {
6364 /* try to make sure the O_APPEND flag is set */
6366 flags
= fcntl(fd
, F_GETFL
);
6368 fcntl(fd
, F_SETFL
, flags
| O_APPEND
);
6369 fp
= fdopen(fd
, mode
);
6370 if (fp
== NULL
&& flags
!= -1)
6371 /* restore old mode if fdopen failed */
6372 fcntl(fd
, F_SETFL
, flags
);
6374 fp
= fdopen(fd
, mode
);
6377 fp
= fdopen(fd
, mode
);
6379 Py_END_ALLOW_THREADS
6382 return posix_error();
6383 f
= PyFile_FromFile(fp
, "<fdopen>", orgmode
, fclose
);
6385 PyFile_SetBufSize(f
, bufsize
);
6389 PyDoc_STRVAR(posix_isatty__doc__
,
6390 "isatty(fd) -> bool\n\n\
6391 Return True if the file descriptor 'fd' is an open file descriptor\n\
6392 connected to the slave end of a terminal.");
6395 posix_isatty(PyObject
*self
, PyObject
*args
)
6398 if (!PyArg_ParseTuple(args
, "i:isatty", &fd
))
6400 return PyBool_FromLong(isatty(fd
));
6404 PyDoc_STRVAR(posix_pipe__doc__
,
6405 "pipe() -> (read_end, write_end)\n\n\
6409 posix_pipe(PyObject
*self
, PyObject
*noargs
)
6411 #if defined(PYOS_OS2)
6415 Py_BEGIN_ALLOW_THREADS
6416 rc
= DosCreatePipe( &read
, &write
, 4096);
6417 Py_END_ALLOW_THREADS
6419 return os2_error(rc
);
6421 return Py_BuildValue("(ii)", read
, write
);
6423 #if !defined(MS_WINDOWS)
6426 Py_BEGIN_ALLOW_THREADS
6428 Py_END_ALLOW_THREADS
6430 return posix_error();
6431 return Py_BuildValue("(ii)", fds
[0], fds
[1]);
6432 #else /* MS_WINDOWS */
6434 int read_fd
, write_fd
;
6436 Py_BEGIN_ALLOW_THREADS
6437 ok
= CreatePipe(&read
, &write
, NULL
, 0);
6438 Py_END_ALLOW_THREADS
6440 return win32_error("CreatePipe", NULL
);
6441 read_fd
= _open_osfhandle((Py_intptr_t
)read
, 0);
6442 write_fd
= _open_osfhandle((Py_intptr_t
)write
, 1);
6443 return Py_BuildValue("(ii)", read_fd
, write_fd
);
6444 #endif /* MS_WINDOWS */
6447 #endif /* HAVE_PIPE */
6451 PyDoc_STRVAR(posix_mkfifo__doc__
,
6452 "mkfifo(filename [, mode=0666])\n\n\
6453 Create a FIFO (a POSIX named pipe).");
6456 posix_mkfifo(PyObject
*self
, PyObject
*args
)
6461 if (!PyArg_ParseTuple(args
, "s|i:mkfifo", &filename
, &mode
))
6463 Py_BEGIN_ALLOW_THREADS
6464 res
= mkfifo(filename
, mode
);
6465 Py_END_ALLOW_THREADS
6467 return posix_error();
6474 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
6475 PyDoc_STRVAR(posix_mknod__doc__
,
6476 "mknod(filename [, mode=0600, device])\n\n\
6477 Create a filesystem node (file, device special file or named pipe)\n\
6478 named filename. mode specifies both the permissions to use and the\n\
6479 type of node to be created, being combined (bitwise OR) with one of\n\
6480 S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\n\
6481 device defines the newly created device special file (probably using\n\
6482 os.makedev()), otherwise it is ignored.");
6486 posix_mknod(PyObject
*self
, PyObject
*args
)
6492 if (!PyArg_ParseTuple(args
, "s|ii:mknod", &filename
, &mode
, &device
))
6494 Py_BEGIN_ALLOW_THREADS
6495 res
= mknod(filename
, mode
, device
);
6496 Py_END_ALLOW_THREADS
6498 return posix_error();
6504 #ifdef HAVE_DEVICE_MACROS
6505 PyDoc_STRVAR(posix_major__doc__
,
6506 "major(device) -> major number\n\
6507 Extracts a device major number from a raw device number.");
6510 posix_major(PyObject
*self
, PyObject
*args
)
6513 if (!PyArg_ParseTuple(args
, "i:major", &device
))
6515 return PyInt_FromLong((long)major(device
));
6518 PyDoc_STRVAR(posix_minor__doc__
,
6519 "minor(device) -> minor number\n\
6520 Extracts a device minor number from a raw device number.");
6523 posix_minor(PyObject
*self
, PyObject
*args
)
6526 if (!PyArg_ParseTuple(args
, "i:minor", &device
))
6528 return PyInt_FromLong((long)minor(device
));
6531 PyDoc_STRVAR(posix_makedev__doc__
,
6532 "makedev(major, minor) -> device number\n\
6533 Composes a raw device number from the major and minor device numbers.");
6536 posix_makedev(PyObject
*self
, PyObject
*args
)
6539 if (!PyArg_ParseTuple(args
, "ii:makedev", &major
, &minor
))
6541 return PyInt_FromLong((long)makedev(major
, minor
));
6543 #endif /* device macros */
6546 #ifdef HAVE_FTRUNCATE
6547 PyDoc_STRVAR(posix_ftruncate__doc__
,
6548 "ftruncate(fd, length)\n\n\
6549 Truncate a file to a specified length.");
6552 posix_ftruncate(PyObject
*self
, PyObject
*args
)
6559 if (!PyArg_ParseTuple(args
, "iO:ftruncate", &fd
, &lenobj
))
6562 #if !defined(HAVE_LARGEFILE_SUPPORT)
6563 length
= PyInt_AsLong(lenobj
);
6565 length
= PyLong_Check(lenobj
) ?
6566 PyLong_AsLongLong(lenobj
) : PyInt_AsLong(lenobj
);
6568 if (PyErr_Occurred())
6571 Py_BEGIN_ALLOW_THREADS
6572 res
= ftruncate(fd
, length
);
6573 Py_END_ALLOW_THREADS
6575 PyErr_SetFromErrno(PyExc_IOError
);
6584 PyDoc_STRVAR(posix_putenv__doc__
,
6585 "putenv(key, value)\n\n\
6586 Change or add an environment variable.");
6588 /* Save putenv() parameters as values here, so we can collect them when they
6589 * get re-set with another call for the same key. */
6590 static PyObject
*posix_putenv_garbage
;
6593 posix_putenv(PyObject
*self
, PyObject
*args
)
6600 if (!PyArg_ParseTuple(args
, "ss:putenv", &s1
, &s2
))
6603 #if defined(PYOS_OS2)
6604 if (stricmp(s1
, "BEGINLIBPATH") == 0) {
6607 rc
= DosSetExtLIBPATH(s2
, BEGIN_LIBPATH
);
6609 return os2_error(rc
);
6611 } else if (stricmp(s1
, "ENDLIBPATH") == 0) {
6614 rc
= DosSetExtLIBPATH(s2
, END_LIBPATH
);
6616 return os2_error(rc
);
6620 /* XXX This can leak memory -- not easy to fix :-( */
6621 len
= strlen(s1
) + strlen(s2
) + 2;
6622 /* len includes space for a trailing \0; the size arg to
6623 PyString_FromStringAndSize does not count that */
6624 newstr
= PyString_FromStringAndSize(NULL
, (int)len
- 1);
6626 return PyErr_NoMemory();
6627 newenv
= PyString_AS_STRING(newstr
);
6628 PyOS_snprintf(newenv
, len
, "%s=%s", s1
, s2
);
6629 if (putenv(newenv
)) {
6634 /* Install the first arg and newstr in posix_putenv_garbage;
6635 * this will cause previous value to be collected. This has to
6636 * happen after the real putenv() call because the old value
6637 * was still accessible until then. */
6638 if (PyDict_SetItem(posix_putenv_garbage
,
6639 PyTuple_GET_ITEM(args
, 0), newstr
)) {
6640 /* really not much we can do; just leak */
6647 #if defined(PYOS_OS2)
6655 #ifdef HAVE_UNSETENV
6656 PyDoc_STRVAR(posix_unsetenv__doc__
,
6658 Delete an environment variable.");
6661 posix_unsetenv(PyObject
*self
, PyObject
*args
)
6665 if (!PyArg_ParseTuple(args
, "s:unsetenv", &s1
))
6670 /* Remove the key from posix_putenv_garbage;
6671 * this will cause it to be collected. This has to
6672 * happen after the real unsetenv() call because the
6673 * old value was still accessible until then.
6675 if (PyDict_DelItem(posix_putenv_garbage
,
6676 PyTuple_GET_ITEM(args
, 0))) {
6677 /* really not much we can do; just leak */
6684 #endif /* unsetenv */
6686 #ifdef HAVE_STRERROR
6687 PyDoc_STRVAR(posix_strerror__doc__
,
6688 "strerror(code) -> string\n\n\
6689 Translate an error code to a message string.");
6692 posix_strerror(PyObject
*self
, PyObject
*args
)
6696 if (!PyArg_ParseTuple(args
, "i:strerror", &code
))
6698 message
= strerror(code
);
6699 if (message
== NULL
) {
6700 PyErr_SetString(PyExc_ValueError
,
6701 "strerror() argument out of range");
6704 return PyString_FromString(message
);
6706 #endif /* strerror */
6709 #ifdef HAVE_SYS_WAIT_H
6712 PyDoc_STRVAR(posix_WCOREDUMP__doc__
,
6713 "WCOREDUMP(status) -> bool\n\n\
6714 Return True if the process returning 'status' was dumped to a core file.");
6717 posix_WCOREDUMP(PyObject
*self
, PyObject
*args
)
6720 WAIT_STATUS_INT(status
) = 0;
6722 if (!PyArg_ParseTuple(args
, "i:WCOREDUMP", &WAIT_STATUS_INT(status
)))
6725 return PyBool_FromLong(WCOREDUMP(status
));
6727 #endif /* WCOREDUMP */
6730 PyDoc_STRVAR(posix_WIFCONTINUED__doc__
,
6731 "WIFCONTINUED(status) -> bool\n\n\
6732 Return True if the process returning 'status' was continued from a\n\
6733 job control stop.");
6736 posix_WIFCONTINUED(PyObject
*self
, PyObject
*args
)
6739 WAIT_STATUS_INT(status
) = 0;
6741 if (!PyArg_ParseTuple(args
, "i:WCONTINUED", &WAIT_STATUS_INT(status
)))
6744 return PyBool_FromLong(WIFCONTINUED(status
));
6746 #endif /* WIFCONTINUED */
6749 PyDoc_STRVAR(posix_WIFSTOPPED__doc__
,
6750 "WIFSTOPPED(status) -> bool\n\n\
6751 Return True if the process returning 'status' was stopped.");
6754 posix_WIFSTOPPED(PyObject
*self
, PyObject
*args
)
6757 WAIT_STATUS_INT(status
) = 0;
6759 if (!PyArg_ParseTuple(args
, "i:WIFSTOPPED", &WAIT_STATUS_INT(status
)))
6762 return PyBool_FromLong(WIFSTOPPED(status
));
6764 #endif /* WIFSTOPPED */
6767 PyDoc_STRVAR(posix_WIFSIGNALED__doc__
,
6768 "WIFSIGNALED(status) -> bool\n\n\
6769 Return True if the process returning 'status' was terminated by a signal.");
6772 posix_WIFSIGNALED(PyObject
*self
, PyObject
*args
)
6775 WAIT_STATUS_INT(status
) = 0;
6777 if (!PyArg_ParseTuple(args
, "i:WIFSIGNALED", &WAIT_STATUS_INT(status
)))
6780 return PyBool_FromLong(WIFSIGNALED(status
));
6782 #endif /* WIFSIGNALED */
6785 PyDoc_STRVAR(posix_WIFEXITED__doc__
,
6786 "WIFEXITED(status) -> bool\n\n\
6787 Return true if the process returning 'status' exited using the exit()\n\
6791 posix_WIFEXITED(PyObject
*self
, PyObject
*args
)
6794 WAIT_STATUS_INT(status
) = 0;
6796 if (!PyArg_ParseTuple(args
, "i:WIFEXITED", &WAIT_STATUS_INT(status
)))
6799 return PyBool_FromLong(WIFEXITED(status
));
6801 #endif /* WIFEXITED */
6804 PyDoc_STRVAR(posix_WEXITSTATUS__doc__
,
6805 "WEXITSTATUS(status) -> integer\n\n\
6806 Return the process return code from 'status'.");
6809 posix_WEXITSTATUS(PyObject
*self
, PyObject
*args
)
6812 WAIT_STATUS_INT(status
) = 0;
6814 if (!PyArg_ParseTuple(args
, "i:WEXITSTATUS", &WAIT_STATUS_INT(status
)))
6817 return Py_BuildValue("i", WEXITSTATUS(status
));
6819 #endif /* WEXITSTATUS */
6822 PyDoc_STRVAR(posix_WTERMSIG__doc__
,
6823 "WTERMSIG(status) -> integer\n\n\
6824 Return the signal that terminated the process that provided the 'status'\n\
6828 posix_WTERMSIG(PyObject
*self
, PyObject
*args
)
6831 WAIT_STATUS_INT(status
) = 0;
6833 if (!PyArg_ParseTuple(args
, "i:WTERMSIG", &WAIT_STATUS_INT(status
)))
6836 return Py_BuildValue("i", WTERMSIG(status
));
6838 #endif /* WTERMSIG */
6841 PyDoc_STRVAR(posix_WSTOPSIG__doc__
,
6842 "WSTOPSIG(status) -> integer\n\n\
6843 Return the signal that stopped the process that provided\n\
6844 the 'status' value.");
6847 posix_WSTOPSIG(PyObject
*self
, PyObject
*args
)
6850 WAIT_STATUS_INT(status
) = 0;
6852 if (!PyArg_ParseTuple(args
, "i:WSTOPSIG", &WAIT_STATUS_INT(status
)))
6855 return Py_BuildValue("i", WSTOPSIG(status
));
6857 #endif /* WSTOPSIG */
6859 #endif /* HAVE_SYS_WAIT_H */
6862 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
6864 /* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the
6865 needed definitions in sys/statvfs.h */
6868 #include <sys/statvfs.h>
6871 _pystatvfs_fromstructstatvfs(struct statvfs st
) {
6872 PyObject
*v
= PyStructSequence_New(&StatVFSResultType
);
6876 #if !defined(HAVE_LARGEFILE_SUPPORT)
6877 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
6878 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
6879 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long) st
.f_blocks
));
6880 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long) st
.f_bfree
));
6881 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long) st
.f_bavail
));
6882 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long) st
.f_files
));
6883 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong((long) st
.f_ffree
));
6884 PyStructSequence_SET_ITEM(v
, 7, PyInt_FromLong((long) st
.f_favail
));
6885 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
6886 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
6888 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
6889 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
6890 PyStructSequence_SET_ITEM(v
, 2,
6891 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_blocks
));
6892 PyStructSequence_SET_ITEM(v
, 3,
6893 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bfree
));
6894 PyStructSequence_SET_ITEM(v
, 4,
6895 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bavail
));
6896 PyStructSequence_SET_ITEM(v
, 5,
6897 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_files
));
6898 PyStructSequence_SET_ITEM(v
, 6,
6899 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_ffree
));
6900 PyStructSequence_SET_ITEM(v
, 7,
6901 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_favail
));
6902 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
6903 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
6909 PyDoc_STRVAR(posix_fstatvfs__doc__
,
6910 "fstatvfs(fd) -> statvfs result\n\n\
6911 Perform an fstatvfs system call on the given fd.");
6914 posix_fstatvfs(PyObject
*self
, PyObject
*args
)
6919 if (!PyArg_ParseTuple(args
, "i:fstatvfs", &fd
))
6921 Py_BEGIN_ALLOW_THREADS
6922 res
= fstatvfs(fd
, &st
);
6923 Py_END_ALLOW_THREADS
6925 return posix_error();
6927 return _pystatvfs_fromstructstatvfs(st
);
6929 #endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */
6932 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
6933 #include <sys/statvfs.h>
6935 PyDoc_STRVAR(posix_statvfs__doc__
,
6936 "statvfs(path) -> statvfs result\n\n\
6937 Perform a statvfs system call on the given path.");
6940 posix_statvfs(PyObject
*self
, PyObject
*args
)
6945 if (!PyArg_ParseTuple(args
, "s:statvfs", &path
))
6947 Py_BEGIN_ALLOW_THREADS
6948 res
= statvfs(path
, &st
);
6949 Py_END_ALLOW_THREADS
6951 return posix_error_with_filename(path
);
6953 return _pystatvfs_fromstructstatvfs(st
);
6955 #endif /* HAVE_STATVFS */
6959 PyDoc_STRVAR(posix_tempnam__doc__
,
6960 "tempnam([dir[, prefix]]) -> string\n\n\
6961 Return a unique name for a temporary file.\n\
6962 The directory and a prefix may be specified as strings; they may be omitted\n\
6963 or None if not needed.");
6966 posix_tempnam(PyObject
*self
, PyObject
*args
)
6968 PyObject
*result
= NULL
;
6973 if (!PyArg_ParseTuple(args
, "|zz:tempnam", &dir
, &pfx
))
6976 if (PyErr_Warn(PyExc_RuntimeWarning
,
6977 "tempnam is a potential security risk to your program") < 0)
6981 name
= _tempnam(dir
, pfx
);
6983 name
= tempnam(dir
, pfx
);
6986 return PyErr_NoMemory();
6987 result
= PyString_FromString(name
);
6995 PyDoc_STRVAR(posix_tmpfile__doc__
,
6996 "tmpfile() -> file object\n\n\
6997 Create a temporary file with no directory entries.");
7000 posix_tmpfile(PyObject
*self
, PyObject
*noargs
)
7006 return posix_error();
7007 return PyFile_FromFile(fp
, "<tmpfile>", "w+b", fclose
);
7013 PyDoc_STRVAR(posix_tmpnam__doc__
,
7014 "tmpnam() -> string\n\n\
7015 Return a unique name for a temporary file.");
7018 posix_tmpnam(PyObject
*self
, PyObject
*noargs
)
7020 char buffer
[L_tmpnam
];
7023 if (PyErr_Warn(PyExc_RuntimeWarning
,
7024 "tmpnam is a potential security risk to your program") < 0)
7028 name
= tmpnam_r(buffer
);
7030 name
= tmpnam(buffer
);
7033 PyObject
*err
= Py_BuildValue("is", 0,
7035 "unexpected NULL from tmpnam_r"
7037 "unexpected NULL from tmpnam"
7040 PyErr_SetObject(PyExc_OSError
, err
);
7044 return PyString_FromString(buffer
);
7049 /* This is used for fpathconf(), pathconf(), confstr() and sysconf().
7050 * It maps strings representing configuration variable names to
7051 * integer values, allowing those functions to be called with the
7052 * magic names instead of polluting the module's namespace with tons of
7053 * rarely-used constants. There are three separate tables that use
7054 * these definitions.
7056 * This code is always included, even if none of the interfaces that
7057 * need it are included. The #if hackery needed to avoid it would be
7058 * sufficiently pervasive that it's not worth the loss of readability.
7066 conv_confname(PyObject
*arg
, int *valuep
, struct constdef
*table
,
7069 if (PyInt_Check(arg
)) {
7070 *valuep
= PyInt_AS_LONG(arg
);
7073 if (PyString_Check(arg
)) {
7074 /* look up the value in the table using a binary search */
7077 size_t hi
= tablesize
;
7079 char *confname
= PyString_AS_STRING(arg
);
7081 mid
= (lo
+ hi
) / 2;
7082 cmp
= strcmp(confname
, table
[mid
].name
);
7088 *valuep
= table
[mid
].value
;
7092 PyErr_SetString(PyExc_ValueError
, "unrecognized configuration name");
7095 PyErr_SetString(PyExc_TypeError
,
7096 "configuration names must be strings or integers");
7101 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
7102 static struct constdef posix_constants_pathconf
[] = {
7103 #ifdef _PC_ABI_AIO_XFER_MAX
7104 {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX
},
7106 #ifdef _PC_ABI_ASYNC_IO
7107 {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO
},
7110 {"PC_ASYNC_IO", _PC_ASYNC_IO
},
7112 #ifdef _PC_CHOWN_RESTRICTED
7113 {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED
},
7115 #ifdef _PC_FILESIZEBITS
7116 {"PC_FILESIZEBITS", _PC_FILESIZEBITS
},
7119 {"PC_LAST", _PC_LAST
},
7122 {"PC_LINK_MAX", _PC_LINK_MAX
},
7124 #ifdef _PC_MAX_CANON
7125 {"PC_MAX_CANON", _PC_MAX_CANON
},
7127 #ifdef _PC_MAX_INPUT
7128 {"PC_MAX_INPUT", _PC_MAX_INPUT
},
7131 {"PC_NAME_MAX", _PC_NAME_MAX
},
7134 {"PC_NO_TRUNC", _PC_NO_TRUNC
},
7137 {"PC_PATH_MAX", _PC_PATH_MAX
},
7140 {"PC_PIPE_BUF", _PC_PIPE_BUF
},
7143 {"PC_PRIO_IO", _PC_PRIO_IO
},
7145 #ifdef _PC_SOCK_MAXBUF
7146 {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF
},
7149 {"PC_SYNC_IO", _PC_SYNC_IO
},
7152 {"PC_VDISABLE", _PC_VDISABLE
},
7157 conv_path_confname(PyObject
*arg
, int *valuep
)
7159 return conv_confname(arg
, valuep
, posix_constants_pathconf
,
7160 sizeof(posix_constants_pathconf
)
7161 / sizeof(struct constdef
));
7165 #ifdef HAVE_FPATHCONF
7166 PyDoc_STRVAR(posix_fpathconf__doc__
,
7167 "fpathconf(fd, name) -> integer\n\n\
7168 Return the configuration limit name for the file descriptor fd.\n\
7169 If there is no limit, return -1.");
7172 posix_fpathconf(PyObject
*self
, PyObject
*args
)
7174 PyObject
*result
= NULL
;
7177 if (PyArg_ParseTuple(args
, "iO&:fpathconf", &fd
,
7178 conv_path_confname
, &name
)) {
7182 limit
= fpathconf(fd
, name
);
7183 if (limit
== -1 && errno
!= 0)
7186 result
= PyInt_FromLong(limit
);
7193 #ifdef HAVE_PATHCONF
7194 PyDoc_STRVAR(posix_pathconf__doc__
,
7195 "pathconf(path, name) -> integer\n\n\
7196 Return the configuration limit name for the file or directory path.\n\
7197 If there is no limit, return -1.");
7200 posix_pathconf(PyObject
*self
, PyObject
*args
)
7202 PyObject
*result
= NULL
;
7206 if (PyArg_ParseTuple(args
, "sO&:pathconf", &path
,
7207 conv_path_confname
, &name
)) {
7211 limit
= pathconf(path
, name
);
7212 if (limit
== -1 && errno
!= 0) {
7213 if (errno
== EINVAL
)
7214 /* could be a path or name problem */
7217 posix_error_with_filename(path
);
7220 result
= PyInt_FromLong(limit
);
7227 static struct constdef posix_constants_confstr
[] = {
7228 #ifdef _CS_ARCHITECTURE
7229 {"CS_ARCHITECTURE", _CS_ARCHITECTURE
},
7232 {"CS_HOSTNAME", _CS_HOSTNAME
},
7234 #ifdef _CS_HW_PROVIDER
7235 {"CS_HW_PROVIDER", _CS_HW_PROVIDER
},
7237 #ifdef _CS_HW_SERIAL
7238 {"CS_HW_SERIAL", _CS_HW_SERIAL
},
7240 #ifdef _CS_INITTAB_NAME
7241 {"CS_INITTAB_NAME", _CS_INITTAB_NAME
},
7243 #ifdef _CS_LFS64_CFLAGS
7244 {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS
},
7246 #ifdef _CS_LFS64_LDFLAGS
7247 {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS
},
7249 #ifdef _CS_LFS64_LIBS
7250 {"CS_LFS64_LIBS", _CS_LFS64_LIBS
},
7252 #ifdef _CS_LFS64_LINTFLAGS
7253 {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS
},
7255 #ifdef _CS_LFS_CFLAGS
7256 {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS
},
7258 #ifdef _CS_LFS_LDFLAGS
7259 {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS
},
7262 {"CS_LFS_LIBS", _CS_LFS_LIBS
},
7264 #ifdef _CS_LFS_LINTFLAGS
7265 {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS
},
7268 {"CS_MACHINE", _CS_MACHINE
},
7271 {"CS_PATH", _CS_PATH
},
7274 {"CS_RELEASE", _CS_RELEASE
},
7276 #ifdef _CS_SRPC_DOMAIN
7277 {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN
},
7280 {"CS_SYSNAME", _CS_SYSNAME
},
7283 {"CS_VERSION", _CS_VERSION
},
7285 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
7286 {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS
},
7288 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
7289 {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS
},
7291 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
7292 {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS
},
7294 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
7295 {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS
},
7297 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
7298 {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS
},
7300 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
7301 {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS
},
7303 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
7304 {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS
},
7306 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
7307 {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
},
7309 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
7310 {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS
},
7312 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
7313 {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS
},
7315 #ifdef _CS_XBS5_LP64_OFF64_LIBS
7316 {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS
},
7318 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
7319 {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS
},
7321 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
7322 {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS
},
7324 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
7325 {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
},
7327 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
7328 {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS
},
7330 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
7331 {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
},
7333 #ifdef _MIPS_CS_AVAIL_PROCESSORS
7334 {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS
},
7336 #ifdef _MIPS_CS_BASE
7337 {"MIPS_CS_BASE", _MIPS_CS_BASE
},
7339 #ifdef _MIPS_CS_HOSTID
7340 {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID
},
7342 #ifdef _MIPS_CS_HW_NAME
7343 {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME
},
7345 #ifdef _MIPS_CS_NUM_PROCESSORS
7346 {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS
},
7348 #ifdef _MIPS_CS_OSREL_MAJ
7349 {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ
},
7351 #ifdef _MIPS_CS_OSREL_MIN
7352 {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN
},
7354 #ifdef _MIPS_CS_OSREL_PATCH
7355 {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH
},
7357 #ifdef _MIPS_CS_OS_NAME
7358 {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME
},
7360 #ifdef _MIPS_CS_OS_PROVIDER
7361 {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER
},
7363 #ifdef _MIPS_CS_PROCESSORS
7364 {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS
},
7366 #ifdef _MIPS_CS_SERIAL
7367 {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL
},
7369 #ifdef _MIPS_CS_VENDOR
7370 {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR
},
7375 conv_confstr_confname(PyObject
*arg
, int *valuep
)
7377 return conv_confname(arg
, valuep
, posix_constants_confstr
,
7378 sizeof(posix_constants_confstr
)
7379 / sizeof(struct constdef
));
7382 PyDoc_STRVAR(posix_confstr__doc__
,
7383 "confstr(name) -> string\n\n\
7384 Return a string-valued system configuration variable.");
7387 posix_confstr(PyObject
*self
, PyObject
*args
)
7389 PyObject
*result
= NULL
;
7393 if (PyArg_ParseTuple(args
, "O&:confstr", conv_confstr_confname
, &name
)) {
7397 len
= confstr(name
, buffer
, sizeof(buffer
));
7408 if ((unsigned int)len
>= sizeof(buffer
)) {
7409 result
= PyString_FromStringAndSize(NULL
, len
-1);
7411 confstr(name
, PyString_AS_STRING(result
), len
);
7414 result
= PyString_FromStringAndSize(buffer
, len
-1);
7423 static struct constdef posix_constants_sysconf
[] = {
7424 #ifdef _SC_2_CHAR_TERM
7425 {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM
},
7428 {"SC_2_C_BIND", _SC_2_C_BIND
},
7431 {"SC_2_C_DEV", _SC_2_C_DEV
},
7433 #ifdef _SC_2_C_VERSION
7434 {"SC_2_C_VERSION", _SC_2_C_VERSION
},
7436 #ifdef _SC_2_FORT_DEV
7437 {"SC_2_FORT_DEV", _SC_2_FORT_DEV
},
7439 #ifdef _SC_2_FORT_RUN
7440 {"SC_2_FORT_RUN", _SC_2_FORT_RUN
},
7442 #ifdef _SC_2_LOCALEDEF
7443 {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF
},
7446 {"SC_2_SW_DEV", _SC_2_SW_DEV
},
7449 {"SC_2_UPE", _SC_2_UPE
},
7451 #ifdef _SC_2_VERSION
7452 {"SC_2_VERSION", _SC_2_VERSION
},
7454 #ifdef _SC_ABI_ASYNCHRONOUS_IO
7455 {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO
},
7458 {"SC_ACL", _SC_ACL
},
7460 #ifdef _SC_AIO_LISTIO_MAX
7461 {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX
},
7464 {"SC_AIO_MAX", _SC_AIO_MAX
},
7466 #ifdef _SC_AIO_PRIO_DELTA_MAX
7467 {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX
},
7470 {"SC_ARG_MAX", _SC_ARG_MAX
},
7472 #ifdef _SC_ASYNCHRONOUS_IO
7473 {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO
},
7475 #ifdef _SC_ATEXIT_MAX
7476 {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX
},
7479 {"SC_AUDIT", _SC_AUDIT
},
7481 #ifdef _SC_AVPHYS_PAGES
7482 {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES
},
7484 #ifdef _SC_BC_BASE_MAX
7485 {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX
},
7487 #ifdef _SC_BC_DIM_MAX
7488 {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX
},
7490 #ifdef _SC_BC_SCALE_MAX
7491 {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX
},
7493 #ifdef _SC_BC_STRING_MAX
7494 {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX
},
7497 {"SC_CAP", _SC_CAP
},
7499 #ifdef _SC_CHARCLASS_NAME_MAX
7500 {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX
},
7503 {"SC_CHAR_BIT", _SC_CHAR_BIT
},
7506 {"SC_CHAR_MAX", _SC_CHAR_MAX
},
7509 {"SC_CHAR_MIN", _SC_CHAR_MIN
},
7511 #ifdef _SC_CHILD_MAX
7512 {"SC_CHILD_MAX", _SC_CHILD_MAX
},
7515 {"SC_CLK_TCK", _SC_CLK_TCK
},
7517 #ifdef _SC_COHER_BLKSZ
7518 {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ
},
7520 #ifdef _SC_COLL_WEIGHTS_MAX
7521 {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX
},
7523 #ifdef _SC_DCACHE_ASSOC
7524 {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC
},
7526 #ifdef _SC_DCACHE_BLKSZ
7527 {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ
},
7529 #ifdef _SC_DCACHE_LINESZ
7530 {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ
},
7532 #ifdef _SC_DCACHE_SZ
7533 {"SC_DCACHE_SZ", _SC_DCACHE_SZ
},
7535 #ifdef _SC_DCACHE_TBLKSZ
7536 {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ
},
7538 #ifdef _SC_DELAYTIMER_MAX
7539 {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX
},
7541 #ifdef _SC_EQUIV_CLASS_MAX
7542 {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX
},
7544 #ifdef _SC_EXPR_NEST_MAX
7545 {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX
},
7548 {"SC_FSYNC", _SC_FSYNC
},
7550 #ifdef _SC_GETGR_R_SIZE_MAX
7551 {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX
},
7553 #ifdef _SC_GETPW_R_SIZE_MAX
7554 {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX
},
7556 #ifdef _SC_ICACHE_ASSOC
7557 {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC
},
7559 #ifdef _SC_ICACHE_BLKSZ
7560 {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ
},
7562 #ifdef _SC_ICACHE_LINESZ
7563 {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ
},
7565 #ifdef _SC_ICACHE_SZ
7566 {"SC_ICACHE_SZ", _SC_ICACHE_SZ
},
7569 {"SC_INF", _SC_INF
},
7572 {"SC_INT_MAX", _SC_INT_MAX
},
7575 {"SC_INT_MIN", _SC_INT_MIN
},
7578 {"SC_IOV_MAX", _SC_IOV_MAX
},
7580 #ifdef _SC_IP_SECOPTS
7581 {"SC_IP_SECOPTS", _SC_IP_SECOPTS
},
7583 #ifdef _SC_JOB_CONTROL
7584 {"SC_JOB_CONTROL", _SC_JOB_CONTROL
},
7586 #ifdef _SC_KERN_POINTERS
7587 {"SC_KERN_POINTERS", _SC_KERN_POINTERS
},
7590 {"SC_KERN_SIM", _SC_KERN_SIM
},
7593 {"SC_LINE_MAX", _SC_LINE_MAX
},
7595 #ifdef _SC_LOGIN_NAME_MAX
7596 {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX
},
7598 #ifdef _SC_LOGNAME_MAX
7599 {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX
},
7602 {"SC_LONG_BIT", _SC_LONG_BIT
},
7605 {"SC_MAC", _SC_MAC
},
7607 #ifdef _SC_MAPPED_FILES
7608 {"SC_MAPPED_FILES", _SC_MAPPED_FILES
},
7611 {"SC_MAXPID", _SC_MAXPID
},
7613 #ifdef _SC_MB_LEN_MAX
7614 {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX
},
7617 {"SC_MEMLOCK", _SC_MEMLOCK
},
7619 #ifdef _SC_MEMLOCK_RANGE
7620 {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE
},
7622 #ifdef _SC_MEMORY_PROTECTION
7623 {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION
},
7625 #ifdef _SC_MESSAGE_PASSING
7626 {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING
},
7628 #ifdef _SC_MMAP_FIXED_ALIGNMENT
7629 {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT
},
7631 #ifdef _SC_MQ_OPEN_MAX
7632 {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX
},
7634 #ifdef _SC_MQ_PRIO_MAX
7635 {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX
},
7637 #ifdef _SC_NACLS_MAX
7638 {"SC_NACLS_MAX", _SC_NACLS_MAX
},
7640 #ifdef _SC_NGROUPS_MAX
7641 {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX
},
7643 #ifdef _SC_NL_ARGMAX
7644 {"SC_NL_ARGMAX", _SC_NL_ARGMAX
},
7646 #ifdef _SC_NL_LANGMAX
7647 {"SC_NL_LANGMAX", _SC_NL_LANGMAX
},
7649 #ifdef _SC_NL_MSGMAX
7650 {"SC_NL_MSGMAX", _SC_NL_MSGMAX
},
7653 {"SC_NL_NMAX", _SC_NL_NMAX
},
7655 #ifdef _SC_NL_SETMAX
7656 {"SC_NL_SETMAX", _SC_NL_SETMAX
},
7658 #ifdef _SC_NL_TEXTMAX
7659 {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX
},
7661 #ifdef _SC_NPROCESSORS_CONF
7662 {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF
},
7664 #ifdef _SC_NPROCESSORS_ONLN
7665 {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN
},
7667 #ifdef _SC_NPROC_CONF
7668 {"SC_NPROC_CONF", _SC_NPROC_CONF
},
7670 #ifdef _SC_NPROC_ONLN
7671 {"SC_NPROC_ONLN", _SC_NPROC_ONLN
},
7674 {"SC_NZERO", _SC_NZERO
},
7677 {"SC_OPEN_MAX", _SC_OPEN_MAX
},
7680 {"SC_PAGESIZE", _SC_PAGESIZE
},
7682 #ifdef _SC_PAGE_SIZE
7683 {"SC_PAGE_SIZE", _SC_PAGE_SIZE
},
7686 {"SC_PASS_MAX", _SC_PASS_MAX
},
7688 #ifdef _SC_PHYS_PAGES
7689 {"SC_PHYS_PAGES", _SC_PHYS_PAGES
},
7692 {"SC_PII", _SC_PII
},
7694 #ifdef _SC_PII_INTERNET
7695 {"SC_PII_INTERNET", _SC_PII_INTERNET
},
7697 #ifdef _SC_PII_INTERNET_DGRAM
7698 {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM
},
7700 #ifdef _SC_PII_INTERNET_STREAM
7701 {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM
},
7704 {"SC_PII_OSI", _SC_PII_OSI
},
7706 #ifdef _SC_PII_OSI_CLTS
7707 {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS
},
7709 #ifdef _SC_PII_OSI_COTS
7710 {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS
},
7712 #ifdef _SC_PII_OSI_M
7713 {"SC_PII_OSI_M", _SC_PII_OSI_M
},
7715 #ifdef _SC_PII_SOCKET
7716 {"SC_PII_SOCKET", _SC_PII_SOCKET
},
7719 {"SC_PII_XTI", _SC_PII_XTI
},
7722 {"SC_POLL", _SC_POLL
},
7724 #ifdef _SC_PRIORITIZED_IO
7725 {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO
},
7727 #ifdef _SC_PRIORITY_SCHEDULING
7728 {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING
},
7730 #ifdef _SC_REALTIME_SIGNALS
7731 {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS
},
7733 #ifdef _SC_RE_DUP_MAX
7734 {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX
},
7736 #ifdef _SC_RTSIG_MAX
7737 {"SC_RTSIG_MAX", _SC_RTSIG_MAX
},
7739 #ifdef _SC_SAVED_IDS
7740 {"SC_SAVED_IDS", _SC_SAVED_IDS
},
7742 #ifdef _SC_SCHAR_MAX
7743 {"SC_SCHAR_MAX", _SC_SCHAR_MAX
},
7745 #ifdef _SC_SCHAR_MIN
7746 {"SC_SCHAR_MIN", _SC_SCHAR_MIN
},
7749 {"SC_SELECT", _SC_SELECT
},
7751 #ifdef _SC_SEMAPHORES
7752 {"SC_SEMAPHORES", _SC_SEMAPHORES
},
7754 #ifdef _SC_SEM_NSEMS_MAX
7755 {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX
},
7757 #ifdef _SC_SEM_VALUE_MAX
7758 {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX
},
7760 #ifdef _SC_SHARED_MEMORY_OBJECTS
7761 {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS
},
7764 {"SC_SHRT_MAX", _SC_SHRT_MAX
},
7767 {"SC_SHRT_MIN", _SC_SHRT_MIN
},
7769 #ifdef _SC_SIGQUEUE_MAX
7770 {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX
},
7772 #ifdef _SC_SIGRT_MAX
7773 {"SC_SIGRT_MAX", _SC_SIGRT_MAX
},
7775 #ifdef _SC_SIGRT_MIN
7776 {"SC_SIGRT_MIN", _SC_SIGRT_MIN
},
7778 #ifdef _SC_SOFTPOWER
7779 {"SC_SOFTPOWER", _SC_SOFTPOWER
},
7781 #ifdef _SC_SPLIT_CACHE
7782 {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE
},
7784 #ifdef _SC_SSIZE_MAX
7785 {"SC_SSIZE_MAX", _SC_SSIZE_MAX
},
7787 #ifdef _SC_STACK_PROT
7788 {"SC_STACK_PROT", _SC_STACK_PROT
},
7790 #ifdef _SC_STREAM_MAX
7791 {"SC_STREAM_MAX", _SC_STREAM_MAX
},
7793 #ifdef _SC_SYNCHRONIZED_IO
7794 {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO
},
7797 {"SC_THREADS", _SC_THREADS
},
7799 #ifdef _SC_THREAD_ATTR_STACKADDR
7800 {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR
},
7802 #ifdef _SC_THREAD_ATTR_STACKSIZE
7803 {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE
},
7805 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
7806 {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS
},
7808 #ifdef _SC_THREAD_KEYS_MAX
7809 {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX
},
7811 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
7812 {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING
},
7814 #ifdef _SC_THREAD_PRIO_INHERIT
7815 {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT
},
7817 #ifdef _SC_THREAD_PRIO_PROTECT
7818 {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT
},
7820 #ifdef _SC_THREAD_PROCESS_SHARED
7821 {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED
},
7823 #ifdef _SC_THREAD_SAFE_FUNCTIONS
7824 {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS
},
7826 #ifdef _SC_THREAD_STACK_MIN
7827 {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN
},
7829 #ifdef _SC_THREAD_THREADS_MAX
7830 {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX
},
7833 {"SC_TIMERS", _SC_TIMERS
},
7835 #ifdef _SC_TIMER_MAX
7836 {"SC_TIMER_MAX", _SC_TIMER_MAX
},
7838 #ifdef _SC_TTY_NAME_MAX
7839 {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX
},
7841 #ifdef _SC_TZNAME_MAX
7842 {"SC_TZNAME_MAX", _SC_TZNAME_MAX
},
7844 #ifdef _SC_T_IOV_MAX
7845 {"SC_T_IOV_MAX", _SC_T_IOV_MAX
},
7847 #ifdef _SC_UCHAR_MAX
7848 {"SC_UCHAR_MAX", _SC_UCHAR_MAX
},
7851 {"SC_UINT_MAX", _SC_UINT_MAX
},
7853 #ifdef _SC_UIO_MAXIOV
7854 {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV
},
7856 #ifdef _SC_ULONG_MAX
7857 {"SC_ULONG_MAX", _SC_ULONG_MAX
},
7859 #ifdef _SC_USHRT_MAX
7860 {"SC_USHRT_MAX", _SC_USHRT_MAX
},
7863 {"SC_VERSION", _SC_VERSION
},
7866 {"SC_WORD_BIT", _SC_WORD_BIT
},
7868 #ifdef _SC_XBS5_ILP32_OFF32
7869 {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32
},
7871 #ifdef _SC_XBS5_ILP32_OFFBIG
7872 {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG
},
7874 #ifdef _SC_XBS5_LP64_OFF64
7875 {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64
},
7877 #ifdef _SC_XBS5_LPBIG_OFFBIG
7878 {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG
},
7880 #ifdef _SC_XOPEN_CRYPT
7881 {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT
},
7883 #ifdef _SC_XOPEN_ENH_I18N
7884 {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N
},
7886 #ifdef _SC_XOPEN_LEGACY
7887 {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY
},
7889 #ifdef _SC_XOPEN_REALTIME
7890 {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME
},
7892 #ifdef _SC_XOPEN_REALTIME_THREADS
7893 {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS
},
7895 #ifdef _SC_XOPEN_SHM
7896 {"SC_XOPEN_SHM", _SC_XOPEN_SHM
},
7898 #ifdef _SC_XOPEN_UNIX
7899 {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX
},
7901 #ifdef _SC_XOPEN_VERSION
7902 {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION
},
7904 #ifdef _SC_XOPEN_XCU_VERSION
7905 {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION
},
7907 #ifdef _SC_XOPEN_XPG2
7908 {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2
},
7910 #ifdef _SC_XOPEN_XPG3
7911 {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3
},
7913 #ifdef _SC_XOPEN_XPG4
7914 {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4
},
7919 conv_sysconf_confname(PyObject
*arg
, int *valuep
)
7921 return conv_confname(arg
, valuep
, posix_constants_sysconf
,
7922 sizeof(posix_constants_sysconf
)
7923 / sizeof(struct constdef
));
7926 PyDoc_STRVAR(posix_sysconf__doc__
,
7927 "sysconf(name) -> integer\n\n\
7928 Return an integer-valued system configuration variable.");
7931 posix_sysconf(PyObject
*self
, PyObject
*args
)
7933 PyObject
*result
= NULL
;
7936 if (PyArg_ParseTuple(args
, "O&:sysconf", conv_sysconf_confname
, &name
)) {
7940 value
= sysconf(name
);
7941 if (value
== -1 && errno
!= 0)
7944 result
= PyInt_FromLong(value
);
7951 /* This code is used to ensure that the tables of configuration value names
7952 * are in sorted order as required by conv_confname(), and also to build the
7953 * the exported dictionaries that are used to publish information about the
7954 * names available on the host platform.
7956 * Sorting the table at runtime ensures that the table is properly ordered
7957 * when used, even for platforms we're not able to test on. It also makes
7958 * it easier to add additional entries to the tables.
7962 cmp_constdefs(const void *v1
, const void *v2
)
7964 const struct constdef
*c1
=
7965 (const struct constdef
*) v1
;
7966 const struct constdef
*c2
=
7967 (const struct constdef
*) v2
;
7969 return strcmp(c1
->name
, c2
->name
);
7973 setup_confname_table(struct constdef
*table
, size_t tablesize
,
7974 char *tablename
, PyObject
*module
)
7979 qsort(table
, tablesize
, sizeof(struct constdef
), cmp_constdefs
);
7984 for (i
=0; i
< tablesize
; ++i
) {
7985 PyObject
*o
= PyInt_FromLong(table
[i
].value
);
7986 if (o
== NULL
|| PyDict_SetItemString(d
, table
[i
].name
, o
) == -1) {
7993 return PyModule_AddObject(module
, tablename
, d
);
7996 /* Return -1 on failure, 0 on success. */
7998 setup_confname_tables(PyObject
*module
)
8000 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
8001 if (setup_confname_table(posix_constants_pathconf
,
8002 sizeof(posix_constants_pathconf
)
8003 / sizeof(struct constdef
),
8004 "pathconf_names", module
))
8008 if (setup_confname_table(posix_constants_confstr
,
8009 sizeof(posix_constants_confstr
)
8010 / sizeof(struct constdef
),
8011 "confstr_names", module
))
8015 if (setup_confname_table(posix_constants_sysconf
,
8016 sizeof(posix_constants_sysconf
)
8017 / sizeof(struct constdef
),
8018 "sysconf_names", module
))
8025 PyDoc_STRVAR(posix_abort__doc__
,
8026 "abort() -> does not return!\n\n\
8027 Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\
8028 in the hardest way possible on the hosting operating system.");
8031 posix_abort(PyObject
*self
, PyObject
*noargs
)
8035 Py_FatalError("abort() called from Python code didn't abort!");
8040 PyDoc_STRVAR(win32_startfile__doc__
,
8041 "startfile(filepath [, operation]) - Start a file with its associated\n\
8044 When \"operation\" is not specified or \"open\", this acts like\n\
8045 double-clicking the file in Explorer, or giving the file name as an\n\
8046 argument to the DOS \"start\" command: the file is opened with whatever\n\
8047 application (if any) its extension is associated.\n\
8048 When another \"operation\" is given, it specifies what should be done with\n\
8049 the file. A typical operation is \"print\".\n\
8051 startfile returns as soon as the associated application is launched.\n\
8052 There is no option to wait for the application to close, and no way\n\
8053 to retrieve the application's exit status.\n\
8055 The filepath is relative to the current directory. If you want to use\n\
8056 an absolute path, make sure the first character is not a slash (\"/\");\n\
8057 the underlying Win32 ShellExecute function doesn't work if it is.");
8060 win32_startfile(PyObject
*self
, PyObject
*args
)
8063 char *operation
= NULL
;
8065 #ifdef Py_WIN_WIDE_FILENAMES
8066 if (unicode_file_names()) {
8067 PyObject
*unipath
, *woperation
= NULL
;
8068 if (!PyArg_ParseTuple(args
, "U|s:startfile",
8069 &unipath
, &operation
)) {
8076 woperation
= PyUnicode_DecodeASCII(operation
,
8077 strlen(operation
), NULL
);
8085 Py_BEGIN_ALLOW_THREADS
8086 rc
= ShellExecuteW((HWND
)0, woperation
? PyUnicode_AS_UNICODE(woperation
) : 0,
8087 PyUnicode_AS_UNICODE(unipath
),
8088 NULL
, NULL
, SW_SHOWNORMAL
);
8089 Py_END_ALLOW_THREADS
8091 Py_XDECREF(woperation
);
8092 if (rc
<= (HINSTANCE
)32) {
8093 PyObject
*errval
= win32_error_unicode("startfile",
8094 PyUnicode_AS_UNICODE(unipath
));
8103 if (!PyArg_ParseTuple(args
, "et|s:startfile",
8104 Py_FileSystemDefaultEncoding
, &filepath
,
8107 Py_BEGIN_ALLOW_THREADS
8108 rc
= ShellExecute((HWND
)0, operation
, filepath
,
8109 NULL
, NULL
, SW_SHOWNORMAL
);
8110 Py_END_ALLOW_THREADS
8111 if (rc
<= (HINSTANCE
)32) {
8112 PyObject
*errval
= win32_error("startfile", filepath
);
8113 PyMem_Free(filepath
);
8116 PyMem_Free(filepath
);
8122 #ifdef HAVE_GETLOADAVG
8123 PyDoc_STRVAR(posix_getloadavg__doc__
,
8124 "getloadavg() -> (float, float, float)\n\n\
8125 Return the number of processes in the system run queue averaged over\n\
8126 the last 1, 5, and 15 minutes or raises OSError if the load average\n\
8130 posix_getloadavg(PyObject
*self
, PyObject
*noargs
)
8133 if (getloadavg(loadavg
, 3)!=3) {
8134 PyErr_SetString(PyExc_OSError
, "Load averages are unobtainable");
8137 return Py_BuildValue("ddd", loadavg
[0], loadavg
[1], loadavg
[2]);
8143 PyDoc_STRVAR(win32_urandom__doc__
,
8144 "urandom(n) -> str\n\n\
8145 Return a string of n random bytes suitable for cryptographic use.");
8147 typedef BOOL (WINAPI
*CRYPTACQUIRECONTEXTA
)(HCRYPTPROV
*phProv
,\
8148 LPCSTR pszContainer
, LPCSTR pszProvider
, DWORD dwProvType
,\
8150 typedef BOOL (WINAPI
*CRYPTGENRANDOM
)(HCRYPTPROV hProv
, DWORD dwLen
,\
8153 static CRYPTGENRANDOM pCryptGenRandom
= NULL
;
8154 /* This handle is never explicitly released. Instead, the operating
8155 system will release it when the process terminates. */
8156 static HCRYPTPROV hCryptProv
= 0;
8159 win32_urandom(PyObject
*self
, PyObject
*args
)
8164 /* Read arguments */
8165 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8168 return PyErr_Format(PyExc_ValueError
,
8169 "negative argument not allowed");
8171 if (hCryptProv
== 0) {
8172 HINSTANCE hAdvAPI32
= NULL
;
8173 CRYPTACQUIRECONTEXTA pCryptAcquireContext
= NULL
;
8175 /* Obtain handle to the DLL containing CryptoAPI
8176 This should not fail */
8177 hAdvAPI32
= GetModuleHandle("advapi32.dll");
8178 if(hAdvAPI32
== NULL
)
8179 return win32_error("GetModuleHandle", NULL
);
8181 /* Obtain pointers to the CryptoAPI functions
8182 This will fail on some early versions of Win95 */
8183 pCryptAcquireContext
= (CRYPTACQUIRECONTEXTA
)GetProcAddress(
8185 "CryptAcquireContextA");
8186 if (pCryptAcquireContext
== NULL
)
8187 return PyErr_Format(PyExc_NotImplementedError
,
8188 "CryptAcquireContextA not found");
8190 pCryptGenRandom
= (CRYPTGENRANDOM
)GetProcAddress(
8191 hAdvAPI32
, "CryptGenRandom");
8192 if (pCryptGenRandom
== NULL
)
8193 return PyErr_Format(PyExc_NotImplementedError
,
8194 "CryptGenRandom not found");
8196 /* Acquire context */
8197 if (! pCryptAcquireContext(&hCryptProv
, NULL
, NULL
,
8198 PROV_RSA_FULL
, CRYPT_VERIFYCONTEXT
))
8199 return win32_error("CryptAcquireContext", NULL
);
8202 /* Allocate bytes */
8203 result
= PyString_FromStringAndSize(NULL
, howMany
);
8204 if (result
!= NULL
) {
8205 /* Get random data */
8206 if (! pCryptGenRandom(hCryptProv
, howMany
, (unsigned char*)
8207 PyString_AS_STRING(result
))) {
8209 return win32_error("CryptGenRandom", NULL
);
8217 /* Use openssl random routine */
8218 #include <openssl/rand.h>
8219 PyDoc_STRVAR(vms_urandom__doc__
,
8220 "urandom(n) -> str\n\n\
8221 Return a string of n random bytes suitable for cryptographic use.");
8224 vms_urandom(PyObject
*self
, PyObject
*args
)
8229 /* Read arguments */
8230 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8233 return PyErr_Format(PyExc_ValueError
,
8234 "negative argument not allowed");
8236 /* Allocate bytes */
8237 result
= PyString_FromStringAndSize(NULL
, howMany
);
8238 if (result
!= NULL
) {
8239 /* Get random data */
8240 if (RAND_pseudo_bytes((unsigned char*)
8241 PyString_AS_STRING(result
),
8244 return PyErr_Format(PyExc_ValueError
,
8245 "RAND_pseudo_bytes");
8252 static PyMethodDef posix_methods
[] = {
8253 {"access", posix_access
, METH_VARARGS
, posix_access__doc__
},
8255 {"ttyname", posix_ttyname
, METH_VARARGS
, posix_ttyname__doc__
},
8257 {"chdir", posix_chdir
, METH_VARARGS
, posix_chdir__doc__
},
8259 {"chflags", posix_chflags
, METH_VARARGS
, posix_chflags__doc__
},
8260 #endif /* HAVE_CHFLAGS */
8261 {"chmod", posix_chmod
, METH_VARARGS
, posix_chmod__doc__
},
8263 {"fchmod", posix_fchmod
, METH_VARARGS
, posix_fchmod__doc__
},
8264 #endif /* HAVE_FCHMOD */
8266 {"chown", posix_chown
, METH_VARARGS
, posix_chown__doc__
},
8267 #endif /* HAVE_CHOWN */
8269 {"lchmod", posix_lchmod
, METH_VARARGS
, posix_lchmod__doc__
},
8270 #endif /* HAVE_LCHMOD */
8272 {"fchown", posix_fchown
, METH_VARARGS
, posix_fchown__doc__
},
8273 #endif /* HAVE_FCHOWN */
8274 #ifdef HAVE_LCHFLAGS
8275 {"lchflags", posix_lchflags
, METH_VARARGS
, posix_lchflags__doc__
},
8276 #endif /* HAVE_LCHFLAGS */
8278 {"lchown", posix_lchown
, METH_VARARGS
, posix_lchown__doc__
},
8279 #endif /* HAVE_LCHOWN */
8281 {"chroot", posix_chroot
, METH_VARARGS
, posix_chroot__doc__
},
8284 {"ctermid", posix_ctermid
, METH_NOARGS
, posix_ctermid__doc__
},
8287 {"getcwd", posix_getcwd
, METH_NOARGS
, posix_getcwd__doc__
},
8288 #ifdef Py_USING_UNICODE
8289 {"getcwdu", posix_getcwdu
, METH_NOARGS
, posix_getcwdu__doc__
},
8293 {"link", posix_link
, METH_VARARGS
, posix_link__doc__
},
8294 #endif /* HAVE_LINK */
8295 {"listdir", posix_listdir
, METH_VARARGS
, posix_listdir__doc__
},
8296 {"lstat", posix_lstat
, METH_VARARGS
, posix_lstat__doc__
},
8297 {"mkdir", posix_mkdir
, METH_VARARGS
, posix_mkdir__doc__
},
8299 {"nice", posix_nice
, METH_VARARGS
, posix_nice__doc__
},
8300 #endif /* HAVE_NICE */
8301 #ifdef HAVE_READLINK
8302 {"readlink", posix_readlink
, METH_VARARGS
, posix_readlink__doc__
},
8303 #endif /* HAVE_READLINK */
8304 {"rename", posix_rename
, METH_VARARGS
, posix_rename__doc__
},
8305 {"rmdir", posix_rmdir
, METH_VARARGS
, posix_rmdir__doc__
},
8306 {"stat", posix_stat
, METH_VARARGS
, posix_stat__doc__
},
8307 {"stat_float_times", stat_float_times
, METH_VARARGS
, stat_float_times__doc__
},
8309 {"symlink", posix_symlink
, METH_VARARGS
, posix_symlink__doc__
},
8310 #endif /* HAVE_SYMLINK */
8312 {"system", posix_system
, METH_VARARGS
, posix_system__doc__
},
8314 {"umask", posix_umask
, METH_VARARGS
, posix_umask__doc__
},
8316 {"uname", posix_uname
, METH_NOARGS
, posix_uname__doc__
},
8317 #endif /* HAVE_UNAME */
8318 {"unlink", posix_unlink
, METH_VARARGS
, posix_unlink__doc__
},
8319 {"remove", posix_unlink
, METH_VARARGS
, posix_remove__doc__
},
8320 {"utime", posix_utime
, METH_VARARGS
, posix_utime__doc__
},
8322 {"times", posix_times
, METH_NOARGS
, posix_times__doc__
},
8323 #endif /* HAVE_TIMES */
8324 {"_exit", posix__exit
, METH_VARARGS
, posix__exit__doc__
},
8326 {"execv", posix_execv
, METH_VARARGS
, posix_execv__doc__
},
8327 {"execve", posix_execve
, METH_VARARGS
, posix_execve__doc__
},
8328 #endif /* HAVE_EXECV */
8330 {"spawnv", posix_spawnv
, METH_VARARGS
, posix_spawnv__doc__
},
8331 {"spawnve", posix_spawnve
, METH_VARARGS
, posix_spawnve__doc__
},
8332 #if defined(PYOS_OS2)
8333 {"spawnvp", posix_spawnvp
, METH_VARARGS
, posix_spawnvp__doc__
},
8334 {"spawnvpe", posix_spawnvpe
, METH_VARARGS
, posix_spawnvpe__doc__
},
8335 #endif /* PYOS_OS2 */
8336 #endif /* HAVE_SPAWNV */
8338 {"fork1", posix_fork1
, METH_NOARGS
, posix_fork1__doc__
},
8339 #endif /* HAVE_FORK1 */
8341 {"fork", posix_fork
, METH_NOARGS
, posix_fork__doc__
},
8342 #endif /* HAVE_FORK */
8343 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
8344 {"openpty", posix_openpty
, METH_NOARGS
, posix_openpty__doc__
},
8345 #endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */
8347 {"forkpty", posix_forkpty
, METH_NOARGS
, posix_forkpty__doc__
},
8348 #endif /* HAVE_FORKPTY */
8350 {"getegid", posix_getegid
, METH_NOARGS
, posix_getegid__doc__
},
8351 #endif /* HAVE_GETEGID */
8353 {"geteuid", posix_geteuid
, METH_NOARGS
, posix_geteuid__doc__
},
8354 #endif /* HAVE_GETEUID */
8356 {"getgid", posix_getgid
, METH_NOARGS
, posix_getgid__doc__
},
8357 #endif /* HAVE_GETGID */
8358 #ifdef HAVE_GETGROUPS
8359 {"getgroups", posix_getgroups
, METH_NOARGS
, posix_getgroups__doc__
},
8361 {"getpid", posix_getpid
, METH_NOARGS
, posix_getpid__doc__
},
8363 {"getpgrp", posix_getpgrp
, METH_NOARGS
, posix_getpgrp__doc__
},
8364 #endif /* HAVE_GETPGRP */
8366 {"getppid", posix_getppid
, METH_NOARGS
, posix_getppid__doc__
},
8367 #endif /* HAVE_GETPPID */
8369 {"getuid", posix_getuid
, METH_NOARGS
, posix_getuid__doc__
},
8370 #endif /* HAVE_GETUID */
8371 #ifdef HAVE_GETLOGIN
8372 {"getlogin", posix_getlogin
, METH_NOARGS
, posix_getlogin__doc__
},
8375 {"kill", posix_kill
, METH_VARARGS
, posix_kill__doc__
},
8376 #endif /* HAVE_KILL */
8378 {"killpg", posix_killpg
, METH_VARARGS
, posix_killpg__doc__
},
8379 #endif /* HAVE_KILLPG */
8381 {"plock", posix_plock
, METH_VARARGS
, posix_plock__doc__
},
8382 #endif /* HAVE_PLOCK */
8384 {"popen", posix_popen
, METH_VARARGS
, posix_popen__doc__
},
8386 {"popen2", win32_popen2
, METH_VARARGS
},
8387 {"popen3", win32_popen3
, METH_VARARGS
},
8388 {"popen4", win32_popen4
, METH_VARARGS
},
8389 {"startfile", win32_startfile
, METH_VARARGS
, win32_startfile__doc__
},
8391 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8392 {"popen2", os2emx_popen2
, METH_VARARGS
},
8393 {"popen3", os2emx_popen3
, METH_VARARGS
},
8394 {"popen4", os2emx_popen4
, METH_VARARGS
},
8397 #endif /* HAVE_POPEN */
8399 {"setuid", posix_setuid
, METH_VARARGS
, posix_setuid__doc__
},
8400 #endif /* HAVE_SETUID */
8402 {"seteuid", posix_seteuid
, METH_VARARGS
, posix_seteuid__doc__
},
8403 #endif /* HAVE_SETEUID */
8405 {"setegid", posix_setegid
, METH_VARARGS
, posix_setegid__doc__
},
8406 #endif /* HAVE_SETEGID */
8407 #ifdef HAVE_SETREUID
8408 {"setreuid", posix_setreuid
, METH_VARARGS
, posix_setreuid__doc__
},
8409 #endif /* HAVE_SETREUID */
8410 #ifdef HAVE_SETREGID
8411 {"setregid", posix_setregid
, METH_VARARGS
, posix_setregid__doc__
},
8412 #endif /* HAVE_SETREGID */
8414 {"setgid", posix_setgid
, METH_VARARGS
, posix_setgid__doc__
},
8415 #endif /* HAVE_SETGID */
8416 #ifdef HAVE_SETGROUPS
8417 {"setgroups", posix_setgroups
, METH_O
, posix_setgroups__doc__
},
8418 #endif /* HAVE_SETGROUPS */
8420 {"getpgid", posix_getpgid
, METH_VARARGS
, posix_getpgid__doc__
},
8421 #endif /* HAVE_GETPGID */
8423 {"setpgrp", posix_setpgrp
, METH_NOARGS
, posix_setpgrp__doc__
},
8424 #endif /* HAVE_SETPGRP */
8426 {"wait", posix_wait
, METH_NOARGS
, posix_wait__doc__
},
8427 #endif /* HAVE_WAIT */
8429 {"wait3", posix_wait3
, METH_VARARGS
, posix_wait3__doc__
},
8430 #endif /* HAVE_WAIT3 */
8432 {"wait4", posix_wait4
, METH_VARARGS
, posix_wait4__doc__
},
8433 #endif /* HAVE_WAIT4 */
8434 #if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)
8435 {"waitpid", posix_waitpid
, METH_VARARGS
, posix_waitpid__doc__
},
8436 #endif /* HAVE_WAITPID */
8438 {"getsid", posix_getsid
, METH_VARARGS
, posix_getsid__doc__
},
8439 #endif /* HAVE_GETSID */
8441 {"setsid", posix_setsid
, METH_NOARGS
, posix_setsid__doc__
},
8442 #endif /* HAVE_SETSID */
8444 {"setpgid", posix_setpgid
, METH_VARARGS
, posix_setpgid__doc__
},
8445 #endif /* HAVE_SETPGID */
8446 #ifdef HAVE_TCGETPGRP
8447 {"tcgetpgrp", posix_tcgetpgrp
, METH_VARARGS
, posix_tcgetpgrp__doc__
},
8448 #endif /* HAVE_TCGETPGRP */
8449 #ifdef HAVE_TCSETPGRP
8450 {"tcsetpgrp", posix_tcsetpgrp
, METH_VARARGS
, posix_tcsetpgrp__doc__
},
8451 #endif /* HAVE_TCSETPGRP */
8452 {"open", posix_open
, METH_VARARGS
, posix_open__doc__
},
8453 {"close", posix_close
, METH_VARARGS
, posix_close__doc__
},
8454 {"dup", posix_dup
, METH_VARARGS
, posix_dup__doc__
},
8455 {"dup2", posix_dup2
, METH_VARARGS
, posix_dup2__doc__
},
8456 {"lseek", posix_lseek
, METH_VARARGS
, posix_lseek__doc__
},
8457 {"read", posix_read
, METH_VARARGS
, posix_read__doc__
},
8458 {"write", posix_write
, METH_VARARGS
, posix_write__doc__
},
8459 {"fstat", posix_fstat
, METH_VARARGS
, posix_fstat__doc__
},
8460 {"fdopen", posix_fdopen
, METH_VARARGS
, posix_fdopen__doc__
},
8461 {"isatty", posix_isatty
, METH_VARARGS
, posix_isatty__doc__
},
8463 {"pipe", posix_pipe
, METH_NOARGS
, posix_pipe__doc__
},
8466 {"mkfifo", posix_mkfifo
, METH_VARARGS
, posix_mkfifo__doc__
},
8468 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
8469 {"mknod", posix_mknod
, METH_VARARGS
, posix_mknod__doc__
},
8471 #ifdef HAVE_DEVICE_MACROS
8472 {"major", posix_major
, METH_VARARGS
, posix_major__doc__
},
8473 {"minor", posix_minor
, METH_VARARGS
, posix_minor__doc__
},
8474 {"makedev", posix_makedev
, METH_VARARGS
, posix_makedev__doc__
},
8476 #ifdef HAVE_FTRUNCATE
8477 {"ftruncate", posix_ftruncate
, METH_VARARGS
, posix_ftruncate__doc__
},
8480 {"putenv", posix_putenv
, METH_VARARGS
, posix_putenv__doc__
},
8482 #ifdef HAVE_UNSETENV
8483 {"unsetenv", posix_unsetenv
, METH_VARARGS
, posix_unsetenv__doc__
},
8485 #ifdef HAVE_STRERROR
8486 {"strerror", posix_strerror
, METH_VARARGS
, posix_strerror__doc__
},
8489 {"fchdir", posix_fchdir
, METH_O
, posix_fchdir__doc__
},
8492 {"fsync", posix_fsync
, METH_O
, posix_fsync__doc__
},
8494 #ifdef HAVE_FDATASYNC
8495 {"fdatasync", posix_fdatasync
, METH_O
, posix_fdatasync__doc__
},
8497 #ifdef HAVE_SYS_WAIT_H
8499 {"WCOREDUMP", posix_WCOREDUMP
, METH_VARARGS
, posix_WCOREDUMP__doc__
},
8500 #endif /* WCOREDUMP */
8502 {"WIFCONTINUED",posix_WIFCONTINUED
, METH_VARARGS
, posix_WIFCONTINUED__doc__
},
8503 #endif /* WIFCONTINUED */
8505 {"WIFSTOPPED", posix_WIFSTOPPED
, METH_VARARGS
, posix_WIFSTOPPED__doc__
},
8506 #endif /* WIFSTOPPED */
8508 {"WIFSIGNALED", posix_WIFSIGNALED
, METH_VARARGS
, posix_WIFSIGNALED__doc__
},
8509 #endif /* WIFSIGNALED */
8511 {"WIFEXITED", posix_WIFEXITED
, METH_VARARGS
, posix_WIFEXITED__doc__
},
8512 #endif /* WIFEXITED */
8514 {"WEXITSTATUS", posix_WEXITSTATUS
, METH_VARARGS
, posix_WEXITSTATUS__doc__
},
8515 #endif /* WEXITSTATUS */
8517 {"WTERMSIG", posix_WTERMSIG
, METH_VARARGS
, posix_WTERMSIG__doc__
},
8518 #endif /* WTERMSIG */
8520 {"WSTOPSIG", posix_WSTOPSIG
, METH_VARARGS
, posix_WSTOPSIG__doc__
},
8521 #endif /* WSTOPSIG */
8522 #endif /* HAVE_SYS_WAIT_H */
8523 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
8524 {"fstatvfs", posix_fstatvfs
, METH_VARARGS
, posix_fstatvfs__doc__
},
8526 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
8527 {"statvfs", posix_statvfs
, METH_VARARGS
, posix_statvfs__doc__
},
8530 {"tmpfile", posix_tmpfile
, METH_NOARGS
, posix_tmpfile__doc__
},
8533 {"tempnam", posix_tempnam
, METH_VARARGS
, posix_tempnam__doc__
},
8536 {"tmpnam", posix_tmpnam
, METH_NOARGS
, posix_tmpnam__doc__
},
8539 {"confstr", posix_confstr
, METH_VARARGS
, posix_confstr__doc__
},
8542 {"sysconf", posix_sysconf
, METH_VARARGS
, posix_sysconf__doc__
},
8544 #ifdef HAVE_FPATHCONF
8545 {"fpathconf", posix_fpathconf
, METH_VARARGS
, posix_fpathconf__doc__
},
8547 #ifdef HAVE_PATHCONF
8548 {"pathconf", posix_pathconf
, METH_VARARGS
, posix_pathconf__doc__
},
8550 {"abort", posix_abort
, METH_NOARGS
, posix_abort__doc__
},
8552 {"_getfullpathname", posix__getfullpathname
, METH_VARARGS
, NULL
},
8554 #ifdef HAVE_GETLOADAVG
8555 {"getloadavg", posix_getloadavg
, METH_NOARGS
, posix_getloadavg__doc__
},
8558 {"urandom", win32_urandom
, METH_VARARGS
, win32_urandom__doc__
},
8561 {"urandom", vms_urandom
, METH_VARARGS
, vms_urandom__doc__
},
8563 {NULL
, NULL
} /* Sentinel */
8568 ins(PyObject
*module
, char *symbol
, long value
)
8570 return PyModule_AddIntConstant(module
, symbol
, value
);
8573 #if defined(PYOS_OS2)
8574 /* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */
8575 static int insertvalues(PyObject
*module
)
8578 ULONG values
[QSV_MAX
+1];
8582 Py_BEGIN_ALLOW_THREADS
8583 rc
= DosQuerySysInfo(1L, QSV_MAX
, &values
[1], sizeof(ULONG
) * QSV_MAX
);
8584 Py_END_ALLOW_THREADS
8586 if (rc
!= NO_ERROR
) {
8591 if (ins(module
, "meminstalled", values
[QSV_TOTPHYSMEM
])) return -1;
8592 if (ins(module
, "memkernel", values
[QSV_TOTRESMEM
])) return -1;
8593 if (ins(module
, "memvirtual", values
[QSV_TOTAVAILMEM
])) return -1;
8594 if (ins(module
, "maxpathlen", values
[QSV_MAX_PATH_LENGTH
])) return -1;
8595 if (ins(module
, "maxnamelen", values
[QSV_MAX_COMP_LENGTH
])) return -1;
8596 if (ins(module
, "revision", values
[QSV_VERSION_REVISION
])) return -1;
8597 if (ins(module
, "timeslice", values
[QSV_MIN_SLICE
])) return -1;
8599 switch (values
[QSV_VERSION_MINOR
]) {
8600 case 0: ver
= "2.00"; break;
8601 case 10: ver
= "2.10"; break;
8602 case 11: ver
= "2.11"; break;
8603 case 30: ver
= "3.00"; break;
8604 case 40: ver
= "4.00"; break;
8605 case 50: ver
= "5.00"; break;
8607 PyOS_snprintf(tmp
, sizeof(tmp
),
8608 "%d-%d", values
[QSV_VERSION_MAJOR
],
8609 values
[QSV_VERSION_MINOR
]);
8613 /* Add Indicator of the Version of the Operating System */
8614 if (PyModule_AddStringConstant(module
, "version", tmp
) < 0)
8617 /* Add Indicator of Which Drive was Used to Boot the System */
8618 tmp
[0] = 'A' + values
[QSV_BOOT_DRIVE
] - 1;
8622 return PyModule_AddStringConstant(module
, "bootdrive", tmp
);
8627 all_ins(PyObject
*d
)
8630 if (ins(d
, "F_OK", (long)F_OK
)) return -1;
8633 if (ins(d
, "R_OK", (long)R_OK
)) return -1;
8636 if (ins(d
, "W_OK", (long)W_OK
)) return -1;
8639 if (ins(d
, "X_OK", (long)X_OK
)) return -1;
8642 if (ins(d
, "NGROUPS_MAX", (long)NGROUPS_MAX
)) return -1;
8645 if (ins(d
, "TMP_MAX", (long)TMP_MAX
)) return -1;
8648 if (ins(d
, "WCONTINUED", (long)WCONTINUED
)) return -1;
8651 if (ins(d
, "WNOHANG", (long)WNOHANG
)) return -1;
8654 if (ins(d
, "WUNTRACED", (long)WUNTRACED
)) return -1;
8657 if (ins(d
, "O_RDONLY", (long)O_RDONLY
)) return -1;
8660 if (ins(d
, "O_WRONLY", (long)O_WRONLY
)) return -1;
8663 if (ins(d
, "O_RDWR", (long)O_RDWR
)) return -1;
8666 if (ins(d
, "O_NDELAY", (long)O_NDELAY
)) return -1;
8669 if (ins(d
, "O_NONBLOCK", (long)O_NONBLOCK
)) return -1;
8672 if (ins(d
, "O_APPEND", (long)O_APPEND
)) return -1;
8675 if (ins(d
, "O_DSYNC", (long)O_DSYNC
)) return -1;
8678 if (ins(d
, "O_RSYNC", (long)O_RSYNC
)) return -1;
8681 if (ins(d
, "O_SYNC", (long)O_SYNC
)) return -1;
8684 if (ins(d
, "O_NOCTTY", (long)O_NOCTTY
)) return -1;
8687 if (ins(d
, "O_CREAT", (long)O_CREAT
)) return -1;
8690 if (ins(d
, "O_EXCL", (long)O_EXCL
)) return -1;
8693 if (ins(d
, "O_TRUNC", (long)O_TRUNC
)) return -1;
8696 if (ins(d
, "O_BINARY", (long)O_BINARY
)) return -1;
8699 if (ins(d
, "O_TEXT", (long)O_TEXT
)) return -1;
8702 if (ins(d
, "O_LARGEFILE", (long)O_LARGEFILE
)) return -1;
8705 if (ins(d
, "O_SHLOCK", (long)O_SHLOCK
)) return -1;
8708 if (ins(d
, "O_EXLOCK", (long)O_EXLOCK
)) return -1;
8713 /* Don't inherit in child processes. */
8714 if (ins(d
, "O_NOINHERIT", (long)O_NOINHERIT
)) return -1;
8716 #ifdef _O_SHORT_LIVED
8717 /* Optimize for short life (keep in memory). */
8718 /* MS forgot to define this one with a non-underscore form too. */
8719 if (ins(d
, "O_SHORT_LIVED", (long)_O_SHORT_LIVED
)) return -1;
8722 /* Automatically delete when last handle is closed. */
8723 if (ins(d
, "O_TEMPORARY", (long)O_TEMPORARY
)) return -1;
8726 /* Optimize for random access. */
8727 if (ins(d
, "O_RANDOM", (long)O_RANDOM
)) return -1;
8730 /* Optimize for sequential access. */
8731 if (ins(d
, "O_SEQUENTIAL", (long)O_SEQUENTIAL
)) return -1;
8734 /* GNU extensions. */
8736 /* Direct disk access. */
8737 if (ins(d
, "O_DIRECT", (long)O_DIRECT
)) return -1;
8740 /* Must be a directory. */
8741 if (ins(d
, "O_DIRECTORY", (long)O_DIRECTORY
)) return -1;
8744 /* Do not follow links. */
8745 if (ins(d
, "O_NOFOLLOW", (long)O_NOFOLLOW
)) return -1;
8748 /* Do not update the access time. */
8749 if (ins(d
, "O_NOATIME", (long)O_NOATIME
)) return -1;
8752 /* These come from sysexits.h */
8754 if (ins(d
, "EX_OK", (long)EX_OK
)) return -1;
8757 if (ins(d
, "EX_USAGE", (long)EX_USAGE
)) return -1;
8758 #endif /* EX_USAGE */
8760 if (ins(d
, "EX_DATAERR", (long)EX_DATAERR
)) return -1;
8761 #endif /* EX_DATAERR */
8763 if (ins(d
, "EX_NOINPUT", (long)EX_NOINPUT
)) return -1;
8764 #endif /* EX_NOINPUT */
8766 if (ins(d
, "EX_NOUSER", (long)EX_NOUSER
)) return -1;
8767 #endif /* EX_NOUSER */
8769 if (ins(d
, "EX_NOHOST", (long)EX_NOHOST
)) return -1;
8770 #endif /* EX_NOHOST */
8771 #ifdef EX_UNAVAILABLE
8772 if (ins(d
, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE
)) return -1;
8773 #endif /* EX_UNAVAILABLE */
8775 if (ins(d
, "EX_SOFTWARE", (long)EX_SOFTWARE
)) return -1;
8776 #endif /* EX_SOFTWARE */
8778 if (ins(d
, "EX_OSERR", (long)EX_OSERR
)) return -1;
8779 #endif /* EX_OSERR */
8781 if (ins(d
, "EX_OSFILE", (long)EX_OSFILE
)) return -1;
8782 #endif /* EX_OSFILE */
8784 if (ins(d
, "EX_CANTCREAT", (long)EX_CANTCREAT
)) return -1;
8785 #endif /* EX_CANTCREAT */
8787 if (ins(d
, "EX_IOERR", (long)EX_IOERR
)) return -1;
8788 #endif /* EX_IOERR */
8790 if (ins(d
, "EX_TEMPFAIL", (long)EX_TEMPFAIL
)) return -1;
8791 #endif /* EX_TEMPFAIL */
8793 if (ins(d
, "EX_PROTOCOL", (long)EX_PROTOCOL
)) return -1;
8794 #endif /* EX_PROTOCOL */
8796 if (ins(d
, "EX_NOPERM", (long)EX_NOPERM
)) return -1;
8797 #endif /* EX_NOPERM */
8799 if (ins(d
, "EX_CONFIG", (long)EX_CONFIG
)) return -1;
8800 #endif /* EX_CONFIG */
8802 if (ins(d
, "EX_NOTFOUND", (long)EX_NOTFOUND
)) return -1;
8803 #endif /* EX_NOTFOUND */
8806 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8807 if (ins(d
, "P_WAIT", (long)P_WAIT
)) return -1;
8808 if (ins(d
, "P_NOWAIT", (long)P_NOWAIT
)) return -1;
8809 if (ins(d
, "P_OVERLAY", (long)P_OVERLAY
)) return -1;
8810 if (ins(d
, "P_DEBUG", (long)P_DEBUG
)) return -1;
8811 if (ins(d
, "P_SESSION", (long)P_SESSION
)) return -1;
8812 if (ins(d
, "P_DETACH", (long)P_DETACH
)) return -1;
8813 if (ins(d
, "P_PM", (long)P_PM
)) return -1;
8814 if (ins(d
, "P_DEFAULT", (long)P_DEFAULT
)) return -1;
8815 if (ins(d
, "P_MINIMIZE", (long)P_MINIMIZE
)) return -1;
8816 if (ins(d
, "P_MAXIMIZE", (long)P_MAXIMIZE
)) return -1;
8817 if (ins(d
, "P_FULLSCREEN", (long)P_FULLSCREEN
)) return -1;
8818 if (ins(d
, "P_WINDOWED", (long)P_WINDOWED
)) return -1;
8819 if (ins(d
, "P_FOREGROUND", (long)P_FOREGROUND
)) return -1;
8820 if (ins(d
, "P_BACKGROUND", (long)P_BACKGROUND
)) return -1;
8821 if (ins(d
, "P_NOCLOSE", (long)P_NOCLOSE
)) return -1;
8822 if (ins(d
, "P_NOSESSION", (long)P_NOSESSION
)) return -1;
8823 if (ins(d
, "P_QUOTE", (long)P_QUOTE
)) return -1;
8824 if (ins(d
, "P_TILDE", (long)P_TILDE
)) return -1;
8825 if (ins(d
, "P_UNRELATED", (long)P_UNRELATED
)) return -1;
8826 if (ins(d
, "P_DEBUGDESC", (long)P_DEBUGDESC
)) return -1;
8828 if (ins(d
, "P_WAIT", (long)_P_WAIT
)) return -1;
8829 if (ins(d
, "P_NOWAIT", (long)_P_NOWAIT
)) return -1;
8830 if (ins(d
, "P_OVERLAY", (long)_OLD_P_OVERLAY
)) return -1;
8831 if (ins(d
, "P_NOWAITO", (long)_P_NOWAITO
)) return -1;
8832 if (ins(d
, "P_DETACH", (long)_P_DETACH
)) return -1;
8836 #if defined(PYOS_OS2)
8837 if (insertvalues(d
)) return -1;
8843 #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)) && !defined(__QNX__)
8844 #define INITFUNC initnt
8845 #define MODNAME "nt"
8847 #elif defined(PYOS_OS2)
8848 #define INITFUNC initos2
8849 #define MODNAME "os2"
8852 #define INITFUNC initposix
8853 #define MODNAME "posix"
8861 m
= Py_InitModule3(MODNAME
,
8867 /* Initialize environ dictionary */
8868 v
= convertenviron();
8870 if (v
== NULL
|| PyModule_AddObject(m
, "environ", v
) != 0)
8877 if (setup_confname_tables(m
))
8880 Py_INCREF(PyExc_OSError
);
8881 PyModule_AddObject(m
, "error", PyExc_OSError
);
8884 if (posix_putenv_garbage
== NULL
)
8885 posix_putenv_garbage
= PyDict_New();
8889 stat_result_desc
.name
= MODNAME
".stat_result";
8890 stat_result_desc
.fields
[7].name
= PyStructSequence_UnnamedField
;
8891 stat_result_desc
.fields
[8].name
= PyStructSequence_UnnamedField
;
8892 stat_result_desc
.fields
[9].name
= PyStructSequence_UnnamedField
;
8893 PyStructSequence_InitType(&StatResultType
, &stat_result_desc
);
8894 structseq_new
= StatResultType
.tp_new
;
8895 StatResultType
.tp_new
= statresult_new
;
8897 statvfs_result_desc
.name
= MODNAME
".statvfs_result";
8898 PyStructSequence_InitType(&StatVFSResultType
, &statvfs_result_desc
);
8900 Py_INCREF((PyObject
*) &StatResultType
);
8901 PyModule_AddObject(m
, "stat_result", (PyObject
*) &StatResultType
);
8902 Py_INCREF((PyObject
*) &StatVFSResultType
);
8903 PyModule_AddObject(m
, "statvfs_result",
8904 (PyObject
*) &StatVFSResultType
);
8909 * Step 2 of weak-linking support on Mac OS X.
8911 * The code below removes functions that are not available on the
8912 * currently active platform.
8914 * This block allow one to use a python binary that was build on
8915 * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
8918 #ifdef HAVE_FSTATVFS
8919 if (fstatvfs
== NULL
) {
8920 if (PyObject_DelAttrString(m
, "fstatvfs") == -1) {
8924 #endif /* HAVE_FSTATVFS */
8927 if (statvfs
== NULL
) {
8928 if (PyObject_DelAttrString(m
, "statvfs") == -1) {
8932 #endif /* HAVE_STATVFS */
8935 if (lchown
== NULL
) {
8936 if (PyObject_DelAttrString(m
, "lchown") == -1) {
8940 #endif /* HAVE_LCHOWN */
8943 #endif /* __APPLE__ */