2 /* POSIX module implementation */
4 /* This file is also used for Windows NT/MS-Win and OS/2. In that case the
5 module actually calls itself 'nt' or 'os2', not 'posix', and a few
6 functions are either unimplemented or implemented differently. The source
7 assumes that for Windows NT, the macro 'MS_WINDOWS' is defined independent
8 of the compiler used. Different compilers define their own feature
9 test macro, e.g. '__BORLANDC__' or '_MSC_VER'. For OS/2, the compiler
10 independent macro PYOS_OS2 should be defined. On OS/2 the default
11 compiler is assumed to be IBM's VisualAge C++ (VACPP). PYCC_GCC is used
12 as the compiler specific macro for the EMX port of gcc to OS/2. */
14 /* See also ../Dos/dosmodule.c */
18 * Step 1 of support for weak-linking a number of symbols existing on
19 * OSX 10.4 and later, see the comment in the #ifdef __APPLE__ block
20 * at the end of this file for more information.
24 # pragma weak fstatvfs
26 #endif /* __APPLE__ */
28 #define PY_SSIZE_T_CLEAN
31 #include "structseq.h"
35 #endif /* defined(__VMS) */
41 PyDoc_STRVAR(posix__doc__
,
42 "This module provides access to operating system functionality that is\n\
43 standardized by the C Standard and the POSIX standard (a thinly\n\
44 disguised Unix interface). Refer to the library manual and\n\
45 corresponding Unix manual entries for more information on calls.");
47 #ifndef Py_USING_UNICODE
48 /* This is used in signatures of functions. */
49 #define Py_UNICODE void
54 #define INCL_DOSERRORS
55 #define INCL_DOSPROCESS
67 #ifdef HAVE_SYS_TYPES_H
68 #include <sys/types.h>
69 #endif /* HAVE_SYS_TYPES_H */
71 #ifdef HAVE_SYS_STAT_H
73 #endif /* HAVE_SYS_STAT_H */
75 #ifdef HAVE_SYS_WAIT_H
76 #include <sys/wait.h> /* For WNOHANG */
85 #endif /* HAVE_FCNTL_H */
91 #ifdef HAVE_SYSEXITS_H
93 #endif /* HAVE_SYSEXITS_H */
95 #ifdef HAVE_SYS_LOADAVG_H
96 #include <sys/loadavg.h>
99 /* Various compilers have only certain posix functions */
100 /* XXX Gosh I wish these were all moved into pyconfig.h */
101 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
104 #if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */
105 #define HAVE_GETCWD 1
106 #define HAVE_OPENDIR 1
107 #define HAVE_SYSTEM 1
114 #ifdef __BORLANDC__ /* Borland compiler */
116 #define HAVE_GETCWD 1
117 #define HAVE_OPENDIR 1
120 #define HAVE_SYSTEM 1
123 #ifdef _MSC_VER /* Microsoft compiler */
124 #define HAVE_GETCWD 1
125 #define HAVE_SPAWNV 1
129 #define HAVE_SYSTEM 1
132 #define fsync _commit
134 #if defined(PYOS_OS2) && defined(PYCC_GCC) || defined(__VMS)
135 /* Everything needed is defined in PC/os2emx/pyconfig.h or vms/pyconfig.h */
136 #else /* all other compilers */
137 /* Unix functions that the configure script doesn't check for */
140 #if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */
143 #define HAVE_GETCWD 1
144 #define HAVE_GETEGID 1
145 #define HAVE_GETEUID 1
146 #define HAVE_GETGID 1
147 #define HAVE_GETPPID 1
148 #define HAVE_GETUID 1
150 #define HAVE_OPENDIR 1
155 #define HAVE_SYSTEM 1
157 #define HAVE_TTYNAME 1
158 #endif /* PYOS_OS2 && PYCC_GCC && __VMS */
159 #endif /* _MSC_VER */
160 #endif /* __BORLANDC__ */
161 #endif /* ! __WATCOMC__ || __QNX__ */
162 #endif /* ! __IBMC__ */
166 #if defined(__sgi)&&_COMPILER_VERSION>=700
167 /* declare ctermid_r if compiling with MIPSPro 7.x in ANSI C mode
169 extern char *ctermid_r(char *);
172 #ifndef HAVE_UNISTD_H
173 #if defined(PYCC_VACPP)
174 extern int mkdir(char *);
176 #if ( defined(__WATCOMC__) || defined(_MSC_VER) ) && !defined(__QNX__)
177 extern int mkdir(const char *);
179 extern int mkdir(const char *, mode_t
);
182 #if defined(__IBMC__) || defined(__IBMCPP__)
183 extern int chdir(char *);
184 extern int rmdir(char *);
186 extern int chdir(const char *);
187 extern int rmdir(const char *);
190 extern int chmod(const char *, int);
192 extern int chmod(const char *, mode_t
);
195 extern int fchmod(int, mode_t);
198 extern int lchmod(const char *, mode_t);
200 extern int chown(const char *, uid_t
, gid_t
);
201 extern char *getcwd(char *, int);
202 extern char *strerror(int);
203 extern int link(const char *, const char *);
204 extern int rename(const char *, const char *);
205 extern int stat(const char *, struct stat
*);
206 extern int unlink(const char *);
207 extern int pclose(FILE *);
209 extern int symlink(const char *, const char *);
210 #endif /* HAVE_SYMLINK */
212 extern int lstat(const char *, struct stat
*);
213 #endif /* HAVE_LSTAT */
214 #endif /* !HAVE_UNISTD_H */
216 #endif /* !_MSC_VER */
220 #endif /* HAVE_UTIME_H */
222 #ifdef HAVE_SYS_UTIME_H
223 #include <sys/utime.h>
224 #define HAVE_UTIME_H /* pretend we do for the rest of this file */
225 #endif /* HAVE_SYS_UTIME_H */
227 #ifdef HAVE_SYS_TIMES_H
228 #include <sys/times.h>
229 #endif /* HAVE_SYS_TIMES_H */
231 #ifdef HAVE_SYS_PARAM_H
232 #include <sys/param.h>
233 #endif /* HAVE_SYS_PARAM_H */
235 #ifdef HAVE_SYS_UTSNAME_H
236 #include <sys/utsname.h>
237 #endif /* HAVE_SYS_UTSNAME_H */
241 #define NAMLEN(dirent) strlen((dirent)->d_name)
243 #if defined(__WATCOMC__) && !defined(__QNX__)
245 #define NAMLEN(dirent) strlen((dirent)->d_name)
247 #define dirent direct
248 #define NAMLEN(dirent) (dirent)->d_namlen
250 #ifdef HAVE_SYS_NDIR_H
251 #include <sys/ndir.h>
253 #ifdef HAVE_SYS_DIR_H
268 #ifdef HAVE_PROCESS_H
273 #include <shellapi.h> /* for ShellExecute() */
275 #define pclose _pclose
276 #endif /* _MSC_VER */
278 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
283 #if defined(PATH_MAX) && PATH_MAX > 1024
284 #define MAXPATHLEN PATH_MAX
286 #define MAXPATHLEN 1024
288 #endif /* MAXPATHLEN */
291 /* Emulate some macros on systems that have a union instead of macros */
294 #define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump)
298 #define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1)
302 #define WTERMSIG(u_wait) ((u_wait).w_termsig)
305 #define WAIT_TYPE union wait
306 #define WAIT_STATUS_INT(s) (s.w_status)
308 #else /* !UNION_WAIT */
309 #define WAIT_TYPE int
310 #define WAIT_STATUS_INT(s) (s)
311 #endif /* UNION_WAIT */
313 /* Don't use the "_r" form if we don't need it (also, won't have a
314 prototype for it, at least on Solaris -- maybe others as well?). */
315 #if defined(HAVE_CTERMID_R) && defined(WITH_THREAD)
316 #define USE_CTERMID_R
319 #if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD)
323 /* choose the appropriate stat and fstat functions and return structs */
325 #if defined(MS_WIN64) || defined(MS_WINDOWS)
326 # define STAT win32_stat
327 # define FSTAT win32_fstat
328 # define STRUCT_STAT struct win32_stat
332 # define STRUCT_STAT struct stat
335 #if defined(MAJOR_IN_MKDEV)
336 #include <sys/mkdev.h>
338 #if defined(MAJOR_IN_SYSMACROS)
339 #include <sys/sysmacros.h>
341 #if defined(HAVE_MKNOD) && defined(HAVE_SYS_MKDEV_H)
342 #include <sys/mkdev.h>
346 /* Return a dictionary corresponding to the POSIX environment table */
347 #ifdef WITH_NEXT_FRAMEWORK
348 /* On Darwin/MacOSX a shared library or framework has no access to
349 ** environ directly, we must obtain it with _NSGetEnviron().
351 #include <crt_externs.h>
352 static char **environ
;
353 #elif !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )
354 extern char **environ
;
355 #endif /* !_MSC_VER */
365 #ifdef WITH_NEXT_FRAMEWORK
367 environ
= *_NSGetEnviron();
371 /* This part ignores errors */
372 for (e
= environ
; *e
!= NULL
; e
++) {
375 char *p
= strchr(*e
, '=');
378 k
= PyString_FromStringAndSize(*e
, (int)(p
-*e
));
383 v
= PyString_FromString(p
+1);
389 if (PyDict_GetItem(d
, k
) == NULL
) {
390 if (PyDict_SetItem(d
, k
, v
) != 0)
396 #if defined(PYOS_OS2)
399 char buffer
[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */
401 rc
= DosQueryExtLIBPATH(buffer
, BEGIN_LIBPATH
);
402 if (rc
== NO_ERROR
) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
403 PyObject
*v
= PyString_FromString(buffer
);
404 PyDict_SetItemString(d
, "BEGINLIBPATH", v
);
407 rc
= DosQueryExtLIBPATH(buffer
, END_LIBPATH
);
408 if (rc
== NO_ERROR
) { /* (not a typo, envname is NOT 'END_LIBPATH') */
409 PyObject
*v
= PyString_FromString(buffer
);
410 PyDict_SetItemString(d
, "ENDLIBPATH", v
);
419 /* Set a POSIX-specific error from errno, and return NULL */
424 return PyErr_SetFromErrno(PyExc_OSError
);
427 posix_error_with_filename(char* name
)
429 return PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
432 #ifdef Py_WIN_WIDE_FILENAMES
434 posix_error_with_unicode_filename(Py_UNICODE
* name
)
436 return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError
, name
);
438 #endif /* Py_WIN_WIDE_FILENAMES */
442 posix_error_with_allocated_filename(char* name
)
444 PyObject
*rc
= PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
451 win32_error(char* function
, char* filename
)
453 /* XXX We should pass the function name along in the future.
454 (_winreg.c also wants to pass the function name.)
455 This would however require an additional param to the
456 Windows error object, which is non-trivial.
458 errno
= GetLastError();
460 return PyErr_SetFromWindowsErrWithFilename(errno
, filename
);
462 return PyErr_SetFromWindowsErr(errno
);
465 #ifdef Py_WIN_WIDE_FILENAMES
467 win32_error_unicode(char* function
, Py_UNICODE
* filename
)
469 /* XXX - see win32_error for comments on 'function' */
470 errno
= GetLastError();
472 return PyErr_SetFromWindowsErrWithUnicodeFilename(errno
, filename
);
474 return PyErr_SetFromWindowsErr(errno
);
477 static PyObject
*_PyUnicode_FromFileSystemEncodedObject(register PyObject
*obj
)
481 /* Function suitable for O& conversion */
483 convert_to_unicode(PyObject
*arg
, void* _param
)
485 PyObject
**param
= (PyObject
**)_param
;
486 if (PyUnicode_CheckExact(arg
)) {
490 else if (PyUnicode_Check(arg
)) {
491 /* For a Unicode subtype that's not a Unicode object,
492 return a true Unicode object with the same data. */
493 *param
= PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(arg
),
494 PyUnicode_GET_SIZE(arg
));
495 return *param
!= NULL
;
498 *param
= PyUnicode_FromEncodedObject(arg
,
499 Py_FileSystemDefaultEncoding
,
501 return (*param
) != NULL
;
504 #endif /* Py_WIN_WIDE_FILENAMES */
508 #if defined(PYOS_OS2)
509 /**********************************************************************
510 * Helper Function to Trim and Format OS/2 Messages
511 **********************************************************************/
513 os2_formatmsg(char *msgbuf
, int msglen
, char *reason
)
515 msgbuf
[msglen
] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
517 if (strlen(msgbuf
) > 0) { /* If Non-Empty Msg, Trim CRLF */
518 char *lastc
= &msgbuf
[ strlen(msgbuf
)-1 ];
520 while (lastc
> msgbuf
&& isspace(Py_CHARMASK(*lastc
)))
521 *lastc
-- = '\0'; /* Trim Trailing Whitespace (CRLF) */
524 /* Add Optional Reason Text */
526 strcat(msgbuf
, " : ");
527 strcat(msgbuf
, reason
);
531 /**********************************************************************
532 * Decode an OS/2 Operating System Error Code
534 * A convenience function to lookup an OS/2 error code and return a
535 * text message we can use to raise a Python exception.
538 * The messages for errors returned from the OS/2 kernel reside in
539 * the file OSO001.MSG in the \OS2 directory hierarchy.
541 **********************************************************************/
543 os2_strerror(char *msgbuf
, int msgbuflen
, int errorcode
, char *reason
)
548 /* Retrieve Kernel-Related Error Message from OSO001.MSG File */
549 Py_BEGIN_ALLOW_THREADS
550 rc
= DosGetMessage(NULL
, 0, msgbuf
, msgbuflen
,
551 errorcode
, "oso001.msg", &msglen
);
555 os2_formatmsg(msgbuf
, msglen
, reason
);
557 PyOS_snprintf(msgbuf
, msgbuflen
,
558 "unknown OS error #%d", errorcode
);
563 /* Set an OS/2-specific error and return NULL. OS/2 kernel
564 errors are not in a global variable e.g. 'errno' nor are
565 they congruent with posix error numbers. */
567 static PyObject
* os2_error(int code
)
572 os2_strerror(text
, sizeof(text
), code
, "");
574 v
= Py_BuildValue("(is)", code
, text
);
576 PyErr_SetObject(PyExc_OSError
, v
);
579 return NULL
; /* Signal to Python that an Exception is Pending */
584 /* POSIX generic methods */
587 posix_fildes(PyObject
*fdobj
, int (*func
)(int))
591 fd
= PyObject_AsFileDescriptor(fdobj
);
594 Py_BEGIN_ALLOW_THREADS
598 return posix_error();
603 #ifdef Py_WIN_WIDE_FILENAMES
605 unicode_file_names(void)
607 static int canusewide
= -1;
608 if (canusewide
== -1) {
609 /* As per doc for ::GetVersion(), this is the correct test for
610 the Windows NT family. */
611 canusewide
= (GetVersion() < 0x80000000) ? 1 : 0;
618 posix_1str(PyObject
*args
, char *format
, int (*func
)(const char*))
622 if (!PyArg_ParseTuple(args
, format
,
623 Py_FileSystemDefaultEncoding
, &path1
))
625 Py_BEGIN_ALLOW_THREADS
626 res
= (*func
)(path1
);
629 return posix_error_with_allocated_filename(path1
);
636 posix_2str(PyObject
*args
,
638 int (*func
)(const char *, const char *))
640 char *path1
= NULL
, *path2
= NULL
;
642 if (!PyArg_ParseTuple(args
, format
,
643 Py_FileSystemDefaultEncoding
, &path1
,
644 Py_FileSystemDefaultEncoding
, &path2
))
646 Py_BEGIN_ALLOW_THREADS
647 res
= (*func
)(path1
, path2
);
652 /* XXX how to report both path1 and path2??? */
653 return posix_error();
658 #ifdef Py_WIN_WIDE_FILENAMES
660 win32_1str(PyObject
* args
, char* func
,
661 char* format
, BOOL (__stdcall
*funcA
)(LPCSTR
),
662 char* wformat
, BOOL (__stdcall
*funcW
)(LPWSTR
))
667 if (unicode_file_names()) {
668 if (!PyArg_ParseTuple(args
, wformat
, &uni
))
671 Py_BEGIN_ALLOW_THREADS
672 result
= funcW(PyUnicode_AsUnicode(uni
));
675 return win32_error_unicode(func
, PyUnicode_AsUnicode(uni
));
680 if (!PyArg_ParseTuple(args
, format
, &ansi
))
682 Py_BEGIN_ALLOW_THREADS
683 result
= funcA(ansi
);
686 return win32_error(func
, ansi
);
692 /* This is a reimplementation of the C library's chdir function,
693 but one that produces Win32 errors instead of DOS error codes.
694 chdir is essentially a wrapper around SetCurrentDirectory; however,
695 it also needs to set "magic" environment variables indicating
696 the per-drive current directory, which are of the form =<drive>: */
698 win32_chdir(LPCSTR path
)
700 char new_path
[MAX_PATH
+1];
704 if(!SetCurrentDirectoryA(path
))
706 result
= GetCurrentDirectoryA(MAX_PATH
+1, new_path
);
709 /* In the ANSI API, there should not be any paths longer
711 assert(result
<= MAX_PATH
+1);
712 if (strncmp(new_path
, "\\\\", 2) == 0 ||
713 strncmp(new_path
, "//", 2) == 0)
714 /* UNC path, nothing to do. */
716 env
[1] = new_path
[0];
717 return SetEnvironmentVariableA(env
, new_path
);
720 /* The Unicode version differs from the ANSI version
721 since the current directory might exceed MAX_PATH characters */
723 win32_wchdir(LPCWSTR path
)
725 wchar_t _new_path
[MAX_PATH
+1], *new_path
= _new_path
;
727 wchar_t env
[4] = L
"=x:";
729 if(!SetCurrentDirectoryW(path
))
731 result
= GetCurrentDirectoryW(MAX_PATH
+1, new_path
);
734 if (result
> MAX_PATH
+1) {
735 new_path
= malloc(result
);
737 SetLastError(ERROR_OUTOFMEMORY
);
741 if (wcsncmp(new_path
, L
"\\\\", 2) == 0 ||
742 wcsncmp(new_path
, L
"//", 2) == 0)
743 /* UNC path, nothing to do. */
745 env
[1] = new_path
[0];
746 result
= SetEnvironmentVariableW(env
, new_path
);
747 if (new_path
!= _new_path
)
754 /* The CRT of Windows has a number of flaws wrt. its stat() implementation:
755 - time stamps are restricted to second resolution
756 - file modification times suffer from forth-and-back conversions between
758 Therefore, we implement our own stat, based on the Win32 API directly.
760 #define HAVE_STAT_NSEC 1
765 unsigned short st_mode
;
779 static __int64 secs_between_epochs
= 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */
782 FILE_TIME_to_time_t_nsec(FILETIME
*in_ptr
, int *time_out
, int* nsec_out
)
784 /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */
785 /* Cannot simply cast and dereference in_ptr,
786 since it might not be aligned properly */
788 memcpy(&in
, in_ptr
, sizeof(in
));
789 *nsec_out
= (int)(in
% 10000000) * 100; /* FILETIME is in units of 100 nsec. */
790 /* XXX Win32 supports time stamps past 2038; we currently don't */
791 *time_out
= Py_SAFE_DOWNCAST((in
/ 10000000) - secs_between_epochs
, __int64
, int);
795 time_t_to_FILE_TIME(int time_in
, int nsec_in
, FILETIME
*out_ptr
)
799 out
= time_in
+ secs_between_epochs
;
800 out
= out
* 10000000 + nsec_in
/ 100;
801 memcpy(out_ptr
, &out
, sizeof(out
));
804 /* Below, we *know* that ugo+r is 0444 */
806 #error Unsupported C library
809 attributes_to_mode(DWORD attr
)
812 if (attr
& FILE_ATTRIBUTE_DIRECTORY
)
813 m
|= _S_IFDIR
| 0111; /* IFEXEC for user,group,other */
816 if (attr
& FILE_ATTRIBUTE_READONLY
)
824 attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA
*info
, struct win32_stat
*result
)
826 memset(result
, 0, sizeof(*result
));
827 result
->st_mode
= attributes_to_mode(info
->dwFileAttributes
);
828 result
->st_size
= (((__int64
)info
->nFileSizeHigh
)<<32) + info
->nFileSizeLow
;
829 FILE_TIME_to_time_t_nsec(&info
->ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
830 FILE_TIME_to_time_t_nsec(&info
->ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
831 FILE_TIME_to_time_t_nsec(&info
->ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
836 /* Emulate GetFileAttributesEx[AW] on Windows 95 */
837 static int checked
= 0;
838 static BOOL (CALLBACK
*gfaxa
)(LPCSTR
, GET_FILEEX_INFO_LEVELS
, LPVOID
);
839 static BOOL (CALLBACK
*gfaxw
)(LPCWSTR
, GET_FILEEX_INFO_LEVELS
, LPVOID
);
847 hKernel32
= GetModuleHandle("KERNEL32");
848 *(FARPROC
*)&gfaxa
= GetProcAddress(hKernel32
, "GetFileAttributesExA");
849 *(FARPROC
*)&gfaxw
= GetProcAddress(hKernel32
, "GetFileAttributesExW");
853 attributes_from_dir(LPCSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
856 WIN32_FIND_DATAA FileData
;
857 hFindFile
= FindFirstFileA(pszFile
, &FileData
);
858 if (hFindFile
== INVALID_HANDLE_VALUE
)
860 FindClose(hFindFile
);
861 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
862 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
863 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
864 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
865 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
866 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
871 attributes_from_dir_w(LPCWSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
874 WIN32_FIND_DATAW FileData
;
875 hFindFile
= FindFirstFileW(pszFile
, &FileData
);
876 if (hFindFile
== INVALID_HANDLE_VALUE
)
878 FindClose(hFindFile
);
879 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
880 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
881 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
882 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
883 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
884 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
889 Py_GetFileAttributesExA(LPCSTR pszFile
,
890 GET_FILEEX_INFO_LEVELS level
,
894 LPWIN32_FILE_ATTRIBUTE_DATA pfad
= pv
;
895 /* First try to use the system's implementation, if that is
896 available and either succeeds to gives an error other than
897 that it isn't implemented. */
900 result
= gfaxa(pszFile
, level
, pv
);
901 if (result
|| GetLastError() != ERROR_CALL_NOT_IMPLEMENTED
)
904 /* It's either not present, or not implemented.
905 Emulate using FindFirstFile. */
906 if (level
!= GetFileExInfoStandard
) {
907 SetLastError(ERROR_INVALID_PARAMETER
);
910 /* Use GetFileAttributes to validate that the file name
911 does not contain wildcards (which FindFirstFile would
913 if (GetFileAttributesA(pszFile
) == 0xFFFFFFFF)
915 return attributes_from_dir(pszFile
, pfad
);
919 Py_GetFileAttributesExW(LPCWSTR pszFile
,
920 GET_FILEEX_INFO_LEVELS level
,
924 LPWIN32_FILE_ATTRIBUTE_DATA pfad
= pv
;
925 /* First try to use the system's implementation, if that is
926 available and either succeeds to gives an error other than
927 that it isn't implemented. */
930 result
= gfaxw(pszFile
, level
, pv
);
931 if (result
|| GetLastError() != ERROR_CALL_NOT_IMPLEMENTED
)
934 /* It's either not present, or not implemented.
935 Emulate using FindFirstFile. */
936 if (level
!= GetFileExInfoStandard
) {
937 SetLastError(ERROR_INVALID_PARAMETER
);
940 /* Use GetFileAttributes to validate that the file name
941 does not contain wildcards (which FindFirstFile would
943 if (GetFileAttributesW(pszFile
) == 0xFFFFFFFF)
945 return attributes_from_dir_w(pszFile
, pfad
);
949 win32_stat(const char* path
, struct win32_stat
*result
)
951 WIN32_FILE_ATTRIBUTE_DATA info
;
954 /* XXX not supported on Win95 and NT 3.x */
955 if (!Py_GetFileAttributesExA(path
, GetFileExInfoStandard
, &info
)) {
956 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
957 /* Protocol violation: we explicitly clear errno, instead of
958 setting it to a POSIX error. Callers should use GetLastError. */
962 /* Could not get attributes on open file. Fall back to
963 reading the directory. */
964 if (!attributes_from_dir(path
, &info
)) {
965 /* Very strange. This should not fail now */
971 code
= attribute_data_to_stat(&info
, result
);
974 /* Set S_IFEXEC if it is an .exe, .bat, ... */
975 dot
= strrchr(path
, '.');
977 if (stricmp(dot
, ".bat") == 0 ||
978 stricmp(dot
, ".cmd") == 0 ||
979 stricmp(dot
, ".exe") == 0 ||
980 stricmp(dot
, ".com") == 0)
981 result
->st_mode
|= 0111;
987 win32_wstat(const wchar_t* path
, struct win32_stat
*result
)
991 WIN32_FILE_ATTRIBUTE_DATA info
;
992 /* XXX not supported on Win95 and NT 3.x */
993 if (!Py_GetFileAttributesExW(path
, GetFileExInfoStandard
, &info
)) {
994 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
995 /* Protocol violation: we explicitly clear errno, instead of
996 setting it to a POSIX error. Callers should use GetLastError. */
1000 /* Could not get attributes on open file. Fall back to
1001 reading the directory. */
1002 if (!attributes_from_dir_w(path
, &info
)) {
1003 /* Very strange. This should not fail now */
1009 code
= attribute_data_to_stat(&info
, result
);
1012 /* Set IFEXEC if it is an .exe, .bat, ... */
1013 dot
= wcsrchr(path
, '.');
1015 if (_wcsicmp(dot
, L
".bat") == 0 ||
1016 _wcsicmp(dot
, L
".cmd") == 0 ||
1017 _wcsicmp(dot
, L
".exe") == 0 ||
1018 _wcsicmp(dot
, L
".com") == 0)
1019 result
->st_mode
|= 0111;
1025 win32_fstat(int file_number
, struct win32_stat
*result
)
1027 BY_HANDLE_FILE_INFORMATION info
;
1031 h
= (HANDLE
)_get_osfhandle(file_number
);
1033 /* Protocol violation: we explicitly clear errno, instead of
1034 setting it to a POSIX error. Callers should use GetLastError. */
1037 if (h
== INVALID_HANDLE_VALUE
) {
1038 /* This is really a C library error (invalid file handle).
1039 We set the Win32 error to the closes one matching. */
1040 SetLastError(ERROR_INVALID_HANDLE
);
1043 memset(result
, 0, sizeof(*result
));
1045 type
= GetFileType(h
);
1046 if (type
== FILE_TYPE_UNKNOWN
) {
1047 DWORD error
= GetLastError();
1051 /* else: valid but unknown file */
1054 if (type
!= FILE_TYPE_DISK
) {
1055 if (type
== FILE_TYPE_CHAR
)
1056 result
->st_mode
= _S_IFCHR
;
1057 else if (type
== FILE_TYPE_PIPE
)
1058 result
->st_mode
= _S_IFIFO
;
1062 if (!GetFileInformationByHandle(h
, &info
)) {
1066 /* similar to stat() */
1067 result
->st_mode
= attributes_to_mode(info
.dwFileAttributes
);
1068 result
->st_size
= (((__int64
)info
.nFileSizeHigh
)<<32) + info
.nFileSizeLow
;
1069 FILE_TIME_to_time_t_nsec(&info
.ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
1070 FILE_TIME_to_time_t_nsec(&info
.ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
1071 FILE_TIME_to_time_t_nsec(&info
.ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
1072 /* specific to fstat() */
1073 result
->st_nlink
= info
.nNumberOfLinks
;
1074 result
->st_ino
= (((__int64
)info
.nFileIndexHigh
)<<32) + info
.nFileIndexLow
;
1078 #endif /* MS_WINDOWS */
1080 PyDoc_STRVAR(stat_result__doc__
,
1081 "stat_result: Result from stat or lstat.\n\n\
1082 This object may be accessed either as a tuple of\n\
1083 (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n\
1084 or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\
1086 Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n\
1087 or st_flags, they are available as attributes only.\n\
1089 See os.stat for more information.");
1091 static PyStructSequence_Field stat_result_fields
[] = {
1092 {"st_mode", "protection bits"},
1093 {"st_ino", "inode"},
1094 {"st_dev", "device"},
1095 {"st_nlink", "number of hard links"},
1096 {"st_uid", "user ID of owner"},
1097 {"st_gid", "group ID of owner"},
1098 {"st_size", "total size, in bytes"},
1099 /* The NULL is replaced with PyStructSequence_UnnamedField later. */
1100 {NULL
, "integer time of last access"},
1101 {NULL
, "integer time of last modification"},
1102 {NULL
, "integer time of last change"},
1103 {"st_atime", "time of last access"},
1104 {"st_mtime", "time of last modification"},
1105 {"st_ctime", "time of last change"},
1106 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1107 {"st_blksize", "blocksize for filesystem I/O"},
1109 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1110 {"st_blocks", "number of blocks allocated"},
1112 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1113 {"st_rdev", "device type (if inode device)"},
1115 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1116 {"st_flags", "user defined flags for file"},
1118 #ifdef HAVE_STRUCT_STAT_ST_GEN
1119 {"st_gen", "generation number"},
1121 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1122 {"st_birthtime", "time of creation"},
1127 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1128 #define ST_BLKSIZE_IDX 13
1130 #define ST_BLKSIZE_IDX 12
1133 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1134 #define ST_BLOCKS_IDX (ST_BLKSIZE_IDX+1)
1136 #define ST_BLOCKS_IDX ST_BLKSIZE_IDX
1139 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1140 #define ST_RDEV_IDX (ST_BLOCKS_IDX+1)
1142 #define ST_RDEV_IDX ST_BLOCKS_IDX
1145 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1146 #define ST_FLAGS_IDX (ST_RDEV_IDX+1)
1148 #define ST_FLAGS_IDX ST_RDEV_IDX
1151 #ifdef HAVE_STRUCT_STAT_ST_GEN
1152 #define ST_GEN_IDX (ST_FLAGS_IDX+1)
1154 #define ST_GEN_IDX ST_FLAGS_IDX
1157 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1158 #define ST_BIRTHTIME_IDX (ST_GEN_IDX+1)
1160 #define ST_BIRTHTIME_IDX ST_GEN_IDX
1163 static PyStructSequence_Desc stat_result_desc
= {
1164 "stat_result", /* name */
1165 stat_result__doc__
, /* doc */
1170 PyDoc_STRVAR(statvfs_result__doc__
,
1171 "statvfs_result: Result from statvfs or fstatvfs.\n\n\
1172 This object may be accessed either as a tuple of\n\
1173 (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n\
1174 or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\
1176 See os.statvfs for more information.");
1178 static PyStructSequence_Field statvfs_result_fields
[] = {
1192 static PyStructSequence_Desc statvfs_result_desc
= {
1193 "statvfs_result", /* name */
1194 statvfs_result__doc__
, /* doc */
1195 statvfs_result_fields
,
1199 static int initialized
;
1200 static PyTypeObject StatResultType
;
1201 static PyTypeObject StatVFSResultType
;
1202 static newfunc structseq_new
;
1205 statresult_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1207 PyStructSequence
*result
;
1210 result
= (PyStructSequence
*)structseq_new(type
, args
, kwds
);
1213 /* If we have been initialized from a tuple,
1214 st_?time might be set to None. Initialize it
1215 from the int slots. */
1216 for (i
= 7; i
<= 9; i
++) {
1217 if (result
->ob_item
[i
+3] == Py_None
) {
1219 Py_INCREF(result
->ob_item
[i
]);
1220 result
->ob_item
[i
+3] = result
->ob_item
[i
];
1223 return (PyObject
*)result
;
1228 /* If true, st_?time is float. */
1229 static int _stat_float_times
= 1;
1231 PyDoc_STRVAR(stat_float_times__doc__
,
1232 "stat_float_times([newval]) -> oldval\n\n\
1233 Determine whether os.[lf]stat represents time stamps as float objects.\n\
1234 If newval is True, future calls to stat() return floats, if it is False,\n\
1235 future calls return ints. \n\
1236 If newval is omitted, return the current setting.\n");
1239 stat_float_times(PyObject
* self
, PyObject
*args
)
1242 if (!PyArg_ParseTuple(args
, "|i:stat_float_times", &newval
))
1245 /* Return old value */
1246 return PyBool_FromLong(_stat_float_times
);
1247 _stat_float_times
= newval
;
1253 fill_time(PyObject
*v
, int index
, time_t sec
, unsigned long nsec
)
1255 PyObject
*fval
,*ival
;
1256 #if SIZEOF_TIME_T > SIZEOF_LONG
1257 ival
= PyLong_FromLongLong((PY_LONG_LONG
)sec
);
1259 ival
= PyInt_FromLong((long)sec
);
1263 if (_stat_float_times
) {
1264 fval
= PyFloat_FromDouble(sec
+ 1e-9*nsec
);
1269 PyStructSequence_SET_ITEM(v
, index
, ival
);
1270 PyStructSequence_SET_ITEM(v
, index
+3, fval
);
1273 /* pack a system stat C structure into the Python stat tuple
1274 (used by posix_stat() and posix_fstat()) */
1276 _pystat_fromstructstat(STRUCT_STAT
*st
)
1278 unsigned long ansec
, mnsec
, cnsec
;
1279 PyObject
*v
= PyStructSequence_New(&StatResultType
);
1283 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long)st
->st_mode
));
1284 #ifdef HAVE_LARGEFILE_SUPPORT
1285 PyStructSequence_SET_ITEM(v
, 1,
1286 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_ino
));
1288 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long)st
->st_ino
));
1290 #if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
1291 PyStructSequence_SET_ITEM(v
, 2,
1292 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_dev
));
1294 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long)st
->st_dev
));
1296 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long)st
->st_nlink
));
1297 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long)st
->st_uid
));
1298 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long)st
->st_gid
));
1299 #ifdef HAVE_LARGEFILE_SUPPORT
1300 PyStructSequence_SET_ITEM(v
, 6,
1301 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_size
));
1303 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong(st
->st_size
));
1306 #if defined(HAVE_STAT_TV_NSEC)
1307 ansec
= st
->st_atim
.tv_nsec
;
1308 mnsec
= st
->st_mtim
.tv_nsec
;
1309 cnsec
= st
->st_ctim
.tv_nsec
;
1310 #elif defined(HAVE_STAT_TV_NSEC2)
1311 ansec
= st
->st_atimespec
.tv_nsec
;
1312 mnsec
= st
->st_mtimespec
.tv_nsec
;
1313 cnsec
= st
->st_ctimespec
.tv_nsec
;
1314 #elif defined(HAVE_STAT_NSEC)
1315 ansec
= st
->st_atime_nsec
;
1316 mnsec
= st
->st_mtime_nsec
;
1317 cnsec
= st
->st_ctime_nsec
;
1319 ansec
= mnsec
= cnsec
= 0;
1321 fill_time(v
, 7, st
->st_atime
, ansec
);
1322 fill_time(v
, 8, st
->st_mtime
, mnsec
);
1323 fill_time(v
, 9, st
->st_ctime
, cnsec
);
1325 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1326 PyStructSequence_SET_ITEM(v
, ST_BLKSIZE_IDX
,
1327 PyInt_FromLong((long)st
->st_blksize
));
1329 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1330 PyStructSequence_SET_ITEM(v
, ST_BLOCKS_IDX
,
1331 PyInt_FromLong((long)st
->st_blocks
));
1333 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1334 PyStructSequence_SET_ITEM(v
, ST_RDEV_IDX
,
1335 PyInt_FromLong((long)st
->st_rdev
));
1337 #ifdef HAVE_STRUCT_STAT_ST_GEN
1338 PyStructSequence_SET_ITEM(v
, ST_GEN_IDX
,
1339 PyInt_FromLong((long)st
->st_gen
));
1341 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1344 unsigned long bsec
,bnsec
;
1345 bsec
= (long)st
->st_birthtime
;
1346 #ifdef HAVE_STAT_TV_NSEC2
1347 bnsec
= st
->st_birthtimespec
.tv_nsec
;
1351 if (_stat_float_times
) {
1352 val
= PyFloat_FromDouble(bsec
+ 1e-9*bnsec
);
1354 val
= PyInt_FromLong((long)bsec
);
1356 PyStructSequence_SET_ITEM(v
, ST_BIRTHTIME_IDX
,
1360 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1361 PyStructSequence_SET_ITEM(v
, ST_FLAGS_IDX
,
1362 PyInt_FromLong((long)st
->st_flags
));
1365 if (PyErr_Occurred()) {
1375 /* IsUNCRoot -- test whether the supplied path is of the form \\SERVER\SHARE\,
1376 where / can be used in place of \ and the trailing slash is optional.
1377 Both SERVER and SHARE must have at least one character.
1380 #define ISSLASHA(c) ((c) == '\\' || (c) == '/')
1381 #define ISSLASHW(c) ((c) == L'\\' || (c) == L'/')
1383 #define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
1387 IsUNCRootA(char *path
, int pathlen
)
1389 #define ISSLASH ISSLASHA
1393 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1394 /* minimum UNCRoot is \\x\y */
1396 for (i
= 2; i
< pathlen
; i
++)
1397 if (ISSLASH(path
[i
])) break;
1398 if (i
== 2 || i
== pathlen
)
1399 /* do not allow \\\SHARE or \\SERVER */
1402 for (i
= share
; i
< pathlen
; i
++)
1403 if (ISSLASH(path
[i
])) break;
1404 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1409 #ifdef Py_WIN_WIDE_FILENAMES
1411 IsUNCRootW(Py_UNICODE
*path
, int pathlen
)
1413 #define ISSLASH ISSLASHW
1417 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1418 /* minimum UNCRoot is \\x\y */
1420 for (i
= 2; i
< pathlen
; i
++)
1421 if (ISSLASH(path
[i
])) break;
1422 if (i
== 2 || i
== pathlen
)
1423 /* do not allow \\\SHARE or \\SERVER */
1426 for (i
= share
; i
< pathlen
; i
++)
1427 if (ISSLASH(path
[i
])) break;
1428 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1432 #endif /* Py_WIN_WIDE_FILENAMES */
1433 #endif /* MS_WINDOWS */
1436 posix_do_stat(PyObject
*self
, PyObject
*args
,
1439 int (*statfunc
)(const char *, STRUCT_STAT
*, ...),
1441 int (*statfunc
)(const char *, STRUCT_STAT
*),
1444 int (*wstatfunc
)(const Py_UNICODE
*, STRUCT_STAT
*))
1447 char *path
= NULL
; /* pass this to stat; do not free() it */
1448 char *pathfree
= NULL
; /* this memory must be free'd */
1452 #ifdef Py_WIN_WIDE_FILENAMES
1453 /* If on wide-character-capable OS see if argument
1454 is Unicode and if so use wide API. */
1455 if (unicode_file_names()) {
1456 PyUnicodeObject
*po
;
1457 if (PyArg_ParseTuple(args
, wformat
, &po
)) {
1458 Py_UNICODE
*wpath
= PyUnicode_AS_UNICODE(po
);
1460 Py_BEGIN_ALLOW_THREADS
1461 /* PyUnicode_AS_UNICODE result OK without
1462 thread lock as it is a simple dereference. */
1463 res
= wstatfunc(wpath
, &st
);
1464 Py_END_ALLOW_THREADS
1467 return win32_error_unicode("stat", wpath
);
1468 return _pystat_fromstructstat(&st
);
1470 /* Drop the argument parsing error as narrow strings
1476 if (!PyArg_ParseTuple(args
, format
,
1477 Py_FileSystemDefaultEncoding
, &path
))
1481 Py_BEGIN_ALLOW_THREADS
1482 res
= (*statfunc
)(path
, &st
);
1483 Py_END_ALLOW_THREADS
1487 result
= win32_error("stat", pathfree
);
1489 result
= posix_error_with_filename(pathfree
);
1493 result
= _pystat_fromstructstat(&st
);
1495 PyMem_Free(pathfree
);
1501 PyDoc_STRVAR(posix_access__doc__
,
1502 "access(path, mode) -> True if granted, False otherwise\n\n\
1503 Use the real uid/gid to test for access to a path. Note that most\n\
1504 operations will use the effective uid/gid, therefore this routine can\n\
1505 be used in a suid/sgid environment to test if the invoking user has the\n\
1506 specified access to the path. The mode argument can be F_OK to test\n\
1507 existence, or the inclusive-OR of R_OK, W_OK, and X_OK.");
1510 posix_access(PyObject
*self
, PyObject
*args
)
1515 #ifdef Py_WIN_WIDE_FILENAMES
1517 if (unicode_file_names()) {
1518 PyUnicodeObject
*po
;
1519 if (PyArg_ParseTuple(args
, "Ui:access", &po
, &mode
)) {
1520 Py_BEGIN_ALLOW_THREADS
1521 /* PyUnicode_AS_UNICODE OK without thread lock as
1522 it is a simple dereference. */
1523 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1524 Py_END_ALLOW_THREADS
1527 /* Drop the argument parsing error as narrow strings
1531 if (!PyArg_ParseTuple(args
, "eti:access",
1532 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1534 Py_BEGIN_ALLOW_THREADS
1535 attr
= GetFileAttributesA(path
);
1536 Py_END_ALLOW_THREADS
1539 if (attr
== 0xFFFFFFFF)
1540 /* File does not exist, or cannot read attributes */
1541 return PyBool_FromLong(0);
1542 /* Access is possible if either write access wasn't requested, or
1543 the file isn't read-only, or if it's a directory, as there are
1544 no read-only directories on Windows. */
1545 return PyBool_FromLong(!(mode
& 2)
1546 || !(attr
& FILE_ATTRIBUTE_READONLY
)
1547 || (attr
& FILE_ATTRIBUTE_DIRECTORY
));
1550 if (!PyArg_ParseTuple(args
, "eti:access",
1551 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1553 Py_BEGIN_ALLOW_THREADS
1554 res
= access(path
, mode
);
1555 Py_END_ALLOW_THREADS
1557 return PyBool_FromLong(res
== 0);
1575 PyDoc_STRVAR(posix_ttyname__doc__
,
1576 "ttyname(fd) -> string\n\n\
1577 Return the name of the terminal device connected to 'fd'.");
1580 posix_ttyname(PyObject
*self
, PyObject
*args
)
1585 if (!PyArg_ParseTuple(args
, "i:ttyname", &id
))
1589 /* file descriptor 0 only, the default input device (stdin) */
1600 return posix_error();
1601 return PyString_FromString(ret
);
1606 PyDoc_STRVAR(posix_ctermid__doc__
,
1607 "ctermid() -> string\n\n\
1608 Return the name of the controlling terminal for this process.");
1611 posix_ctermid(PyObject
*self
, PyObject
*noargs
)
1614 char buffer
[L_ctermid
];
1616 #ifdef USE_CTERMID_R
1617 ret
= ctermid_r(buffer
);
1619 ret
= ctermid(buffer
);
1622 return posix_error();
1623 return PyString_FromString(buffer
);
1627 PyDoc_STRVAR(posix_chdir__doc__
,
1629 Change the current working directory to the specified path.");
1632 posix_chdir(PyObject
*self
, PyObject
*args
)
1635 return win32_1str(args
, "chdir", "s:chdir", win32_chdir
, "U:chdir", win32_wchdir
);
1636 #elif defined(PYOS_OS2) && defined(PYCC_GCC)
1637 return posix_1str(args
, "et:chdir", _chdir2
);
1638 #elif defined(__VMS)
1639 return posix_1str(args
, "et:chdir", (int (*)(const char *))chdir
);
1641 return posix_1str(args
, "et:chdir", chdir
);
1646 PyDoc_STRVAR(posix_fchdir__doc__
,
1647 "fchdir(fildes)\n\n\
1648 Change to the directory of the given file descriptor. fildes must be\n\
1649 opened on a directory, not a file.");
1652 posix_fchdir(PyObject
*self
, PyObject
*fdobj
)
1654 return posix_fildes(fdobj
, fchdir
);
1656 #endif /* HAVE_FCHDIR */
1659 PyDoc_STRVAR(posix_chmod__doc__
,
1660 "chmod(path, mode)\n\n\
1661 Change the access permissions of a file.");
1664 posix_chmod(PyObject
*self
, PyObject
*args
)
1669 #ifdef Py_WIN_WIDE_FILENAMES
1671 if (unicode_file_names()) {
1672 PyUnicodeObject
*po
;
1673 if (PyArg_ParseTuple(args
, "Ui|:chmod", &po
, &i
)) {
1674 Py_BEGIN_ALLOW_THREADS
1675 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1676 if (attr
!= 0xFFFFFFFF) {
1678 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1680 attr
|= FILE_ATTRIBUTE_READONLY
;
1681 res
= SetFileAttributesW(PyUnicode_AS_UNICODE(po
), attr
);
1685 Py_END_ALLOW_THREADS
1687 return win32_error_unicode("chmod",
1688 PyUnicode_AS_UNICODE(po
));
1692 /* Drop the argument parsing error as narrow strings
1696 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1699 Py_BEGIN_ALLOW_THREADS
1700 attr
= GetFileAttributesA(path
);
1701 if (attr
!= 0xFFFFFFFF) {
1703 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1705 attr
|= FILE_ATTRIBUTE_READONLY
;
1706 res
= SetFileAttributesA(path
, attr
);
1710 Py_END_ALLOW_THREADS
1712 win32_error("chmod", path
);
1719 #else /* Py_WIN_WIDE_FILENAMES */
1720 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1723 Py_BEGIN_ALLOW_THREADS
1724 res
= chmod(path
, i
);
1725 Py_END_ALLOW_THREADS
1727 return posix_error_with_allocated_filename(path
);
1735 PyDoc_STRVAR(posix_fchmod__doc__
,
1736 "fchmod(fd, mode)\n\n\
1737 Change the access permissions of the file given by file\n\
1741 posix_fchmod(PyObject
*self
, PyObject
*args
)
1744 if (!PyArg_ParseTuple(args
, "ii:fchmod", &fd
, &mode
))
1746 Py_BEGIN_ALLOW_THREADS
1747 res
= fchmod(fd
, mode
);
1748 Py_END_ALLOW_THREADS
1750 return posix_error();
1753 #endif /* HAVE_FCHMOD */
1756 PyDoc_STRVAR(posix_lchmod__doc__
,
1757 "lchmod(path, mode)\n\n\
1758 Change the access permissions of a file. If path is a symlink, this\n\
1759 affects the link itself rather than the target.");
1762 posix_lchmod(PyObject
*self
, PyObject
*args
)
1767 if (!PyArg_ParseTuple(args
, "eti:lchmod", Py_FileSystemDefaultEncoding
,
1770 Py_BEGIN_ALLOW_THREADS
1771 res
= lchmod(path
, i
);
1772 Py_END_ALLOW_THREADS
1774 return posix_error_with_allocated_filename(path
);
1778 #endif /* HAVE_LCHMOD */
1782 PyDoc_STRVAR(posix_chflags__doc__
,
1783 "chflags(path, flags)\n\n\
1787 posix_chflags(PyObject
*self
, PyObject
*args
)
1790 unsigned long flags
;
1792 if (!PyArg_ParseTuple(args
, "etk:chflags",
1793 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1795 Py_BEGIN_ALLOW_THREADS
1796 res
= chflags(path
, flags
);
1797 Py_END_ALLOW_THREADS
1799 return posix_error_with_allocated_filename(path
);
1804 #endif /* HAVE_CHFLAGS */
1806 #ifdef HAVE_LCHFLAGS
1807 PyDoc_STRVAR(posix_lchflags__doc__
,
1808 "lchflags(path, flags)\n\n\
1810 This function will not follow symbolic links.");
1813 posix_lchflags(PyObject
*self
, PyObject
*args
)
1816 unsigned long flags
;
1818 if (!PyArg_ParseTuple(args
, "etk:lchflags",
1819 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1821 Py_BEGIN_ALLOW_THREADS
1822 res
= lchflags(path
, flags
);
1823 Py_END_ALLOW_THREADS
1825 return posix_error_with_allocated_filename(path
);
1830 #endif /* HAVE_LCHFLAGS */
1833 PyDoc_STRVAR(posix_chroot__doc__
,
1835 Change root directory to path.");
1838 posix_chroot(PyObject
*self
, PyObject
*args
)
1840 return posix_1str(args
, "et:chroot", chroot
);
1845 PyDoc_STRVAR(posix_fsync__doc__
,
1847 force write of file with filedescriptor to disk.");
1850 posix_fsync(PyObject
*self
, PyObject
*fdobj
)
1852 return posix_fildes(fdobj
, fsync
);
1854 #endif /* HAVE_FSYNC */
1856 #ifdef HAVE_FDATASYNC
1859 extern int fdatasync(int); /* On HP-UX, in libc but not in unistd.h */
1862 PyDoc_STRVAR(posix_fdatasync__doc__
,
1863 "fdatasync(fildes)\n\n\
1864 force write of file with filedescriptor to disk.\n\
1865 does not force update of metadata.");
1868 posix_fdatasync(PyObject
*self
, PyObject
*fdobj
)
1870 return posix_fildes(fdobj
, fdatasync
);
1872 #endif /* HAVE_FDATASYNC */
1876 PyDoc_STRVAR(posix_chown__doc__
,
1877 "chown(path, uid, gid)\n\n\
1878 Change the owner and group id of path to the numeric uid and gid.");
1881 posix_chown(PyObject
*self
, PyObject
*args
)
1886 if (!PyArg_ParseTuple(args
, "etll:chown",
1887 Py_FileSystemDefaultEncoding
, &path
,
1890 Py_BEGIN_ALLOW_THREADS
1891 res
= chown(path
, (uid_t
) uid
, (gid_t
) gid
);
1892 Py_END_ALLOW_THREADS
1894 return posix_error_with_allocated_filename(path
);
1899 #endif /* HAVE_CHOWN */
1902 PyDoc_STRVAR(posix_fchown__doc__
,
1903 "fchown(fd, uid, gid)\n\n\
1904 Change the owner and group id of the file given by file descriptor\n\
1905 fd to the numeric uid and gid.");
1908 posix_fchown(PyObject
*self
, PyObject
*args
)
1912 if (!PyArg_ParseTuple(args
, "iii:chown", &fd
, &uid
, &gid
))
1914 Py_BEGIN_ALLOW_THREADS
1915 res
= fchown(fd
, (uid_t
) uid
, (gid_t
) gid
);
1916 Py_END_ALLOW_THREADS
1918 return posix_error();
1921 #endif /* HAVE_FCHOWN */
1924 PyDoc_STRVAR(posix_lchown__doc__
,
1925 "lchown(path, uid, gid)\n\n\
1926 Change the owner and group id of path to the numeric uid and gid.\n\
1927 This function will not follow symbolic links.");
1930 posix_lchown(PyObject
*self
, PyObject
*args
)
1935 if (!PyArg_ParseTuple(args
, "etii:lchown",
1936 Py_FileSystemDefaultEncoding
, &path
,
1939 Py_BEGIN_ALLOW_THREADS
1940 res
= lchown(path
, (uid_t
) uid
, (gid_t
) gid
);
1941 Py_END_ALLOW_THREADS
1943 return posix_error_with_allocated_filename(path
);
1948 #endif /* HAVE_LCHOWN */
1952 PyDoc_STRVAR(posix_getcwd__doc__
,
1953 "getcwd() -> path\n\n\
1954 Return a string representing the current working directory.");
1957 posix_getcwd(PyObject
*self
, PyObject
*noargs
)
1959 int bufsize_incr
= 1024;
1961 char *tmpbuf
= NULL
;
1963 PyObject
*dynamic_return
;
1965 Py_BEGIN_ALLOW_THREADS
1967 bufsize
= bufsize
+ bufsize_incr
;
1968 tmpbuf
= malloc(bufsize
);
1969 if (tmpbuf
== NULL
) {
1972 #if defined(PYOS_OS2) && defined(PYCC_GCC)
1973 res
= _getcwd2(tmpbuf
, bufsize
);
1975 res
= getcwd(tmpbuf
, bufsize
);
1981 } while ((res
== NULL
) && (errno
== ERANGE
));
1982 Py_END_ALLOW_THREADS
1985 return posix_error();
1987 dynamic_return
= PyString_FromString(tmpbuf
);
1990 return dynamic_return
;
1993 #ifdef Py_USING_UNICODE
1994 PyDoc_STRVAR(posix_getcwdu__doc__
,
1995 "getcwdu() -> path\n\n\
1996 Return a unicode string representing the current working directory.");
1999 posix_getcwdu(PyObject
*self
, PyObject
*noargs
)
2004 #ifdef Py_WIN_WIDE_FILENAMES
2006 if (unicode_file_names()) {
2008 wchar_t *wbuf2
= wbuf
;
2010 Py_BEGIN_ALLOW_THREADS
2011 len
= GetCurrentDirectoryW(sizeof wbuf
/ sizeof wbuf
[0], wbuf
);
2012 /* If the buffer is large enough, len does not include the
2013 terminating \0. If the buffer is too small, len includes
2014 the space needed for the terminator. */
2015 if (len
>= sizeof wbuf
/ sizeof wbuf
[0]) {
2016 wbuf2
= malloc(len
* sizeof(wchar_t));
2018 len
= GetCurrentDirectoryW(len
, wbuf2
);
2020 Py_END_ALLOW_THREADS
2026 if (wbuf2
!= wbuf
) free(wbuf2
);
2027 return win32_error("getcwdu", NULL
);
2029 resobj
= PyUnicode_FromWideChar(wbuf2
, len
);
2030 if (wbuf2
!= wbuf
) free(wbuf2
);
2035 Py_BEGIN_ALLOW_THREADS
2036 #if defined(PYOS_OS2) && defined(PYCC_GCC)
2037 res
= _getcwd2(buf
, sizeof buf
);
2039 res
= getcwd(buf
, sizeof buf
);
2041 Py_END_ALLOW_THREADS
2043 return posix_error();
2044 return PyUnicode_Decode(buf
, strlen(buf
), Py_FileSystemDefaultEncoding
,"strict");
2051 PyDoc_STRVAR(posix_link__doc__
,
2052 "link(src, dst)\n\n\
2053 Create a hard link to a file.");
2056 posix_link(PyObject
*self
, PyObject
*args
)
2058 return posix_2str(args
, "etet:link", link
);
2060 #endif /* HAVE_LINK */
2063 PyDoc_STRVAR(posix_listdir__doc__
,
2064 "listdir(path) -> list_of_strings\n\n\
2065 Return a list containing the names of the entries in the directory.\n\
2067 path: path of directory to list\n\
2069 The list is in arbitrary order. It does not include the special\n\
2070 entries '.' and '..' even if they are present in the directory.");
2073 posix_listdir(PyObject
*self
, PyObject
*args
)
2075 /* XXX Should redo this putting the (now four) versions of opendir
2076 in separate files instead of having them all here... */
2077 #if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)
2082 WIN32_FIND_DATA FileData
;
2083 char namebuf
[MAX_PATH
+5]; /* Overallocate for \\*.*\0 */
2084 char *bufptr
= namebuf
;
2085 Py_ssize_t len
= sizeof(namebuf
)-5; /* only claim to have space for MAX_PATH */
2087 #ifdef Py_WIN_WIDE_FILENAMES
2088 /* If on wide-character-capable OS see if argument
2089 is Unicode and if so use wide API. */
2090 if (unicode_file_names()) {
2092 if (PyArg_ParseTuple(args
, "U:listdir", &po
)) {
2093 WIN32_FIND_DATAW wFileData
;
2094 Py_UNICODE
*wnamebuf
;
2096 /* Overallocate for \\*.*\0 */
2097 len
= PyUnicode_GET_SIZE(po
);
2098 wnamebuf
= malloc((len
+ 5) * sizeof(wchar_t));
2103 wcscpy(wnamebuf
, PyUnicode_AS_UNICODE(po
));
2104 wch
= len
> 0 ? wnamebuf
[len
-1] : '\0';
2105 if (wch
!= L
'/' && wch
!= L
'\\' && wch
!= L
':')
2106 wnamebuf
[len
++] = L
'\\';
2107 wcscpy(wnamebuf
+ len
, L
"*.*");
2108 if ((d
= PyList_New(0)) == NULL
) {
2112 hFindFile
= FindFirstFileW(wnamebuf
, &wFileData
);
2113 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2114 int error
= GetLastError();
2115 if (error
== ERROR_FILE_NOT_FOUND
) {
2120 win32_error_unicode("FindFirstFileW", wnamebuf
);
2125 /* Skip over . and .. */
2126 if (wcscmp(wFileData
.cFileName
, L
".") != 0 &&
2127 wcscmp(wFileData
.cFileName
, L
"..") != 0) {
2128 v
= PyUnicode_FromUnicode(wFileData
.cFileName
, wcslen(wFileData
.cFileName
));
2134 if (PyList_Append(d
, v
) != 0) {
2142 Py_BEGIN_ALLOW_THREADS
2143 result
= FindNextFileW(hFindFile
, &wFileData
);
2144 Py_END_ALLOW_THREADS
2145 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2146 it got to the end of the directory. */
2147 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2149 win32_error_unicode("FindNextFileW", wnamebuf
);
2150 FindClose(hFindFile
);
2154 } while (result
== TRUE
);
2156 if (FindClose(hFindFile
) == FALSE
) {
2158 win32_error_unicode("FindClose", wnamebuf
);
2165 /* Drop the argument parsing error as narrow strings
2171 if (!PyArg_ParseTuple(args
, "et#:listdir",
2172 Py_FileSystemDefaultEncoding
, &bufptr
, &len
))
2175 char ch
= namebuf
[len
-1];
2176 if (ch
!= SEP
&& ch
!= ALTSEP
&& ch
!= ':')
2177 namebuf
[len
++] = '/';
2179 strcpy(namebuf
+ len
, "*.*");
2181 if ((d
= PyList_New(0)) == NULL
)
2184 hFindFile
= FindFirstFile(namebuf
, &FileData
);
2185 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2186 int error
= GetLastError();
2187 if (error
== ERROR_FILE_NOT_FOUND
)
2190 return win32_error("FindFirstFile", namebuf
);
2193 /* Skip over . and .. */
2194 if (strcmp(FileData
.cFileName
, ".") != 0 &&
2195 strcmp(FileData
.cFileName
, "..") != 0) {
2196 v
= PyString_FromString(FileData
.cFileName
);
2202 if (PyList_Append(d
, v
) != 0) {
2210 Py_BEGIN_ALLOW_THREADS
2211 result
= FindNextFile(hFindFile
, &FileData
);
2212 Py_END_ALLOW_THREADS
2213 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2214 it got to the end of the directory. */
2215 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2217 win32_error("FindNextFile", namebuf
);
2218 FindClose(hFindFile
);
2221 } while (result
== TRUE
);
2223 if (FindClose(hFindFile
) == FALSE
) {
2225 return win32_error("FindClose", namebuf
);
2230 #elif defined(PYOS_OS2)
2233 #define MAX_PATH CCHMAXPATH
2238 char namebuf
[MAX_PATH
+5];
2244 if (!PyArg_ParseTuple(args
, "t#:listdir", &name
, &len
))
2246 if (len
>= MAX_PATH
) {
2247 PyErr_SetString(PyExc_ValueError
, "path too long");
2250 strcpy(namebuf
, name
);
2251 for (pt
= namebuf
; *pt
; pt
++)
2254 if (namebuf
[len
-1] != SEP
)
2255 namebuf
[len
++] = SEP
;
2256 strcpy(namebuf
+ len
, "*.*");
2258 if ((d
= PyList_New(0)) == NULL
)
2261 rc
= DosFindFirst(namebuf
, /* Wildcard Pattern to Match */
2262 &hdir
, /* Handle to Use While Search Directory */
2263 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
2264 &ep
, sizeof(ep
), /* Structure to Receive Directory Entry */
2265 &srchcnt
, /* Max and Actual Count of Entries Per Iteration */
2266 FIL_STANDARD
); /* Format of Entry (EAs or Not) */
2268 if (rc
!= NO_ERROR
) {
2270 return posix_error_with_filename(name
);
2273 if (srchcnt
> 0) { /* If Directory is NOT Totally Empty, */
2275 if (ep
.achName
[0] == '.'
2276 && (ep
.achName
[1] == '\0' || (ep
.achName
[1] == '.' && ep
.achName
[2] == '\0')))
2277 continue; /* Skip Over "." and ".." Names */
2279 strcpy(namebuf
, ep
.achName
);
2281 /* Leave Case of Name Alone -- In Native Form */
2282 /* (Removed Forced Lowercasing Code) */
2284 v
= PyString_FromString(namebuf
);
2290 if (PyList_Append(d
, v
) != 0) {
2297 } while (DosFindNext(hdir
, &ep
, sizeof(ep
), &srchcnt
) == NO_ERROR
&& srchcnt
> 0);
2307 int arg_is_unicode
= 1;
2310 if (!PyArg_ParseTuple(args
, "U:listdir", &v
)) {
2314 if (!PyArg_ParseTuple(args
, "et:listdir", Py_FileSystemDefaultEncoding
, &name
))
2316 if ((dirp
= opendir(name
)) == NULL
) {
2317 return posix_error_with_allocated_filename(name
);
2319 if ((d
= PyList_New(0)) == NULL
) {
2325 Py_BEGIN_ALLOW_THREADS
2327 Py_END_ALLOW_THREADS
2330 if (ep
->d_name
[0] == '.' &&
2332 (ep
->d_name
[1] == '.' && NAMLEN(ep
) == 2)))
2334 v
= PyString_FromStringAndSize(ep
->d_name
, NAMLEN(ep
));
2340 #ifdef Py_USING_UNICODE
2341 if (arg_is_unicode
) {
2344 w
= PyUnicode_FromEncodedObject(v
,
2345 Py_FileSystemDefaultEncoding
,
2352 /* fall back to the original byte string, as
2353 discussed in patch #683592 */
2358 if (PyList_Append(d
, v
) != 0) {
2366 if (errno
!= 0 && d
!= NULL
) {
2367 /* readdir() returned NULL and set errno */
2370 return posix_error_with_allocated_filename(name
);
2377 #endif /* which OS */
2378 } /* end of posix_listdir */
2381 /* A helper function for abspath on win32 */
2383 posix__getfullpathname(PyObject
*self
, PyObject
*args
)
2385 /* assume encoded strings wont more than double no of chars */
2386 char inbuf
[MAX_PATH
*2];
2387 char *inbufp
= inbuf
;
2388 Py_ssize_t insize
= sizeof(inbuf
);
2389 char outbuf
[MAX_PATH
*2];
2391 #ifdef Py_WIN_WIDE_FILENAMES
2392 if (unicode_file_names()) {
2393 PyUnicodeObject
*po
;
2394 if (PyArg_ParseTuple(args
, "U|:_getfullpathname", &po
)) {
2395 Py_UNICODE woutbuf
[MAX_PATH
*2];
2397 if (!GetFullPathNameW(PyUnicode_AS_UNICODE(po
),
2398 sizeof(woutbuf
)/sizeof(woutbuf
[0]),
2400 return win32_error("GetFullPathName", "");
2401 return PyUnicode_FromUnicode(woutbuf
, wcslen(woutbuf
));
2403 /* Drop the argument parsing error as narrow strings
2408 if (!PyArg_ParseTuple (args
, "et#:_getfullpathname",
2409 Py_FileSystemDefaultEncoding
, &inbufp
,
2412 if (!GetFullPathName(inbuf
, sizeof(outbuf
)/sizeof(outbuf
[0]),
2414 return win32_error("GetFullPathName", inbuf
);
2415 if (PyUnicode_Check(PyTuple_GetItem(args
, 0))) {
2416 return PyUnicode_Decode(outbuf
, strlen(outbuf
),
2417 Py_FileSystemDefaultEncoding
, NULL
);
2419 return PyString_FromString(outbuf
);
2420 } /* end of posix__getfullpathname */
2421 #endif /* MS_WINDOWS */
2423 PyDoc_STRVAR(posix_mkdir__doc__
,
2424 "mkdir(path [, mode=0777])\n\n\
2425 Create a directory.");
2428 posix_mkdir(PyObject
*self
, PyObject
*args
)
2434 #ifdef Py_WIN_WIDE_FILENAMES
2435 if (unicode_file_names()) {
2436 PyUnicodeObject
*po
;
2437 if (PyArg_ParseTuple(args
, "U|i:mkdir", &po
, &mode
)) {
2438 Py_BEGIN_ALLOW_THREADS
2439 /* PyUnicode_AS_UNICODE OK without thread lock as
2440 it is a simple dereference. */
2441 res
= CreateDirectoryW(PyUnicode_AS_UNICODE(po
), NULL
);
2442 Py_END_ALLOW_THREADS
2444 return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po
));
2448 /* Drop the argument parsing error as narrow strings
2452 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2453 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2455 Py_BEGIN_ALLOW_THREADS
2456 /* PyUnicode_AS_UNICODE OK without thread lock as
2457 it is a simple dereference. */
2458 res
= CreateDirectoryA(path
, NULL
);
2459 Py_END_ALLOW_THREADS
2461 win32_error("mkdir", path
);
2470 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2471 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2473 Py_BEGIN_ALLOW_THREADS
2474 #if ( defined(__WATCOMC__) || defined(PYCC_VACPP) ) && !defined(__QNX__)
2477 res
= mkdir(path
, mode
);
2479 Py_END_ALLOW_THREADS
2481 return posix_error_with_allocated_filename(path
);
2489 /* sys/resource.h is needed for at least: wait3(), wait4(), broken nice. */
2490 #if defined(HAVE_SYS_RESOURCE_H)
2491 #include <sys/resource.h>
2496 PyDoc_STRVAR(posix_nice__doc__
,
2497 "nice(inc) -> new_priority\n\n\
2498 Decrease the priority of process by inc and return the new priority.");
2501 posix_nice(PyObject
*self
, PyObject
*args
)
2503 int increment
, value
;
2505 if (!PyArg_ParseTuple(args
, "i:nice", &increment
))
2508 /* There are two flavours of 'nice': one that returns the new
2509 priority (as required by almost all standards out there) and the
2510 Linux/FreeBSD/BSDI one, which returns '0' on success and advices
2511 the use of getpriority() to get the new priority.
2513 If we are of the nice family that returns the new priority, we
2514 need to clear errno before the call, and check if errno is filled
2515 before calling posix_error() on a returnvalue of -1, because the
2516 -1 may be the actual new priority! */
2519 value
= nice(increment
);
2520 #if defined(HAVE_BROKEN_NICE) && defined(HAVE_GETPRIORITY)
2522 value
= getpriority(PRIO_PROCESS
, 0);
2524 if (value
== -1 && errno
!= 0)
2525 /* either nice() or getpriority() returned an error */
2526 return posix_error();
2527 return PyInt_FromLong((long) value
);
2529 #endif /* HAVE_NICE */
2531 PyDoc_STRVAR(posix_rename__doc__
,
2532 "rename(old, new)\n\n\
2533 Rename a file or directory.");
2536 posix_rename(PyObject
*self
, PyObject
*args
)
2542 if (unicode_file_names()) {
2543 if (!PyArg_ParseTuple(args
, "O&O&:rename",
2544 convert_to_unicode
, &o1
,
2545 convert_to_unicode
, &o2
))
2548 Py_BEGIN_ALLOW_THREADS
2549 result
= MoveFileW(PyUnicode_AsUnicode(o1
),
2550 PyUnicode_AsUnicode(o2
));
2551 Py_END_ALLOW_THREADS
2555 return win32_error("rename", NULL
);
2560 if (!PyArg_ParseTuple(args
, "ss:rename", &p1
, &p2
))
2562 Py_BEGIN_ALLOW_THREADS
2563 result
= MoveFileA(p1
, p2
);
2564 Py_END_ALLOW_THREADS
2566 return win32_error("rename", NULL
);
2570 return posix_2str(args
, "etet:rename", rename
);
2575 PyDoc_STRVAR(posix_rmdir__doc__
,
2577 Remove a directory.");
2580 posix_rmdir(PyObject
*self
, PyObject
*args
)
2583 return win32_1str(args
, "rmdir", "s:rmdir", RemoveDirectoryA
, "U:rmdir", RemoveDirectoryW
);
2585 return posix_1str(args
, "et:rmdir", rmdir
);
2590 PyDoc_STRVAR(posix_stat__doc__
,
2591 "stat(path) -> stat result\n\n\
2592 Perform a stat system call on the given path.");
2595 posix_stat(PyObject
*self
, PyObject
*args
)
2598 return posix_do_stat(self
, args
, "et:stat", STAT
, "U:stat", win32_wstat
);
2600 return posix_do_stat(self
, args
, "et:stat", STAT
, NULL
, NULL
);
2606 PyDoc_STRVAR(posix_system__doc__
,
2607 "system(command) -> exit_status\n\n\
2608 Execute the command (a string) in a subshell.");
2611 posix_system(PyObject
*self
, PyObject
*args
)
2615 if (!PyArg_ParseTuple(args
, "s:system", &command
))
2617 Py_BEGIN_ALLOW_THREADS
2618 sts
= system(command
);
2619 Py_END_ALLOW_THREADS
2620 return PyInt_FromLong(sts
);
2625 PyDoc_STRVAR(posix_umask__doc__
,
2626 "umask(new_mask) -> old_mask\n\n\
2627 Set the current numeric umask and return the previous umask.");
2630 posix_umask(PyObject
*self
, PyObject
*args
)
2633 if (!PyArg_ParseTuple(args
, "i:umask", &i
))
2637 return posix_error();
2638 return PyInt_FromLong((long)i
);
2642 PyDoc_STRVAR(posix_unlink__doc__
,
2644 Remove a file (same as remove(path)).");
2646 PyDoc_STRVAR(posix_remove__doc__
,
2648 Remove a file (same as unlink(path)).");
2651 posix_unlink(PyObject
*self
, PyObject
*args
)
2654 return win32_1str(args
, "remove", "s:remove", DeleteFileA
, "U:remove", DeleteFileW
);
2656 return posix_1str(args
, "et:remove", unlink
);
2662 PyDoc_STRVAR(posix_uname__doc__
,
2663 "uname() -> (sysname, nodename, release, version, machine)\n\n\
2664 Return a tuple identifying the current operating system.");
2667 posix_uname(PyObject
*self
, PyObject
*noargs
)
2672 Py_BEGIN_ALLOW_THREADS
2674 Py_END_ALLOW_THREADS
2676 return posix_error();
2677 return Py_BuildValue("(sssss)",
2684 #endif /* HAVE_UNAME */
2687 extract_time(PyObject
*t
, long* sec
, long* usec
)
2690 if (PyFloat_Check(t
)) {
2691 double tval
= PyFloat_AsDouble(t
);
2692 PyObject
*intobj
= Py_TYPE(t
)->tp_as_number
->nb_int(t
);
2695 intval
= PyInt_AsLong(intobj
);
2697 if (intval
== -1 && PyErr_Occurred())
2700 *usec
= (long)((tval
- intval
) * 1e6
); /* can't exceed 1000000 */
2702 /* If rounding gave us a negative number,
2707 intval
= PyInt_AsLong(t
);
2708 if (intval
== -1 && PyErr_Occurred())
2715 PyDoc_STRVAR(posix_utime__doc__
,
2716 "utime(path, (atime, mtime))\n\
2717 utime(path, None)\n\n\
2718 Set the access and modified time of the file to the given values. If the\n\
2719 second form is used, set the access and modified times to the current time.");
2722 posix_utime(PyObject
*self
, PyObject
*args
)
2724 #ifdef Py_WIN_WIDE_FILENAMES
2726 PyUnicodeObject
*obwpath
;
2727 wchar_t *wpath
= NULL
;
2730 long atimesec
, mtimesec
, ausec
, musec
;
2731 FILETIME atime
, mtime
;
2732 PyObject
*result
= NULL
;
2734 if (unicode_file_names()) {
2735 if (PyArg_ParseTuple(args
, "UO|:utime", &obwpath
, &arg
)) {
2736 wpath
= PyUnicode_AS_UNICODE(obwpath
);
2737 Py_BEGIN_ALLOW_THREADS
2738 hFile
= CreateFileW(wpath
, FILE_WRITE_ATTRIBUTES
, 0,
2739 NULL
, OPEN_EXISTING
,
2740 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2741 Py_END_ALLOW_THREADS
2742 if (hFile
== INVALID_HANDLE_VALUE
)
2743 return win32_error_unicode("utime", wpath
);
2745 /* Drop the argument parsing error as narrow strings
2750 if (!PyArg_ParseTuple(args
, "etO:utime",
2751 Py_FileSystemDefaultEncoding
, &apath
, &arg
))
2753 Py_BEGIN_ALLOW_THREADS
2754 hFile
= CreateFileA(apath
, FILE_WRITE_ATTRIBUTES
, 0,
2755 NULL
, OPEN_EXISTING
,
2756 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2757 Py_END_ALLOW_THREADS
2758 if (hFile
== INVALID_HANDLE_VALUE
) {
2759 win32_error("utime", apath
);
2766 if (arg
== Py_None
) {
2768 GetSystemTime(&now
);
2769 if (!SystemTimeToFileTime(&now
, &mtime
) ||
2770 !SystemTimeToFileTime(&now
, &atime
)) {
2771 win32_error("utime", NULL
);
2775 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2776 PyErr_SetString(PyExc_TypeError
,
2777 "utime() arg 2 must be a tuple (atime, mtime)");
2781 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2782 &atimesec
, &ausec
) == -1)
2784 time_t_to_FILE_TIME(atimesec
, 1000*ausec
, &atime
);
2785 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2786 &mtimesec
, &musec
) == -1)
2788 time_t_to_FILE_TIME(mtimesec
, 1000*musec
, &mtime
);
2790 if (!SetFileTime(hFile
, NULL
, &atime
, &mtime
)) {
2791 /* Avoid putting the file name into the error here,
2792 as that may confuse the user into believing that
2793 something is wrong with the file, when it also
2794 could be the time stamp that gives a problem. */
2795 win32_error("utime", NULL
);
2802 #else /* Py_WIN_WIDE_FILENAMES */
2805 long atime
, mtime
, ausec
, musec
;
2809 #if defined(HAVE_UTIMES)
2810 struct timeval buf
[2];
2811 #define ATIME buf[0].tv_sec
2812 #define MTIME buf[1].tv_sec
2813 #elif defined(HAVE_UTIME_H)
2814 /* XXX should define struct utimbuf instead, above */
2816 #define ATIME buf.actime
2817 #define MTIME buf.modtime
2818 #define UTIME_ARG &buf
2819 #else /* HAVE_UTIMES */
2821 #define ATIME buf[0]
2822 #define MTIME buf[1]
2823 #define UTIME_ARG buf
2824 #endif /* HAVE_UTIMES */
2827 if (!PyArg_ParseTuple(args
, "etO:utime",
2828 Py_FileSystemDefaultEncoding
, &path
, &arg
))
2830 if (arg
== Py_None
) {
2831 /* optional time values not given */
2832 Py_BEGIN_ALLOW_THREADS
2833 res
= utime(path
, NULL
);
2834 Py_END_ALLOW_THREADS
2836 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2837 PyErr_SetString(PyExc_TypeError
,
2838 "utime() arg 2 must be a tuple (atime, mtime)");
2843 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2844 &atime
, &ausec
) == -1) {
2848 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2849 &mtime
, &musec
) == -1) {
2856 buf
[0].tv_usec
= ausec
;
2857 buf
[1].tv_usec
= musec
;
2858 Py_BEGIN_ALLOW_THREADS
2859 res
= utimes(path
, buf
);
2860 Py_END_ALLOW_THREADS
2862 Py_BEGIN_ALLOW_THREADS
2863 res
= utime(path
, UTIME_ARG
);
2864 Py_END_ALLOW_THREADS
2865 #endif /* HAVE_UTIMES */
2868 return posix_error_with_allocated_filename(path
);
2876 #endif /* Py_WIN_WIDE_FILENAMES */
2880 /* Process operations */
2882 PyDoc_STRVAR(posix__exit__doc__
,
2884 Exit to the system with specified status, without normal exit processing.");
2887 posix__exit(PyObject
*self
, PyObject
*args
)
2890 if (!PyArg_ParseTuple(args
, "i:_exit", &sts
))
2893 return NULL
; /* Make gcc -Wall happy */
2896 #if defined(HAVE_EXECV) || defined(HAVE_SPAWNV)
2898 free_string_array(char **array
, Py_ssize_t count
)
2901 for (i
= 0; i
< count
; i
++)
2902 PyMem_Free(array
[i
]);
2909 PyDoc_STRVAR(posix_execv__doc__
,
2910 "execv(path, args)\n\n\
2911 Execute an executable path with arguments, replacing current process.\n\
2913 path: path of executable file\n\
2914 args: tuple or list of strings");
2917 posix_execv(PyObject
*self
, PyObject
*args
)
2923 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
2925 /* execv has two arguments: (path, argv), where
2926 argv is a list or tuple of strings. */
2928 if (!PyArg_ParseTuple(args
, "etO:execv",
2929 Py_FileSystemDefaultEncoding
,
2932 if (PyList_Check(argv
)) {
2933 argc
= PyList_Size(argv
);
2934 getitem
= PyList_GetItem
;
2936 else if (PyTuple_Check(argv
)) {
2937 argc
= PyTuple_Size(argv
);
2938 getitem
= PyTuple_GetItem
;
2941 PyErr_SetString(PyExc_TypeError
, "execv() arg 2 must be a tuple or list");
2946 argvlist
= PyMem_NEW(char *, argc
+1);
2947 if (argvlist
== NULL
) {
2949 return PyErr_NoMemory();
2951 for (i
= 0; i
< argc
; i
++) {
2952 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
2953 Py_FileSystemDefaultEncoding
,
2955 free_string_array(argvlist
, i
);
2956 PyErr_SetString(PyExc_TypeError
,
2957 "execv() arg 2 must contain only strings");
2963 argvlist
[argc
] = NULL
;
2965 execv(path
, argvlist
);
2967 /* If we get here it's definitely an error */
2969 free_string_array(argvlist
, argc
);
2971 return posix_error();
2975 PyDoc_STRVAR(posix_execve__doc__
,
2976 "execve(path, args, env)\n\n\
2977 Execute a path with arguments and environment, replacing current process.\n\
2979 path: path of executable file\n\
2980 args: tuple or list of arguments\n\
2981 env: dictionary of strings mapping to strings");
2984 posix_execve(PyObject
*self
, PyObject
*args
)
2987 PyObject
*argv
, *env
;
2990 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
;
2991 Py_ssize_t i
, pos
, argc
, envc
;
2992 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
2993 Py_ssize_t lastarg
= 0;
2995 /* execve has three arguments: (path, argv, env), where
2996 argv is a list or tuple of strings and env is a dictionary
2997 like posix.environ. */
2999 if (!PyArg_ParseTuple(args
, "etOO:execve",
3000 Py_FileSystemDefaultEncoding
,
3001 &path
, &argv
, &env
))
3003 if (PyList_Check(argv
)) {
3004 argc
= PyList_Size(argv
);
3005 getitem
= PyList_GetItem
;
3007 else if (PyTuple_Check(argv
)) {
3008 argc
= PyTuple_Size(argv
);
3009 getitem
= PyTuple_GetItem
;
3012 PyErr_SetString(PyExc_TypeError
,
3013 "execve() arg 2 must be a tuple or list");
3016 if (!PyMapping_Check(env
)) {
3017 PyErr_SetString(PyExc_TypeError
,
3018 "execve() arg 3 must be a mapping object");
3022 argvlist
= PyMem_NEW(char *, argc
+1);
3023 if (argvlist
== NULL
) {
3027 for (i
= 0; i
< argc
; i
++) {
3028 if (!PyArg_Parse((*getitem
)(argv
, i
),
3029 "et;execve() arg 2 must contain only strings",
3030 Py_FileSystemDefaultEncoding
,
3038 argvlist
[argc
] = NULL
;
3040 i
= PyMapping_Size(env
);
3043 envlist
= PyMem_NEW(char *, i
+ 1);
3044 if (envlist
== NULL
) {
3049 keys
= PyMapping_Keys(env
);
3050 vals
= PyMapping_Values(env
);
3053 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3054 PyErr_SetString(PyExc_TypeError
,
3055 "execve(): env.keys() or env.values() is not a list");
3059 for (pos
= 0; pos
< i
; pos
++) {
3063 key
= PyList_GetItem(keys
, pos
);
3064 val
= PyList_GetItem(vals
, pos
);
3070 "s;execve() arg 3 contains a non-string key",
3074 "s;execve() arg 3 contains a non-string value",
3080 #if defined(PYOS_OS2)
3081 /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
3082 if (stricmp(k
, "BEGINLIBPATH") != 0 && stricmp(k
, "ENDLIBPATH") != 0) {
3084 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3085 p
= PyMem_NEW(char, len
);
3090 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3091 envlist
[envc
++] = p
;
3092 #if defined(PYOS_OS2)
3098 execve(path
, argvlist
, envlist
);
3100 /* If we get here it's definitely an error */
3102 (void) posix_error();
3106 PyMem_DEL(envlist
[envc
]);
3109 free_string_array(argvlist
, lastarg
);
3116 #endif /* HAVE_EXECV */
3120 PyDoc_STRVAR(posix_spawnv__doc__
,
3121 "spawnv(mode, path, args)\n\n\
3122 Execute the program 'path' in a new process.\n\
3124 mode: mode of process creation\n\
3125 path: path of executable file\n\
3126 args: tuple or list of strings");
3129 posix_spawnv(PyObject
*self
, PyObject
*args
)
3136 Py_intptr_t spawnval
;
3137 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3139 /* spawnv has three arguments: (mode, path, argv), where
3140 argv is a list or tuple of strings. */
3142 if (!PyArg_ParseTuple(args
, "ietO:spawnv", &mode
,
3143 Py_FileSystemDefaultEncoding
,
3146 if (PyList_Check(argv
)) {
3147 argc
= PyList_Size(argv
);
3148 getitem
= PyList_GetItem
;
3150 else if (PyTuple_Check(argv
)) {
3151 argc
= PyTuple_Size(argv
);
3152 getitem
= PyTuple_GetItem
;
3155 PyErr_SetString(PyExc_TypeError
,
3156 "spawnv() arg 2 must be a tuple or list");
3161 argvlist
= PyMem_NEW(char *, argc
+1);
3162 if (argvlist
== NULL
) {
3164 return PyErr_NoMemory();
3166 for (i
= 0; i
< argc
; i
++) {
3167 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3168 Py_FileSystemDefaultEncoding
,
3170 free_string_array(argvlist
, i
);
3173 "spawnv() arg 2 must contain only strings");
3178 argvlist
[argc
] = NULL
;
3180 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3181 Py_BEGIN_ALLOW_THREADS
3182 spawnval
= spawnv(mode
, path
, argvlist
);
3183 Py_END_ALLOW_THREADS
3185 if (mode
== _OLD_P_OVERLAY
)
3188 Py_BEGIN_ALLOW_THREADS
3189 spawnval
= _spawnv(mode
, path
, argvlist
);
3190 Py_END_ALLOW_THREADS
3193 free_string_array(argvlist
, argc
);
3197 return posix_error();
3199 #if SIZEOF_LONG == SIZEOF_VOID_P
3200 return Py_BuildValue("l", (long) spawnval
);
3202 return Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3207 PyDoc_STRVAR(posix_spawnve__doc__
,
3208 "spawnve(mode, path, args, env)\n\n\
3209 Execute the program 'path' in a new process.\n\
3211 mode: mode of process creation\n\
3212 path: path of executable file\n\
3213 args: tuple or list of arguments\n\
3214 env: dictionary of strings mapping to strings");
3217 posix_spawnve(PyObject
*self
, PyObject
*args
)
3220 PyObject
*argv
, *env
;
3223 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3224 int mode
, pos
, envc
;
3226 Py_intptr_t spawnval
;
3227 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3228 Py_ssize_t lastarg
= 0;
3230 /* spawnve has four arguments: (mode, path, argv, env), where
3231 argv is a list or tuple of strings and env is a dictionary
3232 like posix.environ. */
3234 if (!PyArg_ParseTuple(args
, "ietOO:spawnve", &mode
,
3235 Py_FileSystemDefaultEncoding
,
3236 &path
, &argv
, &env
))
3238 if (PyList_Check(argv
)) {
3239 argc
= PyList_Size(argv
);
3240 getitem
= PyList_GetItem
;
3242 else if (PyTuple_Check(argv
)) {
3243 argc
= PyTuple_Size(argv
);
3244 getitem
= PyTuple_GetItem
;
3247 PyErr_SetString(PyExc_TypeError
,
3248 "spawnve() arg 2 must be a tuple or list");
3251 if (!PyMapping_Check(env
)) {
3252 PyErr_SetString(PyExc_TypeError
,
3253 "spawnve() arg 3 must be a mapping object");
3257 argvlist
= PyMem_NEW(char *, argc
+1);
3258 if (argvlist
== NULL
) {
3262 for (i
= 0; i
< argc
; i
++) {
3263 if (!PyArg_Parse((*getitem
)(argv
, i
),
3264 "et;spawnve() arg 2 must contain only strings",
3265 Py_FileSystemDefaultEncoding
,
3273 argvlist
[argc
] = NULL
;
3275 i
= PyMapping_Size(env
);
3278 envlist
= PyMem_NEW(char *, i
+ 1);
3279 if (envlist
== NULL
) {
3284 keys
= PyMapping_Keys(env
);
3285 vals
= PyMapping_Values(env
);
3288 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3289 PyErr_SetString(PyExc_TypeError
,
3290 "spawnve(): env.keys() or env.values() is not a list");
3294 for (pos
= 0; pos
< i
; pos
++) {
3298 key
= PyList_GetItem(keys
, pos
);
3299 val
= PyList_GetItem(vals
, pos
);
3305 "s;spawnve() arg 3 contains a non-string key",
3309 "s;spawnve() arg 3 contains a non-string value",
3314 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3315 p
= PyMem_NEW(char, len
);
3320 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3321 envlist
[envc
++] = p
;
3325 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3326 Py_BEGIN_ALLOW_THREADS
3327 spawnval
= spawnve(mode
, path
, argvlist
, envlist
);
3328 Py_END_ALLOW_THREADS
3330 if (mode
== _OLD_P_OVERLAY
)
3333 Py_BEGIN_ALLOW_THREADS
3334 spawnval
= _spawnve(mode
, path
, argvlist
, envlist
);
3335 Py_END_ALLOW_THREADS
3339 (void) posix_error();
3341 #if SIZEOF_LONG == SIZEOF_VOID_P
3342 res
= Py_BuildValue("l", (long) spawnval
);
3344 res
= Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3349 PyMem_DEL(envlist
[envc
]);
3352 free_string_array(argvlist
, lastarg
);
3360 /* OS/2 supports spawnvp & spawnvpe natively */
3361 #if defined(PYOS_OS2)
3362 PyDoc_STRVAR(posix_spawnvp__doc__
,
3363 "spawnvp(mode, file, args)\n\n\
3364 Execute the program 'file' in a new process, using the environment\n\
3365 search path to find the file.\n\
3367 mode: mode of process creation\n\
3368 file: executable file name\n\
3369 args: tuple or list of strings");
3372 posix_spawnvp(PyObject
*self
, PyObject
*args
)
3378 Py_intptr_t spawnval
;
3379 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3381 /* spawnvp has three arguments: (mode, path, argv), where
3382 argv is a list or tuple of strings. */
3384 if (!PyArg_ParseTuple(args
, "ietO:spawnvp", &mode
,
3385 Py_FileSystemDefaultEncoding
,
3388 if (PyList_Check(argv
)) {
3389 argc
= PyList_Size(argv
);
3390 getitem
= PyList_GetItem
;
3392 else if (PyTuple_Check(argv
)) {
3393 argc
= PyTuple_Size(argv
);
3394 getitem
= PyTuple_GetItem
;
3397 PyErr_SetString(PyExc_TypeError
,
3398 "spawnvp() arg 2 must be a tuple or list");
3403 argvlist
= PyMem_NEW(char *, argc
+1);
3404 if (argvlist
== NULL
) {
3406 return PyErr_NoMemory();
3408 for (i
= 0; i
< argc
; i
++) {
3409 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3410 Py_FileSystemDefaultEncoding
,
3412 free_string_array(argvlist
, i
);
3415 "spawnvp() arg 2 must contain only strings");
3420 argvlist
[argc
] = NULL
;
3422 Py_BEGIN_ALLOW_THREADS
3423 #if defined(PYCC_GCC)
3424 spawnval
= spawnvp(mode
, path
, argvlist
);
3426 spawnval
= _spawnvp(mode
, path
, argvlist
);
3428 Py_END_ALLOW_THREADS
3430 free_string_array(argvlist
, argc
);
3434 return posix_error();
3436 return Py_BuildValue("l", (long) spawnval
);
3440 PyDoc_STRVAR(posix_spawnvpe__doc__
,
3441 "spawnvpe(mode, file, args, env)\n\n\
3442 Execute the program 'file' in a new process, using the environment\n\
3443 search path to find the file.\n\
3445 mode: mode of process creation\n\
3446 file: executable file name\n\
3447 args: tuple or list of arguments\n\
3448 env: dictionary of strings mapping to strings");
3451 posix_spawnvpe(PyObject
*self
, PyObject
*args
)
3454 PyObject
*argv
, *env
;
3457 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3458 int mode
, i
, pos
, argc
, envc
;
3459 Py_intptr_t spawnval
;
3460 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3463 /* spawnvpe has four arguments: (mode, path, argv, env), where
3464 argv is a list or tuple of strings and env is a dictionary
3465 like posix.environ. */
3467 if (!PyArg_ParseTuple(args
, "ietOO:spawnvpe", &mode
,
3468 Py_FileSystemDefaultEncoding
,
3469 &path
, &argv
, &env
))
3471 if (PyList_Check(argv
)) {
3472 argc
= PyList_Size(argv
);
3473 getitem
= PyList_GetItem
;
3475 else if (PyTuple_Check(argv
)) {
3476 argc
= PyTuple_Size(argv
);
3477 getitem
= PyTuple_GetItem
;
3480 PyErr_SetString(PyExc_TypeError
,
3481 "spawnvpe() arg 2 must be a tuple or list");
3484 if (!PyMapping_Check(env
)) {
3485 PyErr_SetString(PyExc_TypeError
,
3486 "spawnvpe() arg 3 must be a mapping object");
3490 argvlist
= PyMem_NEW(char *, argc
+1);
3491 if (argvlist
== NULL
) {
3495 for (i
= 0; i
< argc
; i
++) {
3496 if (!PyArg_Parse((*getitem
)(argv
, i
),
3497 "et;spawnvpe() arg 2 must contain only strings",
3498 Py_FileSystemDefaultEncoding
,
3506 argvlist
[argc
] = NULL
;
3508 i
= PyMapping_Size(env
);
3511 envlist
= PyMem_NEW(char *, i
+ 1);
3512 if (envlist
== NULL
) {
3517 keys
= PyMapping_Keys(env
);
3518 vals
= PyMapping_Values(env
);
3521 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3522 PyErr_SetString(PyExc_TypeError
,
3523 "spawnvpe(): env.keys() or env.values() is not a list");
3527 for (pos
= 0; pos
< i
; pos
++) {
3531 key
= PyList_GetItem(keys
, pos
);
3532 val
= PyList_GetItem(vals
, pos
);
3538 "s;spawnvpe() arg 3 contains a non-string key",
3542 "s;spawnvpe() arg 3 contains a non-string value",
3547 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3548 p
= PyMem_NEW(char, len
);
3553 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3554 envlist
[envc
++] = p
;
3558 Py_BEGIN_ALLOW_THREADS
3559 #if defined(PYCC_GCC)
3560 spawnval
= spawnvpe(mode
, path
, argvlist
, envlist
);
3562 spawnval
= _spawnvpe(mode
, path
, argvlist
, envlist
);
3564 Py_END_ALLOW_THREADS
3567 (void) posix_error();
3569 res
= Py_BuildValue("l", (long) spawnval
);
3573 PyMem_DEL(envlist
[envc
]);
3576 free_string_array(argvlist
, lastarg
);
3583 #endif /* PYOS_OS2 */
3584 #endif /* HAVE_SPAWNV */
3588 PyDoc_STRVAR(posix_fork1__doc__
,
3589 "fork1() -> pid\n\n\
3590 Fork a child process with a single multiplexed (i.e., not bound) thread.\n\
3592 Return 0 to child process and PID of child to parent process.");
3595 posix_fork1(PyObject
*self
, PyObject
*noargs
)
3597 pid_t pid
= fork1();
3599 return posix_error();
3601 return PyInt_FromLong(pid
);
3607 PyDoc_STRVAR(posix_fork__doc__
,
3609 Fork a child process.\n\
3610 Return 0 to child process and PID of child to parent process.");
3613 posix_fork(PyObject
*self
, PyObject
*noargs
)
3617 return posix_error();
3620 return PyInt_FromLong(pid
);
3624 /* AIX uses /dev/ptc but is otherwise the same as /dev/ptmx */
3625 /* IRIX has both /dev/ptc and /dev/ptmx, use ptmx */
3626 #if defined(HAVE_DEV_PTC) && !defined(HAVE_DEV_PTMX)
3627 #define DEV_PTY_FILE "/dev/ptc"
3628 #define HAVE_DEV_PTMX
3630 #define DEV_PTY_FILE "/dev/ptmx"
3633 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX)
3637 #ifdef HAVE_LIBUTIL_H
3638 #include <libutil.h>
3639 #endif /* HAVE_LIBUTIL_H */
3640 #endif /* HAVE_PTY_H */
3641 #ifdef HAVE_STROPTS_H
3642 #include <stropts.h>
3644 #endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX */
3646 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
3647 PyDoc_STRVAR(posix_openpty__doc__
,
3648 "openpty() -> (master_fd, slave_fd)\n\n\
3649 Open a pseudo-terminal, returning open fd's for both master and slave end.\n");
3652 posix_openpty(PyObject
*self
, PyObject
*noargs
)
3654 int master_fd
, slave_fd
;
3655 #ifndef HAVE_OPENPTY
3658 #if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)
3659 PyOS_sighandler_t sig_saved
;
3661 extern char *ptsname(int fildes
);
3666 if (openpty(&master_fd
, &slave_fd
, NULL
, NULL
, NULL
) != 0)
3667 return posix_error();
3668 #elif defined(HAVE__GETPTY)
3669 slave_name
= _getpty(&master_fd
, O_RDWR
, 0666, 0);
3670 if (slave_name
== NULL
)
3671 return posix_error();
3673 slave_fd
= open(slave_name
, O_RDWR
);
3675 return posix_error();
3677 master_fd
= open(DEV_PTY_FILE
, O_RDWR
| O_NOCTTY
); /* open master */
3679 return posix_error();
3680 sig_saved
= PyOS_setsig(SIGCHLD
, SIG_DFL
);
3681 /* change permission of slave */
3682 if (grantpt(master_fd
) < 0) {
3683 PyOS_setsig(SIGCHLD
, sig_saved
);
3684 return posix_error();
3687 if (unlockpt(master_fd
) < 0) {
3688 PyOS_setsig(SIGCHLD
, sig_saved
);
3689 return posix_error();
3691 PyOS_setsig(SIGCHLD
, sig_saved
);
3692 slave_name
= ptsname(master_fd
); /* get name of slave */
3693 if (slave_name
== NULL
)
3694 return posix_error();
3695 slave_fd
= open(slave_name
, O_RDWR
| O_NOCTTY
); /* open slave */
3697 return posix_error();
3698 #if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)
3699 ioctl(slave_fd
, I_PUSH
, "ptem"); /* push ptem */
3700 ioctl(slave_fd
, I_PUSH
, "ldterm"); /* push ldterm */
3702 ioctl(slave_fd
, I_PUSH
, "ttcompat"); /* push ttcompat */
3704 #endif /* HAVE_CYGWIN */
3705 #endif /* HAVE_OPENPTY */
3707 return Py_BuildValue("(ii)", master_fd
, slave_fd
);
3710 #endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */
3713 PyDoc_STRVAR(posix_forkpty__doc__
,
3714 "forkpty() -> (pid, master_fd)\n\n\
3715 Fork a new process with a new pseudo-terminal as controlling tty.\n\n\
3716 Like fork(), return 0 as pid to child process, and PID of child to parent.\n\
3717 To both, return fd of newly opened pseudo-terminal.\n");
3720 posix_forkpty(PyObject
*self
, PyObject
*noargs
)
3725 pid
= forkpty(&master_fd
, NULL
, NULL
, NULL
);
3727 return posix_error();
3730 return Py_BuildValue("(li)", pid
, master_fd
);
3735 PyDoc_STRVAR(posix_getegid__doc__
,
3736 "getegid() -> egid\n\n\
3737 Return the current process's effective group id.");
3740 posix_getegid(PyObject
*self
, PyObject
*noargs
)
3742 return PyInt_FromLong((long)getegid());
3748 PyDoc_STRVAR(posix_geteuid__doc__
,
3749 "geteuid() -> euid\n\n\
3750 Return the current process's effective user id.");
3753 posix_geteuid(PyObject
*self
, PyObject
*noargs
)
3755 return PyInt_FromLong((long)geteuid());
3761 PyDoc_STRVAR(posix_getgid__doc__
,
3762 "getgid() -> gid\n\n\
3763 Return the current process's group id.");
3766 posix_getgid(PyObject
*self
, PyObject
*noargs
)
3768 return PyInt_FromLong((long)getgid());
3773 PyDoc_STRVAR(posix_getpid__doc__
,
3774 "getpid() -> pid\n\n\
3775 Return the current process id");
3778 posix_getpid(PyObject
*self
, PyObject
*noargs
)
3780 return PyInt_FromLong((long)getpid());
3784 #ifdef HAVE_GETGROUPS
3785 PyDoc_STRVAR(posix_getgroups__doc__
,
3786 "getgroups() -> list of group IDs\n\n\
3787 Return list of supplemental group IDs for the process.");
3790 posix_getgroups(PyObject
*self
, PyObject
*noargs
)
3792 PyObject
*result
= NULL
;
3795 #define MAX_GROUPS NGROUPS_MAX
3797 /* defined to be 16 on Solaris7, so this should be a small number */
3798 #define MAX_GROUPS 64
3800 gid_t grouplist
[MAX_GROUPS
];
3803 n
= getgroups(MAX_GROUPS
, grouplist
);
3807 result
= PyList_New(n
);
3808 if (result
!= NULL
) {
3810 for (i
= 0; i
< n
; ++i
) {
3811 PyObject
*o
= PyInt_FromLong((long)grouplist
[i
]);
3817 PyList_SET_ITEM(result
, i
, o
);
3827 PyDoc_STRVAR(posix_getpgid__doc__
,
3828 "getpgid(pid) -> pgid\n\n\
3829 Call the system call getpgid().");
3832 posix_getpgid(PyObject
*self
, PyObject
*args
)
3835 if (!PyArg_ParseTuple(args
, "i:getpgid", &pid
))
3837 pgid
= getpgid(pid
);
3839 return posix_error();
3840 return PyInt_FromLong((long)pgid
);
3842 #endif /* HAVE_GETPGID */
3846 PyDoc_STRVAR(posix_getpgrp__doc__
,
3847 "getpgrp() -> pgrp\n\n\
3848 Return the current process group id.");
3851 posix_getpgrp(PyObject
*self
, PyObject
*noargs
)
3853 #ifdef GETPGRP_HAVE_ARG
3854 return PyInt_FromLong((long)getpgrp(0));
3855 #else /* GETPGRP_HAVE_ARG */
3856 return PyInt_FromLong((long)getpgrp());
3857 #endif /* GETPGRP_HAVE_ARG */
3859 #endif /* HAVE_GETPGRP */
3863 PyDoc_STRVAR(posix_setpgrp__doc__
,
3865 Make this process a session leader.");
3868 posix_setpgrp(PyObject
*self
, PyObject
*noargs
)
3870 #ifdef SETPGRP_HAVE_ARG
3871 if (setpgrp(0, 0) < 0)
3872 #else /* SETPGRP_HAVE_ARG */
3874 #endif /* SETPGRP_HAVE_ARG */
3875 return posix_error();
3880 #endif /* HAVE_SETPGRP */
3883 PyDoc_STRVAR(posix_getppid__doc__
,
3884 "getppid() -> ppid\n\n\
3885 Return the parent's process id.");
3888 posix_getppid(PyObject
*self
, PyObject
*noargs
)
3890 return PyInt_FromLong(getppid());
3895 #ifdef HAVE_GETLOGIN
3896 PyDoc_STRVAR(posix_getlogin__doc__
,
3897 "getlogin() -> string\n\n\
3898 Return the actual login name.");
3901 posix_getlogin(PyObject
*self
, PyObject
*noargs
)
3903 PyObject
*result
= NULL
;
3905 int old_errno
= errno
;
3913 PyErr_SetString(PyExc_OSError
,
3914 "unable to determine login name");
3917 result
= PyString_FromString(name
);
3925 PyDoc_STRVAR(posix_getuid__doc__
,
3926 "getuid() -> uid\n\n\
3927 Return the current process's user id.");
3930 posix_getuid(PyObject
*self
, PyObject
*noargs
)
3932 return PyInt_FromLong((long)getuid());
3938 PyDoc_STRVAR(posix_kill__doc__
,
3939 "kill(pid, sig)\n\n\
3940 Kill a process with a signal.");
3943 posix_kill(PyObject
*self
, PyObject
*args
)
3947 if (!PyArg_ParseTuple(args
, "ii:kill", &pid
, &sig
))
3949 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
3950 if (sig
== XCPT_SIGNAL_INTR
|| sig
== XCPT_SIGNAL_BREAK
) {
3952 if ((rc
= DosSendSignalException(pid
, sig
)) != NO_ERROR
)
3953 return os2_error(rc
);
3955 } else if (sig
== XCPT_SIGNAL_KILLPROC
) {
3957 if ((rc
= DosKillProcess(DKP_PROCESS
, pid
)) != NO_ERROR
)
3958 return os2_error(rc
);
3961 return NULL
; /* Unrecognized Signal Requested */
3963 if (kill(pid
, sig
) == -1)
3964 return posix_error();
3972 PyDoc_STRVAR(posix_killpg__doc__
,
3973 "killpg(pgid, sig)\n\n\
3974 Kill a process group with a signal.");
3977 posix_killpg(PyObject
*self
, PyObject
*args
)
3980 if (!PyArg_ParseTuple(args
, "ii:killpg", &pgid
, &sig
))
3982 if (killpg(pgid
, sig
) == -1)
3983 return posix_error();
3991 #ifdef HAVE_SYS_LOCK_H
3992 #include <sys/lock.h>
3995 PyDoc_STRVAR(posix_plock__doc__
,
3997 Lock program segments into memory.");
4000 posix_plock(PyObject
*self
, PyObject
*args
)
4003 if (!PyArg_ParseTuple(args
, "i:plock", &op
))
4005 if (plock(op
) == -1)
4006 return posix_error();
4014 PyDoc_STRVAR(posix_popen__doc__
,
4015 "popen(command [, mode='r' [, bufsize]]) -> pipe\n\n\
4016 Open a pipe to/from a command returning a file object.");
4018 #if defined(PYOS_OS2)
4019 #if defined(PYCC_VACPP)
4021 async_system(const char *command
)
4023 char errormsg
[256], args
[1024];
4027 char *shell
= getenv("COMSPEC");
4031 /* avoid overflowing the argument buffer */
4032 if (strlen(shell
) + 3 + strlen(command
) >= 1024)
4033 return ERROR_NOT_ENOUGH_MEMORY
4036 strcat(args
, shell
);
4037 strcat(args
, "/c ");
4038 strcat(args
, command
);
4040 /* execute asynchronously, inheriting the environment */
4041 rc
= DosExecPgm(errormsg
,
4052 popen(const char *command
, const char *mode
, int pipesize
, int *err
)
4058 /* mode determines which of stdin or stdout is reconnected to
4059 * the pipe to the child
4061 if (strchr(mode
, 'r') != NULL
) {
4062 tgt_fd
= 1; /* stdout */
4063 } else if (strchr(mode
, 'w')) {
4064 tgt_fd
= 0; /* stdin */
4066 *err
= ERROR_INVALID_ACCESS
;
4070 /* setup the pipe */
4071 if ((rc
= DosCreatePipe(&pipeh
[0], &pipeh
[1], pipesize
)) != NO_ERROR
) {
4076 /* prevent other threads accessing stdio */
4079 /* reconnect stdio and execute child */
4082 if (dup2(pipeh
[tgtfd
], tgtfd
) == 0) {
4083 DosClose(pipeh
[tgtfd
]);
4084 rc
= async_system(command
);
4091 /* allow other threads access to stdio */
4094 /* if execution of child was successful return file stream */
4096 return fdopen(pipeh
[1 - tgtfd
], mode
);
4098 DosClose(pipeh
[1 - tgtfd
]);
4105 posix_popen(PyObject
*self
, PyObject
*args
)
4109 int err
, bufsize
= -1;
4112 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4114 Py_BEGIN_ALLOW_THREADS
4115 fp
= popen(name
, mode
, (bufsize
> 0) ? bufsize
: 4096, &err
);
4116 Py_END_ALLOW_THREADS
4118 return os2_error(err
);
4120 f
= PyFile_FromFile(fp
, name
, mode
, fclose
);
4122 PyFile_SetBufSize(f
, bufsize
);
4126 #elif defined(PYCC_GCC)
4128 /* standard posix version of popen() support */
4130 posix_popen(PyObject
*self
, PyObject
*args
)
4137 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4139 Py_BEGIN_ALLOW_THREADS
4140 fp
= popen(name
, mode
);
4141 Py_END_ALLOW_THREADS
4143 return posix_error();
4144 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
4146 PyFile_SetBufSize(f
, bufsize
);
4150 /* fork() under OS/2 has lots'o'warts
4151 * EMX supports pipe() and spawn*() so we can synthesize popen[234]()
4152 * most of this code is a ripoff of the win32 code, but using the
4153 * capabilities of EMX's C library routines
4156 /* These tell _PyPopen() whether to return 1, 2, or 3 file objects. */
4162 static PyObject
*_PyPopen(char *, int, int, int);
4163 static int _PyPclose(FILE *file
);
4166 * Internal dictionary mapping popen* file pointers to process handles,
4167 * for use when retrieving the process exit code. See _PyPclose() below
4168 * for more information on this dictionary's use.
4170 static PyObject
*_PyPopenProcs
= NULL
;
4172 /* os2emx version of popen2()
4174 * The result of this function is a pipe (file) connected to the
4175 * process's stdin, and a pipe connected to the process's stdout.
4179 os2emx_popen2(PyObject
*self
, PyObject
*args
)
4187 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4192 else if (*mode
!= 'b') {
4193 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4198 f
= _PyPopen(cmdstring
, tm
, POPEN_2
, bufsize
);
4204 * Variation on os2emx.popen2
4206 * The result of this function is 3 pipes - the process's stdin,
4211 os2emx_popen3(PyObject
*self
, PyObject
*args
)
4219 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4224 else if (*mode
!= 'b') {
4225 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4230 f
= _PyPopen(cmdstring
, tm
, POPEN_3
, bufsize
);
4236 * Variation on os2emx.popen2
4238 * The result of this function is 2 pipes - the processes stdin,
4239 * and stdout+stderr combined as a single pipe.
4243 os2emx_popen4(PyObject
*self
, PyObject
*args
)
4251 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4256 else if (*mode
!= 'b') {
4257 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4262 f
= _PyPopen(cmdstring
, tm
, POPEN_4
, bufsize
);
4267 /* a couple of structures for convenient handling of multiple
4268 * file handles and pipes
4282 /* The following code is derived from the win32 code */
4285 _PyPopen(char *cmdstring
, int mode
, int n
, int bufsize
)
4287 struct file_ref stdio
[3];
4288 struct pipe_ref p_fd
[3];
4290 int file_count
, i
, pipe_err
;
4292 char *shell
, *sh_name
, *opt
, *rd_mode
, *wr_mode
;
4293 PyObject
*f
, *p_f
[3];
4295 /* file modes for subsequent fdopen's on pipe handles */
4307 /* prepare shell references */
4308 if ((shell
= getenv("EMXSHELL")) == NULL
)
4309 if ((shell
= getenv("COMSPEC")) == NULL
)
4312 return posix_error();
4315 sh_name
= _getname(shell
);
4316 if (stricmp(sh_name
, "cmd.exe") == 0 || stricmp(sh_name
, "4os2.exe") == 0)
4321 /* save current stdio fds + their flags, and set not inheritable */
4323 while (pipe_err
>= 0 && i
< 3)
4325 pipe_err
= stdio
[i
].handle
= dup(i
);
4326 stdio
[i
].flags
= fcntl(i
, F_GETFD
, 0);
4327 fcntl(stdio
[i
].handle
, F_SETFD
, stdio
[i
].flags
| FD_CLOEXEC
);
4332 /* didn't get them all saved - clean up and bail out */
4333 int saved_err
= errno
;
4336 close(stdio
[i
].handle
);
4339 return posix_error();
4342 /* create pipe ends */
4347 while ((pipe_err
== 0) && (i
< file_count
))
4348 pipe_err
= pipe((int *)&p_fd
[i
++]);
4351 /* didn't get them all made - clean up and bail out */
4358 return posix_error();
4361 /* change the actual standard IO streams over temporarily,
4362 * making the retained pipe ends non-inheritable
4367 if (dup2(p_fd
[0].rd
, 0) == 0)
4370 i
= fcntl(p_fd
[0].wr
, F_GETFD
, 0);
4371 fcntl(p_fd
[0].wr
, F_SETFD
, i
| FD_CLOEXEC
);
4372 if ((p_s
[0] = fdopen(p_fd
[0].wr
, wr_mode
)) == NULL
)
4386 if (dup2(p_fd
[1].wr
, 1) == 1)
4389 i
= fcntl(p_fd
[1].rd
, F_GETFD
, 0);
4390 fcntl(p_fd
[1].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4391 if ((p_s
[1] = fdopen(p_fd
[1].rd
, rd_mode
)) == NULL
)
4403 /* - stderr, as required */
4409 if (dup2(p_fd
[2].wr
, 2) == 2)
4412 i
= fcntl(p_fd
[2].rd
, F_GETFD
, 0);
4413 fcntl(p_fd
[2].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4414 if ((p_s
[2] = fdopen(p_fd
[2].rd
, rd_mode
)) == NULL
)
4429 if (dup2(1, 2) != 2)
4437 /* spawn the child process */
4440 pipe_pid
= spawnlp(P_NOWAIT
, shell
, shell
, opt
, cmdstring
, (char *)0);
4447 /* save the PID into the FILE structure
4448 * NOTE: this implementation doesn't actually
4449 * take advantage of this, but do it for
4450 * completeness - AIM Apr01
4452 for (i
= 0; i
< file_count
; i
++)
4453 p_s
[i
]->_pid
= pipe_pid
;
4457 /* reset standard IO to normal */
4458 for (i
= 0; i
< 3; i
++)
4460 dup2(stdio
[i
].handle
, i
);
4461 fcntl(i
, F_SETFD
, stdio
[i
].flags
);
4462 close(stdio
[i
].handle
);
4465 /* if any remnant problems, clean up and bail out */
4468 for (i
= 0; i
< 3; i
++)
4474 return posix_error_with_filename(cmdstring
);
4477 /* build tuple of file objects to return */
4478 if ((p_f
[0] = PyFile_FromFile(p_s
[0], cmdstring
, wr_mode
, _PyPclose
)) != NULL
)
4479 PyFile_SetBufSize(p_f
[0], bufsize
);
4480 if ((p_f
[1] = PyFile_FromFile(p_s
[1], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4481 PyFile_SetBufSize(p_f
[1], bufsize
);
4484 if ((p_f
[2] = PyFile_FromFile(p_s
[2], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4485 PyFile_SetBufSize(p_f
[0], bufsize
);
4486 f
= PyTuple_Pack(3, p_f
[0], p_f
[1], p_f
[2]);
4489 f
= PyTuple_Pack(2, p_f
[0], p_f
[1]);
4492 * Insert the files we've created into the process dictionary
4493 * all referencing the list with the process handle and the
4494 * initial number of files (see description below in _PyPclose).
4495 * Since if _PyPclose later tried to wait on a process when all
4496 * handles weren't closed, it could create a deadlock with the
4497 * child, we spend some energy here to try to ensure that we
4498 * either insert all file handles into the dictionary or none
4499 * at all. It's a little clumsy with the various popen modes
4500 * and variable number of files involved.
4504 _PyPopenProcs
= PyDict_New();
4509 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
[3];
4512 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
4513 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
4515 procObj
= PyList_New(2);
4516 pidObj
= PyInt_FromLong((long) pipe_pid
);
4517 intObj
= PyInt_FromLong((long) file_count
);
4519 if (procObj
&& pidObj
&& intObj
)
4521 PyList_SetItem(procObj
, 0, pidObj
);
4522 PyList_SetItem(procObj
, 1, intObj
);
4524 fileObj
[0] = PyLong_FromVoidPtr(p_s
[0]);
4527 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
4531 fileObj
[1] = PyLong_FromVoidPtr(p_s
[1]);
4534 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
4538 if (file_count
>= 3)
4540 fileObj
[2] = PyLong_FromVoidPtr(p_s
[2]);
4543 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
4549 if (ins_rc
[0] < 0 || !fileObj
[0] ||
4550 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
4551 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2]))
4553 /* Something failed - remove any dictionary
4554 * entries that did make it.
4556 if (!ins_rc
[0] && fileObj
[0])
4558 PyDict_DelItem(_PyPopenProcs
,
4561 if (!ins_rc
[1] && fileObj
[1])
4563 PyDict_DelItem(_PyPopenProcs
,
4566 if (!ins_rc
[2] && fileObj
[2])
4568 PyDict_DelItem(_PyPopenProcs
,
4575 * Clean up our localized references for the dictionary keys
4576 * and value since PyDict_SetItem will Py_INCREF any copies
4577 * that got placed in the dictionary.
4579 Py_XDECREF(procObj
);
4580 Py_XDECREF(fileObj
[0]);
4581 Py_XDECREF(fileObj
[1]);
4582 Py_XDECREF(fileObj
[2]);
4585 /* Child is launched. */
4590 * Wrapper for fclose() to use for popen* files, so we can retrieve the
4591 * exit code for the child process and return as a result of the close.
4593 * This function uses the _PyPopenProcs dictionary in order to map the
4594 * input file pointer to information about the process that was
4595 * originally created by the popen* call that created the file pointer.
4596 * The dictionary uses the file pointer as a key (with one entry
4597 * inserted for each file returned by the original popen* call) and a
4598 * single list object as the value for all files from a single call.
4599 * The list object contains the Win32 process handle at [0], and a file
4600 * count at [1], which is initialized to the total number of file
4601 * handles using that list.
4603 * This function closes whichever handle it is passed, and decrements
4604 * the file count in the dictionary for the process handle pointed to
4605 * by this file. On the last close (when the file count reaches zero),
4606 * this function will wait for the child process and then return its
4607 * exit code as the result of the close() operation. This permits the
4608 * files to be closed in any order - it is always the close() of the
4609 * final handle that will return the exit code.
4611 * NOTE: This function is currently called with the GIL released.
4612 * hence we use the GILState API to manage our state.
4615 static int _PyPclose(FILE *file
)
4620 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
;
4623 PyGILState_STATE state
;
4626 /* Close the file handle first, to ensure it can't block the
4627 * child from exiting if it's the last handle.
4629 result
= fclose(file
);
4632 state
= PyGILState_Ensure();
4636 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
4637 (procObj
= PyDict_GetItem(_PyPopenProcs
,
4638 fileObj
)) != NULL
&&
4639 (pidObj
= PyList_GetItem(procObj
,0)) != NULL
&&
4640 (intObj
= PyList_GetItem(procObj
,1)) != NULL
)
4642 pipe_pid
= (int) PyInt_AsLong(pidObj
);
4643 file_count
= (int) PyInt_AsLong(intObj
);
4647 /* Still other files referencing process */
4649 PyList_SetItem(procObj
,1,
4650 PyInt_FromLong((long) file_count
));
4654 /* Last file for this process */
4655 if (result
!= EOF
&&
4656 waitpid(pipe_pid
, &exit_code
, 0) == pipe_pid
)
4658 /* extract exit status */
4659 if (WIFEXITED(exit_code
))
4661 result
= WEXITSTATUS(exit_code
);
4671 /* Indicate failure - this will cause the file object
4672 * to raise an I/O error and translate the last
4673 * error code from errno. We do have a problem with
4674 * last errors that overlap the normal errno table,
4675 * but that's a consistent problem with the file object.
4681 /* Remove this file pointer from dictionary */
4682 PyDict_DelItem(_PyPopenProcs
, fileObj
);
4684 if (PyDict_Size(_PyPopenProcs
) == 0)
4686 Py_DECREF(_PyPopenProcs
);
4687 _PyPopenProcs
= NULL
;
4690 } /* if object retrieval ok */
4692 Py_XDECREF(fileObj
);
4693 } /* if _PyPopenProcs */
4696 PyGILState_Release(state
);
4701 #endif /* PYCC_??? */
4703 #elif defined(MS_WINDOWS)
4706 * Portable 'popen' replacement for Win32.
4708 * Written by Bill Tutt <billtut@microsoft.com>. Minor tweaks
4709 * and 2.0 integration by Fredrik Lundh <fredrik@pythonware.com>
4710 * Return code handling by David Bolen <db3l@fitlinxx.com>.
4717 /* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */
4723 static PyObject
*_PyPopen(char *, int, int);
4724 static int _PyPclose(FILE *file
);
4727 * Internal dictionary mapping popen* file pointers to process handles,
4728 * for use when retrieving the process exit code. See _PyPclose() below
4729 * for more information on this dictionary's use.
4731 static PyObject
*_PyPopenProcs
= NULL
;
4734 /* popen that works from a GUI.
4736 * The result of this function is a pipe (file) connected to the
4737 * processes stdin or stdout, depending on the requested mode.
4741 posix_popen(PyObject
*self
, PyObject
*args
)
4749 if (!PyArg_ParseTuple(args
, "s|si:popen", &cmdstring
, &mode
, &bufsize
))
4754 else if (*mode
!= 'w') {
4755 PyErr_SetString(PyExc_ValueError
, "popen() arg 2 must be 'r' or 'w'");
4760 if (bufsize
!= -1) {
4761 PyErr_SetString(PyExc_ValueError
, "popen() arg 3 must be -1");
4765 if (*(mode
+1) == 't')
4766 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4767 else if (*(mode
+1) == 'b')
4768 f
= _PyPopen(cmdstring
, tm
| _O_BINARY
, POPEN_1
);
4770 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4775 /* Variation on win32pipe.popen
4777 * The result of this function is a pipe (file) connected to the
4778 * process's stdin, and a pipe connected to the process's stdout.
4782 win32_popen2(PyObject
*self
, PyObject
*args
)
4790 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4795 else if (*mode
!= 'b') {
4796 PyErr_SetString(PyExc_ValueError
, "popen2() arg 2 must be 't' or 'b'");
4801 if (bufsize
!= -1) {
4802 PyErr_SetString(PyExc_ValueError
, "popen2() arg 3 must be -1");
4806 f
= _PyPopen(cmdstring
, tm
, POPEN_2
);
4812 * Variation on <om win32pipe.popen>
4814 * The result of this function is 3 pipes - the process's stdin,
4819 win32_popen3(PyObject
*self
, PyObject
*args
)
4827 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4832 else if (*mode
!= 'b') {
4833 PyErr_SetString(PyExc_ValueError
, "popen3() arg 2 must be 't' or 'b'");
4838 if (bufsize
!= -1) {
4839 PyErr_SetString(PyExc_ValueError
, "popen3() arg 3 must be -1");
4843 f
= _PyPopen(cmdstring
, tm
, POPEN_3
);
4849 * Variation on win32pipe.popen
4851 * The result of this function is 2 pipes - the processes stdin,
4852 * and stdout+stderr combined as a single pipe.
4856 win32_popen4(PyObject
*self
, PyObject
*args
)
4864 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4869 else if (*mode
!= 'b') {
4870 PyErr_SetString(PyExc_ValueError
, "popen4() arg 2 must be 't' or 'b'");
4875 if (bufsize
!= -1) {
4876 PyErr_SetString(PyExc_ValueError
, "popen4() arg 3 must be -1");
4880 f
= _PyPopen(cmdstring
, tm
, POPEN_4
);
4886 _PyPopenCreateProcess(char *cmdstring
,
4892 PROCESS_INFORMATION piProcInfo
;
4893 STARTUPINFO siStartInfo
;
4894 DWORD dwProcessFlags
= 0; /* no NEW_CONSOLE by default for Ctrl+C handling */
4895 char *s1
,*s2
, *s3
= " /c ";
4896 const char *szConsoleSpawn
= "w9xpopen.exe";
4900 if (i
= GetEnvironmentVariable("COMSPEC",NULL
,0)) {
4903 s1
= (char *)alloca(i
);
4904 if (!(x
= GetEnvironmentVariable("COMSPEC", s1
, i
)))
4905 /* x < i, so x fits into an integer */
4908 /* Explicitly check if we are using COMMAND.COM. If we are
4909 * then use the w9xpopen hack.
4912 while (comshell
>= s1
&& *comshell
!= '\\')
4916 if (GetVersion() < 0x80000000 &&
4917 _stricmp(comshell
, "command.com") != 0) {
4918 /* NT/2000 and not using command.com. */
4919 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1;
4920 s2
= (char *)alloca(x
);
4922 PyOS_snprintf(s2
, x
, "%s%s%s", s1
, s3
, cmdstring
);
4926 * Oh gag, we're on Win9x or using COMMAND.COM. Use
4927 * the workaround listed in KB: Q150956
4929 char modulepath
[_MAX_PATH
];
4930 struct stat statinfo
;
4931 GetModuleFileName(NULL
, modulepath
, sizeof(modulepath
));
4932 for (x
= i
= 0; modulepath
[i
]; i
++)
4933 if (modulepath
[i
] == SEP
)
4935 modulepath
[x
] = '\0';
4936 /* Create the full-name to w9xpopen, so we can test it exists */
4939 (sizeof(modulepath
)/sizeof(modulepath
[0]))
4940 -strlen(modulepath
));
4941 if (stat(modulepath
, &statinfo
) != 0) {
4942 size_t mplen
= sizeof(modulepath
)/sizeof(modulepath
[0]);
4943 /* Eeek - file-not-found - possibly an embedding
4944 situation - see if we can locate it in sys.prefix
4949 modulepath
[mplen
-1] = '\0';
4950 if (modulepath
[strlen(modulepath
)-1] != '\\')
4951 strcat(modulepath
, "\\");
4954 mplen
-strlen(modulepath
));
4955 /* No where else to look - raise an easily identifiable
4956 error, rather than leaving Windows to report
4957 "file not found" - as the user is probably blissfully
4958 unaware this shim EXE is used, and it will confuse them.
4959 (well, it confused me for a while ;-)
4961 if (stat(modulepath
, &statinfo
) != 0) {
4962 PyErr_Format(PyExc_RuntimeError
,
4963 "Can not locate '%s' which is needed "
4964 "for popen to work with your shell "
4970 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1 +
4971 strlen(modulepath
) +
4972 strlen(szConsoleSpawn
) + 1;
4974 s2
= (char *)alloca(x
);
4976 /* To maintain correct argument passing semantics,
4977 we pass the command-line as it stands, and allow
4978 quoting to be applied. w9xpopen.exe will then
4979 use its argv vector, and re-quote the necessary
4980 args for the ultimate child process.
4989 /* Not passing CREATE_NEW_CONSOLE has been known to
4990 cause random failures on win9x. Specifically a
4992 "Your program accessed mem currently in use at xxx"
4993 and a hopeful warning about the stability of your
4995 Cost is Ctrl+C wont kill children, but anyone
4996 who cares can have a go!
4998 dwProcessFlags
|= CREATE_NEW_CONSOLE
;
5002 /* Could be an else here to try cmd.exe / command.com in the path
5003 Now we'll just error out.. */
5005 PyErr_SetString(PyExc_RuntimeError
,
5006 "Cannot locate a COMSPEC environment variable to "
5007 "use as the shell");
5011 ZeroMemory(&siStartInfo
, sizeof(STARTUPINFO
));
5012 siStartInfo
.cb
= sizeof(STARTUPINFO
);
5013 siStartInfo
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
5014 siStartInfo
.hStdInput
= hStdin
;
5015 siStartInfo
.hStdOutput
= hStdout
;
5016 siStartInfo
.hStdError
= hStderr
;
5017 siStartInfo
.wShowWindow
= SW_HIDE
;
5019 if (CreateProcess(NULL
,
5029 /* Close the handles now so anyone waiting is woken. */
5030 CloseHandle(piProcInfo
.hThread
);
5032 /* Return process handle */
5033 *hProcess
= piProcInfo
.hProcess
;
5036 win32_error("CreateProcess", s2
);
5040 /* The following code is based off of KB: Q190351 */
5043 _PyPopen(char *cmdstring
, int mode
, int n
)
5045 HANDLE hChildStdinRd
, hChildStdinWr
, hChildStdoutRd
, hChildStdoutWr
,
5046 hChildStderrRd
, hChildStderrWr
, hChildStdinWrDup
, hChildStdoutRdDup
,
5047 hChildStderrRdDup
, hProcess
; /* hChildStdoutWrDup; */
5049 SECURITY_ATTRIBUTES saAttr
;
5056 saAttr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
5057 saAttr
.bInheritHandle
= TRUE
;
5058 saAttr
.lpSecurityDescriptor
= NULL
;
5060 if (!CreatePipe(&hChildStdinRd
, &hChildStdinWr
, &saAttr
, 0))
5061 return win32_error("CreatePipe", NULL
);
5063 /* Create new output read handle and the input write handle. Set
5064 * the inheritance properties to FALSE. Otherwise, the child inherits
5065 * these handles; resulting in non-closeable handles to the pipes
5067 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdinWr
,
5068 GetCurrentProcess(), &hChildStdinWrDup
, 0,
5070 DUPLICATE_SAME_ACCESS
);
5072 return win32_error("DuplicateHandle", NULL
);
5074 /* Close the inheritable version of ChildStdin
5075 that we're using. */
5076 CloseHandle(hChildStdinWr
);
5078 if (!CreatePipe(&hChildStdoutRd
, &hChildStdoutWr
, &saAttr
, 0))
5079 return win32_error("CreatePipe", NULL
);
5081 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdoutRd
,
5082 GetCurrentProcess(), &hChildStdoutRdDup
, 0,
5083 FALSE
, DUPLICATE_SAME_ACCESS
);
5085 return win32_error("DuplicateHandle", NULL
);
5087 /* Close the inheritable version of ChildStdout
5088 that we're using. */
5089 CloseHandle(hChildStdoutRd
);
5092 if (!CreatePipe(&hChildStderrRd
, &hChildStderrWr
, &saAttr
, 0))
5093 return win32_error("CreatePipe", NULL
);
5094 fSuccess
= DuplicateHandle(GetCurrentProcess(),
5096 GetCurrentProcess(),
5097 &hChildStderrRdDup
, 0,
5098 FALSE
, DUPLICATE_SAME_ACCESS
);
5100 return win32_error("DuplicateHandle", NULL
);
5101 /* Close the inheritable version of ChildStdErr that we're using. */
5102 CloseHandle(hChildStderrRd
);
5107 switch (mode
& (_O_RDONLY
| _O_TEXT
| _O_BINARY
| _O_WRONLY
)) {
5108 case _O_WRONLY
| _O_TEXT
:
5109 /* Case for writing to child Stdin in text mode. */
5110 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5111 f1
= _fdopen(fd1
, "w");
5112 f
= PyFile_FromFile(f1
, cmdstring
, "w", _PyPclose
);
5113 PyFile_SetBufSize(f
, 0);
5114 /* We don't care about these pipes anymore, so close them. */
5115 CloseHandle(hChildStdoutRdDup
);
5116 CloseHandle(hChildStderrRdDup
);
5119 case _O_RDONLY
| _O_TEXT
:
5120 /* Case for reading from child Stdout in text mode. */
5121 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5122 f1
= _fdopen(fd1
, "r");
5123 f
= PyFile_FromFile(f1
, cmdstring
, "r", _PyPclose
);
5124 PyFile_SetBufSize(f
, 0);
5125 /* We don't care about these pipes anymore, so close them. */
5126 CloseHandle(hChildStdinWrDup
);
5127 CloseHandle(hChildStderrRdDup
);
5130 case _O_RDONLY
| _O_BINARY
:
5131 /* Case for readinig from child Stdout in binary mode. */
5132 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5133 f1
= _fdopen(fd1
, "rb");
5134 f
= PyFile_FromFile(f1
, cmdstring
, "rb", _PyPclose
);
5135 PyFile_SetBufSize(f
, 0);
5136 /* We don't care about these pipes anymore, so close them. */
5137 CloseHandle(hChildStdinWrDup
);
5138 CloseHandle(hChildStderrRdDup
);
5141 case _O_WRONLY
| _O_BINARY
:
5142 /* Case for writing to child Stdin in binary mode. */
5143 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5144 f1
= _fdopen(fd1
, "wb");
5145 f
= PyFile_FromFile(f1
, cmdstring
, "wb", _PyPclose
);
5146 PyFile_SetBufSize(f
, 0);
5147 /* We don't care about these pipes anymore, so close them. */
5148 CloseHandle(hChildStdoutRdDup
);
5149 CloseHandle(hChildStderrRdDup
);
5161 if (mode
& _O_TEXT
) {
5169 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5170 f1
= _fdopen(fd1
, m2
);
5171 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5172 f2
= _fdopen(fd2
, m1
);
5173 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5174 PyFile_SetBufSize(p1
, 0);
5175 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5176 PyFile_SetBufSize(p2
, 0);
5179 CloseHandle(hChildStderrRdDup
);
5181 f
= PyTuple_Pack(2,p1
,p2
);
5191 PyObject
*p1
, *p2
, *p3
;
5193 if (mode
& _O_TEXT
) {
5201 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5202 f1
= _fdopen(fd1
, m2
);
5203 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5204 f2
= _fdopen(fd2
, m1
);
5205 fd3
= _open_osfhandle((Py_intptr_t
)hChildStderrRdDup
, mode
);
5206 f3
= _fdopen(fd3
, m1
);
5207 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5208 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5209 p3
= PyFile_FromFile(f3
, cmdstring
, m1
, _PyPclose
);
5210 PyFile_SetBufSize(p1
, 0);
5211 PyFile_SetBufSize(p2
, 0);
5212 PyFile_SetBufSize(p3
, 0);
5213 f
= PyTuple_Pack(3,p1
,p2
,p3
);
5223 if (!_PyPopenCreateProcess(cmdstring
,
5231 if (!_PyPopenCreateProcess(cmdstring
,
5240 * Insert the files we've created into the process dictionary
5241 * all referencing the list with the process handle and the
5242 * initial number of files (see description below in _PyPclose).
5243 * Since if _PyPclose later tried to wait on a process when all
5244 * handles weren't closed, it could create a deadlock with the
5245 * child, we spend some energy here to try to ensure that we
5246 * either insert all file handles into the dictionary or none
5247 * at all. It's a little clumsy with the various popen modes
5248 * and variable number of files involved.
5250 if (!_PyPopenProcs
) {
5251 _PyPopenProcs
= PyDict_New();
5254 if (_PyPopenProcs
) {
5255 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
[3];
5258 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
5259 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
5261 procObj
= PyList_New(2);
5262 hProcessObj
= PyLong_FromVoidPtr(hProcess
);
5263 intObj
= PyInt_FromLong(file_count
);
5265 if (procObj
&& hProcessObj
&& intObj
) {
5266 PyList_SetItem(procObj
,0,hProcessObj
);
5267 PyList_SetItem(procObj
,1,intObj
);
5269 fileObj
[0] = PyLong_FromVoidPtr(f1
);
5271 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
5275 if (file_count
>= 2) {
5276 fileObj
[1] = PyLong_FromVoidPtr(f2
);
5278 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
5283 if (file_count
>= 3) {
5284 fileObj
[2] = PyLong_FromVoidPtr(f3
);
5286 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
5292 if (ins_rc
[0] < 0 || !fileObj
[0] ||
5293 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
5294 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2])) {
5295 /* Something failed - remove any dictionary
5296 * entries that did make it.
5298 if (!ins_rc
[0] && fileObj
[0]) {
5299 PyDict_DelItem(_PyPopenProcs
,
5302 if (!ins_rc
[1] && fileObj
[1]) {
5303 PyDict_DelItem(_PyPopenProcs
,
5306 if (!ins_rc
[2] && fileObj
[2]) {
5307 PyDict_DelItem(_PyPopenProcs
,
5314 * Clean up our localized references for the dictionary keys
5315 * and value since PyDict_SetItem will Py_INCREF any copies
5316 * that got placed in the dictionary.
5318 Py_XDECREF(procObj
);
5319 Py_XDECREF(fileObj
[0]);
5320 Py_XDECREF(fileObj
[1]);
5321 Py_XDECREF(fileObj
[2]);
5324 /* Child is launched. Close the parents copy of those pipe
5325 * handles that only the child should have open. You need to
5326 * make sure that no handles to the write end of the output pipe
5327 * are maintained in this process or else the pipe will not close
5328 * when the child process exits and the ReadFile will hang. */
5330 if (!CloseHandle(hChildStdinRd
))
5331 return win32_error("CloseHandle", NULL
);
5333 if (!CloseHandle(hChildStdoutWr
))
5334 return win32_error("CloseHandle", NULL
);
5336 if ((n
!= 4) && (!CloseHandle(hChildStderrWr
)))
5337 return win32_error("CloseHandle", NULL
);
5343 * Wrapper for fclose() to use for popen* files, so we can retrieve the
5344 * exit code for the child process and return as a result of the close.
5346 * This function uses the _PyPopenProcs dictionary in order to map the
5347 * input file pointer to information about the process that was
5348 * originally created by the popen* call that created the file pointer.
5349 * The dictionary uses the file pointer as a key (with one entry
5350 * inserted for each file returned by the original popen* call) and a
5351 * single list object as the value for all files from a single call.
5352 * The list object contains the Win32 process handle at [0], and a file
5353 * count at [1], which is initialized to the total number of file
5354 * handles using that list.
5356 * This function closes whichever handle it is passed, and decrements
5357 * the file count in the dictionary for the process handle pointed to
5358 * by this file. On the last close (when the file count reaches zero),
5359 * this function will wait for the child process and then return its
5360 * exit code as the result of the close() operation. This permits the
5361 * files to be closed in any order - it is always the close() of the
5362 * final handle that will return the exit code.
5364 * NOTE: This function is currently called with the GIL released.
5365 * hence we use the GILState API to manage our state.
5368 static int _PyPclose(FILE *file
)
5373 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
;
5376 PyGILState_STATE state
;
5379 /* Close the file handle first, to ensure it can't block the
5380 * child from exiting if it's the last handle.
5382 result
= fclose(file
);
5384 state
= PyGILState_Ensure();
5386 if (_PyPopenProcs
) {
5387 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
5388 (procObj
= PyDict_GetItem(_PyPopenProcs
,
5389 fileObj
)) != NULL
&&
5390 (hProcessObj
= PyList_GetItem(procObj
,0)) != NULL
&&
5391 (intObj
= PyList_GetItem(procObj
,1)) != NULL
) {
5393 hProcess
= PyLong_AsVoidPtr(hProcessObj
);
5394 file_count
= PyInt_AsLong(intObj
);
5396 if (file_count
> 1) {
5397 /* Still other files referencing process */
5399 PyList_SetItem(procObj
,1,
5400 PyInt_FromLong(file_count
));
5402 /* Last file for this process */
5403 if (result
!= EOF
&&
5404 WaitForSingleObject(hProcess
, INFINITE
) != WAIT_FAILED
&&
5405 GetExitCodeProcess(hProcess
, &exit_code
)) {
5406 /* Possible truncation here in 16-bit environments, but
5407 * real exit codes are just the lower byte in any event.
5411 /* Indicate failure - this will cause the file object
5412 * to raise an I/O error and translate the last Win32
5413 * error code from errno. We do have a problem with
5414 * last errors that overlap the normal errno table,
5415 * but that's a consistent problem with the file object.
5417 if (result
!= EOF
) {
5418 /* If the error wasn't from the fclose(), then
5419 * set errno for the file object error handling.
5421 errno
= GetLastError();
5426 /* Free up the native handle at this point */
5427 CloseHandle(hProcess
);
5430 /* Remove this file pointer from dictionary */
5431 PyDict_DelItem(_PyPopenProcs
, fileObj
);
5433 if (PyDict_Size(_PyPopenProcs
) == 0) {
5434 Py_DECREF(_PyPopenProcs
);
5435 _PyPopenProcs
= NULL
;
5438 } /* if object retrieval ok */
5440 Py_XDECREF(fileObj
);
5441 } /* if _PyPopenProcs */
5444 PyGILState_Release(state
);
5449 #else /* which OS? */
5451 posix_popen(PyObject
*self
, PyObject
*args
)
5458 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
5460 /* Strip mode of binary or text modifiers */
5461 if (strcmp(mode
, "rb") == 0 || strcmp(mode
, "rt") == 0)
5463 else if (strcmp(mode
, "wb") == 0 || strcmp(mode
, "wt") == 0)
5465 Py_BEGIN_ALLOW_THREADS
5466 fp
= popen(name
, mode
);
5467 Py_END_ALLOW_THREADS
5469 return posix_error();
5470 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
5472 PyFile_SetBufSize(f
, bufsize
);
5476 #endif /* PYOS_??? */
5477 #endif /* HAVE_POPEN */
5481 PyDoc_STRVAR(posix_setuid__doc__
,
5483 Set the current process's user id.");
5486 posix_setuid(PyObject
*self
, PyObject
*args
)
5489 if (!PyArg_ParseTuple(args
, "i:setuid", &uid
))
5491 if (setuid(uid
) < 0)
5492 return posix_error();
5496 #endif /* HAVE_SETUID */
5500 PyDoc_STRVAR(posix_seteuid__doc__
,
5502 Set the current process's effective user id.");
5505 posix_seteuid (PyObject
*self
, PyObject
*args
)
5508 if (!PyArg_ParseTuple(args
, "i", &euid
)) {
5510 } else if (seteuid(euid
) < 0) {
5511 return posix_error();
5517 #endif /* HAVE_SETEUID */
5520 PyDoc_STRVAR(posix_setegid__doc__
,
5522 Set the current process's effective group id.");
5525 posix_setegid (PyObject
*self
, PyObject
*args
)
5528 if (!PyArg_ParseTuple(args
, "i", &egid
)) {
5530 } else if (setegid(egid
) < 0) {
5531 return posix_error();
5537 #endif /* HAVE_SETEGID */
5539 #ifdef HAVE_SETREUID
5540 PyDoc_STRVAR(posix_setreuid__doc__
,
5541 "setreuid(ruid, euid)\n\n\
5542 Set the current process's real and effective user ids.");
5545 posix_setreuid (PyObject
*self
, PyObject
*args
)
5548 if (!PyArg_ParseTuple(args
, "ii", &ruid
, &euid
)) {
5550 } else if (setreuid(ruid
, euid
) < 0) {
5551 return posix_error();
5557 #endif /* HAVE_SETREUID */
5559 #ifdef HAVE_SETREGID
5560 PyDoc_STRVAR(posix_setregid__doc__
,
5561 "setregid(rgid, egid)\n\n\
5562 Set the current process's real and effective group ids.");
5565 posix_setregid (PyObject
*self
, PyObject
*args
)
5568 if (!PyArg_ParseTuple(args
, "ii", &rgid
, &egid
)) {
5570 } else if (setregid(rgid
, egid
) < 0) {
5571 return posix_error();
5577 #endif /* HAVE_SETREGID */
5580 PyDoc_STRVAR(posix_setgid__doc__
,
5582 Set the current process's group id.");
5585 posix_setgid(PyObject
*self
, PyObject
*args
)
5588 if (!PyArg_ParseTuple(args
, "i:setgid", &gid
))
5590 if (setgid(gid
) < 0)
5591 return posix_error();
5595 #endif /* HAVE_SETGID */
5597 #ifdef HAVE_SETGROUPS
5598 PyDoc_STRVAR(posix_setgroups__doc__
,
5599 "setgroups(list)\n\n\
5600 Set the groups of the current process to list.");
5603 posix_setgroups(PyObject
*self
, PyObject
*groups
)
5606 gid_t grouplist
[MAX_GROUPS
];
5608 if (!PySequence_Check(groups
)) {
5609 PyErr_SetString(PyExc_TypeError
, "setgroups argument must be a sequence");
5612 len
= PySequence_Size(groups
);
5613 if (len
> MAX_GROUPS
) {
5614 PyErr_SetString(PyExc_ValueError
, "too many groups");
5617 for(i
= 0; i
< len
; i
++) {
5619 elem
= PySequence_GetItem(groups
, i
);
5622 if (!PyInt_Check(elem
)) {
5623 if (!PyLong_Check(elem
)) {
5624 PyErr_SetString(PyExc_TypeError
,
5625 "groups must be integers");
5629 unsigned long x
= PyLong_AsUnsignedLong(elem
);
5630 if (PyErr_Occurred()) {
5631 PyErr_SetString(PyExc_TypeError
,
5632 "group id too big");
5637 /* read back the value to see if it fitted in gid_t */
5638 if (grouplist
[i
] != x
) {
5639 PyErr_SetString(PyExc_TypeError
,
5640 "group id too big");
5646 long x
= PyInt_AsLong(elem
);
5648 if (grouplist
[i
] != x
) {
5649 PyErr_SetString(PyExc_TypeError
,
5650 "group id too big");
5658 if (setgroups(len
, grouplist
) < 0)
5659 return posix_error();
5663 #endif /* HAVE_SETGROUPS */
5665 #if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
5667 wait_helper(pid_t pid
, int status
, struct rusage
*ru
)
5670 static PyObject
*struct_rusage
;
5673 return posix_error();
5675 if (struct_rusage
== NULL
) {
5676 PyObject
*m
= PyImport_ImportModuleNoBlock("resource");
5679 struct_rusage
= PyObject_GetAttrString(m
, "struct_rusage");
5681 if (struct_rusage
== NULL
)
5685 /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
5686 result
= PyStructSequence_New((PyTypeObject
*) struct_rusage
);
5691 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
5694 PyStructSequence_SET_ITEM(result
, 0,
5695 PyFloat_FromDouble(doubletime(ru
->ru_utime
)));
5696 PyStructSequence_SET_ITEM(result
, 1,
5697 PyFloat_FromDouble(doubletime(ru
->ru_stime
)));
5698 #define SET_INT(result, index, value)\
5699 PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))
5700 SET_INT(result
, 2, ru
->ru_maxrss
);
5701 SET_INT(result
, 3, ru
->ru_ixrss
);
5702 SET_INT(result
, 4, ru
->ru_idrss
);
5703 SET_INT(result
, 5, ru
->ru_isrss
);
5704 SET_INT(result
, 6, ru
->ru_minflt
);
5705 SET_INT(result
, 7, ru
->ru_majflt
);
5706 SET_INT(result
, 8, ru
->ru_nswap
);
5707 SET_INT(result
, 9, ru
->ru_inblock
);
5708 SET_INT(result
, 10, ru
->ru_oublock
);
5709 SET_INT(result
, 11, ru
->ru_msgsnd
);
5710 SET_INT(result
, 12, ru
->ru_msgrcv
);
5711 SET_INT(result
, 13, ru
->ru_nsignals
);
5712 SET_INT(result
, 14, ru
->ru_nvcsw
);
5713 SET_INT(result
, 15, ru
->ru_nivcsw
);
5716 if (PyErr_Occurred()) {
5721 return Py_BuildValue("iiN", pid
, status
, result
);
5723 #endif /* HAVE_WAIT3 || HAVE_WAIT4 */
5726 PyDoc_STRVAR(posix_wait3__doc__
,
5727 "wait3(options) -> (pid, status, rusage)\n\n\
5728 Wait for completion of a child process.");
5731 posix_wait3(PyObject
*self
, PyObject
*args
)
5737 WAIT_STATUS_INT(status
) = 0;
5739 if (!PyArg_ParseTuple(args
, "i:wait3", &options
))
5742 Py_BEGIN_ALLOW_THREADS
5743 pid
= wait3(&status
, options
, &ru
);
5744 Py_END_ALLOW_THREADS
5746 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5748 #endif /* HAVE_WAIT3 */
5751 PyDoc_STRVAR(posix_wait4__doc__
,
5752 "wait4(pid, options) -> (pid, status, rusage)\n\n\
5753 Wait for completion of a given child process.");
5756 posix_wait4(PyObject
*self
, PyObject
*args
)
5762 WAIT_STATUS_INT(status
) = 0;
5764 if (!PyArg_ParseTuple(args
, "ii:wait4", &pid
, &options
))
5767 Py_BEGIN_ALLOW_THREADS
5768 pid
= wait4(pid
, &status
, options
, &ru
);
5769 Py_END_ALLOW_THREADS
5771 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5773 #endif /* HAVE_WAIT4 */
5776 PyDoc_STRVAR(posix_waitpid__doc__
,
5777 "waitpid(pid, options) -> (pid, status)\n\n\
5778 Wait for completion of a given child process.");
5781 posix_waitpid(PyObject
*self
, PyObject
*args
)
5786 WAIT_STATUS_INT(status
) = 0;
5788 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5790 Py_BEGIN_ALLOW_THREADS
5791 pid
= waitpid(pid
, &status
, options
);
5792 Py_END_ALLOW_THREADS
5794 return posix_error();
5796 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5799 #elif defined(HAVE_CWAIT)
5801 /* MS C has a variant of waitpid() that's usable for most purposes. */
5802 PyDoc_STRVAR(posix_waitpid__doc__
,
5803 "waitpid(pid, options) -> (pid, status << 8)\n\n"
5804 "Wait for completion of a given process. options is ignored on Windows.");
5807 posix_waitpid(PyObject
*self
, PyObject
*args
)
5810 int status
, options
;
5812 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5814 Py_BEGIN_ALLOW_THREADS
5815 pid
= _cwait(&status
, pid
, options
);
5816 Py_END_ALLOW_THREADS
5818 return posix_error();
5820 /* shift the status left a byte so this is more like the POSIX waitpid */
5821 return Py_BuildValue("ii", pid
, status
<< 8);
5823 #endif /* HAVE_WAITPID || HAVE_CWAIT */
5826 PyDoc_STRVAR(posix_wait__doc__
,
5827 "wait() -> (pid, status)\n\n\
5828 Wait for completion of a child process.");
5831 posix_wait(PyObject
*self
, PyObject
*noargs
)
5835 WAIT_STATUS_INT(status
) = 0;
5837 Py_BEGIN_ALLOW_THREADS
5838 pid
= wait(&status
);
5839 Py_END_ALLOW_THREADS
5841 return posix_error();
5843 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5848 PyDoc_STRVAR(posix_lstat__doc__
,
5849 "lstat(path) -> stat result\n\n\
5850 Like stat(path), but do not follow symbolic links.");
5853 posix_lstat(PyObject
*self
, PyObject
*args
)
5856 return posix_do_stat(self
, args
, "et:lstat", lstat
, NULL
, NULL
);
5857 #else /* !HAVE_LSTAT */
5859 return posix_do_stat(self
, args
, "et:lstat", STAT
, "U:lstat", win32_wstat
);
5861 return posix_do_stat(self
, args
, "et:lstat", STAT
, NULL
, NULL
);
5863 #endif /* !HAVE_LSTAT */
5867 #ifdef HAVE_READLINK
5868 PyDoc_STRVAR(posix_readlink__doc__
,
5869 "readlink(path) -> path\n\n\
5870 Return a string representing the path to which the symbolic link points.");
5873 posix_readlink(PyObject
*self
, PyObject
*args
)
5876 char buf
[MAXPATHLEN
];
5879 #ifdef Py_USING_UNICODE
5880 int arg_is_unicode
= 0;
5883 if (!PyArg_ParseTuple(args
, "et:readlink",
5884 Py_FileSystemDefaultEncoding
, &path
))
5886 #ifdef Py_USING_UNICODE
5887 v
= PySequence_GetItem(args
, 0);
5893 if (PyUnicode_Check(v
)) {
5899 Py_BEGIN_ALLOW_THREADS
5900 n
= readlink(path
, buf
, (int) sizeof buf
);
5901 Py_END_ALLOW_THREADS
5903 return posix_error_with_allocated_filename(path
);
5906 v
= PyString_FromStringAndSize(buf
, n
);
5907 #ifdef Py_USING_UNICODE
5908 if (arg_is_unicode
) {
5911 w
= PyUnicode_FromEncodedObject(v
,
5912 Py_FileSystemDefaultEncoding
,
5919 /* fall back to the original byte string, as
5920 discussed in patch #683592 */
5927 #endif /* HAVE_READLINK */
5931 PyDoc_STRVAR(posix_symlink__doc__
,
5932 "symlink(src, dst)\n\n\
5933 Create a symbolic link pointing to src named dst.");
5936 posix_symlink(PyObject
*self
, PyObject
*args
)
5938 return posix_2str(args
, "etet:symlink", symlink
);
5940 #endif /* HAVE_SYMLINK */
5945 #define HZ 60 /* Universal constant :-) */
5948 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
5954 Py_BEGIN_ALLOW_THREADS
5955 DosQuerySysInfo(QSV_MS_COUNT
, QSV_MS_COUNT
, &value
, sizeof(value
));
5956 Py_END_ALLOW_THREADS
5962 posix_times(PyObject
*self
, PyObject
*noargs
)
5964 /* Currently Only Uptime is Provided -- Others Later */
5965 return Py_BuildValue("ddddd",
5966 (double)0 /* t.tms_utime / HZ */,
5967 (double)0 /* t.tms_stime / HZ */,
5968 (double)0 /* t.tms_cutime / HZ */,
5969 (double)0 /* t.tms_cstime / HZ */,
5970 (double)system_uptime() / 1000);
5974 posix_times(PyObject
*self
, PyObject
*noargs
)
5980 if (c
== (clock_t) -1)
5981 return posix_error();
5982 return Py_BuildValue("ddddd",
5983 (double)t
.tms_utime
/ HZ
,
5984 (double)t
.tms_stime
/ HZ
,
5985 (double)t
.tms_cutime
/ HZ
,
5986 (double)t
.tms_cstime
/ HZ
,
5989 #endif /* not OS2 */
5990 #endif /* HAVE_TIMES */
5994 #define HAVE_TIMES /* so the method table will pick it up */
5996 posix_times(PyObject
*self
, PyObject
*noargs
)
5998 FILETIME create
, exit
, kernel
, user
;
6000 hProc
= GetCurrentProcess();
6001 GetProcessTimes(hProc
, &create
, &exit
, &kernel
, &user
);
6002 /* The fields of a FILETIME structure are the hi and lo part
6003 of a 64-bit value expressed in 100 nanosecond units.
6004 1e7 is one second in such units; 1e-7 the inverse.
6005 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
6007 return Py_BuildValue(
6009 (double)(user
.dwHighDateTime
*429.4967296 +
6010 user
.dwLowDateTime
*1e-7),
6011 (double)(kernel
.dwHighDateTime
*429.4967296 +
6012 kernel
.dwLowDateTime
*1e-7),
6017 #endif /* MS_WINDOWS */
6020 PyDoc_STRVAR(posix_times__doc__
,
6021 "times() -> (utime, stime, cutime, cstime, elapsed_time)\n\n\
6022 Return a tuple of floating point numbers indicating process times.");
6027 PyDoc_STRVAR(posix_getsid__doc__
,
6028 "getsid(pid) -> sid\n\n\
6029 Call the system call getsid().");
6032 posix_getsid(PyObject
*self
, PyObject
*args
)
6036 if (!PyArg_ParseTuple(args
, "i:getsid", &pid
))
6040 return posix_error();
6041 return PyInt_FromLong((long)sid
);
6043 #endif /* HAVE_GETSID */
6047 PyDoc_STRVAR(posix_setsid__doc__
,
6049 Call the system call setsid().");
6052 posix_setsid(PyObject
*self
, PyObject
*noargs
)
6055 return posix_error();
6059 #endif /* HAVE_SETSID */
6062 PyDoc_STRVAR(posix_setpgid__doc__
,
6063 "setpgid(pid, pgrp)\n\n\
6064 Call the system call setpgid().");
6067 posix_setpgid(PyObject
*self
, PyObject
*args
)
6071 if (!PyArg_ParseTuple(args
, "ii:setpgid", &pid
, &pgrp
))
6073 if (setpgid(pid
, pgrp
) < 0)
6074 return posix_error();
6078 #endif /* HAVE_SETPGID */
6081 #ifdef HAVE_TCGETPGRP
6082 PyDoc_STRVAR(posix_tcgetpgrp__doc__
,
6083 "tcgetpgrp(fd) -> pgid\n\n\
6084 Return the process group associated with the terminal given by a fd.");
6087 posix_tcgetpgrp(PyObject
*self
, PyObject
*args
)
6091 if (!PyArg_ParseTuple(args
, "i:tcgetpgrp", &fd
))
6093 pgid
= tcgetpgrp(fd
);
6095 return posix_error();
6096 return PyInt_FromLong((long)pgid
);
6098 #endif /* HAVE_TCGETPGRP */
6101 #ifdef HAVE_TCSETPGRP
6102 PyDoc_STRVAR(posix_tcsetpgrp__doc__
,
6103 "tcsetpgrp(fd, pgid)\n\n\
6104 Set the process group associated with the terminal given by a fd.");
6107 posix_tcsetpgrp(PyObject
*self
, PyObject
*args
)
6110 if (!PyArg_ParseTuple(args
, "ii:tcsetpgrp", &fd
, &pgid
))
6112 if (tcsetpgrp(fd
, pgid
) < 0)
6113 return posix_error();
6117 #endif /* HAVE_TCSETPGRP */
6119 /* Functions acting on file descriptors */
6121 PyDoc_STRVAR(posix_open__doc__
,
6122 "open(filename, flag [, mode=0777]) -> fd\n\n\
6123 Open a file (for low level IO).");
6126 posix_open(PyObject
*self
, PyObject
*args
)
6134 if (unicode_file_names()) {
6135 PyUnicodeObject
*po
;
6136 if (PyArg_ParseTuple(args
, "Ui|i:mkdir", &po
, &flag
, &mode
)) {
6137 Py_BEGIN_ALLOW_THREADS
6138 /* PyUnicode_AS_UNICODE OK without thread
6139 lock as it is a simple dereference. */
6140 fd
= _wopen(PyUnicode_AS_UNICODE(po
), flag
, mode
);
6141 Py_END_ALLOW_THREADS
6143 return posix_error();
6144 return PyInt_FromLong((long)fd
);
6146 /* Drop the argument parsing error as narrow strings
6152 if (!PyArg_ParseTuple(args
, "eti|i",
6153 Py_FileSystemDefaultEncoding
, &file
,
6157 Py_BEGIN_ALLOW_THREADS
6158 fd
= open(file
, flag
, mode
);
6159 Py_END_ALLOW_THREADS
6161 return posix_error_with_allocated_filename(file
);
6163 return PyInt_FromLong((long)fd
);
6167 PyDoc_STRVAR(posix_close__doc__
,
6169 Close a file descriptor (for low level IO).");
6172 posix_close(PyObject
*self
, PyObject
*args
)
6175 if (!PyArg_ParseTuple(args
, "i:close", &fd
))
6177 Py_BEGIN_ALLOW_THREADS
6179 Py_END_ALLOW_THREADS
6181 return posix_error();
6187 PyDoc_STRVAR(posix_closerange__doc__
,
6188 "closerange(fd_low, fd_high)\n\n\
6189 Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
6192 posix_closerange(PyObject
*self
, PyObject
*args
)
6194 int fd_from
, fd_to
, i
;
6195 if (!PyArg_ParseTuple(args
, "ii:closerange", &fd_from
, &fd_to
))
6197 Py_BEGIN_ALLOW_THREADS
6198 for (i
= fd_from
; i
< fd_to
; i
++)
6200 Py_END_ALLOW_THREADS
6205 PyDoc_STRVAR(posix_dup__doc__
,
6206 "dup(fd) -> fd2\n\n\
6207 Return a duplicate of a file descriptor.");
6210 posix_dup(PyObject
*self
, PyObject
*args
)
6213 if (!PyArg_ParseTuple(args
, "i:dup", &fd
))
6215 Py_BEGIN_ALLOW_THREADS
6217 Py_END_ALLOW_THREADS
6219 return posix_error();
6220 return PyInt_FromLong((long)fd
);
6224 PyDoc_STRVAR(posix_dup2__doc__
,
6225 "dup2(old_fd, new_fd)\n\n\
6226 Duplicate file descriptor.");
6229 posix_dup2(PyObject
*self
, PyObject
*args
)
6232 if (!PyArg_ParseTuple(args
, "ii:dup2", &fd
, &fd2
))
6234 Py_BEGIN_ALLOW_THREADS
6235 res
= dup2(fd
, fd2
);
6236 Py_END_ALLOW_THREADS
6238 return posix_error();
6244 PyDoc_STRVAR(posix_lseek__doc__
,
6245 "lseek(fd, pos, how) -> newpos\n\n\
6246 Set the current position of a file descriptor.");
6249 posix_lseek(PyObject
*self
, PyObject
*args
)
6252 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6253 PY_LONG_LONG pos
, res
;
6258 if (!PyArg_ParseTuple(args
, "iOi:lseek", &fd
, &posobj
, &how
))
6261 /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
6263 case 0: how
= SEEK_SET
; break;
6264 case 1: how
= SEEK_CUR
; break;
6265 case 2: how
= SEEK_END
; break;
6267 #endif /* SEEK_END */
6269 #if !defined(HAVE_LARGEFILE_SUPPORT)
6270 pos
= PyInt_AsLong(posobj
);
6272 pos
= PyLong_Check(posobj
) ?
6273 PyLong_AsLongLong(posobj
) : PyInt_AsLong(posobj
);
6275 if (PyErr_Occurred())
6278 Py_BEGIN_ALLOW_THREADS
6279 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6280 res
= _lseeki64(fd
, pos
, how
);
6282 res
= lseek(fd
, pos
, how
);
6284 Py_END_ALLOW_THREADS
6286 return posix_error();
6288 #if !defined(HAVE_LARGEFILE_SUPPORT)
6289 return PyInt_FromLong(res
);
6291 return PyLong_FromLongLong(res
);
6296 PyDoc_STRVAR(posix_read__doc__
,
6297 "read(fd, buffersize) -> string\n\n\
6298 Read a file descriptor.");
6301 posix_read(PyObject
*self
, PyObject
*args
)
6305 if (!PyArg_ParseTuple(args
, "ii:read", &fd
, &size
))
6309 return posix_error();
6311 buffer
= PyString_FromStringAndSize((char *)NULL
, size
);
6314 Py_BEGIN_ALLOW_THREADS
6315 n
= read(fd
, PyString_AsString(buffer
), size
);
6316 Py_END_ALLOW_THREADS
6319 return posix_error();
6322 _PyString_Resize(&buffer
, n
);
6327 PyDoc_STRVAR(posix_write__doc__
,
6328 "write(fd, string) -> byteswritten\n\n\
6329 Write a string to a file descriptor.");
6332 posix_write(PyObject
*self
, PyObject
*args
)
6338 if (!PyArg_ParseTuple(args
, "is#:write", &fd
, &buffer
, &size
))
6340 Py_BEGIN_ALLOW_THREADS
6341 size
= write(fd
, buffer
, (size_t)size
);
6342 Py_END_ALLOW_THREADS
6344 return posix_error();
6345 return PyInt_FromSsize_t(size
);
6349 PyDoc_STRVAR(posix_fstat__doc__
,
6350 "fstat(fd) -> stat result\n\n\
6351 Like stat(), but for an open file descriptor.");
6354 posix_fstat(PyObject
*self
, PyObject
*args
)
6359 if (!PyArg_ParseTuple(args
, "i:fstat", &fd
))
6362 /* on OpenVMS we must ensure that all bytes are written to the file */
6365 Py_BEGIN_ALLOW_THREADS
6366 res
= FSTAT(fd
, &st
);
6367 Py_END_ALLOW_THREADS
6370 return win32_error("fstat", NULL
);
6372 return posix_error();
6376 return _pystat_fromstructstat(&st
);
6380 PyDoc_STRVAR(posix_fdopen__doc__
,
6381 "fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\n\
6382 Return an open file object connected to a file descriptor.");
6385 posix_fdopen(PyObject
*self
, PyObject
*args
)
6388 char *orgmode
= "r";
6393 if (!PyArg_ParseTuple(args
, "i|si", &fd
, &orgmode
, &bufsize
))
6396 /* Sanitize mode. See fileobject.c */
6397 mode
= PyMem_MALLOC(strlen(orgmode
)+3);
6402 strcpy(mode
, orgmode
);
6403 if (_PyFile_SanitizeMode(mode
)) {
6407 Py_BEGIN_ALLOW_THREADS
6408 #if !defined(MS_WINDOWS) && defined(HAVE_FCNTL_H)
6409 if (mode
[0] == 'a') {
6410 /* try to make sure the O_APPEND flag is set */
6412 flags
= fcntl(fd
, F_GETFL
);
6414 fcntl(fd
, F_SETFL
, flags
| O_APPEND
);
6415 fp
= fdopen(fd
, mode
);
6416 if (fp
== NULL
&& flags
!= -1)
6417 /* restore old mode if fdopen failed */
6418 fcntl(fd
, F_SETFL
, flags
);
6420 fp
= fdopen(fd
, mode
);
6423 fp
= fdopen(fd
, mode
);
6425 Py_END_ALLOW_THREADS
6428 return posix_error();
6429 f
= PyFile_FromFile(fp
, "<fdopen>", orgmode
, fclose
);
6431 PyFile_SetBufSize(f
, bufsize
);
6435 PyDoc_STRVAR(posix_isatty__doc__
,
6436 "isatty(fd) -> bool\n\n\
6437 Return True if the file descriptor 'fd' is an open file descriptor\n\
6438 connected to the slave end of a terminal.");
6441 posix_isatty(PyObject
*self
, PyObject
*args
)
6444 if (!PyArg_ParseTuple(args
, "i:isatty", &fd
))
6446 return PyBool_FromLong(isatty(fd
));
6450 PyDoc_STRVAR(posix_pipe__doc__
,
6451 "pipe() -> (read_end, write_end)\n\n\
6455 posix_pipe(PyObject
*self
, PyObject
*noargs
)
6457 #if defined(PYOS_OS2)
6461 Py_BEGIN_ALLOW_THREADS
6462 rc
= DosCreatePipe( &read
, &write
, 4096);
6463 Py_END_ALLOW_THREADS
6465 return os2_error(rc
);
6467 return Py_BuildValue("(ii)", read
, write
);
6469 #if !defined(MS_WINDOWS)
6472 Py_BEGIN_ALLOW_THREADS
6474 Py_END_ALLOW_THREADS
6476 return posix_error();
6477 return Py_BuildValue("(ii)", fds
[0], fds
[1]);
6478 #else /* MS_WINDOWS */
6480 int read_fd
, write_fd
;
6482 Py_BEGIN_ALLOW_THREADS
6483 ok
= CreatePipe(&read
, &write
, NULL
, 0);
6484 Py_END_ALLOW_THREADS
6486 return win32_error("CreatePipe", NULL
);
6487 read_fd
= _open_osfhandle((Py_intptr_t
)read
, 0);
6488 write_fd
= _open_osfhandle((Py_intptr_t
)write
, 1);
6489 return Py_BuildValue("(ii)", read_fd
, write_fd
);
6490 #endif /* MS_WINDOWS */
6493 #endif /* HAVE_PIPE */
6497 PyDoc_STRVAR(posix_mkfifo__doc__
,
6498 "mkfifo(filename [, mode=0666])\n\n\
6499 Create a FIFO (a POSIX named pipe).");
6502 posix_mkfifo(PyObject
*self
, PyObject
*args
)
6507 if (!PyArg_ParseTuple(args
, "s|i:mkfifo", &filename
, &mode
))
6509 Py_BEGIN_ALLOW_THREADS
6510 res
= mkfifo(filename
, mode
);
6511 Py_END_ALLOW_THREADS
6513 return posix_error();
6520 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
6521 PyDoc_STRVAR(posix_mknod__doc__
,
6522 "mknod(filename [, mode=0600, device])\n\n\
6523 Create a filesystem node (file, device special file or named pipe)\n\
6524 named filename. mode specifies both the permissions to use and the\n\
6525 type of node to be created, being combined (bitwise OR) with one of\n\
6526 S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\n\
6527 device defines the newly created device special file (probably using\n\
6528 os.makedev()), otherwise it is ignored.");
6532 posix_mknod(PyObject
*self
, PyObject
*args
)
6538 if (!PyArg_ParseTuple(args
, "s|ii:mknod", &filename
, &mode
, &device
))
6540 Py_BEGIN_ALLOW_THREADS
6541 res
= mknod(filename
, mode
, device
);
6542 Py_END_ALLOW_THREADS
6544 return posix_error();
6550 #ifdef HAVE_DEVICE_MACROS
6551 PyDoc_STRVAR(posix_major__doc__
,
6552 "major(device) -> major number\n\
6553 Extracts a device major number from a raw device number.");
6556 posix_major(PyObject
*self
, PyObject
*args
)
6559 if (!PyArg_ParseTuple(args
, "i:major", &device
))
6561 return PyInt_FromLong((long)major(device
));
6564 PyDoc_STRVAR(posix_minor__doc__
,
6565 "minor(device) -> minor number\n\
6566 Extracts a device minor number from a raw device number.");
6569 posix_minor(PyObject
*self
, PyObject
*args
)
6572 if (!PyArg_ParseTuple(args
, "i:minor", &device
))
6574 return PyInt_FromLong((long)minor(device
));
6577 PyDoc_STRVAR(posix_makedev__doc__
,
6578 "makedev(major, minor) -> device number\n\
6579 Composes a raw device number from the major and minor device numbers.");
6582 posix_makedev(PyObject
*self
, PyObject
*args
)
6585 if (!PyArg_ParseTuple(args
, "ii:makedev", &major
, &minor
))
6587 return PyInt_FromLong((long)makedev(major
, minor
));
6589 #endif /* device macros */
6592 #ifdef HAVE_FTRUNCATE
6593 PyDoc_STRVAR(posix_ftruncate__doc__
,
6594 "ftruncate(fd, length)\n\n\
6595 Truncate a file to a specified length.");
6598 posix_ftruncate(PyObject
*self
, PyObject
*args
)
6605 if (!PyArg_ParseTuple(args
, "iO:ftruncate", &fd
, &lenobj
))
6608 #if !defined(HAVE_LARGEFILE_SUPPORT)
6609 length
= PyInt_AsLong(lenobj
);
6611 length
= PyLong_Check(lenobj
) ?
6612 PyLong_AsLongLong(lenobj
) : PyInt_AsLong(lenobj
);
6614 if (PyErr_Occurred())
6617 Py_BEGIN_ALLOW_THREADS
6618 res
= ftruncate(fd
, length
);
6619 Py_END_ALLOW_THREADS
6621 PyErr_SetFromErrno(PyExc_IOError
);
6630 PyDoc_STRVAR(posix_putenv__doc__
,
6631 "putenv(key, value)\n\n\
6632 Change or add an environment variable.");
6634 /* Save putenv() parameters as values here, so we can collect them when they
6635 * get re-set with another call for the same key. */
6636 static PyObject
*posix_putenv_garbage
;
6639 posix_putenv(PyObject
*self
, PyObject
*args
)
6646 if (!PyArg_ParseTuple(args
, "ss:putenv", &s1
, &s2
))
6649 #if defined(PYOS_OS2)
6650 if (stricmp(s1
, "BEGINLIBPATH") == 0) {
6653 rc
= DosSetExtLIBPATH(s2
, BEGIN_LIBPATH
);
6655 return os2_error(rc
);
6657 } else if (stricmp(s1
, "ENDLIBPATH") == 0) {
6660 rc
= DosSetExtLIBPATH(s2
, END_LIBPATH
);
6662 return os2_error(rc
);
6666 /* XXX This can leak memory -- not easy to fix :-( */
6667 len
= strlen(s1
) + strlen(s2
) + 2;
6668 /* len includes space for a trailing \0; the size arg to
6669 PyString_FromStringAndSize does not count that */
6670 newstr
= PyString_FromStringAndSize(NULL
, (int)len
- 1);
6672 return PyErr_NoMemory();
6673 newenv
= PyString_AS_STRING(newstr
);
6674 PyOS_snprintf(newenv
, len
, "%s=%s", s1
, s2
);
6675 if (putenv(newenv
)) {
6680 /* Install the first arg and newstr in posix_putenv_garbage;
6681 * this will cause previous value to be collected. This has to
6682 * happen after the real putenv() call because the old value
6683 * was still accessible until then. */
6684 if (PyDict_SetItem(posix_putenv_garbage
,
6685 PyTuple_GET_ITEM(args
, 0), newstr
)) {
6686 /* really not much we can do; just leak */
6693 #if defined(PYOS_OS2)
6701 #ifdef HAVE_UNSETENV
6702 PyDoc_STRVAR(posix_unsetenv__doc__
,
6704 Delete an environment variable.");
6707 posix_unsetenv(PyObject
*self
, PyObject
*args
)
6711 if (!PyArg_ParseTuple(args
, "s:unsetenv", &s1
))
6716 /* Remove the key from posix_putenv_garbage;
6717 * this will cause it to be collected. This has to
6718 * happen after the real unsetenv() call because the
6719 * old value was still accessible until then.
6721 if (PyDict_DelItem(posix_putenv_garbage
,
6722 PyTuple_GET_ITEM(args
, 0))) {
6723 /* really not much we can do; just leak */
6730 #endif /* unsetenv */
6732 PyDoc_STRVAR(posix_strerror__doc__
,
6733 "strerror(code) -> string\n\n\
6734 Translate an error code to a message string.");
6737 posix_strerror(PyObject
*self
, PyObject
*args
)
6741 if (!PyArg_ParseTuple(args
, "i:strerror", &code
))
6743 message
= strerror(code
);
6744 if (message
== NULL
) {
6745 PyErr_SetString(PyExc_ValueError
,
6746 "strerror() argument out of range");
6749 return PyString_FromString(message
);
6753 #ifdef HAVE_SYS_WAIT_H
6756 PyDoc_STRVAR(posix_WCOREDUMP__doc__
,
6757 "WCOREDUMP(status) -> bool\n\n\
6758 Return True if the process returning 'status' was dumped to a core file.");
6761 posix_WCOREDUMP(PyObject
*self
, PyObject
*args
)
6764 WAIT_STATUS_INT(status
) = 0;
6766 if (!PyArg_ParseTuple(args
, "i:WCOREDUMP", &WAIT_STATUS_INT(status
)))
6769 return PyBool_FromLong(WCOREDUMP(status
));
6771 #endif /* WCOREDUMP */
6774 PyDoc_STRVAR(posix_WIFCONTINUED__doc__
,
6775 "WIFCONTINUED(status) -> bool\n\n\
6776 Return True if the process returning 'status' was continued from a\n\
6777 job control stop.");
6780 posix_WIFCONTINUED(PyObject
*self
, PyObject
*args
)
6783 WAIT_STATUS_INT(status
) = 0;
6785 if (!PyArg_ParseTuple(args
, "i:WCONTINUED", &WAIT_STATUS_INT(status
)))
6788 return PyBool_FromLong(WIFCONTINUED(status
));
6790 #endif /* WIFCONTINUED */
6793 PyDoc_STRVAR(posix_WIFSTOPPED__doc__
,
6794 "WIFSTOPPED(status) -> bool\n\n\
6795 Return True if the process returning 'status' was stopped.");
6798 posix_WIFSTOPPED(PyObject
*self
, PyObject
*args
)
6801 WAIT_STATUS_INT(status
) = 0;
6803 if (!PyArg_ParseTuple(args
, "i:WIFSTOPPED", &WAIT_STATUS_INT(status
)))
6806 return PyBool_FromLong(WIFSTOPPED(status
));
6808 #endif /* WIFSTOPPED */
6811 PyDoc_STRVAR(posix_WIFSIGNALED__doc__
,
6812 "WIFSIGNALED(status) -> bool\n\n\
6813 Return True if the process returning 'status' was terminated by a signal.");
6816 posix_WIFSIGNALED(PyObject
*self
, PyObject
*args
)
6819 WAIT_STATUS_INT(status
) = 0;
6821 if (!PyArg_ParseTuple(args
, "i:WIFSIGNALED", &WAIT_STATUS_INT(status
)))
6824 return PyBool_FromLong(WIFSIGNALED(status
));
6826 #endif /* WIFSIGNALED */
6829 PyDoc_STRVAR(posix_WIFEXITED__doc__
,
6830 "WIFEXITED(status) -> bool\n\n\
6831 Return true if the process returning 'status' exited using the exit()\n\
6835 posix_WIFEXITED(PyObject
*self
, PyObject
*args
)
6838 WAIT_STATUS_INT(status
) = 0;
6840 if (!PyArg_ParseTuple(args
, "i:WIFEXITED", &WAIT_STATUS_INT(status
)))
6843 return PyBool_FromLong(WIFEXITED(status
));
6845 #endif /* WIFEXITED */
6848 PyDoc_STRVAR(posix_WEXITSTATUS__doc__
,
6849 "WEXITSTATUS(status) -> integer\n\n\
6850 Return the process return code from 'status'.");
6853 posix_WEXITSTATUS(PyObject
*self
, PyObject
*args
)
6856 WAIT_STATUS_INT(status
) = 0;
6858 if (!PyArg_ParseTuple(args
, "i:WEXITSTATUS", &WAIT_STATUS_INT(status
)))
6861 return Py_BuildValue("i", WEXITSTATUS(status
));
6863 #endif /* WEXITSTATUS */
6866 PyDoc_STRVAR(posix_WTERMSIG__doc__
,
6867 "WTERMSIG(status) -> integer\n\n\
6868 Return the signal that terminated the process that provided the 'status'\n\
6872 posix_WTERMSIG(PyObject
*self
, PyObject
*args
)
6875 WAIT_STATUS_INT(status
) = 0;
6877 if (!PyArg_ParseTuple(args
, "i:WTERMSIG", &WAIT_STATUS_INT(status
)))
6880 return Py_BuildValue("i", WTERMSIG(status
));
6882 #endif /* WTERMSIG */
6885 PyDoc_STRVAR(posix_WSTOPSIG__doc__
,
6886 "WSTOPSIG(status) -> integer\n\n\
6887 Return the signal that stopped the process that provided\n\
6888 the 'status' value.");
6891 posix_WSTOPSIG(PyObject
*self
, PyObject
*args
)
6894 WAIT_STATUS_INT(status
) = 0;
6896 if (!PyArg_ParseTuple(args
, "i:WSTOPSIG", &WAIT_STATUS_INT(status
)))
6899 return Py_BuildValue("i", WSTOPSIG(status
));
6901 #endif /* WSTOPSIG */
6903 #endif /* HAVE_SYS_WAIT_H */
6906 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
6908 /* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the
6909 needed definitions in sys/statvfs.h */
6912 #include <sys/statvfs.h>
6915 _pystatvfs_fromstructstatvfs(struct statvfs st
) {
6916 PyObject
*v
= PyStructSequence_New(&StatVFSResultType
);
6920 #if !defined(HAVE_LARGEFILE_SUPPORT)
6921 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
6922 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
6923 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long) st
.f_blocks
));
6924 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long) st
.f_bfree
));
6925 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long) st
.f_bavail
));
6926 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long) st
.f_files
));
6927 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong((long) st
.f_ffree
));
6928 PyStructSequence_SET_ITEM(v
, 7, PyInt_FromLong((long) st
.f_favail
));
6929 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
6930 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
6932 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
6933 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
6934 PyStructSequence_SET_ITEM(v
, 2,
6935 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_blocks
));
6936 PyStructSequence_SET_ITEM(v
, 3,
6937 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bfree
));
6938 PyStructSequence_SET_ITEM(v
, 4,
6939 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bavail
));
6940 PyStructSequence_SET_ITEM(v
, 5,
6941 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_files
));
6942 PyStructSequence_SET_ITEM(v
, 6,
6943 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_ffree
));
6944 PyStructSequence_SET_ITEM(v
, 7,
6945 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_favail
));
6946 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
6947 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
6953 PyDoc_STRVAR(posix_fstatvfs__doc__
,
6954 "fstatvfs(fd) -> statvfs result\n\n\
6955 Perform an fstatvfs system call on the given fd.");
6958 posix_fstatvfs(PyObject
*self
, PyObject
*args
)
6963 if (!PyArg_ParseTuple(args
, "i:fstatvfs", &fd
))
6965 Py_BEGIN_ALLOW_THREADS
6966 res
= fstatvfs(fd
, &st
);
6967 Py_END_ALLOW_THREADS
6969 return posix_error();
6971 return _pystatvfs_fromstructstatvfs(st
);
6973 #endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */
6976 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
6977 #include <sys/statvfs.h>
6979 PyDoc_STRVAR(posix_statvfs__doc__
,
6980 "statvfs(path) -> statvfs result\n\n\
6981 Perform a statvfs system call on the given path.");
6984 posix_statvfs(PyObject
*self
, PyObject
*args
)
6989 if (!PyArg_ParseTuple(args
, "s:statvfs", &path
))
6991 Py_BEGIN_ALLOW_THREADS
6992 res
= statvfs(path
, &st
);
6993 Py_END_ALLOW_THREADS
6995 return posix_error_with_filename(path
);
6997 return _pystatvfs_fromstructstatvfs(st
);
6999 #endif /* HAVE_STATVFS */
7003 PyDoc_STRVAR(posix_tempnam__doc__
,
7004 "tempnam([dir[, prefix]]) -> string\n\n\
7005 Return a unique name for a temporary file.\n\
7006 The directory and a prefix may be specified as strings; they may be omitted\n\
7007 or None if not needed.");
7010 posix_tempnam(PyObject
*self
, PyObject
*args
)
7012 PyObject
*result
= NULL
;
7017 if (!PyArg_ParseTuple(args
, "|zz:tempnam", &dir
, &pfx
))
7020 if (PyErr_Warn(PyExc_RuntimeWarning
,
7021 "tempnam is a potential security risk to your program") < 0)
7025 name
= _tempnam(dir
, pfx
);
7027 name
= tempnam(dir
, pfx
);
7030 return PyErr_NoMemory();
7031 result
= PyString_FromString(name
);
7039 PyDoc_STRVAR(posix_tmpfile__doc__
,
7040 "tmpfile() -> file object\n\n\
7041 Create a temporary file with no directory entries.");
7044 posix_tmpfile(PyObject
*self
, PyObject
*noargs
)
7050 return posix_error();
7051 return PyFile_FromFile(fp
, "<tmpfile>", "w+b", fclose
);
7057 PyDoc_STRVAR(posix_tmpnam__doc__
,
7058 "tmpnam() -> string\n\n\
7059 Return a unique name for a temporary file.");
7062 posix_tmpnam(PyObject
*self
, PyObject
*noargs
)
7064 char buffer
[L_tmpnam
];
7067 if (PyErr_Warn(PyExc_RuntimeWarning
,
7068 "tmpnam is a potential security risk to your program") < 0)
7072 name
= tmpnam_r(buffer
);
7074 name
= tmpnam(buffer
);
7077 PyObject
*err
= Py_BuildValue("is", 0,
7079 "unexpected NULL from tmpnam_r"
7081 "unexpected NULL from tmpnam"
7084 PyErr_SetObject(PyExc_OSError
, err
);
7088 return PyString_FromString(buffer
);
7093 /* This is used for fpathconf(), pathconf(), confstr() and sysconf().
7094 * It maps strings representing configuration variable names to
7095 * integer values, allowing those functions to be called with the
7096 * magic names instead of polluting the module's namespace with tons of
7097 * rarely-used constants. There are three separate tables that use
7098 * these definitions.
7100 * This code is always included, even if none of the interfaces that
7101 * need it are included. The #if hackery needed to avoid it would be
7102 * sufficiently pervasive that it's not worth the loss of readability.
7110 conv_confname(PyObject
*arg
, int *valuep
, struct constdef
*table
,
7113 if (PyInt_Check(arg
)) {
7114 *valuep
= PyInt_AS_LONG(arg
);
7117 if (PyString_Check(arg
)) {
7118 /* look up the value in the table using a binary search */
7121 size_t hi
= tablesize
;
7123 char *confname
= PyString_AS_STRING(arg
);
7125 mid
= (lo
+ hi
) / 2;
7126 cmp
= strcmp(confname
, table
[mid
].name
);
7132 *valuep
= table
[mid
].value
;
7136 PyErr_SetString(PyExc_ValueError
, "unrecognized configuration name");
7139 PyErr_SetString(PyExc_TypeError
,
7140 "configuration names must be strings or integers");
7145 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
7146 static struct constdef posix_constants_pathconf
[] = {
7147 #ifdef _PC_ABI_AIO_XFER_MAX
7148 {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX
},
7150 #ifdef _PC_ABI_ASYNC_IO
7151 {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO
},
7154 {"PC_ASYNC_IO", _PC_ASYNC_IO
},
7156 #ifdef _PC_CHOWN_RESTRICTED
7157 {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED
},
7159 #ifdef _PC_FILESIZEBITS
7160 {"PC_FILESIZEBITS", _PC_FILESIZEBITS
},
7163 {"PC_LAST", _PC_LAST
},
7166 {"PC_LINK_MAX", _PC_LINK_MAX
},
7168 #ifdef _PC_MAX_CANON
7169 {"PC_MAX_CANON", _PC_MAX_CANON
},
7171 #ifdef _PC_MAX_INPUT
7172 {"PC_MAX_INPUT", _PC_MAX_INPUT
},
7175 {"PC_NAME_MAX", _PC_NAME_MAX
},
7178 {"PC_NO_TRUNC", _PC_NO_TRUNC
},
7181 {"PC_PATH_MAX", _PC_PATH_MAX
},
7184 {"PC_PIPE_BUF", _PC_PIPE_BUF
},
7187 {"PC_PRIO_IO", _PC_PRIO_IO
},
7189 #ifdef _PC_SOCK_MAXBUF
7190 {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF
},
7193 {"PC_SYNC_IO", _PC_SYNC_IO
},
7196 {"PC_VDISABLE", _PC_VDISABLE
},
7201 conv_path_confname(PyObject
*arg
, int *valuep
)
7203 return conv_confname(arg
, valuep
, posix_constants_pathconf
,
7204 sizeof(posix_constants_pathconf
)
7205 / sizeof(struct constdef
));
7209 #ifdef HAVE_FPATHCONF
7210 PyDoc_STRVAR(posix_fpathconf__doc__
,
7211 "fpathconf(fd, name) -> integer\n\n\
7212 Return the configuration limit name for the file descriptor fd.\n\
7213 If there is no limit, return -1.");
7216 posix_fpathconf(PyObject
*self
, PyObject
*args
)
7218 PyObject
*result
= NULL
;
7221 if (PyArg_ParseTuple(args
, "iO&:fpathconf", &fd
,
7222 conv_path_confname
, &name
)) {
7226 limit
= fpathconf(fd
, name
);
7227 if (limit
== -1 && errno
!= 0)
7230 result
= PyInt_FromLong(limit
);
7237 #ifdef HAVE_PATHCONF
7238 PyDoc_STRVAR(posix_pathconf__doc__
,
7239 "pathconf(path, name) -> integer\n\n\
7240 Return the configuration limit name for the file or directory path.\n\
7241 If there is no limit, return -1.");
7244 posix_pathconf(PyObject
*self
, PyObject
*args
)
7246 PyObject
*result
= NULL
;
7250 if (PyArg_ParseTuple(args
, "sO&:pathconf", &path
,
7251 conv_path_confname
, &name
)) {
7255 limit
= pathconf(path
, name
);
7256 if (limit
== -1 && errno
!= 0) {
7257 if (errno
== EINVAL
)
7258 /* could be a path or name problem */
7261 posix_error_with_filename(path
);
7264 result
= PyInt_FromLong(limit
);
7271 static struct constdef posix_constants_confstr
[] = {
7272 #ifdef _CS_ARCHITECTURE
7273 {"CS_ARCHITECTURE", _CS_ARCHITECTURE
},
7276 {"CS_HOSTNAME", _CS_HOSTNAME
},
7278 #ifdef _CS_HW_PROVIDER
7279 {"CS_HW_PROVIDER", _CS_HW_PROVIDER
},
7281 #ifdef _CS_HW_SERIAL
7282 {"CS_HW_SERIAL", _CS_HW_SERIAL
},
7284 #ifdef _CS_INITTAB_NAME
7285 {"CS_INITTAB_NAME", _CS_INITTAB_NAME
},
7287 #ifdef _CS_LFS64_CFLAGS
7288 {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS
},
7290 #ifdef _CS_LFS64_LDFLAGS
7291 {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS
},
7293 #ifdef _CS_LFS64_LIBS
7294 {"CS_LFS64_LIBS", _CS_LFS64_LIBS
},
7296 #ifdef _CS_LFS64_LINTFLAGS
7297 {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS
},
7299 #ifdef _CS_LFS_CFLAGS
7300 {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS
},
7302 #ifdef _CS_LFS_LDFLAGS
7303 {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS
},
7306 {"CS_LFS_LIBS", _CS_LFS_LIBS
},
7308 #ifdef _CS_LFS_LINTFLAGS
7309 {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS
},
7312 {"CS_MACHINE", _CS_MACHINE
},
7315 {"CS_PATH", _CS_PATH
},
7318 {"CS_RELEASE", _CS_RELEASE
},
7320 #ifdef _CS_SRPC_DOMAIN
7321 {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN
},
7324 {"CS_SYSNAME", _CS_SYSNAME
},
7327 {"CS_VERSION", _CS_VERSION
},
7329 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
7330 {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS
},
7332 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
7333 {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS
},
7335 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
7336 {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS
},
7338 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
7339 {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS
},
7341 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
7342 {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS
},
7344 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
7345 {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS
},
7347 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
7348 {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS
},
7350 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
7351 {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
},
7353 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
7354 {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS
},
7356 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
7357 {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS
},
7359 #ifdef _CS_XBS5_LP64_OFF64_LIBS
7360 {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS
},
7362 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
7363 {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS
},
7365 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
7366 {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS
},
7368 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
7369 {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
},
7371 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
7372 {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS
},
7374 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
7375 {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
},
7377 #ifdef _MIPS_CS_AVAIL_PROCESSORS
7378 {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS
},
7380 #ifdef _MIPS_CS_BASE
7381 {"MIPS_CS_BASE", _MIPS_CS_BASE
},
7383 #ifdef _MIPS_CS_HOSTID
7384 {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID
},
7386 #ifdef _MIPS_CS_HW_NAME
7387 {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME
},
7389 #ifdef _MIPS_CS_NUM_PROCESSORS
7390 {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS
},
7392 #ifdef _MIPS_CS_OSREL_MAJ
7393 {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ
},
7395 #ifdef _MIPS_CS_OSREL_MIN
7396 {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN
},
7398 #ifdef _MIPS_CS_OSREL_PATCH
7399 {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH
},
7401 #ifdef _MIPS_CS_OS_NAME
7402 {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME
},
7404 #ifdef _MIPS_CS_OS_PROVIDER
7405 {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER
},
7407 #ifdef _MIPS_CS_PROCESSORS
7408 {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS
},
7410 #ifdef _MIPS_CS_SERIAL
7411 {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL
},
7413 #ifdef _MIPS_CS_VENDOR
7414 {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR
},
7419 conv_confstr_confname(PyObject
*arg
, int *valuep
)
7421 return conv_confname(arg
, valuep
, posix_constants_confstr
,
7422 sizeof(posix_constants_confstr
)
7423 / sizeof(struct constdef
));
7426 PyDoc_STRVAR(posix_confstr__doc__
,
7427 "confstr(name) -> string\n\n\
7428 Return a string-valued system configuration variable.");
7431 posix_confstr(PyObject
*self
, PyObject
*args
)
7433 PyObject
*result
= NULL
;
7437 if (PyArg_ParseTuple(args
, "O&:confstr", conv_confstr_confname
, &name
)) {
7441 len
= confstr(name
, buffer
, sizeof(buffer
));
7452 if ((unsigned int)len
>= sizeof(buffer
)) {
7453 result
= PyString_FromStringAndSize(NULL
, len
-1);
7455 confstr(name
, PyString_AS_STRING(result
), len
);
7458 result
= PyString_FromStringAndSize(buffer
, len
-1);
7467 static struct constdef posix_constants_sysconf
[] = {
7468 #ifdef _SC_2_CHAR_TERM
7469 {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM
},
7472 {"SC_2_C_BIND", _SC_2_C_BIND
},
7475 {"SC_2_C_DEV", _SC_2_C_DEV
},
7477 #ifdef _SC_2_C_VERSION
7478 {"SC_2_C_VERSION", _SC_2_C_VERSION
},
7480 #ifdef _SC_2_FORT_DEV
7481 {"SC_2_FORT_DEV", _SC_2_FORT_DEV
},
7483 #ifdef _SC_2_FORT_RUN
7484 {"SC_2_FORT_RUN", _SC_2_FORT_RUN
},
7486 #ifdef _SC_2_LOCALEDEF
7487 {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF
},
7490 {"SC_2_SW_DEV", _SC_2_SW_DEV
},
7493 {"SC_2_UPE", _SC_2_UPE
},
7495 #ifdef _SC_2_VERSION
7496 {"SC_2_VERSION", _SC_2_VERSION
},
7498 #ifdef _SC_ABI_ASYNCHRONOUS_IO
7499 {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO
},
7502 {"SC_ACL", _SC_ACL
},
7504 #ifdef _SC_AIO_LISTIO_MAX
7505 {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX
},
7508 {"SC_AIO_MAX", _SC_AIO_MAX
},
7510 #ifdef _SC_AIO_PRIO_DELTA_MAX
7511 {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX
},
7514 {"SC_ARG_MAX", _SC_ARG_MAX
},
7516 #ifdef _SC_ASYNCHRONOUS_IO
7517 {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO
},
7519 #ifdef _SC_ATEXIT_MAX
7520 {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX
},
7523 {"SC_AUDIT", _SC_AUDIT
},
7525 #ifdef _SC_AVPHYS_PAGES
7526 {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES
},
7528 #ifdef _SC_BC_BASE_MAX
7529 {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX
},
7531 #ifdef _SC_BC_DIM_MAX
7532 {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX
},
7534 #ifdef _SC_BC_SCALE_MAX
7535 {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX
},
7537 #ifdef _SC_BC_STRING_MAX
7538 {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX
},
7541 {"SC_CAP", _SC_CAP
},
7543 #ifdef _SC_CHARCLASS_NAME_MAX
7544 {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX
},
7547 {"SC_CHAR_BIT", _SC_CHAR_BIT
},
7550 {"SC_CHAR_MAX", _SC_CHAR_MAX
},
7553 {"SC_CHAR_MIN", _SC_CHAR_MIN
},
7555 #ifdef _SC_CHILD_MAX
7556 {"SC_CHILD_MAX", _SC_CHILD_MAX
},
7559 {"SC_CLK_TCK", _SC_CLK_TCK
},
7561 #ifdef _SC_COHER_BLKSZ
7562 {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ
},
7564 #ifdef _SC_COLL_WEIGHTS_MAX
7565 {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX
},
7567 #ifdef _SC_DCACHE_ASSOC
7568 {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC
},
7570 #ifdef _SC_DCACHE_BLKSZ
7571 {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ
},
7573 #ifdef _SC_DCACHE_LINESZ
7574 {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ
},
7576 #ifdef _SC_DCACHE_SZ
7577 {"SC_DCACHE_SZ", _SC_DCACHE_SZ
},
7579 #ifdef _SC_DCACHE_TBLKSZ
7580 {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ
},
7582 #ifdef _SC_DELAYTIMER_MAX
7583 {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX
},
7585 #ifdef _SC_EQUIV_CLASS_MAX
7586 {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX
},
7588 #ifdef _SC_EXPR_NEST_MAX
7589 {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX
},
7592 {"SC_FSYNC", _SC_FSYNC
},
7594 #ifdef _SC_GETGR_R_SIZE_MAX
7595 {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX
},
7597 #ifdef _SC_GETPW_R_SIZE_MAX
7598 {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX
},
7600 #ifdef _SC_ICACHE_ASSOC
7601 {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC
},
7603 #ifdef _SC_ICACHE_BLKSZ
7604 {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ
},
7606 #ifdef _SC_ICACHE_LINESZ
7607 {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ
},
7609 #ifdef _SC_ICACHE_SZ
7610 {"SC_ICACHE_SZ", _SC_ICACHE_SZ
},
7613 {"SC_INF", _SC_INF
},
7616 {"SC_INT_MAX", _SC_INT_MAX
},
7619 {"SC_INT_MIN", _SC_INT_MIN
},
7622 {"SC_IOV_MAX", _SC_IOV_MAX
},
7624 #ifdef _SC_IP_SECOPTS
7625 {"SC_IP_SECOPTS", _SC_IP_SECOPTS
},
7627 #ifdef _SC_JOB_CONTROL
7628 {"SC_JOB_CONTROL", _SC_JOB_CONTROL
},
7630 #ifdef _SC_KERN_POINTERS
7631 {"SC_KERN_POINTERS", _SC_KERN_POINTERS
},
7634 {"SC_KERN_SIM", _SC_KERN_SIM
},
7637 {"SC_LINE_MAX", _SC_LINE_MAX
},
7639 #ifdef _SC_LOGIN_NAME_MAX
7640 {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX
},
7642 #ifdef _SC_LOGNAME_MAX
7643 {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX
},
7646 {"SC_LONG_BIT", _SC_LONG_BIT
},
7649 {"SC_MAC", _SC_MAC
},
7651 #ifdef _SC_MAPPED_FILES
7652 {"SC_MAPPED_FILES", _SC_MAPPED_FILES
},
7655 {"SC_MAXPID", _SC_MAXPID
},
7657 #ifdef _SC_MB_LEN_MAX
7658 {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX
},
7661 {"SC_MEMLOCK", _SC_MEMLOCK
},
7663 #ifdef _SC_MEMLOCK_RANGE
7664 {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE
},
7666 #ifdef _SC_MEMORY_PROTECTION
7667 {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION
},
7669 #ifdef _SC_MESSAGE_PASSING
7670 {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING
},
7672 #ifdef _SC_MMAP_FIXED_ALIGNMENT
7673 {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT
},
7675 #ifdef _SC_MQ_OPEN_MAX
7676 {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX
},
7678 #ifdef _SC_MQ_PRIO_MAX
7679 {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX
},
7681 #ifdef _SC_NACLS_MAX
7682 {"SC_NACLS_MAX", _SC_NACLS_MAX
},
7684 #ifdef _SC_NGROUPS_MAX
7685 {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX
},
7687 #ifdef _SC_NL_ARGMAX
7688 {"SC_NL_ARGMAX", _SC_NL_ARGMAX
},
7690 #ifdef _SC_NL_LANGMAX
7691 {"SC_NL_LANGMAX", _SC_NL_LANGMAX
},
7693 #ifdef _SC_NL_MSGMAX
7694 {"SC_NL_MSGMAX", _SC_NL_MSGMAX
},
7697 {"SC_NL_NMAX", _SC_NL_NMAX
},
7699 #ifdef _SC_NL_SETMAX
7700 {"SC_NL_SETMAX", _SC_NL_SETMAX
},
7702 #ifdef _SC_NL_TEXTMAX
7703 {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX
},
7705 #ifdef _SC_NPROCESSORS_CONF
7706 {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF
},
7708 #ifdef _SC_NPROCESSORS_ONLN
7709 {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN
},
7711 #ifdef _SC_NPROC_CONF
7712 {"SC_NPROC_CONF", _SC_NPROC_CONF
},
7714 #ifdef _SC_NPROC_ONLN
7715 {"SC_NPROC_ONLN", _SC_NPROC_ONLN
},
7718 {"SC_NZERO", _SC_NZERO
},
7721 {"SC_OPEN_MAX", _SC_OPEN_MAX
},
7724 {"SC_PAGESIZE", _SC_PAGESIZE
},
7726 #ifdef _SC_PAGE_SIZE
7727 {"SC_PAGE_SIZE", _SC_PAGE_SIZE
},
7730 {"SC_PASS_MAX", _SC_PASS_MAX
},
7732 #ifdef _SC_PHYS_PAGES
7733 {"SC_PHYS_PAGES", _SC_PHYS_PAGES
},
7736 {"SC_PII", _SC_PII
},
7738 #ifdef _SC_PII_INTERNET
7739 {"SC_PII_INTERNET", _SC_PII_INTERNET
},
7741 #ifdef _SC_PII_INTERNET_DGRAM
7742 {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM
},
7744 #ifdef _SC_PII_INTERNET_STREAM
7745 {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM
},
7748 {"SC_PII_OSI", _SC_PII_OSI
},
7750 #ifdef _SC_PII_OSI_CLTS
7751 {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS
},
7753 #ifdef _SC_PII_OSI_COTS
7754 {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS
},
7756 #ifdef _SC_PII_OSI_M
7757 {"SC_PII_OSI_M", _SC_PII_OSI_M
},
7759 #ifdef _SC_PII_SOCKET
7760 {"SC_PII_SOCKET", _SC_PII_SOCKET
},
7763 {"SC_PII_XTI", _SC_PII_XTI
},
7766 {"SC_POLL", _SC_POLL
},
7768 #ifdef _SC_PRIORITIZED_IO
7769 {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO
},
7771 #ifdef _SC_PRIORITY_SCHEDULING
7772 {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING
},
7774 #ifdef _SC_REALTIME_SIGNALS
7775 {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS
},
7777 #ifdef _SC_RE_DUP_MAX
7778 {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX
},
7780 #ifdef _SC_RTSIG_MAX
7781 {"SC_RTSIG_MAX", _SC_RTSIG_MAX
},
7783 #ifdef _SC_SAVED_IDS
7784 {"SC_SAVED_IDS", _SC_SAVED_IDS
},
7786 #ifdef _SC_SCHAR_MAX
7787 {"SC_SCHAR_MAX", _SC_SCHAR_MAX
},
7789 #ifdef _SC_SCHAR_MIN
7790 {"SC_SCHAR_MIN", _SC_SCHAR_MIN
},
7793 {"SC_SELECT", _SC_SELECT
},
7795 #ifdef _SC_SEMAPHORES
7796 {"SC_SEMAPHORES", _SC_SEMAPHORES
},
7798 #ifdef _SC_SEM_NSEMS_MAX
7799 {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX
},
7801 #ifdef _SC_SEM_VALUE_MAX
7802 {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX
},
7804 #ifdef _SC_SHARED_MEMORY_OBJECTS
7805 {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS
},
7808 {"SC_SHRT_MAX", _SC_SHRT_MAX
},
7811 {"SC_SHRT_MIN", _SC_SHRT_MIN
},
7813 #ifdef _SC_SIGQUEUE_MAX
7814 {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX
},
7816 #ifdef _SC_SIGRT_MAX
7817 {"SC_SIGRT_MAX", _SC_SIGRT_MAX
},
7819 #ifdef _SC_SIGRT_MIN
7820 {"SC_SIGRT_MIN", _SC_SIGRT_MIN
},
7822 #ifdef _SC_SOFTPOWER
7823 {"SC_SOFTPOWER", _SC_SOFTPOWER
},
7825 #ifdef _SC_SPLIT_CACHE
7826 {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE
},
7828 #ifdef _SC_SSIZE_MAX
7829 {"SC_SSIZE_MAX", _SC_SSIZE_MAX
},
7831 #ifdef _SC_STACK_PROT
7832 {"SC_STACK_PROT", _SC_STACK_PROT
},
7834 #ifdef _SC_STREAM_MAX
7835 {"SC_STREAM_MAX", _SC_STREAM_MAX
},
7837 #ifdef _SC_SYNCHRONIZED_IO
7838 {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO
},
7841 {"SC_THREADS", _SC_THREADS
},
7843 #ifdef _SC_THREAD_ATTR_STACKADDR
7844 {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR
},
7846 #ifdef _SC_THREAD_ATTR_STACKSIZE
7847 {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE
},
7849 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
7850 {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS
},
7852 #ifdef _SC_THREAD_KEYS_MAX
7853 {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX
},
7855 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
7856 {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING
},
7858 #ifdef _SC_THREAD_PRIO_INHERIT
7859 {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT
},
7861 #ifdef _SC_THREAD_PRIO_PROTECT
7862 {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT
},
7864 #ifdef _SC_THREAD_PROCESS_SHARED
7865 {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED
},
7867 #ifdef _SC_THREAD_SAFE_FUNCTIONS
7868 {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS
},
7870 #ifdef _SC_THREAD_STACK_MIN
7871 {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN
},
7873 #ifdef _SC_THREAD_THREADS_MAX
7874 {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX
},
7877 {"SC_TIMERS", _SC_TIMERS
},
7879 #ifdef _SC_TIMER_MAX
7880 {"SC_TIMER_MAX", _SC_TIMER_MAX
},
7882 #ifdef _SC_TTY_NAME_MAX
7883 {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX
},
7885 #ifdef _SC_TZNAME_MAX
7886 {"SC_TZNAME_MAX", _SC_TZNAME_MAX
},
7888 #ifdef _SC_T_IOV_MAX
7889 {"SC_T_IOV_MAX", _SC_T_IOV_MAX
},
7891 #ifdef _SC_UCHAR_MAX
7892 {"SC_UCHAR_MAX", _SC_UCHAR_MAX
},
7895 {"SC_UINT_MAX", _SC_UINT_MAX
},
7897 #ifdef _SC_UIO_MAXIOV
7898 {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV
},
7900 #ifdef _SC_ULONG_MAX
7901 {"SC_ULONG_MAX", _SC_ULONG_MAX
},
7903 #ifdef _SC_USHRT_MAX
7904 {"SC_USHRT_MAX", _SC_USHRT_MAX
},
7907 {"SC_VERSION", _SC_VERSION
},
7910 {"SC_WORD_BIT", _SC_WORD_BIT
},
7912 #ifdef _SC_XBS5_ILP32_OFF32
7913 {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32
},
7915 #ifdef _SC_XBS5_ILP32_OFFBIG
7916 {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG
},
7918 #ifdef _SC_XBS5_LP64_OFF64
7919 {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64
},
7921 #ifdef _SC_XBS5_LPBIG_OFFBIG
7922 {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG
},
7924 #ifdef _SC_XOPEN_CRYPT
7925 {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT
},
7927 #ifdef _SC_XOPEN_ENH_I18N
7928 {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N
},
7930 #ifdef _SC_XOPEN_LEGACY
7931 {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY
},
7933 #ifdef _SC_XOPEN_REALTIME
7934 {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME
},
7936 #ifdef _SC_XOPEN_REALTIME_THREADS
7937 {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS
},
7939 #ifdef _SC_XOPEN_SHM
7940 {"SC_XOPEN_SHM", _SC_XOPEN_SHM
},
7942 #ifdef _SC_XOPEN_UNIX
7943 {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX
},
7945 #ifdef _SC_XOPEN_VERSION
7946 {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION
},
7948 #ifdef _SC_XOPEN_XCU_VERSION
7949 {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION
},
7951 #ifdef _SC_XOPEN_XPG2
7952 {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2
},
7954 #ifdef _SC_XOPEN_XPG3
7955 {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3
},
7957 #ifdef _SC_XOPEN_XPG4
7958 {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4
},
7963 conv_sysconf_confname(PyObject
*arg
, int *valuep
)
7965 return conv_confname(arg
, valuep
, posix_constants_sysconf
,
7966 sizeof(posix_constants_sysconf
)
7967 / sizeof(struct constdef
));
7970 PyDoc_STRVAR(posix_sysconf__doc__
,
7971 "sysconf(name) -> integer\n\n\
7972 Return an integer-valued system configuration variable.");
7975 posix_sysconf(PyObject
*self
, PyObject
*args
)
7977 PyObject
*result
= NULL
;
7980 if (PyArg_ParseTuple(args
, "O&:sysconf", conv_sysconf_confname
, &name
)) {
7984 value
= sysconf(name
);
7985 if (value
== -1 && errno
!= 0)
7988 result
= PyInt_FromLong(value
);
7995 /* This code is used to ensure that the tables of configuration value names
7996 * are in sorted order as required by conv_confname(), and also to build the
7997 * the exported dictionaries that are used to publish information about the
7998 * names available on the host platform.
8000 * Sorting the table at runtime ensures that the table is properly ordered
8001 * when used, even for platforms we're not able to test on. It also makes
8002 * it easier to add additional entries to the tables.
8006 cmp_constdefs(const void *v1
, const void *v2
)
8008 const struct constdef
*c1
=
8009 (const struct constdef
*) v1
;
8010 const struct constdef
*c2
=
8011 (const struct constdef
*) v2
;
8013 return strcmp(c1
->name
, c2
->name
);
8017 setup_confname_table(struct constdef
*table
, size_t tablesize
,
8018 char *tablename
, PyObject
*module
)
8023 qsort(table
, tablesize
, sizeof(struct constdef
), cmp_constdefs
);
8028 for (i
=0; i
< tablesize
; ++i
) {
8029 PyObject
*o
= PyInt_FromLong(table
[i
].value
);
8030 if (o
== NULL
|| PyDict_SetItemString(d
, table
[i
].name
, o
) == -1) {
8037 return PyModule_AddObject(module
, tablename
, d
);
8040 /* Return -1 on failure, 0 on success. */
8042 setup_confname_tables(PyObject
*module
)
8044 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
8045 if (setup_confname_table(posix_constants_pathconf
,
8046 sizeof(posix_constants_pathconf
)
8047 / sizeof(struct constdef
),
8048 "pathconf_names", module
))
8052 if (setup_confname_table(posix_constants_confstr
,
8053 sizeof(posix_constants_confstr
)
8054 / sizeof(struct constdef
),
8055 "confstr_names", module
))
8059 if (setup_confname_table(posix_constants_sysconf
,
8060 sizeof(posix_constants_sysconf
)
8061 / sizeof(struct constdef
),
8062 "sysconf_names", module
))
8069 PyDoc_STRVAR(posix_abort__doc__
,
8070 "abort() -> does not return!\n\n\
8071 Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\
8072 in the hardest way possible on the hosting operating system.");
8075 posix_abort(PyObject
*self
, PyObject
*noargs
)
8079 Py_FatalError("abort() called from Python code didn't abort!");
8084 PyDoc_STRVAR(win32_startfile__doc__
,
8085 "startfile(filepath [, operation]) - Start a file with its associated\n\
8088 When \"operation\" is not specified or \"open\", this acts like\n\
8089 double-clicking the file in Explorer, or giving the file name as an\n\
8090 argument to the DOS \"start\" command: the file is opened with whatever\n\
8091 application (if any) its extension is associated.\n\
8092 When another \"operation\" is given, it specifies what should be done with\n\
8093 the file. A typical operation is \"print\".\n\
8095 startfile returns as soon as the associated application is launched.\n\
8096 There is no option to wait for the application to close, and no way\n\
8097 to retrieve the application's exit status.\n\
8099 The filepath is relative to the current directory. If you want to use\n\
8100 an absolute path, make sure the first character is not a slash (\"/\");\n\
8101 the underlying Win32 ShellExecute function doesn't work if it is.");
8104 win32_startfile(PyObject
*self
, PyObject
*args
)
8107 char *operation
= NULL
;
8109 #ifdef Py_WIN_WIDE_FILENAMES
8110 if (unicode_file_names()) {
8111 PyObject
*unipath
, *woperation
= NULL
;
8112 if (!PyArg_ParseTuple(args
, "U|s:startfile",
8113 &unipath
, &operation
)) {
8120 woperation
= PyUnicode_DecodeASCII(operation
,
8121 strlen(operation
), NULL
);
8129 Py_BEGIN_ALLOW_THREADS
8130 rc
= ShellExecuteW((HWND
)0, woperation
? PyUnicode_AS_UNICODE(woperation
) : 0,
8131 PyUnicode_AS_UNICODE(unipath
),
8132 NULL
, NULL
, SW_SHOWNORMAL
);
8133 Py_END_ALLOW_THREADS
8135 Py_XDECREF(woperation
);
8136 if (rc
<= (HINSTANCE
)32) {
8137 PyObject
*errval
= win32_error_unicode("startfile",
8138 PyUnicode_AS_UNICODE(unipath
));
8147 if (!PyArg_ParseTuple(args
, "et|s:startfile",
8148 Py_FileSystemDefaultEncoding
, &filepath
,
8151 Py_BEGIN_ALLOW_THREADS
8152 rc
= ShellExecute((HWND
)0, operation
, filepath
,
8153 NULL
, NULL
, SW_SHOWNORMAL
);
8154 Py_END_ALLOW_THREADS
8155 if (rc
<= (HINSTANCE
)32) {
8156 PyObject
*errval
= win32_error("startfile", filepath
);
8157 PyMem_Free(filepath
);
8160 PyMem_Free(filepath
);
8166 #ifdef HAVE_GETLOADAVG
8167 PyDoc_STRVAR(posix_getloadavg__doc__
,
8168 "getloadavg() -> (float, float, float)\n\n\
8169 Return the number of processes in the system run queue averaged over\n\
8170 the last 1, 5, and 15 minutes or raises OSError if the load average\n\
8174 posix_getloadavg(PyObject
*self
, PyObject
*noargs
)
8177 if (getloadavg(loadavg
, 3)!=3) {
8178 PyErr_SetString(PyExc_OSError
, "Load averages are unobtainable");
8181 return Py_BuildValue("ddd", loadavg
[0], loadavg
[1], loadavg
[2]);
8187 PyDoc_STRVAR(win32_urandom__doc__
,
8188 "urandom(n) -> str\n\n\
8189 Return a string of n random bytes suitable for cryptographic use.");
8191 typedef BOOL (WINAPI
*CRYPTACQUIRECONTEXTA
)(HCRYPTPROV
*phProv
,\
8192 LPCSTR pszContainer
, LPCSTR pszProvider
, DWORD dwProvType
,\
8194 typedef BOOL (WINAPI
*CRYPTGENRANDOM
)(HCRYPTPROV hProv
, DWORD dwLen
,\
8197 static CRYPTGENRANDOM pCryptGenRandom
= NULL
;
8198 /* This handle is never explicitly released. Instead, the operating
8199 system will release it when the process terminates. */
8200 static HCRYPTPROV hCryptProv
= 0;
8203 win32_urandom(PyObject
*self
, PyObject
*args
)
8208 /* Read arguments */
8209 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8212 return PyErr_Format(PyExc_ValueError
,
8213 "negative argument not allowed");
8215 if (hCryptProv
== 0) {
8216 HINSTANCE hAdvAPI32
= NULL
;
8217 CRYPTACQUIRECONTEXTA pCryptAcquireContext
= NULL
;
8219 /* Obtain handle to the DLL containing CryptoAPI
8220 This should not fail */
8221 hAdvAPI32
= GetModuleHandle("advapi32.dll");
8222 if(hAdvAPI32
== NULL
)
8223 return win32_error("GetModuleHandle", NULL
);
8225 /* Obtain pointers to the CryptoAPI functions
8226 This will fail on some early versions of Win95 */
8227 pCryptAcquireContext
= (CRYPTACQUIRECONTEXTA
)GetProcAddress(
8229 "CryptAcquireContextA");
8230 if (pCryptAcquireContext
== NULL
)
8231 return PyErr_Format(PyExc_NotImplementedError
,
8232 "CryptAcquireContextA not found");
8234 pCryptGenRandom
= (CRYPTGENRANDOM
)GetProcAddress(
8235 hAdvAPI32
, "CryptGenRandom");
8236 if (pCryptGenRandom
== NULL
)
8237 return PyErr_Format(PyExc_NotImplementedError
,
8238 "CryptGenRandom not found");
8240 /* Acquire context */
8241 if (! pCryptAcquireContext(&hCryptProv
, NULL
, NULL
,
8242 PROV_RSA_FULL
, CRYPT_VERIFYCONTEXT
))
8243 return win32_error("CryptAcquireContext", NULL
);
8246 /* Allocate bytes */
8247 result
= PyString_FromStringAndSize(NULL
, howMany
);
8248 if (result
!= NULL
) {
8249 /* Get random data */
8250 if (! pCryptGenRandom(hCryptProv
, howMany
, (unsigned char*)
8251 PyString_AS_STRING(result
))) {
8253 return win32_error("CryptGenRandom", NULL
);
8261 /* Use openssl random routine */
8262 #include <openssl/rand.h>
8263 PyDoc_STRVAR(vms_urandom__doc__
,
8264 "urandom(n) -> str\n\n\
8265 Return a string of n random bytes suitable for cryptographic use.");
8268 vms_urandom(PyObject
*self
, PyObject
*args
)
8273 /* Read arguments */
8274 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8277 return PyErr_Format(PyExc_ValueError
,
8278 "negative argument not allowed");
8280 /* Allocate bytes */
8281 result
= PyString_FromStringAndSize(NULL
, howMany
);
8282 if (result
!= NULL
) {
8283 /* Get random data */
8284 if (RAND_pseudo_bytes((unsigned char*)
8285 PyString_AS_STRING(result
),
8288 return PyErr_Format(PyExc_ValueError
,
8289 "RAND_pseudo_bytes");
8296 static PyMethodDef posix_methods
[] = {
8297 {"access", posix_access
, METH_VARARGS
, posix_access__doc__
},
8299 {"ttyname", posix_ttyname
, METH_VARARGS
, posix_ttyname__doc__
},
8301 {"chdir", posix_chdir
, METH_VARARGS
, posix_chdir__doc__
},
8303 {"chflags", posix_chflags
, METH_VARARGS
, posix_chflags__doc__
},
8304 #endif /* HAVE_CHFLAGS */
8305 {"chmod", posix_chmod
, METH_VARARGS
, posix_chmod__doc__
},
8307 {"fchmod", posix_fchmod
, METH_VARARGS
, posix_fchmod__doc__
},
8308 #endif /* HAVE_FCHMOD */
8310 {"chown", posix_chown
, METH_VARARGS
, posix_chown__doc__
},
8311 #endif /* HAVE_CHOWN */
8313 {"lchmod", posix_lchmod
, METH_VARARGS
, posix_lchmod__doc__
},
8314 #endif /* HAVE_LCHMOD */
8316 {"fchown", posix_fchown
, METH_VARARGS
, posix_fchown__doc__
},
8317 #endif /* HAVE_FCHOWN */
8318 #ifdef HAVE_LCHFLAGS
8319 {"lchflags", posix_lchflags
, METH_VARARGS
, posix_lchflags__doc__
},
8320 #endif /* HAVE_LCHFLAGS */
8322 {"lchown", posix_lchown
, METH_VARARGS
, posix_lchown__doc__
},
8323 #endif /* HAVE_LCHOWN */
8325 {"chroot", posix_chroot
, METH_VARARGS
, posix_chroot__doc__
},
8328 {"ctermid", posix_ctermid
, METH_NOARGS
, posix_ctermid__doc__
},
8331 {"getcwd", posix_getcwd
, METH_NOARGS
, posix_getcwd__doc__
},
8332 #ifdef Py_USING_UNICODE
8333 {"getcwdu", posix_getcwdu
, METH_NOARGS
, posix_getcwdu__doc__
},
8337 {"link", posix_link
, METH_VARARGS
, posix_link__doc__
},
8338 #endif /* HAVE_LINK */
8339 {"listdir", posix_listdir
, METH_VARARGS
, posix_listdir__doc__
},
8340 {"lstat", posix_lstat
, METH_VARARGS
, posix_lstat__doc__
},
8341 {"mkdir", posix_mkdir
, METH_VARARGS
, posix_mkdir__doc__
},
8343 {"nice", posix_nice
, METH_VARARGS
, posix_nice__doc__
},
8344 #endif /* HAVE_NICE */
8345 #ifdef HAVE_READLINK
8346 {"readlink", posix_readlink
, METH_VARARGS
, posix_readlink__doc__
},
8347 #endif /* HAVE_READLINK */
8348 {"rename", posix_rename
, METH_VARARGS
, posix_rename__doc__
},
8349 {"rmdir", posix_rmdir
, METH_VARARGS
, posix_rmdir__doc__
},
8350 {"stat", posix_stat
, METH_VARARGS
, posix_stat__doc__
},
8351 {"stat_float_times", stat_float_times
, METH_VARARGS
, stat_float_times__doc__
},
8353 {"symlink", posix_symlink
, METH_VARARGS
, posix_symlink__doc__
},
8354 #endif /* HAVE_SYMLINK */
8356 {"system", posix_system
, METH_VARARGS
, posix_system__doc__
},
8358 {"umask", posix_umask
, METH_VARARGS
, posix_umask__doc__
},
8360 {"uname", posix_uname
, METH_NOARGS
, posix_uname__doc__
},
8361 #endif /* HAVE_UNAME */
8362 {"unlink", posix_unlink
, METH_VARARGS
, posix_unlink__doc__
},
8363 {"remove", posix_unlink
, METH_VARARGS
, posix_remove__doc__
},
8364 {"utime", posix_utime
, METH_VARARGS
, posix_utime__doc__
},
8366 {"times", posix_times
, METH_NOARGS
, posix_times__doc__
},
8367 #endif /* HAVE_TIMES */
8368 {"_exit", posix__exit
, METH_VARARGS
, posix__exit__doc__
},
8370 {"execv", posix_execv
, METH_VARARGS
, posix_execv__doc__
},
8371 {"execve", posix_execve
, METH_VARARGS
, posix_execve__doc__
},
8372 #endif /* HAVE_EXECV */
8374 {"spawnv", posix_spawnv
, METH_VARARGS
, posix_spawnv__doc__
},
8375 {"spawnve", posix_spawnve
, METH_VARARGS
, posix_spawnve__doc__
},
8376 #if defined(PYOS_OS2)
8377 {"spawnvp", posix_spawnvp
, METH_VARARGS
, posix_spawnvp__doc__
},
8378 {"spawnvpe", posix_spawnvpe
, METH_VARARGS
, posix_spawnvpe__doc__
},
8379 #endif /* PYOS_OS2 */
8380 #endif /* HAVE_SPAWNV */
8382 {"fork1", posix_fork1
, METH_NOARGS
, posix_fork1__doc__
},
8383 #endif /* HAVE_FORK1 */
8385 {"fork", posix_fork
, METH_NOARGS
, posix_fork__doc__
},
8386 #endif /* HAVE_FORK */
8387 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
8388 {"openpty", posix_openpty
, METH_NOARGS
, posix_openpty__doc__
},
8389 #endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */
8391 {"forkpty", posix_forkpty
, METH_NOARGS
, posix_forkpty__doc__
},
8392 #endif /* HAVE_FORKPTY */
8394 {"getegid", posix_getegid
, METH_NOARGS
, posix_getegid__doc__
},
8395 #endif /* HAVE_GETEGID */
8397 {"geteuid", posix_geteuid
, METH_NOARGS
, posix_geteuid__doc__
},
8398 #endif /* HAVE_GETEUID */
8400 {"getgid", posix_getgid
, METH_NOARGS
, posix_getgid__doc__
},
8401 #endif /* HAVE_GETGID */
8402 #ifdef HAVE_GETGROUPS
8403 {"getgroups", posix_getgroups
, METH_NOARGS
, posix_getgroups__doc__
},
8405 {"getpid", posix_getpid
, METH_NOARGS
, posix_getpid__doc__
},
8407 {"getpgrp", posix_getpgrp
, METH_NOARGS
, posix_getpgrp__doc__
},
8408 #endif /* HAVE_GETPGRP */
8410 {"getppid", posix_getppid
, METH_NOARGS
, posix_getppid__doc__
},
8411 #endif /* HAVE_GETPPID */
8413 {"getuid", posix_getuid
, METH_NOARGS
, posix_getuid__doc__
},
8414 #endif /* HAVE_GETUID */
8415 #ifdef HAVE_GETLOGIN
8416 {"getlogin", posix_getlogin
, METH_NOARGS
, posix_getlogin__doc__
},
8419 {"kill", posix_kill
, METH_VARARGS
, posix_kill__doc__
},
8420 #endif /* HAVE_KILL */
8422 {"killpg", posix_killpg
, METH_VARARGS
, posix_killpg__doc__
},
8423 #endif /* HAVE_KILLPG */
8425 {"plock", posix_plock
, METH_VARARGS
, posix_plock__doc__
},
8426 #endif /* HAVE_PLOCK */
8428 {"popen", posix_popen
, METH_VARARGS
, posix_popen__doc__
},
8430 {"popen2", win32_popen2
, METH_VARARGS
},
8431 {"popen3", win32_popen3
, METH_VARARGS
},
8432 {"popen4", win32_popen4
, METH_VARARGS
},
8433 {"startfile", win32_startfile
, METH_VARARGS
, win32_startfile__doc__
},
8435 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8436 {"popen2", os2emx_popen2
, METH_VARARGS
},
8437 {"popen3", os2emx_popen3
, METH_VARARGS
},
8438 {"popen4", os2emx_popen4
, METH_VARARGS
},
8441 #endif /* HAVE_POPEN */
8443 {"setuid", posix_setuid
, METH_VARARGS
, posix_setuid__doc__
},
8444 #endif /* HAVE_SETUID */
8446 {"seteuid", posix_seteuid
, METH_VARARGS
, posix_seteuid__doc__
},
8447 #endif /* HAVE_SETEUID */
8449 {"setegid", posix_setegid
, METH_VARARGS
, posix_setegid__doc__
},
8450 #endif /* HAVE_SETEGID */
8451 #ifdef HAVE_SETREUID
8452 {"setreuid", posix_setreuid
, METH_VARARGS
, posix_setreuid__doc__
},
8453 #endif /* HAVE_SETREUID */
8454 #ifdef HAVE_SETREGID
8455 {"setregid", posix_setregid
, METH_VARARGS
, posix_setregid__doc__
},
8456 #endif /* HAVE_SETREGID */
8458 {"setgid", posix_setgid
, METH_VARARGS
, posix_setgid__doc__
},
8459 #endif /* HAVE_SETGID */
8460 #ifdef HAVE_SETGROUPS
8461 {"setgroups", posix_setgroups
, METH_O
, posix_setgroups__doc__
},
8462 #endif /* HAVE_SETGROUPS */
8464 {"getpgid", posix_getpgid
, METH_VARARGS
, posix_getpgid__doc__
},
8465 #endif /* HAVE_GETPGID */
8467 {"setpgrp", posix_setpgrp
, METH_NOARGS
, posix_setpgrp__doc__
},
8468 #endif /* HAVE_SETPGRP */
8470 {"wait", posix_wait
, METH_NOARGS
, posix_wait__doc__
},
8471 #endif /* HAVE_WAIT */
8473 {"wait3", posix_wait3
, METH_VARARGS
, posix_wait3__doc__
},
8474 #endif /* HAVE_WAIT3 */
8476 {"wait4", posix_wait4
, METH_VARARGS
, posix_wait4__doc__
},
8477 #endif /* HAVE_WAIT4 */
8478 #if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)
8479 {"waitpid", posix_waitpid
, METH_VARARGS
, posix_waitpid__doc__
},
8480 #endif /* HAVE_WAITPID */
8482 {"getsid", posix_getsid
, METH_VARARGS
, posix_getsid__doc__
},
8483 #endif /* HAVE_GETSID */
8485 {"setsid", posix_setsid
, METH_NOARGS
, posix_setsid__doc__
},
8486 #endif /* HAVE_SETSID */
8488 {"setpgid", posix_setpgid
, METH_VARARGS
, posix_setpgid__doc__
},
8489 #endif /* HAVE_SETPGID */
8490 #ifdef HAVE_TCGETPGRP
8491 {"tcgetpgrp", posix_tcgetpgrp
, METH_VARARGS
, posix_tcgetpgrp__doc__
},
8492 #endif /* HAVE_TCGETPGRP */
8493 #ifdef HAVE_TCSETPGRP
8494 {"tcsetpgrp", posix_tcsetpgrp
, METH_VARARGS
, posix_tcsetpgrp__doc__
},
8495 #endif /* HAVE_TCSETPGRP */
8496 {"open", posix_open
, METH_VARARGS
, posix_open__doc__
},
8497 {"close", posix_close
, METH_VARARGS
, posix_close__doc__
},
8498 {"closerange", posix_closerange
, METH_VARARGS
, posix_closerange__doc__
},
8499 {"dup", posix_dup
, METH_VARARGS
, posix_dup__doc__
},
8500 {"dup2", posix_dup2
, METH_VARARGS
, posix_dup2__doc__
},
8501 {"lseek", posix_lseek
, METH_VARARGS
, posix_lseek__doc__
},
8502 {"read", posix_read
, METH_VARARGS
, posix_read__doc__
},
8503 {"write", posix_write
, METH_VARARGS
, posix_write__doc__
},
8504 {"fstat", posix_fstat
, METH_VARARGS
, posix_fstat__doc__
},
8505 {"fdopen", posix_fdopen
, METH_VARARGS
, posix_fdopen__doc__
},
8506 {"isatty", posix_isatty
, METH_VARARGS
, posix_isatty__doc__
},
8508 {"pipe", posix_pipe
, METH_NOARGS
, posix_pipe__doc__
},
8511 {"mkfifo", posix_mkfifo
, METH_VARARGS
, posix_mkfifo__doc__
},
8513 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
8514 {"mknod", posix_mknod
, METH_VARARGS
, posix_mknod__doc__
},
8516 #ifdef HAVE_DEVICE_MACROS
8517 {"major", posix_major
, METH_VARARGS
, posix_major__doc__
},
8518 {"minor", posix_minor
, METH_VARARGS
, posix_minor__doc__
},
8519 {"makedev", posix_makedev
, METH_VARARGS
, posix_makedev__doc__
},
8521 #ifdef HAVE_FTRUNCATE
8522 {"ftruncate", posix_ftruncate
, METH_VARARGS
, posix_ftruncate__doc__
},
8525 {"putenv", posix_putenv
, METH_VARARGS
, posix_putenv__doc__
},
8527 #ifdef HAVE_UNSETENV
8528 {"unsetenv", posix_unsetenv
, METH_VARARGS
, posix_unsetenv__doc__
},
8530 {"strerror", posix_strerror
, METH_VARARGS
, posix_strerror__doc__
},
8532 {"fchdir", posix_fchdir
, METH_O
, posix_fchdir__doc__
},
8535 {"fsync", posix_fsync
, METH_O
, posix_fsync__doc__
},
8537 #ifdef HAVE_FDATASYNC
8538 {"fdatasync", posix_fdatasync
, METH_O
, posix_fdatasync__doc__
},
8540 #ifdef HAVE_SYS_WAIT_H
8542 {"WCOREDUMP", posix_WCOREDUMP
, METH_VARARGS
, posix_WCOREDUMP__doc__
},
8543 #endif /* WCOREDUMP */
8545 {"WIFCONTINUED",posix_WIFCONTINUED
, METH_VARARGS
, posix_WIFCONTINUED__doc__
},
8546 #endif /* WIFCONTINUED */
8548 {"WIFSTOPPED", posix_WIFSTOPPED
, METH_VARARGS
, posix_WIFSTOPPED__doc__
},
8549 #endif /* WIFSTOPPED */
8551 {"WIFSIGNALED", posix_WIFSIGNALED
, METH_VARARGS
, posix_WIFSIGNALED__doc__
},
8552 #endif /* WIFSIGNALED */
8554 {"WIFEXITED", posix_WIFEXITED
, METH_VARARGS
, posix_WIFEXITED__doc__
},
8555 #endif /* WIFEXITED */
8557 {"WEXITSTATUS", posix_WEXITSTATUS
, METH_VARARGS
, posix_WEXITSTATUS__doc__
},
8558 #endif /* WEXITSTATUS */
8560 {"WTERMSIG", posix_WTERMSIG
, METH_VARARGS
, posix_WTERMSIG__doc__
},
8561 #endif /* WTERMSIG */
8563 {"WSTOPSIG", posix_WSTOPSIG
, METH_VARARGS
, posix_WSTOPSIG__doc__
},
8564 #endif /* WSTOPSIG */
8565 #endif /* HAVE_SYS_WAIT_H */
8566 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
8567 {"fstatvfs", posix_fstatvfs
, METH_VARARGS
, posix_fstatvfs__doc__
},
8569 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
8570 {"statvfs", posix_statvfs
, METH_VARARGS
, posix_statvfs__doc__
},
8573 {"tmpfile", posix_tmpfile
, METH_NOARGS
, posix_tmpfile__doc__
},
8576 {"tempnam", posix_tempnam
, METH_VARARGS
, posix_tempnam__doc__
},
8579 {"tmpnam", posix_tmpnam
, METH_NOARGS
, posix_tmpnam__doc__
},
8582 {"confstr", posix_confstr
, METH_VARARGS
, posix_confstr__doc__
},
8585 {"sysconf", posix_sysconf
, METH_VARARGS
, posix_sysconf__doc__
},
8587 #ifdef HAVE_FPATHCONF
8588 {"fpathconf", posix_fpathconf
, METH_VARARGS
, posix_fpathconf__doc__
},
8590 #ifdef HAVE_PATHCONF
8591 {"pathconf", posix_pathconf
, METH_VARARGS
, posix_pathconf__doc__
},
8593 {"abort", posix_abort
, METH_NOARGS
, posix_abort__doc__
},
8595 {"_getfullpathname", posix__getfullpathname
, METH_VARARGS
, NULL
},
8597 #ifdef HAVE_GETLOADAVG
8598 {"getloadavg", posix_getloadavg
, METH_NOARGS
, posix_getloadavg__doc__
},
8601 {"urandom", win32_urandom
, METH_VARARGS
, win32_urandom__doc__
},
8604 {"urandom", vms_urandom
, METH_VARARGS
, vms_urandom__doc__
},
8606 {NULL
, NULL
} /* Sentinel */
8611 ins(PyObject
*module
, char *symbol
, long value
)
8613 return PyModule_AddIntConstant(module
, symbol
, value
);
8616 #if defined(PYOS_OS2)
8617 /* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */
8618 static int insertvalues(PyObject
*module
)
8621 ULONG values
[QSV_MAX
+1];
8625 Py_BEGIN_ALLOW_THREADS
8626 rc
= DosQuerySysInfo(1L, QSV_MAX
, &values
[1], sizeof(ULONG
) * QSV_MAX
);
8627 Py_END_ALLOW_THREADS
8629 if (rc
!= NO_ERROR
) {
8634 if (ins(module
, "meminstalled", values
[QSV_TOTPHYSMEM
])) return -1;
8635 if (ins(module
, "memkernel", values
[QSV_TOTRESMEM
])) return -1;
8636 if (ins(module
, "memvirtual", values
[QSV_TOTAVAILMEM
])) return -1;
8637 if (ins(module
, "maxpathlen", values
[QSV_MAX_PATH_LENGTH
])) return -1;
8638 if (ins(module
, "maxnamelen", values
[QSV_MAX_COMP_LENGTH
])) return -1;
8639 if (ins(module
, "revision", values
[QSV_VERSION_REVISION
])) return -1;
8640 if (ins(module
, "timeslice", values
[QSV_MIN_SLICE
])) return -1;
8642 switch (values
[QSV_VERSION_MINOR
]) {
8643 case 0: ver
= "2.00"; break;
8644 case 10: ver
= "2.10"; break;
8645 case 11: ver
= "2.11"; break;
8646 case 30: ver
= "3.00"; break;
8647 case 40: ver
= "4.00"; break;
8648 case 50: ver
= "5.00"; break;
8650 PyOS_snprintf(tmp
, sizeof(tmp
),
8651 "%d-%d", values
[QSV_VERSION_MAJOR
],
8652 values
[QSV_VERSION_MINOR
]);
8656 /* Add Indicator of the Version of the Operating System */
8657 if (PyModule_AddStringConstant(module
, "version", tmp
) < 0)
8660 /* Add Indicator of Which Drive was Used to Boot the System */
8661 tmp
[0] = 'A' + values
[QSV_BOOT_DRIVE
] - 1;
8665 return PyModule_AddStringConstant(module
, "bootdrive", tmp
);
8670 all_ins(PyObject
*d
)
8673 if (ins(d
, "F_OK", (long)F_OK
)) return -1;
8676 if (ins(d
, "R_OK", (long)R_OK
)) return -1;
8679 if (ins(d
, "W_OK", (long)W_OK
)) return -1;
8682 if (ins(d
, "X_OK", (long)X_OK
)) return -1;
8685 if (ins(d
, "NGROUPS_MAX", (long)NGROUPS_MAX
)) return -1;
8688 if (ins(d
, "TMP_MAX", (long)TMP_MAX
)) return -1;
8691 if (ins(d
, "WCONTINUED", (long)WCONTINUED
)) return -1;
8694 if (ins(d
, "WNOHANG", (long)WNOHANG
)) return -1;
8697 if (ins(d
, "WUNTRACED", (long)WUNTRACED
)) return -1;
8700 if (ins(d
, "O_RDONLY", (long)O_RDONLY
)) return -1;
8703 if (ins(d
, "O_WRONLY", (long)O_WRONLY
)) return -1;
8706 if (ins(d
, "O_RDWR", (long)O_RDWR
)) return -1;
8709 if (ins(d
, "O_NDELAY", (long)O_NDELAY
)) return -1;
8712 if (ins(d
, "O_NONBLOCK", (long)O_NONBLOCK
)) return -1;
8715 if (ins(d
, "O_APPEND", (long)O_APPEND
)) return -1;
8718 if (ins(d
, "O_DSYNC", (long)O_DSYNC
)) return -1;
8721 if (ins(d
, "O_RSYNC", (long)O_RSYNC
)) return -1;
8724 if (ins(d
, "O_SYNC", (long)O_SYNC
)) return -1;
8727 if (ins(d
, "O_NOCTTY", (long)O_NOCTTY
)) return -1;
8730 if (ins(d
, "O_CREAT", (long)O_CREAT
)) return -1;
8733 if (ins(d
, "O_EXCL", (long)O_EXCL
)) return -1;
8736 if (ins(d
, "O_TRUNC", (long)O_TRUNC
)) return -1;
8739 if (ins(d
, "O_BINARY", (long)O_BINARY
)) return -1;
8742 if (ins(d
, "O_TEXT", (long)O_TEXT
)) return -1;
8745 if (ins(d
, "O_LARGEFILE", (long)O_LARGEFILE
)) return -1;
8748 if (ins(d
, "O_SHLOCK", (long)O_SHLOCK
)) return -1;
8751 if (ins(d
, "O_EXLOCK", (long)O_EXLOCK
)) return -1;
8756 /* Don't inherit in child processes. */
8757 if (ins(d
, "O_NOINHERIT", (long)O_NOINHERIT
)) return -1;
8759 #ifdef _O_SHORT_LIVED
8760 /* Optimize for short life (keep in memory). */
8761 /* MS forgot to define this one with a non-underscore form too. */
8762 if (ins(d
, "O_SHORT_LIVED", (long)_O_SHORT_LIVED
)) return -1;
8765 /* Automatically delete when last handle is closed. */
8766 if (ins(d
, "O_TEMPORARY", (long)O_TEMPORARY
)) return -1;
8769 /* Optimize for random access. */
8770 if (ins(d
, "O_RANDOM", (long)O_RANDOM
)) return -1;
8773 /* Optimize for sequential access. */
8774 if (ins(d
, "O_SEQUENTIAL", (long)O_SEQUENTIAL
)) return -1;
8777 /* GNU extensions. */
8779 /* Send a SIGIO signal whenever input or output
8780 becomes available on file descriptor */
8781 if (ins(d
, "O_ASYNC", (long)O_ASYNC
)) return -1;
8784 /* Direct disk access. */
8785 if (ins(d
, "O_DIRECT", (long)O_DIRECT
)) return -1;
8788 /* Must be a directory. */
8789 if (ins(d
, "O_DIRECTORY", (long)O_DIRECTORY
)) return -1;
8792 /* Do not follow links. */
8793 if (ins(d
, "O_NOFOLLOW", (long)O_NOFOLLOW
)) return -1;
8796 /* Do not update the access time. */
8797 if (ins(d
, "O_NOATIME", (long)O_NOATIME
)) return -1;
8800 /* These come from sysexits.h */
8802 if (ins(d
, "EX_OK", (long)EX_OK
)) return -1;
8805 if (ins(d
, "EX_USAGE", (long)EX_USAGE
)) return -1;
8806 #endif /* EX_USAGE */
8808 if (ins(d
, "EX_DATAERR", (long)EX_DATAERR
)) return -1;
8809 #endif /* EX_DATAERR */
8811 if (ins(d
, "EX_NOINPUT", (long)EX_NOINPUT
)) return -1;
8812 #endif /* EX_NOINPUT */
8814 if (ins(d
, "EX_NOUSER", (long)EX_NOUSER
)) return -1;
8815 #endif /* EX_NOUSER */
8817 if (ins(d
, "EX_NOHOST", (long)EX_NOHOST
)) return -1;
8818 #endif /* EX_NOHOST */
8819 #ifdef EX_UNAVAILABLE
8820 if (ins(d
, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE
)) return -1;
8821 #endif /* EX_UNAVAILABLE */
8823 if (ins(d
, "EX_SOFTWARE", (long)EX_SOFTWARE
)) return -1;
8824 #endif /* EX_SOFTWARE */
8826 if (ins(d
, "EX_OSERR", (long)EX_OSERR
)) return -1;
8827 #endif /* EX_OSERR */
8829 if (ins(d
, "EX_OSFILE", (long)EX_OSFILE
)) return -1;
8830 #endif /* EX_OSFILE */
8832 if (ins(d
, "EX_CANTCREAT", (long)EX_CANTCREAT
)) return -1;
8833 #endif /* EX_CANTCREAT */
8835 if (ins(d
, "EX_IOERR", (long)EX_IOERR
)) return -1;
8836 #endif /* EX_IOERR */
8838 if (ins(d
, "EX_TEMPFAIL", (long)EX_TEMPFAIL
)) return -1;
8839 #endif /* EX_TEMPFAIL */
8841 if (ins(d
, "EX_PROTOCOL", (long)EX_PROTOCOL
)) return -1;
8842 #endif /* EX_PROTOCOL */
8844 if (ins(d
, "EX_NOPERM", (long)EX_NOPERM
)) return -1;
8845 #endif /* EX_NOPERM */
8847 if (ins(d
, "EX_CONFIG", (long)EX_CONFIG
)) return -1;
8848 #endif /* EX_CONFIG */
8850 if (ins(d
, "EX_NOTFOUND", (long)EX_NOTFOUND
)) return -1;
8851 #endif /* EX_NOTFOUND */
8854 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8855 if (ins(d
, "P_WAIT", (long)P_WAIT
)) return -1;
8856 if (ins(d
, "P_NOWAIT", (long)P_NOWAIT
)) return -1;
8857 if (ins(d
, "P_OVERLAY", (long)P_OVERLAY
)) return -1;
8858 if (ins(d
, "P_DEBUG", (long)P_DEBUG
)) return -1;
8859 if (ins(d
, "P_SESSION", (long)P_SESSION
)) return -1;
8860 if (ins(d
, "P_DETACH", (long)P_DETACH
)) return -1;
8861 if (ins(d
, "P_PM", (long)P_PM
)) return -1;
8862 if (ins(d
, "P_DEFAULT", (long)P_DEFAULT
)) return -1;
8863 if (ins(d
, "P_MINIMIZE", (long)P_MINIMIZE
)) return -1;
8864 if (ins(d
, "P_MAXIMIZE", (long)P_MAXIMIZE
)) return -1;
8865 if (ins(d
, "P_FULLSCREEN", (long)P_FULLSCREEN
)) return -1;
8866 if (ins(d
, "P_WINDOWED", (long)P_WINDOWED
)) return -1;
8867 if (ins(d
, "P_FOREGROUND", (long)P_FOREGROUND
)) return -1;
8868 if (ins(d
, "P_BACKGROUND", (long)P_BACKGROUND
)) return -1;
8869 if (ins(d
, "P_NOCLOSE", (long)P_NOCLOSE
)) return -1;
8870 if (ins(d
, "P_NOSESSION", (long)P_NOSESSION
)) return -1;
8871 if (ins(d
, "P_QUOTE", (long)P_QUOTE
)) return -1;
8872 if (ins(d
, "P_TILDE", (long)P_TILDE
)) return -1;
8873 if (ins(d
, "P_UNRELATED", (long)P_UNRELATED
)) return -1;
8874 if (ins(d
, "P_DEBUGDESC", (long)P_DEBUGDESC
)) return -1;
8876 if (ins(d
, "P_WAIT", (long)_P_WAIT
)) return -1;
8877 if (ins(d
, "P_NOWAIT", (long)_P_NOWAIT
)) return -1;
8878 if (ins(d
, "P_OVERLAY", (long)_OLD_P_OVERLAY
)) return -1;
8879 if (ins(d
, "P_NOWAITO", (long)_P_NOWAITO
)) return -1;
8880 if (ins(d
, "P_DETACH", (long)_P_DETACH
)) return -1;
8884 #if defined(PYOS_OS2)
8885 if (insertvalues(d
)) return -1;
8891 #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)) && !defined(__QNX__)
8892 #define INITFUNC initnt
8893 #define MODNAME "nt"
8895 #elif defined(PYOS_OS2)
8896 #define INITFUNC initos2
8897 #define MODNAME "os2"
8900 #define INITFUNC initposix
8901 #define MODNAME "posix"
8909 m
= Py_InitModule3(MODNAME
,
8915 /* Initialize environ dictionary */
8916 v
= convertenviron();
8918 if (v
== NULL
|| PyModule_AddObject(m
, "environ", v
) != 0)
8925 if (setup_confname_tables(m
))
8928 Py_INCREF(PyExc_OSError
);
8929 PyModule_AddObject(m
, "error", PyExc_OSError
);
8932 if (posix_putenv_garbage
== NULL
)
8933 posix_putenv_garbage
= PyDict_New();
8937 stat_result_desc
.name
= MODNAME
".stat_result";
8938 stat_result_desc
.fields
[7].name
= PyStructSequence_UnnamedField
;
8939 stat_result_desc
.fields
[8].name
= PyStructSequence_UnnamedField
;
8940 stat_result_desc
.fields
[9].name
= PyStructSequence_UnnamedField
;
8941 PyStructSequence_InitType(&StatResultType
, &stat_result_desc
);
8942 structseq_new
= StatResultType
.tp_new
;
8943 StatResultType
.tp_new
= statresult_new
;
8945 statvfs_result_desc
.name
= MODNAME
".statvfs_result";
8946 PyStructSequence_InitType(&StatVFSResultType
, &statvfs_result_desc
);
8948 Py_INCREF((PyObject
*) &StatResultType
);
8949 PyModule_AddObject(m
, "stat_result", (PyObject
*) &StatResultType
);
8950 Py_INCREF((PyObject
*) &StatVFSResultType
);
8951 PyModule_AddObject(m
, "statvfs_result",
8952 (PyObject
*) &StatVFSResultType
);
8957 * Step 2 of weak-linking support on Mac OS X.
8959 * The code below removes functions that are not available on the
8960 * currently active platform.
8962 * This block allow one to use a python binary that was build on
8963 * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
8966 #ifdef HAVE_FSTATVFS
8967 if (fstatvfs
== NULL
) {
8968 if (PyObject_DelAttrString(m
, "fstatvfs") == -1) {
8972 #endif /* HAVE_FSTATVFS */
8975 if (statvfs
== NULL
) {
8976 if (PyObject_DelAttrString(m
, "statvfs") == -1) {
8980 #endif /* HAVE_STATVFS */
8983 if (lchown
== NULL
) {
8984 if (PyObject_DelAttrString(m
, "lchown") == -1) {
8988 #endif /* HAVE_LCHOWN */
8991 #endif /* __APPLE__ */