/* 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 "pythread.h"

#include "structmember.h"

#ifndef MS_WINDOWS

#include "posixmodule.h"

#else

#include "winreparse.h"

#endif

/* On android API level 21, 'AT_EACCESS' is not declared although

* HAVE_FACCESSAT is defined. */

#ifdef __ANDROID__

#undef HAVE_FACCESSAT

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

#ifdef HAVE_LINUX_RANDOM_H

# include <linux/random.h>

#endif

#ifdef HAVE_GETRANDOM_SYSCALL

# include <sys/syscall.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_WSPAWNV 1

#define HAVE_WEXECV 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 HAVE_FORK

static void

run_at_forkers(PyObject *lst, int reverse)

{

Py_ssize_t i;

PyObject *cpy;

if (lst != NULL) {

assert(PyList_CheckExact(lst));

/* Use a list copy in case register_at_fork() is called from

* one of the callbacks.

*/

cpy = PyList_GetSlice(lst, 0, PyList_GET_SIZE(lst));

if (cpy == NULL)

PyErr_WriteUnraisable(lst);

else {

if (reverse)

PyList_Reverse(cpy);

for (i = 0; i < PyList_GET_SIZE(cpy); i++) {

PyObject *func, *res;

func = PyList_GET_ITEM(cpy, i);

res = PyObject_CallObject(func, NULL);

if (res == NULL)

PyErr_WriteUnraisable(func);

else

Py_DECREF(res);

}

Py_DECREF(cpy);

}

}

}

void

PyOS_BeforeFork(void)

{

run_at_forkers(PyThreadState_Get()->interp->before_forkers, 1);

_PyImport_AcquireLock();

}

void

PyOS_AfterFork_Parent(void)

{

if (_PyImport_ReleaseLock() <= 0)

Py_FatalError("failed releasing import lock after fork");

run_at_forkers(PyThreadState_Get()->interp->after_forkers_parent, 0);

}

void

PyOS_AfterFork_Child(void)

{

#ifdef WITH_THREAD

/* PyThread_ReInitTLS() must be called early, to make sure that the TLS API

* can be called safely. */

PyThread_ReInitTLS();

_PyGILState_Reinit();

PyEval_ReInitThreads();

_PyImport_ReInitLock();

#endif

_PySignal_AfterFork();

run_at_forkers(PyThreadState_Get()->interp->after_forkers_child, 0);

}

static int

register_at_forker(PyObject **lst, PyObject *func)

{

if (func == NULL) /* nothing to register? do nothing. */

return 0;

if (*lst == NULL) {

*lst = PyList_New(0);

if (*lst == NULL)

return -1;

}

return PyList_Append(*lst, func);

}

#endif

/* Legacy wrapper */

void

PyOS_AfterFork(void)

{

#ifdef HAVE_FORK

PyOS_AfterFork_Child();

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

#define _PyLong_FromDev PyLong_FromLongLong

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

static int

_Py_Dev_Converter(PyObject *obj, void *p)

{

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

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)

{

int overflow;

long long_value;

PyObject *index = PyNumber_Index(o);

if (index == NULL) {

return 0;

}

assert(PyLong_Check(index));

long_value = PyLong_AsLongAndOverflow(index, &overflow);

Py_DECREF(index);

assert(!PyErr_Occurred());

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;

}

else if (PyIndex_Check(o)) {

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

}

else {

PyErr_Format(PyExc_TypeError,

"argument should be integer or None, not %.200s",

Py_TYPE(o)->tp_name);

return 0;

}

}

/*

* 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 decode to wchar_t * 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. (On Windows,

* is a non-zero integer if the path was expressed as bytes.

* The type is deliberately incompatible to prevent misuse.)

* 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 (if get a PathLike object,

* the result of PyOS_FSPath() is treated as the original object).

* Own a reference to the object.

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

const wchar_t *wide;

#ifdef MS_WINDOWS

BOOL narrow;

#else

const char *narrow;

#endif

int fd;

Py_ssize_t length;

PyObject *object;

PyObject *cleanup;

} path_t;

#ifdef MS_WINDOWS

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

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

#else

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

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

#endif

static void

path_cleanup(path_t *path)

{

Py_CLEAR(path->object);

Py_CLEAR(path->cleanup);

}

static int

path_converter(PyObject *o, void *p)

{

path_t *path = (path_t *)p;

PyObject *bytes = NULL;

Py_ssize_t length = 0;

int is_index, is_buffer, is_bytes, is_unicode;

const char *narrow;

#ifdef MS_WINDOWS

PyObject *wo = NULL;

const wchar_t *wide;

#endif

#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->object = path->cleanup = NULL;

/* path->object owns a reference to the original object */

Py_INCREF(o);

if ((o == Py_None) && path->nullable) {

path->wide = NULL;

#ifdef MS_WINDOWS

path->narrow = FALSE;

#else

path->narrow = NULL;

#endif

path->fd = -1;

goto success_exit;

}

/* Only call this here so that we don't treat the return value of

os.fspath() as an fd or buffer. */

is_index = path->allow_fd && PyIndex_Check(o);

is_buffer = PyObject_CheckBuffer(o);

is_bytes = PyBytes_Check(o);

is_unicode = PyUnicode_Check(o);

if (!is_index && !is_buffer && !is_unicode && !is_bytes) {

/* Inline PyOS_FSPath() for better error messages. */

_Py_IDENTIFIER(__fspath__);

PyObject *func = NULL;

func = _PyObject_LookupSpecial(o, &PyId___fspath__);

if (NULL == func) {

goto error_format;

}

/* still owns a reference to the original object */

Py_DECREF(o);

o = _PyObject_CallNoArg(func);

Py_DECREF(func);

if (NULL == o) {

goto error_exit;

}

else if (PyUnicode_Check(o)) {

is_unicode = 1;