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 #if defined _MSC_VER && _MSC_VER >= 1400
347 /* Microsoft CRT in VS2005 and higher will verify that a filehandle is
348 * valid and throw an assertion if it isn't.
349 * Normally, an invalid fd is likely to be a C program error and therefore
350 * an assertion can be useful, but it does contradict the POSIX standard
351 * which for write(2) states:
352 * "Otherwise, -1 shall be returned and errno set to indicate the error."
353 * "[EBADF] The fildes argument is not a valid file descriptor open for
355 * Furthermore, python allows the user to enter any old integer
356 * as a fd and should merely raise a python exception on error.
357 * The Microsoft CRT doesn't provide an official way to check for the
358 * validity of a file descriptor, but we can emulate its internal behaviour
359 * by using the exported __pinfo data member and knowledge of the
360 * internal structures involved.
361 * The structures below must be updated for each version of visual studio
362 * according to the file internal.h in the CRT source, until MS comes
363 * up with a less hacky way to do this.
364 * (all of this is to avoid globally modifying the CRT behaviour using
365 * _set_invalid_parameter_handler() and _CrtSetReportMode())
367 #if _MSC_VER >= 1500 /* VS 2008 */
373 CRITICAL_SECTION lock
;
374 #ifndef _SAFECRT_IMPL
379 BOOL utf8translations
;
382 #endif /* _SAFECRT_IMPL */
384 #elif _MSC_VER >= 1400 /* VS 2005 */
390 CRITICAL_SECTION lock
;
391 #ifndef _SAFECRT_IMPL
396 BOOL utf8translations
;
397 #endif /* _SAFECRT_IMPL */
401 extern __declspec(dllimport
) ioinfo
* __pioinfo
[];
403 #define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
404 #define IOINFO_ARRAYS 64
405 #define _NHANDLE_ (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS)
407 #define _NO_CONSOLE_FILENO (intptr_t)-2
409 /* This function emulates what the windows CRT does to validate file handles */
413 const int i1
= fd
>> IOINFO_L2E
;
414 const int i2
= fd
& ((1 << IOINFO_L2E
) - 1);
416 /* See that it isn't a special CLEAR fileno */
417 if (fd
!= _NO_CONSOLE_FILENO
) {
418 /* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead
419 * we check pointer validity and other info
421 if (0 <= i1
&& i1
< IOINFO_ARRAYS
&& __pioinfo
[i1
] != NULL
) {
422 /* finally, check that the file is open */
423 if (__pioinfo
[i1
][i2
].osfile
& FOPEN
)
431 /* the special case of checking dup2. The target fd must be in a sensible range */
433 _PyVerify_fd_dup2(int fd1
, int fd2
)
435 if (!_PyVerify_fd(fd1
))
437 if (fd2
== _NO_CONSOLE_FILENO
)
439 if ((unsigned)fd2
< _NHANDLE_
)
445 /* dummy version. _PyVerify_fd() is already defined in fileobject.h */
446 #define _PyVerify_fd_dup2(A, B) (1)
449 /* Return a dictionary corresponding to the POSIX environment table */
450 #ifdef WITH_NEXT_FRAMEWORK
451 /* On Darwin/MacOSX a shared library or framework has no access to
452 ** environ directly, we must obtain it with _NSGetEnviron().
454 #include <crt_externs.h>
455 static char **environ
;
456 #elif !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )
457 extern char **environ
;
458 #endif /* !_MSC_VER */
468 #ifdef WITH_NEXT_FRAMEWORK
470 environ
= *_NSGetEnviron();
474 /* This part ignores errors */
475 for (e
= environ
; *e
!= NULL
; e
++) {
478 char *p
= strchr(*e
, '=');
481 k
= PyString_FromStringAndSize(*e
, (int)(p
-*e
));
486 v
= PyString_FromString(p
+1);
492 if (PyDict_GetItem(d
, k
) == NULL
) {
493 if (PyDict_SetItem(d
, k
, v
) != 0)
499 #if defined(PYOS_OS2)
502 char buffer
[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */
504 rc
= DosQueryExtLIBPATH(buffer
, BEGIN_LIBPATH
);
505 if (rc
== NO_ERROR
) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
506 PyObject
*v
= PyString_FromString(buffer
);
507 PyDict_SetItemString(d
, "BEGINLIBPATH", v
);
510 rc
= DosQueryExtLIBPATH(buffer
, END_LIBPATH
);
511 if (rc
== NO_ERROR
) { /* (not a typo, envname is NOT 'END_LIBPATH') */
512 PyObject
*v
= PyString_FromString(buffer
);
513 PyDict_SetItemString(d
, "ENDLIBPATH", v
);
522 /* Set a POSIX-specific error from errno, and return NULL */
527 return PyErr_SetFromErrno(PyExc_OSError
);
530 posix_error_with_filename(char* name
)
532 return PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
535 #ifdef Py_WIN_WIDE_FILENAMES
537 posix_error_with_unicode_filename(Py_UNICODE
* name
)
539 return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError
, name
);
541 #endif /* Py_WIN_WIDE_FILENAMES */
545 posix_error_with_allocated_filename(char* name
)
547 PyObject
*rc
= PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
554 win32_error(char* function
, char* filename
)
556 /* XXX We should pass the function name along in the future.
557 (_winreg.c also wants to pass the function name.)
558 This would however require an additional param to the
559 Windows error object, which is non-trivial.
561 errno
= GetLastError();
563 return PyErr_SetFromWindowsErrWithFilename(errno
, filename
);
565 return PyErr_SetFromWindowsErr(errno
);
568 #ifdef Py_WIN_WIDE_FILENAMES
570 win32_error_unicode(char* function
, Py_UNICODE
* filename
)
572 /* XXX - see win32_error for comments on 'function' */
573 errno
= GetLastError();
575 return PyErr_SetFromWindowsErrWithUnicodeFilename(errno
, filename
);
577 return PyErr_SetFromWindowsErr(errno
);
581 convert_to_unicode(PyObject
**param
)
583 if (PyUnicode_CheckExact(*param
))
585 else if (PyUnicode_Check(*param
))
586 /* For a Unicode subtype that's not a Unicode object,
587 return a true Unicode object with the same data. */
588 *param
= PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(*param
),
589 PyUnicode_GET_SIZE(*param
));
591 *param
= PyUnicode_FromEncodedObject(*param
,
592 Py_FileSystemDefaultEncoding
,
594 return (*param
) != NULL
;
597 #endif /* Py_WIN_WIDE_FILENAMES */
601 #if defined(PYOS_OS2)
602 /**********************************************************************
603 * Helper Function to Trim and Format OS/2 Messages
604 **********************************************************************/
606 os2_formatmsg(char *msgbuf
, int msglen
, char *reason
)
608 msgbuf
[msglen
] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
610 if (strlen(msgbuf
) > 0) { /* If Non-Empty Msg, Trim CRLF */
611 char *lastc
= &msgbuf
[ strlen(msgbuf
)-1 ];
613 while (lastc
> msgbuf
&& isspace(Py_CHARMASK(*lastc
)))
614 *lastc
-- = '\0'; /* Trim Trailing Whitespace (CRLF) */
617 /* Add Optional Reason Text */
619 strcat(msgbuf
, " : ");
620 strcat(msgbuf
, reason
);
624 /**********************************************************************
625 * Decode an OS/2 Operating System Error Code
627 * A convenience function to lookup an OS/2 error code and return a
628 * text message we can use to raise a Python exception.
631 * The messages for errors returned from the OS/2 kernel reside in
632 * the file OSO001.MSG in the \OS2 directory hierarchy.
634 **********************************************************************/
636 os2_strerror(char *msgbuf
, int msgbuflen
, int errorcode
, char *reason
)
641 /* Retrieve Kernel-Related Error Message from OSO001.MSG File */
642 Py_BEGIN_ALLOW_THREADS
643 rc
= DosGetMessage(NULL
, 0, msgbuf
, msgbuflen
,
644 errorcode
, "oso001.msg", &msglen
);
648 os2_formatmsg(msgbuf
, msglen
, reason
);
650 PyOS_snprintf(msgbuf
, msgbuflen
,
651 "unknown OS error #%d", errorcode
);
656 /* Set an OS/2-specific error and return NULL. OS/2 kernel
657 errors are not in a global variable e.g. 'errno' nor are
658 they congruent with posix error numbers. */
660 static PyObject
* os2_error(int code
)
665 os2_strerror(text
, sizeof(text
), code
, "");
667 v
= Py_BuildValue("(is)", code
, text
);
669 PyErr_SetObject(PyExc_OSError
, v
);
672 return NULL
; /* Signal to Python that an Exception is Pending */
677 /* POSIX generic methods */
680 posix_fildes(PyObject
*fdobj
, int (*func
)(int))
684 fd
= PyObject_AsFileDescriptor(fdobj
);
687 if (!_PyVerify_fd(fd
))
688 return posix_error();
689 Py_BEGIN_ALLOW_THREADS
693 return posix_error();
698 #ifdef Py_WIN_WIDE_FILENAMES
700 unicode_file_names(void)
702 static int canusewide
= -1;
703 if (canusewide
== -1) {
704 /* As per doc for ::GetVersion(), this is the correct test for
705 the Windows NT family. */
706 canusewide
= (GetVersion() < 0x80000000) ? 1 : 0;
713 posix_1str(PyObject
*args
, char *format
, int (*func
)(const char*))
717 if (!PyArg_ParseTuple(args
, format
,
718 Py_FileSystemDefaultEncoding
, &path1
))
720 Py_BEGIN_ALLOW_THREADS
721 res
= (*func
)(path1
);
724 return posix_error_with_allocated_filename(path1
);
731 posix_2str(PyObject
*args
,
733 int (*func
)(const char *, const char *))
735 char *path1
= NULL
, *path2
= NULL
;
737 if (!PyArg_ParseTuple(args
, format
,
738 Py_FileSystemDefaultEncoding
, &path1
,
739 Py_FileSystemDefaultEncoding
, &path2
))
741 Py_BEGIN_ALLOW_THREADS
742 res
= (*func
)(path1
, path2
);
747 /* XXX how to report both path1 and path2??? */
748 return posix_error();
753 #ifdef Py_WIN_WIDE_FILENAMES
755 win32_1str(PyObject
* args
, char* func
,
756 char* format
, BOOL (__stdcall
*funcA
)(LPCSTR
),
757 char* wformat
, BOOL (__stdcall
*funcW
)(LPWSTR
))
762 if (unicode_file_names()) {
763 if (!PyArg_ParseTuple(args
, wformat
, &uni
))
766 Py_BEGIN_ALLOW_THREADS
767 result
= funcW(PyUnicode_AsUnicode(uni
));
770 return win32_error_unicode(func
, PyUnicode_AsUnicode(uni
));
775 if (!PyArg_ParseTuple(args
, format
, &ansi
))
777 Py_BEGIN_ALLOW_THREADS
778 result
= funcA(ansi
);
781 return win32_error(func
, ansi
);
787 /* This is a reimplementation of the C library's chdir function,
788 but one that produces Win32 errors instead of DOS error codes.
789 chdir is essentially a wrapper around SetCurrentDirectory; however,
790 it also needs to set "magic" environment variables indicating
791 the per-drive current directory, which are of the form =<drive>: */
792 static BOOL __stdcall
793 win32_chdir(LPCSTR path
)
795 char new_path
[MAX_PATH
+1];
799 if(!SetCurrentDirectoryA(path
))
801 result
= GetCurrentDirectoryA(MAX_PATH
+1, new_path
);
804 /* In the ANSI API, there should not be any paths longer
806 assert(result
<= MAX_PATH
+1);
807 if (strncmp(new_path
, "\\\\", 2) == 0 ||
808 strncmp(new_path
, "//", 2) == 0)
809 /* UNC path, nothing to do. */
811 env
[1] = new_path
[0];
812 return SetEnvironmentVariableA(env
, new_path
);
815 /* The Unicode version differs from the ANSI version
816 since the current directory might exceed MAX_PATH characters */
817 static BOOL __stdcall
818 win32_wchdir(LPCWSTR path
)
820 wchar_t _new_path
[MAX_PATH
+1], *new_path
= _new_path
;
822 wchar_t env
[4] = L
"=x:";
824 if(!SetCurrentDirectoryW(path
))
826 result
= GetCurrentDirectoryW(MAX_PATH
+1, new_path
);
829 if (result
> MAX_PATH
+1) {
830 new_path
= malloc(result
* sizeof(wchar_t));
832 SetLastError(ERROR_OUTOFMEMORY
);
835 result
= GetCurrentDirectoryW(result
, new_path
);
841 if (wcsncmp(new_path
, L
"\\\\", 2) == 0 ||
842 wcsncmp(new_path
, L
"//", 2) == 0)
843 /* UNC path, nothing to do. */
845 env
[1] = new_path
[0];
846 result
= SetEnvironmentVariableW(env
, new_path
);
847 if (new_path
!= _new_path
)
854 /* The CRT of Windows has a number of flaws wrt. its stat() implementation:
855 - time stamps are restricted to second resolution
856 - file modification times suffer from forth-and-back conversions between
858 Therefore, we implement our own stat, based on the Win32 API directly.
860 #define HAVE_STAT_NSEC 1
865 unsigned short st_mode
;
879 static __int64 secs_between_epochs
= 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */
882 FILE_TIME_to_time_t_nsec(FILETIME
*in_ptr
, int *time_out
, int* nsec_out
)
884 /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */
885 /* Cannot simply cast and dereference in_ptr,
886 since it might not be aligned properly */
888 memcpy(&in
, in_ptr
, sizeof(in
));
889 *nsec_out
= (int)(in
% 10000000) * 100; /* FILETIME is in units of 100 nsec. */
890 /* XXX Win32 supports time stamps past 2038; we currently don't */
891 *time_out
= Py_SAFE_DOWNCAST((in
/ 10000000) - secs_between_epochs
, __int64
, int);
895 time_t_to_FILE_TIME(int time_in
, int nsec_in
, FILETIME
*out_ptr
)
899 out
= time_in
+ secs_between_epochs
;
900 out
= out
* 10000000 + nsec_in
/ 100;
901 memcpy(out_ptr
, &out
, sizeof(out
));
904 /* Below, we *know* that ugo+r is 0444 */
906 #error Unsupported C library
909 attributes_to_mode(DWORD attr
)
912 if (attr
& FILE_ATTRIBUTE_DIRECTORY
)
913 m
|= _S_IFDIR
| 0111; /* IFEXEC for user,group,other */
916 if (attr
& FILE_ATTRIBUTE_READONLY
)
924 attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA
*info
, struct win32_stat
*result
)
926 memset(result
, 0, sizeof(*result
));
927 result
->st_mode
= attributes_to_mode(info
->dwFileAttributes
);
928 result
->st_size
= (((__int64
)info
->nFileSizeHigh
)<<32) + info
->nFileSizeLow
;
929 FILE_TIME_to_time_t_nsec(&info
->ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
930 FILE_TIME_to_time_t_nsec(&info
->ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
931 FILE_TIME_to_time_t_nsec(&info
->ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
936 /* Emulate GetFileAttributesEx[AW] on Windows 95 */
937 static int checked
= 0;
938 static BOOL (CALLBACK
*gfaxa
)(LPCSTR
, GET_FILEEX_INFO_LEVELS
, LPVOID
);
939 static BOOL (CALLBACK
*gfaxw
)(LPCWSTR
, GET_FILEEX_INFO_LEVELS
, LPVOID
);
947 hKernel32
= GetModuleHandle("KERNEL32");
948 *(FARPROC
*)&gfaxa
= GetProcAddress(hKernel32
, "GetFileAttributesExA");
949 *(FARPROC
*)&gfaxw
= GetProcAddress(hKernel32
, "GetFileAttributesExW");
953 attributes_from_dir(LPCSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
956 WIN32_FIND_DATAA FileData
;
957 hFindFile
= FindFirstFileA(pszFile
, &FileData
);
958 if (hFindFile
== INVALID_HANDLE_VALUE
)
960 FindClose(hFindFile
);
961 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
962 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
963 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
964 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
965 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
966 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
971 attributes_from_dir_w(LPCWSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
974 WIN32_FIND_DATAW FileData
;
975 hFindFile
= FindFirstFileW(pszFile
, &FileData
);
976 if (hFindFile
== INVALID_HANDLE_VALUE
)
978 FindClose(hFindFile
);
979 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
980 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
981 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
982 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
983 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
984 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
989 Py_GetFileAttributesExA(LPCSTR pszFile
,
990 GET_FILEEX_INFO_LEVELS level
,
994 LPWIN32_FILE_ATTRIBUTE_DATA pfad
= pv
;
995 /* First try to use the system's implementation, if that is
996 available and either succeeds to gives an error other than
997 that it isn't implemented. */
1000 result
= gfaxa(pszFile
, level
, pv
);
1001 if (result
|| GetLastError() != ERROR_CALL_NOT_IMPLEMENTED
)
1004 /* It's either not present, or not implemented.
1005 Emulate using FindFirstFile. */
1006 if (level
!= GetFileExInfoStandard
) {
1007 SetLastError(ERROR_INVALID_PARAMETER
);
1010 /* Use GetFileAttributes to validate that the file name
1011 does not contain wildcards (which FindFirstFile would
1013 if (GetFileAttributesA(pszFile
) == 0xFFFFFFFF)
1015 return attributes_from_dir(pszFile
, pfad
);
1019 Py_GetFileAttributesExW(LPCWSTR pszFile
,
1020 GET_FILEEX_INFO_LEVELS level
,
1024 LPWIN32_FILE_ATTRIBUTE_DATA pfad
= pv
;
1025 /* First try to use the system's implementation, if that is
1026 available and either succeeds to gives an error other than
1027 that it isn't implemented. */
1030 result
= gfaxw(pszFile
, level
, pv
);
1031 if (result
|| GetLastError() != ERROR_CALL_NOT_IMPLEMENTED
)
1034 /* It's either not present, or not implemented.
1035 Emulate using FindFirstFile. */
1036 if (level
!= GetFileExInfoStandard
) {
1037 SetLastError(ERROR_INVALID_PARAMETER
);
1040 /* Use GetFileAttributes to validate that the file name
1041 does not contain wildcards (which FindFirstFile would
1043 if (GetFileAttributesW(pszFile
) == 0xFFFFFFFF)
1045 return attributes_from_dir_w(pszFile
, pfad
);
1049 win32_stat(const char* path
, struct win32_stat
*result
)
1051 WIN32_FILE_ATTRIBUTE_DATA info
;
1054 /* XXX not supported on Win95 and NT 3.x */
1055 if (!Py_GetFileAttributesExA(path
, GetFileExInfoStandard
, &info
)) {
1056 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
1057 /* Protocol violation: we explicitly clear errno, instead of
1058 setting it to a POSIX error. Callers should use GetLastError. */
1062 /* Could not get attributes on open file. Fall back to
1063 reading the directory. */
1064 if (!attributes_from_dir(path
, &info
)) {
1065 /* Very strange. This should not fail now */
1071 code
= attribute_data_to_stat(&info
, result
);
1074 /* Set S_IFEXEC if it is an .exe, .bat, ... */
1075 dot
= strrchr(path
, '.');
1077 if (stricmp(dot
, ".bat") == 0 ||
1078 stricmp(dot
, ".cmd") == 0 ||
1079 stricmp(dot
, ".exe") == 0 ||
1080 stricmp(dot
, ".com") == 0)
1081 result
->st_mode
|= 0111;
1087 win32_wstat(const wchar_t* path
, struct win32_stat
*result
)
1091 WIN32_FILE_ATTRIBUTE_DATA info
;
1092 /* XXX not supported on Win95 and NT 3.x */
1093 if (!Py_GetFileAttributesExW(path
, GetFileExInfoStandard
, &info
)) {
1094 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
1095 /* Protocol violation: we explicitly clear errno, instead of
1096 setting it to a POSIX error. Callers should use GetLastError. */
1100 /* Could not get attributes on open file. Fall back to
1101 reading the directory. */
1102 if (!attributes_from_dir_w(path
, &info
)) {
1103 /* Very strange. This should not fail now */
1109 code
= attribute_data_to_stat(&info
, result
);
1112 /* Set IFEXEC if it is an .exe, .bat, ... */
1113 dot
= wcsrchr(path
, '.');
1115 if (_wcsicmp(dot
, L
".bat") == 0 ||
1116 _wcsicmp(dot
, L
".cmd") == 0 ||
1117 _wcsicmp(dot
, L
".exe") == 0 ||
1118 _wcsicmp(dot
, L
".com") == 0)
1119 result
->st_mode
|= 0111;
1125 win32_fstat(int file_number
, struct win32_stat
*result
)
1127 BY_HANDLE_FILE_INFORMATION info
;
1131 h
= (HANDLE
)_get_osfhandle(file_number
);
1133 /* Protocol violation: we explicitly clear errno, instead of
1134 setting it to a POSIX error. Callers should use GetLastError. */
1137 if (h
== INVALID_HANDLE_VALUE
) {
1138 /* This is really a C library error (invalid file handle).
1139 We set the Win32 error to the closes one matching. */
1140 SetLastError(ERROR_INVALID_HANDLE
);
1143 memset(result
, 0, sizeof(*result
));
1145 type
= GetFileType(h
);
1146 if (type
== FILE_TYPE_UNKNOWN
) {
1147 DWORD error
= GetLastError();
1151 /* else: valid but unknown file */
1154 if (type
!= FILE_TYPE_DISK
) {
1155 if (type
== FILE_TYPE_CHAR
)
1156 result
->st_mode
= _S_IFCHR
;
1157 else if (type
== FILE_TYPE_PIPE
)
1158 result
->st_mode
= _S_IFIFO
;
1162 if (!GetFileInformationByHandle(h
, &info
)) {
1166 /* similar to stat() */
1167 result
->st_mode
= attributes_to_mode(info
.dwFileAttributes
);
1168 result
->st_size
= (((__int64
)info
.nFileSizeHigh
)<<32) + info
.nFileSizeLow
;
1169 FILE_TIME_to_time_t_nsec(&info
.ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
1170 FILE_TIME_to_time_t_nsec(&info
.ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
1171 FILE_TIME_to_time_t_nsec(&info
.ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
1172 /* specific to fstat() */
1173 result
->st_nlink
= info
.nNumberOfLinks
;
1174 result
->st_ino
= (((__int64
)info
.nFileIndexHigh
)<<32) + info
.nFileIndexLow
;
1178 #endif /* MS_WINDOWS */
1180 PyDoc_STRVAR(stat_result__doc__
,
1181 "stat_result: Result from stat or lstat.\n\n\
1182 This object may be accessed either as a tuple of\n\
1183 (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n\
1184 or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\
1186 Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n\
1187 or st_flags, they are available as attributes only.\n\
1189 See os.stat for more information.");
1191 static PyStructSequence_Field stat_result_fields
[] = {
1192 {"st_mode", "protection bits"},
1193 {"st_ino", "inode"},
1194 {"st_dev", "device"},
1195 {"st_nlink", "number of hard links"},
1196 {"st_uid", "user ID of owner"},
1197 {"st_gid", "group ID of owner"},
1198 {"st_size", "total size, in bytes"},
1199 /* The NULL is replaced with PyStructSequence_UnnamedField later. */
1200 {NULL
, "integer time of last access"},
1201 {NULL
, "integer time of last modification"},
1202 {NULL
, "integer time of last change"},
1203 {"st_atime", "time of last access"},
1204 {"st_mtime", "time of last modification"},
1205 {"st_ctime", "time of last change"},
1206 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1207 {"st_blksize", "blocksize for filesystem I/O"},
1209 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1210 {"st_blocks", "number of blocks allocated"},
1212 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1213 {"st_rdev", "device type (if inode device)"},
1215 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1216 {"st_flags", "user defined flags for file"},
1218 #ifdef HAVE_STRUCT_STAT_ST_GEN
1219 {"st_gen", "generation number"},
1221 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1222 {"st_birthtime", "time of creation"},
1227 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1228 #define ST_BLKSIZE_IDX 13
1230 #define ST_BLKSIZE_IDX 12
1233 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1234 #define ST_BLOCKS_IDX (ST_BLKSIZE_IDX+1)
1236 #define ST_BLOCKS_IDX ST_BLKSIZE_IDX
1239 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1240 #define ST_RDEV_IDX (ST_BLOCKS_IDX+1)
1242 #define ST_RDEV_IDX ST_BLOCKS_IDX
1245 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1246 #define ST_FLAGS_IDX (ST_RDEV_IDX+1)
1248 #define ST_FLAGS_IDX ST_RDEV_IDX
1251 #ifdef HAVE_STRUCT_STAT_ST_GEN
1252 #define ST_GEN_IDX (ST_FLAGS_IDX+1)
1254 #define ST_GEN_IDX ST_FLAGS_IDX
1257 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1258 #define ST_BIRTHTIME_IDX (ST_GEN_IDX+1)
1260 #define ST_BIRTHTIME_IDX ST_GEN_IDX
1263 static PyStructSequence_Desc stat_result_desc
= {
1264 "stat_result", /* name */
1265 stat_result__doc__
, /* doc */
1270 PyDoc_STRVAR(statvfs_result__doc__
,
1271 "statvfs_result: Result from statvfs or fstatvfs.\n\n\
1272 This object may be accessed either as a tuple of\n\
1273 (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n\
1274 or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\
1276 See os.statvfs for more information.");
1278 static PyStructSequence_Field statvfs_result_fields
[] = {
1292 static PyStructSequence_Desc statvfs_result_desc
= {
1293 "statvfs_result", /* name */
1294 statvfs_result__doc__
, /* doc */
1295 statvfs_result_fields
,
1299 static int initialized
;
1300 static PyTypeObject StatResultType
;
1301 static PyTypeObject StatVFSResultType
;
1302 static newfunc structseq_new
;
1305 statresult_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1307 PyStructSequence
*result
;
1310 result
= (PyStructSequence
*)structseq_new(type
, args
, kwds
);
1313 /* If we have been initialized from a tuple,
1314 st_?time might be set to None. Initialize it
1315 from the int slots. */
1316 for (i
= 7; i
<= 9; i
++) {
1317 if (result
->ob_item
[i
+3] == Py_None
) {
1319 Py_INCREF(result
->ob_item
[i
]);
1320 result
->ob_item
[i
+3] = result
->ob_item
[i
];
1323 return (PyObject
*)result
;
1328 /* If true, st_?time is float. */
1329 static int _stat_float_times
= 1;
1331 PyDoc_STRVAR(stat_float_times__doc__
,
1332 "stat_float_times([newval]) -> oldval\n\n\
1333 Determine whether os.[lf]stat represents time stamps as float objects.\n\
1334 If newval is True, future calls to stat() return floats, if it is False,\n\
1335 future calls return ints. \n\
1336 If newval is omitted, return the current setting.\n");
1339 stat_float_times(PyObject
* self
, PyObject
*args
)
1342 if (!PyArg_ParseTuple(args
, "|i:stat_float_times", &newval
))
1345 /* Return old value */
1346 return PyBool_FromLong(_stat_float_times
);
1347 _stat_float_times
= newval
;
1353 fill_time(PyObject
*v
, int index
, time_t sec
, unsigned long nsec
)
1355 PyObject
*fval
,*ival
;
1356 #if SIZEOF_TIME_T > SIZEOF_LONG
1357 ival
= PyLong_FromLongLong((PY_LONG_LONG
)sec
);
1359 ival
= PyInt_FromLong((long)sec
);
1363 if (_stat_float_times
) {
1364 fval
= PyFloat_FromDouble(sec
+ 1e-9*nsec
);
1369 PyStructSequence_SET_ITEM(v
, index
, ival
);
1370 PyStructSequence_SET_ITEM(v
, index
+3, fval
);
1373 /* pack a system stat C structure into the Python stat tuple
1374 (used by posix_stat() and posix_fstat()) */
1376 _pystat_fromstructstat(STRUCT_STAT
*st
)
1378 unsigned long ansec
, mnsec
, cnsec
;
1379 PyObject
*v
= PyStructSequence_New(&StatResultType
);
1383 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long)st
->st_mode
));
1384 #ifdef HAVE_LARGEFILE_SUPPORT
1385 PyStructSequence_SET_ITEM(v
, 1,
1386 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_ino
));
1388 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long)st
->st_ino
));
1390 #if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
1391 PyStructSequence_SET_ITEM(v
, 2,
1392 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_dev
));
1394 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long)st
->st_dev
));
1396 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long)st
->st_nlink
));
1397 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long)st
->st_uid
));
1398 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long)st
->st_gid
));
1399 #ifdef HAVE_LARGEFILE_SUPPORT
1400 PyStructSequence_SET_ITEM(v
, 6,
1401 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_size
));
1403 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong(st
->st_size
));
1406 #if defined(HAVE_STAT_TV_NSEC)
1407 ansec
= st
->st_atim
.tv_nsec
;
1408 mnsec
= st
->st_mtim
.tv_nsec
;
1409 cnsec
= st
->st_ctim
.tv_nsec
;
1410 #elif defined(HAVE_STAT_TV_NSEC2)
1411 ansec
= st
->st_atimespec
.tv_nsec
;
1412 mnsec
= st
->st_mtimespec
.tv_nsec
;
1413 cnsec
= st
->st_ctimespec
.tv_nsec
;
1414 #elif defined(HAVE_STAT_NSEC)
1415 ansec
= st
->st_atime_nsec
;
1416 mnsec
= st
->st_mtime_nsec
;
1417 cnsec
= st
->st_ctime_nsec
;
1419 ansec
= mnsec
= cnsec
= 0;
1421 fill_time(v
, 7, st
->st_atime
, ansec
);
1422 fill_time(v
, 8, st
->st_mtime
, mnsec
);
1423 fill_time(v
, 9, st
->st_ctime
, cnsec
);
1425 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1426 PyStructSequence_SET_ITEM(v
, ST_BLKSIZE_IDX
,
1427 PyInt_FromLong((long)st
->st_blksize
));
1429 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1430 PyStructSequence_SET_ITEM(v
, ST_BLOCKS_IDX
,
1431 PyInt_FromLong((long)st
->st_blocks
));
1433 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1434 PyStructSequence_SET_ITEM(v
, ST_RDEV_IDX
,
1435 PyInt_FromLong((long)st
->st_rdev
));
1437 #ifdef HAVE_STRUCT_STAT_ST_GEN
1438 PyStructSequence_SET_ITEM(v
, ST_GEN_IDX
,
1439 PyInt_FromLong((long)st
->st_gen
));
1441 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1444 unsigned long bsec
,bnsec
;
1445 bsec
= (long)st
->st_birthtime
;
1446 #ifdef HAVE_STAT_TV_NSEC2
1447 bnsec
= st
->st_birthtimespec
.tv_nsec
;
1451 if (_stat_float_times
) {
1452 val
= PyFloat_FromDouble(bsec
+ 1e-9*bnsec
);
1454 val
= PyInt_FromLong((long)bsec
);
1456 PyStructSequence_SET_ITEM(v
, ST_BIRTHTIME_IDX
,
1460 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1461 PyStructSequence_SET_ITEM(v
, ST_FLAGS_IDX
,
1462 PyInt_FromLong((long)st
->st_flags
));
1465 if (PyErr_Occurred()) {
1475 /* IsUNCRoot -- test whether the supplied path is of the form \\SERVER\SHARE\,
1476 where / can be used in place of \ and the trailing slash is optional.
1477 Both SERVER and SHARE must have at least one character.
1480 #define ISSLASHA(c) ((c) == '\\' || (c) == '/')
1481 #define ISSLASHW(c) ((c) == L'\\' || (c) == L'/')
1483 #define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
1487 IsUNCRootA(char *path
, int pathlen
)
1489 #define ISSLASH ISSLASHA
1493 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1494 /* minimum UNCRoot is \\x\y */
1496 for (i
= 2; i
< pathlen
; i
++)
1497 if (ISSLASH(path
[i
])) break;
1498 if (i
== 2 || i
== pathlen
)
1499 /* do not allow \\\SHARE or \\SERVER */
1502 for (i
= share
; i
< pathlen
; i
++)
1503 if (ISSLASH(path
[i
])) break;
1504 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1509 #ifdef Py_WIN_WIDE_FILENAMES
1511 IsUNCRootW(Py_UNICODE
*path
, int pathlen
)
1513 #define ISSLASH ISSLASHW
1517 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1518 /* minimum UNCRoot is \\x\y */
1520 for (i
= 2; i
< pathlen
; i
++)
1521 if (ISSLASH(path
[i
])) break;
1522 if (i
== 2 || i
== pathlen
)
1523 /* do not allow \\\SHARE or \\SERVER */
1526 for (i
= share
; i
< pathlen
; i
++)
1527 if (ISSLASH(path
[i
])) break;
1528 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1532 #endif /* Py_WIN_WIDE_FILENAMES */
1533 #endif /* MS_WINDOWS */
1536 posix_do_stat(PyObject
*self
, PyObject
*args
,
1539 int (*statfunc
)(const char *, STRUCT_STAT
*, ...),
1541 int (*statfunc
)(const char *, STRUCT_STAT
*),
1544 int (*wstatfunc
)(const Py_UNICODE
*, STRUCT_STAT
*))
1547 char *path
= NULL
; /* pass this to stat; do not free() it */
1548 char *pathfree
= NULL
; /* this memory must be free'd */
1552 #ifdef Py_WIN_WIDE_FILENAMES
1553 /* If on wide-character-capable OS see if argument
1554 is Unicode and if so use wide API. */
1555 if (unicode_file_names()) {
1556 PyUnicodeObject
*po
;
1557 if (PyArg_ParseTuple(args
, wformat
, &po
)) {
1558 Py_UNICODE
*wpath
= PyUnicode_AS_UNICODE(po
);
1560 Py_BEGIN_ALLOW_THREADS
1561 /* PyUnicode_AS_UNICODE result OK without
1562 thread lock as it is a simple dereference. */
1563 res
= wstatfunc(wpath
, &st
);
1564 Py_END_ALLOW_THREADS
1567 return win32_error_unicode("stat", wpath
);
1568 return _pystat_fromstructstat(&st
);
1570 /* Drop the argument parsing error as narrow strings
1576 if (!PyArg_ParseTuple(args
, format
,
1577 Py_FileSystemDefaultEncoding
, &path
))
1581 Py_BEGIN_ALLOW_THREADS
1582 res
= (*statfunc
)(path
, &st
);
1583 Py_END_ALLOW_THREADS
1587 result
= win32_error("stat", pathfree
);
1589 result
= posix_error_with_filename(pathfree
);
1593 result
= _pystat_fromstructstat(&st
);
1595 PyMem_Free(pathfree
);
1601 PyDoc_STRVAR(posix_access__doc__
,
1602 "access(path, mode) -> True if granted, False otherwise\n\n\
1603 Use the real uid/gid to test for access to a path. Note that most\n\
1604 operations will use the effective uid/gid, therefore this routine can\n\
1605 be used in a suid/sgid environment to test if the invoking user has the\n\
1606 specified access to the path. The mode argument can be F_OK to test\n\
1607 existence, or the inclusive-OR of R_OK, W_OK, and X_OK.");
1610 posix_access(PyObject
*self
, PyObject
*args
)
1615 #ifdef Py_WIN_WIDE_FILENAMES
1617 if (unicode_file_names()) {
1618 PyUnicodeObject
*po
;
1619 if (PyArg_ParseTuple(args
, "Ui:access", &po
, &mode
)) {
1620 Py_BEGIN_ALLOW_THREADS
1621 /* PyUnicode_AS_UNICODE OK without thread lock as
1622 it is a simple dereference. */
1623 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1624 Py_END_ALLOW_THREADS
1627 /* Drop the argument parsing error as narrow strings
1631 if (!PyArg_ParseTuple(args
, "eti:access",
1632 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1634 Py_BEGIN_ALLOW_THREADS
1635 attr
= GetFileAttributesA(path
);
1636 Py_END_ALLOW_THREADS
1639 if (attr
== 0xFFFFFFFF)
1640 /* File does not exist, or cannot read attributes */
1641 return PyBool_FromLong(0);
1642 /* Access is possible if either write access wasn't requested, or
1643 the file isn't read-only, or if it's a directory, as there are
1644 no read-only directories on Windows. */
1645 return PyBool_FromLong(!(mode
& 2)
1646 || !(attr
& FILE_ATTRIBUTE_READONLY
)
1647 || (attr
& FILE_ATTRIBUTE_DIRECTORY
));
1650 if (!PyArg_ParseTuple(args
, "eti:access",
1651 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1653 Py_BEGIN_ALLOW_THREADS
1654 res
= access(path
, mode
);
1655 Py_END_ALLOW_THREADS
1657 return PyBool_FromLong(res
== 0);
1675 PyDoc_STRVAR(posix_ttyname__doc__
,
1676 "ttyname(fd) -> string\n\n\
1677 Return the name of the terminal device connected to 'fd'.");
1680 posix_ttyname(PyObject
*self
, PyObject
*args
)
1685 if (!PyArg_ParseTuple(args
, "i:ttyname", &id
))
1689 /* file descriptor 0 only, the default input device (stdin) */
1700 return posix_error();
1701 return PyString_FromString(ret
);
1706 PyDoc_STRVAR(posix_ctermid__doc__
,
1707 "ctermid() -> string\n\n\
1708 Return the name of the controlling terminal for this process.");
1711 posix_ctermid(PyObject
*self
, PyObject
*noargs
)
1714 char buffer
[L_ctermid
];
1716 #ifdef USE_CTERMID_R
1717 ret
= ctermid_r(buffer
);
1719 ret
= ctermid(buffer
);
1722 return posix_error();
1723 return PyString_FromString(buffer
);
1727 PyDoc_STRVAR(posix_chdir__doc__
,
1729 Change the current working directory to the specified path.");
1732 posix_chdir(PyObject
*self
, PyObject
*args
)
1735 return win32_1str(args
, "chdir", "s:chdir", win32_chdir
, "U:chdir", win32_wchdir
);
1736 #elif defined(PYOS_OS2) && defined(PYCC_GCC)
1737 return posix_1str(args
, "et:chdir", _chdir2
);
1738 #elif defined(__VMS)
1739 return posix_1str(args
, "et:chdir", (int (*)(const char *))chdir
);
1741 return posix_1str(args
, "et:chdir", chdir
);
1746 PyDoc_STRVAR(posix_fchdir__doc__
,
1747 "fchdir(fildes)\n\n\
1748 Change to the directory of the given file descriptor. fildes must be\n\
1749 opened on a directory, not a file.");
1752 posix_fchdir(PyObject
*self
, PyObject
*fdobj
)
1754 return posix_fildes(fdobj
, fchdir
);
1756 #endif /* HAVE_FCHDIR */
1759 PyDoc_STRVAR(posix_chmod__doc__
,
1760 "chmod(path, mode)\n\n\
1761 Change the access permissions of a file.");
1764 posix_chmod(PyObject
*self
, PyObject
*args
)
1769 #ifdef Py_WIN_WIDE_FILENAMES
1771 if (unicode_file_names()) {
1772 PyUnicodeObject
*po
;
1773 if (PyArg_ParseTuple(args
, "Ui|:chmod", &po
, &i
)) {
1774 Py_BEGIN_ALLOW_THREADS
1775 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1776 if (attr
!= 0xFFFFFFFF) {
1778 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1780 attr
|= FILE_ATTRIBUTE_READONLY
;
1781 res
= SetFileAttributesW(PyUnicode_AS_UNICODE(po
), attr
);
1785 Py_END_ALLOW_THREADS
1787 return win32_error_unicode("chmod",
1788 PyUnicode_AS_UNICODE(po
));
1792 /* Drop the argument parsing error as narrow strings
1796 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1799 Py_BEGIN_ALLOW_THREADS
1800 attr
= GetFileAttributesA(path
);
1801 if (attr
!= 0xFFFFFFFF) {
1803 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1805 attr
|= FILE_ATTRIBUTE_READONLY
;
1806 res
= SetFileAttributesA(path
, attr
);
1810 Py_END_ALLOW_THREADS
1812 win32_error("chmod", path
);
1819 #else /* Py_WIN_WIDE_FILENAMES */
1820 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1823 Py_BEGIN_ALLOW_THREADS
1824 res
= chmod(path
, i
);
1825 Py_END_ALLOW_THREADS
1827 return posix_error_with_allocated_filename(path
);
1835 PyDoc_STRVAR(posix_fchmod__doc__
,
1836 "fchmod(fd, mode)\n\n\
1837 Change the access permissions of the file given by file\n\
1841 posix_fchmod(PyObject
*self
, PyObject
*args
)
1844 if (!PyArg_ParseTuple(args
, "ii:fchmod", &fd
, &mode
))
1846 Py_BEGIN_ALLOW_THREADS
1847 res
= fchmod(fd
, mode
);
1848 Py_END_ALLOW_THREADS
1850 return posix_error();
1853 #endif /* HAVE_FCHMOD */
1856 PyDoc_STRVAR(posix_lchmod__doc__
,
1857 "lchmod(path, mode)\n\n\
1858 Change the access permissions of a file. If path is a symlink, this\n\
1859 affects the link itself rather than the target.");
1862 posix_lchmod(PyObject
*self
, PyObject
*args
)
1867 if (!PyArg_ParseTuple(args
, "eti:lchmod", Py_FileSystemDefaultEncoding
,
1870 Py_BEGIN_ALLOW_THREADS
1871 res
= lchmod(path
, i
);
1872 Py_END_ALLOW_THREADS
1874 return posix_error_with_allocated_filename(path
);
1878 #endif /* HAVE_LCHMOD */
1882 PyDoc_STRVAR(posix_chflags__doc__
,
1883 "chflags(path, flags)\n\n\
1887 posix_chflags(PyObject
*self
, PyObject
*args
)
1890 unsigned long flags
;
1892 if (!PyArg_ParseTuple(args
, "etk:chflags",
1893 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1895 Py_BEGIN_ALLOW_THREADS
1896 res
= chflags(path
, flags
);
1897 Py_END_ALLOW_THREADS
1899 return posix_error_with_allocated_filename(path
);
1904 #endif /* HAVE_CHFLAGS */
1906 #ifdef HAVE_LCHFLAGS
1907 PyDoc_STRVAR(posix_lchflags__doc__
,
1908 "lchflags(path, flags)\n\n\
1910 This function will not follow symbolic links.");
1913 posix_lchflags(PyObject
*self
, PyObject
*args
)
1916 unsigned long flags
;
1918 if (!PyArg_ParseTuple(args
, "etk:lchflags",
1919 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1921 Py_BEGIN_ALLOW_THREADS
1922 res
= lchflags(path
, flags
);
1923 Py_END_ALLOW_THREADS
1925 return posix_error_with_allocated_filename(path
);
1930 #endif /* HAVE_LCHFLAGS */
1933 PyDoc_STRVAR(posix_chroot__doc__
,
1935 Change root directory to path.");
1938 posix_chroot(PyObject
*self
, PyObject
*args
)
1940 return posix_1str(args
, "et:chroot", chroot
);
1945 PyDoc_STRVAR(posix_fsync__doc__
,
1947 force write of file with filedescriptor to disk.");
1950 posix_fsync(PyObject
*self
, PyObject
*fdobj
)
1952 return posix_fildes(fdobj
, fsync
);
1954 #endif /* HAVE_FSYNC */
1956 #ifdef HAVE_FDATASYNC
1959 extern int fdatasync(int); /* On HP-UX, in libc but not in unistd.h */
1962 PyDoc_STRVAR(posix_fdatasync__doc__
,
1963 "fdatasync(fildes)\n\n\
1964 force write of file with filedescriptor to disk.\n\
1965 does not force update of metadata.");
1968 posix_fdatasync(PyObject
*self
, PyObject
*fdobj
)
1970 return posix_fildes(fdobj
, fdatasync
);
1972 #endif /* HAVE_FDATASYNC */
1976 PyDoc_STRVAR(posix_chown__doc__
,
1977 "chown(path, uid, gid)\n\n\
1978 Change the owner and group id of path to the numeric uid and gid.");
1981 posix_chown(PyObject
*self
, PyObject
*args
)
1986 if (!PyArg_ParseTuple(args
, "etll:chown",
1987 Py_FileSystemDefaultEncoding
, &path
,
1990 Py_BEGIN_ALLOW_THREADS
1991 res
= chown(path
, (uid_t
) uid
, (gid_t
) gid
);
1992 Py_END_ALLOW_THREADS
1994 return posix_error_with_allocated_filename(path
);
1999 #endif /* HAVE_CHOWN */
2002 PyDoc_STRVAR(posix_fchown__doc__
,
2003 "fchown(fd, uid, gid)\n\n\
2004 Change the owner and group id of the file given by file descriptor\n\
2005 fd to the numeric uid and gid.");
2008 posix_fchown(PyObject
*self
, PyObject
*args
)
2012 if (!PyArg_ParseTuple(args
, "iii:chown", &fd
, &uid
, &gid
))
2014 Py_BEGIN_ALLOW_THREADS
2015 res
= fchown(fd
, (uid_t
) uid
, (gid_t
) gid
);
2016 Py_END_ALLOW_THREADS
2018 return posix_error();
2021 #endif /* HAVE_FCHOWN */
2024 PyDoc_STRVAR(posix_lchown__doc__
,
2025 "lchown(path, uid, gid)\n\n\
2026 Change the owner and group id of path to the numeric uid and gid.\n\
2027 This function will not follow symbolic links.");
2030 posix_lchown(PyObject
*self
, PyObject
*args
)
2035 if (!PyArg_ParseTuple(args
, "etii:lchown",
2036 Py_FileSystemDefaultEncoding
, &path
,
2039 Py_BEGIN_ALLOW_THREADS
2040 res
= lchown(path
, (uid_t
) uid
, (gid_t
) gid
);
2041 Py_END_ALLOW_THREADS
2043 return posix_error_with_allocated_filename(path
);
2048 #endif /* HAVE_LCHOWN */
2052 PyDoc_STRVAR(posix_getcwd__doc__
,
2053 "getcwd() -> path\n\n\
2054 Return a string representing the current working directory.");
2057 posix_getcwd(PyObject
*self
, PyObject
*noargs
)
2059 int bufsize_incr
= 1024;
2061 char *tmpbuf
= NULL
;
2063 PyObject
*dynamic_return
;
2065 Py_BEGIN_ALLOW_THREADS
2067 bufsize
= bufsize
+ bufsize_incr
;
2068 tmpbuf
= malloc(bufsize
);
2069 if (tmpbuf
== NULL
) {
2072 #if defined(PYOS_OS2) && defined(PYCC_GCC)
2073 res
= _getcwd2(tmpbuf
, bufsize
);
2075 res
= getcwd(tmpbuf
, bufsize
);
2081 } while ((res
== NULL
) && (errno
== ERANGE
));
2082 Py_END_ALLOW_THREADS
2085 return posix_error();
2087 dynamic_return
= PyString_FromString(tmpbuf
);
2090 return dynamic_return
;
2093 #ifdef Py_USING_UNICODE
2094 PyDoc_STRVAR(posix_getcwdu__doc__
,
2095 "getcwdu() -> path\n\n\
2096 Return a unicode string representing the current working directory.");
2099 posix_getcwdu(PyObject
*self
, PyObject
*noargs
)
2104 #ifdef Py_WIN_WIDE_FILENAMES
2106 if (unicode_file_names()) {
2108 wchar_t *wbuf2
= wbuf
;
2110 Py_BEGIN_ALLOW_THREADS
2111 len
= GetCurrentDirectoryW(sizeof wbuf
/ sizeof wbuf
[0], wbuf
);
2112 /* If the buffer is large enough, len does not include the
2113 terminating \0. If the buffer is too small, len includes
2114 the space needed for the terminator. */
2115 if (len
>= sizeof wbuf
/ sizeof wbuf
[0]) {
2116 wbuf2
= malloc(len
* sizeof(wchar_t));
2118 len
= GetCurrentDirectoryW(len
, wbuf2
);
2120 Py_END_ALLOW_THREADS
2126 if (wbuf2
!= wbuf
) free(wbuf2
);
2127 return win32_error("getcwdu", NULL
);
2129 resobj
= PyUnicode_FromWideChar(wbuf2
, len
);
2130 if (wbuf2
!= wbuf
) free(wbuf2
);
2135 Py_BEGIN_ALLOW_THREADS
2136 #if defined(PYOS_OS2) && defined(PYCC_GCC)
2137 res
= _getcwd2(buf
, sizeof buf
);
2139 res
= getcwd(buf
, sizeof buf
);
2141 Py_END_ALLOW_THREADS
2143 return posix_error();
2144 return PyUnicode_Decode(buf
, strlen(buf
), Py_FileSystemDefaultEncoding
,"strict");
2151 PyDoc_STRVAR(posix_link__doc__
,
2152 "link(src, dst)\n\n\
2153 Create a hard link to a file.");
2156 posix_link(PyObject
*self
, PyObject
*args
)
2158 return posix_2str(args
, "etet:link", link
);
2160 #endif /* HAVE_LINK */
2163 PyDoc_STRVAR(posix_listdir__doc__
,
2164 "listdir(path) -> list_of_strings\n\n\
2165 Return a list containing the names of the entries in the directory.\n\
2167 path: path of directory to list\n\
2169 The list is in arbitrary order. It does not include the special\n\
2170 entries '.' and '..' even if they are present in the directory.");
2173 posix_listdir(PyObject
*self
, PyObject
*args
)
2175 /* XXX Should redo this putting the (now four) versions of opendir
2176 in separate files instead of having them all here... */
2177 #if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)
2182 WIN32_FIND_DATA FileData
;
2183 char namebuf
[MAX_PATH
+5]; /* Overallocate for \\*.*\0 */
2184 char *bufptr
= namebuf
;
2185 Py_ssize_t len
= sizeof(namebuf
)-5; /* only claim to have space for MAX_PATH */
2187 #ifdef Py_WIN_WIDE_FILENAMES
2188 /* If on wide-character-capable OS see if argument
2189 is Unicode and if so use wide API. */
2190 if (unicode_file_names()) {
2192 if (PyArg_ParseTuple(args
, "U:listdir", &po
)) {
2193 WIN32_FIND_DATAW wFileData
;
2194 Py_UNICODE
*wnamebuf
;
2196 /* Overallocate for \\*.*\0 */
2197 len
= PyUnicode_GET_SIZE(po
);
2198 wnamebuf
= malloc((len
+ 5) * sizeof(wchar_t));
2203 wcscpy(wnamebuf
, PyUnicode_AS_UNICODE(po
));
2204 wch
= len
> 0 ? wnamebuf
[len
-1] : '\0';
2205 if (wch
!= L
'/' && wch
!= L
'\\' && wch
!= L
':')
2206 wnamebuf
[len
++] = L
'\\';
2207 wcscpy(wnamebuf
+ len
, L
"*.*");
2208 if ((d
= PyList_New(0)) == NULL
) {
2212 hFindFile
= FindFirstFileW(wnamebuf
, &wFileData
);
2213 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2214 int error
= GetLastError();
2215 if (error
== ERROR_FILE_NOT_FOUND
) {
2220 win32_error_unicode("FindFirstFileW", wnamebuf
);
2225 /* Skip over . and .. */
2226 if (wcscmp(wFileData
.cFileName
, L
".") != 0 &&
2227 wcscmp(wFileData
.cFileName
, L
"..") != 0) {
2228 v
= PyUnicode_FromUnicode(wFileData
.cFileName
, wcslen(wFileData
.cFileName
));
2234 if (PyList_Append(d
, v
) != 0) {
2242 Py_BEGIN_ALLOW_THREADS
2243 result
= FindNextFileW(hFindFile
, &wFileData
);
2244 Py_END_ALLOW_THREADS
2245 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2246 it got to the end of the directory. */
2247 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2249 win32_error_unicode("FindNextFileW", wnamebuf
);
2250 FindClose(hFindFile
);
2254 } while (result
== TRUE
);
2256 if (FindClose(hFindFile
) == FALSE
) {
2258 win32_error_unicode("FindClose", wnamebuf
);
2265 /* Drop the argument parsing error as narrow strings
2271 if (!PyArg_ParseTuple(args
, "et#:listdir",
2272 Py_FileSystemDefaultEncoding
, &bufptr
, &len
))
2275 char ch
= namebuf
[len
-1];
2276 if (ch
!= SEP
&& ch
!= ALTSEP
&& ch
!= ':')
2277 namebuf
[len
++] = '/';
2279 strcpy(namebuf
+ len
, "*.*");
2281 if ((d
= PyList_New(0)) == NULL
)
2284 hFindFile
= FindFirstFile(namebuf
, &FileData
);
2285 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2286 int error
= GetLastError();
2287 if (error
== ERROR_FILE_NOT_FOUND
)
2290 return win32_error("FindFirstFile", namebuf
);
2293 /* Skip over . and .. */
2294 if (strcmp(FileData
.cFileName
, ".") != 0 &&
2295 strcmp(FileData
.cFileName
, "..") != 0) {
2296 v
= PyString_FromString(FileData
.cFileName
);
2302 if (PyList_Append(d
, v
) != 0) {
2310 Py_BEGIN_ALLOW_THREADS
2311 result
= FindNextFile(hFindFile
, &FileData
);
2312 Py_END_ALLOW_THREADS
2313 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2314 it got to the end of the directory. */
2315 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2317 win32_error("FindNextFile", namebuf
);
2318 FindClose(hFindFile
);
2321 } while (result
== TRUE
);
2323 if (FindClose(hFindFile
) == FALSE
) {
2325 return win32_error("FindClose", namebuf
);
2330 #elif defined(PYOS_OS2)
2333 #define MAX_PATH CCHMAXPATH
2338 char namebuf
[MAX_PATH
+5];
2344 if (!PyArg_ParseTuple(args
, "t#:listdir", &name
, &len
))
2346 if (len
>= MAX_PATH
) {
2347 PyErr_SetString(PyExc_ValueError
, "path too long");
2350 strcpy(namebuf
, name
);
2351 for (pt
= namebuf
; *pt
; pt
++)
2354 if (namebuf
[len
-1] != SEP
)
2355 namebuf
[len
++] = SEP
;
2356 strcpy(namebuf
+ len
, "*.*");
2358 if ((d
= PyList_New(0)) == NULL
)
2361 rc
= DosFindFirst(namebuf
, /* Wildcard Pattern to Match */
2362 &hdir
, /* Handle to Use While Search Directory */
2363 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
2364 &ep
, sizeof(ep
), /* Structure to Receive Directory Entry */
2365 &srchcnt
, /* Max and Actual Count of Entries Per Iteration */
2366 FIL_STANDARD
); /* Format of Entry (EAs or Not) */
2368 if (rc
!= NO_ERROR
) {
2370 return posix_error_with_filename(name
);
2373 if (srchcnt
> 0) { /* If Directory is NOT Totally Empty, */
2375 if (ep
.achName
[0] == '.'
2376 && (ep
.achName
[1] == '\0' || (ep
.achName
[1] == '.' && ep
.achName
[2] == '\0')))
2377 continue; /* Skip Over "." and ".." Names */
2379 strcpy(namebuf
, ep
.achName
);
2381 /* Leave Case of Name Alone -- In Native Form */
2382 /* (Removed Forced Lowercasing Code) */
2384 v
= PyString_FromString(namebuf
);
2390 if (PyList_Append(d
, v
) != 0) {
2397 } while (DosFindNext(hdir
, &ep
, sizeof(ep
), &srchcnt
) == NO_ERROR
&& srchcnt
> 0);
2407 int arg_is_unicode
= 1;
2410 if (!PyArg_ParseTuple(args
, "U:listdir", &v
)) {
2414 if (!PyArg_ParseTuple(args
, "et:listdir", Py_FileSystemDefaultEncoding
, &name
))
2416 if ((dirp
= opendir(name
)) == NULL
) {
2417 return posix_error_with_allocated_filename(name
);
2419 if ((d
= PyList_New(0)) == NULL
) {
2426 Py_BEGIN_ALLOW_THREADS
2428 Py_END_ALLOW_THREADS
2435 return posix_error_with_allocated_filename(name
);
2438 if (ep
->d_name
[0] == '.' &&
2440 (ep
->d_name
[1] == '.' && NAMLEN(ep
) == 2)))
2442 v
= PyString_FromStringAndSize(ep
->d_name
, NAMLEN(ep
));
2448 #ifdef Py_USING_UNICODE
2449 if (arg_is_unicode
) {
2452 w
= PyUnicode_FromEncodedObject(v
,
2453 Py_FileSystemDefaultEncoding
,
2460 /* fall back to the original byte string, as
2461 discussed in patch #683592 */
2466 if (PyList_Append(d
, v
) != 0) {
2479 #endif /* which OS */
2480 } /* end of posix_listdir */
2483 /* A helper function for abspath on win32 */
2485 posix__getfullpathname(PyObject
*self
, PyObject
*args
)
2487 /* assume encoded strings won't more than double no of chars */
2488 char inbuf
[MAX_PATH
*2];
2489 char *inbufp
= inbuf
;
2490 Py_ssize_t insize
= sizeof(inbuf
);
2491 char outbuf
[MAX_PATH
*2];
2493 #ifdef Py_WIN_WIDE_FILENAMES
2494 if (unicode_file_names()) {
2495 PyUnicodeObject
*po
;
2496 if (PyArg_ParseTuple(args
, "U|:_getfullpathname", &po
)) {
2497 Py_UNICODE
*wpath
= PyUnicode_AS_UNICODE(po
);
2498 Py_UNICODE woutbuf
[MAX_PATH
*2], *woutbufp
= woutbuf
;
2502 result
= GetFullPathNameW(wpath
,
2503 sizeof(woutbuf
)/sizeof(woutbuf
[0]),
2505 if (result
> sizeof(woutbuf
)/sizeof(woutbuf
[0])) {
2506 woutbufp
= malloc(result
* sizeof(Py_UNICODE
));
2508 return PyErr_NoMemory();
2509 result
= GetFullPathNameW(wpath
, result
, woutbufp
, &wtemp
);
2512 v
= PyUnicode_FromUnicode(woutbufp
, wcslen(woutbufp
));
2514 v
= win32_error_unicode("GetFullPathNameW", wpath
);
2515 if (woutbufp
!= woutbuf
)
2519 /* Drop the argument parsing error as narrow strings
2524 if (!PyArg_ParseTuple (args
, "et#:_getfullpathname",
2525 Py_FileSystemDefaultEncoding
, &inbufp
,
2528 if (!GetFullPathName(inbuf
, sizeof(outbuf
)/sizeof(outbuf
[0]),
2530 return win32_error("GetFullPathName", inbuf
);
2531 if (PyUnicode_Check(PyTuple_GetItem(args
, 0))) {
2532 return PyUnicode_Decode(outbuf
, strlen(outbuf
),
2533 Py_FileSystemDefaultEncoding
, NULL
);
2535 return PyString_FromString(outbuf
);
2536 } /* end of posix__getfullpathname */
2537 #endif /* MS_WINDOWS */
2539 PyDoc_STRVAR(posix_mkdir__doc__
,
2540 "mkdir(path [, mode=0777])\n\n\
2541 Create a directory.");
2544 posix_mkdir(PyObject
*self
, PyObject
*args
)
2550 #ifdef Py_WIN_WIDE_FILENAMES
2551 if (unicode_file_names()) {
2552 PyUnicodeObject
*po
;
2553 if (PyArg_ParseTuple(args
, "U|i:mkdir", &po
, &mode
)) {
2554 Py_BEGIN_ALLOW_THREADS
2555 /* PyUnicode_AS_UNICODE OK without thread lock as
2556 it is a simple dereference. */
2557 res
= CreateDirectoryW(PyUnicode_AS_UNICODE(po
), NULL
);
2558 Py_END_ALLOW_THREADS
2560 return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po
));
2564 /* Drop the argument parsing error as narrow strings
2568 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2569 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2571 Py_BEGIN_ALLOW_THREADS
2572 /* PyUnicode_AS_UNICODE OK without thread lock as
2573 it is a simple dereference. */
2574 res
= CreateDirectoryA(path
, NULL
);
2575 Py_END_ALLOW_THREADS
2577 win32_error("mkdir", path
);
2586 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2587 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2589 Py_BEGIN_ALLOW_THREADS
2590 #if ( defined(__WATCOMC__) || defined(PYCC_VACPP) ) && !defined(__QNX__)
2593 res
= mkdir(path
, mode
);
2595 Py_END_ALLOW_THREADS
2597 return posix_error_with_allocated_filename(path
);
2605 /* sys/resource.h is needed for at least: wait3(), wait4(), broken nice. */
2606 #if defined(HAVE_SYS_RESOURCE_H)
2607 #include <sys/resource.h>
2612 PyDoc_STRVAR(posix_nice__doc__
,
2613 "nice(inc) -> new_priority\n\n\
2614 Decrease the priority of process by inc and return the new priority.");
2617 posix_nice(PyObject
*self
, PyObject
*args
)
2619 int increment
, value
;
2621 if (!PyArg_ParseTuple(args
, "i:nice", &increment
))
2624 /* There are two flavours of 'nice': one that returns the new
2625 priority (as required by almost all standards out there) and the
2626 Linux/FreeBSD/BSDI one, which returns '0' on success and advices
2627 the use of getpriority() to get the new priority.
2629 If we are of the nice family that returns the new priority, we
2630 need to clear errno before the call, and check if errno is filled
2631 before calling posix_error() on a returnvalue of -1, because the
2632 -1 may be the actual new priority! */
2635 value
= nice(increment
);
2636 #if defined(HAVE_BROKEN_NICE) && defined(HAVE_GETPRIORITY)
2638 value
= getpriority(PRIO_PROCESS
, 0);
2640 if (value
== -1 && errno
!= 0)
2641 /* either nice() or getpriority() returned an error */
2642 return posix_error();
2643 return PyInt_FromLong((long) value
);
2645 #endif /* HAVE_NICE */
2647 PyDoc_STRVAR(posix_rename__doc__
,
2648 "rename(old, new)\n\n\
2649 Rename a file or directory.");
2652 posix_rename(PyObject
*self
, PyObject
*args
)
2658 if (unicode_file_names()) {
2659 if (!PyArg_ParseTuple(args
, "OO:rename", &o1
, &o2
))
2661 if (!convert_to_unicode(&o1
))
2663 if (!convert_to_unicode(&o2
)) {
2667 Py_BEGIN_ALLOW_THREADS
2668 result
= MoveFileW(PyUnicode_AsUnicode(o1
),
2669 PyUnicode_AsUnicode(o2
));
2670 Py_END_ALLOW_THREADS
2674 return win32_error("rename", NULL
);
2680 if (!PyArg_ParseTuple(args
, "ss:rename", &p1
, &p2
))
2682 Py_BEGIN_ALLOW_THREADS
2683 result
= MoveFileA(p1
, p2
);
2684 Py_END_ALLOW_THREADS
2686 return win32_error("rename", NULL
);
2690 return posix_2str(args
, "etet:rename", rename
);
2695 PyDoc_STRVAR(posix_rmdir__doc__
,
2697 Remove a directory.");
2700 posix_rmdir(PyObject
*self
, PyObject
*args
)
2703 return win32_1str(args
, "rmdir", "s:rmdir", RemoveDirectoryA
, "U:rmdir", RemoveDirectoryW
);
2705 return posix_1str(args
, "et:rmdir", rmdir
);
2710 PyDoc_STRVAR(posix_stat__doc__
,
2711 "stat(path) -> stat result\n\n\
2712 Perform a stat system call on the given path.");
2715 posix_stat(PyObject
*self
, PyObject
*args
)
2718 return posix_do_stat(self
, args
, "et:stat", STAT
, "U:stat", win32_wstat
);
2720 return posix_do_stat(self
, args
, "et:stat", STAT
, NULL
, NULL
);
2726 PyDoc_STRVAR(posix_system__doc__
,
2727 "system(command) -> exit_status\n\n\
2728 Execute the command (a string) in a subshell.");
2731 posix_system(PyObject
*self
, PyObject
*args
)
2735 if (!PyArg_ParseTuple(args
, "s:system", &command
))
2737 Py_BEGIN_ALLOW_THREADS
2738 sts
= system(command
);
2739 Py_END_ALLOW_THREADS
2740 return PyInt_FromLong(sts
);
2745 PyDoc_STRVAR(posix_umask__doc__
,
2746 "umask(new_mask) -> old_mask\n\n\
2747 Set the current numeric umask and return the previous umask.");
2750 posix_umask(PyObject
*self
, PyObject
*args
)
2753 if (!PyArg_ParseTuple(args
, "i:umask", &i
))
2757 return posix_error();
2758 return PyInt_FromLong((long)i
);
2762 PyDoc_STRVAR(posix_unlink__doc__
,
2764 Remove a file (same as remove(path)).");
2766 PyDoc_STRVAR(posix_remove__doc__
,
2768 Remove a file (same as unlink(path)).");
2771 posix_unlink(PyObject
*self
, PyObject
*args
)
2774 return win32_1str(args
, "remove", "s:remove", DeleteFileA
, "U:remove", DeleteFileW
);
2776 return posix_1str(args
, "et:remove", unlink
);
2782 PyDoc_STRVAR(posix_uname__doc__
,
2783 "uname() -> (sysname, nodename, release, version, machine)\n\n\
2784 Return a tuple identifying the current operating system.");
2787 posix_uname(PyObject
*self
, PyObject
*noargs
)
2792 Py_BEGIN_ALLOW_THREADS
2794 Py_END_ALLOW_THREADS
2796 return posix_error();
2797 return Py_BuildValue("(sssss)",
2804 #endif /* HAVE_UNAME */
2807 extract_time(PyObject
*t
, long* sec
, long* usec
)
2810 if (PyFloat_Check(t
)) {
2811 double tval
= PyFloat_AsDouble(t
);
2812 PyObject
*intobj
= Py_TYPE(t
)->tp_as_number
->nb_int(t
);
2815 intval
= PyInt_AsLong(intobj
);
2817 if (intval
== -1 && PyErr_Occurred())
2820 *usec
= (long)((tval
- intval
) * 1e6
); /* can't exceed 1000000 */
2822 /* If rounding gave us a negative number,
2827 intval
= PyInt_AsLong(t
);
2828 if (intval
== -1 && PyErr_Occurred())
2835 PyDoc_STRVAR(posix_utime__doc__
,
2836 "utime(path, (atime, mtime))\n\
2837 utime(path, None)\n\n\
2838 Set the access and modified time of the file to the given values. If the\n\
2839 second form is used, set the access and modified times to the current time.");
2842 posix_utime(PyObject
*self
, PyObject
*args
)
2844 #ifdef Py_WIN_WIDE_FILENAMES
2846 PyUnicodeObject
*obwpath
;
2847 wchar_t *wpath
= NULL
;
2850 long atimesec
, mtimesec
, ausec
, musec
;
2851 FILETIME atime
, mtime
;
2852 PyObject
*result
= NULL
;
2854 if (unicode_file_names()) {
2855 if (PyArg_ParseTuple(args
, "UO|:utime", &obwpath
, &arg
)) {
2856 wpath
= PyUnicode_AS_UNICODE(obwpath
);
2857 Py_BEGIN_ALLOW_THREADS
2858 hFile
= CreateFileW(wpath
, FILE_WRITE_ATTRIBUTES
, 0,
2859 NULL
, OPEN_EXISTING
,
2860 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2861 Py_END_ALLOW_THREADS
2862 if (hFile
== INVALID_HANDLE_VALUE
)
2863 return win32_error_unicode("utime", wpath
);
2865 /* Drop the argument parsing error as narrow strings
2870 if (!PyArg_ParseTuple(args
, "etO:utime",
2871 Py_FileSystemDefaultEncoding
, &apath
, &arg
))
2873 Py_BEGIN_ALLOW_THREADS
2874 hFile
= CreateFileA(apath
, FILE_WRITE_ATTRIBUTES
, 0,
2875 NULL
, OPEN_EXISTING
,
2876 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2877 Py_END_ALLOW_THREADS
2878 if (hFile
== INVALID_HANDLE_VALUE
) {
2879 win32_error("utime", apath
);
2886 if (arg
== Py_None
) {
2888 GetSystemTime(&now
);
2889 if (!SystemTimeToFileTime(&now
, &mtime
) ||
2890 !SystemTimeToFileTime(&now
, &atime
)) {
2891 win32_error("utime", NULL
);
2895 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2896 PyErr_SetString(PyExc_TypeError
,
2897 "utime() arg 2 must be a tuple (atime, mtime)");
2901 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2902 &atimesec
, &ausec
) == -1)
2904 time_t_to_FILE_TIME(atimesec
, 1000*ausec
, &atime
);
2905 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2906 &mtimesec
, &musec
) == -1)
2908 time_t_to_FILE_TIME(mtimesec
, 1000*musec
, &mtime
);
2910 if (!SetFileTime(hFile
, NULL
, &atime
, &mtime
)) {
2911 /* Avoid putting the file name into the error here,
2912 as that may confuse the user into believing that
2913 something is wrong with the file, when it also
2914 could be the time stamp that gives a problem. */
2915 win32_error("utime", NULL
);
2922 #else /* Py_WIN_WIDE_FILENAMES */
2925 long atime
, mtime
, ausec
, musec
;
2929 #if defined(HAVE_UTIMES)
2930 struct timeval buf
[2];
2931 #define ATIME buf[0].tv_sec
2932 #define MTIME buf[1].tv_sec
2933 #elif defined(HAVE_UTIME_H)
2934 /* XXX should define struct utimbuf instead, above */
2936 #define ATIME buf.actime
2937 #define MTIME buf.modtime
2938 #define UTIME_ARG &buf
2939 #else /* HAVE_UTIMES */
2941 #define ATIME buf[0]
2942 #define MTIME buf[1]
2943 #define UTIME_ARG buf
2944 #endif /* HAVE_UTIMES */
2947 if (!PyArg_ParseTuple(args
, "etO:utime",
2948 Py_FileSystemDefaultEncoding
, &path
, &arg
))
2950 if (arg
== Py_None
) {
2951 /* optional time values not given */
2952 Py_BEGIN_ALLOW_THREADS
2953 res
= utime(path
, NULL
);
2954 Py_END_ALLOW_THREADS
2956 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2957 PyErr_SetString(PyExc_TypeError
,
2958 "utime() arg 2 must be a tuple (atime, mtime)");
2963 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2964 &atime
, &ausec
) == -1) {
2968 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2969 &mtime
, &musec
) == -1) {
2976 buf
[0].tv_usec
= ausec
;
2977 buf
[1].tv_usec
= musec
;
2978 Py_BEGIN_ALLOW_THREADS
2979 res
= utimes(path
, buf
);
2980 Py_END_ALLOW_THREADS
2982 Py_BEGIN_ALLOW_THREADS
2983 res
= utime(path
, UTIME_ARG
);
2984 Py_END_ALLOW_THREADS
2985 #endif /* HAVE_UTIMES */
2988 return posix_error_with_allocated_filename(path
);
2996 #endif /* Py_WIN_WIDE_FILENAMES */
3000 /* Process operations */
3002 PyDoc_STRVAR(posix__exit__doc__
,
3004 Exit to the system with specified status, without normal exit processing.");
3007 posix__exit(PyObject
*self
, PyObject
*args
)
3010 if (!PyArg_ParseTuple(args
, "i:_exit", &sts
))
3013 return NULL
; /* Make gcc -Wall happy */
3016 #if defined(HAVE_EXECV) || defined(HAVE_SPAWNV)
3018 free_string_array(char **array
, Py_ssize_t count
)
3021 for (i
= 0; i
< count
; i
++)
3022 PyMem_Free(array
[i
]);
3029 PyDoc_STRVAR(posix_execv__doc__
,
3030 "execv(path, args)\n\n\
3031 Execute an executable path with arguments, replacing current process.\n\
3033 path: path of executable file\n\
3034 args: tuple or list of strings");
3037 posix_execv(PyObject
*self
, PyObject
*args
)
3043 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3045 /* execv has two arguments: (path, argv), where
3046 argv is a list or tuple of strings. */
3048 if (!PyArg_ParseTuple(args
, "etO:execv",
3049 Py_FileSystemDefaultEncoding
,
3052 if (PyList_Check(argv
)) {
3053 argc
= PyList_Size(argv
);
3054 getitem
= PyList_GetItem
;
3056 else if (PyTuple_Check(argv
)) {
3057 argc
= PyTuple_Size(argv
);
3058 getitem
= PyTuple_GetItem
;
3061 PyErr_SetString(PyExc_TypeError
, "execv() arg 2 must be a tuple or list");
3066 argvlist
= PyMem_NEW(char *, argc
+1);
3067 if (argvlist
== NULL
) {
3069 return PyErr_NoMemory();
3071 for (i
= 0; i
< argc
; i
++) {
3072 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3073 Py_FileSystemDefaultEncoding
,
3075 free_string_array(argvlist
, i
);
3076 PyErr_SetString(PyExc_TypeError
,
3077 "execv() arg 2 must contain only strings");
3083 argvlist
[argc
] = NULL
;
3085 execv(path
, argvlist
);
3087 /* If we get here it's definitely an error */
3089 free_string_array(argvlist
, argc
);
3091 return posix_error();
3095 PyDoc_STRVAR(posix_execve__doc__
,
3096 "execve(path, args, env)\n\n\
3097 Execute a path with arguments and environment, replacing current process.\n\
3099 path: path of executable file\n\
3100 args: tuple or list of arguments\n\
3101 env: dictionary of strings mapping to strings");
3104 posix_execve(PyObject
*self
, PyObject
*args
)
3107 PyObject
*argv
, *env
;
3110 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
;
3111 Py_ssize_t i
, pos
, argc
, envc
;
3112 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3113 Py_ssize_t lastarg
= 0;
3115 /* execve has three arguments: (path, argv, env), where
3116 argv is a list or tuple of strings and env is a dictionary
3117 like posix.environ. */
3119 if (!PyArg_ParseTuple(args
, "etOO:execve",
3120 Py_FileSystemDefaultEncoding
,
3121 &path
, &argv
, &env
))
3123 if (PyList_Check(argv
)) {
3124 argc
= PyList_Size(argv
);
3125 getitem
= PyList_GetItem
;
3127 else if (PyTuple_Check(argv
)) {
3128 argc
= PyTuple_Size(argv
);
3129 getitem
= PyTuple_GetItem
;
3132 PyErr_SetString(PyExc_TypeError
,
3133 "execve() arg 2 must be a tuple or list");
3136 if (!PyMapping_Check(env
)) {
3137 PyErr_SetString(PyExc_TypeError
,
3138 "execve() arg 3 must be a mapping object");
3142 argvlist
= PyMem_NEW(char *, argc
+1);
3143 if (argvlist
== NULL
) {
3147 for (i
= 0; i
< argc
; i
++) {
3148 if (!PyArg_Parse((*getitem
)(argv
, i
),
3149 "et;execve() arg 2 must contain only strings",
3150 Py_FileSystemDefaultEncoding
,
3158 argvlist
[argc
] = NULL
;
3160 i
= PyMapping_Size(env
);
3163 envlist
= PyMem_NEW(char *, i
+ 1);
3164 if (envlist
== NULL
) {
3169 keys
= PyMapping_Keys(env
);
3170 vals
= PyMapping_Values(env
);
3173 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3174 PyErr_SetString(PyExc_TypeError
,
3175 "execve(): env.keys() or env.values() is not a list");
3179 for (pos
= 0; pos
< i
; pos
++) {
3183 key
= PyList_GetItem(keys
, pos
);
3184 val
= PyList_GetItem(vals
, pos
);
3190 "s;execve() arg 3 contains a non-string key",
3194 "s;execve() arg 3 contains a non-string value",
3200 #if defined(PYOS_OS2)
3201 /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
3202 if (stricmp(k
, "BEGINLIBPATH") != 0 && stricmp(k
, "ENDLIBPATH") != 0) {
3204 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3205 p
= PyMem_NEW(char, len
);
3210 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3211 envlist
[envc
++] = p
;
3212 #if defined(PYOS_OS2)
3218 execve(path
, argvlist
, envlist
);
3220 /* If we get here it's definitely an error */
3222 (void) posix_error();
3226 PyMem_DEL(envlist
[envc
]);
3229 free_string_array(argvlist
, lastarg
);
3236 #endif /* HAVE_EXECV */
3240 PyDoc_STRVAR(posix_spawnv__doc__
,
3241 "spawnv(mode, path, args)\n\n\
3242 Execute the program 'path' in a new process.\n\
3244 mode: mode of process creation\n\
3245 path: path of executable file\n\
3246 args: tuple or list of strings");
3249 posix_spawnv(PyObject
*self
, PyObject
*args
)
3256 Py_intptr_t spawnval
;
3257 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3259 /* spawnv has three arguments: (mode, path, argv), where
3260 argv is a list or tuple of strings. */
3262 if (!PyArg_ParseTuple(args
, "ietO:spawnv", &mode
,
3263 Py_FileSystemDefaultEncoding
,
3266 if (PyList_Check(argv
)) {
3267 argc
= PyList_Size(argv
);
3268 getitem
= PyList_GetItem
;
3270 else if (PyTuple_Check(argv
)) {
3271 argc
= PyTuple_Size(argv
);
3272 getitem
= PyTuple_GetItem
;
3275 PyErr_SetString(PyExc_TypeError
,
3276 "spawnv() arg 2 must be a tuple or list");
3281 argvlist
= PyMem_NEW(char *, argc
+1);
3282 if (argvlist
== NULL
) {
3284 return PyErr_NoMemory();
3286 for (i
= 0; i
< argc
; i
++) {
3287 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3288 Py_FileSystemDefaultEncoding
,
3290 free_string_array(argvlist
, i
);
3293 "spawnv() arg 2 must contain only strings");
3298 argvlist
[argc
] = NULL
;
3300 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3301 Py_BEGIN_ALLOW_THREADS
3302 spawnval
= spawnv(mode
, path
, argvlist
);
3303 Py_END_ALLOW_THREADS
3305 if (mode
== _OLD_P_OVERLAY
)
3308 Py_BEGIN_ALLOW_THREADS
3309 spawnval
= _spawnv(mode
, path
, argvlist
);
3310 Py_END_ALLOW_THREADS
3313 free_string_array(argvlist
, argc
);
3317 return posix_error();
3319 #if SIZEOF_LONG == SIZEOF_VOID_P
3320 return Py_BuildValue("l", (long) spawnval
);
3322 return Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3327 PyDoc_STRVAR(posix_spawnve__doc__
,
3328 "spawnve(mode, path, args, env)\n\n\
3329 Execute the program 'path' in a new process.\n\
3331 mode: mode of process creation\n\
3332 path: path of executable file\n\
3333 args: tuple or list of arguments\n\
3334 env: dictionary of strings mapping to strings");
3337 posix_spawnve(PyObject
*self
, PyObject
*args
)
3340 PyObject
*argv
, *env
;
3343 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3344 int mode
, pos
, envc
;
3346 Py_intptr_t spawnval
;
3347 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3348 Py_ssize_t lastarg
= 0;
3350 /* spawnve has four arguments: (mode, path, argv, env), where
3351 argv is a list or tuple of strings and env is a dictionary
3352 like posix.environ. */
3354 if (!PyArg_ParseTuple(args
, "ietOO:spawnve", &mode
,
3355 Py_FileSystemDefaultEncoding
,
3356 &path
, &argv
, &env
))
3358 if (PyList_Check(argv
)) {
3359 argc
= PyList_Size(argv
);
3360 getitem
= PyList_GetItem
;
3362 else if (PyTuple_Check(argv
)) {
3363 argc
= PyTuple_Size(argv
);
3364 getitem
= PyTuple_GetItem
;
3367 PyErr_SetString(PyExc_TypeError
,
3368 "spawnve() arg 2 must be a tuple or list");
3371 if (!PyMapping_Check(env
)) {
3372 PyErr_SetString(PyExc_TypeError
,
3373 "spawnve() arg 3 must be a mapping object");
3377 argvlist
= PyMem_NEW(char *, argc
+1);
3378 if (argvlist
== NULL
) {
3382 for (i
= 0; i
< argc
; i
++) {
3383 if (!PyArg_Parse((*getitem
)(argv
, i
),
3384 "et;spawnve() arg 2 must contain only strings",
3385 Py_FileSystemDefaultEncoding
,
3393 argvlist
[argc
] = NULL
;
3395 i
= PyMapping_Size(env
);
3398 envlist
= PyMem_NEW(char *, i
+ 1);
3399 if (envlist
== NULL
) {
3404 keys
= PyMapping_Keys(env
);
3405 vals
= PyMapping_Values(env
);
3408 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3409 PyErr_SetString(PyExc_TypeError
,
3410 "spawnve(): env.keys() or env.values() is not a list");
3414 for (pos
= 0; pos
< i
; pos
++) {
3418 key
= PyList_GetItem(keys
, pos
);
3419 val
= PyList_GetItem(vals
, pos
);
3425 "s;spawnve() arg 3 contains a non-string key",
3429 "s;spawnve() arg 3 contains a non-string value",
3434 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3435 p
= PyMem_NEW(char, len
);
3440 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3441 envlist
[envc
++] = p
;
3445 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3446 Py_BEGIN_ALLOW_THREADS
3447 spawnval
= spawnve(mode
, path
, argvlist
, envlist
);
3448 Py_END_ALLOW_THREADS
3450 if (mode
== _OLD_P_OVERLAY
)
3453 Py_BEGIN_ALLOW_THREADS
3454 spawnval
= _spawnve(mode
, path
, argvlist
, envlist
);
3455 Py_END_ALLOW_THREADS
3459 (void) posix_error();
3461 #if SIZEOF_LONG == SIZEOF_VOID_P
3462 res
= Py_BuildValue("l", (long) spawnval
);
3464 res
= Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3469 PyMem_DEL(envlist
[envc
]);
3472 free_string_array(argvlist
, lastarg
);
3480 /* OS/2 supports spawnvp & spawnvpe natively */
3481 #if defined(PYOS_OS2)
3482 PyDoc_STRVAR(posix_spawnvp__doc__
,
3483 "spawnvp(mode, file, args)\n\n\
3484 Execute the program 'file' in a new process, using the environment\n\
3485 search path to find the file.\n\
3487 mode: mode of process creation\n\
3488 file: executable file name\n\
3489 args: tuple or list of strings");
3492 posix_spawnvp(PyObject
*self
, PyObject
*args
)
3498 Py_intptr_t spawnval
;
3499 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3501 /* spawnvp has three arguments: (mode, path, argv), where
3502 argv is a list or tuple of strings. */
3504 if (!PyArg_ParseTuple(args
, "ietO:spawnvp", &mode
,
3505 Py_FileSystemDefaultEncoding
,
3508 if (PyList_Check(argv
)) {
3509 argc
= PyList_Size(argv
);
3510 getitem
= PyList_GetItem
;
3512 else if (PyTuple_Check(argv
)) {
3513 argc
= PyTuple_Size(argv
);
3514 getitem
= PyTuple_GetItem
;
3517 PyErr_SetString(PyExc_TypeError
,
3518 "spawnvp() arg 2 must be a tuple or list");
3523 argvlist
= PyMem_NEW(char *, argc
+1);
3524 if (argvlist
== NULL
) {
3526 return PyErr_NoMemory();
3528 for (i
= 0; i
< argc
; i
++) {
3529 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3530 Py_FileSystemDefaultEncoding
,
3532 free_string_array(argvlist
, i
);
3535 "spawnvp() arg 2 must contain only strings");
3540 argvlist
[argc
] = NULL
;
3542 Py_BEGIN_ALLOW_THREADS
3543 #if defined(PYCC_GCC)
3544 spawnval
= spawnvp(mode
, path
, argvlist
);
3546 spawnval
= _spawnvp(mode
, path
, argvlist
);
3548 Py_END_ALLOW_THREADS
3550 free_string_array(argvlist
, argc
);
3554 return posix_error();
3556 return Py_BuildValue("l", (long) spawnval
);
3560 PyDoc_STRVAR(posix_spawnvpe__doc__
,
3561 "spawnvpe(mode, file, args, env)\n\n\
3562 Execute the program 'file' in a new process, using the environment\n\
3563 search path to find the file.\n\
3565 mode: mode of process creation\n\
3566 file: executable file name\n\
3567 args: tuple or list of arguments\n\
3568 env: dictionary of strings mapping to strings");
3571 posix_spawnvpe(PyObject
*self
, PyObject
*args
)
3574 PyObject
*argv
, *env
;
3577 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3578 int mode
, i
, pos
, argc
, envc
;
3579 Py_intptr_t spawnval
;
3580 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3583 /* spawnvpe has four arguments: (mode, path, argv, env), where
3584 argv is a list or tuple of strings and env is a dictionary
3585 like posix.environ. */
3587 if (!PyArg_ParseTuple(args
, "ietOO:spawnvpe", &mode
,
3588 Py_FileSystemDefaultEncoding
,
3589 &path
, &argv
, &env
))
3591 if (PyList_Check(argv
)) {
3592 argc
= PyList_Size(argv
);
3593 getitem
= PyList_GetItem
;
3595 else if (PyTuple_Check(argv
)) {
3596 argc
= PyTuple_Size(argv
);
3597 getitem
= PyTuple_GetItem
;
3600 PyErr_SetString(PyExc_TypeError
,
3601 "spawnvpe() arg 2 must be a tuple or list");
3604 if (!PyMapping_Check(env
)) {
3605 PyErr_SetString(PyExc_TypeError
,
3606 "spawnvpe() arg 3 must be a mapping object");
3610 argvlist
= PyMem_NEW(char *, argc
+1);
3611 if (argvlist
== NULL
) {
3615 for (i
= 0; i
< argc
; i
++) {
3616 if (!PyArg_Parse((*getitem
)(argv
, i
),
3617 "et;spawnvpe() arg 2 must contain only strings",
3618 Py_FileSystemDefaultEncoding
,
3626 argvlist
[argc
] = NULL
;
3628 i
= PyMapping_Size(env
);
3631 envlist
= PyMem_NEW(char *, i
+ 1);
3632 if (envlist
== NULL
) {
3637 keys
= PyMapping_Keys(env
);
3638 vals
= PyMapping_Values(env
);
3641 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3642 PyErr_SetString(PyExc_TypeError
,
3643 "spawnvpe(): env.keys() or env.values() is not a list");
3647 for (pos
= 0; pos
< i
; pos
++) {
3651 key
= PyList_GetItem(keys
, pos
);
3652 val
= PyList_GetItem(vals
, pos
);
3658 "s;spawnvpe() arg 3 contains a non-string key",
3662 "s;spawnvpe() arg 3 contains a non-string value",
3667 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3668 p
= PyMem_NEW(char, len
);
3673 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3674 envlist
[envc
++] = p
;
3678 Py_BEGIN_ALLOW_THREADS
3679 #if defined(PYCC_GCC)
3680 spawnval
= spawnvpe(mode
, path
, argvlist
, envlist
);
3682 spawnval
= _spawnvpe(mode
, path
, argvlist
, envlist
);
3684 Py_END_ALLOW_THREADS
3687 (void) posix_error();
3689 res
= Py_BuildValue("l", (long) spawnval
);
3693 PyMem_DEL(envlist
[envc
]);
3696 free_string_array(argvlist
, lastarg
);
3703 #endif /* PYOS_OS2 */
3704 #endif /* HAVE_SPAWNV */
3708 PyDoc_STRVAR(posix_fork1__doc__
,
3709 "fork1() -> pid\n\n\
3710 Fork a child process with a single multiplexed (i.e., not bound) thread.\n\
3712 Return 0 to child process and PID of child to parent process.");
3715 posix_fork1(PyObject
*self
, PyObject
*noargs
)
3717 pid_t pid
= fork1();
3719 return posix_error();
3722 return PyInt_FromLong(pid
);
3728 PyDoc_STRVAR(posix_fork__doc__
,
3730 Fork a child process.\n\
3731 Return 0 to child process and PID of child to parent process.");
3734 posix_fork(PyObject
*self
, PyObject
*noargs
)
3738 return posix_error();
3741 return PyInt_FromLong(pid
);
3745 /* AIX uses /dev/ptc but is otherwise the same as /dev/ptmx */
3746 /* IRIX has both /dev/ptc and /dev/ptmx, use ptmx */
3747 #if defined(HAVE_DEV_PTC) && !defined(HAVE_DEV_PTMX)
3748 #define DEV_PTY_FILE "/dev/ptc"
3749 #define HAVE_DEV_PTMX
3751 #define DEV_PTY_FILE "/dev/ptmx"
3754 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX)
3758 #ifdef HAVE_LIBUTIL_H
3759 #include <libutil.h>
3760 #endif /* HAVE_LIBUTIL_H */
3761 #endif /* HAVE_PTY_H */
3762 #ifdef HAVE_STROPTS_H
3763 #include <stropts.h>
3765 #endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX */
3767 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
3768 PyDoc_STRVAR(posix_openpty__doc__
,
3769 "openpty() -> (master_fd, slave_fd)\n\n\
3770 Open a pseudo-terminal, returning open fd's for both master and slave end.\n");
3773 posix_openpty(PyObject
*self
, PyObject
*noargs
)
3775 int master_fd
, slave_fd
;
3776 #ifndef HAVE_OPENPTY
3779 #if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)
3780 PyOS_sighandler_t sig_saved
;
3782 extern char *ptsname(int fildes
);
3787 if (openpty(&master_fd
, &slave_fd
, NULL
, NULL
, NULL
) != 0)
3788 return posix_error();
3789 #elif defined(HAVE__GETPTY)
3790 slave_name
= _getpty(&master_fd
, O_RDWR
, 0666, 0);
3791 if (slave_name
== NULL
)
3792 return posix_error();
3794 slave_fd
= open(slave_name
, O_RDWR
);
3796 return posix_error();
3798 master_fd
= open(DEV_PTY_FILE
, O_RDWR
| O_NOCTTY
); /* open master */
3800 return posix_error();
3801 sig_saved
= PyOS_setsig(SIGCHLD
, SIG_DFL
);
3802 /* change permission of slave */
3803 if (grantpt(master_fd
) < 0) {
3804 PyOS_setsig(SIGCHLD
, sig_saved
);
3805 return posix_error();
3808 if (unlockpt(master_fd
) < 0) {
3809 PyOS_setsig(SIGCHLD
, sig_saved
);
3810 return posix_error();
3812 PyOS_setsig(SIGCHLD
, sig_saved
);
3813 slave_name
= ptsname(master_fd
); /* get name of slave */
3814 if (slave_name
== NULL
)
3815 return posix_error();
3816 slave_fd
= open(slave_name
, O_RDWR
| O_NOCTTY
); /* open slave */
3818 return posix_error();
3819 #if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)
3820 ioctl(slave_fd
, I_PUSH
, "ptem"); /* push ptem */
3821 ioctl(slave_fd
, I_PUSH
, "ldterm"); /* push ldterm */
3823 ioctl(slave_fd
, I_PUSH
, "ttcompat"); /* push ttcompat */
3825 #endif /* HAVE_CYGWIN */
3826 #endif /* HAVE_OPENPTY */
3828 return Py_BuildValue("(ii)", master_fd
, slave_fd
);
3831 #endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */
3834 PyDoc_STRVAR(posix_forkpty__doc__
,
3835 "forkpty() -> (pid, master_fd)\n\n\
3836 Fork a new process with a new pseudo-terminal as controlling tty.\n\n\
3837 Like fork(), return 0 as pid to child process, and PID of child to parent.\n\
3838 To both, return fd of newly opened pseudo-terminal.\n");
3841 posix_forkpty(PyObject
*self
, PyObject
*noargs
)
3846 pid
= forkpty(&master_fd
, NULL
, NULL
, NULL
);
3848 return posix_error();
3851 return Py_BuildValue("(li)", pid
, master_fd
);
3856 PyDoc_STRVAR(posix_getegid__doc__
,
3857 "getegid() -> egid\n\n\
3858 Return the current process's effective group id.");
3861 posix_getegid(PyObject
*self
, PyObject
*noargs
)
3863 return PyInt_FromLong((long)getegid());
3869 PyDoc_STRVAR(posix_geteuid__doc__
,
3870 "geteuid() -> euid\n\n\
3871 Return the current process's effective user id.");
3874 posix_geteuid(PyObject
*self
, PyObject
*noargs
)
3876 return PyInt_FromLong((long)geteuid());
3882 PyDoc_STRVAR(posix_getgid__doc__
,
3883 "getgid() -> gid\n\n\
3884 Return the current process's group id.");
3887 posix_getgid(PyObject
*self
, PyObject
*noargs
)
3889 return PyInt_FromLong((long)getgid());
3894 PyDoc_STRVAR(posix_getpid__doc__
,
3895 "getpid() -> pid\n\n\
3896 Return the current process id");
3899 posix_getpid(PyObject
*self
, PyObject
*noargs
)
3901 return PyInt_FromLong((long)getpid());
3905 #ifdef HAVE_GETGROUPS
3906 PyDoc_STRVAR(posix_getgroups__doc__
,
3907 "getgroups() -> list of group IDs\n\n\
3908 Return list of supplemental group IDs for the process.");
3911 posix_getgroups(PyObject
*self
, PyObject
*noargs
)
3913 PyObject
*result
= NULL
;
3916 #define MAX_GROUPS NGROUPS_MAX
3918 /* defined to be 16 on Solaris7, so this should be a small number */
3919 #define MAX_GROUPS 64
3921 gid_t grouplist
[MAX_GROUPS
];
3924 n
= getgroups(MAX_GROUPS
, grouplist
);
3928 result
= PyList_New(n
);
3929 if (result
!= NULL
) {
3931 for (i
= 0; i
< n
; ++i
) {
3932 PyObject
*o
= PyInt_FromLong((long)grouplist
[i
]);
3938 PyList_SET_ITEM(result
, i
, o
);
3948 PyDoc_STRVAR(posix_getpgid__doc__
,
3949 "getpgid(pid) -> pgid\n\n\
3950 Call the system call getpgid().");
3953 posix_getpgid(PyObject
*self
, PyObject
*args
)
3956 if (!PyArg_ParseTuple(args
, "i:getpgid", &pid
))
3958 pgid
= getpgid(pid
);
3960 return posix_error();
3961 return PyInt_FromLong((long)pgid
);
3963 #endif /* HAVE_GETPGID */
3967 PyDoc_STRVAR(posix_getpgrp__doc__
,
3968 "getpgrp() -> pgrp\n\n\
3969 Return the current process group id.");
3972 posix_getpgrp(PyObject
*self
, PyObject
*noargs
)
3974 #ifdef GETPGRP_HAVE_ARG
3975 return PyInt_FromLong((long)getpgrp(0));
3976 #else /* GETPGRP_HAVE_ARG */
3977 return PyInt_FromLong((long)getpgrp());
3978 #endif /* GETPGRP_HAVE_ARG */
3980 #endif /* HAVE_GETPGRP */
3984 PyDoc_STRVAR(posix_setpgrp__doc__
,
3986 Make this process a session leader.");
3989 posix_setpgrp(PyObject
*self
, PyObject
*noargs
)
3991 #ifdef SETPGRP_HAVE_ARG
3992 if (setpgrp(0, 0) < 0)
3993 #else /* SETPGRP_HAVE_ARG */
3995 #endif /* SETPGRP_HAVE_ARG */
3996 return posix_error();
4001 #endif /* HAVE_SETPGRP */
4004 PyDoc_STRVAR(posix_getppid__doc__
,
4005 "getppid() -> ppid\n\n\
4006 Return the parent's process id.");
4009 posix_getppid(PyObject
*self
, PyObject
*noargs
)
4011 return PyInt_FromLong(getppid());
4016 #ifdef HAVE_GETLOGIN
4017 PyDoc_STRVAR(posix_getlogin__doc__
,
4018 "getlogin() -> string\n\n\
4019 Return the actual login name.");
4022 posix_getlogin(PyObject
*self
, PyObject
*noargs
)
4024 PyObject
*result
= NULL
;
4026 int old_errno
= errno
;
4034 PyErr_SetString(PyExc_OSError
,
4035 "unable to determine login name");
4038 result
= PyString_FromString(name
);
4046 PyDoc_STRVAR(posix_getuid__doc__
,
4047 "getuid() -> uid\n\n\
4048 Return the current process's user id.");
4051 posix_getuid(PyObject
*self
, PyObject
*noargs
)
4053 return PyInt_FromLong((long)getuid());
4059 PyDoc_STRVAR(posix_kill__doc__
,
4060 "kill(pid, sig)\n\n\
4061 Kill a process with a signal.");
4064 posix_kill(PyObject
*self
, PyObject
*args
)
4068 if (!PyArg_ParseTuple(args
, "ii:kill", &pid
, &sig
))
4070 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
4071 if (sig
== XCPT_SIGNAL_INTR
|| sig
== XCPT_SIGNAL_BREAK
) {
4073 if ((rc
= DosSendSignalException(pid
, sig
)) != NO_ERROR
)
4074 return os2_error(rc
);
4076 } else if (sig
== XCPT_SIGNAL_KILLPROC
) {
4078 if ((rc
= DosKillProcess(DKP_PROCESS
, pid
)) != NO_ERROR
)
4079 return os2_error(rc
);
4082 return NULL
; /* Unrecognized Signal Requested */
4084 if (kill(pid
, sig
) == -1)
4085 return posix_error();
4093 PyDoc_STRVAR(posix_killpg__doc__
,
4094 "killpg(pgid, sig)\n\n\
4095 Kill a process group with a signal.");
4098 posix_killpg(PyObject
*self
, PyObject
*args
)
4101 if (!PyArg_ParseTuple(args
, "ii:killpg", &pgid
, &sig
))
4103 if (killpg(pgid
, sig
) == -1)
4104 return posix_error();
4112 #ifdef HAVE_SYS_LOCK_H
4113 #include <sys/lock.h>
4116 PyDoc_STRVAR(posix_plock__doc__
,
4118 Lock program segments into memory.");
4121 posix_plock(PyObject
*self
, PyObject
*args
)
4124 if (!PyArg_ParseTuple(args
, "i:plock", &op
))
4126 if (plock(op
) == -1)
4127 return posix_error();
4135 PyDoc_STRVAR(posix_popen__doc__
,
4136 "popen(command [, mode='r' [, bufsize]]) -> pipe\n\n\
4137 Open a pipe to/from a command returning a file object.");
4139 #if defined(PYOS_OS2)
4140 #if defined(PYCC_VACPP)
4142 async_system(const char *command
)
4144 char errormsg
[256], args
[1024];
4148 char *shell
= getenv("COMSPEC");
4152 /* avoid overflowing the argument buffer */
4153 if (strlen(shell
) + 3 + strlen(command
) >= 1024)
4154 return ERROR_NOT_ENOUGH_MEMORY
4157 strcat(args
, shell
);
4158 strcat(args
, "/c ");
4159 strcat(args
, command
);
4161 /* execute asynchronously, inheriting the environment */
4162 rc
= DosExecPgm(errormsg
,
4173 popen(const char *command
, const char *mode
, int pipesize
, int *err
)
4179 /* mode determines which of stdin or stdout is reconnected to
4180 * the pipe to the child
4182 if (strchr(mode
, 'r') != NULL
) {
4183 tgt_fd
= 1; /* stdout */
4184 } else if (strchr(mode
, 'w')) {
4185 tgt_fd
= 0; /* stdin */
4187 *err
= ERROR_INVALID_ACCESS
;
4191 /* setup the pipe */
4192 if ((rc
= DosCreatePipe(&pipeh
[0], &pipeh
[1], pipesize
)) != NO_ERROR
) {
4197 /* prevent other threads accessing stdio */
4200 /* reconnect stdio and execute child */
4203 if (dup2(pipeh
[tgtfd
], tgtfd
) == 0) {
4204 DosClose(pipeh
[tgtfd
]);
4205 rc
= async_system(command
);
4212 /* allow other threads access to stdio */
4215 /* if execution of child was successful return file stream */
4217 return fdopen(pipeh
[1 - tgtfd
], mode
);
4219 DosClose(pipeh
[1 - tgtfd
]);
4226 posix_popen(PyObject
*self
, PyObject
*args
)
4230 int err
, bufsize
= -1;
4233 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4235 Py_BEGIN_ALLOW_THREADS
4236 fp
= popen(name
, mode
, (bufsize
> 0) ? bufsize
: 4096, &err
);
4237 Py_END_ALLOW_THREADS
4239 return os2_error(err
);
4241 f
= PyFile_FromFile(fp
, name
, mode
, fclose
);
4243 PyFile_SetBufSize(f
, bufsize
);
4247 #elif defined(PYCC_GCC)
4249 /* standard posix version of popen() support */
4251 posix_popen(PyObject
*self
, PyObject
*args
)
4258 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4260 Py_BEGIN_ALLOW_THREADS
4261 fp
= popen(name
, mode
);
4262 Py_END_ALLOW_THREADS
4264 return posix_error();
4265 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
4267 PyFile_SetBufSize(f
, bufsize
);
4271 /* fork() under OS/2 has lots'o'warts
4272 * EMX supports pipe() and spawn*() so we can synthesize popen[234]()
4273 * most of this code is a ripoff of the win32 code, but using the
4274 * capabilities of EMX's C library routines
4277 /* These tell _PyPopen() whether to return 1, 2, or 3 file objects. */
4283 static PyObject
*_PyPopen(char *, int, int, int);
4284 static int _PyPclose(FILE *file
);
4287 * Internal dictionary mapping popen* file pointers to process handles,
4288 * for use when retrieving the process exit code. See _PyPclose() below
4289 * for more information on this dictionary's use.
4291 static PyObject
*_PyPopenProcs
= NULL
;
4293 /* os2emx version of popen2()
4295 * The result of this function is a pipe (file) connected to the
4296 * process's stdin, and a pipe connected to the process's stdout.
4300 os2emx_popen2(PyObject
*self
, PyObject
*args
)
4308 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4313 else if (*mode
!= 'b') {
4314 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4319 f
= _PyPopen(cmdstring
, tm
, POPEN_2
, bufsize
);
4325 * Variation on os2emx.popen2
4327 * The result of this function is 3 pipes - the process's stdin,
4332 os2emx_popen3(PyObject
*self
, PyObject
*args
)
4340 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4345 else if (*mode
!= 'b') {
4346 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4351 f
= _PyPopen(cmdstring
, tm
, POPEN_3
, bufsize
);
4357 * Variation on os2emx.popen2
4359 * The result of this function is 2 pipes - the processes stdin,
4360 * and stdout+stderr combined as a single pipe.
4364 os2emx_popen4(PyObject
*self
, PyObject
*args
)
4372 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4377 else if (*mode
!= 'b') {
4378 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4383 f
= _PyPopen(cmdstring
, tm
, POPEN_4
, bufsize
);
4388 /* a couple of structures for convenient handling of multiple
4389 * file handles and pipes
4403 /* The following code is derived from the win32 code */
4406 _PyPopen(char *cmdstring
, int mode
, int n
, int bufsize
)
4408 struct file_ref stdio
[3];
4409 struct pipe_ref p_fd
[3];
4411 int file_count
, i
, pipe_err
;
4413 char *shell
, *sh_name
, *opt
, *rd_mode
, *wr_mode
;
4414 PyObject
*f
, *p_f
[3];
4416 /* file modes for subsequent fdopen's on pipe handles */
4428 /* prepare shell references */
4429 if ((shell
= getenv("EMXSHELL")) == NULL
)
4430 if ((shell
= getenv("COMSPEC")) == NULL
)
4433 return posix_error();
4436 sh_name
= _getname(shell
);
4437 if (stricmp(sh_name
, "cmd.exe") == 0 || stricmp(sh_name
, "4os2.exe") == 0)
4442 /* save current stdio fds + their flags, and set not inheritable */
4444 while (pipe_err
>= 0 && i
< 3)
4446 pipe_err
= stdio
[i
].handle
= dup(i
);
4447 stdio
[i
].flags
= fcntl(i
, F_GETFD
, 0);
4448 fcntl(stdio
[i
].handle
, F_SETFD
, stdio
[i
].flags
| FD_CLOEXEC
);
4453 /* didn't get them all saved - clean up and bail out */
4454 int saved_err
= errno
;
4457 close(stdio
[i
].handle
);
4460 return posix_error();
4463 /* create pipe ends */
4468 while ((pipe_err
== 0) && (i
< file_count
))
4469 pipe_err
= pipe((int *)&p_fd
[i
++]);
4472 /* didn't get them all made - clean up and bail out */
4479 return posix_error();
4482 /* change the actual standard IO streams over temporarily,
4483 * making the retained pipe ends non-inheritable
4488 if (dup2(p_fd
[0].rd
, 0) == 0)
4491 i
= fcntl(p_fd
[0].wr
, F_GETFD
, 0);
4492 fcntl(p_fd
[0].wr
, F_SETFD
, i
| FD_CLOEXEC
);
4493 if ((p_s
[0] = fdopen(p_fd
[0].wr
, wr_mode
)) == NULL
)
4507 if (dup2(p_fd
[1].wr
, 1) == 1)
4510 i
= fcntl(p_fd
[1].rd
, F_GETFD
, 0);
4511 fcntl(p_fd
[1].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4512 if ((p_s
[1] = fdopen(p_fd
[1].rd
, rd_mode
)) == NULL
)
4524 /* - stderr, as required */
4530 if (dup2(p_fd
[2].wr
, 2) == 2)
4533 i
= fcntl(p_fd
[2].rd
, F_GETFD
, 0);
4534 fcntl(p_fd
[2].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4535 if ((p_s
[2] = fdopen(p_fd
[2].rd
, rd_mode
)) == NULL
)
4550 if (dup2(1, 2) != 2)
4558 /* spawn the child process */
4561 pipe_pid
= spawnlp(P_NOWAIT
, shell
, shell
, opt
, cmdstring
, (char *)0);
4568 /* save the PID into the FILE structure
4569 * NOTE: this implementation doesn't actually
4570 * take advantage of this, but do it for
4571 * completeness - AIM Apr01
4573 for (i
= 0; i
< file_count
; i
++)
4574 p_s
[i
]->_pid
= pipe_pid
;
4578 /* reset standard IO to normal */
4579 for (i
= 0; i
< 3; i
++)
4581 dup2(stdio
[i
].handle
, i
);
4582 fcntl(i
, F_SETFD
, stdio
[i
].flags
);
4583 close(stdio
[i
].handle
);
4586 /* if any remnant problems, clean up and bail out */
4589 for (i
= 0; i
< 3; i
++)
4595 return posix_error_with_filename(cmdstring
);
4598 /* build tuple of file objects to return */
4599 if ((p_f
[0] = PyFile_FromFile(p_s
[0], cmdstring
, wr_mode
, _PyPclose
)) != NULL
)
4600 PyFile_SetBufSize(p_f
[0], bufsize
);
4601 if ((p_f
[1] = PyFile_FromFile(p_s
[1], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4602 PyFile_SetBufSize(p_f
[1], bufsize
);
4605 if ((p_f
[2] = PyFile_FromFile(p_s
[2], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4606 PyFile_SetBufSize(p_f
[0], bufsize
);
4607 f
= PyTuple_Pack(3, p_f
[0], p_f
[1], p_f
[2]);
4610 f
= PyTuple_Pack(2, p_f
[0], p_f
[1]);
4613 * Insert the files we've created into the process dictionary
4614 * all referencing the list with the process handle and the
4615 * initial number of files (see description below in _PyPclose).
4616 * Since if _PyPclose later tried to wait on a process when all
4617 * handles weren't closed, it could create a deadlock with the
4618 * child, we spend some energy here to try to ensure that we
4619 * either insert all file handles into the dictionary or none
4620 * at all. It's a little clumsy with the various popen modes
4621 * and variable number of files involved.
4625 _PyPopenProcs
= PyDict_New();
4630 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
[3];
4633 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
4634 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
4636 procObj
= PyList_New(2);
4637 pidObj
= PyInt_FromLong((long) pipe_pid
);
4638 intObj
= PyInt_FromLong((long) file_count
);
4640 if (procObj
&& pidObj
&& intObj
)
4642 PyList_SetItem(procObj
, 0, pidObj
);
4643 PyList_SetItem(procObj
, 1, intObj
);
4645 fileObj
[0] = PyLong_FromVoidPtr(p_s
[0]);
4648 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
4652 fileObj
[1] = PyLong_FromVoidPtr(p_s
[1]);
4655 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
4659 if (file_count
>= 3)
4661 fileObj
[2] = PyLong_FromVoidPtr(p_s
[2]);
4664 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
4670 if (ins_rc
[0] < 0 || !fileObj
[0] ||
4671 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
4672 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2]))
4674 /* Something failed - remove any dictionary
4675 * entries that did make it.
4677 if (!ins_rc
[0] && fileObj
[0])
4679 PyDict_DelItem(_PyPopenProcs
,
4682 if (!ins_rc
[1] && fileObj
[1])
4684 PyDict_DelItem(_PyPopenProcs
,
4687 if (!ins_rc
[2] && fileObj
[2])
4689 PyDict_DelItem(_PyPopenProcs
,
4696 * Clean up our localized references for the dictionary keys
4697 * and value since PyDict_SetItem will Py_INCREF any copies
4698 * that got placed in the dictionary.
4700 Py_XDECREF(procObj
);
4701 Py_XDECREF(fileObj
[0]);
4702 Py_XDECREF(fileObj
[1]);
4703 Py_XDECREF(fileObj
[2]);
4706 /* Child is launched. */
4711 * Wrapper for fclose() to use for popen* files, so we can retrieve the
4712 * exit code for the child process and return as a result of the close.
4714 * This function uses the _PyPopenProcs dictionary in order to map the
4715 * input file pointer to information about the process that was
4716 * originally created by the popen* call that created the file pointer.
4717 * The dictionary uses the file pointer as a key (with one entry
4718 * inserted for each file returned by the original popen* call) and a
4719 * single list object as the value for all files from a single call.
4720 * The list object contains the Win32 process handle at [0], and a file
4721 * count at [1], which is initialized to the total number of file
4722 * handles using that list.
4724 * This function closes whichever handle it is passed, and decrements
4725 * the file count in the dictionary for the process handle pointed to
4726 * by this file. On the last close (when the file count reaches zero),
4727 * this function will wait for the child process and then return its
4728 * exit code as the result of the close() operation. This permits the
4729 * files to be closed in any order - it is always the close() of the
4730 * final handle that will return the exit code.
4732 * NOTE: This function is currently called with the GIL released.
4733 * hence we use the GILState API to manage our state.
4736 static int _PyPclose(FILE *file
)
4741 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
;
4744 PyGILState_STATE state
;
4747 /* Close the file handle first, to ensure it can't block the
4748 * child from exiting if it's the last handle.
4750 result
= fclose(file
);
4753 state
= PyGILState_Ensure();
4757 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
4758 (procObj
= PyDict_GetItem(_PyPopenProcs
,
4759 fileObj
)) != NULL
&&
4760 (pidObj
= PyList_GetItem(procObj
,0)) != NULL
&&
4761 (intObj
= PyList_GetItem(procObj
,1)) != NULL
)
4763 pipe_pid
= (int) PyInt_AsLong(pidObj
);
4764 file_count
= (int) PyInt_AsLong(intObj
);
4768 /* Still other files referencing process */
4770 PyList_SetItem(procObj
,1,
4771 PyInt_FromLong((long) file_count
));
4775 /* Last file for this process */
4776 if (result
!= EOF
&&
4777 waitpid(pipe_pid
, &exit_code
, 0) == pipe_pid
)
4779 /* extract exit status */
4780 if (WIFEXITED(exit_code
))
4782 result
= WEXITSTATUS(exit_code
);
4792 /* Indicate failure - this will cause the file object
4793 * to raise an I/O error and translate the last
4794 * error code from errno. We do have a problem with
4795 * last errors that overlap the normal errno table,
4796 * but that's a consistent problem with the file object.
4802 /* Remove this file pointer from dictionary */
4803 PyDict_DelItem(_PyPopenProcs
, fileObj
);
4805 if (PyDict_Size(_PyPopenProcs
) == 0)
4807 Py_DECREF(_PyPopenProcs
);
4808 _PyPopenProcs
= NULL
;
4811 } /* if object retrieval ok */
4813 Py_XDECREF(fileObj
);
4814 } /* if _PyPopenProcs */
4817 PyGILState_Release(state
);
4822 #endif /* PYCC_??? */
4824 #elif defined(MS_WINDOWS)
4827 * Portable 'popen' replacement for Win32.
4829 * Written by Bill Tutt <billtut@microsoft.com>. Minor tweaks
4830 * and 2.0 integration by Fredrik Lundh <fredrik@pythonware.com>
4831 * Return code handling by David Bolen <db3l@fitlinxx.com>.
4838 /* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */
4844 static PyObject
*_PyPopen(char *, int, int);
4845 static int _PyPclose(FILE *file
);
4848 * Internal dictionary mapping popen* file pointers to process handles,
4849 * for use when retrieving the process exit code. See _PyPclose() below
4850 * for more information on this dictionary's use.
4852 static PyObject
*_PyPopenProcs
= NULL
;
4855 /* popen that works from a GUI.
4857 * The result of this function is a pipe (file) connected to the
4858 * processes stdin or stdout, depending on the requested mode.
4862 posix_popen(PyObject
*self
, PyObject
*args
)
4870 if (!PyArg_ParseTuple(args
, "s|si:popen", &cmdstring
, &mode
, &bufsize
))
4875 else if (*mode
!= 'w') {
4876 PyErr_SetString(PyExc_ValueError
, "popen() arg 2 must be 'r' or 'w'");
4881 if (bufsize
!= -1) {
4882 PyErr_SetString(PyExc_ValueError
, "popen() arg 3 must be -1");
4886 if (*(mode
+1) == 't')
4887 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4888 else if (*(mode
+1) == 'b')
4889 f
= _PyPopen(cmdstring
, tm
| _O_BINARY
, POPEN_1
);
4891 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4896 /* Variation on win32pipe.popen
4898 * The result of this function is a pipe (file) connected to the
4899 * process's stdin, and a pipe connected to the process's stdout.
4903 win32_popen2(PyObject
*self
, PyObject
*args
)
4911 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4916 else if (*mode
!= 'b') {
4917 PyErr_SetString(PyExc_ValueError
, "popen2() arg 2 must be 't' or 'b'");
4922 if (bufsize
!= -1) {
4923 PyErr_SetString(PyExc_ValueError
, "popen2() arg 3 must be -1");
4927 f
= _PyPopen(cmdstring
, tm
, POPEN_2
);
4933 * Variation on <om win32pipe.popen>
4935 * The result of this function is 3 pipes - the process's stdin,
4940 win32_popen3(PyObject
*self
, PyObject
*args
)
4948 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4953 else if (*mode
!= 'b') {
4954 PyErr_SetString(PyExc_ValueError
, "popen3() arg 2 must be 't' or 'b'");
4959 if (bufsize
!= -1) {
4960 PyErr_SetString(PyExc_ValueError
, "popen3() arg 3 must be -1");
4964 f
= _PyPopen(cmdstring
, tm
, POPEN_3
);
4970 * Variation on win32pipe.popen
4972 * The result of this function is 2 pipes - the processes stdin,
4973 * and stdout+stderr combined as a single pipe.
4977 win32_popen4(PyObject
*self
, PyObject
*args
)
4985 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4990 else if (*mode
!= 'b') {
4991 PyErr_SetString(PyExc_ValueError
, "popen4() arg 2 must be 't' or 'b'");
4996 if (bufsize
!= -1) {
4997 PyErr_SetString(PyExc_ValueError
, "popen4() arg 3 must be -1");
5001 f
= _PyPopen(cmdstring
, tm
, POPEN_4
);
5007 _PyPopenCreateProcess(char *cmdstring
,
5013 PROCESS_INFORMATION piProcInfo
;
5014 STARTUPINFO siStartInfo
;
5015 DWORD dwProcessFlags
= 0; /* no NEW_CONSOLE by default for Ctrl+C handling */
5016 char *s1
,*s2
, *s3
= " /c ";
5017 const char *szConsoleSpawn
= "w9xpopen.exe";
5021 if (i
= GetEnvironmentVariable("COMSPEC",NULL
,0)) {
5024 s1
= (char *)alloca(i
);
5025 if (!(x
= GetEnvironmentVariable("COMSPEC", s1
, i
)))
5026 /* x < i, so x fits into an integer */
5029 /* Explicitly check if we are using COMMAND.COM. If we are
5030 * then use the w9xpopen hack.
5033 while (comshell
>= s1
&& *comshell
!= '\\')
5037 if (GetVersion() < 0x80000000 &&
5038 _stricmp(comshell
, "command.com") != 0) {
5039 /* NT/2000 and not using command.com. */
5040 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1;
5041 s2
= (char *)alloca(x
);
5043 PyOS_snprintf(s2
, x
, "%s%s%s", s1
, s3
, cmdstring
);
5047 * Oh gag, we're on Win9x or using COMMAND.COM. Use
5048 * the workaround listed in KB: Q150956
5050 char modulepath
[_MAX_PATH
];
5051 struct stat statinfo
;
5052 GetModuleFileName(NULL
, modulepath
, sizeof(modulepath
));
5053 for (x
= i
= 0; modulepath
[i
]; i
++)
5054 if (modulepath
[i
] == SEP
)
5056 modulepath
[x
] = '\0';
5057 /* Create the full-name to w9xpopen, so we can test it exists */
5060 (sizeof(modulepath
)/sizeof(modulepath
[0]))
5061 -strlen(modulepath
));
5062 if (stat(modulepath
, &statinfo
) != 0) {
5063 size_t mplen
= sizeof(modulepath
)/sizeof(modulepath
[0]);
5064 /* Eeek - file-not-found - possibly an embedding
5065 situation - see if we can locate it in sys.prefix
5070 modulepath
[mplen
-1] = '\0';
5071 if (modulepath
[strlen(modulepath
)-1] != '\\')
5072 strcat(modulepath
, "\\");
5075 mplen
-strlen(modulepath
));
5076 /* No where else to look - raise an easily identifiable
5077 error, rather than leaving Windows to report
5078 "file not found" - as the user is probably blissfully
5079 unaware this shim EXE is used, and it will confuse them.
5080 (well, it confused me for a while ;-)
5082 if (stat(modulepath
, &statinfo
) != 0) {
5083 PyErr_Format(PyExc_RuntimeError
,
5084 "Can not locate '%s' which is needed "
5085 "for popen to work with your shell "
5091 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1 +
5092 strlen(modulepath
) +
5093 strlen(szConsoleSpawn
) + 1;
5095 s2
= (char *)alloca(x
);
5097 /* To maintain correct argument passing semantics,
5098 we pass the command-line as it stands, and allow
5099 quoting to be applied. w9xpopen.exe will then
5100 use its argv vector, and re-quote the necessary
5101 args for the ultimate child process.
5110 /* Not passing CREATE_NEW_CONSOLE has been known to
5111 cause random failures on win9x. Specifically a
5113 "Your program accessed mem currently in use at xxx"
5114 and a hopeful warning about the stability of your
5116 Cost is Ctrl+C won't kill children, but anyone
5117 who cares can have a go!
5119 dwProcessFlags
|= CREATE_NEW_CONSOLE
;
5123 /* Could be an else here to try cmd.exe / command.com in the path
5124 Now we'll just error out.. */
5126 PyErr_SetString(PyExc_RuntimeError
,
5127 "Cannot locate a COMSPEC environment variable to "
5128 "use as the shell");
5132 ZeroMemory(&siStartInfo
, sizeof(STARTUPINFO
));
5133 siStartInfo
.cb
= sizeof(STARTUPINFO
);
5134 siStartInfo
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
5135 siStartInfo
.hStdInput
= hStdin
;
5136 siStartInfo
.hStdOutput
= hStdout
;
5137 siStartInfo
.hStdError
= hStderr
;
5138 siStartInfo
.wShowWindow
= SW_HIDE
;
5140 if (CreateProcess(NULL
,
5150 /* Close the handles now so anyone waiting is woken. */
5151 CloseHandle(piProcInfo
.hThread
);
5153 /* Return process handle */
5154 *hProcess
= piProcInfo
.hProcess
;
5157 win32_error("CreateProcess", s2
);
5161 /* The following code is based off of KB: Q190351 */
5164 _PyPopen(char *cmdstring
, int mode
, int n
)
5166 HANDLE hChildStdinRd
, hChildStdinWr
, hChildStdoutRd
, hChildStdoutWr
,
5167 hChildStderrRd
, hChildStderrWr
, hChildStdinWrDup
, hChildStdoutRdDup
,
5168 hChildStderrRdDup
, hProcess
; /* hChildStdoutWrDup; */
5170 SECURITY_ATTRIBUTES saAttr
;
5177 saAttr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
5178 saAttr
.bInheritHandle
= TRUE
;
5179 saAttr
.lpSecurityDescriptor
= NULL
;
5181 if (!CreatePipe(&hChildStdinRd
, &hChildStdinWr
, &saAttr
, 0))
5182 return win32_error("CreatePipe", NULL
);
5184 /* Create new output read handle and the input write handle. Set
5185 * the inheritance properties to FALSE. Otherwise, the child inherits
5186 * these handles; resulting in non-closeable handles to the pipes
5188 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdinWr
,
5189 GetCurrentProcess(), &hChildStdinWrDup
, 0,
5191 DUPLICATE_SAME_ACCESS
);
5193 return win32_error("DuplicateHandle", NULL
);
5195 /* Close the inheritable version of ChildStdin
5196 that we're using. */
5197 CloseHandle(hChildStdinWr
);
5199 if (!CreatePipe(&hChildStdoutRd
, &hChildStdoutWr
, &saAttr
, 0))
5200 return win32_error("CreatePipe", NULL
);
5202 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdoutRd
,
5203 GetCurrentProcess(), &hChildStdoutRdDup
, 0,
5204 FALSE
, DUPLICATE_SAME_ACCESS
);
5206 return win32_error("DuplicateHandle", NULL
);
5208 /* Close the inheritable version of ChildStdout
5209 that we're using. */
5210 CloseHandle(hChildStdoutRd
);
5213 if (!CreatePipe(&hChildStderrRd
, &hChildStderrWr
, &saAttr
, 0))
5214 return win32_error("CreatePipe", NULL
);
5215 fSuccess
= DuplicateHandle(GetCurrentProcess(),
5217 GetCurrentProcess(),
5218 &hChildStderrRdDup
, 0,
5219 FALSE
, DUPLICATE_SAME_ACCESS
);
5221 return win32_error("DuplicateHandle", NULL
);
5222 /* Close the inheritable version of ChildStdErr that we're using. */
5223 CloseHandle(hChildStderrRd
);
5228 switch (mode
& (_O_RDONLY
| _O_TEXT
| _O_BINARY
| _O_WRONLY
)) {
5229 case _O_WRONLY
| _O_TEXT
:
5230 /* Case for writing to child Stdin in text mode. */
5231 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5232 f1
= _fdopen(fd1
, "w");
5233 f
= PyFile_FromFile(f1
, cmdstring
, "w", _PyPclose
);
5234 PyFile_SetBufSize(f
, 0);
5235 /* We don't care about these pipes anymore, so close them. */
5236 CloseHandle(hChildStdoutRdDup
);
5237 CloseHandle(hChildStderrRdDup
);
5240 case _O_RDONLY
| _O_TEXT
:
5241 /* Case for reading from child Stdout in text mode. */
5242 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5243 f1
= _fdopen(fd1
, "r");
5244 f
= PyFile_FromFile(f1
, cmdstring
, "r", _PyPclose
);
5245 PyFile_SetBufSize(f
, 0);
5246 /* We don't care about these pipes anymore, so close them. */
5247 CloseHandle(hChildStdinWrDup
);
5248 CloseHandle(hChildStderrRdDup
);
5251 case _O_RDONLY
| _O_BINARY
:
5252 /* Case for readinig from child Stdout in binary mode. */
5253 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5254 f1
= _fdopen(fd1
, "rb");
5255 f
= PyFile_FromFile(f1
, cmdstring
, "rb", _PyPclose
);
5256 PyFile_SetBufSize(f
, 0);
5257 /* We don't care about these pipes anymore, so close them. */
5258 CloseHandle(hChildStdinWrDup
);
5259 CloseHandle(hChildStderrRdDup
);
5262 case _O_WRONLY
| _O_BINARY
:
5263 /* Case for writing to child Stdin in binary mode. */
5264 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5265 f1
= _fdopen(fd1
, "wb");
5266 f
= PyFile_FromFile(f1
, cmdstring
, "wb", _PyPclose
);
5267 PyFile_SetBufSize(f
, 0);
5268 /* We don't care about these pipes anymore, so close them. */
5269 CloseHandle(hChildStdoutRdDup
);
5270 CloseHandle(hChildStderrRdDup
);
5282 if (mode
& _O_TEXT
) {
5290 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5291 f1
= _fdopen(fd1
, m2
);
5292 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5293 f2
= _fdopen(fd2
, m1
);
5294 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5295 PyFile_SetBufSize(p1
, 0);
5296 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5297 PyFile_SetBufSize(p2
, 0);
5300 CloseHandle(hChildStderrRdDup
);
5302 f
= PyTuple_Pack(2,p1
,p2
);
5312 PyObject
*p1
, *p2
, *p3
;
5314 if (mode
& _O_TEXT
) {
5322 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5323 f1
= _fdopen(fd1
, m2
);
5324 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5325 f2
= _fdopen(fd2
, m1
);
5326 fd3
= _open_osfhandle((Py_intptr_t
)hChildStderrRdDup
, mode
);
5327 f3
= _fdopen(fd3
, m1
);
5328 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5329 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5330 p3
= PyFile_FromFile(f3
, cmdstring
, m1
, _PyPclose
);
5331 PyFile_SetBufSize(p1
, 0);
5332 PyFile_SetBufSize(p2
, 0);
5333 PyFile_SetBufSize(p3
, 0);
5334 f
= PyTuple_Pack(3,p1
,p2
,p3
);
5344 if (!_PyPopenCreateProcess(cmdstring
,
5352 if (!_PyPopenCreateProcess(cmdstring
,
5361 * Insert the files we've created into the process dictionary
5362 * all referencing the list with the process handle and the
5363 * initial number of files (see description below in _PyPclose).
5364 * Since if _PyPclose later tried to wait on a process when all
5365 * handles weren't closed, it could create a deadlock with the
5366 * child, we spend some energy here to try to ensure that we
5367 * either insert all file handles into the dictionary or none
5368 * at all. It's a little clumsy with the various popen modes
5369 * and variable number of files involved.
5371 if (!_PyPopenProcs
) {
5372 _PyPopenProcs
= PyDict_New();
5375 if (_PyPopenProcs
) {
5376 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
[3];
5379 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
5380 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
5382 procObj
= PyList_New(2);
5383 hProcessObj
= PyLong_FromVoidPtr(hProcess
);
5384 intObj
= PyInt_FromLong(file_count
);
5386 if (procObj
&& hProcessObj
&& intObj
) {
5387 PyList_SetItem(procObj
,0,hProcessObj
);
5388 PyList_SetItem(procObj
,1,intObj
);
5390 fileObj
[0] = PyLong_FromVoidPtr(f1
);
5392 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
5396 if (file_count
>= 2) {
5397 fileObj
[1] = PyLong_FromVoidPtr(f2
);
5399 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
5404 if (file_count
>= 3) {
5405 fileObj
[2] = PyLong_FromVoidPtr(f3
);
5407 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
5413 if (ins_rc
[0] < 0 || !fileObj
[0] ||
5414 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
5415 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2])) {
5416 /* Something failed - remove any dictionary
5417 * entries that did make it.
5419 if (!ins_rc
[0] && fileObj
[0]) {
5420 PyDict_DelItem(_PyPopenProcs
,
5423 if (!ins_rc
[1] && fileObj
[1]) {
5424 PyDict_DelItem(_PyPopenProcs
,
5427 if (!ins_rc
[2] && fileObj
[2]) {
5428 PyDict_DelItem(_PyPopenProcs
,
5435 * Clean up our localized references for the dictionary keys
5436 * and value since PyDict_SetItem will Py_INCREF any copies
5437 * that got placed in the dictionary.
5439 Py_XDECREF(procObj
);
5440 Py_XDECREF(fileObj
[0]);
5441 Py_XDECREF(fileObj
[1]);
5442 Py_XDECREF(fileObj
[2]);
5445 /* Child is launched. Close the parents copy of those pipe
5446 * handles that only the child should have open. You need to
5447 * make sure that no handles to the write end of the output pipe
5448 * are maintained in this process or else the pipe will not close
5449 * when the child process exits and the ReadFile will hang. */
5451 if (!CloseHandle(hChildStdinRd
))
5452 return win32_error("CloseHandle", NULL
);
5454 if (!CloseHandle(hChildStdoutWr
))
5455 return win32_error("CloseHandle", NULL
);
5457 if ((n
!= 4) && (!CloseHandle(hChildStderrWr
)))
5458 return win32_error("CloseHandle", NULL
);
5464 * Wrapper for fclose() to use for popen* files, so we can retrieve the
5465 * exit code for the child process and return as a result of the close.
5467 * This function uses the _PyPopenProcs dictionary in order to map the
5468 * input file pointer to information about the process that was
5469 * originally created by the popen* call that created the file pointer.
5470 * The dictionary uses the file pointer as a key (with one entry
5471 * inserted for each file returned by the original popen* call) and a
5472 * single list object as the value for all files from a single call.
5473 * The list object contains the Win32 process handle at [0], and a file
5474 * count at [1], which is initialized to the total number of file
5475 * handles using that list.
5477 * This function closes whichever handle it is passed, and decrements
5478 * the file count in the dictionary for the process handle pointed to
5479 * by this file. On the last close (when the file count reaches zero),
5480 * this function will wait for the child process and then return its
5481 * exit code as the result of the close() operation. This permits the
5482 * files to be closed in any order - it is always the close() of the
5483 * final handle that will return the exit code.
5485 * NOTE: This function is currently called with the GIL released.
5486 * hence we use the GILState API to manage our state.
5489 static int _PyPclose(FILE *file
)
5494 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
;
5497 PyGILState_STATE state
;
5500 /* Close the file handle first, to ensure it can't block the
5501 * child from exiting if it's the last handle.
5503 result
= fclose(file
);
5505 state
= PyGILState_Ensure();
5507 if (_PyPopenProcs
) {
5508 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
5509 (procObj
= PyDict_GetItem(_PyPopenProcs
,
5510 fileObj
)) != NULL
&&
5511 (hProcessObj
= PyList_GetItem(procObj
,0)) != NULL
&&
5512 (intObj
= PyList_GetItem(procObj
,1)) != NULL
) {
5514 hProcess
= PyLong_AsVoidPtr(hProcessObj
);
5515 file_count
= PyInt_AsLong(intObj
);
5517 if (file_count
> 1) {
5518 /* Still other files referencing process */
5520 PyList_SetItem(procObj
,1,
5521 PyInt_FromLong(file_count
));
5523 /* Last file for this process */
5524 if (result
!= EOF
&&
5525 WaitForSingleObject(hProcess
, INFINITE
) != WAIT_FAILED
&&
5526 GetExitCodeProcess(hProcess
, &exit_code
)) {
5527 /* Possible truncation here in 16-bit environments, but
5528 * real exit codes are just the lower byte in any event.
5532 /* Indicate failure - this will cause the file object
5533 * to raise an I/O error and translate the last Win32
5534 * error code from errno. We do have a problem with
5535 * last errors that overlap the normal errno table,
5536 * but that's a consistent problem with the file object.
5538 if (result
!= EOF
) {
5539 /* If the error wasn't from the fclose(), then
5540 * set errno for the file object error handling.
5542 errno
= GetLastError();
5547 /* Free up the native handle at this point */
5548 CloseHandle(hProcess
);
5551 /* Remove this file pointer from dictionary */
5552 PyDict_DelItem(_PyPopenProcs
, fileObj
);
5554 if (PyDict_Size(_PyPopenProcs
) == 0) {
5555 Py_DECREF(_PyPopenProcs
);
5556 _PyPopenProcs
= NULL
;
5559 } /* if object retrieval ok */
5561 Py_XDECREF(fileObj
);
5562 } /* if _PyPopenProcs */
5565 PyGILState_Release(state
);
5570 #else /* which OS? */
5572 posix_popen(PyObject
*self
, PyObject
*args
)
5579 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
5581 /* Strip mode of binary or text modifiers */
5582 if (strcmp(mode
, "rb") == 0 || strcmp(mode
, "rt") == 0)
5584 else if (strcmp(mode
, "wb") == 0 || strcmp(mode
, "wt") == 0)
5586 Py_BEGIN_ALLOW_THREADS
5587 fp
= popen(name
, mode
);
5588 Py_END_ALLOW_THREADS
5590 return posix_error();
5591 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
5593 PyFile_SetBufSize(f
, bufsize
);
5597 #endif /* PYOS_??? */
5598 #endif /* HAVE_POPEN */
5602 PyDoc_STRVAR(posix_setuid__doc__
,
5604 Set the current process's user id.");
5607 posix_setuid(PyObject
*self
, PyObject
*args
)
5610 if (!PyArg_ParseTuple(args
, "i:setuid", &uid
))
5612 if (setuid(uid
) < 0)
5613 return posix_error();
5617 #endif /* HAVE_SETUID */
5621 PyDoc_STRVAR(posix_seteuid__doc__
,
5623 Set the current process's effective user id.");
5626 posix_seteuid (PyObject
*self
, PyObject
*args
)
5629 if (!PyArg_ParseTuple(args
, "i", &euid
)) {
5631 } else if (seteuid(euid
) < 0) {
5632 return posix_error();
5638 #endif /* HAVE_SETEUID */
5641 PyDoc_STRVAR(posix_setegid__doc__
,
5643 Set the current process's effective group id.");
5646 posix_setegid (PyObject
*self
, PyObject
*args
)
5649 if (!PyArg_ParseTuple(args
, "i", &egid
)) {
5651 } else if (setegid(egid
) < 0) {
5652 return posix_error();
5658 #endif /* HAVE_SETEGID */
5660 #ifdef HAVE_SETREUID
5661 PyDoc_STRVAR(posix_setreuid__doc__
,
5662 "setreuid(ruid, euid)\n\n\
5663 Set the current process's real and effective user ids.");
5666 posix_setreuid (PyObject
*self
, PyObject
*args
)
5669 if (!PyArg_ParseTuple(args
, "ii", &ruid
, &euid
)) {
5671 } else if (setreuid(ruid
, euid
) < 0) {
5672 return posix_error();
5678 #endif /* HAVE_SETREUID */
5680 #ifdef HAVE_SETREGID
5681 PyDoc_STRVAR(posix_setregid__doc__
,
5682 "setregid(rgid, egid)\n\n\
5683 Set the current process's real and effective group ids.");
5686 posix_setregid (PyObject
*self
, PyObject
*args
)
5689 if (!PyArg_ParseTuple(args
, "ii", &rgid
, &egid
)) {
5691 } else if (setregid(rgid
, egid
) < 0) {
5692 return posix_error();
5698 #endif /* HAVE_SETREGID */
5701 PyDoc_STRVAR(posix_setgid__doc__
,
5703 Set the current process's group id.");
5706 posix_setgid(PyObject
*self
, PyObject
*args
)
5709 if (!PyArg_ParseTuple(args
, "i:setgid", &gid
))
5711 if (setgid(gid
) < 0)
5712 return posix_error();
5716 #endif /* HAVE_SETGID */
5718 #ifdef HAVE_SETGROUPS
5719 PyDoc_STRVAR(posix_setgroups__doc__
,
5720 "setgroups(list)\n\n\
5721 Set the groups of the current process to list.");
5724 posix_setgroups(PyObject
*self
, PyObject
*groups
)
5727 gid_t grouplist
[MAX_GROUPS
];
5729 if (!PySequence_Check(groups
)) {
5730 PyErr_SetString(PyExc_TypeError
, "setgroups argument must be a sequence");
5733 len
= PySequence_Size(groups
);
5734 if (len
> MAX_GROUPS
) {
5735 PyErr_SetString(PyExc_ValueError
, "too many groups");
5738 for(i
= 0; i
< len
; i
++) {
5740 elem
= PySequence_GetItem(groups
, i
);
5743 if (!PyInt_Check(elem
)) {
5744 if (!PyLong_Check(elem
)) {
5745 PyErr_SetString(PyExc_TypeError
,
5746 "groups must be integers");
5750 unsigned long x
= PyLong_AsUnsignedLong(elem
);
5751 if (PyErr_Occurred()) {
5752 PyErr_SetString(PyExc_TypeError
,
5753 "group id too big");
5758 /* read back the value to see if it fitted in gid_t */
5759 if (grouplist
[i
] != x
) {
5760 PyErr_SetString(PyExc_TypeError
,
5761 "group id too big");
5767 long x
= PyInt_AsLong(elem
);
5769 if (grouplist
[i
] != x
) {
5770 PyErr_SetString(PyExc_TypeError
,
5771 "group id too big");
5779 if (setgroups(len
, grouplist
) < 0)
5780 return posix_error();
5784 #endif /* HAVE_SETGROUPS */
5786 #if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
5788 wait_helper(pid_t pid
, int status
, struct rusage
*ru
)
5791 static PyObject
*struct_rusage
;
5794 return posix_error();
5796 if (struct_rusage
== NULL
) {
5797 PyObject
*m
= PyImport_ImportModuleNoBlock("resource");
5800 struct_rusage
= PyObject_GetAttrString(m
, "struct_rusage");
5802 if (struct_rusage
== NULL
)
5806 /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
5807 result
= PyStructSequence_New((PyTypeObject
*) struct_rusage
);
5812 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
5815 PyStructSequence_SET_ITEM(result
, 0,
5816 PyFloat_FromDouble(doubletime(ru
->ru_utime
)));
5817 PyStructSequence_SET_ITEM(result
, 1,
5818 PyFloat_FromDouble(doubletime(ru
->ru_stime
)));
5819 #define SET_INT(result, index, value)\
5820 PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))
5821 SET_INT(result
, 2, ru
->ru_maxrss
);
5822 SET_INT(result
, 3, ru
->ru_ixrss
);
5823 SET_INT(result
, 4, ru
->ru_idrss
);
5824 SET_INT(result
, 5, ru
->ru_isrss
);
5825 SET_INT(result
, 6, ru
->ru_minflt
);
5826 SET_INT(result
, 7, ru
->ru_majflt
);
5827 SET_INT(result
, 8, ru
->ru_nswap
);
5828 SET_INT(result
, 9, ru
->ru_inblock
);
5829 SET_INT(result
, 10, ru
->ru_oublock
);
5830 SET_INT(result
, 11, ru
->ru_msgsnd
);
5831 SET_INT(result
, 12, ru
->ru_msgrcv
);
5832 SET_INT(result
, 13, ru
->ru_nsignals
);
5833 SET_INT(result
, 14, ru
->ru_nvcsw
);
5834 SET_INT(result
, 15, ru
->ru_nivcsw
);
5837 if (PyErr_Occurred()) {
5842 return Py_BuildValue("iiN", pid
, status
, result
);
5844 #endif /* HAVE_WAIT3 || HAVE_WAIT4 */
5847 PyDoc_STRVAR(posix_wait3__doc__
,
5848 "wait3(options) -> (pid, status, rusage)\n\n\
5849 Wait for completion of a child process.");
5852 posix_wait3(PyObject
*self
, PyObject
*args
)
5858 WAIT_STATUS_INT(status
) = 0;
5860 if (!PyArg_ParseTuple(args
, "i:wait3", &options
))
5863 Py_BEGIN_ALLOW_THREADS
5864 pid
= wait3(&status
, options
, &ru
);
5865 Py_END_ALLOW_THREADS
5867 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5869 #endif /* HAVE_WAIT3 */
5872 PyDoc_STRVAR(posix_wait4__doc__
,
5873 "wait4(pid, options) -> (pid, status, rusage)\n\n\
5874 Wait for completion of a given child process.");
5877 posix_wait4(PyObject
*self
, PyObject
*args
)
5883 WAIT_STATUS_INT(status
) = 0;
5885 if (!PyArg_ParseTuple(args
, "ii:wait4", &pid
, &options
))
5888 Py_BEGIN_ALLOW_THREADS
5889 pid
= wait4(pid
, &status
, options
, &ru
);
5890 Py_END_ALLOW_THREADS
5892 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5894 #endif /* HAVE_WAIT4 */
5897 PyDoc_STRVAR(posix_waitpid__doc__
,
5898 "waitpid(pid, options) -> (pid, status)\n\n\
5899 Wait for completion of a given child process.");
5902 posix_waitpid(PyObject
*self
, PyObject
*args
)
5907 WAIT_STATUS_INT(status
) = 0;
5909 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5911 Py_BEGIN_ALLOW_THREADS
5912 pid
= waitpid(pid
, &status
, options
);
5913 Py_END_ALLOW_THREADS
5915 return posix_error();
5917 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5920 #elif defined(HAVE_CWAIT)
5922 /* MS C has a variant of waitpid() that's usable for most purposes. */
5923 PyDoc_STRVAR(posix_waitpid__doc__
,
5924 "waitpid(pid, options) -> (pid, status << 8)\n\n"
5925 "Wait for completion of a given process. options is ignored on Windows.");
5928 posix_waitpid(PyObject
*self
, PyObject
*args
)
5931 int status
, options
;
5933 if (!PyArg_ParseTuple(args
, "ii:waitpid", &pid
, &options
))
5935 Py_BEGIN_ALLOW_THREADS
5936 pid
= _cwait(&status
, pid
, options
);
5937 Py_END_ALLOW_THREADS
5939 return posix_error();
5941 /* shift the status left a byte so this is more like the POSIX waitpid */
5942 return Py_BuildValue("ii", pid
, status
<< 8);
5944 #endif /* HAVE_WAITPID || HAVE_CWAIT */
5947 PyDoc_STRVAR(posix_wait__doc__
,
5948 "wait() -> (pid, status)\n\n\
5949 Wait for completion of a child process.");
5952 posix_wait(PyObject
*self
, PyObject
*noargs
)
5956 WAIT_STATUS_INT(status
) = 0;
5958 Py_BEGIN_ALLOW_THREADS
5959 pid
= wait(&status
);
5960 Py_END_ALLOW_THREADS
5962 return posix_error();
5964 return Py_BuildValue("ii", pid
, WAIT_STATUS_INT(status
));
5969 PyDoc_STRVAR(posix_lstat__doc__
,
5970 "lstat(path) -> stat result\n\n\
5971 Like stat(path), but do not follow symbolic links.");
5974 posix_lstat(PyObject
*self
, PyObject
*args
)
5977 return posix_do_stat(self
, args
, "et:lstat", lstat
, NULL
, NULL
);
5978 #else /* !HAVE_LSTAT */
5980 return posix_do_stat(self
, args
, "et:lstat", STAT
, "U:lstat", win32_wstat
);
5982 return posix_do_stat(self
, args
, "et:lstat", STAT
, NULL
, NULL
);
5984 #endif /* !HAVE_LSTAT */
5988 #ifdef HAVE_READLINK
5989 PyDoc_STRVAR(posix_readlink__doc__
,
5990 "readlink(path) -> path\n\n\
5991 Return a string representing the path to which the symbolic link points.");
5994 posix_readlink(PyObject
*self
, PyObject
*args
)
5997 char buf
[MAXPATHLEN
];
6000 #ifdef Py_USING_UNICODE
6001 int arg_is_unicode
= 0;
6004 if (!PyArg_ParseTuple(args
, "et:readlink",
6005 Py_FileSystemDefaultEncoding
, &path
))
6007 #ifdef Py_USING_UNICODE
6008 v
= PySequence_GetItem(args
, 0);
6014 if (PyUnicode_Check(v
)) {
6020 Py_BEGIN_ALLOW_THREADS
6021 n
= readlink(path
, buf
, (int) sizeof buf
);
6022 Py_END_ALLOW_THREADS
6024 return posix_error_with_allocated_filename(path
);
6027 v
= PyString_FromStringAndSize(buf
, n
);
6028 #ifdef Py_USING_UNICODE
6029 if (arg_is_unicode
) {
6032 w
= PyUnicode_FromEncodedObject(v
,
6033 Py_FileSystemDefaultEncoding
,
6040 /* fall back to the original byte string, as
6041 discussed in patch #683592 */
6048 #endif /* HAVE_READLINK */
6052 PyDoc_STRVAR(posix_symlink__doc__
,
6053 "symlink(src, dst)\n\n\
6054 Create a symbolic link pointing to src named dst.");
6057 posix_symlink(PyObject
*self
, PyObject
*args
)
6059 return posix_2str(args
, "etet:symlink", symlink
);
6061 #endif /* HAVE_SYMLINK */
6065 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
6071 Py_BEGIN_ALLOW_THREADS
6072 DosQuerySysInfo(QSV_MS_COUNT
, QSV_MS_COUNT
, &value
, sizeof(value
));
6073 Py_END_ALLOW_THREADS
6079 posix_times(PyObject
*self
, PyObject
*noargs
)
6081 /* Currently Only Uptime is Provided -- Others Later */
6082 return Py_BuildValue("ddddd",
6083 (double)0 /* t.tms_utime / HZ */,
6084 (double)0 /* t.tms_stime / HZ */,
6085 (double)0 /* t.tms_cutime / HZ */,
6086 (double)0 /* t.tms_cstime / HZ */,
6087 (double)system_uptime() / 1000);
6090 #define NEED_TICKS_PER_SECOND
6091 static long ticks_per_second
= -1;
6093 posix_times(PyObject
*self
, PyObject
*noargs
)
6099 if (c
== (clock_t) -1)
6100 return posix_error();
6101 return Py_BuildValue("ddddd",
6102 (double)t
.tms_utime
/ ticks_per_second
,
6103 (double)t
.tms_stime
/ ticks_per_second
,
6104 (double)t
.tms_cutime
/ ticks_per_second
,
6105 (double)t
.tms_cstime
/ ticks_per_second
,
6106 (double)c
/ ticks_per_second
);
6108 #endif /* not OS2 */
6109 #endif /* HAVE_TIMES */
6113 #define HAVE_TIMES /* so the method table will pick it up */
6115 posix_times(PyObject
*self
, PyObject
*noargs
)
6117 FILETIME create
, exit
, kernel
, user
;
6119 hProc
= GetCurrentProcess();
6120 GetProcessTimes(hProc
, &create
, &exit
, &kernel
, &user
);
6121 /* The fields of a FILETIME structure are the hi and lo part
6122 of a 64-bit value expressed in 100 nanosecond units.
6123 1e7 is one second in such units; 1e-7 the inverse.
6124 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
6126 return Py_BuildValue(
6128 (double)(user
.dwHighDateTime
*429.4967296 +
6129 user
.dwLowDateTime
*1e-7),
6130 (double)(kernel
.dwHighDateTime
*429.4967296 +
6131 kernel
.dwLowDateTime
*1e-7),
6136 #endif /* MS_WINDOWS */
6139 PyDoc_STRVAR(posix_times__doc__
,
6140 "times() -> (utime, stime, cutime, cstime, elapsed_time)\n\n\
6141 Return a tuple of floating point numbers indicating process times.");
6146 PyDoc_STRVAR(posix_getsid__doc__
,
6147 "getsid(pid) -> sid\n\n\
6148 Call the system call getsid().");
6151 posix_getsid(PyObject
*self
, PyObject
*args
)
6155 if (!PyArg_ParseTuple(args
, "i:getsid", &pid
))
6159 return posix_error();
6160 return PyInt_FromLong((long)sid
);
6162 #endif /* HAVE_GETSID */
6166 PyDoc_STRVAR(posix_setsid__doc__
,
6168 Call the system call setsid().");
6171 posix_setsid(PyObject
*self
, PyObject
*noargs
)
6174 return posix_error();
6178 #endif /* HAVE_SETSID */
6181 PyDoc_STRVAR(posix_setpgid__doc__
,
6182 "setpgid(pid, pgrp)\n\n\
6183 Call the system call setpgid().");
6186 posix_setpgid(PyObject
*self
, PyObject
*args
)
6190 if (!PyArg_ParseTuple(args
, "ii:setpgid", &pid
, &pgrp
))
6192 if (setpgid(pid
, pgrp
) < 0)
6193 return posix_error();
6197 #endif /* HAVE_SETPGID */
6200 #ifdef HAVE_TCGETPGRP
6201 PyDoc_STRVAR(posix_tcgetpgrp__doc__
,
6202 "tcgetpgrp(fd) -> pgid\n\n\
6203 Return the process group associated with the terminal given by a fd.");
6206 posix_tcgetpgrp(PyObject
*self
, PyObject
*args
)
6210 if (!PyArg_ParseTuple(args
, "i:tcgetpgrp", &fd
))
6212 pgid
= tcgetpgrp(fd
);
6214 return posix_error();
6215 return PyInt_FromLong((long)pgid
);
6217 #endif /* HAVE_TCGETPGRP */
6220 #ifdef HAVE_TCSETPGRP
6221 PyDoc_STRVAR(posix_tcsetpgrp__doc__
,
6222 "tcsetpgrp(fd, pgid)\n\n\
6223 Set the process group associated with the terminal given by a fd.");
6226 posix_tcsetpgrp(PyObject
*self
, PyObject
*args
)
6229 if (!PyArg_ParseTuple(args
, "ii:tcsetpgrp", &fd
, &pgid
))
6231 if (tcsetpgrp(fd
, pgid
) < 0)
6232 return posix_error();
6236 #endif /* HAVE_TCSETPGRP */
6238 /* Functions acting on file descriptors */
6240 PyDoc_STRVAR(posix_open__doc__
,
6241 "open(filename, flag [, mode=0777]) -> fd\n\n\
6242 Open a file (for low level IO).");
6245 posix_open(PyObject
*self
, PyObject
*args
)
6253 if (unicode_file_names()) {
6254 PyUnicodeObject
*po
;
6255 if (PyArg_ParseTuple(args
, "Ui|i:mkdir", &po
, &flag
, &mode
)) {
6256 Py_BEGIN_ALLOW_THREADS
6257 /* PyUnicode_AS_UNICODE OK without thread
6258 lock as it is a simple dereference. */
6259 fd
= _wopen(PyUnicode_AS_UNICODE(po
), flag
, mode
);
6260 Py_END_ALLOW_THREADS
6262 return posix_error();
6263 return PyInt_FromLong((long)fd
);
6265 /* Drop the argument parsing error as narrow strings
6271 if (!PyArg_ParseTuple(args
, "eti|i",
6272 Py_FileSystemDefaultEncoding
, &file
,
6276 Py_BEGIN_ALLOW_THREADS
6277 fd
= open(file
, flag
, mode
);
6278 Py_END_ALLOW_THREADS
6280 return posix_error_with_allocated_filename(file
);
6282 return PyInt_FromLong((long)fd
);
6286 PyDoc_STRVAR(posix_close__doc__
,
6288 Close a file descriptor (for low level IO).");
6291 posix_close(PyObject
*self
, PyObject
*args
)
6294 if (!PyArg_ParseTuple(args
, "i:close", &fd
))
6296 if (!_PyVerify_fd(fd
))
6297 return posix_error();
6298 Py_BEGIN_ALLOW_THREADS
6300 Py_END_ALLOW_THREADS
6302 return posix_error();
6308 PyDoc_STRVAR(posix_closerange__doc__
,
6309 "closerange(fd_low, fd_high)\n\n\
6310 Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
6313 posix_closerange(PyObject
*self
, PyObject
*args
)
6315 int fd_from
, fd_to
, i
;
6316 if (!PyArg_ParseTuple(args
, "ii:closerange", &fd_from
, &fd_to
))
6318 Py_BEGIN_ALLOW_THREADS
6319 for (i
= fd_from
; i
< fd_to
; i
++)
6320 if (_PyVerify_fd(i
))
6322 Py_END_ALLOW_THREADS
6327 PyDoc_STRVAR(posix_dup__doc__
,
6328 "dup(fd) -> fd2\n\n\
6329 Return a duplicate of a file descriptor.");
6332 posix_dup(PyObject
*self
, PyObject
*args
)
6335 if (!PyArg_ParseTuple(args
, "i:dup", &fd
))
6337 if (!_PyVerify_fd(fd
))
6338 return posix_error();
6339 Py_BEGIN_ALLOW_THREADS
6341 Py_END_ALLOW_THREADS
6343 return posix_error();
6344 return PyInt_FromLong((long)fd
);
6348 PyDoc_STRVAR(posix_dup2__doc__
,
6349 "dup2(old_fd, new_fd)\n\n\
6350 Duplicate file descriptor.");
6353 posix_dup2(PyObject
*self
, PyObject
*args
)
6356 if (!PyArg_ParseTuple(args
, "ii:dup2", &fd
, &fd2
))
6358 if (!_PyVerify_fd_dup2(fd
, fd2
))
6359 return posix_error();
6360 Py_BEGIN_ALLOW_THREADS
6361 res
= dup2(fd
, fd2
);
6362 Py_END_ALLOW_THREADS
6364 return posix_error();
6370 PyDoc_STRVAR(posix_lseek__doc__
,
6371 "lseek(fd, pos, how) -> newpos\n\n\
6372 Set the current position of a file descriptor.");
6375 posix_lseek(PyObject
*self
, PyObject
*args
)
6378 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6379 PY_LONG_LONG pos
, res
;
6384 if (!PyArg_ParseTuple(args
, "iOi:lseek", &fd
, &posobj
, &how
))
6387 /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
6389 case 0: how
= SEEK_SET
; break;
6390 case 1: how
= SEEK_CUR
; break;
6391 case 2: how
= SEEK_END
; break;
6393 #endif /* SEEK_END */
6395 #if !defined(HAVE_LARGEFILE_SUPPORT)
6396 pos
= PyInt_AsLong(posobj
);
6398 pos
= PyLong_Check(posobj
) ?
6399 PyLong_AsLongLong(posobj
) : PyInt_AsLong(posobj
);
6401 if (PyErr_Occurred())
6404 if (!_PyVerify_fd(fd
))
6405 return posix_error();
6406 Py_BEGIN_ALLOW_THREADS
6407 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6408 res
= _lseeki64(fd
, pos
, how
);
6410 res
= lseek(fd
, pos
, how
);
6412 Py_END_ALLOW_THREADS
6414 return posix_error();
6416 #if !defined(HAVE_LARGEFILE_SUPPORT)
6417 return PyInt_FromLong(res
);
6419 return PyLong_FromLongLong(res
);
6424 PyDoc_STRVAR(posix_read__doc__
,
6425 "read(fd, buffersize) -> string\n\n\
6426 Read a file descriptor.");
6429 posix_read(PyObject
*self
, PyObject
*args
)
6433 if (!PyArg_ParseTuple(args
, "ii:read", &fd
, &size
))
6437 return posix_error();
6439 buffer
= PyString_FromStringAndSize((char *)NULL
, size
);
6442 if (!_PyVerify_fd(fd
))
6443 return posix_error();
6444 Py_BEGIN_ALLOW_THREADS
6445 n
= read(fd
, PyString_AsString(buffer
), size
);
6446 Py_END_ALLOW_THREADS
6449 return posix_error();
6452 _PyString_Resize(&buffer
, n
);
6457 PyDoc_STRVAR(posix_write__doc__
,
6458 "write(fd, string) -> byteswritten\n\n\
6459 Write a string to a file descriptor.");
6462 posix_write(PyObject
*self
, PyObject
*args
)
6468 if (!PyArg_ParseTuple(args
, "is*:write", &fd
, &pbuf
))
6470 if (!_PyVerify_fd(fd
))
6471 return posix_error();
6472 Py_BEGIN_ALLOW_THREADS
6473 size
= write(fd
, pbuf
.buf
, (size_t)pbuf
.len
);
6474 Py_END_ALLOW_THREADS
6475 PyBuffer_Release(&pbuf
);
6477 return posix_error();
6478 return PyInt_FromSsize_t(size
);
6482 PyDoc_STRVAR(posix_fstat__doc__
,
6483 "fstat(fd) -> stat result\n\n\
6484 Like stat(), but for an open file descriptor.");
6487 posix_fstat(PyObject
*self
, PyObject
*args
)
6492 if (!PyArg_ParseTuple(args
, "i:fstat", &fd
))
6495 /* on OpenVMS we must ensure that all bytes are written to the file */
6498 if (!_PyVerify_fd(fd
))
6499 return posix_error();
6500 Py_BEGIN_ALLOW_THREADS
6501 res
= FSTAT(fd
, &st
);
6502 Py_END_ALLOW_THREADS
6505 return win32_error("fstat", NULL
);
6507 return posix_error();
6511 return _pystat_fromstructstat(&st
);
6515 PyDoc_STRVAR(posix_fdopen__doc__
,
6516 "fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\n\
6517 Return an open file object connected to a file descriptor.");
6520 posix_fdopen(PyObject
*self
, PyObject
*args
)
6523 char *orgmode
= "r";
6528 if (!PyArg_ParseTuple(args
, "i|si", &fd
, &orgmode
, &bufsize
))
6531 /* Sanitize mode. See fileobject.c */
6532 mode
= PyMem_MALLOC(strlen(orgmode
)+3);
6537 strcpy(mode
, orgmode
);
6538 if (_PyFile_SanitizeMode(mode
)) {
6542 if (!_PyVerify_fd(fd
))
6543 return posix_error();
6544 Py_BEGIN_ALLOW_THREADS
6545 #if !defined(MS_WINDOWS) && defined(HAVE_FCNTL_H)
6546 if (mode
[0] == 'a') {
6547 /* try to make sure the O_APPEND flag is set */
6549 flags
= fcntl(fd
, F_GETFL
);
6551 fcntl(fd
, F_SETFL
, flags
| O_APPEND
);
6552 fp
= fdopen(fd
, mode
);
6553 if (fp
== NULL
&& flags
!= -1)
6554 /* restore old mode if fdopen failed */
6555 fcntl(fd
, F_SETFL
, flags
);
6557 fp
= fdopen(fd
, mode
);
6560 fp
= fdopen(fd
, mode
);
6562 Py_END_ALLOW_THREADS
6565 return posix_error();
6566 f
= PyFile_FromFile(fp
, "<fdopen>", orgmode
, fclose
);
6568 PyFile_SetBufSize(f
, bufsize
);
6572 PyDoc_STRVAR(posix_isatty__doc__
,
6573 "isatty(fd) -> bool\n\n\
6574 Return True if the file descriptor 'fd' is an open file descriptor\n\
6575 connected to the slave end of a terminal.");
6578 posix_isatty(PyObject
*self
, PyObject
*args
)
6581 if (!PyArg_ParseTuple(args
, "i:isatty", &fd
))
6583 if (!_PyVerify_fd(fd
))
6584 return PyBool_FromLong(0);
6585 return PyBool_FromLong(isatty(fd
));
6589 PyDoc_STRVAR(posix_pipe__doc__
,
6590 "pipe() -> (read_end, write_end)\n\n\
6594 posix_pipe(PyObject
*self
, PyObject
*noargs
)
6596 #if defined(PYOS_OS2)
6600 Py_BEGIN_ALLOW_THREADS
6601 rc
= DosCreatePipe( &read
, &write
, 4096);
6602 Py_END_ALLOW_THREADS
6604 return os2_error(rc
);
6606 return Py_BuildValue("(ii)", read
, write
);
6608 #if !defined(MS_WINDOWS)
6611 Py_BEGIN_ALLOW_THREADS
6613 Py_END_ALLOW_THREADS
6615 return posix_error();
6616 return Py_BuildValue("(ii)", fds
[0], fds
[1]);
6617 #else /* MS_WINDOWS */
6619 int read_fd
, write_fd
;
6621 Py_BEGIN_ALLOW_THREADS
6622 ok
= CreatePipe(&read
, &write
, NULL
, 0);
6623 Py_END_ALLOW_THREADS
6625 return win32_error("CreatePipe", NULL
);
6626 read_fd
= _open_osfhandle((Py_intptr_t
)read
, 0);
6627 write_fd
= _open_osfhandle((Py_intptr_t
)write
, 1);
6628 return Py_BuildValue("(ii)", read_fd
, write_fd
);
6629 #endif /* MS_WINDOWS */
6632 #endif /* HAVE_PIPE */
6636 PyDoc_STRVAR(posix_mkfifo__doc__
,
6637 "mkfifo(filename [, mode=0666])\n\n\
6638 Create a FIFO (a POSIX named pipe).");
6641 posix_mkfifo(PyObject
*self
, PyObject
*args
)
6646 if (!PyArg_ParseTuple(args
, "s|i:mkfifo", &filename
, &mode
))
6648 Py_BEGIN_ALLOW_THREADS
6649 res
= mkfifo(filename
, mode
);
6650 Py_END_ALLOW_THREADS
6652 return posix_error();
6659 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
6660 PyDoc_STRVAR(posix_mknod__doc__
,
6661 "mknod(filename [, mode=0600, device])\n\n\
6662 Create a filesystem node (file, device special file or named pipe)\n\
6663 named filename. mode specifies both the permissions to use and the\n\
6664 type of node to be created, being combined (bitwise OR) with one of\n\
6665 S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\n\
6666 device defines the newly created device special file (probably using\n\
6667 os.makedev()), otherwise it is ignored.");
6671 posix_mknod(PyObject
*self
, PyObject
*args
)
6677 if (!PyArg_ParseTuple(args
, "s|ii:mknod", &filename
, &mode
, &device
))
6679 Py_BEGIN_ALLOW_THREADS
6680 res
= mknod(filename
, mode
, device
);
6681 Py_END_ALLOW_THREADS
6683 return posix_error();
6689 #ifdef HAVE_DEVICE_MACROS
6690 PyDoc_STRVAR(posix_major__doc__
,
6691 "major(device) -> major number\n\
6692 Extracts a device major number from a raw device number.");
6695 posix_major(PyObject
*self
, PyObject
*args
)
6698 if (!PyArg_ParseTuple(args
, "i:major", &device
))
6700 return PyInt_FromLong((long)major(device
));
6703 PyDoc_STRVAR(posix_minor__doc__
,
6704 "minor(device) -> minor number\n\
6705 Extracts a device minor number from a raw device number.");
6708 posix_minor(PyObject
*self
, PyObject
*args
)
6711 if (!PyArg_ParseTuple(args
, "i:minor", &device
))
6713 return PyInt_FromLong((long)minor(device
));
6716 PyDoc_STRVAR(posix_makedev__doc__
,
6717 "makedev(major, minor) -> device number\n\
6718 Composes a raw device number from the major and minor device numbers.");
6721 posix_makedev(PyObject
*self
, PyObject
*args
)
6724 if (!PyArg_ParseTuple(args
, "ii:makedev", &major
, &minor
))
6726 return PyInt_FromLong((long)makedev(major
, minor
));
6728 #endif /* device macros */
6731 #ifdef HAVE_FTRUNCATE
6732 PyDoc_STRVAR(posix_ftruncate__doc__
,
6733 "ftruncate(fd, length)\n\n\
6734 Truncate a file to a specified length.");
6737 posix_ftruncate(PyObject
*self
, PyObject
*args
)
6744 if (!PyArg_ParseTuple(args
, "iO:ftruncate", &fd
, &lenobj
))
6747 #if !defined(HAVE_LARGEFILE_SUPPORT)
6748 length
= PyInt_AsLong(lenobj
);
6750 length
= PyLong_Check(lenobj
) ?
6751 PyLong_AsLongLong(lenobj
) : PyInt_AsLong(lenobj
);
6753 if (PyErr_Occurred())
6756 Py_BEGIN_ALLOW_THREADS
6757 res
= ftruncate(fd
, length
);
6758 Py_END_ALLOW_THREADS
6760 return posix_error();
6767 PyDoc_STRVAR(posix_putenv__doc__
,
6768 "putenv(key, value)\n\n\
6769 Change or add an environment variable.");
6771 /* Save putenv() parameters as values here, so we can collect them when they
6772 * get re-set with another call for the same key. */
6773 static PyObject
*posix_putenv_garbage
;
6776 posix_putenv(PyObject
*self
, PyObject
*args
)
6783 if (!PyArg_ParseTuple(args
, "ss:putenv", &s1
, &s2
))
6786 #if defined(PYOS_OS2)
6787 if (stricmp(s1
, "BEGINLIBPATH") == 0) {
6790 rc
= DosSetExtLIBPATH(s2
, BEGIN_LIBPATH
);
6792 return os2_error(rc
);
6794 } else if (stricmp(s1
, "ENDLIBPATH") == 0) {
6797 rc
= DosSetExtLIBPATH(s2
, END_LIBPATH
);
6799 return os2_error(rc
);
6803 /* XXX This can leak memory -- not easy to fix :-( */
6804 len
= strlen(s1
) + strlen(s2
) + 2;
6805 /* len includes space for a trailing \0; the size arg to
6806 PyString_FromStringAndSize does not count that */
6807 newstr
= PyString_FromStringAndSize(NULL
, (int)len
- 1);
6809 return PyErr_NoMemory();
6810 newenv
= PyString_AS_STRING(newstr
);
6811 PyOS_snprintf(newenv
, len
, "%s=%s", s1
, s2
);
6812 if (putenv(newenv
)) {
6817 /* Install the first arg and newstr in posix_putenv_garbage;
6818 * this will cause previous value to be collected. This has to
6819 * happen after the real putenv() call because the old value
6820 * was still accessible until then. */
6821 if (PyDict_SetItem(posix_putenv_garbage
,
6822 PyTuple_GET_ITEM(args
, 0), newstr
)) {
6823 /* really not much we can do; just leak */
6830 #if defined(PYOS_OS2)
6838 #ifdef HAVE_UNSETENV
6839 PyDoc_STRVAR(posix_unsetenv__doc__
,
6841 Delete an environment variable.");
6844 posix_unsetenv(PyObject
*self
, PyObject
*args
)
6848 if (!PyArg_ParseTuple(args
, "s:unsetenv", &s1
))
6853 /* Remove the key from posix_putenv_garbage;
6854 * this will cause it to be collected. This has to
6855 * happen after the real unsetenv() call because the
6856 * old value was still accessible until then.
6858 if (PyDict_DelItem(posix_putenv_garbage
,
6859 PyTuple_GET_ITEM(args
, 0))) {
6860 /* really not much we can do; just leak */
6867 #endif /* unsetenv */
6869 PyDoc_STRVAR(posix_strerror__doc__
,
6870 "strerror(code) -> string\n\n\
6871 Translate an error code to a message string.");
6874 posix_strerror(PyObject
*self
, PyObject
*args
)
6878 if (!PyArg_ParseTuple(args
, "i:strerror", &code
))
6880 message
= strerror(code
);
6881 if (message
== NULL
) {
6882 PyErr_SetString(PyExc_ValueError
,
6883 "strerror() argument out of range");
6886 return PyString_FromString(message
);
6890 #ifdef HAVE_SYS_WAIT_H
6893 PyDoc_STRVAR(posix_WCOREDUMP__doc__
,
6894 "WCOREDUMP(status) -> bool\n\n\
6895 Return True if the process returning 'status' was dumped to a core file.");
6898 posix_WCOREDUMP(PyObject
*self
, PyObject
*args
)
6901 WAIT_STATUS_INT(status
) = 0;
6903 if (!PyArg_ParseTuple(args
, "i:WCOREDUMP", &WAIT_STATUS_INT(status
)))
6906 return PyBool_FromLong(WCOREDUMP(status
));
6908 #endif /* WCOREDUMP */
6911 PyDoc_STRVAR(posix_WIFCONTINUED__doc__
,
6912 "WIFCONTINUED(status) -> bool\n\n\
6913 Return True if the process returning 'status' was continued from a\n\
6914 job control stop.");
6917 posix_WIFCONTINUED(PyObject
*self
, PyObject
*args
)
6920 WAIT_STATUS_INT(status
) = 0;
6922 if (!PyArg_ParseTuple(args
, "i:WCONTINUED", &WAIT_STATUS_INT(status
)))
6925 return PyBool_FromLong(WIFCONTINUED(status
));
6927 #endif /* WIFCONTINUED */
6930 PyDoc_STRVAR(posix_WIFSTOPPED__doc__
,
6931 "WIFSTOPPED(status) -> bool\n\n\
6932 Return True if the process returning 'status' was stopped.");
6935 posix_WIFSTOPPED(PyObject
*self
, PyObject
*args
)
6938 WAIT_STATUS_INT(status
) = 0;
6940 if (!PyArg_ParseTuple(args
, "i:WIFSTOPPED", &WAIT_STATUS_INT(status
)))
6943 return PyBool_FromLong(WIFSTOPPED(status
));
6945 #endif /* WIFSTOPPED */
6948 PyDoc_STRVAR(posix_WIFSIGNALED__doc__
,
6949 "WIFSIGNALED(status) -> bool\n\n\
6950 Return True if the process returning 'status' was terminated by a signal.");
6953 posix_WIFSIGNALED(PyObject
*self
, PyObject
*args
)
6956 WAIT_STATUS_INT(status
) = 0;
6958 if (!PyArg_ParseTuple(args
, "i:WIFSIGNALED", &WAIT_STATUS_INT(status
)))
6961 return PyBool_FromLong(WIFSIGNALED(status
));
6963 #endif /* WIFSIGNALED */
6966 PyDoc_STRVAR(posix_WIFEXITED__doc__
,
6967 "WIFEXITED(status) -> bool\n\n\
6968 Return true if the process returning 'status' exited using the exit()\n\
6972 posix_WIFEXITED(PyObject
*self
, PyObject
*args
)
6975 WAIT_STATUS_INT(status
) = 0;
6977 if (!PyArg_ParseTuple(args
, "i:WIFEXITED", &WAIT_STATUS_INT(status
)))
6980 return PyBool_FromLong(WIFEXITED(status
));
6982 #endif /* WIFEXITED */
6985 PyDoc_STRVAR(posix_WEXITSTATUS__doc__
,
6986 "WEXITSTATUS(status) -> integer\n\n\
6987 Return the process return code from 'status'.");
6990 posix_WEXITSTATUS(PyObject
*self
, PyObject
*args
)
6993 WAIT_STATUS_INT(status
) = 0;
6995 if (!PyArg_ParseTuple(args
, "i:WEXITSTATUS", &WAIT_STATUS_INT(status
)))
6998 return Py_BuildValue("i", WEXITSTATUS(status
));
7000 #endif /* WEXITSTATUS */
7003 PyDoc_STRVAR(posix_WTERMSIG__doc__
,
7004 "WTERMSIG(status) -> integer\n\n\
7005 Return the signal that terminated the process that provided the 'status'\n\
7009 posix_WTERMSIG(PyObject
*self
, PyObject
*args
)
7012 WAIT_STATUS_INT(status
) = 0;
7014 if (!PyArg_ParseTuple(args
, "i:WTERMSIG", &WAIT_STATUS_INT(status
)))
7017 return Py_BuildValue("i", WTERMSIG(status
));
7019 #endif /* WTERMSIG */
7022 PyDoc_STRVAR(posix_WSTOPSIG__doc__
,
7023 "WSTOPSIG(status) -> integer\n\n\
7024 Return the signal that stopped the process that provided\n\
7025 the 'status' value.");
7028 posix_WSTOPSIG(PyObject
*self
, PyObject
*args
)
7031 WAIT_STATUS_INT(status
) = 0;
7033 if (!PyArg_ParseTuple(args
, "i:WSTOPSIG", &WAIT_STATUS_INT(status
)))
7036 return Py_BuildValue("i", WSTOPSIG(status
));
7038 #endif /* WSTOPSIG */
7040 #endif /* HAVE_SYS_WAIT_H */
7043 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
7045 /* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the
7046 needed definitions in sys/statvfs.h */
7049 #include <sys/statvfs.h>
7052 _pystatvfs_fromstructstatvfs(struct statvfs st
) {
7053 PyObject
*v
= PyStructSequence_New(&StatVFSResultType
);
7057 #if !defined(HAVE_LARGEFILE_SUPPORT)
7058 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
7059 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
7060 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long) st
.f_blocks
));
7061 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long) st
.f_bfree
));
7062 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long) st
.f_bavail
));
7063 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long) st
.f_files
));
7064 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong((long) st
.f_ffree
));
7065 PyStructSequence_SET_ITEM(v
, 7, PyInt_FromLong((long) st
.f_favail
));
7066 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
7067 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
7069 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
7070 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
7071 PyStructSequence_SET_ITEM(v
, 2,
7072 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_blocks
));
7073 PyStructSequence_SET_ITEM(v
, 3,
7074 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bfree
));
7075 PyStructSequence_SET_ITEM(v
, 4,
7076 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bavail
));
7077 PyStructSequence_SET_ITEM(v
, 5,
7078 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_files
));
7079 PyStructSequence_SET_ITEM(v
, 6,
7080 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_ffree
));
7081 PyStructSequence_SET_ITEM(v
, 7,
7082 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_favail
));
7083 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
7084 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
7090 PyDoc_STRVAR(posix_fstatvfs__doc__
,
7091 "fstatvfs(fd) -> statvfs result\n\n\
7092 Perform an fstatvfs system call on the given fd.");
7095 posix_fstatvfs(PyObject
*self
, PyObject
*args
)
7100 if (!PyArg_ParseTuple(args
, "i:fstatvfs", &fd
))
7102 Py_BEGIN_ALLOW_THREADS
7103 res
= fstatvfs(fd
, &st
);
7104 Py_END_ALLOW_THREADS
7106 return posix_error();
7108 return _pystatvfs_fromstructstatvfs(st
);
7110 #endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */
7113 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
7114 #include <sys/statvfs.h>
7116 PyDoc_STRVAR(posix_statvfs__doc__
,
7117 "statvfs(path) -> statvfs result\n\n\
7118 Perform a statvfs system call on the given path.");
7121 posix_statvfs(PyObject
*self
, PyObject
*args
)
7126 if (!PyArg_ParseTuple(args
, "s:statvfs", &path
))
7128 Py_BEGIN_ALLOW_THREADS
7129 res
= statvfs(path
, &st
);
7130 Py_END_ALLOW_THREADS
7132 return posix_error_with_filename(path
);
7134 return _pystatvfs_fromstructstatvfs(st
);
7136 #endif /* HAVE_STATVFS */
7140 PyDoc_STRVAR(posix_tempnam__doc__
,
7141 "tempnam([dir[, prefix]]) -> string\n\n\
7142 Return a unique name for a temporary file.\n\
7143 The directory and a prefix may be specified as strings; they may be omitted\n\
7144 or None if not needed.");
7147 posix_tempnam(PyObject
*self
, PyObject
*args
)
7149 PyObject
*result
= NULL
;
7154 if (!PyArg_ParseTuple(args
, "|zz:tempnam", &dir
, &pfx
))
7157 if (PyErr_Warn(PyExc_RuntimeWarning
,
7158 "tempnam is a potential security risk to your program") < 0)
7162 name
= _tempnam(dir
, pfx
);
7164 name
= tempnam(dir
, pfx
);
7167 return PyErr_NoMemory();
7168 result
= PyString_FromString(name
);
7176 PyDoc_STRVAR(posix_tmpfile__doc__
,
7177 "tmpfile() -> file object\n\n\
7178 Create a temporary file with no directory entries.");
7181 posix_tmpfile(PyObject
*self
, PyObject
*noargs
)
7187 return posix_error();
7188 return PyFile_FromFile(fp
, "<tmpfile>", "w+b", fclose
);
7194 PyDoc_STRVAR(posix_tmpnam__doc__
,
7195 "tmpnam() -> string\n\n\
7196 Return a unique name for a temporary file.");
7199 posix_tmpnam(PyObject
*self
, PyObject
*noargs
)
7201 char buffer
[L_tmpnam
];
7204 if (PyErr_Warn(PyExc_RuntimeWarning
,
7205 "tmpnam is a potential security risk to your program") < 0)
7209 name
= tmpnam_r(buffer
);
7211 name
= tmpnam(buffer
);
7214 PyObject
*err
= Py_BuildValue("is", 0,
7216 "unexpected NULL from tmpnam_r"
7218 "unexpected NULL from tmpnam"
7221 PyErr_SetObject(PyExc_OSError
, err
);
7225 return PyString_FromString(buffer
);
7230 /* This is used for fpathconf(), pathconf(), confstr() and sysconf().
7231 * It maps strings representing configuration variable names to
7232 * integer values, allowing those functions to be called with the
7233 * magic names instead of polluting the module's namespace with tons of
7234 * rarely-used constants. There are three separate tables that use
7235 * these definitions.
7237 * This code is always included, even if none of the interfaces that
7238 * need it are included. The #if hackery needed to avoid it would be
7239 * sufficiently pervasive that it's not worth the loss of readability.
7247 conv_confname(PyObject
*arg
, int *valuep
, struct constdef
*table
,
7250 if (PyInt_Check(arg
)) {
7251 *valuep
= PyInt_AS_LONG(arg
);
7254 if (PyString_Check(arg
)) {
7255 /* look up the value in the table using a binary search */
7258 size_t hi
= tablesize
;
7260 char *confname
= PyString_AS_STRING(arg
);
7262 mid
= (lo
+ hi
) / 2;
7263 cmp
= strcmp(confname
, table
[mid
].name
);
7269 *valuep
= table
[mid
].value
;
7273 PyErr_SetString(PyExc_ValueError
, "unrecognized configuration name");
7276 PyErr_SetString(PyExc_TypeError
,
7277 "configuration names must be strings or integers");
7282 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
7283 static struct constdef posix_constants_pathconf
[] = {
7284 #ifdef _PC_ABI_AIO_XFER_MAX
7285 {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX
},
7287 #ifdef _PC_ABI_ASYNC_IO
7288 {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO
},
7291 {"PC_ASYNC_IO", _PC_ASYNC_IO
},
7293 #ifdef _PC_CHOWN_RESTRICTED
7294 {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED
},
7296 #ifdef _PC_FILESIZEBITS
7297 {"PC_FILESIZEBITS", _PC_FILESIZEBITS
},
7300 {"PC_LAST", _PC_LAST
},
7303 {"PC_LINK_MAX", _PC_LINK_MAX
},
7305 #ifdef _PC_MAX_CANON
7306 {"PC_MAX_CANON", _PC_MAX_CANON
},
7308 #ifdef _PC_MAX_INPUT
7309 {"PC_MAX_INPUT", _PC_MAX_INPUT
},
7312 {"PC_NAME_MAX", _PC_NAME_MAX
},
7315 {"PC_NO_TRUNC", _PC_NO_TRUNC
},
7318 {"PC_PATH_MAX", _PC_PATH_MAX
},
7321 {"PC_PIPE_BUF", _PC_PIPE_BUF
},
7324 {"PC_PRIO_IO", _PC_PRIO_IO
},
7326 #ifdef _PC_SOCK_MAXBUF
7327 {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF
},
7330 {"PC_SYNC_IO", _PC_SYNC_IO
},
7333 {"PC_VDISABLE", _PC_VDISABLE
},
7338 conv_path_confname(PyObject
*arg
, int *valuep
)
7340 return conv_confname(arg
, valuep
, posix_constants_pathconf
,
7341 sizeof(posix_constants_pathconf
)
7342 / sizeof(struct constdef
));
7346 #ifdef HAVE_FPATHCONF
7347 PyDoc_STRVAR(posix_fpathconf__doc__
,
7348 "fpathconf(fd, name) -> integer\n\n\
7349 Return the configuration limit name for the file descriptor fd.\n\
7350 If there is no limit, return -1.");
7353 posix_fpathconf(PyObject
*self
, PyObject
*args
)
7355 PyObject
*result
= NULL
;
7358 if (PyArg_ParseTuple(args
, "iO&:fpathconf", &fd
,
7359 conv_path_confname
, &name
)) {
7363 limit
= fpathconf(fd
, name
);
7364 if (limit
== -1 && errno
!= 0)
7367 result
= PyInt_FromLong(limit
);
7374 #ifdef HAVE_PATHCONF
7375 PyDoc_STRVAR(posix_pathconf__doc__
,
7376 "pathconf(path, name) -> integer\n\n\
7377 Return the configuration limit name for the file or directory path.\n\
7378 If there is no limit, return -1.");
7381 posix_pathconf(PyObject
*self
, PyObject
*args
)
7383 PyObject
*result
= NULL
;
7387 if (PyArg_ParseTuple(args
, "sO&:pathconf", &path
,
7388 conv_path_confname
, &name
)) {
7392 limit
= pathconf(path
, name
);
7393 if (limit
== -1 && errno
!= 0) {
7394 if (errno
== EINVAL
)
7395 /* could be a path or name problem */
7398 posix_error_with_filename(path
);
7401 result
= PyInt_FromLong(limit
);
7408 static struct constdef posix_constants_confstr
[] = {
7409 #ifdef _CS_ARCHITECTURE
7410 {"CS_ARCHITECTURE", _CS_ARCHITECTURE
},
7413 {"CS_HOSTNAME", _CS_HOSTNAME
},
7415 #ifdef _CS_HW_PROVIDER
7416 {"CS_HW_PROVIDER", _CS_HW_PROVIDER
},
7418 #ifdef _CS_HW_SERIAL
7419 {"CS_HW_SERIAL", _CS_HW_SERIAL
},
7421 #ifdef _CS_INITTAB_NAME
7422 {"CS_INITTAB_NAME", _CS_INITTAB_NAME
},
7424 #ifdef _CS_LFS64_CFLAGS
7425 {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS
},
7427 #ifdef _CS_LFS64_LDFLAGS
7428 {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS
},
7430 #ifdef _CS_LFS64_LIBS
7431 {"CS_LFS64_LIBS", _CS_LFS64_LIBS
},
7433 #ifdef _CS_LFS64_LINTFLAGS
7434 {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS
},
7436 #ifdef _CS_LFS_CFLAGS
7437 {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS
},
7439 #ifdef _CS_LFS_LDFLAGS
7440 {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS
},
7443 {"CS_LFS_LIBS", _CS_LFS_LIBS
},
7445 #ifdef _CS_LFS_LINTFLAGS
7446 {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS
},
7449 {"CS_MACHINE", _CS_MACHINE
},
7452 {"CS_PATH", _CS_PATH
},
7455 {"CS_RELEASE", _CS_RELEASE
},
7457 #ifdef _CS_SRPC_DOMAIN
7458 {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN
},
7461 {"CS_SYSNAME", _CS_SYSNAME
},
7464 {"CS_VERSION", _CS_VERSION
},
7466 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
7467 {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS
},
7469 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
7470 {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS
},
7472 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
7473 {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS
},
7475 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
7476 {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS
},
7478 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
7479 {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS
},
7481 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
7482 {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS
},
7484 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
7485 {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS
},
7487 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
7488 {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
},
7490 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
7491 {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS
},
7493 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
7494 {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS
},
7496 #ifdef _CS_XBS5_LP64_OFF64_LIBS
7497 {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS
},
7499 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
7500 {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS
},
7502 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
7503 {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS
},
7505 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
7506 {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
},
7508 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
7509 {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS
},
7511 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
7512 {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
},
7514 #ifdef _MIPS_CS_AVAIL_PROCESSORS
7515 {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS
},
7517 #ifdef _MIPS_CS_BASE
7518 {"MIPS_CS_BASE", _MIPS_CS_BASE
},
7520 #ifdef _MIPS_CS_HOSTID
7521 {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID
},
7523 #ifdef _MIPS_CS_HW_NAME
7524 {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME
},
7526 #ifdef _MIPS_CS_NUM_PROCESSORS
7527 {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS
},
7529 #ifdef _MIPS_CS_OSREL_MAJ
7530 {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ
},
7532 #ifdef _MIPS_CS_OSREL_MIN
7533 {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN
},
7535 #ifdef _MIPS_CS_OSREL_PATCH
7536 {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH
},
7538 #ifdef _MIPS_CS_OS_NAME
7539 {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME
},
7541 #ifdef _MIPS_CS_OS_PROVIDER
7542 {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER
},
7544 #ifdef _MIPS_CS_PROCESSORS
7545 {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS
},
7547 #ifdef _MIPS_CS_SERIAL
7548 {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL
},
7550 #ifdef _MIPS_CS_VENDOR
7551 {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR
},
7556 conv_confstr_confname(PyObject
*arg
, int *valuep
)
7558 return conv_confname(arg
, valuep
, posix_constants_confstr
,
7559 sizeof(posix_constants_confstr
)
7560 / sizeof(struct constdef
));
7563 PyDoc_STRVAR(posix_confstr__doc__
,
7564 "confstr(name) -> string\n\n\
7565 Return a string-valued system configuration variable.");
7568 posix_confstr(PyObject
*self
, PyObject
*args
)
7570 PyObject
*result
= NULL
;
7574 if (PyArg_ParseTuple(args
, "O&:confstr", conv_confstr_confname
, &name
)) {
7578 len
= confstr(name
, buffer
, sizeof(buffer
));
7589 if ((unsigned int)len
>= sizeof(buffer
)) {
7590 result
= PyString_FromStringAndSize(NULL
, len
-1);
7592 confstr(name
, PyString_AS_STRING(result
), len
);
7595 result
= PyString_FromStringAndSize(buffer
, len
-1);
7604 static struct constdef posix_constants_sysconf
[] = {
7605 #ifdef _SC_2_CHAR_TERM
7606 {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM
},
7609 {"SC_2_C_BIND", _SC_2_C_BIND
},
7612 {"SC_2_C_DEV", _SC_2_C_DEV
},
7614 #ifdef _SC_2_C_VERSION
7615 {"SC_2_C_VERSION", _SC_2_C_VERSION
},
7617 #ifdef _SC_2_FORT_DEV
7618 {"SC_2_FORT_DEV", _SC_2_FORT_DEV
},
7620 #ifdef _SC_2_FORT_RUN
7621 {"SC_2_FORT_RUN", _SC_2_FORT_RUN
},
7623 #ifdef _SC_2_LOCALEDEF
7624 {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF
},
7627 {"SC_2_SW_DEV", _SC_2_SW_DEV
},
7630 {"SC_2_UPE", _SC_2_UPE
},
7632 #ifdef _SC_2_VERSION
7633 {"SC_2_VERSION", _SC_2_VERSION
},
7635 #ifdef _SC_ABI_ASYNCHRONOUS_IO
7636 {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO
},
7639 {"SC_ACL", _SC_ACL
},
7641 #ifdef _SC_AIO_LISTIO_MAX
7642 {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX
},
7645 {"SC_AIO_MAX", _SC_AIO_MAX
},
7647 #ifdef _SC_AIO_PRIO_DELTA_MAX
7648 {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX
},
7651 {"SC_ARG_MAX", _SC_ARG_MAX
},
7653 #ifdef _SC_ASYNCHRONOUS_IO
7654 {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO
},
7656 #ifdef _SC_ATEXIT_MAX
7657 {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX
},
7660 {"SC_AUDIT", _SC_AUDIT
},
7662 #ifdef _SC_AVPHYS_PAGES
7663 {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES
},
7665 #ifdef _SC_BC_BASE_MAX
7666 {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX
},
7668 #ifdef _SC_BC_DIM_MAX
7669 {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX
},
7671 #ifdef _SC_BC_SCALE_MAX
7672 {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX
},
7674 #ifdef _SC_BC_STRING_MAX
7675 {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX
},
7678 {"SC_CAP", _SC_CAP
},
7680 #ifdef _SC_CHARCLASS_NAME_MAX
7681 {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX
},
7684 {"SC_CHAR_BIT", _SC_CHAR_BIT
},
7687 {"SC_CHAR_MAX", _SC_CHAR_MAX
},
7690 {"SC_CHAR_MIN", _SC_CHAR_MIN
},
7692 #ifdef _SC_CHILD_MAX
7693 {"SC_CHILD_MAX", _SC_CHILD_MAX
},
7696 {"SC_CLK_TCK", _SC_CLK_TCK
},
7698 #ifdef _SC_COHER_BLKSZ
7699 {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ
},
7701 #ifdef _SC_COLL_WEIGHTS_MAX
7702 {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX
},
7704 #ifdef _SC_DCACHE_ASSOC
7705 {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC
},
7707 #ifdef _SC_DCACHE_BLKSZ
7708 {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ
},
7710 #ifdef _SC_DCACHE_LINESZ
7711 {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ
},
7713 #ifdef _SC_DCACHE_SZ
7714 {"SC_DCACHE_SZ", _SC_DCACHE_SZ
},
7716 #ifdef _SC_DCACHE_TBLKSZ
7717 {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ
},
7719 #ifdef _SC_DELAYTIMER_MAX
7720 {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX
},
7722 #ifdef _SC_EQUIV_CLASS_MAX
7723 {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX
},
7725 #ifdef _SC_EXPR_NEST_MAX
7726 {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX
},
7729 {"SC_FSYNC", _SC_FSYNC
},
7731 #ifdef _SC_GETGR_R_SIZE_MAX
7732 {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX
},
7734 #ifdef _SC_GETPW_R_SIZE_MAX
7735 {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX
},
7737 #ifdef _SC_ICACHE_ASSOC
7738 {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC
},
7740 #ifdef _SC_ICACHE_BLKSZ
7741 {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ
},
7743 #ifdef _SC_ICACHE_LINESZ
7744 {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ
},
7746 #ifdef _SC_ICACHE_SZ
7747 {"SC_ICACHE_SZ", _SC_ICACHE_SZ
},
7750 {"SC_INF", _SC_INF
},
7753 {"SC_INT_MAX", _SC_INT_MAX
},
7756 {"SC_INT_MIN", _SC_INT_MIN
},
7759 {"SC_IOV_MAX", _SC_IOV_MAX
},
7761 #ifdef _SC_IP_SECOPTS
7762 {"SC_IP_SECOPTS", _SC_IP_SECOPTS
},
7764 #ifdef _SC_JOB_CONTROL
7765 {"SC_JOB_CONTROL", _SC_JOB_CONTROL
},
7767 #ifdef _SC_KERN_POINTERS
7768 {"SC_KERN_POINTERS", _SC_KERN_POINTERS
},
7771 {"SC_KERN_SIM", _SC_KERN_SIM
},
7774 {"SC_LINE_MAX", _SC_LINE_MAX
},
7776 #ifdef _SC_LOGIN_NAME_MAX
7777 {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX
},
7779 #ifdef _SC_LOGNAME_MAX
7780 {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX
},
7783 {"SC_LONG_BIT", _SC_LONG_BIT
},
7786 {"SC_MAC", _SC_MAC
},
7788 #ifdef _SC_MAPPED_FILES
7789 {"SC_MAPPED_FILES", _SC_MAPPED_FILES
},
7792 {"SC_MAXPID", _SC_MAXPID
},
7794 #ifdef _SC_MB_LEN_MAX
7795 {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX
},
7798 {"SC_MEMLOCK", _SC_MEMLOCK
},
7800 #ifdef _SC_MEMLOCK_RANGE
7801 {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE
},
7803 #ifdef _SC_MEMORY_PROTECTION
7804 {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION
},
7806 #ifdef _SC_MESSAGE_PASSING
7807 {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING
},
7809 #ifdef _SC_MMAP_FIXED_ALIGNMENT
7810 {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT
},
7812 #ifdef _SC_MQ_OPEN_MAX
7813 {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX
},
7815 #ifdef _SC_MQ_PRIO_MAX
7816 {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX
},
7818 #ifdef _SC_NACLS_MAX
7819 {"SC_NACLS_MAX", _SC_NACLS_MAX
},
7821 #ifdef _SC_NGROUPS_MAX
7822 {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX
},
7824 #ifdef _SC_NL_ARGMAX
7825 {"SC_NL_ARGMAX", _SC_NL_ARGMAX
},
7827 #ifdef _SC_NL_LANGMAX
7828 {"SC_NL_LANGMAX", _SC_NL_LANGMAX
},
7830 #ifdef _SC_NL_MSGMAX
7831 {"SC_NL_MSGMAX", _SC_NL_MSGMAX
},
7834 {"SC_NL_NMAX", _SC_NL_NMAX
},
7836 #ifdef _SC_NL_SETMAX
7837 {"SC_NL_SETMAX", _SC_NL_SETMAX
},
7839 #ifdef _SC_NL_TEXTMAX
7840 {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX
},
7842 #ifdef _SC_NPROCESSORS_CONF
7843 {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF
},
7845 #ifdef _SC_NPROCESSORS_ONLN
7846 {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN
},
7848 #ifdef _SC_NPROC_CONF
7849 {"SC_NPROC_CONF", _SC_NPROC_CONF
},
7851 #ifdef _SC_NPROC_ONLN
7852 {"SC_NPROC_ONLN", _SC_NPROC_ONLN
},
7855 {"SC_NZERO", _SC_NZERO
},
7858 {"SC_OPEN_MAX", _SC_OPEN_MAX
},
7861 {"SC_PAGESIZE", _SC_PAGESIZE
},
7863 #ifdef _SC_PAGE_SIZE
7864 {"SC_PAGE_SIZE", _SC_PAGE_SIZE
},
7867 {"SC_PASS_MAX", _SC_PASS_MAX
},
7869 #ifdef _SC_PHYS_PAGES
7870 {"SC_PHYS_PAGES", _SC_PHYS_PAGES
},
7873 {"SC_PII", _SC_PII
},
7875 #ifdef _SC_PII_INTERNET
7876 {"SC_PII_INTERNET", _SC_PII_INTERNET
},
7878 #ifdef _SC_PII_INTERNET_DGRAM
7879 {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM
},
7881 #ifdef _SC_PII_INTERNET_STREAM
7882 {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM
},
7885 {"SC_PII_OSI", _SC_PII_OSI
},
7887 #ifdef _SC_PII_OSI_CLTS
7888 {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS
},
7890 #ifdef _SC_PII_OSI_COTS
7891 {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS
},
7893 #ifdef _SC_PII_OSI_M
7894 {"SC_PII_OSI_M", _SC_PII_OSI_M
},
7896 #ifdef _SC_PII_SOCKET
7897 {"SC_PII_SOCKET", _SC_PII_SOCKET
},
7900 {"SC_PII_XTI", _SC_PII_XTI
},
7903 {"SC_POLL", _SC_POLL
},
7905 #ifdef _SC_PRIORITIZED_IO
7906 {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO
},
7908 #ifdef _SC_PRIORITY_SCHEDULING
7909 {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING
},
7911 #ifdef _SC_REALTIME_SIGNALS
7912 {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS
},
7914 #ifdef _SC_RE_DUP_MAX
7915 {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX
},
7917 #ifdef _SC_RTSIG_MAX
7918 {"SC_RTSIG_MAX", _SC_RTSIG_MAX
},
7920 #ifdef _SC_SAVED_IDS
7921 {"SC_SAVED_IDS", _SC_SAVED_IDS
},
7923 #ifdef _SC_SCHAR_MAX
7924 {"SC_SCHAR_MAX", _SC_SCHAR_MAX
},
7926 #ifdef _SC_SCHAR_MIN
7927 {"SC_SCHAR_MIN", _SC_SCHAR_MIN
},
7930 {"SC_SELECT", _SC_SELECT
},
7932 #ifdef _SC_SEMAPHORES
7933 {"SC_SEMAPHORES", _SC_SEMAPHORES
},
7935 #ifdef _SC_SEM_NSEMS_MAX
7936 {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX
},
7938 #ifdef _SC_SEM_VALUE_MAX
7939 {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX
},
7941 #ifdef _SC_SHARED_MEMORY_OBJECTS
7942 {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS
},
7945 {"SC_SHRT_MAX", _SC_SHRT_MAX
},
7948 {"SC_SHRT_MIN", _SC_SHRT_MIN
},
7950 #ifdef _SC_SIGQUEUE_MAX
7951 {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX
},
7953 #ifdef _SC_SIGRT_MAX
7954 {"SC_SIGRT_MAX", _SC_SIGRT_MAX
},
7956 #ifdef _SC_SIGRT_MIN
7957 {"SC_SIGRT_MIN", _SC_SIGRT_MIN
},
7959 #ifdef _SC_SOFTPOWER
7960 {"SC_SOFTPOWER", _SC_SOFTPOWER
},
7962 #ifdef _SC_SPLIT_CACHE
7963 {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE
},
7965 #ifdef _SC_SSIZE_MAX
7966 {"SC_SSIZE_MAX", _SC_SSIZE_MAX
},
7968 #ifdef _SC_STACK_PROT
7969 {"SC_STACK_PROT", _SC_STACK_PROT
},
7971 #ifdef _SC_STREAM_MAX
7972 {"SC_STREAM_MAX", _SC_STREAM_MAX
},
7974 #ifdef _SC_SYNCHRONIZED_IO
7975 {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO
},
7978 {"SC_THREADS", _SC_THREADS
},
7980 #ifdef _SC_THREAD_ATTR_STACKADDR
7981 {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR
},
7983 #ifdef _SC_THREAD_ATTR_STACKSIZE
7984 {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE
},
7986 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
7987 {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS
},
7989 #ifdef _SC_THREAD_KEYS_MAX
7990 {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX
},
7992 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
7993 {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING
},
7995 #ifdef _SC_THREAD_PRIO_INHERIT
7996 {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT
},
7998 #ifdef _SC_THREAD_PRIO_PROTECT
7999 {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT
},
8001 #ifdef _SC_THREAD_PROCESS_SHARED
8002 {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED
},
8004 #ifdef _SC_THREAD_SAFE_FUNCTIONS
8005 {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS
},
8007 #ifdef _SC_THREAD_STACK_MIN
8008 {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN
},
8010 #ifdef _SC_THREAD_THREADS_MAX
8011 {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX
},
8014 {"SC_TIMERS", _SC_TIMERS
},
8016 #ifdef _SC_TIMER_MAX
8017 {"SC_TIMER_MAX", _SC_TIMER_MAX
},
8019 #ifdef _SC_TTY_NAME_MAX
8020 {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX
},
8022 #ifdef _SC_TZNAME_MAX
8023 {"SC_TZNAME_MAX", _SC_TZNAME_MAX
},
8025 #ifdef _SC_T_IOV_MAX
8026 {"SC_T_IOV_MAX", _SC_T_IOV_MAX
},
8028 #ifdef _SC_UCHAR_MAX
8029 {"SC_UCHAR_MAX", _SC_UCHAR_MAX
},
8032 {"SC_UINT_MAX", _SC_UINT_MAX
},
8034 #ifdef _SC_UIO_MAXIOV
8035 {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV
},
8037 #ifdef _SC_ULONG_MAX
8038 {"SC_ULONG_MAX", _SC_ULONG_MAX
},
8040 #ifdef _SC_USHRT_MAX
8041 {"SC_USHRT_MAX", _SC_USHRT_MAX
},
8044 {"SC_VERSION", _SC_VERSION
},
8047 {"SC_WORD_BIT", _SC_WORD_BIT
},
8049 #ifdef _SC_XBS5_ILP32_OFF32
8050 {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32
},
8052 #ifdef _SC_XBS5_ILP32_OFFBIG
8053 {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG
},
8055 #ifdef _SC_XBS5_LP64_OFF64
8056 {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64
},
8058 #ifdef _SC_XBS5_LPBIG_OFFBIG
8059 {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG
},
8061 #ifdef _SC_XOPEN_CRYPT
8062 {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT
},
8064 #ifdef _SC_XOPEN_ENH_I18N
8065 {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N
},
8067 #ifdef _SC_XOPEN_LEGACY
8068 {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY
},
8070 #ifdef _SC_XOPEN_REALTIME
8071 {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME
},
8073 #ifdef _SC_XOPEN_REALTIME_THREADS
8074 {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS
},
8076 #ifdef _SC_XOPEN_SHM
8077 {"SC_XOPEN_SHM", _SC_XOPEN_SHM
},
8079 #ifdef _SC_XOPEN_UNIX
8080 {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX
},
8082 #ifdef _SC_XOPEN_VERSION
8083 {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION
},
8085 #ifdef _SC_XOPEN_XCU_VERSION
8086 {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION
},
8088 #ifdef _SC_XOPEN_XPG2
8089 {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2
},
8091 #ifdef _SC_XOPEN_XPG3
8092 {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3
},
8094 #ifdef _SC_XOPEN_XPG4
8095 {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4
},
8100 conv_sysconf_confname(PyObject
*arg
, int *valuep
)
8102 return conv_confname(arg
, valuep
, posix_constants_sysconf
,
8103 sizeof(posix_constants_sysconf
)
8104 / sizeof(struct constdef
));
8107 PyDoc_STRVAR(posix_sysconf__doc__
,
8108 "sysconf(name) -> integer\n\n\
8109 Return an integer-valued system configuration variable.");
8112 posix_sysconf(PyObject
*self
, PyObject
*args
)
8114 PyObject
*result
= NULL
;
8117 if (PyArg_ParseTuple(args
, "O&:sysconf", conv_sysconf_confname
, &name
)) {
8121 value
= sysconf(name
);
8122 if (value
== -1 && errno
!= 0)
8125 result
= PyInt_FromLong(value
);
8132 /* This code is used to ensure that the tables of configuration value names
8133 * are in sorted order as required by conv_confname(), and also to build the
8134 * the exported dictionaries that are used to publish information about the
8135 * names available on the host platform.
8137 * Sorting the table at runtime ensures that the table is properly ordered
8138 * when used, even for platforms we're not able to test on. It also makes
8139 * it easier to add additional entries to the tables.
8143 cmp_constdefs(const void *v1
, const void *v2
)
8145 const struct constdef
*c1
=
8146 (const struct constdef
*) v1
;
8147 const struct constdef
*c2
=
8148 (const struct constdef
*) v2
;
8150 return strcmp(c1
->name
, c2
->name
);
8154 setup_confname_table(struct constdef
*table
, size_t tablesize
,
8155 char *tablename
, PyObject
*module
)
8160 qsort(table
, tablesize
, sizeof(struct constdef
), cmp_constdefs
);
8165 for (i
=0; i
< tablesize
; ++i
) {
8166 PyObject
*o
= PyInt_FromLong(table
[i
].value
);
8167 if (o
== NULL
|| PyDict_SetItemString(d
, table
[i
].name
, o
) == -1) {
8174 return PyModule_AddObject(module
, tablename
, d
);
8177 /* Return -1 on failure, 0 on success. */
8179 setup_confname_tables(PyObject
*module
)
8181 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
8182 if (setup_confname_table(posix_constants_pathconf
,
8183 sizeof(posix_constants_pathconf
)
8184 / sizeof(struct constdef
),
8185 "pathconf_names", module
))
8189 if (setup_confname_table(posix_constants_confstr
,
8190 sizeof(posix_constants_confstr
)
8191 / sizeof(struct constdef
),
8192 "confstr_names", module
))
8196 if (setup_confname_table(posix_constants_sysconf
,
8197 sizeof(posix_constants_sysconf
)
8198 / sizeof(struct constdef
),
8199 "sysconf_names", module
))
8206 PyDoc_STRVAR(posix_abort__doc__
,
8207 "abort() -> does not return!\n\n\
8208 Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\
8209 in the hardest way possible on the hosting operating system.");
8212 posix_abort(PyObject
*self
, PyObject
*noargs
)
8216 Py_FatalError("abort() called from Python code didn't abort!");
8221 PyDoc_STRVAR(win32_startfile__doc__
,
8222 "startfile(filepath [, operation]) - Start a file with its associated\n\
8225 When \"operation\" is not specified or \"open\", this acts like\n\
8226 double-clicking the file in Explorer, or giving the file name as an\n\
8227 argument to the DOS \"start\" command: the file is opened with whatever\n\
8228 application (if any) its extension is associated.\n\
8229 When another \"operation\" is given, it specifies what should be done with\n\
8230 the file. A typical operation is \"print\".\n\
8232 startfile returns as soon as the associated application is launched.\n\
8233 There is no option to wait for the application to close, and no way\n\
8234 to retrieve the application's exit status.\n\
8236 The filepath is relative to the current directory. If you want to use\n\
8237 an absolute path, make sure the first character is not a slash (\"/\");\n\
8238 the underlying Win32 ShellExecute function doesn't work if it is.");
8241 win32_startfile(PyObject
*self
, PyObject
*args
)
8244 char *operation
= NULL
;
8246 #ifdef Py_WIN_WIDE_FILENAMES
8247 if (unicode_file_names()) {
8248 PyObject
*unipath
, *woperation
= NULL
;
8249 if (!PyArg_ParseTuple(args
, "U|s:startfile",
8250 &unipath
, &operation
)) {
8257 woperation
= PyUnicode_DecodeASCII(operation
,
8258 strlen(operation
), NULL
);
8266 Py_BEGIN_ALLOW_THREADS
8267 rc
= ShellExecuteW((HWND
)0, woperation
? PyUnicode_AS_UNICODE(woperation
) : 0,
8268 PyUnicode_AS_UNICODE(unipath
),
8269 NULL
, NULL
, SW_SHOWNORMAL
);
8270 Py_END_ALLOW_THREADS
8272 Py_XDECREF(woperation
);
8273 if (rc
<= (HINSTANCE
)32) {
8274 PyObject
*errval
= win32_error_unicode("startfile",
8275 PyUnicode_AS_UNICODE(unipath
));
8284 if (!PyArg_ParseTuple(args
, "et|s:startfile",
8285 Py_FileSystemDefaultEncoding
, &filepath
,
8288 Py_BEGIN_ALLOW_THREADS
8289 rc
= ShellExecute((HWND
)0, operation
, filepath
,
8290 NULL
, NULL
, SW_SHOWNORMAL
);
8291 Py_END_ALLOW_THREADS
8292 if (rc
<= (HINSTANCE
)32) {
8293 PyObject
*errval
= win32_error("startfile", filepath
);
8294 PyMem_Free(filepath
);
8297 PyMem_Free(filepath
);
8303 #ifdef HAVE_GETLOADAVG
8304 PyDoc_STRVAR(posix_getloadavg__doc__
,
8305 "getloadavg() -> (float, float, float)\n\n\
8306 Return the number of processes in the system run queue averaged over\n\
8307 the last 1, 5, and 15 minutes or raises OSError if the load average\n\
8311 posix_getloadavg(PyObject
*self
, PyObject
*noargs
)
8314 if (getloadavg(loadavg
, 3)!=3) {
8315 PyErr_SetString(PyExc_OSError
, "Load averages are unobtainable");
8318 return Py_BuildValue("ddd", loadavg
[0], loadavg
[1], loadavg
[2]);
8324 PyDoc_STRVAR(win32_urandom__doc__
,
8325 "urandom(n) -> str\n\n\
8326 Return a string of n random bytes suitable for cryptographic use.");
8328 typedef BOOL (WINAPI
*CRYPTACQUIRECONTEXTA
)(HCRYPTPROV
*phProv
,\
8329 LPCSTR pszContainer
, LPCSTR pszProvider
, DWORD dwProvType
,\
8331 typedef BOOL (WINAPI
*CRYPTGENRANDOM
)(HCRYPTPROV hProv
, DWORD dwLen
,\
8334 static CRYPTGENRANDOM pCryptGenRandom
= NULL
;
8335 /* This handle is never explicitly released. Instead, the operating
8336 system will release it when the process terminates. */
8337 static HCRYPTPROV hCryptProv
= 0;
8340 win32_urandom(PyObject
*self
, PyObject
*args
)
8345 /* Read arguments */
8346 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8349 return PyErr_Format(PyExc_ValueError
,
8350 "negative argument not allowed");
8352 if (hCryptProv
== 0) {
8353 HINSTANCE hAdvAPI32
= NULL
;
8354 CRYPTACQUIRECONTEXTA pCryptAcquireContext
= NULL
;
8356 /* Obtain handle to the DLL containing CryptoAPI
8357 This should not fail */
8358 hAdvAPI32
= GetModuleHandle("advapi32.dll");
8359 if(hAdvAPI32
== NULL
)
8360 return win32_error("GetModuleHandle", NULL
);
8362 /* Obtain pointers to the CryptoAPI functions
8363 This will fail on some early versions of Win95 */
8364 pCryptAcquireContext
= (CRYPTACQUIRECONTEXTA
)GetProcAddress(
8366 "CryptAcquireContextA");
8367 if (pCryptAcquireContext
== NULL
)
8368 return PyErr_Format(PyExc_NotImplementedError
,
8369 "CryptAcquireContextA not found");
8371 pCryptGenRandom
= (CRYPTGENRANDOM
)GetProcAddress(
8372 hAdvAPI32
, "CryptGenRandom");
8373 if (pCryptGenRandom
== NULL
)
8374 return PyErr_Format(PyExc_NotImplementedError
,
8375 "CryptGenRandom not found");
8377 /* Acquire context */
8378 if (! pCryptAcquireContext(&hCryptProv
, NULL
, NULL
,
8379 PROV_RSA_FULL
, CRYPT_VERIFYCONTEXT
))
8380 return win32_error("CryptAcquireContext", NULL
);
8383 /* Allocate bytes */
8384 result
= PyString_FromStringAndSize(NULL
, howMany
);
8385 if (result
!= NULL
) {
8386 /* Get random data */
8387 memset(PyString_AS_STRING(result
), 0, howMany
); /* zero seed */
8388 if (! pCryptGenRandom(hCryptProv
, howMany
, (unsigned char*)
8389 PyString_AS_STRING(result
))) {
8391 return win32_error("CryptGenRandom", NULL
);
8399 /* Use openssl random routine */
8400 #include <openssl/rand.h>
8401 PyDoc_STRVAR(vms_urandom__doc__
,
8402 "urandom(n) -> str\n\n\
8403 Return a string of n random bytes suitable for cryptographic use.");
8406 vms_urandom(PyObject
*self
, PyObject
*args
)
8411 /* Read arguments */
8412 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8415 return PyErr_Format(PyExc_ValueError
,
8416 "negative argument not allowed");
8418 /* Allocate bytes */
8419 result
= PyString_FromStringAndSize(NULL
, howMany
);
8420 if (result
!= NULL
) {
8421 /* Get random data */
8422 if (RAND_pseudo_bytes((unsigned char*)
8423 PyString_AS_STRING(result
),
8426 return PyErr_Format(PyExc_ValueError
,
8427 "RAND_pseudo_bytes");
8434 static PyMethodDef posix_methods
[] = {
8435 {"access", posix_access
, METH_VARARGS
, posix_access__doc__
},
8437 {"ttyname", posix_ttyname
, METH_VARARGS
, posix_ttyname__doc__
},
8439 {"chdir", posix_chdir
, METH_VARARGS
, posix_chdir__doc__
},
8441 {"chflags", posix_chflags
, METH_VARARGS
, posix_chflags__doc__
},
8442 #endif /* HAVE_CHFLAGS */
8443 {"chmod", posix_chmod
, METH_VARARGS
, posix_chmod__doc__
},
8445 {"fchmod", posix_fchmod
, METH_VARARGS
, posix_fchmod__doc__
},
8446 #endif /* HAVE_FCHMOD */
8448 {"chown", posix_chown
, METH_VARARGS
, posix_chown__doc__
},
8449 #endif /* HAVE_CHOWN */
8451 {"lchmod", posix_lchmod
, METH_VARARGS
, posix_lchmod__doc__
},
8452 #endif /* HAVE_LCHMOD */
8454 {"fchown", posix_fchown
, METH_VARARGS
, posix_fchown__doc__
},
8455 #endif /* HAVE_FCHOWN */
8456 #ifdef HAVE_LCHFLAGS
8457 {"lchflags", posix_lchflags
, METH_VARARGS
, posix_lchflags__doc__
},
8458 #endif /* HAVE_LCHFLAGS */
8460 {"lchown", posix_lchown
, METH_VARARGS
, posix_lchown__doc__
},
8461 #endif /* HAVE_LCHOWN */
8463 {"chroot", posix_chroot
, METH_VARARGS
, posix_chroot__doc__
},
8466 {"ctermid", posix_ctermid
, METH_NOARGS
, posix_ctermid__doc__
},
8469 {"getcwd", posix_getcwd
, METH_NOARGS
, posix_getcwd__doc__
},
8470 #ifdef Py_USING_UNICODE
8471 {"getcwdu", posix_getcwdu
, METH_NOARGS
, posix_getcwdu__doc__
},
8475 {"link", posix_link
, METH_VARARGS
, posix_link__doc__
},
8476 #endif /* HAVE_LINK */
8477 {"listdir", posix_listdir
, METH_VARARGS
, posix_listdir__doc__
},
8478 {"lstat", posix_lstat
, METH_VARARGS
, posix_lstat__doc__
},
8479 {"mkdir", posix_mkdir
, METH_VARARGS
, posix_mkdir__doc__
},
8481 {"nice", posix_nice
, METH_VARARGS
, posix_nice__doc__
},
8482 #endif /* HAVE_NICE */
8483 #ifdef HAVE_READLINK
8484 {"readlink", posix_readlink
, METH_VARARGS
, posix_readlink__doc__
},
8485 #endif /* HAVE_READLINK */
8486 {"rename", posix_rename
, METH_VARARGS
, posix_rename__doc__
},
8487 {"rmdir", posix_rmdir
, METH_VARARGS
, posix_rmdir__doc__
},
8488 {"stat", posix_stat
, METH_VARARGS
, posix_stat__doc__
},
8489 {"stat_float_times", stat_float_times
, METH_VARARGS
, stat_float_times__doc__
},
8491 {"symlink", posix_symlink
, METH_VARARGS
, posix_symlink__doc__
},
8492 #endif /* HAVE_SYMLINK */
8494 {"system", posix_system
, METH_VARARGS
, posix_system__doc__
},
8496 {"umask", posix_umask
, METH_VARARGS
, posix_umask__doc__
},
8498 {"uname", posix_uname
, METH_NOARGS
, posix_uname__doc__
},
8499 #endif /* HAVE_UNAME */
8500 {"unlink", posix_unlink
, METH_VARARGS
, posix_unlink__doc__
},
8501 {"remove", posix_unlink
, METH_VARARGS
, posix_remove__doc__
},
8502 {"utime", posix_utime
, METH_VARARGS
, posix_utime__doc__
},
8504 {"times", posix_times
, METH_NOARGS
, posix_times__doc__
},
8505 #endif /* HAVE_TIMES */
8506 {"_exit", posix__exit
, METH_VARARGS
, posix__exit__doc__
},
8508 {"execv", posix_execv
, METH_VARARGS
, posix_execv__doc__
},
8509 {"execve", posix_execve
, METH_VARARGS
, posix_execve__doc__
},
8510 #endif /* HAVE_EXECV */
8512 {"spawnv", posix_spawnv
, METH_VARARGS
, posix_spawnv__doc__
},
8513 {"spawnve", posix_spawnve
, METH_VARARGS
, posix_spawnve__doc__
},
8514 #if defined(PYOS_OS2)
8515 {"spawnvp", posix_spawnvp
, METH_VARARGS
, posix_spawnvp__doc__
},
8516 {"spawnvpe", posix_spawnvpe
, METH_VARARGS
, posix_spawnvpe__doc__
},
8517 #endif /* PYOS_OS2 */
8518 #endif /* HAVE_SPAWNV */
8520 {"fork1", posix_fork1
, METH_NOARGS
, posix_fork1__doc__
},
8521 #endif /* HAVE_FORK1 */
8523 {"fork", posix_fork
, METH_NOARGS
, posix_fork__doc__
},
8524 #endif /* HAVE_FORK */
8525 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
8526 {"openpty", posix_openpty
, METH_NOARGS
, posix_openpty__doc__
},
8527 #endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */
8529 {"forkpty", posix_forkpty
, METH_NOARGS
, posix_forkpty__doc__
},
8530 #endif /* HAVE_FORKPTY */
8532 {"getegid", posix_getegid
, METH_NOARGS
, posix_getegid__doc__
},
8533 #endif /* HAVE_GETEGID */
8535 {"geteuid", posix_geteuid
, METH_NOARGS
, posix_geteuid__doc__
},
8536 #endif /* HAVE_GETEUID */
8538 {"getgid", posix_getgid
, METH_NOARGS
, posix_getgid__doc__
},
8539 #endif /* HAVE_GETGID */
8540 #ifdef HAVE_GETGROUPS
8541 {"getgroups", posix_getgroups
, METH_NOARGS
, posix_getgroups__doc__
},
8543 {"getpid", posix_getpid
, METH_NOARGS
, posix_getpid__doc__
},
8545 {"getpgrp", posix_getpgrp
, METH_NOARGS
, posix_getpgrp__doc__
},
8546 #endif /* HAVE_GETPGRP */
8548 {"getppid", posix_getppid
, METH_NOARGS
, posix_getppid__doc__
},
8549 #endif /* HAVE_GETPPID */
8551 {"getuid", posix_getuid
, METH_NOARGS
, posix_getuid__doc__
},
8552 #endif /* HAVE_GETUID */
8553 #ifdef HAVE_GETLOGIN
8554 {"getlogin", posix_getlogin
, METH_NOARGS
, posix_getlogin__doc__
},
8557 {"kill", posix_kill
, METH_VARARGS
, posix_kill__doc__
},
8558 #endif /* HAVE_KILL */
8560 {"killpg", posix_killpg
, METH_VARARGS
, posix_killpg__doc__
},
8561 #endif /* HAVE_KILLPG */
8563 {"plock", posix_plock
, METH_VARARGS
, posix_plock__doc__
},
8564 #endif /* HAVE_PLOCK */
8566 {"popen", posix_popen
, METH_VARARGS
, posix_popen__doc__
},
8568 {"popen2", win32_popen2
, METH_VARARGS
},
8569 {"popen3", win32_popen3
, METH_VARARGS
},
8570 {"popen4", win32_popen4
, METH_VARARGS
},
8571 {"startfile", win32_startfile
, METH_VARARGS
, win32_startfile__doc__
},
8573 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8574 {"popen2", os2emx_popen2
, METH_VARARGS
},
8575 {"popen3", os2emx_popen3
, METH_VARARGS
},
8576 {"popen4", os2emx_popen4
, METH_VARARGS
},
8579 #endif /* HAVE_POPEN */
8581 {"setuid", posix_setuid
, METH_VARARGS
, posix_setuid__doc__
},
8582 #endif /* HAVE_SETUID */
8584 {"seteuid", posix_seteuid
, METH_VARARGS
, posix_seteuid__doc__
},
8585 #endif /* HAVE_SETEUID */
8587 {"setegid", posix_setegid
, METH_VARARGS
, posix_setegid__doc__
},
8588 #endif /* HAVE_SETEGID */
8589 #ifdef HAVE_SETREUID
8590 {"setreuid", posix_setreuid
, METH_VARARGS
, posix_setreuid__doc__
},
8591 #endif /* HAVE_SETREUID */
8592 #ifdef HAVE_SETREGID
8593 {"setregid", posix_setregid
, METH_VARARGS
, posix_setregid__doc__
},
8594 #endif /* HAVE_SETREGID */
8596 {"setgid", posix_setgid
, METH_VARARGS
, posix_setgid__doc__
},
8597 #endif /* HAVE_SETGID */
8598 #ifdef HAVE_SETGROUPS
8599 {"setgroups", posix_setgroups
, METH_O
, posix_setgroups__doc__
},
8600 #endif /* HAVE_SETGROUPS */
8602 {"getpgid", posix_getpgid
, METH_VARARGS
, posix_getpgid__doc__
},
8603 #endif /* HAVE_GETPGID */
8605 {"setpgrp", posix_setpgrp
, METH_NOARGS
, posix_setpgrp__doc__
},
8606 #endif /* HAVE_SETPGRP */
8608 {"wait", posix_wait
, METH_NOARGS
, posix_wait__doc__
},
8609 #endif /* HAVE_WAIT */
8611 {"wait3", posix_wait3
, METH_VARARGS
, posix_wait3__doc__
},
8612 #endif /* HAVE_WAIT3 */
8614 {"wait4", posix_wait4
, METH_VARARGS
, posix_wait4__doc__
},
8615 #endif /* HAVE_WAIT4 */
8616 #if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)
8617 {"waitpid", posix_waitpid
, METH_VARARGS
, posix_waitpid__doc__
},
8618 #endif /* HAVE_WAITPID */
8620 {"getsid", posix_getsid
, METH_VARARGS
, posix_getsid__doc__
},
8621 #endif /* HAVE_GETSID */
8623 {"setsid", posix_setsid
, METH_NOARGS
, posix_setsid__doc__
},
8624 #endif /* HAVE_SETSID */
8626 {"setpgid", posix_setpgid
, METH_VARARGS
, posix_setpgid__doc__
},
8627 #endif /* HAVE_SETPGID */
8628 #ifdef HAVE_TCGETPGRP
8629 {"tcgetpgrp", posix_tcgetpgrp
, METH_VARARGS
, posix_tcgetpgrp__doc__
},
8630 #endif /* HAVE_TCGETPGRP */
8631 #ifdef HAVE_TCSETPGRP
8632 {"tcsetpgrp", posix_tcsetpgrp
, METH_VARARGS
, posix_tcsetpgrp__doc__
},
8633 #endif /* HAVE_TCSETPGRP */
8634 {"open", posix_open
, METH_VARARGS
, posix_open__doc__
},
8635 {"close", posix_close
, METH_VARARGS
, posix_close__doc__
},
8636 {"closerange", posix_closerange
, METH_VARARGS
, posix_closerange__doc__
},
8637 {"dup", posix_dup
, METH_VARARGS
, posix_dup__doc__
},
8638 {"dup2", posix_dup2
, METH_VARARGS
, posix_dup2__doc__
},
8639 {"lseek", posix_lseek
, METH_VARARGS
, posix_lseek__doc__
},
8640 {"read", posix_read
, METH_VARARGS
, posix_read__doc__
},
8641 {"write", posix_write
, METH_VARARGS
, posix_write__doc__
},
8642 {"fstat", posix_fstat
, METH_VARARGS
, posix_fstat__doc__
},
8643 {"fdopen", posix_fdopen
, METH_VARARGS
, posix_fdopen__doc__
},
8644 {"isatty", posix_isatty
, METH_VARARGS
, posix_isatty__doc__
},
8646 {"pipe", posix_pipe
, METH_NOARGS
, posix_pipe__doc__
},
8649 {"mkfifo", posix_mkfifo
, METH_VARARGS
, posix_mkfifo__doc__
},
8651 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
8652 {"mknod", posix_mknod
, METH_VARARGS
, posix_mknod__doc__
},
8654 #ifdef HAVE_DEVICE_MACROS
8655 {"major", posix_major
, METH_VARARGS
, posix_major__doc__
},
8656 {"minor", posix_minor
, METH_VARARGS
, posix_minor__doc__
},
8657 {"makedev", posix_makedev
, METH_VARARGS
, posix_makedev__doc__
},
8659 #ifdef HAVE_FTRUNCATE
8660 {"ftruncate", posix_ftruncate
, METH_VARARGS
, posix_ftruncate__doc__
},
8663 {"putenv", posix_putenv
, METH_VARARGS
, posix_putenv__doc__
},
8665 #ifdef HAVE_UNSETENV
8666 {"unsetenv", posix_unsetenv
, METH_VARARGS
, posix_unsetenv__doc__
},
8668 {"strerror", posix_strerror
, METH_VARARGS
, posix_strerror__doc__
},
8670 {"fchdir", posix_fchdir
, METH_O
, posix_fchdir__doc__
},
8673 {"fsync", posix_fsync
, METH_O
, posix_fsync__doc__
},
8675 #ifdef HAVE_FDATASYNC
8676 {"fdatasync", posix_fdatasync
, METH_O
, posix_fdatasync__doc__
},
8678 #ifdef HAVE_SYS_WAIT_H
8680 {"WCOREDUMP", posix_WCOREDUMP
, METH_VARARGS
, posix_WCOREDUMP__doc__
},
8681 #endif /* WCOREDUMP */
8683 {"WIFCONTINUED",posix_WIFCONTINUED
, METH_VARARGS
, posix_WIFCONTINUED__doc__
},
8684 #endif /* WIFCONTINUED */
8686 {"WIFSTOPPED", posix_WIFSTOPPED
, METH_VARARGS
, posix_WIFSTOPPED__doc__
},
8687 #endif /* WIFSTOPPED */
8689 {"WIFSIGNALED", posix_WIFSIGNALED
, METH_VARARGS
, posix_WIFSIGNALED__doc__
},
8690 #endif /* WIFSIGNALED */
8692 {"WIFEXITED", posix_WIFEXITED
, METH_VARARGS
, posix_WIFEXITED__doc__
},
8693 #endif /* WIFEXITED */
8695 {"WEXITSTATUS", posix_WEXITSTATUS
, METH_VARARGS
, posix_WEXITSTATUS__doc__
},
8696 #endif /* WEXITSTATUS */
8698 {"WTERMSIG", posix_WTERMSIG
, METH_VARARGS
, posix_WTERMSIG__doc__
},
8699 #endif /* WTERMSIG */
8701 {"WSTOPSIG", posix_WSTOPSIG
, METH_VARARGS
, posix_WSTOPSIG__doc__
},
8702 #endif /* WSTOPSIG */
8703 #endif /* HAVE_SYS_WAIT_H */
8704 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
8705 {"fstatvfs", posix_fstatvfs
, METH_VARARGS
, posix_fstatvfs__doc__
},
8707 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
8708 {"statvfs", posix_statvfs
, METH_VARARGS
, posix_statvfs__doc__
},
8711 {"tmpfile", posix_tmpfile
, METH_NOARGS
, posix_tmpfile__doc__
},
8714 {"tempnam", posix_tempnam
, METH_VARARGS
, posix_tempnam__doc__
},
8717 {"tmpnam", posix_tmpnam
, METH_NOARGS
, posix_tmpnam__doc__
},
8720 {"confstr", posix_confstr
, METH_VARARGS
, posix_confstr__doc__
},
8723 {"sysconf", posix_sysconf
, METH_VARARGS
, posix_sysconf__doc__
},
8725 #ifdef HAVE_FPATHCONF
8726 {"fpathconf", posix_fpathconf
, METH_VARARGS
, posix_fpathconf__doc__
},
8728 #ifdef HAVE_PATHCONF
8729 {"pathconf", posix_pathconf
, METH_VARARGS
, posix_pathconf__doc__
},
8731 {"abort", posix_abort
, METH_NOARGS
, posix_abort__doc__
},
8733 {"_getfullpathname", posix__getfullpathname
, METH_VARARGS
, NULL
},
8735 #ifdef HAVE_GETLOADAVG
8736 {"getloadavg", posix_getloadavg
, METH_NOARGS
, posix_getloadavg__doc__
},
8739 {"urandom", win32_urandom
, METH_VARARGS
, win32_urandom__doc__
},
8742 {"urandom", vms_urandom
, METH_VARARGS
, vms_urandom__doc__
},
8744 {NULL
, NULL
} /* Sentinel */
8749 ins(PyObject
*module
, char *symbol
, long value
)
8751 return PyModule_AddIntConstant(module
, symbol
, value
);
8754 #if defined(PYOS_OS2)
8755 /* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */
8756 static int insertvalues(PyObject
*module
)
8759 ULONG values
[QSV_MAX
+1];
8763 Py_BEGIN_ALLOW_THREADS
8764 rc
= DosQuerySysInfo(1L, QSV_MAX
, &values
[1], sizeof(ULONG
) * QSV_MAX
);
8765 Py_END_ALLOW_THREADS
8767 if (rc
!= NO_ERROR
) {
8772 if (ins(module
, "meminstalled", values
[QSV_TOTPHYSMEM
])) return -1;
8773 if (ins(module
, "memkernel", values
[QSV_TOTRESMEM
])) return -1;
8774 if (ins(module
, "memvirtual", values
[QSV_TOTAVAILMEM
])) return -1;
8775 if (ins(module
, "maxpathlen", values
[QSV_MAX_PATH_LENGTH
])) return -1;
8776 if (ins(module
, "maxnamelen", values
[QSV_MAX_COMP_LENGTH
])) return -1;
8777 if (ins(module
, "revision", values
[QSV_VERSION_REVISION
])) return -1;
8778 if (ins(module
, "timeslice", values
[QSV_MIN_SLICE
])) return -1;
8780 switch (values
[QSV_VERSION_MINOR
]) {
8781 case 0: ver
= "2.00"; break;
8782 case 10: ver
= "2.10"; break;
8783 case 11: ver
= "2.11"; break;
8784 case 30: ver
= "3.00"; break;
8785 case 40: ver
= "4.00"; break;
8786 case 50: ver
= "5.00"; break;
8788 PyOS_snprintf(tmp
, sizeof(tmp
),
8789 "%d-%d", values
[QSV_VERSION_MAJOR
],
8790 values
[QSV_VERSION_MINOR
]);
8794 /* Add Indicator of the Version of the Operating System */
8795 if (PyModule_AddStringConstant(module
, "version", tmp
) < 0)
8798 /* Add Indicator of Which Drive was Used to Boot the System */
8799 tmp
[0] = 'A' + values
[QSV_BOOT_DRIVE
] - 1;
8803 return PyModule_AddStringConstant(module
, "bootdrive", tmp
);
8808 all_ins(PyObject
*d
)
8811 if (ins(d
, "F_OK", (long)F_OK
)) return -1;
8814 if (ins(d
, "R_OK", (long)R_OK
)) return -1;
8817 if (ins(d
, "W_OK", (long)W_OK
)) return -1;
8820 if (ins(d
, "X_OK", (long)X_OK
)) return -1;
8823 if (ins(d
, "NGROUPS_MAX", (long)NGROUPS_MAX
)) return -1;
8826 if (ins(d
, "TMP_MAX", (long)TMP_MAX
)) return -1;
8829 if (ins(d
, "WCONTINUED", (long)WCONTINUED
)) return -1;
8832 if (ins(d
, "WNOHANG", (long)WNOHANG
)) return -1;
8835 if (ins(d
, "WUNTRACED", (long)WUNTRACED
)) return -1;
8838 if (ins(d
, "O_RDONLY", (long)O_RDONLY
)) return -1;
8841 if (ins(d
, "O_WRONLY", (long)O_WRONLY
)) return -1;
8844 if (ins(d
, "O_RDWR", (long)O_RDWR
)) return -1;
8847 if (ins(d
, "O_NDELAY", (long)O_NDELAY
)) return -1;
8850 if (ins(d
, "O_NONBLOCK", (long)O_NONBLOCK
)) return -1;
8853 if (ins(d
, "O_APPEND", (long)O_APPEND
)) return -1;
8856 if (ins(d
, "O_DSYNC", (long)O_DSYNC
)) return -1;
8859 if (ins(d
, "O_RSYNC", (long)O_RSYNC
)) return -1;
8862 if (ins(d
, "O_SYNC", (long)O_SYNC
)) return -1;
8865 if (ins(d
, "O_NOCTTY", (long)O_NOCTTY
)) return -1;
8868 if (ins(d
, "O_CREAT", (long)O_CREAT
)) return -1;
8871 if (ins(d
, "O_EXCL", (long)O_EXCL
)) return -1;
8874 if (ins(d
, "O_TRUNC", (long)O_TRUNC
)) return -1;
8877 if (ins(d
, "O_BINARY", (long)O_BINARY
)) return -1;
8880 if (ins(d
, "O_TEXT", (long)O_TEXT
)) return -1;
8883 if (ins(d
, "O_LARGEFILE", (long)O_LARGEFILE
)) return -1;
8886 if (ins(d
, "O_SHLOCK", (long)O_SHLOCK
)) return -1;
8889 if (ins(d
, "O_EXLOCK", (long)O_EXLOCK
)) return -1;
8894 /* Don't inherit in child processes. */
8895 if (ins(d
, "O_NOINHERIT", (long)O_NOINHERIT
)) return -1;
8897 #ifdef _O_SHORT_LIVED
8898 /* Optimize for short life (keep in memory). */
8899 /* MS forgot to define this one with a non-underscore form too. */
8900 if (ins(d
, "O_SHORT_LIVED", (long)_O_SHORT_LIVED
)) return -1;
8903 /* Automatically delete when last handle is closed. */
8904 if (ins(d
, "O_TEMPORARY", (long)O_TEMPORARY
)) return -1;
8907 /* Optimize for random access. */
8908 if (ins(d
, "O_RANDOM", (long)O_RANDOM
)) return -1;
8911 /* Optimize for sequential access. */
8912 if (ins(d
, "O_SEQUENTIAL", (long)O_SEQUENTIAL
)) return -1;
8915 /* GNU extensions. */
8917 /* Send a SIGIO signal whenever input or output
8918 becomes available on file descriptor */
8919 if (ins(d
, "O_ASYNC", (long)O_ASYNC
)) return -1;
8922 /* Direct disk access. */
8923 if (ins(d
, "O_DIRECT", (long)O_DIRECT
)) return -1;
8926 /* Must be a directory. */
8927 if (ins(d
, "O_DIRECTORY", (long)O_DIRECTORY
)) return -1;
8930 /* Do not follow links. */
8931 if (ins(d
, "O_NOFOLLOW", (long)O_NOFOLLOW
)) return -1;
8934 /* Do not update the access time. */
8935 if (ins(d
, "O_NOATIME", (long)O_NOATIME
)) return -1;
8938 /* These come from sysexits.h */
8940 if (ins(d
, "EX_OK", (long)EX_OK
)) return -1;
8943 if (ins(d
, "EX_USAGE", (long)EX_USAGE
)) return -1;
8944 #endif /* EX_USAGE */
8946 if (ins(d
, "EX_DATAERR", (long)EX_DATAERR
)) return -1;
8947 #endif /* EX_DATAERR */
8949 if (ins(d
, "EX_NOINPUT", (long)EX_NOINPUT
)) return -1;
8950 #endif /* EX_NOINPUT */
8952 if (ins(d
, "EX_NOUSER", (long)EX_NOUSER
)) return -1;
8953 #endif /* EX_NOUSER */
8955 if (ins(d
, "EX_NOHOST", (long)EX_NOHOST
)) return -1;
8956 #endif /* EX_NOHOST */
8957 #ifdef EX_UNAVAILABLE
8958 if (ins(d
, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE
)) return -1;
8959 #endif /* EX_UNAVAILABLE */
8961 if (ins(d
, "EX_SOFTWARE", (long)EX_SOFTWARE
)) return -1;
8962 #endif /* EX_SOFTWARE */
8964 if (ins(d
, "EX_OSERR", (long)EX_OSERR
)) return -1;
8965 #endif /* EX_OSERR */
8967 if (ins(d
, "EX_OSFILE", (long)EX_OSFILE
)) return -1;
8968 #endif /* EX_OSFILE */
8970 if (ins(d
, "EX_CANTCREAT", (long)EX_CANTCREAT
)) return -1;
8971 #endif /* EX_CANTCREAT */
8973 if (ins(d
, "EX_IOERR", (long)EX_IOERR
)) return -1;
8974 #endif /* EX_IOERR */
8976 if (ins(d
, "EX_TEMPFAIL", (long)EX_TEMPFAIL
)) return -1;
8977 #endif /* EX_TEMPFAIL */
8979 if (ins(d
, "EX_PROTOCOL", (long)EX_PROTOCOL
)) return -1;
8980 #endif /* EX_PROTOCOL */
8982 if (ins(d
, "EX_NOPERM", (long)EX_NOPERM
)) return -1;
8983 #endif /* EX_NOPERM */
8985 if (ins(d
, "EX_CONFIG", (long)EX_CONFIG
)) return -1;
8986 #endif /* EX_CONFIG */
8988 if (ins(d
, "EX_NOTFOUND", (long)EX_NOTFOUND
)) return -1;
8989 #endif /* EX_NOTFOUND */
8992 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8993 if (ins(d
, "P_WAIT", (long)P_WAIT
)) return -1;
8994 if (ins(d
, "P_NOWAIT", (long)P_NOWAIT
)) return -1;
8995 if (ins(d
, "P_OVERLAY", (long)P_OVERLAY
)) return -1;
8996 if (ins(d
, "P_DEBUG", (long)P_DEBUG
)) return -1;
8997 if (ins(d
, "P_SESSION", (long)P_SESSION
)) return -1;
8998 if (ins(d
, "P_DETACH", (long)P_DETACH
)) return -1;
8999 if (ins(d
, "P_PM", (long)P_PM
)) return -1;
9000 if (ins(d
, "P_DEFAULT", (long)P_DEFAULT
)) return -1;
9001 if (ins(d
, "P_MINIMIZE", (long)P_MINIMIZE
)) return -1;
9002 if (ins(d
, "P_MAXIMIZE", (long)P_MAXIMIZE
)) return -1;
9003 if (ins(d
, "P_FULLSCREEN", (long)P_FULLSCREEN
)) return -1;
9004 if (ins(d
, "P_WINDOWED", (long)P_WINDOWED
)) return -1;
9005 if (ins(d
, "P_FOREGROUND", (long)P_FOREGROUND
)) return -1;
9006 if (ins(d
, "P_BACKGROUND", (long)P_BACKGROUND
)) return -1;
9007 if (ins(d
, "P_NOCLOSE", (long)P_NOCLOSE
)) return -1;
9008 if (ins(d
, "P_NOSESSION", (long)P_NOSESSION
)) return -1;
9009 if (ins(d
, "P_QUOTE", (long)P_QUOTE
)) return -1;
9010 if (ins(d
, "P_TILDE", (long)P_TILDE
)) return -1;
9011 if (ins(d
, "P_UNRELATED", (long)P_UNRELATED
)) return -1;
9012 if (ins(d
, "P_DEBUGDESC", (long)P_DEBUGDESC
)) return -1;
9014 if (ins(d
, "P_WAIT", (long)_P_WAIT
)) return -1;
9015 if (ins(d
, "P_NOWAIT", (long)_P_NOWAIT
)) return -1;
9016 if (ins(d
, "P_OVERLAY", (long)_OLD_P_OVERLAY
)) return -1;
9017 if (ins(d
, "P_NOWAITO", (long)_P_NOWAITO
)) return -1;
9018 if (ins(d
, "P_DETACH", (long)_P_DETACH
)) return -1;
9022 #if defined(PYOS_OS2)
9023 if (insertvalues(d
)) return -1;
9029 #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)) && !defined(__QNX__)
9030 #define INITFUNC initnt
9031 #define MODNAME "nt"
9033 #elif defined(PYOS_OS2)
9034 #define INITFUNC initos2
9035 #define MODNAME "os2"
9038 #define INITFUNC initposix
9039 #define MODNAME "posix"
9047 m
= Py_InitModule3(MODNAME
,
9053 /* Initialize environ dictionary */
9054 v
= convertenviron();
9056 if (v
== NULL
|| PyModule_AddObject(m
, "environ", v
) != 0)
9063 if (setup_confname_tables(m
))
9066 Py_INCREF(PyExc_OSError
);
9067 PyModule_AddObject(m
, "error", PyExc_OSError
);
9070 if (posix_putenv_garbage
== NULL
)
9071 posix_putenv_garbage
= PyDict_New();
9075 stat_result_desc
.name
= MODNAME
".stat_result";
9076 stat_result_desc
.fields
[7].name
= PyStructSequence_UnnamedField
;
9077 stat_result_desc
.fields
[8].name
= PyStructSequence_UnnamedField
;
9078 stat_result_desc
.fields
[9].name
= PyStructSequence_UnnamedField
;
9079 PyStructSequence_InitType(&StatResultType
, &stat_result_desc
);
9080 structseq_new
= StatResultType
.tp_new
;
9081 StatResultType
.tp_new
= statresult_new
;
9083 statvfs_result_desc
.name
= MODNAME
".statvfs_result";
9084 PyStructSequence_InitType(&StatVFSResultType
, &statvfs_result_desc
);
9085 #ifdef NEED_TICKS_PER_SECOND
9086 # if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
9087 ticks_per_second
= sysconf(_SC_CLK_TCK
);
9089 ticks_per_second
= HZ
;
9091 ticks_per_second
= 60; /* magic fallback value; may be bogus */
9095 Py_INCREF((PyObject
*) &StatResultType
);
9096 PyModule_AddObject(m
, "stat_result", (PyObject
*) &StatResultType
);
9097 Py_INCREF((PyObject
*) &StatVFSResultType
);
9098 PyModule_AddObject(m
, "statvfs_result",
9099 (PyObject
*) &StatVFSResultType
);
9104 * Step 2 of weak-linking support on Mac OS X.
9106 * The code below removes functions that are not available on the
9107 * currently active platform.
9109 * This block allow one to use a python binary that was build on
9110 * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
9113 #ifdef HAVE_FSTATVFS
9114 if (fstatvfs
== NULL
) {
9115 if (PyObject_DelAttrString(m
, "fstatvfs") == -1) {
9119 #endif /* HAVE_FSTATVFS */
9122 if (statvfs
== NULL
) {
9123 if (PyObject_DelAttrString(m
, "statvfs") == -1) {
9127 #endif /* HAVE_STATVFS */
9130 if (lchown
== NULL
) {
9131 if (PyObject_DelAttrString(m
, "lchown") == -1) {
9135 #endif /* HAVE_LCHOWN */
9138 #endif /* __APPLE__ */