/* 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. */

#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"

#ifndef MS_WINDOWS

#include "posixmodule.h"

#endif

#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.");

#ifndef Py_USING_UNICODE

/* This is used in signatures of functions. */

#define Py_UNICODE void

#endif

#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

/* 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_POPEN 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_POPEN 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

#ifndef __rtems__

#define HAVE_POPEN 1

#endif

#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 *);

extern int pclose(FILE *);

#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 <malloc.h>

#include <windows.h>

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

#define popen _popen

#define pclose _pclose

#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 */

/* Issue #1983: pid_t can be longer than a C long on some systems */

#if !defined(SIZEOF_PID_T) || SIZEOF_PID_T == SIZEOF_INT

#define PARSE_PID "i"

#define PyLong_FromPid PyInt_FromLong

#define PyLong_AsPid PyInt_AsLong

#elif SIZEOF_PID_T == SIZEOF_LONG

#define PARSE_PID "l"

#define PyLong_FromPid PyInt_FromLong

#define PyLong_AsPid PyInt_AsLong

#elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG

#define PARSE_PID "L"

#define PyLong_FromPid PyLong_FromLongLong

#define PyLong_AsPid PyInt_AsLongLong

#else

#error "sizeof(pid_t) is neither sizeof(int), sizeof(long) or sizeof(long long)"

#endif /* SIZEOF_PID_T */

/* 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

#if defined(HAVE_TMPNAM_R) && defined(WITH_THREAD)

#define USE_TMPNAM_R

#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

#ifndef MS_WINDOWS

PyObject *

_PyInt_FromUid(uid_t uid)

{

if (uid <= LONG_MAX)

return PyInt_FromLong(uid);

return PyLong_FromUnsignedLong(uid);

}

PyObject *

_PyInt_FromGid(gid_t gid)

{

if (gid <= LONG_MAX)

return PyInt_FromLong(gid);

return PyLong_FromUnsignedLong(gid);

}

int

_Py_Uid_Converter(PyObject *obj, void *p)

{

int overflow;

long result;

if (PyFloat_Check(obj)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float");

return 0;

}

result = PyLong_AsLongAndOverflow(obj, &overflow);

if (overflow < 0)

goto OverflowDown;

if (!overflow && result == -1) {

/* error or -1 */

if (PyErr_Occurred())

return 0;

*(uid_t *)p = (uid_t)-1;

}

else {

/* unsigned uid_t */

unsigned long uresult;

if (overflow > 0) {

uresult = PyLong_AsUnsignedLong(obj);

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_OverflowError))

goto OverflowUp;

return 0;

}

} else {

if (result < 0)

goto OverflowDown;

uresult = result;

}

if (sizeof(uid_t) < sizeof(long) &&

(unsigned long)(uid_t)uresult != uresult)

goto OverflowUp;

*(uid_t *)p = (uid_t)uresult;

}

return 1;

OverflowDown:

PyErr_SetString(PyExc_OverflowError,

"user id is less than minimum");

return 0;

OverflowUp:

PyErr_SetString(PyExc_OverflowError,

"user id is greater than maximum");

return 0;

}

int

_Py_Gid_Converter(PyObject *obj, void *p)

{

int overflow;

long result;

if (PyFloat_Check(obj)) {

PyErr_SetString(PyExc_TypeError,

"integer argument expected, got float");

return 0;

}

result = PyLong_AsLongAndOverflow(obj, &overflow);

if (overflow < 0)

goto OverflowDown;

if (!overflow && result == -1) {

/* error or -1 */

if (PyErr_Occurred())

return 0;

*(gid_t *)p = (gid_t)-1;

}

else {

/* unsigned gid_t */

unsigned long uresult;

if (overflow > 0) {

uresult = PyLong_AsUnsignedLong(obj);

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_OverflowError))

goto OverflowUp;

return 0;

}

} else {

if (result < 0)

goto OverflowDown;

uresult = result;

}

if (sizeof(gid_t) < sizeof(long) &&

(unsigned long)(gid_t)uresult != uresult)

goto OverflowUp;

*(gid_t *)p = (gid_t)uresult;

}

return 1;

OverflowDown:

PyErr_SetString(PyExc_OverflowError,

"group id is less than minimum");

return 0;

OverflowUp:

PyErr_SetString(PyExc_OverflowError,

"group id is greater than maximum");

return 0;

}

#endif /* MS_WINDOWS */

#if defined(HAVE_MKNOD) && defined(HAVE_MAKEDEV)

static int

_Py_Dev_Converter(PyObject *obj, void *p)

{

PyObject *index = PyNumber_Index(obj);

if (index == NULL)

return 0;

if (PyInt_Check(index)) {

long x = PyInt_AS_LONG(index);

Py_DECREF(index);

if (x == -1 && PyErr_Occurred())

return 0;

if (x < 0) {

PyErr_SetString(PyExc_OverflowError,

"can't convert negative number to unsigned long");

return 0;

}

*((dev_t *)p) = (unsigned long)x;

}

else if (PyLong_Check(index)) {

#ifdef HAVE_LONG_LONG

*((dev_t *)p) = PyLong_AsUnsignedLongLong(index);

#else

*((dev_t *)p) = PyLong_AsUnsignedLong(index);

#endif

Py_DECREF(index);

if (PyErr_Occurred())

return 0;

}

else {

Py_DECREF(index);

PyErr_Format(PyExc_TypeError,

"expected int/long, %s found",

Py_TYPE(obj)->tp_name);

return 0;

}

return 1;

}

#endif

#ifdef HAVE_LONG_LONG

static PyObject *

_PyInt_FromDev(PY_LONG_LONG v)

{

if (LONG_MIN <= v && v <= LONG_MAX)

return PyInt_FromLong((long)v);

else

return PyLong_FromLongLong(v);

}

#else

# define _PyInt_FromDev PyInt_FromLong

#endif

#if defined _MSC_VER && _MSC_VER >= 1400

/* Microsoft CRT in VS2005 and higher will verify that a filehandle is

* valid and raise an assertion if it isn't.

* Normally, an invalid fd is likely to be a C program error and therefore

* an assertion can be useful, but it does contradict the POSIX standard

* which for write(2) states:

* "Otherwise, -1 shall be returned and errno set to indicate the error."

* "[EBADF] The fildes argument is not a valid file descriptor open for

* writing."

* Furthermore, python allows the user to enter any old integer

* as a fd and should merely raise a python exception on error.

* The Microsoft CRT doesn't provide an official way to check for the

* validity of a file descriptor, but we can emulate its internal behaviour

* by using the exported __pinfo data member and knowledge of the

* internal structures involved.

* The structures below must be updated for each version of visual studio

* according to the file internal.h in the CRT source, until MS comes

* up with a less hacky way to do this.

* (all of this is to avoid globally modifying the CRT behaviour using

* _set_invalid_parameter_handler() and _CrtSetReportMode())

*/

/* The actual size of the structure is determined at runtime.

* Only the first items must be present.

*/

typedef struct {

intptr_t osfhnd;

char osfile;

} my_ioinfo;

extern __declspec(dllimport) char * __pioinfo[];

#define IOINFO_L2E 5

#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)

#define IOINFO_ARRAYS 64

#define _NHANDLE_ (IOINFO_ARRAYS * IOINFO_ARRAY_ELTS)

#define FOPEN 0x01

#define _NO_CONSOLE_FILENO (intptr_t)-2

/* This function emulates what the windows CRT does to validate file handles */

int

_PyVerify_fd(int fd)

{

const int i1 = fd >> IOINFO_L2E;

const int i2 = fd & ((1 << IOINFO_L2E) - 1);

static int sizeof_ioinfo = 0;

/* Determine the actual size of the ioinfo structure,

* as used by the CRT loaded in memory

*/

if (sizeof_ioinfo == 0 && __pioinfo[0] != NULL) {

sizeof_ioinfo = _msize(__pioinfo[0]) / IOINFO_ARRAY_ELTS;

}

if (sizeof_ioinfo == 0) {

/* This should not happen... */

goto fail;

}

/* See that it isn't a special CLEAR fileno */

if (fd != _NO_CONSOLE_FILENO) {

/* Microsoft CRT would check that 0<=fd<_nhandle but we can't do that. Instead

* we check pointer validity and other info

*/

if (0 <= i1 && i1 < IOINFO_ARRAYS && __pioinfo[i1] != NULL) {

/* finally, check that the file is open */

my_ioinfo* info = (my_ioinfo*)(__pioinfo[i1] + i2 * sizeof_ioinfo);

if (info->osfile & FOPEN) {

return 1;

}

}

}

fail:

errno = EBADF;

return 0;

}

/* the special case of checking dup2. The target fd must be in a sensible range */

static int

_PyVerify_fd_dup2(int fd1, int fd2)

{

if (!_PyVerify_fd(fd1))

return 0;

if (fd2 == _NO_CONSOLE_FILENO)

return 0;

if ((unsigned)fd2 < _NHANDLE_)

return 1;

else

return 0;

}

#else

/* dummy version. _PyVerify_fd() is already defined in fileobject.h */

#define _PyVerify_fd_dup2(A, B) (1)

#endif

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

#if defined(WITH_NEXT_FRAMEWORK) || (defined(__APPLE__) && defined(Py_ENABLE_SHARED))

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

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

** man environ(7).

*/

#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;

char **e;

#if defined(PYOS_OS2)

APIRET rc;

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

#endif

d = PyDict_New();

if (d == NULL)

return NULL;

#if defined(WITH_NEXT_FRAMEWORK) || (defined(__APPLE__) && defined(Py_ENABLE_SHARED))

if (environ == NULL)

environ = *_NSGetEnviron();

#endif

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 = PyString_FromStringAndSize(*e, (int)(p-*e));

if (k == NULL) {

PyErr_Clear();

continue;

}

v = PyString_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);

}

#if defined(PYOS_OS2)

rc = DosQueryExtLIBPATH(buffer, BEGIN_LIBPATH);

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

PyObject *v = PyString_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 = PyString_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 MS_WINDOWS

static PyObject *

posix_error_with_unicode_filename(Py_UNICODE* name)

{

return PyErr_SetFromErrnoWithUnicodeFilename(PyExc_OSError, name);

}

#endif /* MS_WINDOWS */

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);

}

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 /* MS_WINDOWS */

#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;

if (!_PyVerify_fd(fd))

return posix_error();

Py_BEGIN_ALLOW_THREADS

res = (*func)(fd);

Py_END_ALLOW_THREADS

if (res < 0)

return posix_error();

Py_INCREF(Py_None);

return Py_None;

}

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 MS_WINDOWS

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 (!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 ||