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
274 #include <shellapi.h> /* for ShellExecute() */
276 #define pclose _pclose
277 #endif /* _MSC_VER */
279 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
284 #if defined(PATH_MAX) && PATH_MAX > 1024
285 #define MAXPATHLEN PATH_MAX
287 #define MAXPATHLEN 1024
289 #endif /* MAXPATHLEN */
292 /* Emulate some macros on systems that have a union instead of macros */
295 #define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump)
299 #define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1)
303 #define WTERMSIG(u_wait) ((u_wait).w_termsig)
306 #define WAIT_TYPE union wait
307 #define WAIT_STATUS_INT(s) (s.w_status)
309 #else /* !UNION_WAIT */
310 #define WAIT_TYPE int
311 #define WAIT_STATUS_INT(s) (s)
312 #endif /* UNION_WAIT */
314 /* Issue #1983: pid_t can be longer than a C long on some systems */
315 #if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT
316 #define PARSE_PID "i"
317 #define PyLong_FromPid PyInt_FromLong
318 #define PyLong_AsPid PyInt_AsLong
319 #elif SIZEOF_PID_T == SIZEOF_LONG
320 #define PARSE_PID "l"
321 #define PyLong_FromPid PyInt_FromLong
322 #define PyLong_AsPid PyInt_AsLong
323 #elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG
324 #define PARSE_PID "L"
325 #define PyLong_FromPid PyLong_FromLongLong
326 #define PyLong_AsPid PyInt_AsLongLong
328 #error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)"
329 #endif /* SIZEOF_PID_T */
331 /* Don't use the "_r" form if we don't need it (also, won't have a
332 prototype for it, at least on Solaris -- maybe others as well?). */
333 #if defined(HAVE_CTERMID_R) && defined(WITH_THREAD)
334 #define USE_CTERMID_R
337 #if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD)
341 /* choose the appropriate stat and fstat functions and return structs */
343 #if defined(MS_WIN64) || defined(MS_WINDOWS)
344 # define STAT win32_stat
345 # define FSTAT win32_fstat
346 # define STRUCT_STAT struct win32_stat
350 # define STRUCT_STAT struct stat
353 #if defined(MAJOR_IN_MKDEV)
354 #include <sys/mkdev.h>
356 #if defined(MAJOR_IN_SYSMACROS)
357 #include <sys/sysmacros.h>
359 #if defined(HAVE_MKNOD) && defined(HAVE_SYS_MKDEV_H)
360 #include <sys/mkdev.h>
364 #if defined _MSC_VER && _MSC_VER >= 1400
365 /* Microsoft CRT in VS2005 and higher will verify that a filehandle is
366 * valid and throw an assertion if it isn't.
367 * Normally, an invalid fd is likely to be a C program error and therefore
368 * an assertion can be useful, but it does contradict the POSIX standard
369 * which for write(2) states:
370 * "Otherwise, -1 shall be returned and errno set to indicate the error."
371 * "[EBADF] The fildes argument is not a valid file descriptor open for
373 * Furthermore, python allows the user to enter any old integer
374 * as a fd and should merely raise a python exception on error.
375 * The Microsoft CRT doesn't provide an official way to check for the
376 * validity of a file descriptor, but we can emulate its internal behaviour
377 * by using the exported __pinfo data member and knowledge of the
378 * internal structures involved.
379 * The structures below must be updated for each version of visual studio
380 * according to the file internal.h in the CRT source, until MS comes
381 * up with a less hacky way to do this.
382 * (all of this is to avoid globally modifying the CRT behaviour using
383 * _set_invalid_parameter_handler() and _CrtSetReportMode())
385 /* The actual size of the structure is determined at runtime.
386 * Only the first items must be present.
393 extern __declspec(dllimport
) char * __pioinfo
[];
395 #define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
396 #define IOINFO_ARRAYS 64
397 #define _NHANDLE_ (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS)
399 #define _NO_CONSOLE_FILENO (intptr_t)-2
401 /* This function emulates what the windows CRT does to validate file handles */
405 const int i1
= fd
>> IOINFO_L2E
;
406 const int i2
= fd
& ((1 << IOINFO_L2E
) - 1);
408 static int sizeof_ioinfo
= 0;
410 /* Determine the actual size of the ioinfo structure,
411 * as used by the CRT loaded in memory
413 if (sizeof_ioinfo
== 0 && __pioinfo
[0] != NULL
) {
414 sizeof_ioinfo
= _msize(__pioinfo
[0]) / IOINFO_ARRAY_ELTS
;
416 if (sizeof_ioinfo
== 0) {
417 /* This should not happen... */
421 /* See that it isn't a special CLEAR fileno */
422 if (fd
!= _NO_CONSOLE_FILENO
) {
423 /* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead
424 * we check pointer validity and other info
426 if (0 <= i1
&& i1
< IOINFO_ARRAYS
&& __pioinfo
[i1
] != NULL
) {
427 /* finally, check that the file is open */
428 my_ioinfo
* info
= (my_ioinfo
*)(__pioinfo
[i1
] + i2
* sizeof_ioinfo
);
429 if (info
->osfile
& FOPEN
) {
439 /* the special case of checking dup2. The target fd must be in a sensible range */
441 _PyVerify_fd_dup2(int fd1
, int fd2
)
443 if (!_PyVerify_fd(fd1
))
445 if (fd2
== _NO_CONSOLE_FILENO
)
447 if ((unsigned)fd2
< _NHANDLE_
)
453 /* dummy version. _PyVerify_fd() is already defined in fileobject.h */
454 #define _PyVerify_fd_dup2(A, B) (1)
457 /* Return a dictionary corresponding to the POSIX environment table */
458 #ifdef WITH_NEXT_FRAMEWORK
459 /* On Darwin/MacOSX a shared library or framework has no access to
460 ** environ directly, we must obtain it with _NSGetEnviron().
462 #include <crt_externs.h>
463 static char **environ
;
464 #elif !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )
465 extern char **environ
;
466 #endif /* !_MSC_VER */
476 #ifdef WITH_NEXT_FRAMEWORK
478 environ
= *_NSGetEnviron();
482 /* This part ignores errors */
483 for (e
= environ
; *e
!= NULL
; e
++) {
486 char *p
= strchr(*e
, '=');
489 k
= PyString_FromStringAndSize(*e
, (int)(p
-*e
));
494 v
= PyString_FromString(p
+1);
500 if (PyDict_GetItem(d
, k
) == NULL
) {
501 if (PyDict_SetItem(d
, k
, v
) != 0)
507 #if defined(PYOS_OS2)
510 char buffer
[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */
512 rc
= DosQueryExtLIBPATH(buffer
, BEGIN_LIBPATH
);
513 if (rc
== NO_ERROR
) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */
514 PyObject
*v
= PyString_FromString(buffer
);
515 PyDict_SetItemString(d
, "BEGINLIBPATH", v
);
518 rc
= DosQueryExtLIBPATH(buffer
, END_LIBPATH
);
519 if (rc
== NO_ERROR
) { /* (not a typo, envname is NOT 'END_LIBPATH') */
520 PyObject
*v
= PyString_FromString(buffer
);
521 PyDict_SetItemString(d
, "ENDLIBPATH", v
);
530 /* Set a POSIX-specific error from errno, and return NULL */
535 return PyErr_SetFromErrno(PyExc_OSError
);
538 posix_error_with_filename(char* name
)
540 return PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
545 posix_error_with_unicode_filename(Py_UNICODE
* name
)
547 return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError
, name
);
549 #endif /* MS_WINDOWS */
553 posix_error_with_allocated_filename(char* name
)
555 PyObject
*rc
= PyErr_SetFromErrnoWithFilename(PyExc_OSError
, name
);
562 win32_error(char* function
, char* filename
)
564 /* XXX We should pass the function name along in the future.
565 (_winreg.c also wants to pass the function name.)
566 This would however require an additional param to the
567 Windows error object, which is non-trivial.
569 errno
= GetLastError();
571 return PyErr_SetFromWindowsErrWithFilename(errno
, filename
);
573 return PyErr_SetFromWindowsErr(errno
);
577 win32_error_unicode(char* function
, Py_UNICODE
* filename
)
579 /* XXX - see win32_error for comments on 'function' */
580 errno
= GetLastError();
582 return PyErr_SetFromWindowsErrWithUnicodeFilename(errno
, filename
);
584 return PyErr_SetFromWindowsErr(errno
);
588 convert_to_unicode(PyObject
**param
)
590 if (PyUnicode_CheckExact(*param
))
592 else if (PyUnicode_Check(*param
))
593 /* For a Unicode subtype that's not a Unicode object,
594 return a true Unicode object with the same data. */
595 *param
= PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(*param
),
596 PyUnicode_GET_SIZE(*param
));
598 *param
= PyUnicode_FromEncodedObject(*param
,
599 Py_FileSystemDefaultEncoding
,
601 return (*param
) != NULL
;
604 #endif /* MS_WINDOWS */
606 #if defined(PYOS_OS2)
607 /**********************************************************************
608 * Helper Function to Trim and Format OS/2 Messages
609 **********************************************************************/
611 os2_formatmsg(char *msgbuf
, int msglen
, char *reason
)
613 msgbuf
[msglen
] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */
615 if (strlen(msgbuf
) > 0) { /* If Non-Empty Msg, Trim CRLF */
616 char *lastc
= &msgbuf
[ strlen(msgbuf
)-1 ];
618 while (lastc
> msgbuf
&& isspace(Py_CHARMASK(*lastc
)))
619 *lastc
-- = '\0'; /* Trim Trailing Whitespace (CRLF) */
622 /* Add Optional Reason Text */
624 strcat(msgbuf
, " : ");
625 strcat(msgbuf
, reason
);
629 /**********************************************************************
630 * Decode an OS/2 Operating System Error Code
632 * A convenience function to lookup an OS/2 error code and return a
633 * text message we can use to raise a Python exception.
636 * The messages for errors returned from the OS/2 kernel reside in
637 * the file OSO001.MSG in the \OS2 directory hierarchy.
639 **********************************************************************/
641 os2_strerror(char *msgbuf
, int msgbuflen
, int errorcode
, char *reason
)
646 /* Retrieve Kernel-Related Error Message from OSO001.MSG File */
647 Py_BEGIN_ALLOW_THREADS
648 rc
= DosGetMessage(NULL
, 0, msgbuf
, msgbuflen
,
649 errorcode
, "oso001.msg", &msglen
);
653 os2_formatmsg(msgbuf
, msglen
, reason
);
655 PyOS_snprintf(msgbuf
, msgbuflen
,
656 "unknown OS error #%d", errorcode
);
661 /* Set an OS/2-specific error and return NULL. OS/2 kernel
662 errors are not in a global variable e.g. 'errno' nor are
663 they congruent with posix error numbers. */
665 static PyObject
* os2_error(int code
)
670 os2_strerror(text
, sizeof(text
), code
, "");
672 v
= Py_BuildValue("(is)", code
, text
);
674 PyErr_SetObject(PyExc_OSError
, v
);
677 return NULL
; /* Signal to Python that an Exception is Pending */
682 /* POSIX generic methods */
685 posix_fildes(PyObject
*fdobj
, int (*func
)(int))
689 fd
= PyObject_AsFileDescriptor(fdobj
);
692 if (!_PyVerify_fd(fd
))
693 return posix_error();
694 Py_BEGIN_ALLOW_THREADS
698 return posix_error();
704 posix_1str(PyObject
*args
, char *format
, int (*func
)(const char*))
708 if (!PyArg_ParseTuple(args
, format
,
709 Py_FileSystemDefaultEncoding
, &path1
))
711 Py_BEGIN_ALLOW_THREADS
712 res
= (*func
)(path1
);
715 return posix_error_with_allocated_filename(path1
);
722 posix_2str(PyObject
*args
,
724 int (*func
)(const char *, const char *))
726 char *path1
= NULL
, *path2
= NULL
;
728 if (!PyArg_ParseTuple(args
, format
,
729 Py_FileSystemDefaultEncoding
, &path1
,
730 Py_FileSystemDefaultEncoding
, &path2
))
732 Py_BEGIN_ALLOW_THREADS
733 res
= (*func
)(path1
, path2
);
738 /* XXX how to report both path1 and path2??? */
739 return posix_error();
746 win32_1str(PyObject
* args
, char* func
,
747 char* format
, BOOL (__stdcall
*funcA
)(LPCSTR
),
748 char* wformat
, BOOL (__stdcall
*funcW
)(LPWSTR
))
754 if (!PyArg_ParseTuple(args
, wformat
, &uni
))
757 Py_BEGIN_ALLOW_THREADS
758 result
= funcW(PyUnicode_AsUnicode(uni
));
761 return win32_error_unicode(func
, PyUnicode_AsUnicode(uni
));
765 if (!PyArg_ParseTuple(args
, format
, &ansi
))
767 Py_BEGIN_ALLOW_THREADS
768 result
= funcA(ansi
);
771 return win32_error(func
, ansi
);
777 /* This is a reimplementation of the C library's chdir function,
778 but one that produces Win32 errors instead of DOS error codes.
779 chdir is essentially a wrapper around SetCurrentDirectory; however,
780 it also needs to set "magic" environment variables indicating
781 the per-drive current directory, which are of the form =<drive>: */
782 static BOOL __stdcall
783 win32_chdir(LPCSTR path
)
785 char new_path
[MAX_PATH
+1];
789 if(!SetCurrentDirectoryA(path
))
791 result
= GetCurrentDirectoryA(MAX_PATH
+1, new_path
);
794 /* In the ANSI API, there should not be any paths longer
796 assert(result
<= MAX_PATH
+1);
797 if (strncmp(new_path
, "\\\\", 2) == 0 ||
798 strncmp(new_path
, "//", 2) == 0)
799 /* UNC path, nothing to do. */
801 env
[1] = new_path
[0];
802 return SetEnvironmentVariableA(env
, new_path
);
805 /* The Unicode version differs from the ANSI version
806 since the current directory might exceed MAX_PATH characters */
807 static BOOL __stdcall
808 win32_wchdir(LPCWSTR path
)
810 wchar_t _new_path
[MAX_PATH
+1], *new_path
= _new_path
;
812 wchar_t env
[4] = L
"=x:";
814 if(!SetCurrentDirectoryW(path
))
816 result
= GetCurrentDirectoryW(MAX_PATH
+1, new_path
);
819 if (result
> MAX_PATH
+1) {
820 new_path
= malloc(result
* sizeof(wchar_t));
822 SetLastError(ERROR_OUTOFMEMORY
);
825 result
= GetCurrentDirectoryW(result
, new_path
);
831 if (wcsncmp(new_path
, L
"\\\\", 2) == 0 ||
832 wcsncmp(new_path
, L
"//", 2) == 0)
833 /* UNC path, nothing to do. */
835 env
[1] = new_path
[0];
836 result
= SetEnvironmentVariableW(env
, new_path
);
837 if (new_path
!= _new_path
)
844 /* The CRT of Windows has a number of flaws wrt. its stat() implementation:
845 - time stamps are restricted to second resolution
846 - file modification times suffer from forth-and-back conversions between
848 Therefore, we implement our own stat, based on the Win32 API directly.
850 #define HAVE_STAT_NSEC 1
855 unsigned short st_mode
;
869 static __int64 secs_between_epochs
= 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */
872 FILE_TIME_to_time_t_nsec(FILETIME
*in_ptr
, int *time_out
, int* nsec_out
)
874 /* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */
875 /* Cannot simply cast and dereference in_ptr,
876 since it might not be aligned properly */
878 memcpy(&in
, in_ptr
, sizeof(in
));
879 *nsec_out
= (int)(in
% 10000000) * 100; /* FILETIME is in units of 100 nsec. */
880 /* XXX Win32 supports time stamps past 2038; we currently don't */
881 *time_out
= Py_SAFE_DOWNCAST((in
/ 10000000) - secs_between_epochs
, __int64
, int);
885 time_t_to_FILE_TIME(int time_in
, int nsec_in
, FILETIME
*out_ptr
)
889 out
= time_in
+ secs_between_epochs
;
890 out
= out
* 10000000 + nsec_in
/ 100;
891 memcpy(out_ptr
, &out
, sizeof(out
));
894 /* Below, we *know* that ugo+r is 0444 */
896 #error Unsupported C library
899 attributes_to_mode(DWORD attr
)
902 if (attr
& FILE_ATTRIBUTE_DIRECTORY
)
903 m
|= _S_IFDIR
| 0111; /* IFEXEC for user,group,other */
906 if (attr
& FILE_ATTRIBUTE_READONLY
)
914 attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA
*info
, struct win32_stat
*result
)
916 memset(result
, 0, sizeof(*result
));
917 result
->st_mode
= attributes_to_mode(info
->dwFileAttributes
);
918 result
->st_size
= (((__int64
)info
->nFileSizeHigh
)<<32) + info
->nFileSizeLow
;
919 FILE_TIME_to_time_t_nsec(&info
->ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
920 FILE_TIME_to_time_t_nsec(&info
->ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
921 FILE_TIME_to_time_t_nsec(&info
->ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
927 attributes_from_dir(LPCSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
930 WIN32_FIND_DATAA FileData
;
931 hFindFile
= FindFirstFileA(pszFile
, &FileData
);
932 if (hFindFile
== INVALID_HANDLE_VALUE
)
934 FindClose(hFindFile
);
935 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
936 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
937 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
938 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
939 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
940 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
945 attributes_from_dir_w(LPCWSTR pszFile
, LPWIN32_FILE_ATTRIBUTE_DATA pfad
)
948 WIN32_FIND_DATAW FileData
;
949 hFindFile
= FindFirstFileW(pszFile
, &FileData
);
950 if (hFindFile
== INVALID_HANDLE_VALUE
)
952 FindClose(hFindFile
);
953 pfad
->dwFileAttributes
= FileData
.dwFileAttributes
;
954 pfad
->ftCreationTime
= FileData
.ftCreationTime
;
955 pfad
->ftLastAccessTime
= FileData
.ftLastAccessTime
;
956 pfad
->ftLastWriteTime
= FileData
.ftLastWriteTime
;
957 pfad
->nFileSizeHigh
= FileData
.nFileSizeHigh
;
958 pfad
->nFileSizeLow
= FileData
.nFileSizeLow
;
963 win32_stat(const char* path
, struct win32_stat
*result
)
965 WIN32_FILE_ATTRIBUTE_DATA info
;
968 if (!GetFileAttributesExA(path
, GetFileExInfoStandard
, &info
)) {
969 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
970 /* Protocol violation: we explicitly clear errno, instead of
971 setting it to a POSIX error. Callers should use GetLastError. */
975 /* Could not get attributes on open file. Fall back to
976 reading the directory. */
977 if (!attributes_from_dir(path
, &info
)) {
978 /* Very strange. This should not fail now */
984 code
= attribute_data_to_stat(&info
, result
);
987 /* Set S_IFEXEC if it is an .exe, .bat, ... */
988 dot
= strrchr(path
, '.');
990 if (stricmp(dot
, ".bat") == 0 ||
991 stricmp(dot
, ".cmd") == 0 ||
992 stricmp(dot
, ".exe") == 0 ||
993 stricmp(dot
, ".com") == 0)
994 result
->st_mode
|= 0111;
1000 win32_wstat(const wchar_t* path
, struct win32_stat
*result
)
1004 WIN32_FILE_ATTRIBUTE_DATA info
;
1005 if (!GetFileAttributesExW(path
, GetFileExInfoStandard
, &info
)) {
1006 if (GetLastError() != ERROR_SHARING_VIOLATION
) {
1007 /* Protocol violation: we explicitly clear errno, instead of
1008 setting it to a POSIX error. Callers should use GetLastError. */
1012 /* Could not get attributes on open file. Fall back to
1013 reading the directory. */
1014 if (!attributes_from_dir_w(path
, &info
)) {
1015 /* Very strange. This should not fail now */
1021 code
= attribute_data_to_stat(&info
, result
);
1024 /* Set IFEXEC if it is an .exe, .bat, ... */
1025 dot
= wcsrchr(path
, '.');
1027 if (_wcsicmp(dot
, L
".bat") == 0 ||
1028 _wcsicmp(dot
, L
".cmd") == 0 ||
1029 _wcsicmp(dot
, L
".exe") == 0 ||
1030 _wcsicmp(dot
, L
".com") == 0)
1031 result
->st_mode
|= 0111;
1037 win32_fstat(int file_number
, struct win32_stat
*result
)
1039 BY_HANDLE_FILE_INFORMATION info
;
1043 h
= (HANDLE
)_get_osfhandle(file_number
);
1045 /* Protocol violation: we explicitly clear errno, instead of
1046 setting it to a POSIX error. Callers should use GetLastError. */
1049 if (h
== INVALID_HANDLE_VALUE
) {
1050 /* This is really a C library error (invalid file handle).
1051 We set the Win32 error to the closes one matching. */
1052 SetLastError(ERROR_INVALID_HANDLE
);
1055 memset(result
, 0, sizeof(*result
));
1057 type
= GetFileType(h
);
1058 if (type
== FILE_TYPE_UNKNOWN
) {
1059 DWORD error
= GetLastError();
1063 /* else: valid but unknown file */
1066 if (type
!= FILE_TYPE_DISK
) {
1067 if (type
== FILE_TYPE_CHAR
)
1068 result
->st_mode
= _S_IFCHR
;
1069 else if (type
== FILE_TYPE_PIPE
)
1070 result
->st_mode
= _S_IFIFO
;
1074 if (!GetFileInformationByHandle(h
, &info
)) {
1078 /* similar to stat() */
1079 result
->st_mode
= attributes_to_mode(info
.dwFileAttributes
);
1080 result
->st_size
= (((__int64
)info
.nFileSizeHigh
)<<32) + info
.nFileSizeLow
;
1081 FILE_TIME_to_time_t_nsec(&info
.ftCreationTime
, &result
->st_ctime
, &result
->st_ctime_nsec
);
1082 FILE_TIME_to_time_t_nsec(&info
.ftLastWriteTime
, &result
->st_mtime
, &result
->st_mtime_nsec
);
1083 FILE_TIME_to_time_t_nsec(&info
.ftLastAccessTime
, &result
->st_atime
, &result
->st_atime_nsec
);
1084 /* specific to fstat() */
1085 result
->st_nlink
= info
.nNumberOfLinks
;
1086 result
->st_ino
= (((__int64
)info
.nFileIndexHigh
)<<32) + info
.nFileIndexLow
;
1090 #endif /* MS_WINDOWS */
1092 PyDoc_STRVAR(stat_result__doc__
,
1093 "stat_result: Result from stat or lstat.\n\n\
1094 This object may be accessed either as a tuple of\n\
1095 (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n\
1096 or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\
1098 Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n\
1099 or st_flags, they are available as attributes only.\n\
1101 See os.stat for more information.");
1103 static PyStructSequence_Field stat_result_fields
[] = {
1104 {"st_mode", "protection bits"},
1105 {"st_ino", "inode"},
1106 {"st_dev", "device"},
1107 {"st_nlink", "number of hard links"},
1108 {"st_uid", "user ID of owner"},
1109 {"st_gid", "group ID of owner"},
1110 {"st_size", "total size, in bytes"},
1111 /* The NULL is replaced with PyStructSequence_UnnamedField later. */
1112 {NULL
, "integer time of last access"},
1113 {NULL
, "integer time of last modification"},
1114 {NULL
, "integer time of last change"},
1115 {"st_atime", "time of last access"},
1116 {"st_mtime", "time of last modification"},
1117 {"st_ctime", "time of last change"},
1118 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1119 {"st_blksize", "blocksize for filesystem I/O"},
1121 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1122 {"st_blocks", "number of blocks allocated"},
1124 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1125 {"st_rdev", "device type (if inode device)"},
1127 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1128 {"st_flags", "user defined flags for file"},
1130 #ifdef HAVE_STRUCT_STAT_ST_GEN
1131 {"st_gen", "generation number"},
1133 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1134 {"st_birthtime", "time of creation"},
1139 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1140 #define ST_BLKSIZE_IDX 13
1142 #define ST_BLKSIZE_IDX 12
1145 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1146 #define ST_BLOCKS_IDX (ST_BLKSIZE_IDX+1)
1148 #define ST_BLOCKS_IDX ST_BLKSIZE_IDX
1151 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1152 #define ST_RDEV_IDX (ST_BLOCKS_IDX+1)
1154 #define ST_RDEV_IDX ST_BLOCKS_IDX
1157 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1158 #define ST_FLAGS_IDX (ST_RDEV_IDX+1)
1160 #define ST_FLAGS_IDX ST_RDEV_IDX
1163 #ifdef HAVE_STRUCT_STAT_ST_GEN
1164 #define ST_GEN_IDX (ST_FLAGS_IDX+1)
1166 #define ST_GEN_IDX ST_FLAGS_IDX
1169 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1170 #define ST_BIRTHTIME_IDX (ST_GEN_IDX+1)
1172 #define ST_BIRTHTIME_IDX ST_GEN_IDX
1175 static PyStructSequence_Desc stat_result_desc
= {
1176 "stat_result", /* name */
1177 stat_result__doc__
, /* doc */
1182 PyDoc_STRVAR(statvfs_result__doc__
,
1183 "statvfs_result: Result from statvfs or fstatvfs.\n\n\
1184 This object may be accessed either as a tuple of\n\
1185 (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n\
1186 or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\
1188 See os.statvfs for more information.");
1190 static PyStructSequence_Field statvfs_result_fields
[] = {
1204 static PyStructSequence_Desc statvfs_result_desc
= {
1205 "statvfs_result", /* name */
1206 statvfs_result__doc__
, /* doc */
1207 statvfs_result_fields
,
1211 static int initialized
;
1212 static PyTypeObject StatResultType
;
1213 static PyTypeObject StatVFSResultType
;
1214 static newfunc structseq_new
;
1217 statresult_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1219 PyStructSequence
*result
;
1222 result
= (PyStructSequence
*)structseq_new(type
, args
, kwds
);
1225 /* If we have been initialized from a tuple,
1226 st_?time might be set to None. Initialize it
1227 from the int slots. */
1228 for (i
= 7; i
<= 9; i
++) {
1229 if (result
->ob_item
[i
+3] == Py_None
) {
1231 Py_INCREF(result
->ob_item
[i
]);
1232 result
->ob_item
[i
+3] = result
->ob_item
[i
];
1235 return (PyObject
*)result
;
1240 /* If true, st_?time is float. */
1241 static int _stat_float_times
= 1;
1243 PyDoc_STRVAR(stat_float_times__doc__
,
1244 "stat_float_times([newval]) -> oldval\n\n\
1245 Determine whether os.[lf]stat represents time stamps as float objects.\n\
1246 If newval is True, future calls to stat() return floats, if it is False,\n\
1247 future calls return ints. \n\
1248 If newval is omitted, return the current setting.\n");
1251 stat_float_times(PyObject
* self
, PyObject
*args
)
1254 if (!PyArg_ParseTuple(args
, "|i:stat_float_times", &newval
))
1257 /* Return old value */
1258 return PyBool_FromLong(_stat_float_times
);
1259 _stat_float_times
= newval
;
1265 fill_time(PyObject
*v
, int index
, time_t sec
, unsigned long nsec
)
1267 PyObject
*fval
,*ival
;
1268 #if SIZEOF_TIME_T > SIZEOF_LONG
1269 ival
= PyLong_FromLongLong((PY_LONG_LONG
)sec
);
1271 ival
= PyInt_FromLong((long)sec
);
1275 if (_stat_float_times
) {
1276 fval
= PyFloat_FromDouble(sec
+ 1e-9*nsec
);
1281 PyStructSequence_SET_ITEM(v
, index
, ival
);
1282 PyStructSequence_SET_ITEM(v
, index
+3, fval
);
1285 /* pack a system stat C structure into the Python stat tuple
1286 (used by posix_stat() and posix_fstat()) */
1288 _pystat_fromstructstat(STRUCT_STAT
*st
)
1290 unsigned long ansec
, mnsec
, cnsec
;
1291 PyObject
*v
= PyStructSequence_New(&StatResultType
);
1295 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long)st
->st_mode
));
1296 #ifdef HAVE_LARGEFILE_SUPPORT
1297 PyStructSequence_SET_ITEM(v
, 1,
1298 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_ino
));
1300 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long)st
->st_ino
));
1302 #if defined(HAVE_LONG_LONG) && !defined(MS_WINDOWS)
1303 PyStructSequence_SET_ITEM(v
, 2,
1304 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_dev
));
1306 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long)st
->st_dev
));
1308 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long)st
->st_nlink
));
1309 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long)st
->st_uid
));
1310 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long)st
->st_gid
));
1311 #ifdef HAVE_LARGEFILE_SUPPORT
1312 PyStructSequence_SET_ITEM(v
, 6,
1313 PyLong_FromLongLong((PY_LONG_LONG
)st
->st_size
));
1315 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong(st
->st_size
));
1318 #if defined(HAVE_STAT_TV_NSEC)
1319 ansec
= st
->st_atim
.tv_nsec
;
1320 mnsec
= st
->st_mtim
.tv_nsec
;
1321 cnsec
= st
->st_ctim
.tv_nsec
;
1322 #elif defined(HAVE_STAT_TV_NSEC2)
1323 ansec
= st
->st_atimespec
.tv_nsec
;
1324 mnsec
= st
->st_mtimespec
.tv_nsec
;
1325 cnsec
= st
->st_ctimespec
.tv_nsec
;
1326 #elif defined(HAVE_STAT_NSEC)
1327 ansec
= st
->st_atime_nsec
;
1328 mnsec
= st
->st_mtime_nsec
;
1329 cnsec
= st
->st_ctime_nsec
;
1331 ansec
= mnsec
= cnsec
= 0;
1333 fill_time(v
, 7, st
->st_atime
, ansec
);
1334 fill_time(v
, 8, st
->st_mtime
, mnsec
);
1335 fill_time(v
, 9, st
->st_ctime
, cnsec
);
1337 #ifdef HAVE_STRUCT_STAT_ST_BLKSIZE
1338 PyStructSequence_SET_ITEM(v
, ST_BLKSIZE_IDX
,
1339 PyInt_FromLong((long)st
->st_blksize
));
1341 #ifdef HAVE_STRUCT_STAT_ST_BLOCKS
1342 PyStructSequence_SET_ITEM(v
, ST_BLOCKS_IDX
,
1343 PyInt_FromLong((long)st
->st_blocks
));
1345 #ifdef HAVE_STRUCT_STAT_ST_RDEV
1346 PyStructSequence_SET_ITEM(v
, ST_RDEV_IDX
,
1347 PyInt_FromLong((long)st
->st_rdev
));
1349 #ifdef HAVE_STRUCT_STAT_ST_GEN
1350 PyStructSequence_SET_ITEM(v
, ST_GEN_IDX
,
1351 PyInt_FromLong((long)st
->st_gen
));
1353 #ifdef HAVE_STRUCT_STAT_ST_BIRTHTIME
1356 unsigned long bsec
,bnsec
;
1357 bsec
= (long)st
->st_birthtime
;
1358 #ifdef HAVE_STAT_TV_NSEC2
1359 bnsec
= st
->st_birthtimespec
.tv_nsec
;
1363 if (_stat_float_times
) {
1364 val
= PyFloat_FromDouble(bsec
+ 1e-9*bnsec
);
1366 val
= PyInt_FromLong((long)bsec
);
1368 PyStructSequence_SET_ITEM(v
, ST_BIRTHTIME_IDX
,
1372 #ifdef HAVE_STRUCT_STAT_ST_FLAGS
1373 PyStructSequence_SET_ITEM(v
, ST_FLAGS_IDX
,
1374 PyInt_FromLong((long)st
->st_flags
));
1377 if (PyErr_Occurred()) {
1387 /* IsUNCRoot -- test whether the supplied path is of the form \\SERVER\SHARE\,
1388 where / can be used in place of \ and the trailing slash is optional.
1389 Both SERVER and SHARE must have at least one character.
1392 #define ISSLASHA(c) ((c) == '\\' || (c) == '/')
1393 #define ISSLASHW(c) ((c) == L'\\' || (c) == L'/')
1395 #define ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
1399 IsUNCRootA(char *path
, int pathlen
)
1401 #define ISSLASH ISSLASHA
1405 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1406 /* minimum UNCRoot is \\x\y */
1408 for (i
= 2; i
< pathlen
; i
++)
1409 if (ISSLASH(path
[i
])) break;
1410 if (i
== 2 || i
== pathlen
)
1411 /* do not allow \\\SHARE or \\SERVER */
1414 for (i
= share
; i
< pathlen
; i
++)
1415 if (ISSLASH(path
[i
])) break;
1416 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1422 IsUNCRootW(Py_UNICODE
*path
, int pathlen
)
1424 #define ISSLASH ISSLASHW
1428 if (pathlen
< 5 || !ISSLASH(path
[0]) || !ISSLASH(path
[1]))
1429 /* minimum UNCRoot is \\x\y */
1431 for (i
= 2; i
< pathlen
; i
++)
1432 if (ISSLASH(path
[i
])) break;
1433 if (i
== 2 || i
== pathlen
)
1434 /* do not allow \\\SHARE or \\SERVER */
1437 for (i
= share
; i
< pathlen
; i
++)
1438 if (ISSLASH(path
[i
])) break;
1439 return (i
!= share
&& (i
== pathlen
|| i
== pathlen
-1));
1443 #endif /* MS_WINDOWS */
1446 posix_do_stat(PyObject
*self
, PyObject
*args
,
1449 int (*statfunc
)(const char *, STRUCT_STAT
*, ...),
1451 int (*statfunc
)(const char *, STRUCT_STAT
*),
1454 int (*wstatfunc
)(const Py_UNICODE
*, STRUCT_STAT
*))
1457 char *path
= NULL
; /* pass this to stat; do not free() it */
1458 char *pathfree
= NULL
; /* this memory must be free'd */
1463 PyUnicodeObject
*po
;
1464 if (PyArg_ParseTuple(args
, wformat
, &po
)) {
1465 Py_UNICODE
*wpath
= PyUnicode_AS_UNICODE(po
);
1467 Py_BEGIN_ALLOW_THREADS
1468 /* PyUnicode_AS_UNICODE result OK without
1469 thread lock as it is a simple dereference. */
1470 res
= wstatfunc(wpath
, &st
);
1471 Py_END_ALLOW_THREADS
1474 return win32_error_unicode("stat", wpath
);
1475 return _pystat_fromstructstat(&st
);
1477 /* Drop the argument parsing error as narrow strings
1482 if (!PyArg_ParseTuple(args
, format
,
1483 Py_FileSystemDefaultEncoding
, &path
))
1487 Py_BEGIN_ALLOW_THREADS
1488 res
= (*statfunc
)(path
, &st
);
1489 Py_END_ALLOW_THREADS
1493 result
= win32_error("stat", pathfree
);
1495 result
= posix_error_with_filename(pathfree
);
1499 result
= _pystat_fromstructstat(&st
);
1501 PyMem_Free(pathfree
);
1507 PyDoc_STRVAR(posix_access__doc__
,
1508 "access(path, mode) -> True if granted, False otherwise\n\n\
1509 Use the real uid/gid to test for access to a path. Note that most\n\
1510 operations will use the effective uid/gid, therefore this routine can\n\
1511 be used in a suid/sgid environment to test if the invoking user has the\n\
1512 specified access to the path. The mode argument can be F_OK to test\n\
1513 existence, or the inclusive-OR of R_OK, W_OK, and X_OK.");
1516 posix_access(PyObject
*self
, PyObject
*args
)
1523 PyUnicodeObject
*po
;
1524 if (PyArg_ParseTuple(args
, "Ui:access", &po
, &mode
)) {
1525 Py_BEGIN_ALLOW_THREADS
1526 /* PyUnicode_AS_UNICODE OK without thread lock as
1527 it is a simple dereference. */
1528 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1529 Py_END_ALLOW_THREADS
1532 /* Drop the argument parsing error as narrow strings
1535 if (!PyArg_ParseTuple(args
, "eti:access",
1536 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1538 Py_BEGIN_ALLOW_THREADS
1539 attr
= GetFileAttributesA(path
);
1540 Py_END_ALLOW_THREADS
1543 if (attr
== 0xFFFFFFFF)
1544 /* File does not exist, or cannot read attributes */
1545 return PyBool_FromLong(0);
1546 /* Access is possible if either write access wasn't requested, or
1547 the file isn't read-only, or if it's a directory, as there are
1548 no read-only directories on Windows. */
1549 return PyBool_FromLong(!(mode
& 2)
1550 || !(attr
& FILE_ATTRIBUTE_READONLY
)
1551 || (attr
& FILE_ATTRIBUTE_DIRECTORY
));
1552 #else /* MS_WINDOWS */
1554 if (!PyArg_ParseTuple(args
, "eti:access",
1555 Py_FileSystemDefaultEncoding
, &path
, &mode
))
1557 Py_BEGIN_ALLOW_THREADS
1558 res
= access(path
, mode
);
1559 Py_END_ALLOW_THREADS
1561 return PyBool_FromLong(res
== 0);
1562 #endif /* MS_WINDOWS */
1579 PyDoc_STRVAR(posix_ttyname__doc__
,
1580 "ttyname(fd) -> string\n\n\
1581 Return the name of the terminal device connected to 'fd'.");
1584 posix_ttyname(PyObject
*self
, PyObject
*args
)
1589 if (!PyArg_ParseTuple(args
, "i:ttyname", &id
))
1593 /* file descriptor 0 only, the default input device (stdin) */
1604 return posix_error();
1605 return PyString_FromString(ret
);
1610 PyDoc_STRVAR(posix_ctermid__doc__
,
1611 "ctermid() -> string\n\n\
1612 Return the name of the controlling terminal for this process.");
1615 posix_ctermid(PyObject
*self
, PyObject
*noargs
)
1618 char buffer
[L_ctermid
];
1620 #ifdef USE_CTERMID_R
1621 ret
= ctermid_r(buffer
);
1623 ret
= ctermid(buffer
);
1626 return posix_error();
1627 return PyString_FromString(buffer
);
1631 PyDoc_STRVAR(posix_chdir__doc__
,
1633 Change the current working directory to the specified path.");
1636 posix_chdir(PyObject
*self
, PyObject
*args
)
1639 return win32_1str(args
, "chdir", "s:chdir", win32_chdir
, "U:chdir", win32_wchdir
);
1640 #elif defined(PYOS_OS2) && defined(PYCC_GCC)
1641 return posix_1str(args
, "et:chdir", _chdir2
);
1642 #elif defined(__VMS)
1643 return posix_1str(args
, "et:chdir", (int (*)(const char *))chdir
);
1645 return posix_1str(args
, "et:chdir", chdir
);
1650 PyDoc_STRVAR(posix_fchdir__doc__
,
1651 "fchdir(fildes)\n\n\
1652 Change to the directory of the given file descriptor. fildes must be\n\
1653 opened on a directory, not a file.");
1656 posix_fchdir(PyObject
*self
, PyObject
*fdobj
)
1658 return posix_fildes(fdobj
, fchdir
);
1660 #endif /* HAVE_FCHDIR */
1663 PyDoc_STRVAR(posix_chmod__doc__
,
1664 "chmod(path, mode)\n\n\
1665 Change the access permissions of a file.");
1668 posix_chmod(PyObject
*self
, PyObject
*args
)
1675 PyUnicodeObject
*po
;
1676 if (PyArg_ParseTuple(args
, "Ui|:chmod", &po
, &i
)) {
1677 Py_BEGIN_ALLOW_THREADS
1678 attr
= GetFileAttributesW(PyUnicode_AS_UNICODE(po
));
1679 if (attr
!= 0xFFFFFFFF) {
1681 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1683 attr
|= FILE_ATTRIBUTE_READONLY
;
1684 res
= SetFileAttributesW(PyUnicode_AS_UNICODE(po
), attr
);
1688 Py_END_ALLOW_THREADS
1690 return win32_error_unicode("chmod",
1691 PyUnicode_AS_UNICODE(po
));
1695 /* Drop the argument parsing error as narrow strings
1699 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1702 Py_BEGIN_ALLOW_THREADS
1703 attr
= GetFileAttributesA(path
);
1704 if (attr
!= 0xFFFFFFFF) {
1706 attr
&= ~FILE_ATTRIBUTE_READONLY
;
1708 attr
|= FILE_ATTRIBUTE_READONLY
;
1709 res
= SetFileAttributesA(path
, attr
);
1713 Py_END_ALLOW_THREADS
1715 win32_error("chmod", path
);
1722 #else /* MS_WINDOWS */
1723 if (!PyArg_ParseTuple(args
, "eti:chmod", Py_FileSystemDefaultEncoding
,
1726 Py_BEGIN_ALLOW_THREADS
1727 res
= chmod(path
, i
);
1728 Py_END_ALLOW_THREADS
1730 return posix_error_with_allocated_filename(path
);
1738 PyDoc_STRVAR(posix_fchmod__doc__
,
1739 "fchmod(fd, mode)\n\n\
1740 Change the access permissions of the file given by file\n\
1744 posix_fchmod(PyObject
*self
, PyObject
*args
)
1747 if (!PyArg_ParseTuple(args
, "ii:fchmod", &fd
, &mode
))
1749 Py_BEGIN_ALLOW_THREADS
1750 res
= fchmod(fd
, mode
);
1751 Py_END_ALLOW_THREADS
1753 return posix_error();
1756 #endif /* HAVE_FCHMOD */
1759 PyDoc_STRVAR(posix_lchmod__doc__
,
1760 "lchmod(path, mode)\n\n\
1761 Change the access permissions of a file. If path is a symlink, this\n\
1762 affects the link itself rather than the target.");
1765 posix_lchmod(PyObject
*self
, PyObject
*args
)
1770 if (!PyArg_ParseTuple(args
, "eti:lchmod", Py_FileSystemDefaultEncoding
,
1773 Py_BEGIN_ALLOW_THREADS
1774 res
= lchmod(path
, i
);
1775 Py_END_ALLOW_THREADS
1777 return posix_error_with_allocated_filename(path
);
1781 #endif /* HAVE_LCHMOD */
1785 PyDoc_STRVAR(posix_chflags__doc__
,
1786 "chflags(path, flags)\n\n\
1790 posix_chflags(PyObject
*self
, PyObject
*args
)
1793 unsigned long flags
;
1795 if (!PyArg_ParseTuple(args
, "etk:chflags",
1796 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1798 Py_BEGIN_ALLOW_THREADS
1799 res
= chflags(path
, flags
);
1800 Py_END_ALLOW_THREADS
1802 return posix_error_with_allocated_filename(path
);
1807 #endif /* HAVE_CHFLAGS */
1809 #ifdef HAVE_LCHFLAGS
1810 PyDoc_STRVAR(posix_lchflags__doc__
,
1811 "lchflags(path, flags)\n\n\
1813 This function will not follow symbolic links.");
1816 posix_lchflags(PyObject
*self
, PyObject
*args
)
1819 unsigned long flags
;
1821 if (!PyArg_ParseTuple(args
, "etk:lchflags",
1822 Py_FileSystemDefaultEncoding
, &path
, &flags
))
1824 Py_BEGIN_ALLOW_THREADS
1825 res
= lchflags(path
, flags
);
1826 Py_END_ALLOW_THREADS
1828 return posix_error_with_allocated_filename(path
);
1833 #endif /* HAVE_LCHFLAGS */
1836 PyDoc_STRVAR(posix_chroot__doc__
,
1838 Change root directory to path.");
1841 posix_chroot(PyObject
*self
, PyObject
*args
)
1843 return posix_1str(args
, "et:chroot", chroot
);
1848 PyDoc_STRVAR(posix_fsync__doc__
,
1850 force write of file with filedescriptor to disk.");
1853 posix_fsync(PyObject
*self
, PyObject
*fdobj
)
1855 return posix_fildes(fdobj
, fsync
);
1857 #endif /* HAVE_FSYNC */
1859 #ifdef HAVE_FDATASYNC
1862 extern int fdatasync(int); /* On HP-UX, in libc but not in unistd.h */
1865 PyDoc_STRVAR(posix_fdatasync__doc__
,
1866 "fdatasync(fildes)\n\n\
1867 force write of file with filedescriptor to disk.\n\
1868 does not force update of metadata.");
1871 posix_fdatasync(PyObject
*self
, PyObject
*fdobj
)
1873 return posix_fildes(fdobj
, fdatasync
);
1875 #endif /* HAVE_FDATASYNC */
1879 PyDoc_STRVAR(posix_chown__doc__
,
1880 "chown(path, uid, gid)\n\n\
1881 Change the owner and group id of path to the numeric uid and gid.");
1884 posix_chown(PyObject
*self
, PyObject
*args
)
1889 if (!PyArg_ParseTuple(args
, "etll:chown",
1890 Py_FileSystemDefaultEncoding
, &path
,
1893 Py_BEGIN_ALLOW_THREADS
1894 res
= chown(path
, (uid_t
) uid
, (gid_t
) gid
);
1895 Py_END_ALLOW_THREADS
1897 return posix_error_with_allocated_filename(path
);
1902 #endif /* HAVE_CHOWN */
1905 PyDoc_STRVAR(posix_fchown__doc__
,
1906 "fchown(fd, uid, gid)\n\n\
1907 Change the owner and group id of the file given by file descriptor\n\
1908 fd to the numeric uid and gid.");
1911 posix_fchown(PyObject
*self
, PyObject
*args
)
1915 if (!PyArg_ParseTuple(args
, "iii:chown", &fd
, &uid
, &gid
))
1917 Py_BEGIN_ALLOW_THREADS
1918 res
= fchown(fd
, (uid_t
) uid
, (gid_t
) gid
);
1919 Py_END_ALLOW_THREADS
1921 return posix_error();
1924 #endif /* HAVE_FCHOWN */
1927 PyDoc_STRVAR(posix_lchown__doc__
,
1928 "lchown(path, uid, gid)\n\n\
1929 Change the owner and group id of path to the numeric uid and gid.\n\
1930 This function will not follow symbolic links.");
1933 posix_lchown(PyObject
*self
, PyObject
*args
)
1938 if (!PyArg_ParseTuple(args
, "etii:lchown",
1939 Py_FileSystemDefaultEncoding
, &path
,
1942 Py_BEGIN_ALLOW_THREADS
1943 res
= lchown(path
, (uid_t
) uid
, (gid_t
) gid
);
1944 Py_END_ALLOW_THREADS
1946 return posix_error_with_allocated_filename(path
);
1951 #endif /* HAVE_LCHOWN */
1955 PyDoc_STRVAR(posix_getcwd__doc__
,
1956 "getcwd() -> path\n\n\
1957 Return a string representing the current working directory.");
1960 posix_getcwd(PyObject
*self
, PyObject
*noargs
)
1962 int bufsize_incr
= 1024;
1964 char *tmpbuf
= NULL
;
1966 PyObject
*dynamic_return
;
1968 Py_BEGIN_ALLOW_THREADS
1970 bufsize
= bufsize
+ bufsize_incr
;
1971 tmpbuf
= malloc(bufsize
);
1972 if (tmpbuf
== NULL
) {
1975 #if defined(PYOS_OS2) && defined(PYCC_GCC)
1976 res
= _getcwd2(tmpbuf
, bufsize
);
1978 res
= getcwd(tmpbuf
, bufsize
);
1984 } while ((res
== NULL
) && (errno
== ERANGE
));
1985 Py_END_ALLOW_THREADS
1988 return posix_error();
1990 dynamic_return
= PyString_FromString(tmpbuf
);
1993 return dynamic_return
;
1996 #ifdef Py_USING_UNICODE
1997 PyDoc_STRVAR(posix_getcwdu__doc__
,
1998 "getcwdu() -> path\n\n\
1999 Return a unicode string representing the current working directory.");
2002 posix_getcwdu(PyObject
*self
, PyObject
*noargs
)
2010 wchar_t *wbuf2
= wbuf
;
2012 Py_BEGIN_ALLOW_THREADS
2013 len
= GetCurrentDirectoryW(sizeof wbuf
/ sizeof wbuf
[0], wbuf
);
2014 /* If the buffer is large enough, len does not include the
2015 terminating \0. If the buffer is too small, len includes
2016 the space needed for the terminator. */
2017 if (len
>= sizeof wbuf
/ sizeof wbuf
[0]) {
2018 wbuf2
= malloc(len
* sizeof(wchar_t));
2020 len
= GetCurrentDirectoryW(len
, wbuf2
);
2022 Py_END_ALLOW_THREADS
2028 if (wbuf2
!= wbuf
) free(wbuf2
);
2029 return win32_error("getcwdu", NULL
);
2031 resobj
= PyUnicode_FromWideChar(wbuf2
, len
);
2032 if (wbuf2
!= wbuf
) free(wbuf2
);
2034 #endif /* MS_WINDOWS */
2036 Py_BEGIN_ALLOW_THREADS
2037 #if defined(PYOS_OS2) && defined(PYCC_GCC)
2038 res
= _getcwd2(buf
, sizeof buf
);
2040 res
= getcwd(buf
, sizeof buf
);
2042 Py_END_ALLOW_THREADS
2044 return posix_error();
2045 return PyUnicode_Decode(buf
, strlen(buf
), Py_FileSystemDefaultEncoding
,"strict");
2047 #endif /* Py_USING_UNICODE */
2048 #endif /* HAVE_GETCWD */
2052 PyDoc_STRVAR(posix_link__doc__
,
2053 "link(src, dst)\n\n\
2054 Create a hard link to a file.");
2057 posix_link(PyObject
*self
, PyObject
*args
)
2059 return posix_2str(args
, "etet:link", link
);
2061 #endif /* HAVE_LINK */
2064 PyDoc_STRVAR(posix_listdir__doc__
,
2065 "listdir(path) -> list_of_strings\n\n\
2066 Return a list containing the names of the entries in the directory.\n\
2068 path: path of directory to list\n\
2070 The list is in arbitrary order. It does not include the special\n\
2071 entries '.' and '..' even if they are present in the directory.");
2074 posix_listdir(PyObject
*self
, PyObject
*args
)
2076 /* XXX Should redo this putting the (now four) versions of opendir
2077 in separate files instead of having them all here... */
2078 #if defined(MS_WINDOWS) && !defined(HAVE_OPENDIR)
2083 WIN32_FIND_DATA FileData
;
2084 char namebuf
[MAX_PATH
+5]; /* Overallocate for \\*.*\0 */
2085 char *bufptr
= namebuf
;
2086 Py_ssize_t len
= sizeof(namebuf
)-5; /* only claim to have space for MAX_PATH */
2089 if (PyArg_ParseTuple(args
, "U:listdir", &po
)) {
2090 WIN32_FIND_DATAW wFileData
;
2091 Py_UNICODE
*wnamebuf
;
2092 /* Overallocate for \\*.*\0 */
2093 len
= PyUnicode_GET_SIZE(po
);
2094 wnamebuf
= malloc((len
+ 5) * sizeof(wchar_t));
2099 wcscpy(wnamebuf
, PyUnicode_AS_UNICODE(po
));
2101 Py_UNICODE wch
= wnamebuf
[len
-1];
2102 if (wch
!= L
'/' && wch
!= L
'\\' && wch
!= L
':')
2103 wnamebuf
[len
++] = L
'\\';
2104 wcscpy(wnamebuf
+ len
, L
"*.*");
2106 if ((d
= PyList_New(0)) == NULL
) {
2110 hFindFile
= FindFirstFileW(wnamebuf
, &wFileData
);
2111 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2112 int error
= GetLastError();
2113 if (error
== ERROR_FILE_NOT_FOUND
) {
2118 win32_error_unicode("FindFirstFileW", wnamebuf
);
2123 /* Skip over . and .. */
2124 if (wcscmp(wFileData
.cFileName
, L
".") != 0 &&
2125 wcscmp(wFileData
.cFileName
, L
"..") != 0) {
2126 v
= PyUnicode_FromUnicode(wFileData
.cFileName
, wcslen(wFileData
.cFileName
));
2132 if (PyList_Append(d
, v
) != 0) {
2140 Py_BEGIN_ALLOW_THREADS
2141 result
= FindNextFileW(hFindFile
, &wFileData
);
2142 Py_END_ALLOW_THREADS
2143 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2144 it got to the end of the directory. */
2145 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2147 win32_error_unicode("FindNextFileW", wnamebuf
);
2148 FindClose(hFindFile
);
2152 } while (result
== TRUE
);
2154 if (FindClose(hFindFile
) == FALSE
) {
2156 win32_error_unicode("FindClose", wnamebuf
);
2163 /* Drop the argument parsing error as narrow strings
2167 if (!PyArg_ParseTuple(args
, "et#:listdir",
2168 Py_FileSystemDefaultEncoding
, &bufptr
, &len
))
2171 char ch
= namebuf
[len
-1];
2172 if (ch
!= SEP
&& ch
!= ALTSEP
&& ch
!= ':')
2173 namebuf
[len
++] = '/';
2174 strcpy(namebuf
+ len
, "*.*");
2177 if ((d
= PyList_New(0)) == NULL
)
2180 hFindFile
= FindFirstFile(namebuf
, &FileData
);
2181 if (hFindFile
== INVALID_HANDLE_VALUE
) {
2182 int error
= GetLastError();
2183 if (error
== ERROR_FILE_NOT_FOUND
)
2186 return win32_error("FindFirstFile", namebuf
);
2189 /* Skip over . and .. */
2190 if (strcmp(FileData
.cFileName
, ".") != 0 &&
2191 strcmp(FileData
.cFileName
, "..") != 0) {
2192 v
= PyString_FromString(FileData
.cFileName
);
2198 if (PyList_Append(d
, v
) != 0) {
2206 Py_BEGIN_ALLOW_THREADS
2207 result
= FindNextFile(hFindFile
, &FileData
);
2208 Py_END_ALLOW_THREADS
2209 /* FindNextFile sets error to ERROR_NO_MORE_FILES if
2210 it got to the end of the directory. */
2211 if (!result
&& GetLastError() != ERROR_NO_MORE_FILES
) {
2213 win32_error("FindNextFile", namebuf
);
2214 FindClose(hFindFile
);
2217 } while (result
== TRUE
);
2219 if (FindClose(hFindFile
) == FALSE
) {
2221 return win32_error("FindClose", namebuf
);
2226 #elif defined(PYOS_OS2)
2229 #define MAX_PATH CCHMAXPATH
2234 char namebuf
[MAX_PATH
+5];
2240 if (!PyArg_ParseTuple(args
, "t#:listdir", &name
, &len
))
2242 if (len
>= MAX_PATH
) {
2243 PyErr_SetString(PyExc_ValueError
, "path too long");
2246 strcpy(namebuf
, name
);
2247 for (pt
= namebuf
; *pt
; pt
++)
2250 if (namebuf
[len
-1] != SEP
)
2251 namebuf
[len
++] = SEP
;
2252 strcpy(namebuf
+ len
, "*.*");
2254 if ((d
= PyList_New(0)) == NULL
)
2257 rc
= DosFindFirst(namebuf
, /* Wildcard Pattern to Match */
2258 &hdir
, /* Handle to Use While Search Directory */
2259 FILE_READONLY
| FILE_HIDDEN
| FILE_SYSTEM
| FILE_DIRECTORY
,
2260 &ep
, sizeof(ep
), /* Structure to Receive Directory Entry */
2261 &srchcnt
, /* Max and Actual Count of Entries Per Iteration */
2262 FIL_STANDARD
); /* Format of Entry (EAs or Not) */
2264 if (rc
!= NO_ERROR
) {
2266 return posix_error_with_filename(name
);
2269 if (srchcnt
> 0) { /* If Directory is NOT Totally Empty, */
2271 if (ep
.achName
[0] == '.'
2272 && (ep
.achName
[1] == '\0' || (ep
.achName
[1] == '.' && ep
.achName
[2] == '\0')))
2273 continue; /* Skip Over "." and ".." Names */
2275 strcpy(namebuf
, ep
.achName
);
2277 /* Leave Case of Name Alone -- In Native Form */
2278 /* (Removed Forced Lowercasing Code) */
2280 v
= PyString_FromString(namebuf
);
2286 if (PyList_Append(d
, v
) != 0) {
2293 } while (DosFindNext(hdir
, &ep
, sizeof(ep
), &srchcnt
) == NO_ERROR
&& srchcnt
> 0);
2303 int arg_is_unicode
= 1;
2306 if (!PyArg_ParseTuple(args
, "U:listdir", &v
)) {
2310 if (!PyArg_ParseTuple(args
, "et:listdir", Py_FileSystemDefaultEncoding
, &name
))
2312 if ((dirp
= opendir(name
)) == NULL
) {
2313 return posix_error_with_allocated_filename(name
);
2315 if ((d
= PyList_New(0)) == NULL
) {
2322 Py_BEGIN_ALLOW_THREADS
2324 Py_END_ALLOW_THREADS
2331 return posix_error_with_allocated_filename(name
);
2334 if (ep
->d_name
[0] == '.' &&
2336 (ep
->d_name
[1] == '.' && NAMLEN(ep
) == 2)))
2338 v
= PyString_FromStringAndSize(ep
->d_name
, NAMLEN(ep
));
2344 #ifdef Py_USING_UNICODE
2345 if (arg_is_unicode
) {
2348 w
= PyUnicode_FromEncodedObject(v
,
2349 Py_FileSystemDefaultEncoding
,
2356 /* fall back to the original byte string, as
2357 discussed in patch #683592 */
2362 if (PyList_Append(d
, v
) != 0) {
2375 #endif /* which OS */
2376 } /* end of posix_listdir */
2379 /* A helper function for abspath on win32 */
2381 posix__getfullpathname(PyObject
*self
, PyObject
*args
)
2383 /* assume encoded strings won't more than double no of chars */
2384 char inbuf
[MAX_PATH
*2];
2385 char *inbufp
= inbuf
;
2386 Py_ssize_t insize
= sizeof(inbuf
);
2387 char outbuf
[MAX_PATH
*2];
2390 PyUnicodeObject
*po
;
2391 if (PyArg_ParseTuple(args
, "U|:_getfullpathname", &po
)) {
2392 Py_UNICODE
*wpath
= PyUnicode_AS_UNICODE(po
);
2393 Py_UNICODE woutbuf
[MAX_PATH
*2], *woutbufp
= woutbuf
;
2397 result
= GetFullPathNameW(wpath
,
2398 sizeof(woutbuf
)/sizeof(woutbuf
[0]),
2400 if (result
> sizeof(woutbuf
)/sizeof(woutbuf
[0])) {
2401 woutbufp
= malloc(result
* sizeof(Py_UNICODE
));
2403 return PyErr_NoMemory();
2404 result
= GetFullPathNameW(wpath
, result
, woutbufp
, &wtemp
);
2407 v
= PyUnicode_FromUnicode(woutbufp
, wcslen(woutbufp
));
2409 v
= win32_error_unicode("GetFullPathNameW", wpath
);
2410 if (woutbufp
!= woutbuf
)
2414 /* Drop the argument parsing error as narrow strings
2418 if (!PyArg_ParseTuple (args
, "et#:_getfullpathname",
2419 Py_FileSystemDefaultEncoding
, &inbufp
,
2422 if (!GetFullPathName(inbuf
, sizeof(outbuf
)/sizeof(outbuf
[0]),
2424 return win32_error("GetFullPathName", inbuf
);
2425 if (PyUnicode_Check(PyTuple_GetItem(args
, 0))) {
2426 return PyUnicode_Decode(outbuf
, strlen(outbuf
),
2427 Py_FileSystemDefaultEncoding
, NULL
);
2429 return PyString_FromString(outbuf
);
2430 } /* end of posix__getfullpathname */
2431 #endif /* MS_WINDOWS */
2433 PyDoc_STRVAR(posix_mkdir__doc__
,
2434 "mkdir(path [, mode=0777])\n\n\
2435 Create a directory.");
2438 posix_mkdir(PyObject
*self
, PyObject
*args
)
2445 PyUnicodeObject
*po
;
2446 if (PyArg_ParseTuple(args
, "U|i:mkdir", &po
, &mode
)) {
2447 Py_BEGIN_ALLOW_THREADS
2448 /* PyUnicode_AS_UNICODE OK without thread lock as
2449 it is a simple dereference. */
2450 res
= CreateDirectoryW(PyUnicode_AS_UNICODE(po
), NULL
);
2451 Py_END_ALLOW_THREADS
2453 return win32_error_unicode("mkdir", PyUnicode_AS_UNICODE(po
));
2457 /* Drop the argument parsing error as narrow strings
2460 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2461 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2463 Py_BEGIN_ALLOW_THREADS
2464 /* PyUnicode_AS_UNICODE OK without thread lock as
2465 it is a simple dereference. */
2466 res
= CreateDirectoryA(path
, NULL
);
2467 Py_END_ALLOW_THREADS
2469 win32_error("mkdir", path
);
2476 #else /* MS_WINDOWS */
2478 if (!PyArg_ParseTuple(args
, "et|i:mkdir",
2479 Py_FileSystemDefaultEncoding
, &path
, &mode
))
2481 Py_BEGIN_ALLOW_THREADS
2482 #if ( defined(__WATCOMC__) || defined(PYCC_VACPP) ) && !defined(__QNX__)
2485 res
= mkdir(path
, mode
);
2487 Py_END_ALLOW_THREADS
2489 return posix_error_with_allocated_filename(path
);
2493 #endif /* MS_WINDOWS */
2497 /* sys/resource.h is needed for at least: wait3(), wait4(), broken nice. */
2498 #if defined(HAVE_SYS_RESOURCE_H)
2499 #include <sys/resource.h>
2504 PyDoc_STRVAR(posix_nice__doc__
,
2505 "nice(inc) -> new_priority\n\n\
2506 Decrease the priority of process by inc and return the new priority.");
2509 posix_nice(PyObject
*self
, PyObject
*args
)
2511 int increment
, value
;
2513 if (!PyArg_ParseTuple(args
, "i:nice", &increment
))
2516 /* There are two flavours of 'nice': one that returns the new
2517 priority (as required by almost all standards out there) and the
2518 Linux/FreeBSD/BSDI one, which returns '0' on success and advices
2519 the use of getpriority() to get the new priority.
2521 If we are of the nice family that returns the new priority, we
2522 need to clear errno before the call, and check if errno is filled
2523 before calling posix_error() on a returnvalue of -1, because the
2524 -1 may be the actual new priority! */
2527 value
= nice(increment
);
2528 #if defined(HAVE_BROKEN_NICE) && defined(HAVE_GETPRIORITY)
2530 value
= getpriority(PRIO_PROCESS
, 0);
2532 if (value
== -1 && errno
!= 0)
2533 /* either nice() or getpriority() returned an error */
2534 return posix_error();
2535 return PyInt_FromLong((long) value
);
2537 #endif /* HAVE_NICE */
2539 PyDoc_STRVAR(posix_rename__doc__
,
2540 "rename(old, new)\n\n\
2541 Rename a file or directory.");
2544 posix_rename(PyObject
*self
, PyObject
*args
)
2550 if (!PyArg_ParseTuple(args
, "OO:rename", &o1
, &o2
))
2552 if (!convert_to_unicode(&o1
))
2554 if (!convert_to_unicode(&o2
)) {
2558 Py_BEGIN_ALLOW_THREADS
2559 result
= MoveFileW(PyUnicode_AsUnicode(o1
),
2560 PyUnicode_AsUnicode(o2
));
2561 Py_END_ALLOW_THREADS
2565 return win32_error("rename", NULL
);
2570 if (!PyArg_ParseTuple(args
, "ss:rename", &p1
, &p2
))
2572 Py_BEGIN_ALLOW_THREADS
2573 result
= MoveFileA(p1
, p2
);
2574 Py_END_ALLOW_THREADS
2576 return win32_error("rename", NULL
);
2580 return posix_2str(args
, "etet:rename", rename
);
2585 PyDoc_STRVAR(posix_rmdir__doc__
,
2587 Remove a directory.");
2590 posix_rmdir(PyObject
*self
, PyObject
*args
)
2593 return win32_1str(args
, "rmdir", "s:rmdir", RemoveDirectoryA
, "U:rmdir", RemoveDirectoryW
);
2595 return posix_1str(args
, "et:rmdir", rmdir
);
2600 PyDoc_STRVAR(posix_stat__doc__
,
2601 "stat(path) -> stat result\n\n\
2602 Perform a stat system call on the given path.");
2605 posix_stat(PyObject
*self
, PyObject
*args
)
2608 return posix_do_stat(self
, args
, "et:stat", STAT
, "U:stat", win32_wstat
);
2610 return posix_do_stat(self
, args
, "et:stat", STAT
, NULL
, NULL
);
2616 PyDoc_STRVAR(posix_system__doc__
,
2617 "system(command) -> exit_status\n\n\
2618 Execute the command (a string) in a subshell.");
2621 posix_system(PyObject
*self
, PyObject
*args
)
2625 if (!PyArg_ParseTuple(args
, "s:system", &command
))
2627 Py_BEGIN_ALLOW_THREADS
2628 sts
= system(command
);
2629 Py_END_ALLOW_THREADS
2630 return PyInt_FromLong(sts
);
2635 PyDoc_STRVAR(posix_umask__doc__
,
2636 "umask(new_mask) -> old_mask\n\n\
2637 Set the current numeric umask and return the previous umask.");
2640 posix_umask(PyObject
*self
, PyObject
*args
)
2643 if (!PyArg_ParseTuple(args
, "i:umask", &i
))
2647 return posix_error();
2648 return PyInt_FromLong((long)i
);
2652 PyDoc_STRVAR(posix_unlink__doc__
,
2654 Remove a file (same as remove(path)).");
2656 PyDoc_STRVAR(posix_remove__doc__
,
2658 Remove a file (same as unlink(path)).");
2661 posix_unlink(PyObject
*self
, PyObject
*args
)
2664 return win32_1str(args
, "remove", "s:remove", DeleteFileA
, "U:remove", DeleteFileW
);
2666 return posix_1str(args
, "et:remove", unlink
);
2672 PyDoc_STRVAR(posix_uname__doc__
,
2673 "uname() -> (sysname, nodename, release, version, machine)\n\n\
2674 Return a tuple identifying the current operating system.");
2677 posix_uname(PyObject
*self
, PyObject
*noargs
)
2682 Py_BEGIN_ALLOW_THREADS
2684 Py_END_ALLOW_THREADS
2686 return posix_error();
2687 return Py_BuildValue("(sssss)",
2694 #endif /* HAVE_UNAME */
2697 extract_time(PyObject
*t
, long* sec
, long* usec
)
2700 if (PyFloat_Check(t
)) {
2701 double tval
= PyFloat_AsDouble(t
);
2702 PyObject
*intobj
= Py_TYPE(t
)->tp_as_number
->nb_int(t
);
2705 intval
= PyInt_AsLong(intobj
);
2707 if (intval
== -1 && PyErr_Occurred())
2710 *usec
= (long)((tval
- intval
) * 1e6
); /* can't exceed 1000000 */
2712 /* If rounding gave us a negative number,
2717 intval
= PyInt_AsLong(t
);
2718 if (intval
== -1 && PyErr_Occurred())
2725 PyDoc_STRVAR(posix_utime__doc__
,
2726 "utime(path, (atime, mtime))\n\
2727 utime(path, None)\n\n\
2728 Set the access and modified time of the file to the given values. If the\n\
2729 second form is used, set the access and modified times to the current time.");
2732 posix_utime(PyObject
*self
, PyObject
*args
)
2736 PyUnicodeObject
*obwpath
;
2737 wchar_t *wpath
= NULL
;
2740 long atimesec
, mtimesec
, ausec
, musec
;
2741 FILETIME atime
, mtime
;
2742 PyObject
*result
= NULL
;
2744 if (PyArg_ParseTuple(args
, "UO|:utime", &obwpath
, &arg
)) {
2745 wpath
= PyUnicode_AS_UNICODE(obwpath
);
2746 Py_BEGIN_ALLOW_THREADS
2747 hFile
= CreateFileW(wpath
, FILE_WRITE_ATTRIBUTES
, 0,
2748 NULL
, OPEN_EXISTING
,
2749 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2750 Py_END_ALLOW_THREADS
2751 if (hFile
== INVALID_HANDLE_VALUE
)
2752 return win32_error_unicode("utime", wpath
);
2754 /* Drop the argument parsing error as narrow strings
2759 if (!PyArg_ParseTuple(args
, "etO:utime",
2760 Py_FileSystemDefaultEncoding
, &apath
, &arg
))
2762 Py_BEGIN_ALLOW_THREADS
2763 hFile
= CreateFileA(apath
, FILE_WRITE_ATTRIBUTES
, 0,
2764 NULL
, OPEN_EXISTING
,
2765 FILE_FLAG_BACKUP_SEMANTICS
, NULL
);
2766 Py_END_ALLOW_THREADS
2767 if (hFile
== INVALID_HANDLE_VALUE
) {
2768 win32_error("utime", apath
);
2775 if (arg
== Py_None
) {
2777 GetSystemTime(&now
);
2778 if (!SystemTimeToFileTime(&now
, &mtime
) ||
2779 !SystemTimeToFileTime(&now
, &atime
)) {
2780 win32_error("utime", NULL
);
2784 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2785 PyErr_SetString(PyExc_TypeError
,
2786 "utime() arg 2 must be a tuple (atime, mtime)");
2790 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2791 &atimesec
, &ausec
) == -1)
2793 time_t_to_FILE_TIME(atimesec
, 1000*ausec
, &atime
);
2794 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2795 &mtimesec
, &musec
) == -1)
2797 time_t_to_FILE_TIME(mtimesec
, 1000*musec
, &mtime
);
2799 if (!SetFileTime(hFile
, NULL
, &atime
, &mtime
)) {
2800 /* Avoid putting the file name into the error here,
2801 as that may confuse the user into believing that
2802 something is wrong with the file, when it also
2803 could be the time stamp that gives a problem. */
2804 win32_error("utime", NULL
);
2811 #else /* MS_WINDOWS */
2814 long atime
, mtime
, ausec
, musec
;
2818 #if defined(HAVE_UTIMES)
2819 struct timeval buf
[2];
2820 #define ATIME buf[0].tv_sec
2821 #define MTIME buf[1].tv_sec
2822 #elif defined(HAVE_UTIME_H)
2823 /* XXX should define struct utimbuf instead, above */
2825 #define ATIME buf.actime
2826 #define MTIME buf.modtime
2827 #define UTIME_ARG &buf
2828 #else /* HAVE_UTIMES */
2830 #define ATIME buf[0]
2831 #define MTIME buf[1]
2832 #define UTIME_ARG buf
2833 #endif /* HAVE_UTIMES */
2836 if (!PyArg_ParseTuple(args
, "etO:utime",
2837 Py_FileSystemDefaultEncoding
, &path
, &arg
))
2839 if (arg
== Py_None
) {
2840 /* optional time values not given */
2841 Py_BEGIN_ALLOW_THREADS
2842 res
= utime(path
, NULL
);
2843 Py_END_ALLOW_THREADS
2845 else if (!PyTuple_Check(arg
) || PyTuple_Size(arg
) != 2) {
2846 PyErr_SetString(PyExc_TypeError
,
2847 "utime() arg 2 must be a tuple (atime, mtime)");
2852 if (extract_time(PyTuple_GET_ITEM(arg
, 0),
2853 &atime
, &ausec
) == -1) {
2857 if (extract_time(PyTuple_GET_ITEM(arg
, 1),
2858 &mtime
, &musec
) == -1) {
2865 buf
[0].tv_usec
= ausec
;
2866 buf
[1].tv_usec
= musec
;
2867 Py_BEGIN_ALLOW_THREADS
2868 res
= utimes(path
, buf
);
2869 Py_END_ALLOW_THREADS
2871 Py_BEGIN_ALLOW_THREADS
2872 res
= utime(path
, UTIME_ARG
);
2873 Py_END_ALLOW_THREADS
2874 #endif /* HAVE_UTIMES */
2877 return posix_error_with_allocated_filename(path
);
2885 #endif /* MS_WINDOWS */
2889 /* Process operations */
2891 PyDoc_STRVAR(posix__exit__doc__
,
2893 Exit to the system with specified status, without normal exit processing.");
2896 posix__exit(PyObject
*self
, PyObject
*args
)
2899 if (!PyArg_ParseTuple(args
, "i:_exit", &sts
))
2902 return NULL
; /* Make gcc -Wall happy */
2905 #if defined(HAVE_EXECV) || defined(HAVE_SPAWNV)
2907 free_string_array(char **array
, Py_ssize_t count
)
2910 for (i
= 0; i
< count
; i
++)
2911 PyMem_Free(array
[i
]);
2918 PyDoc_STRVAR(posix_execv__doc__
,
2919 "execv(path, args)\n\n\
2920 Execute an executable path with arguments, replacing current process.\n\
2922 path: path of executable file\n\
2923 args: tuple or list of strings");
2926 posix_execv(PyObject
*self
, PyObject
*args
)
2932 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
2934 /* execv has two arguments: (path, argv), where
2935 argv is a list or tuple of strings. */
2937 if (!PyArg_ParseTuple(args
, "etO:execv",
2938 Py_FileSystemDefaultEncoding
,
2941 if (PyList_Check(argv
)) {
2942 argc
= PyList_Size(argv
);
2943 getitem
= PyList_GetItem
;
2945 else if (PyTuple_Check(argv
)) {
2946 argc
= PyTuple_Size(argv
);
2947 getitem
= PyTuple_GetItem
;
2950 PyErr_SetString(PyExc_TypeError
, "execv() arg 2 must be a tuple or list");
2955 argvlist
= PyMem_NEW(char *, argc
+1);
2956 if (argvlist
== NULL
) {
2958 return PyErr_NoMemory();
2960 for (i
= 0; i
< argc
; i
++) {
2961 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
2962 Py_FileSystemDefaultEncoding
,
2964 free_string_array(argvlist
, i
);
2965 PyErr_SetString(PyExc_TypeError
,
2966 "execv() arg 2 must contain only strings");
2972 argvlist
[argc
] = NULL
;
2974 execv(path
, argvlist
);
2976 /* If we get here it's definitely an error */
2978 free_string_array(argvlist
, argc
);
2980 return posix_error();
2984 PyDoc_STRVAR(posix_execve__doc__
,
2985 "execve(path, args, env)\n\n\
2986 Execute a path with arguments and environment, replacing current process.\n\
2988 path: path of executable file\n\
2989 args: tuple or list of arguments\n\
2990 env: dictionary of strings mapping to strings");
2993 posix_execve(PyObject
*self
, PyObject
*args
)
2996 PyObject
*argv
, *env
;
2999 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
;
3000 Py_ssize_t i
, pos
, argc
, envc
;
3001 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3002 Py_ssize_t lastarg
= 0;
3004 /* execve has three arguments: (path, argv, env), where
3005 argv is a list or tuple of strings and env is a dictionary
3006 like posix.environ. */
3008 if (!PyArg_ParseTuple(args
, "etOO:execve",
3009 Py_FileSystemDefaultEncoding
,
3010 &path
, &argv
, &env
))
3012 if (PyList_Check(argv
)) {
3013 argc
= PyList_Size(argv
);
3014 getitem
= PyList_GetItem
;
3016 else if (PyTuple_Check(argv
)) {
3017 argc
= PyTuple_Size(argv
);
3018 getitem
= PyTuple_GetItem
;
3021 PyErr_SetString(PyExc_TypeError
,
3022 "execve() arg 2 must be a tuple or list");
3025 if (!PyMapping_Check(env
)) {
3026 PyErr_SetString(PyExc_TypeError
,
3027 "execve() arg 3 must be a mapping object");
3031 argvlist
= PyMem_NEW(char *, argc
+1);
3032 if (argvlist
== NULL
) {
3036 for (i
= 0; i
< argc
; i
++) {
3037 if (!PyArg_Parse((*getitem
)(argv
, i
),
3038 "et;execve() arg 2 must contain only strings",
3039 Py_FileSystemDefaultEncoding
,
3047 argvlist
[argc
] = NULL
;
3049 i
= PyMapping_Size(env
);
3052 envlist
= PyMem_NEW(char *, i
+ 1);
3053 if (envlist
== NULL
) {
3058 keys
= PyMapping_Keys(env
);
3059 vals
= PyMapping_Values(env
);
3062 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3063 PyErr_SetString(PyExc_TypeError
,
3064 "execve(): env.keys() or env.values() is not a list");
3068 for (pos
= 0; pos
< i
; pos
++) {
3072 key
= PyList_GetItem(keys
, pos
);
3073 val
= PyList_GetItem(vals
, pos
);
3079 "s;execve() arg 3 contains a non-string key",
3083 "s;execve() arg 3 contains a non-string value",
3089 #if defined(PYOS_OS2)
3090 /* Omit Pseudo-Env Vars that Would Confuse Programs if Passed On */
3091 if (stricmp(k
, "BEGINLIBPATH") != 0 && stricmp(k
, "ENDLIBPATH") != 0) {
3093 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3094 p
= PyMem_NEW(char, len
);
3099 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3100 envlist
[envc
++] = p
;
3101 #if defined(PYOS_OS2)
3107 execve(path
, argvlist
, envlist
);
3109 /* If we get here it's definitely an error */
3111 (void) posix_error();
3115 PyMem_DEL(envlist
[envc
]);
3118 free_string_array(argvlist
, lastarg
);
3125 #endif /* HAVE_EXECV */
3129 PyDoc_STRVAR(posix_spawnv__doc__
,
3130 "spawnv(mode, path, args)\n\n\
3131 Execute the program 'path' in a new process.\n\
3133 mode: mode of process creation\n\
3134 path: path of executable file\n\
3135 args: tuple or list of strings");
3138 posix_spawnv(PyObject
*self
, PyObject
*args
)
3145 Py_intptr_t spawnval
;
3146 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3148 /* spawnv has three arguments: (mode, path, argv), where
3149 argv is a list or tuple of strings. */
3151 if (!PyArg_ParseTuple(args
, "ietO:spawnv", &mode
,
3152 Py_FileSystemDefaultEncoding
,
3155 if (PyList_Check(argv
)) {
3156 argc
= PyList_Size(argv
);
3157 getitem
= PyList_GetItem
;
3159 else if (PyTuple_Check(argv
)) {
3160 argc
= PyTuple_Size(argv
);
3161 getitem
= PyTuple_GetItem
;
3164 PyErr_SetString(PyExc_TypeError
,
3165 "spawnv() arg 2 must be a tuple or list");
3170 argvlist
= PyMem_NEW(char *, argc
+1);
3171 if (argvlist
== NULL
) {
3173 return PyErr_NoMemory();
3175 for (i
= 0; i
< argc
; i
++) {
3176 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3177 Py_FileSystemDefaultEncoding
,
3179 free_string_array(argvlist
, i
);
3182 "spawnv() arg 2 must contain only strings");
3187 argvlist
[argc
] = NULL
;
3189 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3190 Py_BEGIN_ALLOW_THREADS
3191 spawnval
= spawnv(mode
, path
, argvlist
);
3192 Py_END_ALLOW_THREADS
3194 if (mode
== _OLD_P_OVERLAY
)
3197 Py_BEGIN_ALLOW_THREADS
3198 spawnval
= _spawnv(mode
, path
, argvlist
);
3199 Py_END_ALLOW_THREADS
3202 free_string_array(argvlist
, argc
);
3206 return posix_error();
3208 #if SIZEOF_LONG == SIZEOF_VOID_P
3209 return Py_BuildValue("l", (long) spawnval
);
3211 return Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3216 PyDoc_STRVAR(posix_spawnve__doc__
,
3217 "spawnve(mode, path, args, env)\n\n\
3218 Execute the program 'path' in a new process.\n\
3220 mode: mode of process creation\n\
3221 path: path of executable file\n\
3222 args: tuple or list of arguments\n\
3223 env: dictionary of strings mapping to strings");
3226 posix_spawnve(PyObject
*self
, PyObject
*args
)
3229 PyObject
*argv
, *env
;
3232 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3233 int mode
, pos
, envc
;
3235 Py_intptr_t spawnval
;
3236 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3237 Py_ssize_t lastarg
= 0;
3239 /* spawnve has four arguments: (mode, path, argv, env), where
3240 argv is a list or tuple of strings and env is a dictionary
3241 like posix.environ. */
3243 if (!PyArg_ParseTuple(args
, "ietOO:spawnve", &mode
,
3244 Py_FileSystemDefaultEncoding
,
3245 &path
, &argv
, &env
))
3247 if (PyList_Check(argv
)) {
3248 argc
= PyList_Size(argv
);
3249 getitem
= PyList_GetItem
;
3251 else if (PyTuple_Check(argv
)) {
3252 argc
= PyTuple_Size(argv
);
3253 getitem
= PyTuple_GetItem
;
3256 PyErr_SetString(PyExc_TypeError
,
3257 "spawnve() arg 2 must be a tuple or list");
3260 if (!PyMapping_Check(env
)) {
3261 PyErr_SetString(PyExc_TypeError
,
3262 "spawnve() arg 3 must be a mapping object");
3266 argvlist
= PyMem_NEW(char *, argc
+1);
3267 if (argvlist
== NULL
) {
3271 for (i
= 0; i
< argc
; i
++) {
3272 if (!PyArg_Parse((*getitem
)(argv
, i
),
3273 "et;spawnve() arg 2 must contain only strings",
3274 Py_FileSystemDefaultEncoding
,
3282 argvlist
[argc
] = NULL
;
3284 i
= PyMapping_Size(env
);
3287 envlist
= PyMem_NEW(char *, i
+ 1);
3288 if (envlist
== NULL
) {
3293 keys
= PyMapping_Keys(env
);
3294 vals
= PyMapping_Values(env
);
3297 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3298 PyErr_SetString(PyExc_TypeError
,
3299 "spawnve(): env.keys() or env.values() is not a list");
3303 for (pos
= 0; pos
< i
; pos
++) {
3307 key
= PyList_GetItem(keys
, pos
);
3308 val
= PyList_GetItem(vals
, pos
);
3314 "s;spawnve() arg 3 contains a non-string key",
3318 "s;spawnve() arg 3 contains a non-string value",
3323 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3324 p
= PyMem_NEW(char, len
);
3329 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3330 envlist
[envc
++] = p
;
3334 #if defined(PYOS_OS2) && defined(PYCC_GCC)
3335 Py_BEGIN_ALLOW_THREADS
3336 spawnval
= spawnve(mode
, path
, argvlist
, envlist
);
3337 Py_END_ALLOW_THREADS
3339 if (mode
== _OLD_P_OVERLAY
)
3342 Py_BEGIN_ALLOW_THREADS
3343 spawnval
= _spawnve(mode
, path
, argvlist
, envlist
);
3344 Py_END_ALLOW_THREADS
3348 (void) posix_error();
3350 #if SIZEOF_LONG == SIZEOF_VOID_P
3351 res
= Py_BuildValue("l", (long) spawnval
);
3353 res
= Py_BuildValue("L", (PY_LONG_LONG
) spawnval
);
3358 PyMem_DEL(envlist
[envc
]);
3361 free_string_array(argvlist
, lastarg
);
3369 /* OS/2 supports spawnvp & spawnvpe natively */
3370 #if defined(PYOS_OS2)
3371 PyDoc_STRVAR(posix_spawnvp__doc__
,
3372 "spawnvp(mode, file, args)\n\n\
3373 Execute the program 'file' in a new process, using the environment\n\
3374 search path to find the file.\n\
3376 mode: mode of process creation\n\
3377 file: executable file name\n\
3378 args: tuple or list of strings");
3381 posix_spawnvp(PyObject
*self
, PyObject
*args
)
3387 Py_intptr_t spawnval
;
3388 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3390 /* spawnvp has three arguments: (mode, path, argv), where
3391 argv is a list or tuple of strings. */
3393 if (!PyArg_ParseTuple(args
, "ietO:spawnvp", &mode
,
3394 Py_FileSystemDefaultEncoding
,
3397 if (PyList_Check(argv
)) {
3398 argc
= PyList_Size(argv
);
3399 getitem
= PyList_GetItem
;
3401 else if (PyTuple_Check(argv
)) {
3402 argc
= PyTuple_Size(argv
);
3403 getitem
= PyTuple_GetItem
;
3406 PyErr_SetString(PyExc_TypeError
,
3407 "spawnvp() arg 2 must be a tuple or list");
3412 argvlist
= PyMem_NEW(char *, argc
+1);
3413 if (argvlist
== NULL
) {
3415 return PyErr_NoMemory();
3417 for (i
= 0; i
< argc
; i
++) {
3418 if (!PyArg_Parse((*getitem
)(argv
, i
), "et",
3419 Py_FileSystemDefaultEncoding
,
3421 free_string_array(argvlist
, i
);
3424 "spawnvp() arg 2 must contain only strings");
3429 argvlist
[argc
] = NULL
;
3431 Py_BEGIN_ALLOW_THREADS
3432 #if defined(PYCC_GCC)
3433 spawnval
= spawnvp(mode
, path
, argvlist
);
3435 spawnval
= _spawnvp(mode
, path
, argvlist
);
3437 Py_END_ALLOW_THREADS
3439 free_string_array(argvlist
, argc
);
3443 return posix_error();
3445 return Py_BuildValue("l", (long) spawnval
);
3449 PyDoc_STRVAR(posix_spawnvpe__doc__
,
3450 "spawnvpe(mode, file, args, env)\n\n\
3451 Execute the program 'file' in a new process, using the environment\n\
3452 search path to find the file.\n\
3454 mode: mode of process creation\n\
3455 file: executable file name\n\
3456 args: tuple or list of arguments\n\
3457 env: dictionary of strings mapping to strings");
3460 posix_spawnvpe(PyObject
*self
, PyObject
*args
)
3463 PyObject
*argv
, *env
;
3466 PyObject
*key
, *val
, *keys
=NULL
, *vals
=NULL
, *res
=NULL
;
3467 int mode
, i
, pos
, argc
, envc
;
3468 Py_intptr_t spawnval
;
3469 PyObject
*(*getitem
)(PyObject
*, Py_ssize_t
);
3472 /* spawnvpe has four arguments: (mode, path, argv, env), where
3473 argv is a list or tuple of strings and env is a dictionary
3474 like posix.environ. */
3476 if (!PyArg_ParseTuple(args
, "ietOO:spawnvpe", &mode
,
3477 Py_FileSystemDefaultEncoding
,
3478 &path
, &argv
, &env
))
3480 if (PyList_Check(argv
)) {
3481 argc
= PyList_Size(argv
);
3482 getitem
= PyList_GetItem
;
3484 else if (PyTuple_Check(argv
)) {
3485 argc
= PyTuple_Size(argv
);
3486 getitem
= PyTuple_GetItem
;
3489 PyErr_SetString(PyExc_TypeError
,
3490 "spawnvpe() arg 2 must be a tuple or list");
3493 if (!PyMapping_Check(env
)) {
3494 PyErr_SetString(PyExc_TypeError
,
3495 "spawnvpe() arg 3 must be a mapping object");
3499 argvlist
= PyMem_NEW(char *, argc
+1);
3500 if (argvlist
== NULL
) {
3504 for (i
= 0; i
< argc
; i
++) {
3505 if (!PyArg_Parse((*getitem
)(argv
, i
),
3506 "et;spawnvpe() arg 2 must contain only strings",
3507 Py_FileSystemDefaultEncoding
,
3515 argvlist
[argc
] = NULL
;
3517 i
= PyMapping_Size(env
);
3520 envlist
= PyMem_NEW(char *, i
+ 1);
3521 if (envlist
== NULL
) {
3526 keys
= PyMapping_Keys(env
);
3527 vals
= PyMapping_Values(env
);
3530 if (!PyList_Check(keys
) || !PyList_Check(vals
)) {
3531 PyErr_SetString(PyExc_TypeError
,
3532 "spawnvpe(): env.keys() or env.values() is not a list");
3536 for (pos
= 0; pos
< i
; pos
++) {
3540 key
= PyList_GetItem(keys
, pos
);
3541 val
= PyList_GetItem(vals
, pos
);
3547 "s;spawnvpe() arg 3 contains a non-string key",
3551 "s;spawnvpe() arg 3 contains a non-string value",
3556 len
= PyString_Size(key
) + PyString_Size(val
) + 2;
3557 p
= PyMem_NEW(char, len
);
3562 PyOS_snprintf(p
, len
, "%s=%s", k
, v
);
3563 envlist
[envc
++] = p
;
3567 Py_BEGIN_ALLOW_THREADS
3568 #if defined(PYCC_GCC)
3569 spawnval
= spawnvpe(mode
, path
, argvlist
, envlist
);
3571 spawnval
= _spawnvpe(mode
, path
, argvlist
, envlist
);
3573 Py_END_ALLOW_THREADS
3576 (void) posix_error();
3578 res
= Py_BuildValue("l", (long) spawnval
);
3582 PyMem_DEL(envlist
[envc
]);
3585 free_string_array(argvlist
, lastarg
);
3592 #endif /* PYOS_OS2 */
3593 #endif /* HAVE_SPAWNV */
3597 PyDoc_STRVAR(posix_fork1__doc__
,
3598 "fork1() -> pid\n\n\
3599 Fork a child process with a single multiplexed (i.e., not bound) thread.\n\
3601 Return 0 to child process and PID of child to parent process.");
3604 posix_fork1(PyObject
*self
, PyObject
*noargs
)
3608 _PyImport_AcquireLock();
3610 result
= _PyImport_ReleaseLock();
3612 return posix_error();
3616 /* Don't clobber the OSError if the fork failed. */
3617 PyErr_SetString(PyExc_RuntimeError
,
3618 "not holding the import lock");
3621 return PyLong_FromPid(pid
);
3627 PyDoc_STRVAR(posix_fork__doc__
,
3629 Fork a child process.\n\
3630 Return 0 to child process and PID of child to parent process.");
3633 posix_fork(PyObject
*self
, PyObject
*noargs
)
3637 _PyImport_AcquireLock();
3639 result
= _PyImport_ReleaseLock();
3641 return posix_error();
3645 /* Don't clobber the OSError if the fork failed. */
3646 PyErr_SetString(PyExc_RuntimeError
,
3647 "not holding the import lock");
3650 return PyLong_FromPid(pid
);
3654 /* AIX uses /dev/ptc but is otherwise the same as /dev/ptmx */
3655 /* IRIX has both /dev/ptc and /dev/ptmx, use ptmx */
3656 #if defined(HAVE_DEV_PTC) && !defined(HAVE_DEV_PTMX)
3657 #define DEV_PTY_FILE "/dev/ptc"
3658 #define HAVE_DEV_PTMX
3660 #define DEV_PTY_FILE "/dev/ptmx"
3663 #if defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX)
3667 #ifdef HAVE_LIBUTIL_H
3668 #include <libutil.h>
3669 #endif /* HAVE_LIBUTIL_H */
3670 #endif /* HAVE_PTY_H */
3671 #ifdef HAVE_STROPTS_H
3672 #include <stropts.h>
3674 #endif /* defined(HAVE_OPENPTY) || defined(HAVE_FORKPTY) || defined(HAVE_DEV_PTMX */
3676 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
3677 PyDoc_STRVAR(posix_openpty__doc__
,
3678 "openpty() -> (master_fd, slave_fd)\n\n\
3679 Open a pseudo-terminal, returning open fd's for both master and slave end.\n");
3682 posix_openpty(PyObject
*self
, PyObject
*noargs
)
3684 int master_fd
, slave_fd
;
3685 #ifndef HAVE_OPENPTY
3688 #if defined(HAVE_DEV_PTMX) && !defined(HAVE_OPENPTY) && !defined(HAVE__GETPTY)
3689 PyOS_sighandler_t sig_saved
;
3691 extern char *ptsname(int fildes
);
3696 if (openpty(&master_fd
, &slave_fd
, NULL
, NULL
, NULL
) != 0)
3697 return posix_error();
3698 #elif defined(HAVE__GETPTY)
3699 slave_name
= _getpty(&master_fd
, O_RDWR
, 0666, 0);
3700 if (slave_name
== NULL
)
3701 return posix_error();
3703 slave_fd
= open(slave_name
, O_RDWR
);
3705 return posix_error();
3707 master_fd
= open(DEV_PTY_FILE
, O_RDWR
| O_NOCTTY
); /* open master */
3709 return posix_error();
3710 sig_saved
= PyOS_setsig(SIGCHLD
, SIG_DFL
);
3711 /* change permission of slave */
3712 if (grantpt(master_fd
) < 0) {
3713 PyOS_setsig(SIGCHLD
, sig_saved
);
3714 return posix_error();
3717 if (unlockpt(master_fd
) < 0) {
3718 PyOS_setsig(SIGCHLD
, sig_saved
);
3719 return posix_error();
3721 PyOS_setsig(SIGCHLD
, sig_saved
);
3722 slave_name
= ptsname(master_fd
); /* get name of slave */
3723 if (slave_name
== NULL
)
3724 return posix_error();
3725 slave_fd
= open(slave_name
, O_RDWR
| O_NOCTTY
); /* open slave */
3727 return posix_error();
3728 #if !defined(__CYGWIN__) && !defined(HAVE_DEV_PTC)
3729 ioctl(slave_fd
, I_PUSH
, "ptem"); /* push ptem */
3730 ioctl(slave_fd
, I_PUSH
, "ldterm"); /* push ldterm */
3732 ioctl(slave_fd
, I_PUSH
, "ttcompat"); /* push ttcompat */
3734 #endif /* HAVE_CYGWIN */
3735 #endif /* HAVE_OPENPTY */
3737 return Py_BuildValue("(ii)", master_fd
, slave_fd
);
3740 #endif /* defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX) */
3743 PyDoc_STRVAR(posix_forkpty__doc__
,
3744 "forkpty() -> (pid, master_fd)\n\n\
3745 Fork a new process with a new pseudo-terminal as controlling tty.\n\n\
3746 Like fork(), return 0 as pid to child process, and PID of child to parent.\n\
3747 To both, return fd of newly opened pseudo-terminal.\n");
3750 posix_forkpty(PyObject
*self
, PyObject
*noargs
)
3752 int master_fd
= -1, result
;
3755 _PyImport_AcquireLock();
3756 pid
= forkpty(&master_fd
, NULL
, NULL
, NULL
);
3757 result
= _PyImport_ReleaseLock();
3759 return posix_error();
3763 /* Don't clobber the OSError if the fork failed. */
3764 PyErr_SetString(PyExc_RuntimeError
,
3765 "not holding the import lock");
3768 return Py_BuildValue("(Ni)", PyLong_FromPid(pid
), master_fd
);
3773 PyDoc_STRVAR(posix_getegid__doc__
,
3774 "getegid() -> egid\n\n\
3775 Return the current process's effective group id.");
3778 posix_getegid(PyObject
*self
, PyObject
*noargs
)
3780 return PyInt_FromLong((long)getegid());
3786 PyDoc_STRVAR(posix_geteuid__doc__
,
3787 "geteuid() -> euid\n\n\
3788 Return the current process's effective user id.");
3791 posix_geteuid(PyObject
*self
, PyObject
*noargs
)
3793 return PyInt_FromLong((long)geteuid());
3799 PyDoc_STRVAR(posix_getgid__doc__
,
3800 "getgid() -> gid\n\n\
3801 Return the current process's group id.");
3804 posix_getgid(PyObject
*self
, PyObject
*noargs
)
3806 return PyInt_FromLong((long)getgid());
3811 PyDoc_STRVAR(posix_getpid__doc__
,
3812 "getpid() -> pid\n\n\
3813 Return the current process id");
3816 posix_getpid(PyObject
*self
, PyObject
*noargs
)
3818 return PyLong_FromPid(getpid());
3822 #ifdef HAVE_GETGROUPS
3823 PyDoc_STRVAR(posix_getgroups__doc__
,
3824 "getgroups() -> list of group IDs\n\n\
3825 Return list of supplemental group IDs for the process.");
3828 posix_getgroups(PyObject
*self
, PyObject
*noargs
)
3830 PyObject
*result
= NULL
;
3833 #define MAX_GROUPS NGROUPS_MAX
3835 /* defined to be 16 on Solaris7, so this should be a small number */
3836 #define MAX_GROUPS 64
3838 gid_t grouplist
[MAX_GROUPS
];
3841 n
= getgroups(MAX_GROUPS
, grouplist
);
3845 result
= PyList_New(n
);
3846 if (result
!= NULL
) {
3848 for (i
= 0; i
< n
; ++i
) {
3849 PyObject
*o
= PyInt_FromLong((long)grouplist
[i
]);
3855 PyList_SET_ITEM(result
, i
, o
);
3865 PyDoc_STRVAR(posix_getpgid__doc__
,
3866 "getpgid(pid) -> pgid\n\n\
3867 Call the system call getpgid().");
3870 posix_getpgid(PyObject
*self
, PyObject
*args
)
3873 if (!PyArg_ParseTuple(args
, PARSE_PID
":getpgid", &pid
))
3875 pgid
= getpgid(pid
);
3877 return posix_error();
3878 return PyLong_FromPid(pgid
);
3880 #endif /* HAVE_GETPGID */
3884 PyDoc_STRVAR(posix_getpgrp__doc__
,
3885 "getpgrp() -> pgrp\n\n\
3886 Return the current process group id.");
3889 posix_getpgrp(PyObject
*self
, PyObject
*noargs
)
3891 #ifdef GETPGRP_HAVE_ARG
3892 return PyLong_FromPid(getpgrp(0));
3893 #else /* GETPGRP_HAVE_ARG */
3894 return PyLong_FromPid(getpgrp());
3895 #endif /* GETPGRP_HAVE_ARG */
3897 #endif /* HAVE_GETPGRP */
3901 PyDoc_STRVAR(posix_setpgrp__doc__
,
3903 Make this process a session leader.");
3906 posix_setpgrp(PyObject
*self
, PyObject
*noargs
)
3908 #ifdef SETPGRP_HAVE_ARG
3909 if (setpgrp(0, 0) < 0)
3910 #else /* SETPGRP_HAVE_ARG */
3912 #endif /* SETPGRP_HAVE_ARG */
3913 return posix_error();
3918 #endif /* HAVE_SETPGRP */
3921 PyDoc_STRVAR(posix_getppid__doc__
,
3922 "getppid() -> ppid\n\n\
3923 Return the parent's process id.");
3926 posix_getppid(PyObject
*self
, PyObject
*noargs
)
3928 return PyLong_FromPid(getppid());
3933 #ifdef HAVE_GETLOGIN
3934 PyDoc_STRVAR(posix_getlogin__doc__
,
3935 "getlogin() -> string\n\n\
3936 Return the actual login name.");
3939 posix_getlogin(PyObject
*self
, PyObject
*noargs
)
3941 PyObject
*result
= NULL
;
3943 int old_errno
= errno
;
3951 PyErr_SetString(PyExc_OSError
,
3952 "unable to determine login name");
3955 result
= PyString_FromString(name
);
3963 PyDoc_STRVAR(posix_getuid__doc__
,
3964 "getuid() -> uid\n\n\
3965 Return the current process's user id.");
3968 posix_getuid(PyObject
*self
, PyObject
*noargs
)
3970 return PyInt_FromLong((long)getuid());
3976 PyDoc_STRVAR(posix_kill__doc__
,
3977 "kill(pid, sig)\n\n\
3978 Kill a process with a signal.");
3981 posix_kill(PyObject
*self
, PyObject
*args
)
3985 if (!PyArg_ParseTuple(args
, PARSE_PID
"i:kill", &pid
, &sig
))
3987 #if defined(PYOS_OS2) && !defined(PYCC_GCC)
3988 if (sig
== XCPT_SIGNAL_INTR
|| sig
== XCPT_SIGNAL_BREAK
) {
3990 if ((rc
= DosSendSignalException(pid
, sig
)) != NO_ERROR
)
3991 return os2_error(rc
);
3993 } else if (sig
== XCPT_SIGNAL_KILLPROC
) {
3995 if ((rc
= DosKillProcess(DKP_PROCESS
, pid
)) != NO_ERROR
)
3996 return os2_error(rc
);
3999 return NULL
; /* Unrecognized Signal Requested */
4001 if (kill(pid
, sig
) == -1)
4002 return posix_error();
4010 PyDoc_STRVAR(posix_killpg__doc__
,
4011 "killpg(pgid, sig)\n\n\
4012 Kill a process group with a signal.");
4015 posix_killpg(PyObject
*self
, PyObject
*args
)
4019 /* XXX some man pages make the `pgid` parameter an int, others
4020 a pid_t. Since getpgrp() returns a pid_t, we assume killpg should
4021 take the same type. Moreover, pid_t is always at least as wide as
4022 int (else compilation of this module fails), which is safe. */
4023 if (!PyArg_ParseTuple(args
, PARSE_PID
"i:killpg", &pgid
, &sig
))
4025 if (killpg(pgid
, sig
) == -1)
4026 return posix_error();
4034 #ifdef HAVE_SYS_LOCK_H
4035 #include <sys/lock.h>
4038 PyDoc_STRVAR(posix_plock__doc__
,
4040 Lock program segments into memory.");
4043 posix_plock(PyObject
*self
, PyObject
*args
)
4046 if (!PyArg_ParseTuple(args
, "i:plock", &op
))
4048 if (plock(op
) == -1)
4049 return posix_error();
4057 PyDoc_STRVAR(posix_popen__doc__
,
4058 "popen(command [, mode='r' [, bufsize]]) -> pipe\n\n\
4059 Open a pipe to/from a command returning a file object.");
4061 #if defined(PYOS_OS2)
4062 #if defined(PYCC_VACPP)
4064 async_system(const char *command
)
4066 char errormsg
[256], args
[1024];
4070 char *shell
= getenv("COMSPEC");
4074 /* avoid overflowing the argument buffer */
4075 if (strlen(shell
) + 3 + strlen(command
) >= 1024)
4076 return ERROR_NOT_ENOUGH_MEMORY
4079 strcat(args
, shell
);
4080 strcat(args
, "/c ");
4081 strcat(args
, command
);
4083 /* execute asynchronously, inheriting the environment */
4084 rc
= DosExecPgm(errormsg
,
4095 popen(const char *command
, const char *mode
, int pipesize
, int *err
)
4101 /* mode determines which of stdin or stdout is reconnected to
4102 * the pipe to the child
4104 if (strchr(mode
, 'r') != NULL
) {
4105 tgt_fd
= 1; /* stdout */
4106 } else if (strchr(mode
, 'w')) {
4107 tgt_fd
= 0; /* stdin */
4109 *err
= ERROR_INVALID_ACCESS
;
4113 /* setup the pipe */
4114 if ((rc
= DosCreatePipe(&pipeh
[0], &pipeh
[1], pipesize
)) != NO_ERROR
) {
4119 /* prevent other threads accessing stdio */
4122 /* reconnect stdio and execute child */
4125 if (dup2(pipeh
[tgtfd
], tgtfd
) == 0) {
4126 DosClose(pipeh
[tgtfd
]);
4127 rc
= async_system(command
);
4134 /* allow other threads access to stdio */
4137 /* if execution of child was successful return file stream */
4139 return fdopen(pipeh
[1 - tgtfd
], mode
);
4141 DosClose(pipeh
[1 - tgtfd
]);
4148 posix_popen(PyObject
*self
, PyObject
*args
)
4152 int err
, bufsize
= -1;
4155 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4157 Py_BEGIN_ALLOW_THREADS
4158 fp
= popen(name
, mode
, (bufsize
> 0) ? bufsize
: 4096, &err
);
4159 Py_END_ALLOW_THREADS
4161 return os2_error(err
);
4163 f
= PyFile_FromFile(fp
, name
, mode
, fclose
);
4165 PyFile_SetBufSize(f
, bufsize
);
4169 #elif defined(PYCC_GCC)
4171 /* standard posix version of popen() support */
4173 posix_popen(PyObject
*self
, PyObject
*args
)
4180 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
4182 Py_BEGIN_ALLOW_THREADS
4183 fp
= popen(name
, mode
);
4184 Py_END_ALLOW_THREADS
4186 return posix_error();
4187 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
4189 PyFile_SetBufSize(f
, bufsize
);
4193 /* fork() under OS/2 has lots'o'warts
4194 * EMX supports pipe() and spawn*() so we can synthesize popen[234]()
4195 * most of this code is a ripoff of the win32 code, but using the
4196 * capabilities of EMX's C library routines
4199 /* These tell _PyPopen() whether to return 1, 2, or 3 file objects. */
4205 static PyObject
*_PyPopen(char *, int, int, int);
4206 static int _PyPclose(FILE *file
);
4209 * Internal dictionary mapping popen* file pointers to process handles,
4210 * for use when retrieving the process exit code. See _PyPclose() below
4211 * for more information on this dictionary's use.
4213 static PyObject
*_PyPopenProcs
= NULL
;
4215 /* os2emx version of popen2()
4217 * The result of this function is a pipe (file) connected to the
4218 * process's stdin, and a pipe connected to the process's stdout.
4222 os2emx_popen2(PyObject
*self
, PyObject
*args
)
4230 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4235 else if (*mode
!= 'b') {
4236 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4241 f
= _PyPopen(cmdstring
, tm
, POPEN_2
, bufsize
);
4247 * Variation on os2emx.popen2
4249 * The result of this function is 3 pipes - the process's stdin,
4254 os2emx_popen3(PyObject
*self
, PyObject
*args
)
4262 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4267 else if (*mode
!= 'b') {
4268 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4273 f
= _PyPopen(cmdstring
, tm
, POPEN_3
, bufsize
);
4279 * Variation on os2emx.popen2
4281 * The result of this function is 2 pipes - the processes stdin,
4282 * and stdout+stderr combined as a single pipe.
4286 os2emx_popen4(PyObject
*self
, PyObject
*args
)
4294 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4299 else if (*mode
!= 'b') {
4300 PyErr_SetString(PyExc_ValueError
, "mode must be 't' or 'b'");
4305 f
= _PyPopen(cmdstring
, tm
, POPEN_4
, bufsize
);
4310 /* a couple of structures for convenient handling of multiple
4311 * file handles and pipes
4325 /* The following code is derived from the win32 code */
4328 _PyPopen(char *cmdstring
, int mode
, int n
, int bufsize
)
4330 struct file_ref stdio
[3];
4331 struct pipe_ref p_fd
[3];
4333 int file_count
, i
, pipe_err
;
4335 char *shell
, *sh_name
, *opt
, *rd_mode
, *wr_mode
;
4336 PyObject
*f
, *p_f
[3];
4338 /* file modes for subsequent fdopen's on pipe handles */
4350 /* prepare shell references */
4351 if ((shell
= getenv("EMXSHELL")) == NULL
)
4352 if ((shell
= getenv("COMSPEC")) == NULL
)
4355 return posix_error();
4358 sh_name
= _getname(shell
);
4359 if (stricmp(sh_name
, "cmd.exe") == 0 || stricmp(sh_name
, "4os2.exe") == 0)
4364 /* save current stdio fds + their flags, and set not inheritable */
4366 while (pipe_err
>= 0 && i
< 3)
4368 pipe_err
= stdio
[i
].handle
= dup(i
);
4369 stdio
[i
].flags
= fcntl(i
, F_GETFD
, 0);
4370 fcntl(stdio
[i
].handle
, F_SETFD
, stdio
[i
].flags
| FD_CLOEXEC
);
4375 /* didn't get them all saved - clean up and bail out */
4376 int saved_err
= errno
;
4379 close(stdio
[i
].handle
);
4382 return posix_error();
4385 /* create pipe ends */
4390 while ((pipe_err
== 0) && (i
< file_count
))
4391 pipe_err
= pipe((int *)&p_fd
[i
++]);
4394 /* didn't get them all made - clean up and bail out */
4401 return posix_error();
4404 /* change the actual standard IO streams over temporarily,
4405 * making the retained pipe ends non-inheritable
4410 if (dup2(p_fd
[0].rd
, 0) == 0)
4413 i
= fcntl(p_fd
[0].wr
, F_GETFD
, 0);
4414 fcntl(p_fd
[0].wr
, F_SETFD
, i
| FD_CLOEXEC
);
4415 if ((p_s
[0] = fdopen(p_fd
[0].wr
, wr_mode
)) == NULL
)
4429 if (dup2(p_fd
[1].wr
, 1) == 1)
4432 i
= fcntl(p_fd
[1].rd
, F_GETFD
, 0);
4433 fcntl(p_fd
[1].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4434 if ((p_s
[1] = fdopen(p_fd
[1].rd
, rd_mode
)) == NULL
)
4446 /* - stderr, as required */
4452 if (dup2(p_fd
[2].wr
, 2) == 2)
4455 i
= fcntl(p_fd
[2].rd
, F_GETFD
, 0);
4456 fcntl(p_fd
[2].rd
, F_SETFD
, i
| FD_CLOEXEC
);
4457 if ((p_s
[2] = fdopen(p_fd
[2].rd
, rd_mode
)) == NULL
)
4472 if (dup2(1, 2) != 2)
4480 /* spawn the child process */
4483 pipe_pid
= spawnlp(P_NOWAIT
, shell
, shell
, opt
, cmdstring
, (char *)0);
4490 /* save the PID into the FILE structure
4491 * NOTE: this implementation doesn't actually
4492 * take advantage of this, but do it for
4493 * completeness - AIM Apr01
4495 for (i
= 0; i
< file_count
; i
++)
4496 p_s
[i
]->_pid
= pipe_pid
;
4500 /* reset standard IO to normal */
4501 for (i
= 0; i
< 3; i
++)
4503 dup2(stdio
[i
].handle
, i
);
4504 fcntl(i
, F_SETFD
, stdio
[i
].flags
);
4505 close(stdio
[i
].handle
);
4508 /* if any remnant problems, clean up and bail out */
4511 for (i
= 0; i
< 3; i
++)
4517 return posix_error_with_filename(cmdstring
);
4520 /* build tuple of file objects to return */
4521 if ((p_f
[0] = PyFile_FromFile(p_s
[0], cmdstring
, wr_mode
, _PyPclose
)) != NULL
)
4522 PyFile_SetBufSize(p_f
[0], bufsize
);
4523 if ((p_f
[1] = PyFile_FromFile(p_s
[1], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4524 PyFile_SetBufSize(p_f
[1], bufsize
);
4527 if ((p_f
[2] = PyFile_FromFile(p_s
[2], cmdstring
, rd_mode
, _PyPclose
)) != NULL
)
4528 PyFile_SetBufSize(p_f
[0], bufsize
);
4529 f
= PyTuple_Pack(3, p_f
[0], p_f
[1], p_f
[2]);
4532 f
= PyTuple_Pack(2, p_f
[0], p_f
[1]);
4535 * Insert the files we've created into the process dictionary
4536 * all referencing the list with the process handle and the
4537 * initial number of files (see description below in _PyPclose).
4538 * Since if _PyPclose later tried to wait on a process when all
4539 * handles weren't closed, it could create a deadlock with the
4540 * child, we spend some energy here to try to ensure that we
4541 * either insert all file handles into the dictionary or none
4542 * at all. It's a little clumsy with the various popen modes
4543 * and variable number of files involved.
4547 _PyPopenProcs
= PyDict_New();
4552 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
[3];
4555 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
4556 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
4558 procObj
= PyList_New(2);
4559 pidObj
= PyLong_FromPid(pipe_pid
);
4560 intObj
= PyInt_FromLong((long) file_count
);
4562 if (procObj
&& pidObj
&& intObj
)
4564 PyList_SetItem(procObj
, 0, pidObj
);
4565 PyList_SetItem(procObj
, 1, intObj
);
4567 fileObj
[0] = PyLong_FromVoidPtr(p_s
[0]);
4570 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
4574 fileObj
[1] = PyLong_FromVoidPtr(p_s
[1]);
4577 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
4581 if (file_count
>= 3)
4583 fileObj
[2] = PyLong_FromVoidPtr(p_s
[2]);
4586 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
4592 if (ins_rc
[0] < 0 || !fileObj
[0] ||
4593 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
4594 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2]))
4596 /* Something failed - remove any dictionary
4597 * entries that did make it.
4599 if (!ins_rc
[0] && fileObj
[0])
4601 PyDict_DelItem(_PyPopenProcs
,
4604 if (!ins_rc
[1] && fileObj
[1])
4606 PyDict_DelItem(_PyPopenProcs
,
4609 if (!ins_rc
[2] && fileObj
[2])
4611 PyDict_DelItem(_PyPopenProcs
,
4618 * Clean up our localized references for the dictionary keys
4619 * and value since PyDict_SetItem will Py_INCREF any copies
4620 * that got placed in the dictionary.
4622 Py_XDECREF(procObj
);
4623 Py_XDECREF(fileObj
[0]);
4624 Py_XDECREF(fileObj
[1]);
4625 Py_XDECREF(fileObj
[2]);
4628 /* Child is launched. */
4633 * Wrapper for fclose() to use for popen* files, so we can retrieve the
4634 * exit code for the child process and return as a result of the close.
4636 * This function uses the _PyPopenProcs dictionary in order to map the
4637 * input file pointer to information about the process that was
4638 * originally created by the popen* call that created the file pointer.
4639 * The dictionary uses the file pointer as a key (with one entry
4640 * inserted for each file returned by the original popen* call) and a
4641 * single list object as the value for all files from a single call.
4642 * The list object contains the Win32 process handle at [0], and a file
4643 * count at [1], which is initialized to the total number of file
4644 * handles using that list.
4646 * This function closes whichever handle it is passed, and decrements
4647 * the file count in the dictionary for the process handle pointed to
4648 * by this file. On the last close (when the file count reaches zero),
4649 * this function will wait for the child process and then return its
4650 * exit code as the result of the close() operation. This permits the
4651 * files to be closed in any order - it is always the close() of the
4652 * final handle that will return the exit code.
4654 * NOTE: This function is currently called with the GIL released.
4655 * hence we use the GILState API to manage our state.
4658 static int _PyPclose(FILE *file
)
4663 PyObject
*procObj
, *pidObj
, *intObj
, *fileObj
;
4666 PyGILState_STATE state
;
4669 /* Close the file handle first, to ensure it can't block the
4670 * child from exiting if it's the last handle.
4672 result
= fclose(file
);
4675 state
= PyGILState_Ensure();
4679 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
4680 (procObj
= PyDict_GetItem(_PyPopenProcs
,
4681 fileObj
)) != NULL
&&
4682 (pidObj
= PyList_GetItem(procObj
,0)) != NULL
&&
4683 (intObj
= PyList_GetItem(procObj
,1)) != NULL
)
4685 pipe_pid
= (pid_t
) PyLong_AsPid(pidObj
);
4686 file_count
= (int) PyInt_AsLong(intObj
);
4690 /* Still other files referencing process */
4692 PyList_SetItem(procObj
,1,
4693 PyInt_FromLong((long) file_count
));
4697 /* Last file for this process */
4698 if (result
!= EOF
&&
4699 waitpid(pipe_pid
, &exit_code
, 0) == pipe_pid
)
4701 /* extract exit status */
4702 if (WIFEXITED(exit_code
))
4704 result
= WEXITSTATUS(exit_code
);
4714 /* Indicate failure - this will cause the file object
4715 * to raise an I/O error and translate the last
4716 * error code from errno. We do have a problem with
4717 * last errors that overlap the normal errno table,
4718 * but that's a consistent problem with the file object.
4724 /* Remove this file pointer from dictionary */
4725 PyDict_DelItem(_PyPopenProcs
, fileObj
);
4727 if (PyDict_Size(_PyPopenProcs
) == 0)
4729 Py_DECREF(_PyPopenProcs
);
4730 _PyPopenProcs
= NULL
;
4733 } /* if object retrieval ok */
4735 Py_XDECREF(fileObj
);
4736 } /* if _PyPopenProcs */
4739 PyGILState_Release(state
);
4744 #endif /* PYCC_??? */
4746 #elif defined(MS_WINDOWS)
4749 * Portable 'popen' replacement for Win32.
4751 * Written by Bill Tutt <billtut@microsoft.com>. Minor tweaks
4752 * and 2.0 integration by Fredrik Lundh <fredrik@pythonware.com>
4753 * Return code handling by David Bolen <db3l@fitlinxx.com>.
4760 /* These tell _PyPopen() wether to return 1, 2, or 3 file objects. */
4766 static PyObject
*_PyPopen(char *, int, int);
4767 static int _PyPclose(FILE *file
);
4770 * Internal dictionary mapping popen* file pointers to process handles,
4771 * for use when retrieving the process exit code. See _PyPclose() below
4772 * for more information on this dictionary's use.
4774 static PyObject
*_PyPopenProcs
= NULL
;
4777 /* popen that works from a GUI.
4779 * The result of this function is a pipe (file) connected to the
4780 * processes stdin or stdout, depending on the requested mode.
4784 posix_popen(PyObject
*self
, PyObject
*args
)
4792 if (!PyArg_ParseTuple(args
, "s|si:popen", &cmdstring
, &mode
, &bufsize
))
4797 else if (*mode
!= 'w') {
4798 PyErr_SetString(PyExc_ValueError
, "popen() arg 2 must be 'r' or 'w'");
4803 if (bufsize
!= -1) {
4804 PyErr_SetString(PyExc_ValueError
, "popen() arg 3 must be -1");
4808 if (*(mode
+1) == 't')
4809 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4810 else if (*(mode
+1) == 'b')
4811 f
= _PyPopen(cmdstring
, tm
| _O_BINARY
, POPEN_1
);
4813 f
= _PyPopen(cmdstring
, tm
| _O_TEXT
, POPEN_1
);
4818 /* Variation on win32pipe.popen
4820 * The result of this function is a pipe (file) connected to the
4821 * process's stdin, and a pipe connected to the process's stdout.
4825 win32_popen2(PyObject
*self
, PyObject
*args
)
4833 if (!PyArg_ParseTuple(args
, "s|si:popen2", &cmdstring
, &mode
, &bufsize
))
4838 else if (*mode
!= 'b') {
4839 PyErr_SetString(PyExc_ValueError
, "popen2() arg 2 must be 't' or 'b'");
4844 if (bufsize
!= -1) {
4845 PyErr_SetString(PyExc_ValueError
, "popen2() arg 3 must be -1");
4849 f
= _PyPopen(cmdstring
, tm
, POPEN_2
);
4855 * Variation on <om win32pipe.popen>
4857 * The result of this function is 3 pipes - the process's stdin,
4862 win32_popen3(PyObject
*self
, PyObject
*args
)
4870 if (!PyArg_ParseTuple(args
, "s|si:popen3", &cmdstring
, &mode
, &bufsize
))
4875 else if (*mode
!= 'b') {
4876 PyErr_SetString(PyExc_ValueError
, "popen3() arg 2 must be 't' or 'b'");
4881 if (bufsize
!= -1) {
4882 PyErr_SetString(PyExc_ValueError
, "popen3() arg 3 must be -1");
4886 f
= _PyPopen(cmdstring
, tm
, POPEN_3
);
4892 * Variation on win32pipe.popen
4894 * The result of this function is 2 pipes - the processes stdin,
4895 * and stdout+stderr combined as a single pipe.
4899 win32_popen4(PyObject
*self
, PyObject
*args
)
4907 if (!PyArg_ParseTuple(args
, "s|si:popen4", &cmdstring
, &mode
, &bufsize
))
4912 else if (*mode
!= 'b') {
4913 PyErr_SetString(PyExc_ValueError
, "popen4() arg 2 must be 't' or 'b'");
4918 if (bufsize
!= -1) {
4919 PyErr_SetString(PyExc_ValueError
, "popen4() arg 3 must be -1");
4923 f
= _PyPopen(cmdstring
, tm
, POPEN_4
);
4929 _PyPopenCreateProcess(char *cmdstring
,
4935 PROCESS_INFORMATION piProcInfo
;
4936 STARTUPINFO siStartInfo
;
4937 DWORD dwProcessFlags
= 0; /* no NEW_CONSOLE by default for Ctrl+C handling */
4938 char *s1
,*s2
, *s3
= " /c ";
4939 const char *szConsoleSpawn
= "w9xpopen.exe";
4943 if (i
= GetEnvironmentVariable("COMSPEC",NULL
,0)) {
4946 s1
= (char *)alloca(i
);
4947 if (!(x
= GetEnvironmentVariable("COMSPEC", s1
, i
)))
4948 /* x < i, so x fits into an integer */
4951 /* Explicitly check if we are using COMMAND.COM. If we are
4952 * then use the w9xpopen hack.
4955 while (comshell
>= s1
&& *comshell
!= '\\')
4959 if (GetVersion() < 0x80000000 &&
4960 _stricmp(comshell
, "command.com") != 0) {
4961 /* NT/2000 and not using command.com. */
4962 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1;
4963 s2
= (char *)alloca(x
);
4965 PyOS_snprintf(s2
, x
, "%s%s%s", s1
, s3
, cmdstring
);
4969 * Oh gag, we're on Win9x or using COMMAND.COM. Use
4970 * the workaround listed in KB: Q150956
4972 char modulepath
[_MAX_PATH
];
4973 struct stat statinfo
;
4974 GetModuleFileName(NULL
, modulepath
, sizeof(modulepath
));
4975 for (x
= i
= 0; modulepath
[i
]; i
++)
4976 if (modulepath
[i
] == SEP
)
4978 modulepath
[x
] = '\0';
4979 /* Create the full-name to w9xpopen, so we can test it exists */
4982 (sizeof(modulepath
)/sizeof(modulepath
[0]))
4983 -strlen(modulepath
));
4984 if (stat(modulepath
, &statinfo
) != 0) {
4985 size_t mplen
= sizeof(modulepath
)/sizeof(modulepath
[0]);
4986 /* Eeek - file-not-found - possibly an embedding
4987 situation - see if we can locate it in sys.prefix
4992 modulepath
[mplen
-1] = '\0';
4993 if (modulepath
[strlen(modulepath
)-1] != '\\')
4994 strcat(modulepath
, "\\");
4997 mplen
-strlen(modulepath
));
4998 /* No where else to look - raise an easily identifiable
4999 error, rather than leaving Windows to report
5000 "file not found" - as the user is probably blissfully
5001 unaware this shim EXE is used, and it will confuse them.
5002 (well, it confused me for a while ;-)
5004 if (stat(modulepath
, &statinfo
) != 0) {
5005 PyErr_Format(PyExc_RuntimeError
,
5006 "Can not locate '%s' which is needed "
5007 "for popen to work with your shell "
5013 x
= i
+ strlen(s3
) + strlen(cmdstring
) + 1 +
5014 strlen(modulepath
) +
5015 strlen(szConsoleSpawn
) + 1;
5017 s2
= (char *)alloca(x
);
5019 /* To maintain correct argument passing semantics,
5020 we pass the command-line as it stands, and allow
5021 quoting to be applied. w9xpopen.exe will then
5022 use its argv vector, and re-quote the necessary
5023 args for the ultimate child process.
5032 /* Not passing CREATE_NEW_CONSOLE has been known to
5033 cause random failures on win9x. Specifically a
5035 "Your program accessed mem currently in use at xxx"
5036 and a hopeful warning about the stability of your
5038 Cost is Ctrl+C won't kill children, but anyone
5039 who cares can have a go!
5041 dwProcessFlags
|= CREATE_NEW_CONSOLE
;
5045 /* Could be an else here to try cmd.exe / command.com in the path
5046 Now we'll just error out.. */
5048 PyErr_SetString(PyExc_RuntimeError
,
5049 "Cannot locate a COMSPEC environment variable to "
5050 "use as the shell");
5054 ZeroMemory(&siStartInfo
, sizeof(STARTUPINFO
));
5055 siStartInfo
.cb
= sizeof(STARTUPINFO
);
5056 siStartInfo
.dwFlags
= STARTF_USESTDHANDLES
| STARTF_USESHOWWINDOW
;
5057 siStartInfo
.hStdInput
= hStdin
;
5058 siStartInfo
.hStdOutput
= hStdout
;
5059 siStartInfo
.hStdError
= hStderr
;
5060 siStartInfo
.wShowWindow
= SW_HIDE
;
5062 if (CreateProcess(NULL
,
5072 /* Close the handles now so anyone waiting is woken. */
5073 CloseHandle(piProcInfo
.hThread
);
5075 /* Return process handle */
5076 *hProcess
= piProcInfo
.hProcess
;
5079 win32_error("CreateProcess", s2
);
5083 /* The following code is based off of KB: Q190351 */
5086 _PyPopen(char *cmdstring
, int mode
, int n
)
5088 HANDLE hChildStdinRd
, hChildStdinWr
, hChildStdoutRd
, hChildStdoutWr
,
5089 hChildStderrRd
, hChildStderrWr
, hChildStdinWrDup
, hChildStdoutRdDup
,
5090 hChildStderrRdDup
, hProcess
; /* hChildStdoutWrDup; */
5092 SECURITY_ATTRIBUTES saAttr
;
5099 saAttr
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
5100 saAttr
.bInheritHandle
= TRUE
;
5101 saAttr
.lpSecurityDescriptor
= NULL
;
5103 if (!CreatePipe(&hChildStdinRd
, &hChildStdinWr
, &saAttr
, 0))
5104 return win32_error("CreatePipe", NULL
);
5106 /* Create new output read handle and the input write handle. Set
5107 * the inheritance properties to FALSE. Otherwise, the child inherits
5108 * these handles; resulting in non-closeable handles to the pipes
5110 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdinWr
,
5111 GetCurrentProcess(), &hChildStdinWrDup
, 0,
5113 DUPLICATE_SAME_ACCESS
);
5115 return win32_error("DuplicateHandle", NULL
);
5117 /* Close the inheritable version of ChildStdin
5118 that we're using. */
5119 CloseHandle(hChildStdinWr
);
5121 if (!CreatePipe(&hChildStdoutRd
, &hChildStdoutWr
, &saAttr
, 0))
5122 return win32_error("CreatePipe", NULL
);
5124 fSuccess
= DuplicateHandle(GetCurrentProcess(), hChildStdoutRd
,
5125 GetCurrentProcess(), &hChildStdoutRdDup
, 0,
5126 FALSE
, DUPLICATE_SAME_ACCESS
);
5128 return win32_error("DuplicateHandle", NULL
);
5130 /* Close the inheritable version of ChildStdout
5131 that we're using. */
5132 CloseHandle(hChildStdoutRd
);
5135 if (!CreatePipe(&hChildStderrRd
, &hChildStderrWr
, &saAttr
, 0))
5136 return win32_error("CreatePipe", NULL
);
5137 fSuccess
= DuplicateHandle(GetCurrentProcess(),
5139 GetCurrentProcess(),
5140 &hChildStderrRdDup
, 0,
5141 FALSE
, DUPLICATE_SAME_ACCESS
);
5143 return win32_error("DuplicateHandle", NULL
);
5144 /* Close the inheritable version of ChildStdErr that we're using. */
5145 CloseHandle(hChildStderrRd
);
5150 switch (mode
& (_O_RDONLY
| _O_TEXT
| _O_BINARY
| _O_WRONLY
)) {
5151 case _O_WRONLY
| _O_TEXT
:
5152 /* Case for writing to child Stdin in text mode. */
5153 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5154 f1
= _fdopen(fd1
, "w");
5155 f
= PyFile_FromFile(f1
, cmdstring
, "w", _PyPclose
);
5156 PyFile_SetBufSize(f
, 0);
5157 /* We don't care about these pipes anymore, so close them. */
5158 CloseHandle(hChildStdoutRdDup
);
5159 CloseHandle(hChildStderrRdDup
);
5162 case _O_RDONLY
| _O_TEXT
:
5163 /* Case for reading from child Stdout in text mode. */
5164 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5165 f1
= _fdopen(fd1
, "r");
5166 f
= PyFile_FromFile(f1
, cmdstring
, "r", _PyPclose
);
5167 PyFile_SetBufSize(f
, 0);
5168 /* We don't care about these pipes anymore, so close them. */
5169 CloseHandle(hChildStdinWrDup
);
5170 CloseHandle(hChildStderrRdDup
);
5173 case _O_RDONLY
| _O_BINARY
:
5174 /* Case for readinig from child Stdout in binary mode. */
5175 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5176 f1
= _fdopen(fd1
, "rb");
5177 f
= PyFile_FromFile(f1
, cmdstring
, "rb", _PyPclose
);
5178 PyFile_SetBufSize(f
, 0);
5179 /* We don't care about these pipes anymore, so close them. */
5180 CloseHandle(hChildStdinWrDup
);
5181 CloseHandle(hChildStderrRdDup
);
5184 case _O_WRONLY
| _O_BINARY
:
5185 /* Case for writing to child Stdin in binary mode. */
5186 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5187 f1
= _fdopen(fd1
, "wb");
5188 f
= PyFile_FromFile(f1
, cmdstring
, "wb", _PyPclose
);
5189 PyFile_SetBufSize(f
, 0);
5190 /* We don't care about these pipes anymore, so close them. */
5191 CloseHandle(hChildStdoutRdDup
);
5192 CloseHandle(hChildStderrRdDup
);
5204 if (mode
& _O_TEXT
) {
5212 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5213 f1
= _fdopen(fd1
, m2
);
5214 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5215 f2
= _fdopen(fd2
, m1
);
5216 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5217 PyFile_SetBufSize(p1
, 0);
5218 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5219 PyFile_SetBufSize(p2
, 0);
5222 CloseHandle(hChildStderrRdDup
);
5224 f
= PyTuple_Pack(2,p1
,p2
);
5234 PyObject
*p1
, *p2
, *p3
;
5236 if (mode
& _O_TEXT
) {
5244 fd1
= _open_osfhandle((Py_intptr_t
)hChildStdinWrDup
, mode
);
5245 f1
= _fdopen(fd1
, m2
);
5246 fd2
= _open_osfhandle((Py_intptr_t
)hChildStdoutRdDup
, mode
);
5247 f2
= _fdopen(fd2
, m1
);
5248 fd3
= _open_osfhandle((Py_intptr_t
)hChildStderrRdDup
, mode
);
5249 f3
= _fdopen(fd3
, m1
);
5250 p1
= PyFile_FromFile(f1
, cmdstring
, m2
, _PyPclose
);
5251 p2
= PyFile_FromFile(f2
, cmdstring
, m1
, _PyPclose
);
5252 p3
= PyFile_FromFile(f3
, cmdstring
, m1
, _PyPclose
);
5253 PyFile_SetBufSize(p1
, 0);
5254 PyFile_SetBufSize(p2
, 0);
5255 PyFile_SetBufSize(p3
, 0);
5256 f
= PyTuple_Pack(3,p1
,p2
,p3
);
5266 if (!_PyPopenCreateProcess(cmdstring
,
5274 if (!_PyPopenCreateProcess(cmdstring
,
5283 * Insert the files we've created into the process dictionary
5284 * all referencing the list with the process handle and the
5285 * initial number of files (see description below in _PyPclose).
5286 * Since if _PyPclose later tried to wait on a process when all
5287 * handles weren't closed, it could create a deadlock with the
5288 * child, we spend some energy here to try to ensure that we
5289 * either insert all file handles into the dictionary or none
5290 * at all. It's a little clumsy with the various popen modes
5291 * and variable number of files involved.
5293 if (!_PyPopenProcs
) {
5294 _PyPopenProcs
= PyDict_New();
5297 if (_PyPopenProcs
) {
5298 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
[3];
5301 fileObj
[0] = fileObj
[1] = fileObj
[2] = NULL
;
5302 ins_rc
[0] = ins_rc
[1] = ins_rc
[2] = 0;
5304 procObj
= PyList_New(2);
5305 hProcessObj
= PyLong_FromVoidPtr(hProcess
);
5306 intObj
= PyInt_FromLong(file_count
);
5308 if (procObj
&& hProcessObj
&& intObj
) {
5309 PyList_SetItem(procObj
,0,hProcessObj
);
5310 PyList_SetItem(procObj
,1,intObj
);
5312 fileObj
[0] = PyLong_FromVoidPtr(f1
);
5314 ins_rc
[0] = PyDict_SetItem(_PyPopenProcs
,
5318 if (file_count
>= 2) {
5319 fileObj
[1] = PyLong_FromVoidPtr(f2
);
5321 ins_rc
[1] = PyDict_SetItem(_PyPopenProcs
,
5326 if (file_count
>= 3) {
5327 fileObj
[2] = PyLong_FromVoidPtr(f3
);
5329 ins_rc
[2] = PyDict_SetItem(_PyPopenProcs
,
5335 if (ins_rc
[0] < 0 || !fileObj
[0] ||
5336 ins_rc
[1] < 0 || (file_count
> 1 && !fileObj
[1]) ||
5337 ins_rc
[2] < 0 || (file_count
> 2 && !fileObj
[2])) {
5338 /* Something failed - remove any dictionary
5339 * entries that did make it.
5341 if (!ins_rc
[0] && fileObj
[0]) {
5342 PyDict_DelItem(_PyPopenProcs
,
5345 if (!ins_rc
[1] && fileObj
[1]) {
5346 PyDict_DelItem(_PyPopenProcs
,
5349 if (!ins_rc
[2] && fileObj
[2]) {
5350 PyDict_DelItem(_PyPopenProcs
,
5357 * Clean up our localized references for the dictionary keys
5358 * and value since PyDict_SetItem will Py_INCREF any copies
5359 * that got placed in the dictionary.
5361 Py_XDECREF(procObj
);
5362 Py_XDECREF(fileObj
[0]);
5363 Py_XDECREF(fileObj
[1]);
5364 Py_XDECREF(fileObj
[2]);
5367 /* Child is launched. Close the parents copy of those pipe
5368 * handles that only the child should have open. You need to
5369 * make sure that no handles to the write end of the output pipe
5370 * are maintained in this process or else the pipe will not close
5371 * when the child process exits and the ReadFile will hang. */
5373 if (!CloseHandle(hChildStdinRd
))
5374 return win32_error("CloseHandle", NULL
);
5376 if (!CloseHandle(hChildStdoutWr
))
5377 return win32_error("CloseHandle", NULL
);
5379 if ((n
!= 4) && (!CloseHandle(hChildStderrWr
)))
5380 return win32_error("CloseHandle", NULL
);
5386 * Wrapper for fclose() to use for popen* files, so we can retrieve the
5387 * exit code for the child process and return as a result of the close.
5389 * This function uses the _PyPopenProcs dictionary in order to map the
5390 * input file pointer to information about the process that was
5391 * originally created by the popen* call that created the file pointer.
5392 * The dictionary uses the file pointer as a key (with one entry
5393 * inserted for each file returned by the original popen* call) and a
5394 * single list object as the value for all files from a single call.
5395 * The list object contains the Win32 process handle at [0], and a file
5396 * count at [1], which is initialized to the total number of file
5397 * handles using that list.
5399 * This function closes whichever handle it is passed, and decrements
5400 * the file count in the dictionary for the process handle pointed to
5401 * by this file. On the last close (when the file count reaches zero),
5402 * this function will wait for the child process and then return its
5403 * exit code as the result of the close() operation. This permits the
5404 * files to be closed in any order - it is always the close() of the
5405 * final handle that will return the exit code.
5407 * NOTE: This function is currently called with the GIL released.
5408 * hence we use the GILState API to manage our state.
5411 static int _PyPclose(FILE *file
)
5416 PyObject
*procObj
, *hProcessObj
, *intObj
, *fileObj
;
5419 PyGILState_STATE state
;
5422 /* Close the file handle first, to ensure it can't block the
5423 * child from exiting if it's the last handle.
5425 result
= fclose(file
);
5427 state
= PyGILState_Ensure();
5429 if (_PyPopenProcs
) {
5430 if ((fileObj
= PyLong_FromVoidPtr(file
)) != NULL
&&
5431 (procObj
= PyDict_GetItem(_PyPopenProcs
,
5432 fileObj
)) != NULL
&&
5433 (hProcessObj
= PyList_GetItem(procObj
,0)) != NULL
&&
5434 (intObj
= PyList_GetItem(procObj
,1)) != NULL
) {
5436 hProcess
= PyLong_AsVoidPtr(hProcessObj
);
5437 file_count
= PyInt_AsLong(intObj
);
5439 if (file_count
> 1) {
5440 /* Still other files referencing process */
5442 PyList_SetItem(procObj
,1,
5443 PyInt_FromLong(file_count
));
5445 /* Last file for this process */
5446 if (result
!= EOF
&&
5447 WaitForSingleObject(hProcess
, INFINITE
) != WAIT_FAILED
&&
5448 GetExitCodeProcess(hProcess
, &exit_code
)) {
5449 /* Possible truncation here in 16-bit environments, but
5450 * real exit codes are just the lower byte in any event.
5454 /* Indicate failure - this will cause the file object
5455 * to raise an I/O error and translate the last Win32
5456 * error code from errno. We do have a problem with
5457 * last errors that overlap the normal errno table,
5458 * but that's a consistent problem with the file object.
5460 if (result
!= EOF
) {
5461 /* If the error wasn't from the fclose(), then
5462 * set errno for the file object error handling.
5464 errno
= GetLastError();
5469 /* Free up the native handle at this point */
5470 CloseHandle(hProcess
);
5473 /* Remove this file pointer from dictionary */
5474 PyDict_DelItem(_PyPopenProcs
, fileObj
);
5476 if (PyDict_Size(_PyPopenProcs
) == 0) {
5477 Py_DECREF(_PyPopenProcs
);
5478 _PyPopenProcs
= NULL
;
5481 } /* if object retrieval ok */
5483 Py_XDECREF(fileObj
);
5484 } /* if _PyPopenProcs */
5487 PyGILState_Release(state
);
5492 #else /* which OS? */
5494 posix_popen(PyObject
*self
, PyObject
*args
)
5501 if (!PyArg_ParseTuple(args
, "s|si:popen", &name
, &mode
, &bufsize
))
5503 /* Strip mode of binary or text modifiers */
5504 if (strcmp(mode
, "rb") == 0 || strcmp(mode
, "rt") == 0)
5506 else if (strcmp(mode
, "wb") == 0 || strcmp(mode
, "wt") == 0)
5508 Py_BEGIN_ALLOW_THREADS
5509 fp
= popen(name
, mode
);
5510 Py_END_ALLOW_THREADS
5512 return posix_error();
5513 f
= PyFile_FromFile(fp
, name
, mode
, pclose
);
5515 PyFile_SetBufSize(f
, bufsize
);
5519 #endif /* PYOS_??? */
5520 #endif /* HAVE_POPEN */
5524 PyDoc_STRVAR(posix_setuid__doc__
,
5526 Set the current process's user id.");
5529 posix_setuid(PyObject
*self
, PyObject
*args
)
5533 if (!PyArg_ParseTuple(args
, "l:setuid", &uid_arg
))
5536 if (uid
!= uid_arg
) {
5537 PyErr_SetString(PyExc_OverflowError
, "user id too big");
5540 if (setuid(uid
) < 0)
5541 return posix_error();
5545 #endif /* HAVE_SETUID */
5549 PyDoc_STRVAR(posix_seteuid__doc__
,
5551 Set the current process's effective user id.");
5554 posix_seteuid (PyObject
*self
, PyObject
*args
)
5558 if (!PyArg_ParseTuple(args
, "l", &euid_arg
))
5561 if (euid
!= euid_arg
) {
5562 PyErr_SetString(PyExc_OverflowError
, "user id too big");
5565 if (seteuid(euid
) < 0) {
5566 return posix_error();
5572 #endif /* HAVE_SETEUID */
5575 PyDoc_STRVAR(posix_setegid__doc__
,
5577 Set the current process's effective group id.");
5580 posix_setegid (PyObject
*self
, PyObject
*args
)
5584 if (!PyArg_ParseTuple(args
, "l", &egid_arg
))
5587 if (egid
!= egid_arg
) {
5588 PyErr_SetString(PyExc_OverflowError
, "group id too big");
5591 if (setegid(egid
) < 0) {
5592 return posix_error();
5598 #endif /* HAVE_SETEGID */
5600 #ifdef HAVE_SETREUID
5601 PyDoc_STRVAR(posix_setreuid__doc__
,
5602 "setreuid(ruid, euid)\n\n\
5603 Set the current process's real and effective user ids.");
5606 posix_setreuid (PyObject
*self
, PyObject
*args
)
5608 long ruid_arg
, euid_arg
;
5610 if (!PyArg_ParseTuple(args
, "ll", &ruid_arg
, &euid_arg
))
5614 if (euid
!= euid_arg
|| ruid
!= ruid_arg
) {
5615 PyErr_SetString(PyExc_OverflowError
, "user id too big");
5618 if (setreuid(ruid
, euid
) < 0) {
5619 return posix_error();
5625 #endif /* HAVE_SETREUID */
5627 #ifdef HAVE_SETREGID
5628 PyDoc_STRVAR(posix_setregid__doc__
,
5629 "setregid(rgid, egid)\n\n\
5630 Set the current process's real and effective group ids.");
5633 posix_setregid (PyObject
*self
, PyObject
*args
)
5635 long rgid_arg
, egid_arg
;
5637 if (!PyArg_ParseTuple(args
, "ll", &rgid_arg
, &egid_arg
))
5641 if (egid
!= egid_arg
|| rgid
!= rgid_arg
) {
5642 PyErr_SetString(PyExc_OverflowError
, "group id too big");
5645 if (setregid(rgid
, egid
) < 0) {
5646 return posix_error();
5652 #endif /* HAVE_SETREGID */
5655 PyDoc_STRVAR(posix_setgid__doc__
,
5657 Set the current process's group id.");
5660 posix_setgid(PyObject
*self
, PyObject
*args
)
5664 if (!PyArg_ParseTuple(args
, "l:setgid", &gid_arg
))
5667 if (gid
!= gid_arg
) {
5668 PyErr_SetString(PyExc_OverflowError
, "group id too big");
5671 if (setgid(gid
) < 0)
5672 return posix_error();
5676 #endif /* HAVE_SETGID */
5678 #ifdef HAVE_SETGROUPS
5679 PyDoc_STRVAR(posix_setgroups__doc__
,
5680 "setgroups(list)\n\n\
5681 Set the groups of the current process to list.");
5684 posix_setgroups(PyObject
*self
, PyObject
*groups
)
5687 gid_t grouplist
[MAX_GROUPS
];
5689 if (!PySequence_Check(groups
)) {
5690 PyErr_SetString(PyExc_TypeError
, "setgroups argument must be a sequence");
5693 len
= PySequence_Size(groups
);
5694 if (len
> MAX_GROUPS
) {
5695 PyErr_SetString(PyExc_ValueError
, "too many groups");
5698 for(i
= 0; i
< len
; i
++) {
5700 elem
= PySequence_GetItem(groups
, i
);
5703 if (!PyInt_Check(elem
)) {
5704 if (!PyLong_Check(elem
)) {
5705 PyErr_SetString(PyExc_TypeError
,
5706 "groups must be integers");
5710 unsigned long x
= PyLong_AsUnsignedLong(elem
);
5711 if (PyErr_Occurred()) {
5712 PyErr_SetString(PyExc_TypeError
,
5713 "group id too big");
5718 /* read back to see if it fits in gid_t */
5719 if (grouplist
[i
] != x
) {
5720 PyErr_SetString(PyExc_TypeError
,
5721 "group id too big");
5727 long x
= PyInt_AsLong(elem
);
5729 if (grouplist
[i
] != x
) {
5730 PyErr_SetString(PyExc_TypeError
,
5731 "group id too big");
5739 if (setgroups(len
, grouplist
) < 0)
5740 return posix_error();
5744 #endif /* HAVE_SETGROUPS */
5746 #if defined(HAVE_WAIT3) || defined(HAVE_WAIT4)
5748 wait_helper(pid_t pid
, int status
, struct rusage
*ru
)
5751 static PyObject
*struct_rusage
;
5754 return posix_error();
5756 if (struct_rusage
== NULL
) {
5757 PyObject
*m
= PyImport_ImportModuleNoBlock("resource");
5760 struct_rusage
= PyObject_GetAttrString(m
, "struct_rusage");
5762 if (struct_rusage
== NULL
)
5766 /* XXX(nnorwitz): Copied (w/mods) from resource.c, there should be only one. */
5767 result
= PyStructSequence_New((PyTypeObject
*) struct_rusage
);
5772 #define doubletime(TV) ((double)(TV).tv_sec + (TV).tv_usec * 0.000001)
5775 PyStructSequence_SET_ITEM(result
, 0,
5776 PyFloat_FromDouble(doubletime(ru
->ru_utime
)));
5777 PyStructSequence_SET_ITEM(result
, 1,
5778 PyFloat_FromDouble(doubletime(ru
->ru_stime
)));
5779 #define SET_INT(result, index, value)\
5780 PyStructSequence_SET_ITEM(result, index, PyInt_FromLong(value))
5781 SET_INT(result
, 2, ru
->ru_maxrss
);
5782 SET_INT(result
, 3, ru
->ru_ixrss
);
5783 SET_INT(result
, 4, ru
->ru_idrss
);
5784 SET_INT(result
, 5, ru
->ru_isrss
);
5785 SET_INT(result
, 6, ru
->ru_minflt
);
5786 SET_INT(result
, 7, ru
->ru_majflt
);
5787 SET_INT(result
, 8, ru
->ru_nswap
);
5788 SET_INT(result
, 9, ru
->ru_inblock
);
5789 SET_INT(result
, 10, ru
->ru_oublock
);
5790 SET_INT(result
, 11, ru
->ru_msgsnd
);
5791 SET_INT(result
, 12, ru
->ru_msgrcv
);
5792 SET_INT(result
, 13, ru
->ru_nsignals
);
5793 SET_INT(result
, 14, ru
->ru_nvcsw
);
5794 SET_INT(result
, 15, ru
->ru_nivcsw
);
5797 if (PyErr_Occurred()) {
5802 return Py_BuildValue("NiN", PyLong_FromPid(pid
), status
, result
);
5804 #endif /* HAVE_WAIT3 || HAVE_WAIT4 */
5807 PyDoc_STRVAR(posix_wait3__doc__
,
5808 "wait3(options) -> (pid, status, rusage)\n\n\
5809 Wait for completion of a child process.");
5812 posix_wait3(PyObject
*self
, PyObject
*args
)
5818 WAIT_STATUS_INT(status
) = 0;
5820 if (!PyArg_ParseTuple(args
, "i:wait3", &options
))
5823 Py_BEGIN_ALLOW_THREADS
5824 pid
= wait3(&status
, options
, &ru
);
5825 Py_END_ALLOW_THREADS
5827 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5829 #endif /* HAVE_WAIT3 */
5832 PyDoc_STRVAR(posix_wait4__doc__
,
5833 "wait4(pid, options) -> (pid, status, rusage)\n\n\
5834 Wait for completion of a given child process.");
5837 posix_wait4(PyObject
*self
, PyObject
*args
)
5843 WAIT_STATUS_INT(status
) = 0;
5845 if (!PyArg_ParseTuple(args
, PARSE_PID
"i:wait4", &pid
, &options
))
5848 Py_BEGIN_ALLOW_THREADS
5849 pid
= wait4(pid
, &status
, options
, &ru
);
5850 Py_END_ALLOW_THREADS
5852 return wait_helper(pid
, WAIT_STATUS_INT(status
), &ru
);
5854 #endif /* HAVE_WAIT4 */
5857 PyDoc_STRVAR(posix_waitpid__doc__
,
5858 "waitpid(pid, options) -> (pid, status)\n\n\
5859 Wait for completion of a given child process.");
5862 posix_waitpid(PyObject
*self
, PyObject
*args
)
5867 WAIT_STATUS_INT(status
) = 0;
5869 if (!PyArg_ParseTuple(args
, PARSE_PID
"i:waitpid", &pid
, &options
))
5871 Py_BEGIN_ALLOW_THREADS
5872 pid
= waitpid(pid
, &status
, options
);
5873 Py_END_ALLOW_THREADS
5875 return posix_error();
5877 return Py_BuildValue("Ni", PyLong_FromPid(pid
), WAIT_STATUS_INT(status
));
5880 #elif defined(HAVE_CWAIT)
5882 /* MS C has a variant of waitpid() that's usable for most purposes. */
5883 PyDoc_STRVAR(posix_waitpid__doc__
,
5884 "waitpid(pid, options) -> (pid, status << 8)\n\n"
5885 "Wait for completion of a given process. options is ignored on Windows.");
5888 posix_waitpid(PyObject
*self
, PyObject
*args
)
5891 int status
, options
;
5893 if (!PyArg_ParseTuple(args
, PARSE_PID
"i:waitpid", &pid
, &options
))
5895 Py_BEGIN_ALLOW_THREADS
5896 pid
= _cwait(&status
, pid
, options
);
5897 Py_END_ALLOW_THREADS
5899 return posix_error();
5901 /* shift the status left a byte so this is more like the POSIX waitpid */
5902 return Py_BuildValue("Ni", PyLong_FromPid(pid
), status
<< 8);
5904 #endif /* HAVE_WAITPID || HAVE_CWAIT */
5907 PyDoc_STRVAR(posix_wait__doc__
,
5908 "wait() -> (pid, status)\n\n\
5909 Wait for completion of a child process.");
5912 posix_wait(PyObject
*self
, PyObject
*noargs
)
5916 WAIT_STATUS_INT(status
) = 0;
5918 Py_BEGIN_ALLOW_THREADS
5919 pid
= wait(&status
);
5920 Py_END_ALLOW_THREADS
5922 return posix_error();
5924 return Py_BuildValue("Ni", PyLong_FromPid(pid
), WAIT_STATUS_INT(status
));
5929 PyDoc_STRVAR(posix_lstat__doc__
,
5930 "lstat(path) -> stat result\n\n\
5931 Like stat(path), but do not follow symbolic links.");
5934 posix_lstat(PyObject
*self
, PyObject
*args
)
5937 return posix_do_stat(self
, args
, "et:lstat", lstat
, NULL
, NULL
);
5938 #else /* !HAVE_LSTAT */
5940 return posix_do_stat(self
, args
, "et:lstat", STAT
, "U:lstat", win32_wstat
);
5942 return posix_do_stat(self
, args
, "et:lstat", STAT
, NULL
, NULL
);
5944 #endif /* !HAVE_LSTAT */
5948 #ifdef HAVE_READLINK
5949 PyDoc_STRVAR(posix_readlink__doc__
,
5950 "readlink(path) -> path\n\n\
5951 Return a string representing the path to which the symbolic link points.");
5954 posix_readlink(PyObject
*self
, PyObject
*args
)
5957 char buf
[MAXPATHLEN
];
5960 #ifdef Py_USING_UNICODE
5961 int arg_is_unicode
= 0;
5964 if (!PyArg_ParseTuple(args
, "et:readlink",
5965 Py_FileSystemDefaultEncoding
, &path
))
5967 #ifdef Py_USING_UNICODE
5968 v
= PySequence_GetItem(args
, 0);
5974 if (PyUnicode_Check(v
)) {
5980 Py_BEGIN_ALLOW_THREADS
5981 n
= readlink(path
, buf
, (int) sizeof buf
);
5982 Py_END_ALLOW_THREADS
5984 return posix_error_with_allocated_filename(path
);
5987 v
= PyString_FromStringAndSize(buf
, n
);
5988 #ifdef Py_USING_UNICODE
5989 if (arg_is_unicode
) {
5992 w
= PyUnicode_FromEncodedObject(v
,
5993 Py_FileSystemDefaultEncoding
,
6000 /* fall back to the original byte string, as
6001 discussed in patch #683592 */
6008 #endif /* HAVE_READLINK */
6012 PyDoc_STRVAR(posix_symlink__doc__
,
6013 "symlink(src, dst)\n\n\
6014 Create a symbolic link pointing to src named dst.");
6017 posix_symlink(PyObject
*self
, PyObject
*args
)
6019 return posix_2str(args
, "etet:symlink", symlink
);
6021 #endif /* HAVE_SYMLINK */
6025 #if defined(PYCC_VACPP) && defined(PYOS_OS2)
6031 Py_BEGIN_ALLOW_THREADS
6032 DosQuerySysInfo(QSV_MS_COUNT
, QSV_MS_COUNT
, &value
, sizeof(value
));
6033 Py_END_ALLOW_THREADS
6039 posix_times(PyObject
*self
, PyObject
*noargs
)
6041 /* Currently Only Uptime is Provided -- Others Later */
6042 return Py_BuildValue("ddddd",
6043 (double)0 /* t.tms_utime / HZ */,
6044 (double)0 /* t.tms_stime / HZ */,
6045 (double)0 /* t.tms_cutime / HZ */,
6046 (double)0 /* t.tms_cstime / HZ */,
6047 (double)system_uptime() / 1000);
6050 #define NEED_TICKS_PER_SECOND
6051 static long ticks_per_second
= -1;
6053 posix_times(PyObject
*self
, PyObject
*noargs
)
6059 if (c
== (clock_t) -1)
6060 return posix_error();
6061 return Py_BuildValue("ddddd",
6062 (double)t
.tms_utime
/ ticks_per_second
,
6063 (double)t
.tms_stime
/ ticks_per_second
,
6064 (double)t
.tms_cutime
/ ticks_per_second
,
6065 (double)t
.tms_cstime
/ ticks_per_second
,
6066 (double)c
/ ticks_per_second
);
6068 #endif /* not OS2 */
6069 #endif /* HAVE_TIMES */
6073 #define HAVE_TIMES /* so the method table will pick it up */
6075 posix_times(PyObject
*self
, PyObject
*noargs
)
6077 FILETIME create
, exit
, kernel
, user
;
6079 hProc
= GetCurrentProcess();
6080 GetProcessTimes(hProc
, &create
, &exit
, &kernel
, &user
);
6081 /* The fields of a FILETIME structure are the hi and lo part
6082 of a 64-bit value expressed in 100 nanosecond units.
6083 1e7 is one second in such units; 1e-7 the inverse.
6084 429.4967296 is 2**32 / 1e7 or 2**32 * 1e-7.
6086 return Py_BuildValue(
6088 (double)(user
.dwHighDateTime
*429.4967296 +
6089 user
.dwLowDateTime
*1e-7),
6090 (double)(kernel
.dwHighDateTime
*429.4967296 +
6091 kernel
.dwLowDateTime
*1e-7),
6096 #endif /* MS_WINDOWS */
6099 PyDoc_STRVAR(posix_times__doc__
,
6100 "times() -> (utime, stime, cutime, cstime, elapsed_time)\n\n\
6101 Return a tuple of floating point numbers indicating process times.");
6106 PyDoc_STRVAR(posix_getsid__doc__
,
6107 "getsid(pid) -> sid\n\n\
6108 Call the system call getsid().");
6111 posix_getsid(PyObject
*self
, PyObject
*args
)
6115 if (!PyArg_ParseTuple(args
, PARSE_PID
":getsid", &pid
))
6119 return posix_error();
6120 return PyInt_FromLong((long)sid
);
6122 #endif /* HAVE_GETSID */
6126 PyDoc_STRVAR(posix_setsid__doc__
,
6128 Call the system call setsid().");
6131 posix_setsid(PyObject
*self
, PyObject
*noargs
)
6134 return posix_error();
6138 #endif /* HAVE_SETSID */
6141 PyDoc_STRVAR(posix_setpgid__doc__
,
6142 "setpgid(pid, pgrp)\n\n\
6143 Call the system call setpgid().");
6146 posix_setpgid(PyObject
*self
, PyObject
*args
)
6150 if (!PyArg_ParseTuple(args
, PARSE_PID
"i:setpgid", &pid
, &pgrp
))
6152 if (setpgid(pid
, pgrp
) < 0)
6153 return posix_error();
6157 #endif /* HAVE_SETPGID */
6160 #ifdef HAVE_TCGETPGRP
6161 PyDoc_STRVAR(posix_tcgetpgrp__doc__
,
6162 "tcgetpgrp(fd) -> pgid\n\n\
6163 Return the process group associated with the terminal given by a fd.");
6166 posix_tcgetpgrp(PyObject
*self
, PyObject
*args
)
6170 if (!PyArg_ParseTuple(args
, "i:tcgetpgrp", &fd
))
6172 pgid
= tcgetpgrp(fd
);
6174 return posix_error();
6175 return PyLong_FromPid(pgid
);
6177 #endif /* HAVE_TCGETPGRP */
6180 #ifdef HAVE_TCSETPGRP
6181 PyDoc_STRVAR(posix_tcsetpgrp__doc__
,
6182 "tcsetpgrp(fd, pgid)\n\n\
6183 Set the process group associated with the terminal given by a fd.");
6186 posix_tcsetpgrp(PyObject
*self
, PyObject
*args
)
6190 if (!PyArg_ParseTuple(args
, "i" PARSE_PID
":tcsetpgrp", &fd
, &pgid
))
6192 if (tcsetpgrp(fd
, pgid
) < 0)
6193 return posix_error();
6197 #endif /* HAVE_TCSETPGRP */
6199 /* Functions acting on file descriptors */
6201 PyDoc_STRVAR(posix_open__doc__
,
6202 "open(filename, flag [, mode=0777]) -> fd\n\n\
6203 Open a file (for low level IO).");
6206 posix_open(PyObject
*self
, PyObject
*args
)
6214 PyUnicodeObject
*po
;
6215 if (PyArg_ParseTuple(args
, "Ui|i:mkdir", &po
, &flag
, &mode
)) {
6216 Py_BEGIN_ALLOW_THREADS
6217 /* PyUnicode_AS_UNICODE OK without thread
6218 lock as it is a simple dereference. */
6219 fd
= _wopen(PyUnicode_AS_UNICODE(po
), flag
, mode
);
6220 Py_END_ALLOW_THREADS
6222 return posix_error();
6223 return PyInt_FromLong((long)fd
);
6225 /* Drop the argument parsing error as narrow strings
6230 if (!PyArg_ParseTuple(args
, "eti|i",
6231 Py_FileSystemDefaultEncoding
, &file
,
6235 Py_BEGIN_ALLOW_THREADS
6236 fd
= open(file
, flag
, mode
);
6237 Py_END_ALLOW_THREADS
6239 return posix_error_with_allocated_filename(file
);
6241 return PyInt_FromLong((long)fd
);
6245 PyDoc_STRVAR(posix_close__doc__
,
6247 Close a file descriptor (for low level IO).");
6250 posix_close(PyObject
*self
, PyObject
*args
)
6253 if (!PyArg_ParseTuple(args
, "i:close", &fd
))
6255 if (!_PyVerify_fd(fd
))
6256 return posix_error();
6257 Py_BEGIN_ALLOW_THREADS
6259 Py_END_ALLOW_THREADS
6261 return posix_error();
6267 PyDoc_STRVAR(posix_closerange__doc__
,
6268 "closerange(fd_low, fd_high)\n\n\
6269 Closes all file descriptors in [fd_low, fd_high), ignoring errors.");
6272 posix_closerange(PyObject
*self
, PyObject
*args
)
6274 int fd_from
, fd_to
, i
;
6275 if (!PyArg_ParseTuple(args
, "ii:closerange", &fd_from
, &fd_to
))
6277 Py_BEGIN_ALLOW_THREADS
6278 for (i
= fd_from
; i
< fd_to
; i
++)
6279 if (_PyVerify_fd(i
))
6281 Py_END_ALLOW_THREADS
6286 PyDoc_STRVAR(posix_dup__doc__
,
6287 "dup(fd) -> fd2\n\n\
6288 Return a duplicate of a file descriptor.");
6291 posix_dup(PyObject
*self
, PyObject
*args
)
6294 if (!PyArg_ParseTuple(args
, "i:dup", &fd
))
6296 if (!_PyVerify_fd(fd
))
6297 return posix_error();
6298 Py_BEGIN_ALLOW_THREADS
6300 Py_END_ALLOW_THREADS
6302 return posix_error();
6303 return PyInt_FromLong((long)fd
);
6307 PyDoc_STRVAR(posix_dup2__doc__
,
6308 "dup2(old_fd, new_fd)\n\n\
6309 Duplicate file descriptor.");
6312 posix_dup2(PyObject
*self
, PyObject
*args
)
6315 if (!PyArg_ParseTuple(args
, "ii:dup2", &fd
, &fd2
))
6317 if (!_PyVerify_fd_dup2(fd
, fd2
))
6318 return posix_error();
6319 Py_BEGIN_ALLOW_THREADS
6320 res
= dup2(fd
, fd2
);
6321 Py_END_ALLOW_THREADS
6323 return posix_error();
6329 PyDoc_STRVAR(posix_lseek__doc__
,
6330 "lseek(fd, pos, how) -> newpos\n\n\
6331 Set the current position of a file descriptor.");
6334 posix_lseek(PyObject
*self
, PyObject
*args
)
6337 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6338 PY_LONG_LONG pos
, res
;
6343 if (!PyArg_ParseTuple(args
, "iOi:lseek", &fd
, &posobj
, &how
))
6346 /* Turn 0, 1, 2 into SEEK_{SET,CUR,END} */
6348 case 0: how
= SEEK_SET
; break;
6349 case 1: how
= SEEK_CUR
; break;
6350 case 2: how
= SEEK_END
; break;
6352 #endif /* SEEK_END */
6354 #if !defined(HAVE_LARGEFILE_SUPPORT)
6355 pos
= PyInt_AsLong(posobj
);
6357 pos
= PyLong_Check(posobj
) ?
6358 PyLong_AsLongLong(posobj
) : PyInt_AsLong(posobj
);
6360 if (PyErr_Occurred())
6363 if (!_PyVerify_fd(fd
))
6364 return posix_error();
6365 Py_BEGIN_ALLOW_THREADS
6366 #if defined(MS_WIN64) || defined(MS_WINDOWS)
6367 res
= _lseeki64(fd
, pos
, how
);
6369 res
= lseek(fd
, pos
, how
);
6371 Py_END_ALLOW_THREADS
6373 return posix_error();
6375 #if !defined(HAVE_LARGEFILE_SUPPORT)
6376 return PyInt_FromLong(res
);
6378 return PyLong_FromLongLong(res
);
6383 PyDoc_STRVAR(posix_read__doc__
,
6384 "read(fd, buffersize) -> string\n\n\
6385 Read a file descriptor.");
6388 posix_read(PyObject
*self
, PyObject
*args
)
6392 if (!PyArg_ParseTuple(args
, "ii:read", &fd
, &size
))
6396 return posix_error();
6398 buffer
= PyString_FromStringAndSize((char *)NULL
, size
);
6401 if (!_PyVerify_fd(fd
))
6402 return posix_error();
6403 Py_BEGIN_ALLOW_THREADS
6404 n
= read(fd
, PyString_AsString(buffer
), size
);
6405 Py_END_ALLOW_THREADS
6408 return posix_error();
6411 _PyString_Resize(&buffer
, n
);
6416 PyDoc_STRVAR(posix_write__doc__
,
6417 "write(fd, string) -> byteswritten\n\n\
6418 Write a string to a file descriptor.");
6421 posix_write(PyObject
*self
, PyObject
*args
)
6427 if (!PyArg_ParseTuple(args
, "is*:write", &fd
, &pbuf
))
6429 if (!_PyVerify_fd(fd
))
6430 return posix_error();
6431 Py_BEGIN_ALLOW_THREADS
6432 size
= write(fd
, pbuf
.buf
, (size_t)pbuf
.len
);
6433 Py_END_ALLOW_THREADS
6434 PyBuffer_Release(&pbuf
);
6436 return posix_error();
6437 return PyInt_FromSsize_t(size
);
6441 PyDoc_STRVAR(posix_fstat__doc__
,
6442 "fstat(fd) -> stat result\n\n\
6443 Like stat(), but for an open file descriptor.");
6446 posix_fstat(PyObject
*self
, PyObject
*args
)
6451 if (!PyArg_ParseTuple(args
, "i:fstat", &fd
))
6454 /* on OpenVMS we must ensure that all bytes are written to the file */
6457 if (!_PyVerify_fd(fd
))
6458 return posix_error();
6459 Py_BEGIN_ALLOW_THREADS
6460 res
= FSTAT(fd
, &st
);
6461 Py_END_ALLOW_THREADS
6464 return win32_error("fstat", NULL
);
6466 return posix_error();
6470 return _pystat_fromstructstat(&st
);
6474 PyDoc_STRVAR(posix_fdopen__doc__
,
6475 "fdopen(fd [, mode='r' [, bufsize]]) -> file_object\n\n\
6476 Return an open file object connected to a file descriptor.");
6479 posix_fdopen(PyObject
*self
, PyObject
*args
)
6482 char *orgmode
= "r";
6487 if (!PyArg_ParseTuple(args
, "i|si", &fd
, &orgmode
, &bufsize
))
6490 /* Sanitize mode. See fileobject.c */
6491 mode
= PyMem_MALLOC(strlen(orgmode
)+3);
6496 strcpy(mode
, orgmode
);
6497 if (_PyFile_SanitizeMode(mode
)) {
6501 if (!_PyVerify_fd(fd
))
6502 return posix_error();
6503 Py_BEGIN_ALLOW_THREADS
6504 #if !defined(MS_WINDOWS) && defined(HAVE_FCNTL_H)
6505 if (mode
[0] == 'a') {
6506 /* try to make sure the O_APPEND flag is set */
6508 flags
= fcntl(fd
, F_GETFL
);
6510 fcntl(fd
, F_SETFL
, flags
| O_APPEND
);
6511 fp
= fdopen(fd
, mode
);
6512 if (fp
== NULL
&& flags
!= -1)
6513 /* restore old mode if fdopen failed */
6514 fcntl(fd
, F_SETFL
, flags
);
6516 fp
= fdopen(fd
, mode
);
6519 fp
= fdopen(fd
, mode
);
6521 Py_END_ALLOW_THREADS
6524 return posix_error();
6525 f
= PyFile_FromFile(fp
, "<fdopen>", orgmode
, fclose
);
6527 PyFile_SetBufSize(f
, bufsize
);
6531 PyDoc_STRVAR(posix_isatty__doc__
,
6532 "isatty(fd) -> bool\n\n\
6533 Return True if the file descriptor 'fd' is an open file descriptor\n\
6534 connected to the slave end of a terminal.");
6537 posix_isatty(PyObject
*self
, PyObject
*args
)
6540 if (!PyArg_ParseTuple(args
, "i:isatty", &fd
))
6542 if (!_PyVerify_fd(fd
))
6543 return PyBool_FromLong(0);
6544 return PyBool_FromLong(isatty(fd
));
6548 PyDoc_STRVAR(posix_pipe__doc__
,
6549 "pipe() -> (read_end, write_end)\n\n\
6553 posix_pipe(PyObject
*self
, PyObject
*noargs
)
6555 #if defined(PYOS_OS2)
6559 Py_BEGIN_ALLOW_THREADS
6560 rc
= DosCreatePipe( &read
, &write
, 4096);
6561 Py_END_ALLOW_THREADS
6563 return os2_error(rc
);
6565 return Py_BuildValue("(ii)", read
, write
);
6567 #if !defined(MS_WINDOWS)
6570 Py_BEGIN_ALLOW_THREADS
6572 Py_END_ALLOW_THREADS
6574 return posix_error();
6575 return Py_BuildValue("(ii)", fds
[0], fds
[1]);
6576 #else /* MS_WINDOWS */
6578 int read_fd
, write_fd
;
6580 Py_BEGIN_ALLOW_THREADS
6581 ok
= CreatePipe(&read
, &write
, NULL
, 0);
6582 Py_END_ALLOW_THREADS
6584 return win32_error("CreatePipe", NULL
);
6585 read_fd
= _open_osfhandle((Py_intptr_t
)read
, 0);
6586 write_fd
= _open_osfhandle((Py_intptr_t
)write
, 1);
6587 return Py_BuildValue("(ii)", read_fd
, write_fd
);
6588 #endif /* MS_WINDOWS */
6591 #endif /* HAVE_PIPE */
6595 PyDoc_STRVAR(posix_mkfifo__doc__
,
6596 "mkfifo(filename [, mode=0666])\n\n\
6597 Create a FIFO (a POSIX named pipe).");
6600 posix_mkfifo(PyObject
*self
, PyObject
*args
)
6605 if (!PyArg_ParseTuple(args
, "s|i:mkfifo", &filename
, &mode
))
6607 Py_BEGIN_ALLOW_THREADS
6608 res
= mkfifo(filename
, mode
);
6609 Py_END_ALLOW_THREADS
6611 return posix_error();
6618 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
6619 PyDoc_STRVAR(posix_mknod__doc__
,
6620 "mknod(filename [, mode=0600, device])\n\n\
6621 Create a filesystem node (file, device special file or named pipe)\n\
6622 named filename. mode specifies both the permissions to use and the\n\
6623 type of node to be created, being combined (bitwise OR) with one of\n\
6624 S_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO. For S_IFCHR and S_IFBLK,\n\
6625 device defines the newly created device special file (probably using\n\
6626 os.makedev()), otherwise it is ignored.");
6630 posix_mknod(PyObject
*self
, PyObject
*args
)
6636 if (!PyArg_ParseTuple(args
, "s|ii:mknod", &filename
, &mode
, &device
))
6638 Py_BEGIN_ALLOW_THREADS
6639 res
= mknod(filename
, mode
, device
);
6640 Py_END_ALLOW_THREADS
6642 return posix_error();
6648 #ifdef HAVE_DEVICE_MACROS
6649 PyDoc_STRVAR(posix_major__doc__
,
6650 "major(device) -> major number\n\
6651 Extracts a device major number from a raw device number.");
6654 posix_major(PyObject
*self
, PyObject
*args
)
6657 if (!PyArg_ParseTuple(args
, "i:major", &device
))
6659 return PyInt_FromLong((long)major(device
));
6662 PyDoc_STRVAR(posix_minor__doc__
,
6663 "minor(device) -> minor number\n\
6664 Extracts a device minor number from a raw device number.");
6667 posix_minor(PyObject
*self
, PyObject
*args
)
6670 if (!PyArg_ParseTuple(args
, "i:minor", &device
))
6672 return PyInt_FromLong((long)minor(device
));
6675 PyDoc_STRVAR(posix_makedev__doc__
,
6676 "makedev(major, minor) -> device number\n\
6677 Composes a raw device number from the major and minor device numbers.");
6680 posix_makedev(PyObject
*self
, PyObject
*args
)
6683 if (!PyArg_ParseTuple(args
, "ii:makedev", &major
, &minor
))
6685 return PyInt_FromLong((long)makedev(major
, minor
));
6687 #endif /* device macros */
6690 #ifdef HAVE_FTRUNCATE
6691 PyDoc_STRVAR(posix_ftruncate__doc__
,
6692 "ftruncate(fd, length)\n\n\
6693 Truncate a file to a specified length.");
6696 posix_ftruncate(PyObject
*self
, PyObject
*args
)
6703 if (!PyArg_ParseTuple(args
, "iO:ftruncate", &fd
, &lenobj
))
6706 #if !defined(HAVE_LARGEFILE_SUPPORT)
6707 length
= PyInt_AsLong(lenobj
);
6709 length
= PyLong_Check(lenobj
) ?
6710 PyLong_AsLongLong(lenobj
) : PyInt_AsLong(lenobj
);
6712 if (PyErr_Occurred())
6715 Py_BEGIN_ALLOW_THREADS
6716 res
= ftruncate(fd
, length
);
6717 Py_END_ALLOW_THREADS
6719 return posix_error();
6726 PyDoc_STRVAR(posix_putenv__doc__
,
6727 "putenv(key, value)\n\n\
6728 Change or add an environment variable.");
6730 /* Save putenv() parameters as values here, so we can collect them when they
6731 * get re-set with another call for the same key. */
6732 static PyObject
*posix_putenv_garbage
;
6735 posix_putenv(PyObject
*self
, PyObject
*args
)
6742 if (!PyArg_ParseTuple(args
, "ss:putenv", &s1
, &s2
))
6745 #if defined(PYOS_OS2)
6746 if (stricmp(s1
, "BEGINLIBPATH") == 0) {
6749 rc
= DosSetExtLIBPATH(s2
, BEGIN_LIBPATH
);
6751 return os2_error(rc
);
6753 } else if (stricmp(s1
, "ENDLIBPATH") == 0) {
6756 rc
= DosSetExtLIBPATH(s2
, END_LIBPATH
);
6758 return os2_error(rc
);
6762 /* XXX This can leak memory -- not easy to fix :-( */
6763 len
= strlen(s1
) + strlen(s2
) + 2;
6764 /* len includes space for a trailing \0; the size arg to
6765 PyString_FromStringAndSize does not count that */
6766 newstr
= PyString_FromStringAndSize(NULL
, (int)len
- 1);
6768 return PyErr_NoMemory();
6769 newenv
= PyString_AS_STRING(newstr
);
6770 PyOS_snprintf(newenv
, len
, "%s=%s", s1
, s2
);
6771 if (putenv(newenv
)) {
6776 /* Install the first arg and newstr in posix_putenv_garbage;
6777 * this will cause previous value to be collected. This has to
6778 * happen after the real putenv() call because the old value
6779 * was still accessible until then. */
6780 if (PyDict_SetItem(posix_putenv_garbage
,
6781 PyTuple_GET_ITEM(args
, 0), newstr
)) {
6782 /* really not much we can do; just leak */
6789 #if defined(PYOS_OS2)
6797 #ifdef HAVE_UNSETENV
6798 PyDoc_STRVAR(posix_unsetenv__doc__
,
6800 Delete an environment variable.");
6803 posix_unsetenv(PyObject
*self
, PyObject
*args
)
6807 if (!PyArg_ParseTuple(args
, "s:unsetenv", &s1
))
6812 /* Remove the key from posix_putenv_garbage;
6813 * this will cause it to be collected. This has to
6814 * happen after the real unsetenv() call because the
6815 * old value was still accessible until then.
6817 if (PyDict_DelItem(posix_putenv_garbage
,
6818 PyTuple_GET_ITEM(args
, 0))) {
6819 /* really not much we can do; just leak */
6826 #endif /* unsetenv */
6828 PyDoc_STRVAR(posix_strerror__doc__
,
6829 "strerror(code) -> string\n\n\
6830 Translate an error code to a message string.");
6833 posix_strerror(PyObject
*self
, PyObject
*args
)
6837 if (!PyArg_ParseTuple(args
, "i:strerror", &code
))
6839 message
= strerror(code
);
6840 if (message
== NULL
) {
6841 PyErr_SetString(PyExc_ValueError
,
6842 "strerror() argument out of range");
6845 return PyString_FromString(message
);
6849 #ifdef HAVE_SYS_WAIT_H
6852 PyDoc_STRVAR(posix_WCOREDUMP__doc__
,
6853 "WCOREDUMP(status) -> bool\n\n\
6854 Return True if the process returning 'status' was dumped to a core file.");
6857 posix_WCOREDUMP(PyObject
*self
, PyObject
*args
)
6860 WAIT_STATUS_INT(status
) = 0;
6862 if (!PyArg_ParseTuple(args
, "i:WCOREDUMP", &WAIT_STATUS_INT(status
)))
6865 return PyBool_FromLong(WCOREDUMP(status
));
6867 #endif /* WCOREDUMP */
6870 PyDoc_STRVAR(posix_WIFCONTINUED__doc__
,
6871 "WIFCONTINUED(status) -> bool\n\n\
6872 Return True if the process returning 'status' was continued from a\n\
6873 job control stop.");
6876 posix_WIFCONTINUED(PyObject
*self
, PyObject
*args
)
6879 WAIT_STATUS_INT(status
) = 0;
6881 if (!PyArg_ParseTuple(args
, "i:WCONTINUED", &WAIT_STATUS_INT(status
)))
6884 return PyBool_FromLong(WIFCONTINUED(status
));
6886 #endif /* WIFCONTINUED */
6889 PyDoc_STRVAR(posix_WIFSTOPPED__doc__
,
6890 "WIFSTOPPED(status) -> bool\n\n\
6891 Return True if the process returning 'status' was stopped.");
6894 posix_WIFSTOPPED(PyObject
*self
, PyObject
*args
)
6897 WAIT_STATUS_INT(status
) = 0;
6899 if (!PyArg_ParseTuple(args
, "i:WIFSTOPPED", &WAIT_STATUS_INT(status
)))
6902 return PyBool_FromLong(WIFSTOPPED(status
));
6904 #endif /* WIFSTOPPED */
6907 PyDoc_STRVAR(posix_WIFSIGNALED__doc__
,
6908 "WIFSIGNALED(status) -> bool\n\n\
6909 Return True if the process returning 'status' was terminated by a signal.");
6912 posix_WIFSIGNALED(PyObject
*self
, PyObject
*args
)
6915 WAIT_STATUS_INT(status
) = 0;
6917 if (!PyArg_ParseTuple(args
, "i:WIFSIGNALED", &WAIT_STATUS_INT(status
)))
6920 return PyBool_FromLong(WIFSIGNALED(status
));
6922 #endif /* WIFSIGNALED */
6925 PyDoc_STRVAR(posix_WIFEXITED__doc__
,
6926 "WIFEXITED(status) -> bool\n\n\
6927 Return true if the process returning 'status' exited using the exit()\n\
6931 posix_WIFEXITED(PyObject
*self
, PyObject
*args
)
6934 WAIT_STATUS_INT(status
) = 0;
6936 if (!PyArg_ParseTuple(args
, "i:WIFEXITED", &WAIT_STATUS_INT(status
)))
6939 return PyBool_FromLong(WIFEXITED(status
));
6941 #endif /* WIFEXITED */
6944 PyDoc_STRVAR(posix_WEXITSTATUS__doc__
,
6945 "WEXITSTATUS(status) -> integer\n\n\
6946 Return the process return code from 'status'.");
6949 posix_WEXITSTATUS(PyObject
*self
, PyObject
*args
)
6952 WAIT_STATUS_INT(status
) = 0;
6954 if (!PyArg_ParseTuple(args
, "i:WEXITSTATUS", &WAIT_STATUS_INT(status
)))
6957 return Py_BuildValue("i", WEXITSTATUS(status
));
6959 #endif /* WEXITSTATUS */
6962 PyDoc_STRVAR(posix_WTERMSIG__doc__
,
6963 "WTERMSIG(status) -> integer\n\n\
6964 Return the signal that terminated the process that provided the 'status'\n\
6968 posix_WTERMSIG(PyObject
*self
, PyObject
*args
)
6971 WAIT_STATUS_INT(status
) = 0;
6973 if (!PyArg_ParseTuple(args
, "i:WTERMSIG", &WAIT_STATUS_INT(status
)))
6976 return Py_BuildValue("i", WTERMSIG(status
));
6978 #endif /* WTERMSIG */
6981 PyDoc_STRVAR(posix_WSTOPSIG__doc__
,
6982 "WSTOPSIG(status) -> integer\n\n\
6983 Return the signal that stopped the process that provided\n\
6984 the 'status' value.");
6987 posix_WSTOPSIG(PyObject
*self
, PyObject
*args
)
6990 WAIT_STATUS_INT(status
) = 0;
6992 if (!PyArg_ParseTuple(args
, "i:WSTOPSIG", &WAIT_STATUS_INT(status
)))
6995 return Py_BuildValue("i", WSTOPSIG(status
));
6997 #endif /* WSTOPSIG */
6999 #endif /* HAVE_SYS_WAIT_H */
7002 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
7004 /* SCO OpenServer 5.0 and later requires _SVID3 before it reveals the
7005 needed definitions in sys/statvfs.h */
7008 #include <sys/statvfs.h>
7011 _pystatvfs_fromstructstatvfs(struct statvfs st
) {
7012 PyObject
*v
= PyStructSequence_New(&StatVFSResultType
);
7016 #if !defined(HAVE_LARGEFILE_SUPPORT)
7017 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
7018 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
7019 PyStructSequence_SET_ITEM(v
, 2, PyInt_FromLong((long) st
.f_blocks
));
7020 PyStructSequence_SET_ITEM(v
, 3, PyInt_FromLong((long) st
.f_bfree
));
7021 PyStructSequence_SET_ITEM(v
, 4, PyInt_FromLong((long) st
.f_bavail
));
7022 PyStructSequence_SET_ITEM(v
, 5, PyInt_FromLong((long) st
.f_files
));
7023 PyStructSequence_SET_ITEM(v
, 6, PyInt_FromLong((long) st
.f_ffree
));
7024 PyStructSequence_SET_ITEM(v
, 7, PyInt_FromLong((long) st
.f_favail
));
7025 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
7026 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
7028 PyStructSequence_SET_ITEM(v
, 0, PyInt_FromLong((long) st
.f_bsize
));
7029 PyStructSequence_SET_ITEM(v
, 1, PyInt_FromLong((long) st
.f_frsize
));
7030 PyStructSequence_SET_ITEM(v
, 2,
7031 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_blocks
));
7032 PyStructSequence_SET_ITEM(v
, 3,
7033 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bfree
));
7034 PyStructSequence_SET_ITEM(v
, 4,
7035 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_bavail
));
7036 PyStructSequence_SET_ITEM(v
, 5,
7037 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_files
));
7038 PyStructSequence_SET_ITEM(v
, 6,
7039 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_ffree
));
7040 PyStructSequence_SET_ITEM(v
, 7,
7041 PyLong_FromLongLong((PY_LONG_LONG
) st
.f_favail
));
7042 PyStructSequence_SET_ITEM(v
, 8, PyInt_FromLong((long) st
.f_flag
));
7043 PyStructSequence_SET_ITEM(v
, 9, PyInt_FromLong((long) st
.f_namemax
));
7049 PyDoc_STRVAR(posix_fstatvfs__doc__
,
7050 "fstatvfs(fd) -> statvfs result\n\n\
7051 Perform an fstatvfs system call on the given fd.");
7054 posix_fstatvfs(PyObject
*self
, PyObject
*args
)
7059 if (!PyArg_ParseTuple(args
, "i:fstatvfs", &fd
))
7061 Py_BEGIN_ALLOW_THREADS
7062 res
= fstatvfs(fd
, &st
);
7063 Py_END_ALLOW_THREADS
7065 return posix_error();
7067 return _pystatvfs_fromstructstatvfs(st
);
7069 #endif /* HAVE_FSTATVFS && HAVE_SYS_STATVFS_H */
7072 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
7073 #include <sys/statvfs.h>
7075 PyDoc_STRVAR(posix_statvfs__doc__
,
7076 "statvfs(path) -> statvfs result\n\n\
7077 Perform a statvfs system call on the given path.");
7080 posix_statvfs(PyObject
*self
, PyObject
*args
)
7085 if (!PyArg_ParseTuple(args
, "s:statvfs", &path
))
7087 Py_BEGIN_ALLOW_THREADS
7088 res
= statvfs(path
, &st
);
7089 Py_END_ALLOW_THREADS
7091 return posix_error_with_filename(path
);
7093 return _pystatvfs_fromstructstatvfs(st
);
7095 #endif /* HAVE_STATVFS */
7099 PyDoc_STRVAR(posix_tempnam__doc__
,
7100 "tempnam([dir[, prefix]]) -> string\n\n\
7101 Return a unique name for a temporary file.\n\
7102 The directory and a prefix may be specified as strings; they may be omitted\n\
7103 or None if not needed.");
7106 posix_tempnam(PyObject
*self
, PyObject
*args
)
7108 PyObject
*result
= NULL
;
7113 if (!PyArg_ParseTuple(args
, "|zz:tempnam", &dir
, &pfx
))
7116 if (PyErr_Warn(PyExc_RuntimeWarning
,
7117 "tempnam is a potential security risk to your program") < 0)
7121 name
= _tempnam(dir
, pfx
);
7123 name
= tempnam(dir
, pfx
);
7126 return PyErr_NoMemory();
7127 result
= PyString_FromString(name
);
7135 PyDoc_STRVAR(posix_tmpfile__doc__
,
7136 "tmpfile() -> file object\n\n\
7137 Create a temporary file with no directory entries.");
7140 posix_tmpfile(PyObject
*self
, PyObject
*noargs
)
7146 return posix_error();
7147 return PyFile_FromFile(fp
, "<tmpfile>", "w+b", fclose
);
7153 PyDoc_STRVAR(posix_tmpnam__doc__
,
7154 "tmpnam() -> string\n\n\
7155 Return a unique name for a temporary file.");
7158 posix_tmpnam(PyObject
*self
, PyObject
*noargs
)
7160 char buffer
[L_tmpnam
];
7163 if (PyErr_Warn(PyExc_RuntimeWarning
,
7164 "tmpnam is a potential security risk to your program") < 0)
7168 name
= tmpnam_r(buffer
);
7170 name
= tmpnam(buffer
);
7173 PyObject
*err
= Py_BuildValue("is", 0,
7175 "unexpected NULL from tmpnam_r"
7177 "unexpected NULL from tmpnam"
7180 PyErr_SetObject(PyExc_OSError
, err
);
7184 return PyString_FromString(buffer
);
7189 /* This is used for fpathconf(), pathconf(), confstr() and sysconf().
7190 * It maps strings representing configuration variable names to
7191 * integer values, allowing those functions to be called with the
7192 * magic names instead of polluting the module's namespace with tons of
7193 * rarely-used constants. There are three separate tables that use
7194 * these definitions.
7196 * This code is always included, even if none of the interfaces that
7197 * need it are included. The #if hackery needed to avoid it would be
7198 * sufficiently pervasive that it's not worth the loss of readability.
7206 conv_confname(PyObject
*arg
, int *valuep
, struct constdef
*table
,
7209 if (PyInt_Check(arg
)) {
7210 *valuep
= PyInt_AS_LONG(arg
);
7213 if (PyString_Check(arg
)) {
7214 /* look up the value in the table using a binary search */
7217 size_t hi
= tablesize
;
7219 char *confname
= PyString_AS_STRING(arg
);
7221 mid
= (lo
+ hi
) / 2;
7222 cmp
= strcmp(confname
, table
[mid
].name
);
7228 *valuep
= table
[mid
].value
;
7232 PyErr_SetString(PyExc_ValueError
, "unrecognized configuration name");
7235 PyErr_SetString(PyExc_TypeError
,
7236 "configuration names must be strings or integers");
7241 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
7242 static struct constdef posix_constants_pathconf
[] = {
7243 #ifdef _PC_ABI_AIO_XFER_MAX
7244 {"PC_ABI_AIO_XFER_MAX", _PC_ABI_AIO_XFER_MAX
},
7246 #ifdef _PC_ABI_ASYNC_IO
7247 {"PC_ABI_ASYNC_IO", _PC_ABI_ASYNC_IO
},
7250 {"PC_ASYNC_IO", _PC_ASYNC_IO
},
7252 #ifdef _PC_CHOWN_RESTRICTED
7253 {"PC_CHOWN_RESTRICTED", _PC_CHOWN_RESTRICTED
},
7255 #ifdef _PC_FILESIZEBITS
7256 {"PC_FILESIZEBITS", _PC_FILESIZEBITS
},
7259 {"PC_LAST", _PC_LAST
},
7262 {"PC_LINK_MAX", _PC_LINK_MAX
},
7264 #ifdef _PC_MAX_CANON
7265 {"PC_MAX_CANON", _PC_MAX_CANON
},
7267 #ifdef _PC_MAX_INPUT
7268 {"PC_MAX_INPUT", _PC_MAX_INPUT
},
7271 {"PC_NAME_MAX", _PC_NAME_MAX
},
7274 {"PC_NO_TRUNC", _PC_NO_TRUNC
},
7277 {"PC_PATH_MAX", _PC_PATH_MAX
},
7280 {"PC_PIPE_BUF", _PC_PIPE_BUF
},
7283 {"PC_PRIO_IO", _PC_PRIO_IO
},
7285 #ifdef _PC_SOCK_MAXBUF
7286 {"PC_SOCK_MAXBUF", _PC_SOCK_MAXBUF
},
7289 {"PC_SYNC_IO", _PC_SYNC_IO
},
7292 {"PC_VDISABLE", _PC_VDISABLE
},
7297 conv_path_confname(PyObject
*arg
, int *valuep
)
7299 return conv_confname(arg
, valuep
, posix_constants_pathconf
,
7300 sizeof(posix_constants_pathconf
)
7301 / sizeof(struct constdef
));
7305 #ifdef HAVE_FPATHCONF
7306 PyDoc_STRVAR(posix_fpathconf__doc__
,
7307 "fpathconf(fd, name) -> integer\n\n\
7308 Return the configuration limit name for the file descriptor fd.\n\
7309 If there is no limit, return -1.");
7312 posix_fpathconf(PyObject
*self
, PyObject
*args
)
7314 PyObject
*result
= NULL
;
7317 if (PyArg_ParseTuple(args
, "iO&:fpathconf", &fd
,
7318 conv_path_confname
, &name
)) {
7322 limit
= fpathconf(fd
, name
);
7323 if (limit
== -1 && errno
!= 0)
7326 result
= PyInt_FromLong(limit
);
7333 #ifdef HAVE_PATHCONF
7334 PyDoc_STRVAR(posix_pathconf__doc__
,
7335 "pathconf(path, name) -> integer\n\n\
7336 Return the configuration limit name for the file or directory path.\n\
7337 If there is no limit, return -1.");
7340 posix_pathconf(PyObject
*self
, PyObject
*args
)
7342 PyObject
*result
= NULL
;
7346 if (PyArg_ParseTuple(args
, "sO&:pathconf", &path
,
7347 conv_path_confname
, &name
)) {
7351 limit
= pathconf(path
, name
);
7352 if (limit
== -1 && errno
!= 0) {
7353 if (errno
== EINVAL
)
7354 /* could be a path or name problem */
7357 posix_error_with_filename(path
);
7360 result
= PyInt_FromLong(limit
);
7367 static struct constdef posix_constants_confstr
[] = {
7368 #ifdef _CS_ARCHITECTURE
7369 {"CS_ARCHITECTURE", _CS_ARCHITECTURE
},
7372 {"CS_HOSTNAME", _CS_HOSTNAME
},
7374 #ifdef _CS_HW_PROVIDER
7375 {"CS_HW_PROVIDER", _CS_HW_PROVIDER
},
7377 #ifdef _CS_HW_SERIAL
7378 {"CS_HW_SERIAL", _CS_HW_SERIAL
},
7380 #ifdef _CS_INITTAB_NAME
7381 {"CS_INITTAB_NAME", _CS_INITTAB_NAME
},
7383 #ifdef _CS_LFS64_CFLAGS
7384 {"CS_LFS64_CFLAGS", _CS_LFS64_CFLAGS
},
7386 #ifdef _CS_LFS64_LDFLAGS
7387 {"CS_LFS64_LDFLAGS", _CS_LFS64_LDFLAGS
},
7389 #ifdef _CS_LFS64_LIBS
7390 {"CS_LFS64_LIBS", _CS_LFS64_LIBS
},
7392 #ifdef _CS_LFS64_LINTFLAGS
7393 {"CS_LFS64_LINTFLAGS", _CS_LFS64_LINTFLAGS
},
7395 #ifdef _CS_LFS_CFLAGS
7396 {"CS_LFS_CFLAGS", _CS_LFS_CFLAGS
},
7398 #ifdef _CS_LFS_LDFLAGS
7399 {"CS_LFS_LDFLAGS", _CS_LFS_LDFLAGS
},
7402 {"CS_LFS_LIBS", _CS_LFS_LIBS
},
7404 #ifdef _CS_LFS_LINTFLAGS
7405 {"CS_LFS_LINTFLAGS", _CS_LFS_LINTFLAGS
},
7408 {"CS_MACHINE", _CS_MACHINE
},
7411 {"CS_PATH", _CS_PATH
},
7414 {"CS_RELEASE", _CS_RELEASE
},
7416 #ifdef _CS_SRPC_DOMAIN
7417 {"CS_SRPC_DOMAIN", _CS_SRPC_DOMAIN
},
7420 {"CS_SYSNAME", _CS_SYSNAME
},
7423 {"CS_VERSION", _CS_VERSION
},
7425 #ifdef _CS_XBS5_ILP32_OFF32_CFLAGS
7426 {"CS_XBS5_ILP32_OFF32_CFLAGS", _CS_XBS5_ILP32_OFF32_CFLAGS
},
7428 #ifdef _CS_XBS5_ILP32_OFF32_LDFLAGS
7429 {"CS_XBS5_ILP32_OFF32_LDFLAGS", _CS_XBS5_ILP32_OFF32_LDFLAGS
},
7431 #ifdef _CS_XBS5_ILP32_OFF32_LIBS
7432 {"CS_XBS5_ILP32_OFF32_LIBS", _CS_XBS5_ILP32_OFF32_LIBS
},
7434 #ifdef _CS_XBS5_ILP32_OFF32_LINTFLAGS
7435 {"CS_XBS5_ILP32_OFF32_LINTFLAGS", _CS_XBS5_ILP32_OFF32_LINTFLAGS
},
7437 #ifdef _CS_XBS5_ILP32_OFFBIG_CFLAGS
7438 {"CS_XBS5_ILP32_OFFBIG_CFLAGS", _CS_XBS5_ILP32_OFFBIG_CFLAGS
},
7440 #ifdef _CS_XBS5_ILP32_OFFBIG_LDFLAGS
7441 {"CS_XBS5_ILP32_OFFBIG_LDFLAGS", _CS_XBS5_ILP32_OFFBIG_LDFLAGS
},
7443 #ifdef _CS_XBS5_ILP32_OFFBIG_LIBS
7444 {"CS_XBS5_ILP32_OFFBIG_LIBS", _CS_XBS5_ILP32_OFFBIG_LIBS
},
7446 #ifdef _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
7447 {"CS_XBS5_ILP32_OFFBIG_LINTFLAGS", _CS_XBS5_ILP32_OFFBIG_LINTFLAGS
},
7449 #ifdef _CS_XBS5_LP64_OFF64_CFLAGS
7450 {"CS_XBS5_LP64_OFF64_CFLAGS", _CS_XBS5_LP64_OFF64_CFLAGS
},
7452 #ifdef _CS_XBS5_LP64_OFF64_LDFLAGS
7453 {"CS_XBS5_LP64_OFF64_LDFLAGS", _CS_XBS5_LP64_OFF64_LDFLAGS
},
7455 #ifdef _CS_XBS5_LP64_OFF64_LIBS
7456 {"CS_XBS5_LP64_OFF64_LIBS", _CS_XBS5_LP64_OFF64_LIBS
},
7458 #ifdef _CS_XBS5_LP64_OFF64_LINTFLAGS
7459 {"CS_XBS5_LP64_OFF64_LINTFLAGS", _CS_XBS5_LP64_OFF64_LINTFLAGS
},
7461 #ifdef _CS_XBS5_LPBIG_OFFBIG_CFLAGS
7462 {"CS_XBS5_LPBIG_OFFBIG_CFLAGS", _CS_XBS5_LPBIG_OFFBIG_CFLAGS
},
7464 #ifdef _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
7465 {"CS_XBS5_LPBIG_OFFBIG_LDFLAGS", _CS_XBS5_LPBIG_OFFBIG_LDFLAGS
},
7467 #ifdef _CS_XBS5_LPBIG_OFFBIG_LIBS
7468 {"CS_XBS5_LPBIG_OFFBIG_LIBS", _CS_XBS5_LPBIG_OFFBIG_LIBS
},
7470 #ifdef _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
7471 {"CS_XBS5_LPBIG_OFFBIG_LINTFLAGS", _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS
},
7473 #ifdef _MIPS_CS_AVAIL_PROCESSORS
7474 {"MIPS_CS_AVAIL_PROCESSORS", _MIPS_CS_AVAIL_PROCESSORS
},
7476 #ifdef _MIPS_CS_BASE
7477 {"MIPS_CS_BASE", _MIPS_CS_BASE
},
7479 #ifdef _MIPS_CS_HOSTID
7480 {"MIPS_CS_HOSTID", _MIPS_CS_HOSTID
},
7482 #ifdef _MIPS_CS_HW_NAME
7483 {"MIPS_CS_HW_NAME", _MIPS_CS_HW_NAME
},
7485 #ifdef _MIPS_CS_NUM_PROCESSORS
7486 {"MIPS_CS_NUM_PROCESSORS", _MIPS_CS_NUM_PROCESSORS
},
7488 #ifdef _MIPS_CS_OSREL_MAJ
7489 {"MIPS_CS_OSREL_MAJ", _MIPS_CS_OSREL_MAJ
},
7491 #ifdef _MIPS_CS_OSREL_MIN
7492 {"MIPS_CS_OSREL_MIN", _MIPS_CS_OSREL_MIN
},
7494 #ifdef _MIPS_CS_OSREL_PATCH
7495 {"MIPS_CS_OSREL_PATCH", _MIPS_CS_OSREL_PATCH
},
7497 #ifdef _MIPS_CS_OS_NAME
7498 {"MIPS_CS_OS_NAME", _MIPS_CS_OS_NAME
},
7500 #ifdef _MIPS_CS_OS_PROVIDER
7501 {"MIPS_CS_OS_PROVIDER", _MIPS_CS_OS_PROVIDER
},
7503 #ifdef _MIPS_CS_PROCESSORS
7504 {"MIPS_CS_PROCESSORS", _MIPS_CS_PROCESSORS
},
7506 #ifdef _MIPS_CS_SERIAL
7507 {"MIPS_CS_SERIAL", _MIPS_CS_SERIAL
},
7509 #ifdef _MIPS_CS_VENDOR
7510 {"MIPS_CS_VENDOR", _MIPS_CS_VENDOR
},
7515 conv_confstr_confname(PyObject
*arg
, int *valuep
)
7517 return conv_confname(arg
, valuep
, posix_constants_confstr
,
7518 sizeof(posix_constants_confstr
)
7519 / sizeof(struct constdef
));
7522 PyDoc_STRVAR(posix_confstr__doc__
,
7523 "confstr(name) -> string\n\n\
7524 Return a string-valued system configuration variable.");
7527 posix_confstr(PyObject
*self
, PyObject
*args
)
7529 PyObject
*result
= NULL
;
7533 if (PyArg_ParseTuple(args
, "O&:confstr", conv_confstr_confname
, &name
)) {
7537 len
= confstr(name
, buffer
, sizeof(buffer
));
7548 if ((unsigned int)len
>= sizeof(buffer
)) {
7549 result
= PyString_FromStringAndSize(NULL
, len
-1);
7551 confstr(name
, PyString_AS_STRING(result
), len
);
7554 result
= PyString_FromStringAndSize(buffer
, len
-1);
7563 static struct constdef posix_constants_sysconf
[] = {
7564 #ifdef _SC_2_CHAR_TERM
7565 {"SC_2_CHAR_TERM", _SC_2_CHAR_TERM
},
7568 {"SC_2_C_BIND", _SC_2_C_BIND
},
7571 {"SC_2_C_DEV", _SC_2_C_DEV
},
7573 #ifdef _SC_2_C_VERSION
7574 {"SC_2_C_VERSION", _SC_2_C_VERSION
},
7576 #ifdef _SC_2_FORT_DEV
7577 {"SC_2_FORT_DEV", _SC_2_FORT_DEV
},
7579 #ifdef _SC_2_FORT_RUN
7580 {"SC_2_FORT_RUN", _SC_2_FORT_RUN
},
7582 #ifdef _SC_2_LOCALEDEF
7583 {"SC_2_LOCALEDEF", _SC_2_LOCALEDEF
},
7586 {"SC_2_SW_DEV", _SC_2_SW_DEV
},
7589 {"SC_2_UPE", _SC_2_UPE
},
7591 #ifdef _SC_2_VERSION
7592 {"SC_2_VERSION", _SC_2_VERSION
},
7594 #ifdef _SC_ABI_ASYNCHRONOUS_IO
7595 {"SC_ABI_ASYNCHRONOUS_IO", _SC_ABI_ASYNCHRONOUS_IO
},
7598 {"SC_ACL", _SC_ACL
},
7600 #ifdef _SC_AIO_LISTIO_MAX
7601 {"SC_AIO_LISTIO_MAX", _SC_AIO_LISTIO_MAX
},
7604 {"SC_AIO_MAX", _SC_AIO_MAX
},
7606 #ifdef _SC_AIO_PRIO_DELTA_MAX
7607 {"SC_AIO_PRIO_DELTA_MAX", _SC_AIO_PRIO_DELTA_MAX
},
7610 {"SC_ARG_MAX", _SC_ARG_MAX
},
7612 #ifdef _SC_ASYNCHRONOUS_IO
7613 {"SC_ASYNCHRONOUS_IO", _SC_ASYNCHRONOUS_IO
},
7615 #ifdef _SC_ATEXIT_MAX
7616 {"SC_ATEXIT_MAX", _SC_ATEXIT_MAX
},
7619 {"SC_AUDIT", _SC_AUDIT
},
7621 #ifdef _SC_AVPHYS_PAGES
7622 {"SC_AVPHYS_PAGES", _SC_AVPHYS_PAGES
},
7624 #ifdef _SC_BC_BASE_MAX
7625 {"SC_BC_BASE_MAX", _SC_BC_BASE_MAX
},
7627 #ifdef _SC_BC_DIM_MAX
7628 {"SC_BC_DIM_MAX", _SC_BC_DIM_MAX
},
7630 #ifdef _SC_BC_SCALE_MAX
7631 {"SC_BC_SCALE_MAX", _SC_BC_SCALE_MAX
},
7633 #ifdef _SC_BC_STRING_MAX
7634 {"SC_BC_STRING_MAX", _SC_BC_STRING_MAX
},
7637 {"SC_CAP", _SC_CAP
},
7639 #ifdef _SC_CHARCLASS_NAME_MAX
7640 {"SC_CHARCLASS_NAME_MAX", _SC_CHARCLASS_NAME_MAX
},
7643 {"SC_CHAR_BIT", _SC_CHAR_BIT
},
7646 {"SC_CHAR_MAX", _SC_CHAR_MAX
},
7649 {"SC_CHAR_MIN", _SC_CHAR_MIN
},
7651 #ifdef _SC_CHILD_MAX
7652 {"SC_CHILD_MAX", _SC_CHILD_MAX
},
7655 {"SC_CLK_TCK", _SC_CLK_TCK
},
7657 #ifdef _SC_COHER_BLKSZ
7658 {"SC_COHER_BLKSZ", _SC_COHER_BLKSZ
},
7660 #ifdef _SC_COLL_WEIGHTS_MAX
7661 {"SC_COLL_WEIGHTS_MAX", _SC_COLL_WEIGHTS_MAX
},
7663 #ifdef _SC_DCACHE_ASSOC
7664 {"SC_DCACHE_ASSOC", _SC_DCACHE_ASSOC
},
7666 #ifdef _SC_DCACHE_BLKSZ
7667 {"SC_DCACHE_BLKSZ", _SC_DCACHE_BLKSZ
},
7669 #ifdef _SC_DCACHE_LINESZ
7670 {"SC_DCACHE_LINESZ", _SC_DCACHE_LINESZ
},
7672 #ifdef _SC_DCACHE_SZ
7673 {"SC_DCACHE_SZ", _SC_DCACHE_SZ
},
7675 #ifdef _SC_DCACHE_TBLKSZ
7676 {"SC_DCACHE_TBLKSZ", _SC_DCACHE_TBLKSZ
},
7678 #ifdef _SC_DELAYTIMER_MAX
7679 {"SC_DELAYTIMER_MAX", _SC_DELAYTIMER_MAX
},
7681 #ifdef _SC_EQUIV_CLASS_MAX
7682 {"SC_EQUIV_CLASS_MAX", _SC_EQUIV_CLASS_MAX
},
7684 #ifdef _SC_EXPR_NEST_MAX
7685 {"SC_EXPR_NEST_MAX", _SC_EXPR_NEST_MAX
},
7688 {"SC_FSYNC", _SC_FSYNC
},
7690 #ifdef _SC_GETGR_R_SIZE_MAX
7691 {"SC_GETGR_R_SIZE_MAX", _SC_GETGR_R_SIZE_MAX
},
7693 #ifdef _SC_GETPW_R_SIZE_MAX
7694 {"SC_GETPW_R_SIZE_MAX", _SC_GETPW_R_SIZE_MAX
},
7696 #ifdef _SC_ICACHE_ASSOC
7697 {"SC_ICACHE_ASSOC", _SC_ICACHE_ASSOC
},
7699 #ifdef _SC_ICACHE_BLKSZ
7700 {"SC_ICACHE_BLKSZ", _SC_ICACHE_BLKSZ
},
7702 #ifdef _SC_ICACHE_LINESZ
7703 {"SC_ICACHE_LINESZ", _SC_ICACHE_LINESZ
},
7705 #ifdef _SC_ICACHE_SZ
7706 {"SC_ICACHE_SZ", _SC_ICACHE_SZ
},
7709 {"SC_INF", _SC_INF
},
7712 {"SC_INT_MAX", _SC_INT_MAX
},
7715 {"SC_INT_MIN", _SC_INT_MIN
},
7718 {"SC_IOV_MAX", _SC_IOV_MAX
},
7720 #ifdef _SC_IP_SECOPTS
7721 {"SC_IP_SECOPTS", _SC_IP_SECOPTS
},
7723 #ifdef _SC_JOB_CONTROL
7724 {"SC_JOB_CONTROL", _SC_JOB_CONTROL
},
7726 #ifdef _SC_KERN_POINTERS
7727 {"SC_KERN_POINTERS", _SC_KERN_POINTERS
},
7730 {"SC_KERN_SIM", _SC_KERN_SIM
},
7733 {"SC_LINE_MAX", _SC_LINE_MAX
},
7735 #ifdef _SC_LOGIN_NAME_MAX
7736 {"SC_LOGIN_NAME_MAX", _SC_LOGIN_NAME_MAX
},
7738 #ifdef _SC_LOGNAME_MAX
7739 {"SC_LOGNAME_MAX", _SC_LOGNAME_MAX
},
7742 {"SC_LONG_BIT", _SC_LONG_BIT
},
7745 {"SC_MAC", _SC_MAC
},
7747 #ifdef _SC_MAPPED_FILES
7748 {"SC_MAPPED_FILES", _SC_MAPPED_FILES
},
7751 {"SC_MAXPID", _SC_MAXPID
},
7753 #ifdef _SC_MB_LEN_MAX
7754 {"SC_MB_LEN_MAX", _SC_MB_LEN_MAX
},
7757 {"SC_MEMLOCK", _SC_MEMLOCK
},
7759 #ifdef _SC_MEMLOCK_RANGE
7760 {"SC_MEMLOCK_RANGE", _SC_MEMLOCK_RANGE
},
7762 #ifdef _SC_MEMORY_PROTECTION
7763 {"SC_MEMORY_PROTECTION", _SC_MEMORY_PROTECTION
},
7765 #ifdef _SC_MESSAGE_PASSING
7766 {"SC_MESSAGE_PASSING", _SC_MESSAGE_PASSING
},
7768 #ifdef _SC_MMAP_FIXED_ALIGNMENT
7769 {"SC_MMAP_FIXED_ALIGNMENT", _SC_MMAP_FIXED_ALIGNMENT
},
7771 #ifdef _SC_MQ_OPEN_MAX
7772 {"SC_MQ_OPEN_MAX", _SC_MQ_OPEN_MAX
},
7774 #ifdef _SC_MQ_PRIO_MAX
7775 {"SC_MQ_PRIO_MAX", _SC_MQ_PRIO_MAX
},
7777 #ifdef _SC_NACLS_MAX
7778 {"SC_NACLS_MAX", _SC_NACLS_MAX
},
7780 #ifdef _SC_NGROUPS_MAX
7781 {"SC_NGROUPS_MAX", _SC_NGROUPS_MAX
},
7783 #ifdef _SC_NL_ARGMAX
7784 {"SC_NL_ARGMAX", _SC_NL_ARGMAX
},
7786 #ifdef _SC_NL_LANGMAX
7787 {"SC_NL_LANGMAX", _SC_NL_LANGMAX
},
7789 #ifdef _SC_NL_MSGMAX
7790 {"SC_NL_MSGMAX", _SC_NL_MSGMAX
},
7793 {"SC_NL_NMAX", _SC_NL_NMAX
},
7795 #ifdef _SC_NL_SETMAX
7796 {"SC_NL_SETMAX", _SC_NL_SETMAX
},
7798 #ifdef _SC_NL_TEXTMAX
7799 {"SC_NL_TEXTMAX", _SC_NL_TEXTMAX
},
7801 #ifdef _SC_NPROCESSORS_CONF
7802 {"SC_NPROCESSORS_CONF", _SC_NPROCESSORS_CONF
},
7804 #ifdef _SC_NPROCESSORS_ONLN
7805 {"SC_NPROCESSORS_ONLN", _SC_NPROCESSORS_ONLN
},
7807 #ifdef _SC_NPROC_CONF
7808 {"SC_NPROC_CONF", _SC_NPROC_CONF
},
7810 #ifdef _SC_NPROC_ONLN
7811 {"SC_NPROC_ONLN", _SC_NPROC_ONLN
},
7814 {"SC_NZERO", _SC_NZERO
},
7817 {"SC_OPEN_MAX", _SC_OPEN_MAX
},
7820 {"SC_PAGESIZE", _SC_PAGESIZE
},
7822 #ifdef _SC_PAGE_SIZE
7823 {"SC_PAGE_SIZE", _SC_PAGE_SIZE
},
7826 {"SC_PASS_MAX", _SC_PASS_MAX
},
7828 #ifdef _SC_PHYS_PAGES
7829 {"SC_PHYS_PAGES", _SC_PHYS_PAGES
},
7832 {"SC_PII", _SC_PII
},
7834 #ifdef _SC_PII_INTERNET
7835 {"SC_PII_INTERNET", _SC_PII_INTERNET
},
7837 #ifdef _SC_PII_INTERNET_DGRAM
7838 {"SC_PII_INTERNET_DGRAM", _SC_PII_INTERNET_DGRAM
},
7840 #ifdef _SC_PII_INTERNET_STREAM
7841 {"SC_PII_INTERNET_STREAM", _SC_PII_INTERNET_STREAM
},
7844 {"SC_PII_OSI", _SC_PII_OSI
},
7846 #ifdef _SC_PII_OSI_CLTS
7847 {"SC_PII_OSI_CLTS", _SC_PII_OSI_CLTS
},
7849 #ifdef _SC_PII_OSI_COTS
7850 {"SC_PII_OSI_COTS", _SC_PII_OSI_COTS
},
7852 #ifdef _SC_PII_OSI_M
7853 {"SC_PII_OSI_M", _SC_PII_OSI_M
},
7855 #ifdef _SC_PII_SOCKET
7856 {"SC_PII_SOCKET", _SC_PII_SOCKET
},
7859 {"SC_PII_XTI", _SC_PII_XTI
},
7862 {"SC_POLL", _SC_POLL
},
7864 #ifdef _SC_PRIORITIZED_IO
7865 {"SC_PRIORITIZED_IO", _SC_PRIORITIZED_IO
},
7867 #ifdef _SC_PRIORITY_SCHEDULING
7868 {"SC_PRIORITY_SCHEDULING", _SC_PRIORITY_SCHEDULING
},
7870 #ifdef _SC_REALTIME_SIGNALS
7871 {"SC_REALTIME_SIGNALS", _SC_REALTIME_SIGNALS
},
7873 #ifdef _SC_RE_DUP_MAX
7874 {"SC_RE_DUP_MAX", _SC_RE_DUP_MAX
},
7876 #ifdef _SC_RTSIG_MAX
7877 {"SC_RTSIG_MAX", _SC_RTSIG_MAX
},
7879 #ifdef _SC_SAVED_IDS
7880 {"SC_SAVED_IDS", _SC_SAVED_IDS
},
7882 #ifdef _SC_SCHAR_MAX
7883 {"SC_SCHAR_MAX", _SC_SCHAR_MAX
},
7885 #ifdef _SC_SCHAR_MIN
7886 {"SC_SCHAR_MIN", _SC_SCHAR_MIN
},
7889 {"SC_SELECT", _SC_SELECT
},
7891 #ifdef _SC_SEMAPHORES
7892 {"SC_SEMAPHORES", _SC_SEMAPHORES
},
7894 #ifdef _SC_SEM_NSEMS_MAX
7895 {"SC_SEM_NSEMS_MAX", _SC_SEM_NSEMS_MAX
},
7897 #ifdef _SC_SEM_VALUE_MAX
7898 {"SC_SEM_VALUE_MAX", _SC_SEM_VALUE_MAX
},
7900 #ifdef _SC_SHARED_MEMORY_OBJECTS
7901 {"SC_SHARED_MEMORY_OBJECTS", _SC_SHARED_MEMORY_OBJECTS
},
7904 {"SC_SHRT_MAX", _SC_SHRT_MAX
},
7907 {"SC_SHRT_MIN", _SC_SHRT_MIN
},
7909 #ifdef _SC_SIGQUEUE_MAX
7910 {"SC_SIGQUEUE_MAX", _SC_SIGQUEUE_MAX
},
7912 #ifdef _SC_SIGRT_MAX
7913 {"SC_SIGRT_MAX", _SC_SIGRT_MAX
},
7915 #ifdef _SC_SIGRT_MIN
7916 {"SC_SIGRT_MIN", _SC_SIGRT_MIN
},
7918 #ifdef _SC_SOFTPOWER
7919 {"SC_SOFTPOWER", _SC_SOFTPOWER
},
7921 #ifdef _SC_SPLIT_CACHE
7922 {"SC_SPLIT_CACHE", _SC_SPLIT_CACHE
},
7924 #ifdef _SC_SSIZE_MAX
7925 {"SC_SSIZE_MAX", _SC_SSIZE_MAX
},
7927 #ifdef _SC_STACK_PROT
7928 {"SC_STACK_PROT", _SC_STACK_PROT
},
7930 #ifdef _SC_STREAM_MAX
7931 {"SC_STREAM_MAX", _SC_STREAM_MAX
},
7933 #ifdef _SC_SYNCHRONIZED_IO
7934 {"SC_SYNCHRONIZED_IO", _SC_SYNCHRONIZED_IO
},
7937 {"SC_THREADS", _SC_THREADS
},
7939 #ifdef _SC_THREAD_ATTR_STACKADDR
7940 {"SC_THREAD_ATTR_STACKADDR", _SC_THREAD_ATTR_STACKADDR
},
7942 #ifdef _SC_THREAD_ATTR_STACKSIZE
7943 {"SC_THREAD_ATTR_STACKSIZE", _SC_THREAD_ATTR_STACKSIZE
},
7945 #ifdef _SC_THREAD_DESTRUCTOR_ITERATIONS
7946 {"SC_THREAD_DESTRUCTOR_ITERATIONS", _SC_THREAD_DESTRUCTOR_ITERATIONS
},
7948 #ifdef _SC_THREAD_KEYS_MAX
7949 {"SC_THREAD_KEYS_MAX", _SC_THREAD_KEYS_MAX
},
7951 #ifdef _SC_THREAD_PRIORITY_SCHEDULING
7952 {"SC_THREAD_PRIORITY_SCHEDULING", _SC_THREAD_PRIORITY_SCHEDULING
},
7954 #ifdef _SC_THREAD_PRIO_INHERIT
7955 {"SC_THREAD_PRIO_INHERIT", _SC_THREAD_PRIO_INHERIT
},
7957 #ifdef _SC_THREAD_PRIO_PROTECT
7958 {"SC_THREAD_PRIO_PROTECT", _SC_THREAD_PRIO_PROTECT
},
7960 #ifdef _SC_THREAD_PROCESS_SHARED
7961 {"SC_THREAD_PROCESS_SHARED", _SC_THREAD_PROCESS_SHARED
},
7963 #ifdef _SC_THREAD_SAFE_FUNCTIONS
7964 {"SC_THREAD_SAFE_FUNCTIONS", _SC_THREAD_SAFE_FUNCTIONS
},
7966 #ifdef _SC_THREAD_STACK_MIN
7967 {"SC_THREAD_STACK_MIN", _SC_THREAD_STACK_MIN
},
7969 #ifdef _SC_THREAD_THREADS_MAX
7970 {"SC_THREAD_THREADS_MAX", _SC_THREAD_THREADS_MAX
},
7973 {"SC_TIMERS", _SC_TIMERS
},
7975 #ifdef _SC_TIMER_MAX
7976 {"SC_TIMER_MAX", _SC_TIMER_MAX
},
7978 #ifdef _SC_TTY_NAME_MAX
7979 {"SC_TTY_NAME_MAX", _SC_TTY_NAME_MAX
},
7981 #ifdef _SC_TZNAME_MAX
7982 {"SC_TZNAME_MAX", _SC_TZNAME_MAX
},
7984 #ifdef _SC_T_IOV_MAX
7985 {"SC_T_IOV_MAX", _SC_T_IOV_MAX
},
7987 #ifdef _SC_UCHAR_MAX
7988 {"SC_UCHAR_MAX", _SC_UCHAR_MAX
},
7991 {"SC_UINT_MAX", _SC_UINT_MAX
},
7993 #ifdef _SC_UIO_MAXIOV
7994 {"SC_UIO_MAXIOV", _SC_UIO_MAXIOV
},
7996 #ifdef _SC_ULONG_MAX
7997 {"SC_ULONG_MAX", _SC_ULONG_MAX
},
7999 #ifdef _SC_USHRT_MAX
8000 {"SC_USHRT_MAX", _SC_USHRT_MAX
},
8003 {"SC_VERSION", _SC_VERSION
},
8006 {"SC_WORD_BIT", _SC_WORD_BIT
},
8008 #ifdef _SC_XBS5_ILP32_OFF32
8009 {"SC_XBS5_ILP32_OFF32", _SC_XBS5_ILP32_OFF32
},
8011 #ifdef _SC_XBS5_ILP32_OFFBIG
8012 {"SC_XBS5_ILP32_OFFBIG", _SC_XBS5_ILP32_OFFBIG
},
8014 #ifdef _SC_XBS5_LP64_OFF64
8015 {"SC_XBS5_LP64_OFF64", _SC_XBS5_LP64_OFF64
},
8017 #ifdef _SC_XBS5_LPBIG_OFFBIG
8018 {"SC_XBS5_LPBIG_OFFBIG", _SC_XBS5_LPBIG_OFFBIG
},
8020 #ifdef _SC_XOPEN_CRYPT
8021 {"SC_XOPEN_CRYPT", _SC_XOPEN_CRYPT
},
8023 #ifdef _SC_XOPEN_ENH_I18N
8024 {"SC_XOPEN_ENH_I18N", _SC_XOPEN_ENH_I18N
},
8026 #ifdef _SC_XOPEN_LEGACY
8027 {"SC_XOPEN_LEGACY", _SC_XOPEN_LEGACY
},
8029 #ifdef _SC_XOPEN_REALTIME
8030 {"SC_XOPEN_REALTIME", _SC_XOPEN_REALTIME
},
8032 #ifdef _SC_XOPEN_REALTIME_THREADS
8033 {"SC_XOPEN_REALTIME_THREADS", _SC_XOPEN_REALTIME_THREADS
},
8035 #ifdef _SC_XOPEN_SHM
8036 {"SC_XOPEN_SHM", _SC_XOPEN_SHM
},
8038 #ifdef _SC_XOPEN_UNIX
8039 {"SC_XOPEN_UNIX", _SC_XOPEN_UNIX
},
8041 #ifdef _SC_XOPEN_VERSION
8042 {"SC_XOPEN_VERSION", _SC_XOPEN_VERSION
},
8044 #ifdef _SC_XOPEN_XCU_VERSION
8045 {"SC_XOPEN_XCU_VERSION", _SC_XOPEN_XCU_VERSION
},
8047 #ifdef _SC_XOPEN_XPG2
8048 {"SC_XOPEN_XPG2", _SC_XOPEN_XPG2
},
8050 #ifdef _SC_XOPEN_XPG3
8051 {"SC_XOPEN_XPG3", _SC_XOPEN_XPG3
},
8053 #ifdef _SC_XOPEN_XPG4
8054 {"SC_XOPEN_XPG4", _SC_XOPEN_XPG4
},
8059 conv_sysconf_confname(PyObject
*arg
, int *valuep
)
8061 return conv_confname(arg
, valuep
, posix_constants_sysconf
,
8062 sizeof(posix_constants_sysconf
)
8063 / sizeof(struct constdef
));
8066 PyDoc_STRVAR(posix_sysconf__doc__
,
8067 "sysconf(name) -> integer\n\n\
8068 Return an integer-valued system configuration variable.");
8071 posix_sysconf(PyObject
*self
, PyObject
*args
)
8073 PyObject
*result
= NULL
;
8076 if (PyArg_ParseTuple(args
, "O&:sysconf", conv_sysconf_confname
, &name
)) {
8080 value
= sysconf(name
);
8081 if (value
== -1 && errno
!= 0)
8084 result
= PyInt_FromLong(value
);
8091 /* This code is used to ensure that the tables of configuration value names
8092 * are in sorted order as required by conv_confname(), and also to build the
8093 * the exported dictionaries that are used to publish information about the
8094 * names available on the host platform.
8096 * Sorting the table at runtime ensures that the table is properly ordered
8097 * when used, even for platforms we're not able to test on. It also makes
8098 * it easier to add additional entries to the tables.
8102 cmp_constdefs(const void *v1
, const void *v2
)
8104 const struct constdef
*c1
=
8105 (const struct constdef
*) v1
;
8106 const struct constdef
*c2
=
8107 (const struct constdef
*) v2
;
8109 return strcmp(c1
->name
, c2
->name
);
8113 setup_confname_table(struct constdef
*table
, size_t tablesize
,
8114 char *tablename
, PyObject
*module
)
8119 qsort(table
, tablesize
, sizeof(struct constdef
), cmp_constdefs
);
8124 for (i
=0; i
< tablesize
; ++i
) {
8125 PyObject
*o
= PyInt_FromLong(table
[i
].value
);
8126 if (o
== NULL
|| PyDict_SetItemString(d
, table
[i
].name
, o
) == -1) {
8133 return PyModule_AddObject(module
, tablename
, d
);
8136 /* Return -1 on failure, 0 on success. */
8138 setup_confname_tables(PyObject
*module
)
8140 #if defined(HAVE_FPATHCONF) || defined(HAVE_PATHCONF)
8141 if (setup_confname_table(posix_constants_pathconf
,
8142 sizeof(posix_constants_pathconf
)
8143 / sizeof(struct constdef
),
8144 "pathconf_names", module
))
8148 if (setup_confname_table(posix_constants_confstr
,
8149 sizeof(posix_constants_confstr
)
8150 / sizeof(struct constdef
),
8151 "confstr_names", module
))
8155 if (setup_confname_table(posix_constants_sysconf
,
8156 sizeof(posix_constants_sysconf
)
8157 / sizeof(struct constdef
),
8158 "sysconf_names", module
))
8165 PyDoc_STRVAR(posix_abort__doc__
,
8166 "abort() -> does not return!\n\n\
8167 Abort the interpreter immediately. This 'dumps core' or otherwise fails\n\
8168 in the hardest way possible on the hosting operating system.");
8171 posix_abort(PyObject
*self
, PyObject
*noargs
)
8175 Py_FatalError("abort() called from Python code didn't abort!");
8180 PyDoc_STRVAR(win32_startfile__doc__
,
8181 "startfile(filepath [, operation]) - Start a file with its associated\n\
8184 When \"operation\" is not specified or \"open\", this acts like\n\
8185 double-clicking the file in Explorer, or giving the file name as an\n\
8186 argument to the DOS \"start\" command: the file is opened with whatever\n\
8187 application (if any) its extension is associated.\n\
8188 When another \"operation\" is given, it specifies what should be done with\n\
8189 the file. A typical operation is \"print\".\n\
8191 startfile returns as soon as the associated application is launched.\n\
8192 There is no option to wait for the application to close, and no way\n\
8193 to retrieve the application's exit status.\n\
8195 The filepath is relative to the current directory. If you want to use\n\
8196 an absolute path, make sure the first character is not a slash (\"/\");\n\
8197 the underlying Win32 ShellExecute function doesn't work if it is.");
8200 win32_startfile(PyObject
*self
, PyObject
*args
)
8203 char *operation
= NULL
;
8206 PyObject
*unipath
, *woperation
= NULL
;
8207 if (!PyArg_ParseTuple(args
, "U|s:startfile",
8208 &unipath
, &operation
)) {
8214 woperation
= PyUnicode_DecodeASCII(operation
,
8215 strlen(operation
), NULL
);
8223 Py_BEGIN_ALLOW_THREADS
8224 rc
= ShellExecuteW((HWND
)0, woperation
? PyUnicode_AS_UNICODE(woperation
) : 0,
8225 PyUnicode_AS_UNICODE(unipath
),
8226 NULL
, NULL
, SW_SHOWNORMAL
);
8227 Py_END_ALLOW_THREADS
8229 Py_XDECREF(woperation
);
8230 if (rc
<= (HINSTANCE
)32) {
8231 PyObject
*errval
= win32_error_unicode("startfile",
8232 PyUnicode_AS_UNICODE(unipath
));
8239 if (!PyArg_ParseTuple(args
, "et|s:startfile",
8240 Py_FileSystemDefaultEncoding
, &filepath
,
8243 Py_BEGIN_ALLOW_THREADS
8244 rc
= ShellExecute((HWND
)0, operation
, filepath
,
8245 NULL
, NULL
, SW_SHOWNORMAL
);
8246 Py_END_ALLOW_THREADS
8247 if (rc
<= (HINSTANCE
)32) {
8248 PyObject
*errval
= win32_error("startfile", filepath
);
8249 PyMem_Free(filepath
);
8252 PyMem_Free(filepath
);
8256 #endif /* MS_WINDOWS */
8258 #ifdef HAVE_GETLOADAVG
8259 PyDoc_STRVAR(posix_getloadavg__doc__
,
8260 "getloadavg() -> (float, float, float)\n\n\
8261 Return the number of processes in the system run queue averaged over\n\
8262 the last 1, 5, and 15 minutes or raises OSError if the load average\n\
8266 posix_getloadavg(PyObject
*self
, PyObject
*noargs
)
8269 if (getloadavg(loadavg
, 3)!=3) {
8270 PyErr_SetString(PyExc_OSError
, "Load averages are unobtainable");
8273 return Py_BuildValue("ddd", loadavg
[0], loadavg
[1], loadavg
[2]);
8279 PyDoc_STRVAR(win32_urandom__doc__
,
8280 "urandom(n) -> str\n\n\
8281 Return a string of n random bytes suitable for cryptographic use.");
8283 typedef BOOL (WINAPI
*CRYPTACQUIRECONTEXTA
)(HCRYPTPROV
*phProv
,\
8284 LPCSTR pszContainer
, LPCSTR pszProvider
, DWORD dwProvType
,\
8286 typedef BOOL (WINAPI
*CRYPTGENRANDOM
)(HCRYPTPROV hProv
, DWORD dwLen
,\
8289 static CRYPTGENRANDOM pCryptGenRandom
= NULL
;
8290 /* This handle is never explicitly released. Instead, the operating
8291 system will release it when the process terminates. */
8292 static HCRYPTPROV hCryptProv
= 0;
8295 win32_urandom(PyObject
*self
, PyObject
*args
)
8300 /* Read arguments */
8301 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8304 return PyErr_Format(PyExc_ValueError
,
8305 "negative argument not allowed");
8307 if (hCryptProv
== 0) {
8308 HINSTANCE hAdvAPI32
= NULL
;
8309 CRYPTACQUIRECONTEXTA pCryptAcquireContext
= NULL
;
8311 /* Obtain handle to the DLL containing CryptoAPI
8312 This should not fail */
8313 hAdvAPI32
= GetModuleHandle("advapi32.dll");
8314 if(hAdvAPI32
== NULL
)
8315 return win32_error("GetModuleHandle", NULL
);
8317 /* Obtain pointers to the CryptoAPI functions
8318 This will fail on some early versions of Win95 */
8319 pCryptAcquireContext
= (CRYPTACQUIRECONTEXTA
)GetProcAddress(
8321 "CryptAcquireContextA");
8322 if (pCryptAcquireContext
== NULL
)
8323 return PyErr_Format(PyExc_NotImplementedError
,
8324 "CryptAcquireContextA not found");
8326 pCryptGenRandom
= (CRYPTGENRANDOM
)GetProcAddress(
8327 hAdvAPI32
, "CryptGenRandom");
8328 if (pCryptGenRandom
== NULL
)
8329 return PyErr_Format(PyExc_NotImplementedError
,
8330 "CryptGenRandom not found");
8332 /* Acquire context */
8333 if (! pCryptAcquireContext(&hCryptProv
, NULL
, NULL
,
8334 PROV_RSA_FULL
, CRYPT_VERIFYCONTEXT
))
8335 return win32_error("CryptAcquireContext", NULL
);
8338 /* Allocate bytes */
8339 result
= PyString_FromStringAndSize(NULL
, howMany
);
8340 if (result
!= NULL
) {
8341 /* Get random data */
8342 memset(PyString_AS_STRING(result
), 0, howMany
); /* zero seed */
8343 if (! pCryptGenRandom(hCryptProv
, howMany
, (unsigned char*)
8344 PyString_AS_STRING(result
))) {
8346 return win32_error("CryptGenRandom", NULL
);
8354 /* Use openssl random routine */
8355 #include <openssl/rand.h>
8356 PyDoc_STRVAR(vms_urandom__doc__
,
8357 "urandom(n) -> str\n\n\
8358 Return a string of n random bytes suitable for cryptographic use.");
8361 vms_urandom(PyObject
*self
, PyObject
*args
)
8366 /* Read arguments */
8367 if (! PyArg_ParseTuple(args
, "i:urandom", &howMany
))
8370 return PyErr_Format(PyExc_ValueError
,
8371 "negative argument not allowed");
8373 /* Allocate bytes */
8374 result
= PyString_FromStringAndSize(NULL
, howMany
);
8375 if (result
!= NULL
) {
8376 /* Get random data */
8377 if (RAND_pseudo_bytes((unsigned char*)
8378 PyString_AS_STRING(result
),
8381 return PyErr_Format(PyExc_ValueError
,
8382 "RAND_pseudo_bytes");
8389 static PyMethodDef posix_methods
[] = {
8390 {"access", posix_access
, METH_VARARGS
, posix_access__doc__
},
8392 {"ttyname", posix_ttyname
, METH_VARARGS
, posix_ttyname__doc__
},
8394 {"chdir", posix_chdir
, METH_VARARGS
, posix_chdir__doc__
},
8396 {"chflags", posix_chflags
, METH_VARARGS
, posix_chflags__doc__
},
8397 #endif /* HAVE_CHFLAGS */
8398 {"chmod", posix_chmod
, METH_VARARGS
, posix_chmod__doc__
},
8400 {"fchmod", posix_fchmod
, METH_VARARGS
, posix_fchmod__doc__
},
8401 #endif /* HAVE_FCHMOD */
8403 {"chown", posix_chown
, METH_VARARGS
, posix_chown__doc__
},
8404 #endif /* HAVE_CHOWN */
8406 {"lchmod", posix_lchmod
, METH_VARARGS
, posix_lchmod__doc__
},
8407 #endif /* HAVE_LCHMOD */
8409 {"fchown", posix_fchown
, METH_VARARGS
, posix_fchown__doc__
},
8410 #endif /* HAVE_FCHOWN */
8411 #ifdef HAVE_LCHFLAGS
8412 {"lchflags", posix_lchflags
, METH_VARARGS
, posix_lchflags__doc__
},
8413 #endif /* HAVE_LCHFLAGS */
8415 {"lchown", posix_lchown
, METH_VARARGS
, posix_lchown__doc__
},
8416 #endif /* HAVE_LCHOWN */
8418 {"chroot", posix_chroot
, METH_VARARGS
, posix_chroot__doc__
},
8421 {"ctermid", posix_ctermid
, METH_NOARGS
, posix_ctermid__doc__
},
8424 {"getcwd", posix_getcwd
, METH_NOARGS
, posix_getcwd__doc__
},
8425 #ifdef Py_USING_UNICODE
8426 {"getcwdu", posix_getcwdu
, METH_NOARGS
, posix_getcwdu__doc__
},
8430 {"link", posix_link
, METH_VARARGS
, posix_link__doc__
},
8431 #endif /* HAVE_LINK */
8432 {"listdir", posix_listdir
, METH_VARARGS
, posix_listdir__doc__
},
8433 {"lstat", posix_lstat
, METH_VARARGS
, posix_lstat__doc__
},
8434 {"mkdir", posix_mkdir
, METH_VARARGS
, posix_mkdir__doc__
},
8436 {"nice", posix_nice
, METH_VARARGS
, posix_nice__doc__
},
8437 #endif /* HAVE_NICE */
8438 #ifdef HAVE_READLINK
8439 {"readlink", posix_readlink
, METH_VARARGS
, posix_readlink__doc__
},
8440 #endif /* HAVE_READLINK */
8441 {"rename", posix_rename
, METH_VARARGS
, posix_rename__doc__
},
8442 {"rmdir", posix_rmdir
, METH_VARARGS
, posix_rmdir__doc__
},
8443 {"stat", posix_stat
, METH_VARARGS
, posix_stat__doc__
},
8444 {"stat_float_times", stat_float_times
, METH_VARARGS
, stat_float_times__doc__
},
8446 {"symlink", posix_symlink
, METH_VARARGS
, posix_symlink__doc__
},
8447 #endif /* HAVE_SYMLINK */
8449 {"system", posix_system
, METH_VARARGS
, posix_system__doc__
},
8451 {"umask", posix_umask
, METH_VARARGS
, posix_umask__doc__
},
8453 {"uname", posix_uname
, METH_NOARGS
, posix_uname__doc__
},
8454 #endif /* HAVE_UNAME */
8455 {"unlink", posix_unlink
, METH_VARARGS
, posix_unlink__doc__
},
8456 {"remove", posix_unlink
, METH_VARARGS
, posix_remove__doc__
},
8457 {"utime", posix_utime
, METH_VARARGS
, posix_utime__doc__
},
8459 {"times", posix_times
, METH_NOARGS
, posix_times__doc__
},
8460 #endif /* HAVE_TIMES */
8461 {"_exit", posix__exit
, METH_VARARGS
, posix__exit__doc__
},
8463 {"execv", posix_execv
, METH_VARARGS
, posix_execv__doc__
},
8464 {"execve", posix_execve
, METH_VARARGS
, posix_execve__doc__
},
8465 #endif /* HAVE_EXECV */
8467 {"spawnv", posix_spawnv
, METH_VARARGS
, posix_spawnv__doc__
},
8468 {"spawnve", posix_spawnve
, METH_VARARGS
, posix_spawnve__doc__
},
8469 #if defined(PYOS_OS2)
8470 {"spawnvp", posix_spawnvp
, METH_VARARGS
, posix_spawnvp__doc__
},
8471 {"spawnvpe", posix_spawnvpe
, METH_VARARGS
, posix_spawnvpe__doc__
},
8472 #endif /* PYOS_OS2 */
8473 #endif /* HAVE_SPAWNV */
8475 {"fork1", posix_fork1
, METH_NOARGS
, posix_fork1__doc__
},
8476 #endif /* HAVE_FORK1 */
8478 {"fork", posix_fork
, METH_NOARGS
, posix_fork__doc__
},
8479 #endif /* HAVE_FORK */
8480 #if defined(HAVE_OPENPTY) || defined(HAVE__GETPTY) || defined(HAVE_DEV_PTMX)
8481 {"openpty", posix_openpty
, METH_NOARGS
, posix_openpty__doc__
},
8482 #endif /* HAVE_OPENPTY || HAVE__GETPTY || HAVE_DEV_PTMX */
8484 {"forkpty", posix_forkpty
, METH_NOARGS
, posix_forkpty__doc__
},
8485 #endif /* HAVE_FORKPTY */
8487 {"getegid", posix_getegid
, METH_NOARGS
, posix_getegid__doc__
},
8488 #endif /* HAVE_GETEGID */
8490 {"geteuid", posix_geteuid
, METH_NOARGS
, posix_geteuid__doc__
},
8491 #endif /* HAVE_GETEUID */
8493 {"getgid", posix_getgid
, METH_NOARGS
, posix_getgid__doc__
},
8494 #endif /* HAVE_GETGID */
8495 #ifdef HAVE_GETGROUPS
8496 {"getgroups", posix_getgroups
, METH_NOARGS
, posix_getgroups__doc__
},
8498 {"getpid", posix_getpid
, METH_NOARGS
, posix_getpid__doc__
},
8500 {"getpgrp", posix_getpgrp
, METH_NOARGS
, posix_getpgrp__doc__
},
8501 #endif /* HAVE_GETPGRP */
8503 {"getppid", posix_getppid
, METH_NOARGS
, posix_getppid__doc__
},
8504 #endif /* HAVE_GETPPID */
8506 {"getuid", posix_getuid
, METH_NOARGS
, posix_getuid__doc__
},
8507 #endif /* HAVE_GETUID */
8508 #ifdef HAVE_GETLOGIN
8509 {"getlogin", posix_getlogin
, METH_NOARGS
, posix_getlogin__doc__
},
8512 {"kill", posix_kill
, METH_VARARGS
, posix_kill__doc__
},
8513 #endif /* HAVE_KILL */
8515 {"killpg", posix_killpg
, METH_VARARGS
, posix_killpg__doc__
},
8516 #endif /* HAVE_KILLPG */
8518 {"plock", posix_plock
, METH_VARARGS
, posix_plock__doc__
},
8519 #endif /* HAVE_PLOCK */
8521 {"popen", posix_popen
, METH_VARARGS
, posix_popen__doc__
},
8523 {"popen2", win32_popen2
, METH_VARARGS
},
8524 {"popen3", win32_popen3
, METH_VARARGS
},
8525 {"popen4", win32_popen4
, METH_VARARGS
},
8526 {"startfile", win32_startfile
, METH_VARARGS
, win32_startfile__doc__
},
8528 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8529 {"popen2", os2emx_popen2
, METH_VARARGS
},
8530 {"popen3", os2emx_popen3
, METH_VARARGS
},
8531 {"popen4", os2emx_popen4
, METH_VARARGS
},
8534 #endif /* HAVE_POPEN */
8536 {"setuid", posix_setuid
, METH_VARARGS
, posix_setuid__doc__
},
8537 #endif /* HAVE_SETUID */
8539 {"seteuid", posix_seteuid
, METH_VARARGS
, posix_seteuid__doc__
},
8540 #endif /* HAVE_SETEUID */
8542 {"setegid", posix_setegid
, METH_VARARGS
, posix_setegid__doc__
},
8543 #endif /* HAVE_SETEGID */
8544 #ifdef HAVE_SETREUID
8545 {"setreuid", posix_setreuid
, METH_VARARGS
, posix_setreuid__doc__
},
8546 #endif /* HAVE_SETREUID */
8547 #ifdef HAVE_SETREGID
8548 {"setregid", posix_setregid
, METH_VARARGS
, posix_setregid__doc__
},
8549 #endif /* HAVE_SETREGID */
8551 {"setgid", posix_setgid
, METH_VARARGS
, posix_setgid__doc__
},
8552 #endif /* HAVE_SETGID */
8553 #ifdef HAVE_SETGROUPS
8554 {"setgroups", posix_setgroups
, METH_O
, posix_setgroups__doc__
},
8555 #endif /* HAVE_SETGROUPS */
8557 {"getpgid", posix_getpgid
, METH_VARARGS
, posix_getpgid__doc__
},
8558 #endif /* HAVE_GETPGID */
8560 {"setpgrp", posix_setpgrp
, METH_NOARGS
, posix_setpgrp__doc__
},
8561 #endif /* HAVE_SETPGRP */
8563 {"wait", posix_wait
, METH_NOARGS
, posix_wait__doc__
},
8564 #endif /* HAVE_WAIT */
8566 {"wait3", posix_wait3
, METH_VARARGS
, posix_wait3__doc__
},
8567 #endif /* HAVE_WAIT3 */
8569 {"wait4", posix_wait4
, METH_VARARGS
, posix_wait4__doc__
},
8570 #endif /* HAVE_WAIT4 */
8571 #if defined(HAVE_WAITPID) || defined(HAVE_CWAIT)
8572 {"waitpid", posix_waitpid
, METH_VARARGS
, posix_waitpid__doc__
},
8573 #endif /* HAVE_WAITPID */
8575 {"getsid", posix_getsid
, METH_VARARGS
, posix_getsid__doc__
},
8576 #endif /* HAVE_GETSID */
8578 {"setsid", posix_setsid
, METH_NOARGS
, posix_setsid__doc__
},
8579 #endif /* HAVE_SETSID */
8581 {"setpgid", posix_setpgid
, METH_VARARGS
, posix_setpgid__doc__
},
8582 #endif /* HAVE_SETPGID */
8583 #ifdef HAVE_TCGETPGRP
8584 {"tcgetpgrp", posix_tcgetpgrp
, METH_VARARGS
, posix_tcgetpgrp__doc__
},
8585 #endif /* HAVE_TCGETPGRP */
8586 #ifdef HAVE_TCSETPGRP
8587 {"tcsetpgrp", posix_tcsetpgrp
, METH_VARARGS
, posix_tcsetpgrp__doc__
},
8588 #endif /* HAVE_TCSETPGRP */
8589 {"open", posix_open
, METH_VARARGS
, posix_open__doc__
},
8590 {"close", posix_close
, METH_VARARGS
, posix_close__doc__
},
8591 {"closerange", posix_closerange
, METH_VARARGS
, posix_closerange__doc__
},
8592 {"dup", posix_dup
, METH_VARARGS
, posix_dup__doc__
},
8593 {"dup2", posix_dup2
, METH_VARARGS
, posix_dup2__doc__
},
8594 {"lseek", posix_lseek
, METH_VARARGS
, posix_lseek__doc__
},
8595 {"read", posix_read
, METH_VARARGS
, posix_read__doc__
},
8596 {"write", posix_write
, METH_VARARGS
, posix_write__doc__
},
8597 {"fstat", posix_fstat
, METH_VARARGS
, posix_fstat__doc__
},
8598 {"fdopen", posix_fdopen
, METH_VARARGS
, posix_fdopen__doc__
},
8599 {"isatty", posix_isatty
, METH_VARARGS
, posix_isatty__doc__
},
8601 {"pipe", posix_pipe
, METH_NOARGS
, posix_pipe__doc__
},
8604 {"mkfifo", posix_mkfifo
, METH_VARARGS
, posix_mkfifo__doc__
},
8606 #if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)
8607 {"mknod", posix_mknod
, METH_VARARGS
, posix_mknod__doc__
},
8609 #ifdef HAVE_DEVICE_MACROS
8610 {"major", posix_major
, METH_VARARGS
, posix_major__doc__
},
8611 {"minor", posix_minor
, METH_VARARGS
, posix_minor__doc__
},
8612 {"makedev", posix_makedev
, METH_VARARGS
, posix_makedev__doc__
},
8614 #ifdef HAVE_FTRUNCATE
8615 {"ftruncate", posix_ftruncate
, METH_VARARGS
, posix_ftruncate__doc__
},
8618 {"putenv", posix_putenv
, METH_VARARGS
, posix_putenv__doc__
},
8620 #ifdef HAVE_UNSETENV
8621 {"unsetenv", posix_unsetenv
, METH_VARARGS
, posix_unsetenv__doc__
},
8623 {"strerror", posix_strerror
, METH_VARARGS
, posix_strerror__doc__
},
8625 {"fchdir", posix_fchdir
, METH_O
, posix_fchdir__doc__
},
8628 {"fsync", posix_fsync
, METH_O
, posix_fsync__doc__
},
8630 #ifdef HAVE_FDATASYNC
8631 {"fdatasync", posix_fdatasync
, METH_O
, posix_fdatasync__doc__
},
8633 #ifdef HAVE_SYS_WAIT_H
8635 {"WCOREDUMP", posix_WCOREDUMP
, METH_VARARGS
, posix_WCOREDUMP__doc__
},
8636 #endif /* WCOREDUMP */
8638 {"WIFCONTINUED",posix_WIFCONTINUED
, METH_VARARGS
, posix_WIFCONTINUED__doc__
},
8639 #endif /* WIFCONTINUED */
8641 {"WIFSTOPPED", posix_WIFSTOPPED
, METH_VARARGS
, posix_WIFSTOPPED__doc__
},
8642 #endif /* WIFSTOPPED */
8644 {"WIFSIGNALED", posix_WIFSIGNALED
, METH_VARARGS
, posix_WIFSIGNALED__doc__
},
8645 #endif /* WIFSIGNALED */
8647 {"WIFEXITED", posix_WIFEXITED
, METH_VARARGS
, posix_WIFEXITED__doc__
},
8648 #endif /* WIFEXITED */
8650 {"WEXITSTATUS", posix_WEXITSTATUS
, METH_VARARGS
, posix_WEXITSTATUS__doc__
},
8651 #endif /* WEXITSTATUS */
8653 {"WTERMSIG", posix_WTERMSIG
, METH_VARARGS
, posix_WTERMSIG__doc__
},
8654 #endif /* WTERMSIG */
8656 {"WSTOPSIG", posix_WSTOPSIG
, METH_VARARGS
, posix_WSTOPSIG__doc__
},
8657 #endif /* WSTOPSIG */
8658 #endif /* HAVE_SYS_WAIT_H */
8659 #if defined(HAVE_FSTATVFS) && defined(HAVE_SYS_STATVFS_H)
8660 {"fstatvfs", posix_fstatvfs
, METH_VARARGS
, posix_fstatvfs__doc__
},
8662 #if defined(HAVE_STATVFS) && defined(HAVE_SYS_STATVFS_H)
8663 {"statvfs", posix_statvfs
, METH_VARARGS
, posix_statvfs__doc__
},
8666 {"tmpfile", posix_tmpfile
, METH_NOARGS
, posix_tmpfile__doc__
},
8669 {"tempnam", posix_tempnam
, METH_VARARGS
, posix_tempnam__doc__
},
8672 {"tmpnam", posix_tmpnam
, METH_NOARGS
, posix_tmpnam__doc__
},
8675 {"confstr", posix_confstr
, METH_VARARGS
, posix_confstr__doc__
},
8678 {"sysconf", posix_sysconf
, METH_VARARGS
, posix_sysconf__doc__
},
8680 #ifdef HAVE_FPATHCONF
8681 {"fpathconf", posix_fpathconf
, METH_VARARGS
, posix_fpathconf__doc__
},
8683 #ifdef HAVE_PATHCONF
8684 {"pathconf", posix_pathconf
, METH_VARARGS
, posix_pathconf__doc__
},
8686 {"abort", posix_abort
, METH_NOARGS
, posix_abort__doc__
},
8688 {"_getfullpathname", posix__getfullpathname
, METH_VARARGS
, NULL
},
8690 #ifdef HAVE_GETLOADAVG
8691 {"getloadavg", posix_getloadavg
, METH_NOARGS
, posix_getloadavg__doc__
},
8694 {"urandom", win32_urandom
, METH_VARARGS
, win32_urandom__doc__
},
8697 {"urandom", vms_urandom
, METH_VARARGS
, vms_urandom__doc__
},
8699 {NULL
, NULL
} /* Sentinel */
8704 ins(PyObject
*module
, char *symbol
, long value
)
8706 return PyModule_AddIntConstant(module
, symbol
, value
);
8709 #if defined(PYOS_OS2)
8710 /* Insert Platform-Specific Constant Values (Strings & Numbers) of Common Use */
8711 static int insertvalues(PyObject
*module
)
8714 ULONG values
[QSV_MAX
+1];
8718 Py_BEGIN_ALLOW_THREADS
8719 rc
= DosQuerySysInfo(1L, QSV_MAX
, &values
[1], sizeof(ULONG
) * QSV_MAX
);
8720 Py_END_ALLOW_THREADS
8722 if (rc
!= NO_ERROR
) {
8727 if (ins(module
, "meminstalled", values
[QSV_TOTPHYSMEM
])) return -1;
8728 if (ins(module
, "memkernel", values
[QSV_TOTRESMEM
])) return -1;
8729 if (ins(module
, "memvirtual", values
[QSV_TOTAVAILMEM
])) return -1;
8730 if (ins(module
, "maxpathlen", values
[QSV_MAX_PATH_LENGTH
])) return -1;
8731 if (ins(module
, "maxnamelen", values
[QSV_MAX_COMP_LENGTH
])) return -1;
8732 if (ins(module
, "revision", values
[QSV_VERSION_REVISION
])) return -1;
8733 if (ins(module
, "timeslice", values
[QSV_MIN_SLICE
])) return -1;
8735 switch (values
[QSV_VERSION_MINOR
]) {
8736 case 0: ver
= "2.00"; break;
8737 case 10: ver
= "2.10"; break;
8738 case 11: ver
= "2.11"; break;
8739 case 30: ver
= "3.00"; break;
8740 case 40: ver
= "4.00"; break;
8741 case 50: ver
= "5.00"; break;
8743 PyOS_snprintf(tmp
, sizeof(tmp
),
8744 "%d-%d", values
[QSV_VERSION_MAJOR
],
8745 values
[QSV_VERSION_MINOR
]);
8749 /* Add Indicator of the Version of the Operating System */
8750 if (PyModule_AddStringConstant(module
, "version", tmp
) < 0)
8753 /* Add Indicator of Which Drive was Used to Boot the System */
8754 tmp
[0] = 'A' + values
[QSV_BOOT_DRIVE
] - 1;
8758 return PyModule_AddStringConstant(module
, "bootdrive", tmp
);
8763 all_ins(PyObject
*d
)
8766 if (ins(d
, "F_OK", (long)F_OK
)) return -1;
8769 if (ins(d
, "R_OK", (long)R_OK
)) return -1;
8772 if (ins(d
, "W_OK", (long)W_OK
)) return -1;
8775 if (ins(d
, "X_OK", (long)X_OK
)) return -1;
8778 if (ins(d
, "NGROUPS_MAX", (long)NGROUPS_MAX
)) return -1;
8781 if (ins(d
, "TMP_MAX", (long)TMP_MAX
)) return -1;
8784 if (ins(d
, "WCONTINUED", (long)WCONTINUED
)) return -1;
8787 if (ins(d
, "WNOHANG", (long)WNOHANG
)) return -1;
8790 if (ins(d
, "WUNTRACED", (long)WUNTRACED
)) return -1;
8793 if (ins(d
, "O_RDONLY", (long)O_RDONLY
)) return -1;
8796 if (ins(d
, "O_WRONLY", (long)O_WRONLY
)) return -1;
8799 if (ins(d
, "O_RDWR", (long)O_RDWR
)) return -1;
8802 if (ins(d
, "O_NDELAY", (long)O_NDELAY
)) return -1;
8805 if (ins(d
, "O_NONBLOCK", (long)O_NONBLOCK
)) return -1;
8808 if (ins(d
, "O_APPEND", (long)O_APPEND
)) return -1;
8811 if (ins(d
, "O_DSYNC", (long)O_DSYNC
)) return -1;
8814 if (ins(d
, "O_RSYNC", (long)O_RSYNC
)) return -1;
8817 if (ins(d
, "O_SYNC", (long)O_SYNC
)) return -1;
8820 if (ins(d
, "O_NOCTTY", (long)O_NOCTTY
)) return -1;
8823 if (ins(d
, "O_CREAT", (long)O_CREAT
)) return -1;
8826 if (ins(d
, "O_EXCL", (long)O_EXCL
)) return -1;
8829 if (ins(d
, "O_TRUNC", (long)O_TRUNC
)) return -1;
8832 if (ins(d
, "O_BINARY", (long)O_BINARY
)) return -1;
8835 if (ins(d
, "O_TEXT", (long)O_TEXT
)) return -1;
8838 if (ins(d
, "O_LARGEFILE", (long)O_LARGEFILE
)) return -1;
8841 if (ins(d
, "O_SHLOCK", (long)O_SHLOCK
)) return -1;
8844 if (ins(d
, "O_EXLOCK", (long)O_EXLOCK
)) return -1;
8849 /* Don't inherit in child processes. */
8850 if (ins(d
, "O_NOINHERIT", (long)O_NOINHERIT
)) return -1;
8852 #ifdef _O_SHORT_LIVED
8853 /* Optimize for short life (keep in memory). */
8854 /* MS forgot to define this one with a non-underscore form too. */
8855 if (ins(d
, "O_SHORT_LIVED", (long)_O_SHORT_LIVED
)) return -1;
8858 /* Automatically delete when last handle is closed. */
8859 if (ins(d
, "O_TEMPORARY", (long)O_TEMPORARY
)) return -1;
8862 /* Optimize for random access. */
8863 if (ins(d
, "O_RANDOM", (long)O_RANDOM
)) return -1;
8866 /* Optimize for sequential access. */
8867 if (ins(d
, "O_SEQUENTIAL", (long)O_SEQUENTIAL
)) return -1;
8870 /* GNU extensions. */
8872 /* Send a SIGIO signal whenever input or output
8873 becomes available on file descriptor */
8874 if (ins(d
, "O_ASYNC", (long)O_ASYNC
)) return -1;
8877 /* Direct disk access. */
8878 if (ins(d
, "O_DIRECT", (long)O_DIRECT
)) return -1;
8881 /* Must be a directory. */
8882 if (ins(d
, "O_DIRECTORY", (long)O_DIRECTORY
)) return -1;
8885 /* Do not follow links. */
8886 if (ins(d
, "O_NOFOLLOW", (long)O_NOFOLLOW
)) return -1;
8889 /* Do not update the access time. */
8890 if (ins(d
, "O_NOATIME", (long)O_NOATIME
)) return -1;
8893 /* These come from sysexits.h */
8895 if (ins(d
, "EX_OK", (long)EX_OK
)) return -1;
8898 if (ins(d
, "EX_USAGE", (long)EX_USAGE
)) return -1;
8899 #endif /* EX_USAGE */
8901 if (ins(d
, "EX_DATAERR", (long)EX_DATAERR
)) return -1;
8902 #endif /* EX_DATAERR */
8904 if (ins(d
, "EX_NOINPUT", (long)EX_NOINPUT
)) return -1;
8905 #endif /* EX_NOINPUT */
8907 if (ins(d
, "EX_NOUSER", (long)EX_NOUSER
)) return -1;
8908 #endif /* EX_NOUSER */
8910 if (ins(d
, "EX_NOHOST", (long)EX_NOHOST
)) return -1;
8911 #endif /* EX_NOHOST */
8912 #ifdef EX_UNAVAILABLE
8913 if (ins(d
, "EX_UNAVAILABLE", (long)EX_UNAVAILABLE
)) return -1;
8914 #endif /* EX_UNAVAILABLE */
8916 if (ins(d
, "EX_SOFTWARE", (long)EX_SOFTWARE
)) return -1;
8917 #endif /* EX_SOFTWARE */
8919 if (ins(d
, "EX_OSERR", (long)EX_OSERR
)) return -1;
8920 #endif /* EX_OSERR */
8922 if (ins(d
, "EX_OSFILE", (long)EX_OSFILE
)) return -1;
8923 #endif /* EX_OSFILE */
8925 if (ins(d
, "EX_CANTCREAT", (long)EX_CANTCREAT
)) return -1;
8926 #endif /* EX_CANTCREAT */
8928 if (ins(d
, "EX_IOERR", (long)EX_IOERR
)) return -1;
8929 #endif /* EX_IOERR */
8931 if (ins(d
, "EX_TEMPFAIL", (long)EX_TEMPFAIL
)) return -1;
8932 #endif /* EX_TEMPFAIL */
8934 if (ins(d
, "EX_PROTOCOL", (long)EX_PROTOCOL
)) return -1;
8935 #endif /* EX_PROTOCOL */
8937 if (ins(d
, "EX_NOPERM", (long)EX_NOPERM
)) return -1;
8938 #endif /* EX_NOPERM */
8940 if (ins(d
, "EX_CONFIG", (long)EX_CONFIG
)) return -1;
8941 #endif /* EX_CONFIG */
8943 if (ins(d
, "EX_NOTFOUND", (long)EX_NOTFOUND
)) return -1;
8944 #endif /* EX_NOTFOUND */
8947 #if defined(PYOS_OS2) && defined(PYCC_GCC)
8948 if (ins(d
, "P_WAIT", (long)P_WAIT
)) return -1;
8949 if (ins(d
, "P_NOWAIT", (long)P_NOWAIT
)) return -1;
8950 if (ins(d
, "P_OVERLAY", (long)P_OVERLAY
)) return -1;
8951 if (ins(d
, "P_DEBUG", (long)P_DEBUG
)) return -1;
8952 if (ins(d
, "P_SESSION", (long)P_SESSION
)) return -1;
8953 if (ins(d
, "P_DETACH", (long)P_DETACH
)) return -1;
8954 if (ins(d
, "P_PM", (long)P_PM
)) return -1;
8955 if (ins(d
, "P_DEFAULT", (long)P_DEFAULT
)) return -1;
8956 if (ins(d
, "P_MINIMIZE", (long)P_MINIMIZE
)) return -1;
8957 if (ins(d
, "P_MAXIMIZE", (long)P_MAXIMIZE
)) return -1;
8958 if (ins(d
, "P_FULLSCREEN", (long)P_FULLSCREEN
)) return -1;
8959 if (ins(d
, "P_WINDOWED", (long)P_WINDOWED
)) return -1;
8960 if (ins(d
, "P_FOREGROUND", (long)P_FOREGROUND
)) return -1;
8961 if (ins(d
, "P_BACKGROUND", (long)P_BACKGROUND
)) return -1;
8962 if (ins(d
, "P_NOCLOSE", (long)P_NOCLOSE
)) return -1;
8963 if (ins(d
, "P_NOSESSION", (long)P_NOSESSION
)) return -1;
8964 if (ins(d
, "P_QUOTE", (long)P_QUOTE
)) return -1;
8965 if (ins(d
, "P_TILDE", (long)P_TILDE
)) return -1;
8966 if (ins(d
, "P_UNRELATED", (long)P_UNRELATED
)) return -1;
8967 if (ins(d
, "P_DEBUGDESC", (long)P_DEBUGDESC
)) return -1;
8969 if (ins(d
, "P_WAIT", (long)_P_WAIT
)) return -1;
8970 if (ins(d
, "P_NOWAIT", (long)_P_NOWAIT
)) return -1;
8971 if (ins(d
, "P_OVERLAY", (long)_OLD_P_OVERLAY
)) return -1;
8972 if (ins(d
, "P_NOWAITO", (long)_P_NOWAITO
)) return -1;
8973 if (ins(d
, "P_DETACH", (long)_P_DETACH
)) return -1;
8977 #if defined(PYOS_OS2)
8978 if (insertvalues(d
)) return -1;
8984 #if (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__)) && !defined(__QNX__)
8985 #define INITFUNC initnt
8986 #define MODNAME "nt"
8988 #elif defined(PYOS_OS2)
8989 #define INITFUNC initos2
8990 #define MODNAME "os2"
8993 #define INITFUNC initposix
8994 #define MODNAME "posix"
9002 m
= Py_InitModule3(MODNAME
,
9008 /* Initialize environ dictionary */
9009 v
= convertenviron();
9011 if (v
== NULL
|| PyModule_AddObject(m
, "environ", v
) != 0)
9018 if (setup_confname_tables(m
))
9021 Py_INCREF(PyExc_OSError
);
9022 PyModule_AddObject(m
, "error", PyExc_OSError
);
9025 if (posix_putenv_garbage
== NULL
)
9026 posix_putenv_garbage
= PyDict_New();
9030 stat_result_desc
.name
= MODNAME
".stat_result";
9031 stat_result_desc
.fields
[7].name
= PyStructSequence_UnnamedField
;
9032 stat_result_desc
.fields
[8].name
= PyStructSequence_UnnamedField
;
9033 stat_result_desc
.fields
[9].name
= PyStructSequence_UnnamedField
;
9034 PyStructSequence_InitType(&StatResultType
, &stat_result_desc
);
9035 structseq_new
= StatResultType
.tp_new
;
9036 StatResultType
.tp_new
= statresult_new
;
9038 statvfs_result_desc
.name
= MODNAME
".statvfs_result";
9039 PyStructSequence_InitType(&StatVFSResultType
, &statvfs_result_desc
);
9040 #ifdef NEED_TICKS_PER_SECOND
9041 # if defined(HAVE_SYSCONF) && defined(_SC_CLK_TCK)
9042 ticks_per_second
= sysconf(_SC_CLK_TCK
);
9044 ticks_per_second
= HZ
;
9046 ticks_per_second
= 60; /* magic fallback value; may be bogus */
9050 Py_INCREF((PyObject
*) &StatResultType
);
9051 PyModule_AddObject(m
, "stat_result", (PyObject
*) &StatResultType
);
9052 Py_INCREF((PyObject
*) &StatVFSResultType
);
9053 PyModule_AddObject(m
, "statvfs_result",
9054 (PyObject
*) &StatVFSResultType
);
9059 * Step 2 of weak-linking support on Mac OS X.
9061 * The code below removes functions that are not available on the
9062 * currently active platform.
9064 * This block allow one to use a python binary that was build on
9065 * OSX 10.4 on OSX 10.3, without loosing access to new APIs on
9068 #ifdef HAVE_FSTATVFS
9069 if (fstatvfs
== NULL
) {
9070 if (PyObject_DelAttrString(m
, "fstatvfs") == -1) {
9074 #endif /* HAVE_FSTATVFS */
9077 if (statvfs
== NULL
) {
9078 if (PyObject_DelAttrString(m
, "statvfs") == -1) {
9082 #endif /* HAVE_STATVFS */
9085 if (lchown
== NULL
) {
9086 if (PyObject_DelAttrString(m
, "lchown") == -1) {
9090 #endif /* HAVE_LCHOWN */
9093 #endif /* __APPLE__ */