/* POSIX module implementation */

/* This file is also used for Windows NT/MS-Win and OS/2. In that case the

module actually calls itself 'nt' or 'os2', not 'posix', and a few

functions are either unimplemented or implemented differently. The source

assumes that for Windows NT, the macro 'MS_WINDOWS' is defined independent

of the compiler used. Different compilers define their own feature

test macro, e.g. '__BORLANDC__' or '_MSC_VER'. For OS/2, the compiler

independent macro PYOS_OS2 should be defined. On OS/2 the default

compiler is assumed to be IBM's VisualAge C++ (VACPP). PYCC_GCC is used

as the compiler specific macro for the EMX port of gcc to OS/2. */

/* See also ../Dos/dosmodule.c */

#ifdef __APPLE__

/*

* Step 1 of support for weak-linking a number of symbols existing on

* OSX 10.4 and later, see the comment in the #ifdef __APPLE__ block

* at the end of this file for more information.

*/

# pragma weak lchown

# pragma weak statvfs

# pragma weak fstatvfs

#endif /* __APPLE__ */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structseq.h"

#if defined(__VMS)

# include <unixio.h>

#endif /* defined(__VMS) */

#ifdef __cplusplus

extern "C" {

#endif

PyDoc_STRVAR(posix__doc__,

"This module provides access to operating system functionality that is\n\

standardized by the C Standard and the POSIX standard (a thinly\n\

disguised Unix interface). Refer to the library manual and\n\

corresponding Unix manual entries for more information on calls.");

#if defined(PYOS_OS2)

#define INCL_DOS

#define INCL_DOSERRORS

#define INCL_DOSPROCESS

#define INCL_NOPMAPI

#include <os2.h>

#if defined(PYCC_GCC)

#include <ctype.h>

#include <io.h>

#include <stdio.h>

#include <process.h>

#endif

#include "osdefs.h"

#endif

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif /* HAVE_SYS_STAT_H */

#ifdef HAVE_SYS_WAIT_H

#include <sys/wait.h> /* For WNOHANG */

#endif

#ifdef HAVE_SIGNAL_H

#include <signal.h>

#endif

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif /* HAVE_FCNTL_H */

#ifdef HAVE_GRP_H

#include <grp.h>

#endif

#ifdef HAVE_SYSEXITS_H

#include <sysexits.h>

#endif /* HAVE_SYSEXITS_H */

#ifdef HAVE_SYS_LOADAVG_H

#include <sys/loadavg.h>

#endif

#ifdef HAVE_LANGINFO_H

#include <langinfo.h>

#endif

/* Various compilers have only certain posix functions */

/* XXX Gosh I wish these were all moved into pyconfig.h */

#if defined(PYCC_VACPP) && defined(PYOS_OS2)

#include <process.h>

#else

#if defined(__WATCOMC__) && !defined(__QNX__) /* Watcom compiler */

#define HAVE_GETCWD 1

#define HAVE_OPENDIR 1

#define HAVE_SYSTEM 1

#if defined(__OS2__)

#define HAVE_EXECV 1

#define HAVE_WAIT 1

#endif

#include <process.h>

#else

#ifdef __BORLANDC__ /* Borland compiler */

#define HAVE_EXECV 1

#define HAVE_GETCWD 1

#define HAVE_OPENDIR 1

#define HAVE_PIPE 1

#define HAVE_SYSTEM 1

#define HAVE_WAIT 1

#else

#ifdef _MSC_VER /* Microsoft compiler */

#define HAVE_GETCWD 1

#define HAVE_SPAWNV 1

#define HAVE_EXECV 1

#define HAVE_PIPE 1

#define HAVE_SYSTEM 1

#define HAVE_CWAIT 1

#define HAVE_FSYNC 1

#define fsync _commit

#else

#if defined(PYOS_OS2) && defined(PYCC_GCC) || defined(__VMS)

/* Everything needed is defined in PC/os2emx/pyconfig.h or vms/pyconfig.h */

#else /* all other compilers */

/* Unix functions that the configure script doesn't check for */

#define HAVE_EXECV 1

#define HAVE_FORK 1

#if defined(__USLC__) && defined(__SCO_VERSION__) /* SCO UDK Compiler */

#define HAVE_FORK1 1

#endif

#define HAVE_GETCWD 1

#define HAVE_GETEGID 1

#define HAVE_GETEUID 1

#define HAVE_GETGID 1

#define HAVE_GETPPID 1

#define HAVE_GETUID 1

#define HAVE_KILL 1

#define HAVE_OPENDIR 1

#define HAVE_PIPE 1

#define HAVE_SYSTEM 1

#define HAVE_WAIT 1

#define HAVE_TTYNAME 1

#endif /* PYOS_OS2 && PYCC_GCC && __VMS */

#endif /* _MSC_VER */

#endif /* __BORLANDC__ */

#endif /* ! __WATCOMC__ || __QNX__ */

#endif /* ! __IBMC__ */

#ifndef _MSC_VER

#if defined(__sgi)&&_COMPILER_VERSION>=700

/* declare ctermid_r if compiling with MIPSPro 7.x in ANSI C mode

(default) */

extern char *ctermid_r(char *);

#endif

#ifndef HAVE_UNISTD_H

#if defined(PYCC_VACPP)

extern int mkdir(char *);

#else

#if ( defined(__WATCOMC__) || defined(_MSC_VER) ) && !defined(__QNX__)

extern int mkdir(const char *);

#else

extern int mkdir(const char *, mode_t);

#endif

#endif

#if defined(__IBMC__) || defined(__IBMCPP__)

extern int chdir(char *);

extern int rmdir(char *);

#else

extern int chdir(const char *);

extern int rmdir(const char *);

#endif

#ifdef __BORLANDC__

extern int chmod(const char *, int);

#else

extern int chmod(const char *, mode_t);

#endif

/*#ifdef HAVE_FCHMOD

extern int fchmod(int, mode_t);

#endif*/

/*#ifdef HAVE_LCHMOD

extern int lchmod(const char *, mode_t);

#endif*/

extern int chown(const char *, uid_t, gid_t);

extern char *getcwd(char *, int);

extern char *strerror(int);

extern int link(const char *, const char *);

extern int rename(const char *, const char *);

extern int stat(const char *, struct stat *);

extern int unlink(const char *);

#ifdef HAVE_SYMLINK

extern int symlink(const char *, const char *);

#endif /* HAVE_SYMLINK */

#ifdef HAVE_LSTAT

extern int lstat(const char *, struct stat *);

#endif /* HAVE_LSTAT */

#endif /* !HAVE_UNISTD_H */

#endif /* !_MSC_VER */

#ifdef HAVE_UTIME_H

#include <utime.h>

#endif /* HAVE_UTIME_H */

#ifdef HAVE_SYS_UTIME_H

#include <sys/utime.h>

#define HAVE_UTIME_H /* pretend we do for the rest of this file */

#endif /* HAVE_SYS_UTIME_H */

#ifdef HAVE_SYS_TIMES_H

#include <sys/times.h>

#endif /* HAVE_SYS_TIMES_H */

#ifdef HAVE_SYS_PARAM_H

#include <sys/param.h>

#endif /* HAVE_SYS_PARAM_H */

#ifdef HAVE_SYS_UTSNAME_H

#include <sys/utsname.h>

#endif /* HAVE_SYS_UTSNAME_H */

#ifdef HAVE_DIRENT_H

#include <dirent.h>

#define NAMLEN(dirent) strlen((dirent)->d_name)

#else

#if defined(__WATCOMC__) && !defined(__QNX__)

#include <direct.h>

#define NAMLEN(dirent) strlen((dirent)->d_name)

#else

#define dirent direct

#define NAMLEN(dirent) (dirent)->d_namlen

#endif

#ifdef HAVE_SYS_NDIR_H

#include <sys/ndir.h>

#endif

#ifdef HAVE_SYS_DIR_H

#include <sys/dir.h>

#endif

#ifdef HAVE_NDIR_H

#include <ndir.h>

#endif

#endif

#ifdef _MSC_VER

#ifdef HAVE_DIRECT_H

#include <direct.h>

#endif

#ifdef HAVE_IO_H

#include <io.h>

#endif

#ifdef HAVE_PROCESS_H

#include <process.h>

#endif

#include "osdefs.h"

#include <windows.h>

#include <shellapi.h> /* for ShellExecute() */

#endif /* _MSC_VER */

#if defined(PYCC_VACPP) && defined(PYOS_OS2)

#include <io.h>

#endif /* OS2 */

#ifndef MAXPATHLEN

#if defined(PATH_MAX) && PATH_MAX > 1024

#define MAXPATHLEN PATH_MAX

#else

#define MAXPATHLEN 1024

#endif

#endif /* MAXPATHLEN */

#ifdef UNION_WAIT

/* Emulate some macros on systems that have a union instead of macros */

#ifndef WIFEXITED

#define WIFEXITED(u_wait) (!(u_wait).w_termsig && !(u_wait).w_coredump)

#endif

#ifndef WEXITSTATUS

#define WEXITSTATUS(u_wait) (WIFEXITED(u_wait)?((u_wait).w_retcode):-1)

#endif

#ifndef WTERMSIG

#define WTERMSIG(u_wait) ((u_wait).w_termsig)

#endif

#define WAIT_TYPE union wait

#define WAIT_STATUS_INT(s) (s.w_status)

#else /* !UNION_WAIT */

#define WAIT_TYPE int

#define WAIT_STATUS_INT(s) (s)

#endif /* UNION_WAIT */

/* Don't use the "_r" form if we don't need it (also, won't have a

prototype for it, at least on Solaris -- maybe others as well?). */

#if defined(HAVE_CTERMID_R) && defined(WITH_THREAD)

#define USE_CTERMID_R

#endif

/* choose the appropriate stat and fstat functions and return structs */

#undef STAT

#if defined(MS_WIN64) || defined(MS_WINDOWS)

# define STAT win32_stat

# define FSTAT win32_fstat

# define STRUCT_STAT struct win32_stat

#else

# define STAT stat

# define FSTAT fstat

# define STRUCT_STAT struct stat

#endif

#if defined(MAJOR_IN_MKDEV)

#include <sys/mkdev.h>

#else

#if defined(MAJOR_IN_SYSMACROS)

#include <sys/sysmacros.h>

#endif

#if defined(HAVE_MKNOD) && defined(HAVE_SYS_MKDEV_H)

#include <sys/mkdev.h>

#endif

#endif

/* Return a dictionary corresponding to the POSIX environment table */

#ifdef WITH_NEXT_FRAMEWORK

/* On Darwin/MacOSX a shared library or framework has no access to

** environ directly, we must obtain it with _NSGetEnviron().

*/

#include <crt_externs.h>

static char **environ;

#elif !defined(_MSC_VER) && ( !defined(__WATCOMC__) || defined(__QNX__) )

extern char **environ;

#endif /* !_MSC_VER */

static PyObject *

convertenviron(void)

{

PyObject *d;

#ifdef MS_WINDOWS

wchar_t **e;

#else

char **e;

#endif

d = PyDict_New();

if (d == NULL)

return NULL;

#ifdef WITH_NEXT_FRAMEWORK

if (environ == NULL)

environ = *_NSGetEnviron();

#endif

#ifdef MS_WINDOWS

/* _wenviron must be initialized in this way if the program is started

through main() instead of wmain(). */

_wgetenv(L"");

if (_wenviron == NULL)

return d;

/* This part ignores errors */

for (e = _wenviron; *e != NULL; e++) {

PyObject *k;

PyObject *v;

wchar_t *p = wcschr(*e, L'=');

if (p == NULL)

continue;

k = PyUnicode_FromWideChar(*e, (Py_ssize_t)(p-*e));

if (k == NULL) {

PyErr_Clear();

continue;

}

v = PyUnicode_FromWideChar(p+1, wcslen(p+1));

if (v == NULL) {

PyErr_Clear();

Py_DECREF(k);

continue;

}

if (PyDict_GetItem(d, k) == NULL) {

if (PyDict_SetItem(d, k, v) != 0)

PyErr_Clear();

}

Py_DECREF(k);

Py_DECREF(v);

}

#else

if (environ == NULL)

return d;

/* This part ignores errors */

for (e = environ; *e != NULL; e++) {

PyObject *k;

PyObject *v;

char *p = strchr(*e, '=');

if (p == NULL)

continue;

k = PyUnicode_FromStringAndSize(*e, (int)(p-*e));

if (k == NULL) {

PyErr_Clear();

continue;

}

v = PyUnicode_FromString(p+1);

if (v == NULL) {

PyErr_Clear();

Py_DECREF(k);

continue;

}

if (PyDict_GetItem(d, k) == NULL) {

if (PyDict_SetItem(d, k, v) != 0)

PyErr_Clear();

}

Py_DECREF(k);

Py_DECREF(v);

}

#endif

#if defined(PYOS_OS2)

{

APIRET rc;

char buffer[1024]; /* OS/2 Provides a Documented Max of 1024 Chars */

rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);

if (rc == NO_ERROR) { /* (not a type, envname is NOT 'BEGIN_LIBPATH') */

PyObject *v = PyBytes_FromString(buffer);

PyDict_SetItemString(d, "BEGINLIBPATH", v);

Py_DECREF(v);

}

rc = DosQueryExtLIBPATH(buffer, END_LIBPATH);

if (rc == NO_ERROR) { /* (not a typo, envname is NOT 'END_LIBPATH') */

PyObject *v = PyBytes_FromString(buffer);

PyDict_SetItemString(d, "ENDLIBPATH", v);

Py_DECREF(v);

}

}

#endif

return d;

}

/* Set a POSIX-specific error from errno, and return NULL */

static PyObject *

posix_error(void)

{

return PyErr_SetFromErrno(PyExc_OSError);

}

static PyObject *

posix_error_with_filename(char* name)

{

return PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);

}

#ifdef Py_WIN_WIDE_FILENAMES

static PyObject *

posix_error_with_unicode_filename(Py_UNICODE* name)

{

return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError, name);

}

#endif /* Py_WIN_WIDE_FILENAMES */

static PyObject *

posix_error_with_allocated_filename(char* name)

{

PyObject *rc = PyErr_SetFromErrnoWithFilename(PyExc_OSError, name);

PyMem_Free(name);

return rc;

}

#ifdef MS_WINDOWS

static PyObject *

win32_error(char* function, char* filename)

{

/* XXX We should pass the function name along in the future.

(winreg.c also wants to pass the function name.)

This would however require an additional param to the

Windows error object, which is non-trivial.

*/

errno = GetLastError();

if (filename)

return PyErr_SetFromWindowsErrWithFilename(errno, filename);

else

return PyErr_SetFromWindowsErr(errno);

}

#ifdef Py_WIN_WIDE_FILENAMES

static PyObject *

win32_error_unicode(char* function, Py_UNICODE* filename)

{

/* XXX - see win32_error for comments on 'function' */

errno = GetLastError();

if (filename)

return PyErr_SetFromWindowsErrWithUnicodeFilename(errno, filename);

else

return PyErr_SetFromWindowsErr(errno);

}

static int

convert_to_unicode(PyObject **param)

{

if (PyUnicode_CheckExact(*param))

Py_INCREF(*param);

else if (PyUnicode_Check(*param))

/* For a Unicode subtype that's not a Unicode object,

return a true Unicode object with the same data. */

*param = PyUnicode_FromUnicode(PyUnicode_AS_UNICODE(*param),

PyUnicode_GET_SIZE(*param));

else

*param = PyUnicode_FromEncodedObject(*param,

Py_FileSystemDefaultEncoding,

"strict");

return (*param) != NULL;

}

#endif /* Py_WIN_WIDE_FILENAMES */

#endif

#if defined(PYOS_OS2)

/**********************************************************************

* Helper Function to Trim and Format OS/2 Messages

**********************************************************************/

static void

os2_formatmsg(char *msgbuf, int msglen, char *reason)

{

msgbuf[msglen] = '\0'; /* OS/2 Doesn't Guarantee a Terminator */

if (strlen(msgbuf) > 0) { /* If Non-Empty Msg, Trim CRLF */

char *lastc = &msgbuf[ strlen(msgbuf)-1 ];

while (lastc > msgbuf && isspace(Py_CHARMASK(*lastc)))

*lastc-- = '\0'; /* Trim Trailing Whitespace (CRLF) */

}

/* Add Optional Reason Text */

if (reason) {

strcat(msgbuf, " : ");

strcat(msgbuf, reason);

}

}

/**********************************************************************

* Decode an OS/2 Operating System Error Code

*

* A convenience function to lookup an OS/2 error code and return a

* text message we can use to raise a Python exception.

*

* Notes:

* The messages for errors returned from the OS/2 kernel reside in

* the file OSO001.MSG in the \OS2 directory hierarchy.

*

**********************************************************************/

static char *

os2_strerror(char *msgbuf, int msgbuflen, int errorcode, char *reason)

{

APIRET rc;

ULONG msglen;

/* Retrieve Kernel-Related Error Message from OSO001.MSG File */

Py_BEGIN_ALLOW_THREADS

rc = DosGetMessage(NULL, 0, msgbuf, msgbuflen,

errorcode, "oso001.msg", &msglen);

Py_END_ALLOW_THREADS

if (rc == NO_ERROR)

os2_formatmsg(msgbuf, msglen, reason);

else

PyOS_snprintf(msgbuf, msgbuflen,

"unknown OS error #%d", errorcode);

return msgbuf;

}

/* Set an OS/2-specific error and return NULL. OS/2 kernel

errors are not in a global variable e.g. 'errno' nor are

they congruent with posix error numbers. */

static PyObject * os2_error(int code)

{

char text[1024];

PyObject *v;

os2_strerror(text, sizeof(text), code, "");

v = Py_BuildValue("(is)", code, text);

if (v != NULL) {

PyErr_SetObject(PyExc_OSError, v);

Py_DECREF(v);

}

return NULL; /* Signal to Python that an Exception is Pending */

}

#endif /* OS2 */

/* POSIX generic methods */

static PyObject *

posix_fildes(PyObject *fdobj, int (*func)(int))

{

int fd;

int res;

fd = PyObject_AsFileDescriptor(fdobj);

if (fd < 0)

return NULL;

Py_BEGIN_ALLOW_THREADS

res = (*func)(fd);

Py_END_ALLOW_THREADS

if (res < 0)

return posix_error();

Py_INCREF(Py_None);

return Py_None;

}

#ifdef Py_WIN_WIDE_FILENAMES

static int

unicode_file_names(void)

{

static int canusewide = -1;

if (canusewide == -1) {

/* As per doc for ::GetVersion(), this is the correct test for

the Windows NT family. */

canusewide = (GetVersion() < 0x80000000) ? 1 : 0;

}

return canusewide;

}

#endif

static PyObject *

posix_1str(PyObject *args, char *format, int (*func)(const char*))

{

char *path1 = NULL;

int res;

if (!PyArg_ParseTuple(args, format,

Py_FileSystemDefaultEncoding, &path1))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = (*func)(path1);

Py_END_ALLOW_THREADS

if (res < 0)

return posix_error_with_allocated_filename(path1);

PyMem_Free(path1);

Py_INCREF(Py_None);

return Py_None;

}

static PyObject *

posix_2str(PyObject *args,

char *format,

int (*func)(const char *, const char *))

{

char *path1 = NULL, *path2 = NULL;

int res;

if (!PyArg_ParseTuple(args, format,

Py_FileSystemDefaultEncoding, &path1,

Py_FileSystemDefaultEncoding, &path2))

return NULL;

Py_BEGIN_ALLOW_THREADS

res = (*func)(path1, path2);

Py_END_ALLOW_THREADS

PyMem_Free(path1);

PyMem_Free(path2);

if (res != 0)

/* XXX how to report both path1 and path2??? */

return posix_error();

Py_INCREF(Py_None);

return Py_None;

}

#ifdef Py_WIN_WIDE_FILENAMES

static PyObject*

win32_1str(PyObject* args, char* func,

char* format, BOOL (__stdcall *funcA)(LPCSTR),

char* wformat, BOOL (__stdcall *funcW)(LPWSTR))

{

PyObject *uni;

char *ansi;

BOOL result;

if (unicode_file_names()) {

if (!PyArg_ParseTuple(args, wformat, &uni))

PyErr_Clear();

else {

Py_BEGIN_ALLOW_THREADS

result = funcW(PyUnicode_AsUnicode(uni));

Py_END_ALLOW_THREADS

if (!result)

return win32_error_unicode(func, PyUnicode_AsUnicode(uni));

Py_INCREF(Py_None);

return Py_None;

}

}

if (!PyArg_ParseTuple(args, format, &ansi))

return NULL;

Py_BEGIN_ALLOW_THREADS

result = funcA(ansi);

Py_END_ALLOW_THREADS

if (!result)

return win32_error(func, ansi);

Py_INCREF(Py_None);

return Py_None;

}

/* This is a reimplementation of the C library's chdir function,

but one that produces Win32 errors instead of DOS error codes.

chdir is essentially a wrapper around SetCurrentDirectory; however,

it also needs to set "magic" environment variables indicating

the per-drive current directory, which are of the form =<drive>: */

static BOOL __stdcall

win32_chdir(LPCSTR path)

{

char new_path[MAX_PATH+1];

int result;

char env[4] = "=x:";

if(!SetCurrentDirectoryA(path))

return FALSE;

result = GetCurrentDirectoryA(MAX_PATH+1, new_path);

if (!result)

return FALSE;

/* In the ANSI API, there should not be any paths longer

than MAX_PATH. */

assert(result <= MAX_PATH+1);

if (strncmp(new_path, "\\\\", 2) == 0 ||

strncmp(new_path, "//", 2) == 0)

/* UNC path, nothing to do. */

return TRUE;

env[1] = new_path[0];

return SetEnvironmentVariableA(env, new_path);

}

/* The Unicode version differs from the ANSI version

since the current directory might exceed MAX_PATH characters */

static BOOL __stdcall

win32_wchdir(LPCWSTR path)

{

wchar_t _new_path[MAX_PATH+1], *new_path = _new_path;

int result;

wchar_t env[4] = L"=x:";

if(!SetCurrentDirectoryW(path))

return FALSE;

result = GetCurrentDirectoryW(MAX_PATH+1, new_path);

if (!result)

return FALSE;

if (result > MAX_PATH+1) {

new_path = malloc(result * sizeof(wchar_t));

if (!new_path) {

SetLastError(ERROR_OUTOFMEMORY);

return FALSE;

}

result = GetCurrentDirectoryW(result, new_path);

if (!result) {

free(new_path);

return FALSE;

}

}

if (wcsncmp(new_path, L"\\\\", 2) == 0 ||

wcsncmp(new_path, L"//", 2) == 0)

/* UNC path, nothing to do. */

return TRUE;

env[1] = new_path[0];

result = SetEnvironmentVariableW(env, new_path);

if (new_path != _new_path)

free(new_path);

return result;

}

#endif

#ifdef MS_WINDOWS

/* The CRT of Windows has a number of flaws wrt. its stat() implementation:

- time stamps are restricted to second resolution

- file modification times suffer from forth-and-back conversions between

UTC and local time

Therefore, we implement our own stat, based on the Win32 API directly.

*/

#define HAVE_STAT_NSEC 1

struct win32_stat{

int st_dev;

__int64 st_ino;

unsigned short st_mode;

int st_nlink;

int st_uid;

int st_gid;

int st_rdev;

__int64 st_size;

int st_atime;

int st_atime_nsec;

int st_mtime;

int st_mtime_nsec;

int st_ctime;

int st_ctime_nsec;

};

static __int64 secs_between_epochs = 11644473600; /* Seconds between 1.1.1601 and 1.1.1970 */

static void

FILE_TIME_to_time_t_nsec(FILETIME *in_ptr, int *time_out, int* nsec_out)

{

/* XXX endianness. Shouldn't matter, as all Windows implementations are little-endian */

/* Cannot simply cast and dereference in_ptr,

since it might not be aligned properly */

__int64 in;

memcpy(&in, in_ptr, sizeof(in));

*nsec_out = (int)(in % 10000000) * 100; /* FILETIME is in units of 100 nsec. */

/* XXX Win32 supports time stamps past 2038; we currently don't */

*time_out = Py_SAFE_DOWNCAST((in / 10000000) - secs_between_epochs, __int64, int);

}

static void

time_t_to_FILE_TIME(int time_in, int nsec_in, FILETIME *out_ptr)

{

/* XXX endianness */

__int64 out;

out = time_in + secs_between_epochs;

out = out * 10000000 + nsec_in / 100;

memcpy(out_ptr, &out, sizeof(out));

}

/* Below, we *know* that ugo+r is 0444 */

#if _S_IREAD != 0400

#error Unsupported C library

#endif

static int

attributes_to_mode(DWORD attr)

{

int m = 0;

if (attr & FILE_ATTRIBUTE_DIRECTORY)

m |= _S_IFDIR | 0111; /* IFEXEC for user,group,other */

else

m |= _S_IFREG;

if (attr & FILE_ATTRIBUTE_READONLY)

m |= 0444;

else

m |= 0666;

return m;

}

static int

attribute_data_to_stat(WIN32_FILE_ATTRIBUTE_DATA *info, struct win32_stat *result)

{

memset(result, 0, sizeof(*result));

result->st_mode = attributes_to_mode(info->dwFileAttributes);

result->st_size = (((__int64)info->nFileSizeHigh)<<32) + info->nFileSizeLow;

FILE_TIME_to_time_t_nsec(&info->ftCreationTime, &result->st_ctime, &result->st_ctime_nsec);

FILE_TIME_to_time_t_nsec(&info->ftLastWriteTime, &result->st_mtime, &result->st_mtime_nsec);

FILE_TIME_to_time_t_nsec(&info->ftLastAccessTime, &result->st_atime, &result->st_atime_nsec);

return 0;

}

/* Emulate GetFileAttributesEx[AW] on Windows 95 */

static int checked = 0;

static BOOL (CALLBACK *gfaxa)(LPCSTR, GET_FILEEX_INFO_LEVELS, LPVOID);

static BOOL (CALLBACK *gfaxw)(LPCWSTR, GET_FILEEX_INFO_LEVELS, LPVOID);

static void

check_gfax()

{

HINSTANCE hKernel32;

if (checked)

return;

checked = 1;

hKernel32 = GetModuleHandle("KERNEL32");

*(FARPROC*)&gfaxa = GetProcAddress(hKernel32, "GetFileAttributesExA");

*(FARPROC*)&gfaxw = GetProcAddress(hKernel32, "GetFileAttributesExW");

}

static BOOL

attributes_from_dir(LPCSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)

{

HANDLE hFindFile;

WIN32_FIND_DATAA FileData;

hFindFile = FindFirstFileA(pszFile, &FileData);

if (hFindFile == INVALID_HANDLE_VALUE)

return FALSE;

FindClose(hFindFile);

pfad->dwFileAttributes = FileData.dwFileAttributes;

pfad->ftCreationTime = FileData.ftCreationTime;

pfad->ftLastAccessTime = FileData.ftLastAccessTime;

pfad->ftLastWriteTime = FileData.ftLastWriteTime;

pfad->nFileSizeHigh = FileData.nFileSizeHigh;

pfad->nFileSizeLow = FileData.nFileSizeLow;

return TRUE;

}

static BOOL

attributes_from_dir_w(LPCWSTR pszFile, LPWIN32_FILE_ATTRIBUTE_DATA pfad)

{

HANDLE hFindFile;

WIN32_FIND_DATAW FileData;

hFindFile = FindFirstFileW(pszFile, &FileData);

if (hFindFile == INVALID_HANDLE_VALUE)

return FALSE;

FindClose(hFindFile);

pfad->dwFileAttributes = FileData.dwFileAttributes;

pfad->ftCreationTime = FileData.ftCreationTime;

pfad->ftLastAccessTime = FileData.ftLastAccessTime;

pfad->ftLastWriteTime = FileData.ftLastWriteTime;

pfad->nFileSizeHigh = FileData.nFileSizeHigh;

pfad->nFileSizeLow = FileData.nFileSizeLow;

return TRUE;

}

static BOOL WINAPI

Py_GetFileAttributesExA(LPCSTR pszFile,

GET_FILEEX_INFO_LEVELS level,

LPVOID pv)

{

BOOL result;

LPWIN32_FILE_ATTRIBUTE_DATA pfad = pv;

/* First try to use the system's implementation, if that is

available and either succeeds to gives an error other than

that it isn't implemented. */

check_gfax();

if (gfaxa) {

result = gfaxa(pszFile, level, pv);

if (result || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)

return result;

}

/* It's either not present, or not implemented.

Emulate using FindFirstFile. */

if (level != GetFileExInfoStandard) {

SetLastError(ERROR_INVALID_PARAMETER);

return FALSE;

}

/* Use GetFileAttributes to validate that the file name

does not contain wildcards (which FindFirstFile would

accept). */

if (GetFileAttributesA(pszFile) == 0xFFFFFFFF)

return FALSE;

return attributes_from_dir(pszFile, pfad);

}

static BOOL WINAPI

Py_GetFileAttributesExW(LPCWSTR pszFile,

GET_FILEEX_INFO_LEVELS level,

LPVOID pv)

{

BOOL result;

LPWIN32_FILE_ATTRIBUTE_DATA pfad = pv;

/* First try to use the system's implementation, if that is

available and either succeeds to gives an error other than

that it isn't implemented. */

check_gfax();

if (gfaxa) {

result = gfaxw(pszFile, level, pv);

if (result || GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)

return result;

}

/* It's either not present, or not implemented.

Emulate using FindFirstFile. */

if (level != GetFileExInfoStandard) {

SetLastError(ERROR_INVALID_PARAMETER);

return FALSE;

}

/* Use GetFileAttributes to validate that the file name

does not contain wildcards (which FindFirstFile would

accept). */

if (GetFileAttributesW(pszFile) == 0xFFFFFFFF)

return FALSE;

return attributes_from_dir_w(pszFile, pfad);

}

static int

win32_stat(const char* path, struct win32_stat *result)

{

WIN32_FILE_ATTRIBUTE_DATA info;

int code;

char *dot;

/* XXX not supported on Win95 and NT 3.x */

if (!Py_GetFileAttributesExA(path, GetFileExInfoStandard, &info)) {

if (GetLastError() != ERROR_SHARING_VIOLATION) {

/* Protocol violation: we explicitly clear errno, instead of

setting it to a POSIX error. Callers should use GetLastError. */

errno = 0;

return -1;

} else {

/* Could not get attributes on open file. Fall back to

reading the directory. */

if (!attributes_from_dir(path, &info)) {

/* Very strange. This should not fail now */

errno = 0;

return -1;

}

}

}

code = attribute_data_to_stat(&info, result);

if (code != 0)

return code;

/* Set S_IFEXEC if it is an .exe, .bat, ... */

dot = strrchr(path, '.');

if (dot) {

if (stricmp(dot, ".bat") == 0 ||

stricmp(dot, ".cmd") == 0 ||

stricmp(dot, ".exe") == 0 ||

stricmp(dot, ".com") == 0)