/* POSIX module implementation */

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

module actually calls itself 'nt', 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. '_MSC_VER'. */

#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 "structmember.h"

#ifndef MS_WINDOWS

#include "posixmodule.h"

#else

#include "winreparse.h"

#endif

#include <stdio.h> /* needed for ctermid() */

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

#ifdef HAVE_SYS_UIO_H

#include <sys/uio.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

#ifdef HAVE_SYS_SENDFILE_H

#include <sys/sendfile.h>

#endif

#ifdef HAVE_SCHED_H

#include <sched.h>

#endif

#if !defined(CPU_ALLOC) && defined(HAVE_SCHED_SETAFFINITY)

#undef HAVE_SCHED_SETAFFINITY

#endif

#if defined(HAVE_SYS_XATTR_H) && defined(__GLIBC__) && !defined(__FreeBSD_kernel__) && !defined(__GNU__)

#define USE_XATTRS

#endif

#ifdef USE_XATTRS

#include <sys/xattr.h>

#endif

#if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__APPLE__)

#ifdef HAVE_SYS_SOCKET_H

#include <sys/socket.h>

#endif

#endif

#ifdef HAVE_DLFCN_H

#include <dlfcn.h>

#endif

#ifdef __hpux

#include <sys/mpctl.h>

#endif

#if defined(__DragonFly__) || \

defined(__OpenBSD__) || \

defined(__FreeBSD__) || \

defined(__NetBSD__) || \

defined(__APPLE__)

#include <sys/sysctl.h>

#endif

#if defined(MS_WINDOWS)

# define TERMSIZE_USE_CONIO

#elif defined(HAVE_SYS_IOCTL_H)

# include <sys/ioctl.h>

# if defined(HAVE_TERMIOS_H)

# include <termios.h>

# endif

# if defined(TIOCGWINSZ)

# define TERMSIZE_USE_IOCTL

# endif

#endif /* MS_WINDOWS */

/* Various compilers have only certain posix functions */

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

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

#define HAVE_OPENDIR 1

#define HAVE_SYSTEM 1

#include <process.h>

#else

#ifdef _MSC_VER /* Microsoft compiler */

#define HAVE_GETPPID 1

#define HAVE_GETLOGIN 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

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

#endif /* ! __WATCOMC__ || __QNX__ */

/*[clinic input]

# one of the few times we lie about this name!

module os

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=94a0f0f978acae17]*/

#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

extern int chmod(const char *, mode_t);

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

#ifndef VOLUME_NAME_DOS

#define VOLUME_NAME_DOS 0x0

#endif

#ifndef VOLUME_NAME_NT

#define VOLUME_NAME_NT 0x2

#endif

#ifndef IO_REPARSE_TAG_SYMLINK

#define IO_REPARSE_TAG_SYMLINK (0xA000000CL)

#endif

#ifndef IO_REPARSE_TAG_MOUNT_POINT

#define IO_REPARSE_TAG_MOUNT_POINT (0xA0000003L)

#endif

#include "osdefs.h"

#include <malloc.h>

#include <windows.h>

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

#include <lmcons.h> /* for UNLEN */

#ifdef SE_CREATE_SYMBOLIC_LINK_NAME /* Available starting with Vista */

#define HAVE_SYMLINK

static int win32_can_symlink = 0;

#endif

#endif /* _MSC_VER */

#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

#undef FSTAT

#undef STRUCT_STAT

#ifdef MS_WINDOWS

# define STAT win32_stat

# define LSTAT win32_lstat

# define FSTAT _Py_fstat_noraise

# define STRUCT_STAT struct _Py_stat_struct

#else

# define STAT stat

# define LSTAT lstat

# 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

#define DWORD_MAX 4294967295U

#ifdef MS_WINDOWS

#define INITFUNC PyInit_nt

#define MODNAME "nt"

#else

#define INITFUNC PyInit_posix

#define MODNAME "posix"

#endif

#ifdef MS_WINDOWS

/* defined in fileutils.c */

PyAPI_FUNC(void) _Py_time_t_to_FILE_TIME(time_t, int, FILETIME *);

PyAPI_FUNC(void) _Py_attribute_data_to_stat(BY_HANDLE_FILE_INFORMATION *,

ULONG, struct _Py_stat_struct *);

#endif

#ifdef MS_WINDOWS

static int

win32_warn_bytes_api()

{

return PyErr_WarnEx(PyExc_DeprecationWarning,

"The Windows bytes API has been deprecated, "

"use Unicode filenames instead",

1);

}

#endif

#ifndef MS_WINDOWS

PyObject *

_PyLong_FromUid(uid_t uid)

{

if (uid == (uid_t)-1)

return PyLong_FromLong(-1);

return PyLong_FromUnsignedLong(uid);

}

PyObject *

_PyLong_FromGid(gid_t gid)

{

if (gid == (gid_t)-1)

return PyLong_FromLong(-1);

return PyLong_FromUnsignedLong(gid);

}

int

_Py_Uid_Converter(PyObject *obj, void *p)

{

uid_t uid;

PyObject *index;

int overflow;

long result;

unsigned long uresult;

index = PyNumber_Index(obj);

if (index == NULL) {

PyErr_Format(PyExc_TypeError,

"uid should be integer, not %.200s",

Py_TYPE(obj)->tp_name);

return 0;

}

/*

* Handling uid_t is complicated for two reasons:

* * Although uid_t is (always?) unsigned, it still

* accepts -1.

* * We don't know its size in advance--it may be

* bigger than an int, or it may be smaller than

* a long.

*

* So a bit of defensive programming is in order.

* Start with interpreting the value passed

* in as a signed long and see if it works.

*/

result = PyLong_AsLongAndOverflow(index, &overflow);

if (!overflow) {

uid = (uid_t)result;

if (result == -1) {

if (PyErr_Occurred())

goto fail;

/* It's a legitimate -1, we're done. */

goto success;

}

/* Any other negative number is disallowed. */

if (result < 0)

goto underflow;

/* Ensure the value wasn't truncated. */

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

(long)uid != result)

goto underflow;

goto success;

}

if (overflow < 0)

goto underflow;

/*

* Okay, the value overflowed a signed long. If it

* fits in an *unsigned* long, it may still be okay,

* as uid_t may be unsigned long on this platform.

*/

uresult = PyLong_AsUnsignedLong(index);

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_OverflowError))

goto overflow;

goto fail;

}

uid = (uid_t)uresult;

/*

* If uid == (uid_t)-1, the user actually passed in ULONG_MAX,

* but this value would get interpreted as (uid_t)-1 by chown

* and its siblings. That's not what the user meant! So we

* throw an overflow exception instead. (We already

* handled a real -1 with PyLong_AsLongAndOverflow() above.)

*/

if (uid == (uid_t)-1)

goto overflow;

/* Ensure the value wasn't truncated. */

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

(unsigned long)uid != uresult)

goto overflow;

/* fallthrough */

success:

Py_DECREF(index);

*(uid_t *)p = uid;

return 1;

underflow:

PyErr_SetString(PyExc_OverflowError,

"uid is less than minimum");

goto fail;

overflow:

PyErr_SetString(PyExc_OverflowError,

"uid is greater than maximum");

/* fallthrough */

fail:

Py_DECREF(index);

return 0;

}

int

_Py_Gid_Converter(PyObject *obj, void *p)

{

gid_t gid;

PyObject *index;

int overflow;

long result;

unsigned long uresult;

index = PyNumber_Index(obj);

if (index == NULL) {

PyErr_Format(PyExc_TypeError,

"gid should be integer, not %.200s",

Py_TYPE(obj)->tp_name);

return 0;

}

/*

* Handling gid_t is complicated for two reasons:

* * Although gid_t is (always?) unsigned, it still

* accepts -1.

* * We don't know its size in advance--it may be

* bigger than an int, or it may be smaller than

* a long.

*

* So a bit of defensive programming is in order.

* Start with interpreting the value passed

* in as a signed long and see if it works.

*/

result = PyLong_AsLongAndOverflow(index, &overflow);

if (!overflow) {

gid = (gid_t)result;

if (result == -1) {

if (PyErr_Occurred())

goto fail;

/* It's a legitimate -1, we're done. */

goto success;

}

/* Any other negative number is disallowed. */

if (result < 0) {

goto underflow;

}

/* Ensure the value wasn't truncated. */

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

(long)gid != result)

goto underflow;

goto success;

}

if (overflow < 0)

goto underflow;

/*

* Okay, the value overflowed a signed long. If it

* fits in an *unsigned* long, it may still be okay,

* as gid_t may be unsigned long on this platform.

*/

uresult = PyLong_AsUnsignedLong(index);

if (PyErr_Occurred()) {

if (PyErr_ExceptionMatches(PyExc_OverflowError))

goto overflow;

goto fail;

}

gid = (gid_t)uresult;

/*

* If gid == (gid_t)-1, the user actually passed in ULONG_MAX,

* but this value would get interpreted as (gid_t)-1 by chown

* and its siblings. That's not what the user meant! So we

* throw an overflow exception instead. (We already

* handled a real -1 with PyLong_AsLongAndOverflow() above.)

*/

if (gid == (gid_t)-1)

goto overflow;

/* Ensure the value wasn't truncated. */

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

(unsigned long)gid != uresult)

goto overflow;

/* fallthrough */

success:

Py_DECREF(index);

*(gid_t *)p = gid;

return 1;

underflow:

PyErr_SetString(PyExc_OverflowError,

"gid is less than minimum");

goto fail;

overflow:

PyErr_SetString(PyExc_OverflowError,

"gid is greater than maximum");

/* fallthrough */

fail:

Py_DECREF(index);

return 0;

}

#endif /* MS_WINDOWS */

#ifdef HAVE_LONG_LONG

# define _PyLong_FromDev PyLong_FromLongLong

#else

# define _PyLong_FromDev PyLong_FromLong

#endif

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

static int

_Py_Dev_Converter(PyObject *obj, void *p)

{

#ifdef HAVE_LONG_LONG

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

#else

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

#endif

if (PyErr_Occurred())

return 0;

return 1;

}

#endif /* HAVE_MKNOD && HAVE_MAKEDEV */

#ifdef AT_FDCWD

/*

* Why the (int) cast? Solaris 10 defines AT_FDCWD as 0xffd19553 (-3041965);

* without the int cast, the value gets interpreted as uint (4291925331),

* which doesn't play nicely with all the initializer lines in this file that

* look like this:

* int dir_fd = DEFAULT_DIR_FD;

*/

#define DEFAULT_DIR_FD (int)AT_FDCWD

#else

#define DEFAULT_DIR_FD (-100)

#endif

static int

_fd_converter(PyObject *o, int *p, const char *allowed)

{

int overflow;

long long_value;

PyObject *index = PyNumber_Index(o);

if (index == NULL) {

PyErr_Format(PyExc_TypeError,

"argument should be %s, not %.200s",

allowed, Py_TYPE(o)->tp_name);

return 0;

}

long_value = PyLong_AsLongAndOverflow(index, &overflow);

Py_DECREF(index);

if (overflow > 0 || long_value > INT_MAX) {

PyErr_SetString(PyExc_OverflowError,

"fd is greater than maximum");

return 0;

}

if (overflow < 0 || long_value < INT_MIN) {

PyErr_SetString(PyExc_OverflowError,

"fd is less than minimum");

return 0;

}

*p = (int)long_value;

return 1;

}

static int

dir_fd_converter(PyObject *o, void *p)

{

if (o == Py_None) {

*(int *)p = DEFAULT_DIR_FD;

return 1;

}

return _fd_converter(o, (int *)p, "integer");

}

/*

* A PyArg_ParseTuple "converter" function

* that handles filesystem paths in the manner

* preferred by the os module.

*

* path_converter accepts (Unicode) strings and their

* subclasses, and bytes and their subclasses. What

* it does with the argument depends on the platform:

*

* * On Windows, if we get a (Unicode) string we

* extract the wchar_t * and return it; if we get

* bytes we extract the char * and return that.

*

* * On all other platforms, strings are encoded

* to bytes using PyUnicode_FSConverter, then we

* extract the char * from the bytes object and

* return that.

*

* path_converter also optionally accepts signed

* integers (representing open file descriptors) instead

* of path strings.

*

* Input fields:

* path.nullable

* If nonzero, the path is permitted to be None.

* path.allow_fd

* If nonzero, the path is permitted to be a file handle

* (a signed int) instead of a string.

* path.function_name

* If non-NULL, path_converter will use that as the name

* of the function in error messages.

* (If path.function_name is NULL it omits the function name.)

* path.argument_name

* If non-NULL, path_converter will use that as the name

* of the parameter in error messages.

* (If path.argument_name is NULL it uses "path".)

*

* Output fields:

* path.wide

* Points to the path if it was expressed as Unicode

* and was not encoded. (Only used on Windows.)

* path.narrow

* Points to the path if it was expressed as bytes,

* or it was Unicode and was encoded to bytes.

* path.fd

* Contains a file descriptor if path.accept_fd was true

* and the caller provided a signed integer instead of any

* sort of string.

*

* WARNING: if your "path" parameter is optional, and is

* unspecified, path_converter will never get called.

* So if you set allow_fd, you *MUST* initialize path.fd = -1

* yourself!

* path.length

* The length of the path in characters, if specified as

* a string.

* path.object

* The original object passed in.

* path.cleanup

* For internal use only. May point to a temporary object.

* (Pay no attention to the man behind the curtain.)

*

* At most one of path.wide or path.narrow will be non-NULL.

* If path was None and path.nullable was set,

* or if path was an integer and path.allow_fd was set,

* both path.wide and path.narrow will be NULL

* and path.length will be 0.

*

* path_converter takes care to not write to the path_t

* unless it's successful. However it must reset the

* "cleanup" field each time it's called.

*

* Use as follows:

* path_t path;

* memset(&path, 0, sizeof(path));

* PyArg_ParseTuple(args, "O&", path_converter, &path);

* // ... use values from path ...

* path_cleanup(&path);

*

* (Note that if PyArg_Parse fails you don't need to call

* path_cleanup(). However it is safe to do so.)

*/

typedef struct {

const char *function_name;

const char *argument_name;

int nullable;

int allow_fd;

wchar_t *wide;

char *narrow;

int fd;

Py_ssize_t length;

PyObject *object;

PyObject *cleanup;

} path_t;

#define PATH_T_INITIALIZE(function_name, argument_name, nullable, allow_fd) \

{function_name, argument_name, nullable, allow_fd, NULL, NULL, -1, 0, NULL, NULL}

static void

path_cleanup(path_t *path) {

if (path->cleanup) {

Py_CLEAR(path->cleanup);

}

}

static int

path_converter(PyObject *o, void *p) {

path_t *path = (path_t *)p;

PyObject *unicode, *bytes;

Py_ssize_t length;

char *narrow;

#define FORMAT_EXCEPTION(exc, fmt) \

PyErr_Format(exc, "%s%s" fmt, \

path->function_name ? path->function_name : "", \

path->function_name ? ": " : "", \

path->argument_name ? path->argument_name : "path")

/* Py_CLEANUP_SUPPORTED support */

if (o == NULL) {

path_cleanup(path);

return 1;

}

/* ensure it's always safe to call path_cleanup() */

path->cleanup = NULL;

if (o == Py_None) {

if (!path->nullable) {

FORMAT_EXCEPTION(PyExc_TypeError,

"can't specify None for %s argument");

return 0;

}

path->wide = NULL;

path->narrow = NULL;

path->length = 0;

path->object = o;

path->fd = -1;

return 1;

}

unicode = PyUnicode_FromObject(o);

if (unicode) {

#ifdef MS_WINDOWS

wchar_t *wide;

wide = PyUnicode_AsUnicodeAndSize(unicode, &length);

if (!wide) {

Py_DECREF(unicode);

return 0;

}

if (length > 32767) {

FORMAT_EXCEPTION(PyExc_ValueError, "%s too long for Windows");

Py_DECREF(unicode);

return 0;

}

if (wcslen(wide) != length) {

FORMAT_EXCEPTION(PyExc_ValueError, "embedded null character");

Py_DECREF(unicode);

return 0;

}

path->wide = wide;

path->narrow = NULL;

path->length = length;

path->object = o;

path->fd = -1;

path->cleanup = unicode;

return Py_CLEANUP_SUPPORTED;

#else

int converted = PyUnicode_FSConverter(unicode, &bytes);

Py_DECREF(unicode);

if (!converted)

bytes = NULL;

#endif

}

else {

PyErr_Clear();

if (PyObject_CheckBuffer(o))

bytes = PyBytes_FromObject(o);

else

bytes = NULL;

if (!bytes) {

PyErr_Clear();

if (path->allow_fd) {

int fd;

int result = _fd_converter(o, &fd,

"string, bytes or integer");

if (result) {

path->wide = NULL;

path->narrow = NULL;

path->length = 0;

path->object = o;

path->fd = fd;

return result;

}

}

}

}

if (!bytes) {

if (!PyErr_Occurred())

FORMAT_EXCEPTION(PyExc_TypeError, "illegal type for %s parameter");

return 0;

}

#ifdef MS_WINDOWS

if (win32_warn_bytes_api()) {

Py_DECREF(bytes);

return 0;

}

#endif

length = PyBytes_GET_SIZE(bytes);

#ifdef MS_WINDOWS

if (length > MAX_PATH-1) {

FORMAT_EXCEPTION(PyExc_ValueError, "%s too long for Windows");

Py_DECREF(bytes);

return 0;

}

#endif

narrow = PyBytes_AS_STRING(bytes);

if ((size_t)length != strlen(narrow)) {

FORMAT_EXCEPTION(PyExc_ValueError, "embedded null character in %s");

Py_DECREF(bytes);

return 0;

}

path->wide = NULL;

path->narrow = narrow;

path->length = length;

path->object = o;

path->fd = -1;

path->cleanup = bytes;

return Py_CLEANUP_SUPPORTED;

}

static void

argument_unavailable_error(char *function_name, char *argument_name) {

PyErr_Format(PyExc_NotImplementedError,

"%s%s%s unavailable on this platform",

(function_name != NULL) ? function_name : "",

(function_name != NULL) ? ": ": "",

argument_name);

}

static int

dir_fd_unavailable(PyObject *o, void *p)

{

int dir_fd;

if (!dir_fd_converter(o, &dir_fd))

return 0;

if (dir_fd != DEFAULT_DIR_FD) {

argument_unavailable_error(NULL, "dir_fd");

return 0;

}

*(int *)p = dir_fd;

return 1;

}

static int

fd_specified(char *function_name, int fd) {

if (fd == -1)

return 0;

argument_unavailable_error(function_name, "fd");

return 1;

}

static int

follow_symlinks_specified(char *function_name, int follow_symlinks) {

if (follow_symlinks)

return 0;

argument_unavailable_error(function_name, "follow_symlinks");

return 1;

}

static int

path_and_dir_fd_invalid(char *function_name, path_t *path, int dir_fd) {

if (!path->narrow && !path->wide && (dir_fd != DEFAULT_DIR_FD)) {

PyErr_Format(PyExc_ValueError,

"%s: can't specify dir_fd without matching path",

function_name);

return 1;