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

#include "Python.h"

#ifdef __VXWORKS__

# include "pycore_bitutils.h" // _Py_popcount32()

#endif

#include "pycore_abstract.h" // _PyNumber_Index()

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_ceval.h" // _PyEval_ReInitThreads()

#include "pycore_fileutils.h" // _Py_closerange()

#include "pycore_initconfig.h" // _PyStatus_EXCEPTION()

#include "pycore_long.h" // _PyLong_IsNegative()

#include "pycore_moduleobject.h" // _PyModule_GetState()

#include "pycore_object.h" // _PyObject_LookupSpecial()

#include "pycore_pylifecycle.h" // _PyOS_URandom()

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_signal.h" // Py_NSIG

#include "pycore_time.h" // _PyLong_FromTime_t()

#include "pycore_typeobject.h" // _PyType_AddMethod()

#ifdef HAVE_UNISTD_H

# include <unistd.h> // symlink()

#endif

#ifdef MS_WINDOWS

# include <windows.h>

# if !defined(MS_WINDOWS_GAMES) || defined(MS_WINDOWS_DESKTOP)

# include <pathcch.h>

# endif

# include <winioctl.h>

# include <lmcons.h> // UNLEN

# include "osdefs.h" // SEP

# include <aclapi.h> // SetEntriesInAcl

# include <sddl.h> // SDDL_REVISION_1

# if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)

# define HAVE_SYMLINK

# endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_SYSTEM */

#endif

#ifndef MS_WINDOWS

# include "posixmodule.h"

#else

# include "pycore_fileutils_windows.h"

# include "winreparse.h"

#endif

#ifdef __APPLE__

/* Needed for the implementation of os.statvfs */

# include <sys/param.h>

# include <sys/mount.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> // ctermid()

#include <stdlib.h> // system()

#ifdef HAVE_SYS_TIME_H

# include <sys/time.h> // futimes()

#endif

#ifdef HAVE_SYS_PIDFD_H

# include <sys/pidfd.h> // PIDFD_NONBLOCK

#endif

// SGI apparently needs this forward declaration

#ifdef HAVE__GETPTY

# include <sys/types.h> // mode_t

extern char * _getpty(int *, int, mode_t, int);

#endif

/*

* A number of APIs are available on macOS from a certain macOS version.

* To support building with a new SDK while deploying to older versions

* the availability test is split into two:

* - HAVE_<FUNCTION>: The configure check for compile time availability

* - HAVE_<FUNCTION>_RUNTIME: Runtime check for availability

*

* The latter is always true when not on macOS, or when using a compiler

* that does not support __has_builtin (older versions of Xcode).

*

* Due to compiler restrictions there is one valid use of HAVE_<FUNCTION>_RUNTIME:

* if (HAVE_<FUNCTION>_RUNTIME) { ... }

*

* In mixing the test with other tests or using negations will result in compile

* errors.

*/

#if defined(__APPLE__)

#include <mach/mach.h>

#if defined(__has_builtin)

#if __has_builtin(__builtin_available)

#define HAVE_BUILTIN_AVAILABLE 1

#endif

#endif

#ifdef HAVE_BUILTIN_AVAILABLE

# define HAVE_FSTATAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_FACCESSAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_FCHMODAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_FCHOWNAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_LINKAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_FDOPENDIR_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_MKDIRAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_RENAMEAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_UNLINKAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_OPENAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_READLINKAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_SYMLINKAT_RUNTIME __builtin_available(macOS 10.10, iOS 8.0, *)

# define HAVE_FUTIMENS_RUNTIME __builtin_available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)

# define HAVE_UTIMENSAT_RUNTIME __builtin_available(macOS 10.13, iOS 11.0, tvOS 11.0, watchOS 4.0, *)

# define HAVE_PWRITEV_RUNTIME __builtin_available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)

# define HAVE_MKFIFOAT_RUNTIME __builtin_available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)

# define HAVE_MKNODAT_RUNTIME __builtin_available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 9.0, *)

# define HAVE_PTSNAME_R_RUNTIME __builtin_available(macOS 10.13.4, iOS 11.3, tvOS 11.3, watchOS 4.3, *)

# define HAVE_POSIX_SPAWN_SETSID_RUNTIME __builtin_available(macOS 10.15, *)

#else /* Xcode 8 or earlier */

/* __builtin_available is not present in these compilers, but

* some of the symbols might be weak linked (10.10 SDK or later

* deploying on 10.9.

*

* Fall back to the older style of availability checking for

* symbols introduced in macOS 10.10.

*/

# ifdef HAVE_FSTATAT

# define HAVE_FSTATAT_RUNTIME (fstatat != NULL)

# endif

# ifdef HAVE_FACCESSAT

# define HAVE_FACCESSAT_RUNTIME (faccessat != NULL)

# endif

# ifdef HAVE_FCHMODAT

# define HAVE_FCHMODAT_RUNTIME (fchmodat != NULL)

# endif

# ifdef HAVE_FCHOWNAT

# define HAVE_FCHOWNAT_RUNTIME (fchownat != NULL)

# endif

# ifdef HAVE_LINKAT

# define HAVE_LINKAT_RUNTIME (linkat != NULL)

# endif

# ifdef HAVE_FDOPENDIR

# define HAVE_FDOPENDIR_RUNTIME (fdopendir != NULL)

# endif

# ifdef HAVE_MKDIRAT

# define HAVE_MKDIRAT_RUNTIME (mkdirat != NULL)

# endif

# ifdef HAVE_RENAMEAT

# define HAVE_RENAMEAT_RUNTIME (renameat != NULL)

# endif

# ifdef HAVE_UNLINKAT

# define HAVE_UNLINKAT_RUNTIME (unlinkat != NULL)

# endif

# ifdef HAVE_OPENAT

# define HAVE_OPENAT_RUNTIME (openat != NULL)

# endif

# ifdef HAVE_READLINKAT

# define HAVE_READLINKAT_RUNTIME (readlinkat != NULL)

# endif

# ifdef HAVE_SYMLINKAT

# define HAVE_SYMLINKAT_RUNTIME (symlinkat != NULL)

# endif

# ifdef HAVE_UTIMENSAT

# define HAVE_UTIMENSAT_RUNTIME (utimensat != NULL)

# endif

# ifdef HAVE_FUTIMENS

# define HAVE_FUTIMENS_RUNTIME (futimens != NULL)

# endif

# ifdef HAVE_PWRITEV

# define HAVE_PWRITEV_RUNTIME (pwritev != NULL)

# endif

# ifdef HAVE_MKFIFOAT

# define HAVE_MKFIFOAT_RUNTIME (mkfifoat != NULL)

# endif

# ifdef HAVE_MKNODAT

# define HAVE_MKNODAT_RUNTIME (mknodat != NULL)

# endif

# ifdef HAVE_PTSNAME_R

# define HAVE_PTSNAME_R_RUNTIME (ptsname_r != NULL)

# endif

#endif

#ifdef HAVE_FUTIMESAT

/* Some of the logic for weak linking depends on this assertion */

# error "HAVE_FUTIMESAT unexpectedly defined"

#endif

#else

# define HAVE_FSTATAT_RUNTIME 1

# define HAVE_FACCESSAT_RUNTIME 1

# define HAVE_FCHMODAT_RUNTIME 1

# define HAVE_FCHOWNAT_RUNTIME 1

# define HAVE_LINKAT_RUNTIME 1

# define HAVE_FDOPENDIR_RUNTIME 1

# define HAVE_MKDIRAT_RUNTIME 1

# define HAVE_RENAMEAT_RUNTIME 1

# define HAVE_UNLINKAT_RUNTIME 1

# define HAVE_OPENAT_RUNTIME 1

# define HAVE_READLINKAT_RUNTIME 1

# define HAVE_SYMLINKAT_RUNTIME 1

# define HAVE_FUTIMENS_RUNTIME 1

# define HAVE_UTIMENSAT_RUNTIME 1

# define HAVE_PWRITEV_RUNTIME 1

# define HAVE_MKFIFOAT_RUNTIME 1

# define HAVE_MKNODAT_RUNTIME 1

# define HAVE_PTSNAME_R_RUNTIME 1

#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

/* Should be included before <sys/sysmacros.h> on HP-UX v3 */

# include <sys/types.h>

#endif /* HAVE_SYS_TYPES_H */

#ifdef HAVE_SYS_SYSMACROS_H

/* GNU C Library: major(), minor(), makedev() */

# include <sys/sysmacros.h>

#endif

#ifdef HAVE_SYS_STAT_H

# include <sys/stat.h>

#endif /* HAVE_SYS_STAT_H */

#ifdef HAVE_SYS_WAIT_H

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

#endif

#ifdef HAVE_LINUX_WAIT_H

# include <linux/wait.h> // P_PIDFD

#endif

#ifdef HAVE_SIGNAL_H

# include <signal.h>

#endif

#ifdef HAVE_FCNTL_H

# include <fcntl.h>

#endif

#ifdef HAVE_GRP_H

# include <grp.h>

#endif

#ifdef HAVE_SYSEXITS_H

# include <sysexits.h>

#endif

#if !defined(EX_OK) && defined(EXIT_SUCCESS)

# define EX_OK EXIT_SUCCESS

#endif

#ifdef HAVE_SYS_LOADAVG_H

# include <sys/loadavg.h>

#endif

#ifdef HAVE_SYS_SENDFILE_H

# include <sys/sendfile.h>

#endif

#if defined(__APPLE__)

# include <copyfile.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)

# if defined(HAVE_LINUX_LIMITS_H) && !defined(__FreeBSD_kernel__) && !defined(__GNU__)

# define USE_XATTRS

# include <linux/limits.h> // Needed for XATTR_SIZE_MAX on musl libc.

# endif

# if defined(__CYGWIN__)

# define USE_XATTRS

# include <cygwin/limits.h> // Needed for XATTR_SIZE_MAX and XATTR_LIST_MAX.

# endif

#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

#ifdef HAVE_WINDOWS_CONSOLE_IO

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

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

#elif defined( _MSC_VER)

/* Microsoft compiler */

# if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_APP) || defined(MS_WINDOWS_SYSTEM)

# define HAVE_GETPPID 1

# endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_APP | MS_WINDOWS_SYSTEM */

# if defined(MS_WINDOWS_DESKTOP)

# define HAVE_GETLOGIN 1

# endif /* MS_WINDOWS_DESKTOP */

# if defined(MS_WINDOWS_DESKTOP) || defined(MS_WINDOWS_SYSTEM)

# define HAVE_SPAWNV 1

# define HAVE_EXECV 1

# define HAVE_WSPAWNV 1

# define HAVE_WEXECV 1

# define HAVE_SYSTEM 1

# define HAVE_CWAIT 1

# endif /* MS_WINDOWS_DESKTOP | MS_WINDOWS_SYSTEM */

# define HAVE_PIPE 1

# define HAVE_FSYNC 1

# define fsync _commit

#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

#endif /* !_MSC_VER */

#if defined(__VXWORKS__)

# include <vxCpuLib.h>

# include <rtpLib.h>

# include <wait.h>

# include <taskLib.h>

# ifndef _P_WAIT

# define _P_WAIT 0

# define _P_NOWAIT 1

# define _P_NOWAITO 1

# endif

#endif /* __VXWORKS__ */

#ifdef HAVE_POSIX_SPAWN

# include <spawn.h>

#endif

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

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

# 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

#ifdef MS_WINDOWS

# define INITFUNC PyInit_nt

# define MODNAME "nt"

# define MODNAME_OBJ &_Py_ID(nt)

#else

# define INITFUNC PyInit_posix

# define MODNAME "posix"

# define MODNAME_OBJ &_Py_ID(posix)

#endif

#if defined(__sun)

/* Something to implement in autoconf, not present in autoconf 2.69 */

# define HAVE_STRUCT_STAT_ST_FSTYPE 1

#endif

/* memfd_create is either defined in sys/mman.h or sys/memfd.h

* linux/memfd.h defines additional flags

*/

#ifdef HAVE_SYS_MMAN_H

# include <sys/mman.h>

#endif

#ifdef HAVE_SYS_MEMFD_H

# include <sys/memfd.h>

#endif

#ifdef HAVE_LINUX_MEMFD_H

# include <linux/memfd.h>

#endif

/* eventfd() */

#ifdef HAVE_SYS_EVENTFD_H

# include <sys/eventfd.h>

#endif

/* timerfd_create() */

#ifdef HAVE_SYS_TIMERFD_H

# include <sys/timerfd.h>

#endif

#ifdef _Py_MEMORY_SANITIZER

# include <sanitizer/msan_interface.h>

#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_CallNoArgs(func);

if (res == NULL)

PyErr_WriteUnraisable(func);

else

Py_DECREF(res);

}

Py_DECREF(cpy);

}

}

}

void

PyOS_BeforeFork(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

run_at_forkers(interp->before_forkers, 1);

_PyImport_AcquireLock(interp);

_PyEval_StopTheWorldAll(&_PyRuntime);

HEAD_LOCK(&_PyRuntime);

}

void

PyOS_AfterFork_Parent(void)

{

HEAD_UNLOCK(&_PyRuntime);

_PyEval_StartTheWorldAll(&_PyRuntime);

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyImport_ReleaseLock(interp);

run_at_forkers(interp->after_forkers_parent, 0);

}

void

PyOS_AfterFork_Child(void)

{

PyStatus status;

_PyRuntimeState *runtime = &_PyRuntime;

// re-creates runtime->interpreters.mutex (HEAD_UNLOCK)

status = _PyRuntimeState_ReInitThreads(runtime);

if (_PyStatus_EXCEPTION(status)) {

goto fatal_error;

}

PyThreadState *tstate = _PyThreadState_GET();

_Py_EnsureTstateNotNULL(tstate);

assert(tstate->thread_id == PyThread_get_thread_ident());

#ifdef PY_HAVE_THREAD_NATIVE_ID

tstate->native_thread_id = PyThread_get_thread_native_id();

#endif

#ifdef Py_GIL_DISABLED

_Py_brc_after_fork(tstate->interp);

_Py_qsbr_after_fork((_PyThreadStateImpl *)tstate);

#endif

// Ideally we could guarantee tstate is running main.

_PyInterpreterState_ReinitRunningMain(tstate);

status = _PyEval_ReInitThreads(tstate);

if (_PyStatus_EXCEPTION(status)) {

goto fatal_error;

}

// Remove the dead thread states. We "start the world" once we are the only

// thread state left to undo the stop the world call in `PyOS_BeforeFork`.

// That needs to happen before `_PyThreadState_DeleteList`, because that

// may call destructors.

PyThreadState *list = _PyThreadState_RemoveExcept(tstate);

_PyEval_StartTheWorldAll(&_PyRuntime);

_PyThreadState_DeleteList(list);

_PyImport_ReInitLock(tstate->interp);

_PyImport_ReleaseLock(tstate->interp);

_PySignal_AfterFork();

status = _PyInterpreterState_DeleteExceptMain(runtime);

if (_PyStatus_EXCEPTION(status)) {

goto fatal_error;

}

assert(_PyThreadState_GET() == tstate);

status = _PyPerfTrampoline_AfterFork_Child();

if (_PyStatus_EXCEPTION(status)) {

goto fatal_error;

}

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

return;

fatal_error:

Py_ExitStatusException(status);

}

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

/* Legacy wrapper */

void

PyOS_AfterFork(void)

{

#ifdef HAVE_FORK

PyOS_AfterFork_Child();

#endif

}

#ifdef MS_WINDOWS

/* defined in fileutils.c */

void _Py_time_t_to_FILE_TIME(time_t, int, FILETIME *);

void _Py_attribute_data_to_stat(BY_HANDLE_FILE_INFORMATION *, ULONG,

FILE_BASIC_INFO *, FILE_ID_INFO *,

struct _Py_stat_struct *);

void _Py_stat_basic_info_to_stat(FILE_STAT_BASIC_INFORMATION *,

struct _Py_stat_struct *);

#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, uid_t *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",

_PyType_Name(Py_TYPE(obj)));

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

*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, gid_t *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",

_PyType_Name(Py_TYPE(obj)));

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

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

static PyObject *

_PyLong_FromDev(dev_t dev)

{

#ifdef NODEV

if (dev == NODEV) {

return PyLong_FromLongLong((long long)dev);

}

#endif

return PyLong_FromUnsignedLongLong((unsigned long long)dev);

}

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

static int

_Py_Dev_Converter(PyObject *obj, void *p)

{

#ifdef NODEV

if (PyLong_Check(obj) && _PyLong_IsNegative((PyLongObject *)obj)) {

int overflow;

long long result = PyLong_AsLongLongAndOverflow(obj, &overflow);

if (result == -1 && PyErr_Occurred()) {

return 0;

}

if (!overflow && result == (long long)NODEV) {

*((dev_t *)p) = NODEV;

return 1;