#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#include "Python.h"

#include "pycore_fileutils.h"

#if defined(HAVE_PIPE2) && !defined(_GNU_SOURCE)

# define _GNU_SOURCE

#include <unistd.h>

#include <fcntl.h>

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#if defined(HAVE_SYS_STAT_H)

#include <sys/stat.h>

#ifdef HAVE_SYS_SYSCALL_H

#include <sys/syscall.h>

#if defined(HAVE_SYS_RESOURCE_H)

#include <sys/resource.h>

#ifdef HAVE_DIRENT_H

#include <dirent.h>

#ifdef HAVE_GRP_H

#include <grp.h>

#endif /* HAVE_GRP_H */

#include "posixmodule.h"

#ifdef _Py_MEMORY_SANITIZER

# include <sanitizer/msan_interface.h>

#if defined(__ANDROID__) && __ANDROID_API__ < 21 && !defined(SYS_getdents64)

# include <sys/linux-syscalls.h>

# define SYS_getdents64 __NR_getdents64

#if defined(__linux__) && defined(HAVE_VFORK) && defined(HAVE_SIGNAL_H) && \

defined(HAVE_PTHREAD_SIGMASK) && !defined(HAVE_BROKEN_PTHREAD_SIGMASK)

# include <signal.h>

# define VFORK_USABLE 1

#if defined(__sun) && defined(__SVR4)

# define readdir readdir64

# define dirent dirent64

# if !defined(HAVE_DIRFD)

# define dirfd(dirp) ((dirp)->dd_fd)

# define HAVE_DIRFD

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

# define FD_DIR "/dev/fd"

# define FD_DIR "/proc/self/fd"

#ifdef NGROUPS_MAX

#define MAX_GROUPS NGROUPS_MAX

#define MAX_GROUPS 64

#define POSIX_CALL(call) do { if ((call) == -1) goto error; } while (0)

static struct PyModuleDef _posixsubprocessmodule;

static int

_pos_int_from_ascii(const char *name)

{

int num = 0;

while (*name >= '0' && *name <= '9') {

num = num * 10 + (*name - '0');

++name;

}

if (*name)

return -1; /* Non digit found, not a number. */

return num;

}

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

static int

_is_fdescfs_mounted_on_dev_fd(void)

{

struct stat dev_stat;

struct stat dev_fd_stat;

if (stat("/dev", &dev_stat) != 0)

return 0;

if (stat(FD_DIR, &dev_fd_stat) != 0)

return 0;

if (dev_stat.st_dev == dev_fd_stat.st_dev)

return 0; /* / == /dev == /dev/fd means it is static. #fail */

return 1;

}

static int

_sanity_check_python_fd_sequence(PyObject *fd_sequence)

{

Py_ssize_t seq_idx;

long prev_fd = -1;

for (seq_idx = 0; seq_idx < PyTuple_GET_SIZE(fd_sequence); ++seq_idx) {

PyObject* py_fd = PyTuple_GET_ITEM(fd_sequence, seq_idx);

long iter_fd;

if (!PyLong_Check(py_fd)) {

return 1;

}

iter_fd = PyLong_AsLong(py_fd);

if (iter_fd < 0 || iter_fd <= prev_fd || iter_fd > INT_MAX) {

/* Negative, overflow, unsorted, too big for a fd. */

return 1;

}

prev_fd = iter_fd;

}

return 0;

}

static int

_is_fd_in_sorted_fd_sequence(int fd, PyObject *fd_sequence)

{

/* Binary search. */

Py_ssize_t search_min = 0;

Py_ssize_t search_max = PyTuple_GET_SIZE(fd_sequence) - 1;

if (search_max < 0)

return 0;

do {

long middle = (search_min + search_max) / 2;

long middle_fd = PyLong_AsLong(PyTuple_GET_ITEM(fd_sequence, middle));

if (fd == middle_fd)

return 1;

if (fd > middle_fd)

search_min = middle + 1;

else

search_max = middle - 1;

} while (search_min <= search_max);

return 0;

}

static int

make_inheritable(PyObject *py_fds_to_keep, int errpipe_write)

{

Py_ssize_t i, len;

len = PyTuple_GET_SIZE(py_fds_to_keep);

for (i = 0; i < len; ++i) {

PyObject* fdobj = PyTuple_GET_ITEM(py_fds_to_keep, i);

long fd = PyLong_AsLong(fdobj);

assert(!PyErr_Occurred());

assert(0 <= fd && fd <= INT_MAX);

if (fd == errpipe_write) {

/* errpipe_write is part of py_fds_to_keep. It must be closed at

continue;

}

if (_Py_set_inheritable_async_safe((int)fd, 1, NULL) < 0)

return -1;

}

return 0;

}

static long

safe_get_max_fd(void)

{

long local_max_fd;

#if defined(__NetBSD__)

local_max_fd = fcntl(0, F_MAXFD);

if (local_max_fd >= 0)

return local_max_fd;

#if defined(HAVE_SYS_RESOURCE_H) && defined(__OpenBSD__)

struct rlimit rl;

/* Not on the POSIX async signal safe functions list but likely

if (getrlimit(RLIMIT_NOFILE, &rl) >= 0)

return (long) rl.rlim_max;

#ifdef _SC_OPEN_MAX

local_max_fd = sysconf(_SC_OPEN_MAX);

if (local_max_fd == -1)

local_max_fd = 256; /* Matches legacy Lib/subprocess.py behavior. */

return local_max_fd;

}

static int

_close_range_except(int start_fd,

int end_fd,

PyObject *py_fds_to_keep,

int (*closer)(int, int))

{

if (end_fd == -1) {

end_fd = Py_MIN(safe_get_max_fd(), INT_MAX);

}

Py_ssize_t num_fds_to_keep = PyTuple_GET_SIZE(py_fds_to_keep);

Py_ssize_t keep_seq_idx;

/* As py_fds_to_keep is sorted we can loop through the list closing

for (keep_seq_idx = 0; keep_seq_idx < num_fds_to_keep; ++keep_seq_idx) {

PyObject* py_keep_fd = PyTuple_GET_ITEM(py_fds_to_keep, keep_seq_idx);

int keep_fd = PyLong_AsLong(py_keep_fd);

if (keep_fd < start_fd)

continue;

if (closer(start_fd, keep_fd - 1) != 0)

return -1;

start_fd = keep_fd + 1;

}

if (start_fd <= end_fd) {

if (closer(start_fd, end_fd) != 0)

return -1;

}

return 0;

}

#if defined(__linux__) && defined(HAVE_SYS_SYSCALL_H)

struct linux_dirent64 {

};

static int

_brute_force_closer(int first, int last)

{

for (int i = first; i <= last; i++) {

/* Ignore errors */

(void)close(i);

}

return 0;

}

static void

_close_open_fds_safe(int start_fd, PyObject* py_fds_to_keep)

{

int fd_dir_fd;

fd_dir_fd = _Py_open_noraise(FD_DIR, O_RDONLY);

if (fd_dir_fd == -1) {

/* No way to get a list of open fds. */

_close_range_except(start_fd, -1, py_fds_to_keep, _brute_force_closer);

return;

} else {

char buffer[sizeof(struct linux_dirent64)];

int bytes;

while ((bytes = syscall(SYS_getdents64, fd_dir_fd,

(struct linux_dirent64 *)buffer,

sizeof(buffer))) > 0) {

struct linux_dirent64 *entry;

int offset;

#ifdef _Py_MEMORY_SANITIZER

__msan_unpoison(buffer, bytes);

for (offset = 0; offset < bytes; offset += entry->d_reclen) {

int fd;

entry = (struct linux_dirent64 *)(buffer + offset);

if ((fd = _pos_int_from_ascii(entry->d_name)) < 0)

continue; /* Not a number. */

if (fd != fd_dir_fd && fd >= start_fd &&

!_is_fd_in_sorted_fd_sequence(fd, py_fds_to_keep)) {

close(fd);

}

}

}

close(fd_dir_fd);

}

}

#define _close_open_fds_fallback _close_open_fds_safe

#else /* NOT (defined(__linux__) && defined(HAVE_SYS_SYSCALL_H)) */

static int

_unsafe_closer(int first, int last)

{

_Py_closerange(first, last);

return 0;

}

static void

_close_open_fds_maybe_unsafe(int start_fd, PyObject* py_fds_to_keep)

{

DIR *proc_fd_dir;

#ifndef HAVE_DIRFD

while (_is_fd_in_sorted_fd_sequence(start_fd, py_fds_to_keep)) {

++start_fd;

}

/* Close our lowest fd before we call opendir so that it is likely to

close(start_fd);

++start_fd;

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

if (!_is_fdescfs_mounted_on_dev_fd())

proc_fd_dir = NULL;

else

proc_fd_dir = opendir(FD_DIR);

if (!proc_fd_dir) {

/* No way to get a list of open fds. */

_close_range_except(start_fd, -1, py_fds_to_keep, _unsafe_closer);

} else {

struct dirent *dir_entry;

#ifdef HAVE_DIRFD

int fd_used_by_opendir = dirfd(proc_fd_dir);

int fd_used_by_opendir = start_fd - 1;

errno = 0;

while ((dir_entry = readdir(proc_fd_dir))) {

int fd;

if ((fd = _pos_int_from_ascii(dir_entry->d_name)) < 0)

continue; /* Not a number. */

if (fd != fd_used_by_opendir && fd >= start_fd &&

!_is_fd_in_sorted_fd_sequence(fd, py_fds_to_keep)) {

close(fd);

}

errno = 0;

}

if (errno) {

/* readdir error, revert behavior. Highly Unlikely. */

_close_range_except(start_fd, -1, py_fds_to_keep, _unsafe_closer);

}

closedir(proc_fd_dir);

}

}

#define _close_open_fds_fallback _close_open_fds_maybe_unsafe

#endif /* else NOT (defined(__linux__) && defined(HAVE_SYS_SYSCALL_H)) */

#if defined(HAVE_CLOSE_RANGE) && \

(defined(__linux__) || defined(__FreeBSD__))

#define HAVE_ASYNC_SAFE_CLOSE_RANGE

static int

_close_range_closer(int first, int last)

{

return close_range(first, last, 0);

}

static void

_close_open_fds(int start_fd, PyObject* py_fds_to_keep)

{

#ifdef HAVE_ASYNC_SAFE_CLOSE_RANGE

if (_close_range_except(

start_fd, INT_MAX, py_fds_to_keep,

_close_range_closer) == 0) {

return;

}

_close_open_fds_fallback(start_fd, py_fds_to_keep);

}

#ifdef VFORK_USABLE

static void

reset_signal_handlers(const sigset_t *child_sigmask)

{

struct sigaction sa_dfl = {.sa_handler = SIG_DFL};

for (int sig = 1; sig < _NSIG; sig++) {

/* Dispositions for SIGKILL and SIGSTOP can't be changed. */

if (sig == SIGKILL || sig == SIGSTOP) {

continue;

}

/* There is no need to reset the disposition of signals that will

if (sigismember(child_sigmask, sig) == 1) {

continue;

}

struct sigaction sa;

/* C libraries usually return EINVAL for signals used

if (sigaction(sig, NULL, &sa) == -1) {

continue;

}

/* void *h works as these fields are both pointer types already. */

void *h = (sa.sa_flags & SA_SIGINFO ? (void *)sa.sa_sigaction :

(void *)sa.sa_handler);

if (h == SIG_IGN || h == SIG_DFL) {

continue;

}

/* This call can't reasonably fail, but if it does, terminating

(void) sigaction(sig, &sa_dfl, NULL);

}

}

#endif /* VFORK_USABLE */

Py_NO_INLINE static void

child_exec(char *const exec_array[],

PyObject *preexec_fn_args_tuple)

{

int i, saved_errno, reached_preexec = 0;

PyObject *result;

const char* err_msg = "";

/* Buffer large enough to hold a hex integer. We can't malloc. */

char hex_errno[sizeof(saved_errno)*2+1];

if (make_inheritable(py_fds_to_keep, errpipe_write) < 0)

goto error;

/* Close parent's pipe ends. */

if (p2cwrite != -1)

POSIX_CALL(close(p2cwrite));

if (c2pread != -1)

POSIX_CALL(close(c2pread));

if (errread != -1)

POSIX_CALL(close(errread));

POSIX_CALL(close(errpipe_read));

/* When duping fds, if there arises a situation where one of the fds is

if (c2pwrite == 0) {

POSIX_CALL(c2pwrite = dup(c2pwrite));

/* issue32270 */

if (_Py_set_inheritable_async_safe(c2pwrite, 0, NULL) < 0) {

goto error;

}

}

while (errwrite == 0 || errwrite == 1) {

POSIX_CALL(errwrite = dup(errwrite));

/* issue32270 */

if (_Py_set_inheritable_async_safe(errwrite, 0, NULL) < 0) {

goto error;

}

}

/* Dup fds for child.

if (p2cread == 0) {

if (_Py_set_inheritable_async_safe(p2cread, 1, NULL) < 0)

goto error;

}

else if (p2cread != -1)

POSIX_CALL(dup2(p2cread, 0)); /* stdin */

if (c2pwrite == 1) {

if (_Py_set_inheritable_async_safe(c2pwrite, 1, NULL) < 0)

goto error;

}

else if (c2pwrite != -1)

POSIX_CALL(dup2(c2pwrite, 1)); /* stdout */

if (errwrite == 2) {

if (_Py_set_inheritable_async_safe(errwrite, 1, NULL) < 0)

goto error;

}

else if (errwrite != -1)

POSIX_CALL(dup2(errwrite, 2)); /* stderr */

/* We no longer manually close p2cread, c2pwrite, and errwrite here as

if (cwd)

POSIX_CALL(chdir(cwd));

if (child_umask >= 0)

umask(child_umask); /* umask() always succeeds. */

if (restore_signals)

_Py_RestoreSignals();

#ifdef VFORK_USABLE

if (child_sigmask) {

reset_signal_handlers(child_sigmask);

if ((errno = pthread_sigmask(SIG_SETMASK, child_sigmask, NULL))) {

goto error;

}

}

#ifdef HAVE_SETSID

if (call_setsid)

POSIX_CALL(setsid());

#ifdef HAVE_SETPGID

static_assert(_Py_IS_TYPE_SIGNED(pid_t), "pid_t is unsigned");

if (pgid_to_set >= 0) {

POSIX_CALL(setpgid(0, pgid_to_set));

}

#ifdef HAVE_SETGROUPS

if (call_setgroups)

POSIX_CALL(setgroups(groups_size, groups));

#endif /* HAVE_SETGROUPS */

#ifdef HAVE_SETREGID

if (call_setgid)

POSIX_CALL(setregid(gid, gid));

#endif /* HAVE_SETREGID */

#ifdef HAVE_SETREUID

if (call_setuid)

POSIX_CALL(setreuid(uid, uid));

#endif /* HAVE_SETREUID */

reached_preexec = 1;

if (preexec_fn != Py_None && preexec_fn_args_tuple) {

/* This is where the user has asked us to deadlock their program. */

result = PyObject_Call(preexec_fn, preexec_fn_args_tuple, NULL);

if (result == NULL) {

/* Stringifying the exception or traceback would involve

err_msg = "Exception occurred in preexec_fn.";

errno = 0; /* We don't want to report an OSError. */

goto error;

}

/* Py_DECREF(result); - We're about to exec so why bother? */

}

/* close FDs after executing preexec_fn, which might open FDs */

if (close_fds) {

/* TODO HP-UX could use pstat_getproc() if anyone cares about it. */

_close_open_fds(3, py_fds_to_keep);

}

/* This loop matches the Lib/os.py _execvpe()'s PATH search when */

/* given the executable_list generated by Lib/subprocess.py. */

saved_errno = 0;

for (i = 0; exec_array[i] != NULL; ++i) {

const char *executable = exec_array[i];

if (envp) {

execve(executable, argv, envp);

} else {

execv(executable, argv);

}

if (errno != ENOENT && errno != ENOTDIR && saved_errno == 0) {

saved_errno = errno;

}

}

/* Report the first exec error, not the last. */

if (saved_errno)

errno = saved_errno;

error:

saved_errno = errno;

/* Report the posix error to our parent process. */

/* We ignore all write() return values as the total size of our writes is

if (saved_errno) {

char *cur;

_Py_write_noraise(errpipe_write, "OSError:", 8);

cur = hex_errno + sizeof(hex_errno);

while (saved_errno != 0 && cur != hex_errno) {

*--cur = Py_hexdigits[saved_errno % 16];

saved_errno /= 16;

}

_Py_write_noraise(errpipe_write, cur, hex_errno + sizeof(hex_errno) - cur);

_Py_write_noraise(errpipe_write, ":", 1);

if (!reached_preexec) {

/* Indicate to the parent that the error happened before exec(). */

_Py_write_noraise(errpipe_write, "noexec", 6);

}

/* We can't call strerror(saved_errno). It is not async signal safe.

} else {

_Py_write_noraise(errpipe_write, "SubprocessError:0:", 18);

_Py_write_noraise(errpipe_write, err_msg, strlen(err_msg));

}

}

Py_NO_INLINE static pid_t

do_fork_exec(char *const exec_array[],

PyObject *preexec_fn_args_tuple)

{

pid_t pid;

#ifdef VFORK_USABLE

if (child_sigmask) {

/* These are checked by our caller; verify them in debug builds. */

assert(!call_setuid);

assert(!call_setgid);

assert(!call_setgroups);

assert(preexec_fn == Py_None);

pid = vfork();

if (pid == -1) {

/* If vfork() fails, fall back to using fork(). When it isn't

pid = fork();

}

} else

{

pid = fork();

}

if (pid != 0) {

return pid;

}

/* Child process.

if (preexec_fn != Py_None) {

/* We'll be calling back into Python later so we need to do this.

PyOS_AfterFork_Child();

}

child_exec(exec_array, argv, envp, cwd,

p2cread, p2cwrite, c2pread, c2pwrite,

errread, errwrite, errpipe_read, errpipe_write,

close_fds, restore_signals, call_setsid, pgid_to_set,

call_setgid, gid, call_setgroups, groups_size, groups,

call_setuid, uid, child_umask, child_sigmask,

py_fds_to_keep, preexec_fn, preexec_fn_args_tuple);

_exit(255);

return 0; /* Dead code to avoid a potential compiler warning. */

}

static PyObject *

subprocess_fork_exec(PyObject *module, PyObject *args)

{

PyObject *gc_module = NULL;

PyObject *executable_list, *py_fds_to_keep;

PyObject *env_list, *preexec_fn;

PyObject *process_args, *converted_args = NULL, *fast_args = NULL;

PyObject *preexec_fn_args_tuple = NULL;

PyObject *groups_list;

PyObject *uid_object, *gid_object;

int p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite;

int errpipe_read, errpipe_write, close_fds, restore_signals;

int call_setsid;

pid_t pgid_to_set = -1;

int call_setgid = 0, call_setgroups = 0, call_setuid = 0;

uid_t uid;

gid_t gid, *groups = NULL;

int child_umask;

PyObject *cwd_obj, *cwd_obj2 = NULL;

const char *cwd;

pid_t pid = -1;

int need_to_reenable_gc = 0;

char *const *exec_array, *const *argv = NULL, *const *envp = NULL;

Py_ssize_t arg_num, num_groups = 0;

int need_after_fork = 0;

int saved_errno = 0;

int allow_vfork;

if (!PyArg_ParseTuple(

args, "OOpO!OOiiiiiiiiii" _Py_PARSE_PID "OOOiOp:fork_exec",

&process_args, &executable_list,

&close_fds, &PyTuple_Type, &py_fds_to_keep,

&cwd_obj, &env_list,

&p2cread, &p2cwrite, &c2pread, &c2pwrite,

&errread, &errwrite, &errpipe_read, &errpipe_write,

&restore_signals, &call_setsid, &pgid_to_set,

&gid_object, &groups_list, &uid_object, &child_umask,

&preexec_fn, &allow_vfork))

return NULL;

if ((preexec_fn != Py_None) &&

(PyInterpreterState_Get() != PyInterpreterState_Main())) {

PyErr_SetString(PyExc_RuntimeError,

"preexec_fn not supported within subinterpreters");

return NULL;

}

if (close_fds && errpipe_write < 3) { /* precondition */

PyErr_SetString(PyExc_ValueError, "errpipe_write must be >= 3");

return NULL;

}

if (_sanity_check_python_fd_sequence(py_fds_to_keep)) {

PyErr_SetString(PyExc_ValueError, "bad value(s) in fds_to_keep");

return NULL;

}

PyInterpreterState *interp = PyInterpreterState_Get();

if (!_PyInterpreterState_HasFeature(interp, Py_RTFLAGS_SUBPROCESS)) {

PyErr_SetString(PyExc_RuntimeError,

"subprocess not supported for isolated subinterpreters");

return NULL;

}

/* We need to call gc.disable() when we'll be calling preexec_fn */

if (preexec_fn != Py_None) {

need_to_reenable_gc = PyGC_Disable();

}

exec_array = _PySequence_BytesToCharpArray(executable_list);

if (!exec_array)

goto cleanup;

/* Convert args and env into appropriate arguments for exec() */

/* These conversions are done in the parent process to avoid allocating

if (process_args != Py_None) {

Py_ssize_t num_args;

/* Equivalent to: */

/* tuple(PyUnicode_FSConverter(arg) for arg in process_args) */

fast_args = PySequence_Fast(process_args, "argv must be a tuple");

if (fast_args == NULL)

goto cleanup;

num_args = PySequence_Fast_GET_SIZE(fast_args);

converted_args = PyTuple_New(num_args);

if (converted_args == NULL)

goto cleanup;

for (arg_num = 0; arg_num < num_args; ++arg_num) {

PyObject *borrowed_arg, *converted_arg;

if (PySequence_Fast_GET_SIZE(fast_args) != num_args) {

PyErr_SetString(PyExc_RuntimeError, "args changed during iteration");

goto cleanup;

}

borrowed_arg = PySequence_Fast_GET_ITEM(fast_args, arg_num);

if (PyUnicode_FSConverter(borrowed_arg, &converted_arg) == 0)

goto cleanup;

PyTuple_SET_ITEM(converted_args, arg_num, converted_arg);

}

argv = _PySequence_BytesToCharpArray(converted_args);

Py_CLEAR(converted_args);

Py_CLEAR(fast_args);

if (!argv)

goto cleanup;

}

if (env_list != Py_None) {

envp = _PySequence_BytesToCharpArray(env_list);

if (!envp)

goto cleanup;

}

if (cwd_obj != Py_None) {

if (PyUnicode_FSConverter(cwd_obj, &cwd_obj2) == 0)

goto cleanup;

cwd = PyBytes_AsString(cwd_obj2);

} else {

cwd = NULL;

}

if (groups_list != Py_None) {

#ifdef HAVE_SETGROUPS

Py_ssize_t i;

gid_t gid;

if (!PyList_Check(groups_list)) {

PyErr_SetString(PyExc_TypeError,

"setgroups argument must be a list");

goto cleanup;

}

num_groups = PySequence_Size(groups_list);

if (num_groups < 0)

goto cleanup;

if (num_groups > MAX_GROUPS) {

PyErr_SetString(PyExc_ValueError, "too many groups");

goto cleanup;

}

if ((groups = PyMem_RawMalloc(num_groups * sizeof(gid_t))) == NULL) {

PyErr_SetString(PyExc_MemoryError,

"failed to allocate memory for group list");

goto cleanup;

}

for (i = 0; i < num_groups; i++) {

PyObject *elem;

elem = PySequence_GetItem(groups_list, i);

if (!elem)

goto cleanup;

if (!PyLong_Check(elem)) {

PyErr_SetString(PyExc_TypeError,

"groups must be integers");

Py_DECREF(elem);

goto cleanup;

} else {

if (!_Py_Gid_Converter(elem, &gid)) {

Py_DECREF(elem);

PyErr_SetString(PyExc_ValueError, "invalid group id");

goto cleanup;

}

groups[i] = gid;

}

Py_DECREF(elem);

}

call_setgroups = 1;

#else /* HAVE_SETGROUPS */

PyErr_BadInternalCall();

goto cleanup;

#endif /* HAVE_SETGROUPS */

}

if (gid_object != Py_None) {

#ifdef HAVE_SETREGID

if (!_Py_Gid_Converter(gid_object, &gid))

goto cleanup;

call_setgid = 1;

#else /* HAVE_SETREGID */

PyErr_BadInternalCall();

goto cleanup;

#endif /* HAVE_SETREUID */

}

if (uid_object != Py_None) {

#ifdef HAVE_SETREUID

if (!_Py_Uid_Converter(uid_object, &uid))

goto cleanup;

call_setuid = 1;

#else /* HAVE_SETREUID */

PyErr_BadInternalCall();

goto cleanup;

#endif /* HAVE_SETREUID */

}

/* This must be the last thing done before fork() because we do not

if (preexec_fn != Py_None) {

preexec_fn_args_tuple = PyTuple_New(0);

if (!preexec_fn_args_tuple)

goto cleanup;

PyOS_BeforeFork();

need_after_fork = 1;

}

/* NOTE: When old_sigmask is non-NULL, do_fork_exec() may use vfork(). */

const void *old_sigmask = NULL;

#ifdef VFORK_USABLE