Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
8525 lines (7691 sloc) 228 KB
/**********************************************************************
process.c -
$Author$
created at: Tue Aug 10 14:30:50 JST 1993
Copyright (C) 1993-2007 Yukihiro Matsumoto
Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
Copyright (C) 2000 Information-technology Promotion Agency, Japan
**********************************************************************/
#include "ruby/config.h"
#include "ruby/io.h"
#include "internal.h"
#include "ruby/thread.h"
#include "ruby/util.h"
#include "vm_core.h"
#include "hrtime.h"
#include <stdio.h>
#include <errno.h>
#include <signal.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_PROCESS_H
#include <process.h>
#endif
#include <time.h>
#include <ctype.h>
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0
#endif
#ifndef EXIT_FAILURE
#define EXIT_FAILURE 1
#endif
#ifdef HAVE_SYS_WAIT_H
# include <sys/wait.h>
#endif
#ifdef HAVE_SYS_RESOURCE_H
# include <sys/resource.h>
#endif
#ifdef HAVE_VFORK_H
# include <vfork.h>
#endif
#ifdef HAVE_SYS_PARAM_H
# include <sys/param.h>
#endif
#ifndef MAXPATHLEN
# define MAXPATHLEN 1024
#endif
#include "ruby/st.h"
#include <sys/stat.h>
#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef HAVE_SYS_TIMES_H
#include <sys/times.h>
#endif
#ifdef HAVE_PWD_H
#include <pwd.h>
#endif
#ifdef HAVE_GRP_H
#include <grp.h>
# ifdef __CYGWIN__
int initgroups(const char *, rb_gid_t);
# endif
#endif
#ifdef HAVE_SYS_ID_H
#include <sys/id.h>
#endif
#ifdef __APPLE__
# include <mach/mach_time.h>
#endif
/* define system APIs */
#ifdef _WIN32
#undef open
#define open rb_w32_uopen
#endif
#if defined(HAVE_TIMES) || defined(_WIN32)
static VALUE rb_cProcessTms;
#endif
#ifndef WIFEXITED
#define WIFEXITED(w) (((w) & 0xff) == 0)
#endif
#ifndef WIFSIGNALED
#define WIFSIGNALED(w) (((w) & 0x7f) > 0 && (((w) & 0x7f) < 0x7f))
#endif
#ifndef WIFSTOPPED
#define WIFSTOPPED(w) (((w) & 0xff) == 0x7f)
#endif
#ifndef WEXITSTATUS
#define WEXITSTATUS(w) (((w) >> 8) & 0xff)
#endif
#ifndef WTERMSIG
#define WTERMSIG(w) ((w) & 0x7f)
#endif
#ifndef WSTOPSIG
#define WSTOPSIG WEXITSTATUS
#endif
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__)
#define HAVE_44BSD_SETUID 1
#define HAVE_44BSD_SETGID 1
#endif
#ifdef __NetBSD__
#undef HAVE_SETRUID
#undef HAVE_SETRGID
#endif
#ifdef BROKEN_SETREUID
#define setreuid ruby_setreuid
int setreuid(rb_uid_t ruid, rb_uid_t euid);
#endif
#ifdef BROKEN_SETREGID
#define setregid ruby_setregid
int setregid(rb_gid_t rgid, rb_gid_t egid);
#endif
#if defined(HAVE_44BSD_SETUID) || defined(__APPLE__)
#if !defined(USE_SETREUID) && !defined(BROKEN_SETREUID)
#define OBSOLETE_SETREUID 1
#endif
#if !defined(USE_SETREGID) && !defined(BROKEN_SETREGID)
#define OBSOLETE_SETREGID 1
#endif
#endif
static void check_uid_switch(void);
static void check_gid_switch(void);
static int exec_async_signal_safe(const struct rb_execarg *, char *, size_t);
#if 1
#define p_uid_from_name p_uid_from_name
#define p_gid_from_name p_gid_from_name
#endif
#if defined(HAVE_PWD_H)
# if defined(HAVE_GETPWNAM_R) && defined(_SC_GETPW_R_SIZE_MAX)
# define USE_GETPWNAM_R 1
# define GETPW_R_SIZE_INIT sysconf(_SC_GETPW_R_SIZE_MAX)
# define GETPW_R_SIZE_DEFAULT 0x1000
# define GETPW_R_SIZE_LIMIT 0x10000
# endif
# ifdef USE_GETPWNAM_R
# define PREPARE_GETPWNAM \
VALUE getpw_buf = 0
# define FINISH_GETPWNAM \
(getpw_buf ? (void)rb_str_resize(getpw_buf, 0) : (void)0)
# define OBJ2UID1(id) obj2uid((id), &getpw_buf)
# define OBJ2UID(id) obj2uid0(id)
static rb_uid_t obj2uid(VALUE id, VALUE *getpw_buf);
static inline rb_uid_t
obj2uid0(VALUE id)
{
rb_uid_t uid;
PREPARE_GETPWNAM;
uid = OBJ2UID1(id);
FINISH_GETPWNAM;
return uid;
}
# else
# define PREPARE_GETPWNAM /* do nothing */
# define FINISH_GETPWNAM /* do nothing */
# define OBJ2UID1(id) obj2uid((id))
# define OBJ2UID(id) obj2uid((id))
static rb_uid_t obj2uid(VALUE id);
# endif
#else
# define PREPARE_GETPWNAM /* do nothing */
# define FINISH_GETPWNAM /* do nothing */
# define OBJ2UID1(id) NUM2UIDT(id)
# define OBJ2UID(id) NUM2UIDT(id)
# ifdef p_uid_from_name
# undef p_uid_from_name
# define p_uid_from_name rb_f_notimplement
# endif
#endif
#if defined(HAVE_GRP_H)
# if defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
# define USE_GETGRNAM_R
# define GETGR_R_SIZE_INIT sysconf(_SC_GETGR_R_SIZE_MAX)
# define GETGR_R_SIZE_DEFAULT 0x1000
# define GETGR_R_SIZE_LIMIT 0x10000
# endif
# ifdef USE_GETGRNAM_R
# define PREPARE_GETGRNAM \
VALUE getgr_buf = 0
# define FINISH_GETGRNAM \
(getgr_buf ? (void)rb_str_resize(getgr_buf, 0) : (void)0)
# define OBJ2GID1(id) obj2gid((id), &getgr_buf)
# define OBJ2GID(id) obj2gid0(id)
static rb_gid_t obj2gid(VALUE id, VALUE *getgr_buf);
static inline rb_gid_t
obj2gid0(VALUE id)
{
rb_gid_t gid;
PREPARE_GETGRNAM;
gid = OBJ2GID1(id);
FINISH_GETGRNAM;
return gid;
}
static rb_gid_t obj2gid(VALUE id, VALUE *getgr_buf);
# else
# define PREPARE_GETGRNAM /* do nothing */
# define FINISH_GETGRNAM /* do nothing */
# define OBJ2GID1(id) obj2gid((id))
# define OBJ2GID(id) obj2gid((id))
static rb_gid_t obj2gid(VALUE id);
# endif
#else
# define PREPARE_GETGRNAM /* do nothing */
# define FINISH_GETGRNAM /* do nothing */
# define OBJ2GID1(id) NUM2GIDT(id)
# define OBJ2GID(id) NUM2GIDT(id)
# ifdef p_gid_from_name
# undef p_gid_from_name
# define p_gid_from_name rb_f_notimplement
# endif
#endif
#if SIZEOF_CLOCK_T == SIZEOF_INT
typedef unsigned int unsigned_clock_t;
#elif SIZEOF_CLOCK_T == SIZEOF_LONG
typedef unsigned long unsigned_clock_t;
#elif defined(HAVE_LONG_LONG) && SIZEOF_CLOCK_T == SIZEOF_LONG_LONG
typedef unsigned LONG_LONG unsigned_clock_t;
#endif
#ifndef HAVE_SIG_T
typedef void (*sig_t) (int);
#endif
#define id_exception idException
static ID id_in, id_out, id_err, id_pid, id_uid, id_gid;
static ID id_close, id_child;
#ifdef HAVE_SETPGID
static ID id_pgroup;
#endif
#ifdef _WIN32
static ID id_new_pgroup;
#endif
static ID id_unsetenv_others, id_chdir, id_umask, id_close_others, id_ENV;
static ID id_nanosecond, id_microsecond, id_millisecond, id_second;
static ID id_float_microsecond, id_float_millisecond, id_float_second;
static ID id_GETTIMEOFDAY_BASED_CLOCK_REALTIME, id_TIME_BASED_CLOCK_REALTIME;
#ifdef HAVE_TIMES
static ID id_TIMES_BASED_CLOCK_MONOTONIC;
static ID id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID;
#endif
#ifdef RUSAGE_SELF
static ID id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID;
#endif
static ID id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID;
#ifdef __APPLE__
static ID id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC;
#endif
static ID id_hertz;
/* execv and execl are async-signal-safe since SUSv4 (POSIX.1-2008, XPG7) */
#if defined(__sun) && !defined(_XPG7) /* Solaris 10, 9, ... */
#define execv(path, argv) (rb_async_bug_errno("unreachable: async-signal-unsafe execv() is called", 0))
#define execl(path, arg0, arg1, arg2, term) do { extern char **environ; execle((path), (arg0), (arg1), (arg2), (term), (environ)); } while (0)
#define ALWAYS_NEED_ENVP 1
#else
#define ALWAYS_NEED_ENVP 0
#endif
static void
assert_close_on_exec(int fd)
{
#if VM_CHECK_MODE > 0
#if defined(HAVE_FCNTL) && defined(F_GETFD) && defined(FD_CLOEXEC)
int flags = fcntl(fd, F_GETFD);
if (flags == -1) {
static const char m[] = "reserved FD closed unexpectedly?\n";
(void)!write(2, m, sizeof(m) - 1);
return;
}
if (flags & FD_CLOEXEC) return;
rb_bug("reserved FD did not have close-on-exec set");
#else
rb_bug("reserved FD without close-on-exec support");
#endif /* FD_CLOEXEC */
#endif /* VM_CHECK_MODE */
}
static inline int
close_unless_reserved(int fd)
{
if (rb_reserved_fd_p(fd)) { /* async-signal-safe */
assert_close_on_exec(fd);
return 0;
}
return close(fd); /* async-signal-safe */
}
/*#define DEBUG_REDIRECT*/
#if defined(DEBUG_REDIRECT)
#include <stdarg.h>
static void
ttyprintf(const char *fmt, ...)
{
va_list ap;
FILE *tty;
int save = errno;
#ifdef _WIN32
tty = fopen("con", "w");
#else
tty = fopen("/dev/tty", "w");
#endif
if (!tty)
return;
va_start(ap, fmt);
vfprintf(tty, fmt, ap);
va_end(ap);
fclose(tty);
errno = save;
}
static int
redirect_dup(int oldfd)
{
int ret;
ret = dup(oldfd);
ttyprintf("dup(%d) => %d\n", oldfd, ret);
return ret;
}
static int
redirect_dup2(int oldfd, int newfd)
{
int ret;
ret = dup2(oldfd, newfd);
ttyprintf("dup2(%d, %d) => %d\n", oldfd, newfd, ret);
return ret;
}
static int
redirect_cloexec_dup(int oldfd)
{
int ret;
ret = rb_cloexec_dup(oldfd);
ttyprintf("cloexec_dup(%d) => %d\n", oldfd, ret);
return ret;
}
static int
redirect_cloexec_dup2(int oldfd, int newfd)
{
int ret;
ret = rb_cloexec_dup2(oldfd, newfd);
ttyprintf("cloexec_dup2(%d, %d) => %d\n", oldfd, newfd, ret);
return ret;
}
static int
redirect_close(int fd)
{
int ret;
ret = close_unless_reserved(fd);
ttyprintf("close(%d) => %d\n", fd, ret);
return ret;
}
static int
parent_redirect_open(const char *pathname, int flags, mode_t perm)
{
int ret;
ret = rb_cloexec_open(pathname, flags, perm);
ttyprintf("parent_open(\"%s\", 0x%x, 0%o) => %d\n", pathname, flags, perm, ret);
return ret;
}
static int
parent_redirect_close(int fd)
{
int ret;
ret = close_unless_reserved(fd);
ttyprintf("parent_close(%d) => %d\n", fd, ret);
return ret;
}
#else
#define redirect_dup(oldfd) dup(oldfd)
#define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd))
#define redirect_cloexec_dup(oldfd) rb_cloexec_dup(oldfd)
#define redirect_cloexec_dup2(oldfd, newfd) rb_cloexec_dup2((oldfd), (newfd))
#define redirect_close(fd) close_unless_reserved(fd)
#define parent_redirect_open(pathname, flags, perm) rb_cloexec_open((pathname), (flags), (perm))
#define parent_redirect_close(fd) close_unless_reserved(fd)
#endif
/*
* Document-module: Process
*
* Module to handle processes.
*/
/*
* call-seq:
* Process.pid -> integer
*
* Returns the process id of this process. Not available on all
* platforms.
*
* Process.pid #=> 27415
*/
static VALUE
get_pid(void)
{
return PIDT2NUM(getpid());
}
/*
* call-seq:
* Process.ppid -> integer
*
* Returns the process id of the parent of this process. Returns
* untrustworthy value on Win32/64. Not available on all platforms.
*
* puts "I am #{Process.pid}"
* Process.fork { puts "Dad is #{Process.ppid}" }
*
* <em>produces:</em>
*
* I am 27417
* Dad is 27417
*/
static VALUE
get_ppid(void)
{
return PIDT2NUM(getppid());
}
/*********************************************************************
*
* Document-class: Process::Status
*
* Process::Status encapsulates the information on the
* status of a running or terminated system process. The built-in
* variable <code>$?</code> is either +nil+ or a
* Process::Status object.
*
* fork { exit 99 } #=> 26557
* Process.wait #=> 26557
* $?.class #=> Process::Status
* $?.to_i #=> 25344
* $? >> 8 #=> 99
* $?.stopped? #=> false
* $?.exited? #=> true
* $?.exitstatus #=> 99
*
* Posix systems record information on processes using a 16-bit
* integer. The lower bits record the process status (stopped,
* exited, signaled) and the upper bits possibly contain additional
* information (for example the program's return code in the case of
* exited processes). Pre Ruby 1.8, these bits were exposed directly
* to the Ruby program. Ruby now encapsulates these in a
* Process::Status object. To maximize compatibility,
* however, these objects retain a bit-oriented interface. In the
* descriptions that follow, when we talk about the integer value of
* _stat_, we're referring to this 16 bit value.
*/
static VALUE rb_cProcessStatus;
VALUE
rb_last_status_get(void)
{
return GET_THREAD()->last_status;
}
/*
* call-seq:
* Process.last_status -> Process::Status or nil
*
* Returns the status of the last executed child process in the
* current thread.
*
* Process.wait Process.spawn("ruby", "-e", "exit 13")
* Process.last_status #=> #<Process::Status: pid 4825 exit 13>
*
* If no child process has ever been executed in the current
* thread, this returns +nil+.
*
* Process.last_status #=> nil
*/
static VALUE
proc_s_last_status(VALUE mod)
{
return rb_last_status_get();
}
void
rb_last_status_set(int status, rb_pid_t pid)
{
rb_thread_t *th = GET_THREAD();
th->last_status = rb_obj_alloc(rb_cProcessStatus);
rb_ivar_set(th->last_status, id_status, INT2FIX(status));
rb_ivar_set(th->last_status, id_pid, PIDT2NUM(pid));
}
void
rb_last_status_clear(void)
{
GET_THREAD()->last_status = Qnil;
}
/*
* call-seq:
* stat.to_i -> integer
* stat.to_int -> integer
*
* Returns the bits in _stat_ as a Integer. Poking
* around in these bits is platform dependent.
*
* fork { exit 0xab } #=> 26566
* Process.wait #=> 26566
* sprintf('%04x', $?.to_i) #=> "ab00"
*/
static VALUE
pst_to_i(VALUE st)
{
return rb_ivar_get(st, id_status);
}
#define PST2INT(st) NUM2INT(pst_to_i(st))
/*
* call-seq:
* stat.pid -> integer
*
* Returns the process ID that this status object represents.
*
* fork { exit } #=> 26569
* Process.wait #=> 26569
* $?.pid #=> 26569
*/
static VALUE
pst_pid(VALUE st)
{
return rb_attr_get(st, id_pid);
}
static VALUE pst_message_status(VALUE str, int status);
static void
pst_message(VALUE str, rb_pid_t pid, int status)
{
rb_str_catf(str, "pid %ld", (long)pid);
pst_message_status(str, status);
}
static VALUE
pst_message_status(VALUE str, int status)
{
if (WIFSTOPPED(status)) {
int stopsig = WSTOPSIG(status);
const char *signame = ruby_signal_name(stopsig);
if (signame) {
rb_str_catf(str, " stopped SIG%s (signal %d)", signame, stopsig);
}
else {
rb_str_catf(str, " stopped signal %d", stopsig);
}
}
if (WIFSIGNALED(status)) {
int termsig = WTERMSIG(status);
const char *signame = ruby_signal_name(termsig);
if (signame) {
rb_str_catf(str, " SIG%s (signal %d)", signame, termsig);
}
else {
rb_str_catf(str, " signal %d", termsig);
}
}
if (WIFEXITED(status)) {
rb_str_catf(str, " exit %d", WEXITSTATUS(status));
}
#ifdef WCOREDUMP
if (WCOREDUMP(status)) {
rb_str_cat2(str, " (core dumped)");
}
#endif
return str;
}
/*
* call-seq:
* stat.to_s -> string
*
* Show pid and exit status as a string.
*
* system("false")
* p $?.to_s #=> "pid 12766 exit 1"
*
*/
static VALUE
pst_to_s(VALUE st)
{
rb_pid_t pid;
int status;
VALUE str;
pid = NUM2PIDT(pst_pid(st));
status = PST2INT(st);
str = rb_str_buf_new(0);
pst_message(str, pid, status);
return str;
}
/*
* call-seq:
* stat.inspect -> string
*
* Override the inspection method.
*
* system("false")
* p $?.inspect #=> "#<Process::Status: pid 12861 exit 1>"
*
*/
static VALUE
pst_inspect(VALUE st)
{
rb_pid_t pid;
int status;
VALUE vpid, str;
vpid = pst_pid(st);
if (NIL_P(vpid)) {
return rb_sprintf("#<%s: uninitialized>", rb_class2name(CLASS_OF(st)));
}
pid = NUM2PIDT(vpid);
status = PST2INT(st);
str = rb_sprintf("#<%s: ", rb_class2name(CLASS_OF(st)));
pst_message(str, pid, status);
rb_str_cat2(str, ">");
return str;
}
/*
* call-seq:
* stat == other -> true or false
*
* Returns +true+ if the integer value of _stat_
* equals <em>other</em>.
*/
static VALUE
pst_equal(VALUE st1, VALUE st2)
{
if (st1 == st2) return Qtrue;
return rb_equal(pst_to_i(st1), st2);
}
/*
* call-seq:
* stat & num -> integer
*
* Logical AND of the bits in _stat_ with <em>num</em>.
*
* fork { exit 0x37 }
* Process.wait
* sprintf('%04x', $?.to_i) #=> "3700"
* sprintf('%04x', $? & 0x1e00) #=> "1600"
*/
static VALUE
pst_bitand(VALUE st1, VALUE st2)
{
int status = PST2INT(st1) & NUM2INT(st2);
return INT2NUM(status);
}
/*
* call-seq:
* stat >> num -> integer
*
* Shift the bits in _stat_ right <em>num</em> places.
*
* fork { exit 99 } #=> 26563
* Process.wait #=> 26563
* $?.to_i #=> 25344
* $? >> 8 #=> 99
*/
static VALUE
pst_rshift(VALUE st1, VALUE st2)
{
int status = PST2INT(st1) >> NUM2INT(st2);
return INT2NUM(status);
}
/*
* call-seq:
* stat.stopped? -> true or false
*
* Returns +true+ if this process is stopped. This is only returned
* if the corresponding #wait call had the Process::WUNTRACED flag
* set.
*/
static VALUE
pst_wifstopped(VALUE st)
{
int status = PST2INT(st);
if (WIFSTOPPED(status))
return Qtrue;
else
return Qfalse;
}
/*
* call-seq:
* stat.stopsig -> integer or nil
*
* Returns the number of the signal that caused _stat_ to stop
* (or +nil+ if self is not stopped).
*/
static VALUE
pst_wstopsig(VALUE st)
{
int status = PST2INT(st);
if (WIFSTOPPED(status))
return INT2NUM(WSTOPSIG(status));
return Qnil;
}
/*
* call-seq:
* stat.signaled? -> true or false
*
* Returns +true+ if _stat_ terminated because of
* an uncaught signal.
*/
static VALUE
pst_wifsignaled(VALUE st)
{
int status = PST2INT(st);
if (WIFSIGNALED(status))
return Qtrue;
else
return Qfalse;
}
/*
* call-seq:
* stat.termsig -> integer or nil
*
* Returns the number of the signal that caused _stat_ to
* terminate (or +nil+ if self was not terminated by an
* uncaught signal).
*/
static VALUE
pst_wtermsig(VALUE st)
{
int status = PST2INT(st);
if (WIFSIGNALED(status))
return INT2NUM(WTERMSIG(status));
return Qnil;
}
/*
* call-seq:
* stat.exited? -> true or false
*
* Returns +true+ if _stat_ exited normally (for
* example using an <code>exit()</code> call or finishing the
* program).
*/
static VALUE
pst_wifexited(VALUE st)
{
int status = PST2INT(st);
if (WIFEXITED(status))
return Qtrue;
else
return Qfalse;
}
/*
* call-seq:
* stat.exitstatus -> integer or nil
*
* Returns the least significant eight bits of the return code of
* _stat_. Only available if #exited? is +true+.
*
* fork { } #=> 26572
* Process.wait #=> 26572
* $?.exited? #=> true
* $?.exitstatus #=> 0
*
* fork { exit 99 } #=> 26573
* Process.wait #=> 26573
* $?.exited? #=> true
* $?.exitstatus #=> 99
*/
static VALUE
pst_wexitstatus(VALUE st)
{
int status = PST2INT(st);
if (WIFEXITED(status))
return INT2NUM(WEXITSTATUS(status));
return Qnil;
}
/*
* call-seq:
* stat.success? -> true, false or nil
*
* Returns +true+ if _stat_ is successful, +false+ if not.
* Returns +nil+ if #exited? is not +true+.
*/
static VALUE
pst_success_p(VALUE st)
{
int status = PST2INT(st);
if (!WIFEXITED(status))
return Qnil;
return WEXITSTATUS(status) == EXIT_SUCCESS ? Qtrue : Qfalse;
}
/*
* call-seq:
* stat.coredump? -> true or false
*
* Returns +true+ if _stat_ generated a coredump
* when it terminated. Not available on all platforms.
*/
static VALUE
pst_wcoredump(VALUE st)
{
#ifdef WCOREDUMP
int status = PST2INT(st);
if (WCOREDUMP(status))
return Qtrue;
else
return Qfalse;
#else
return Qfalse;
#endif
}
static rb_pid_t
do_waitpid(rb_pid_t pid, int *st, int flags)
{
#if defined HAVE_WAITPID
return waitpid(pid, st, flags);
#elif defined HAVE_WAIT4
return wait4(pid, st, flags, NULL);
#else
# error waitpid or wait4 is required.
#endif
}
#define WAITPID_LOCK_ONLY ((struct waitpid_state *)-1)
struct waitpid_state {
struct list_node wnode;
rb_execution_context_t *ec;
rb_nativethread_cond_t *cond;
rb_pid_t ret;
rb_pid_t pid;
int status;
int options;
int errnum;
};
void rb_native_mutex_lock(rb_nativethread_lock_t *);
void rb_native_mutex_unlock(rb_nativethread_lock_t *);
void rb_native_cond_signal(rb_nativethread_cond_t *);
void rb_native_cond_wait(rb_nativethread_cond_t *, rb_nativethread_lock_t *);
int rb_sigwait_fd_get(const rb_thread_t *);
void rb_sigwait_sleep(const rb_thread_t *, int fd, const rb_hrtime_t *);
void rb_sigwait_fd_put(const rb_thread_t *, int fd);
void rb_thread_sleep_interruptible(void);
static int
waitpid_signal(struct waitpid_state *w)
{
if (w->ec) { /* rb_waitpid */
rb_threadptr_interrupt(rb_ec_thread_ptr(w->ec));
return TRUE;
}
else { /* ruby_waitpid_locked */
if (w->cond) {
rb_native_cond_signal(w->cond);
return TRUE;
}
}
return FALSE;
}
/*
* When a thread is done using sigwait_fd and there are other threads
* sleeping on waitpid, we must kick one of the threads out of
* rb_native_cond_wait so it can switch to rb_sigwait_sleep
*/
static void
sigwait_fd_migrate_sleeper(rb_vm_t *vm)
{
struct waitpid_state *w = 0;
list_for_each(&vm->waiting_pids, w, wnode) {
if (waitpid_signal(w)) return;
}
list_for_each(&vm->waiting_grps, w, wnode) {
if (waitpid_signal(w)) return;
}
}
void
rb_sigwait_fd_migrate(rb_vm_t *vm)
{
rb_native_mutex_lock(&vm->waitpid_lock);
sigwait_fd_migrate_sleeper(vm);
rb_native_mutex_unlock(&vm->waitpid_lock);
}
#if RUBY_SIGCHLD
extern volatile unsigned int ruby_nocldwait; /* signal.c */
/* called by timer thread or thread which acquired sigwait_fd */
static void
waitpid_each(struct list_head *head)
{
struct waitpid_state *w = 0, *next;
list_for_each_safe(head, w, next, wnode) {
rb_pid_t ret = do_waitpid(w->pid, &w->status, w->options | WNOHANG);
if (!ret) continue;
if (ret == -1) w->errnum = errno;
w->ret = ret;
list_del_init(&w->wnode);
waitpid_signal(w);
}
}
#else
# define ruby_nocldwait 0
#endif
void
ruby_waitpid_all(rb_vm_t *vm)
{
#if RUBY_SIGCHLD
rb_native_mutex_lock(&vm->waitpid_lock);
waitpid_each(&vm->waiting_pids);
if (list_empty(&vm->waiting_pids)) {
waitpid_each(&vm->waiting_grps);
}
/* emulate SA_NOCLDWAIT */
if (list_empty(&vm->waiting_pids) && list_empty(&vm->waiting_grps)) {
while (ruby_nocldwait && do_waitpid(-1, 0, WNOHANG) > 0)
; /* keep looping */
}
rb_native_mutex_unlock(&vm->waitpid_lock);
#endif
}
static void
waitpid_state_init(struct waitpid_state *w, rb_pid_t pid, int options)
{
w->ret = 0;
w->pid = pid;
w->options = options;
}
static const rb_hrtime_t *
sigwait_sleep_time(void)
{
if (SIGCHLD_LOSSY) {
static const rb_hrtime_t busy_wait = 100 * RB_HRTIME_PER_MSEC;
return &busy_wait;
}
return 0;
}
/*
* must be called with vm->waitpid_lock held, this is not interruptible
*/
rb_pid_t
ruby_waitpid_locked(rb_vm_t *vm, rb_pid_t pid, int *status, int options,
rb_nativethread_cond_t *cond)
{
struct waitpid_state w;
assert(!ruby_thread_has_gvl_p() && "must not have GVL");
waitpid_state_init(&w, pid, options);
if (w.pid > 0 || list_empty(&vm->waiting_pids))
w.ret = do_waitpid(w.pid, &w.status, w.options | WNOHANG);
if (w.ret) {
if (w.ret == -1) w.errnum = errno;
}
else {
int sigwait_fd = -1;
w.ec = 0;
list_add(w.pid > 0 ? &vm->waiting_pids : &vm->waiting_grps, &w.wnode);
do {
if (sigwait_fd < 0)
sigwait_fd = rb_sigwait_fd_get(0);
if (sigwait_fd >= 0) {
w.cond = 0;
rb_native_mutex_unlock(&vm->waitpid_lock);
rb_sigwait_sleep(0, sigwait_fd, sigwait_sleep_time());
rb_native_mutex_lock(&vm->waitpid_lock);
}
else {
w.cond = cond;
rb_native_cond_wait(w.cond, &vm->waitpid_lock);
}
} while (!w.ret);
list_del(&w.wnode);
/* we're done, maybe other waitpid callers are not: */
if (sigwait_fd >= 0) {
rb_sigwait_fd_put(0, sigwait_fd);
sigwait_fd_migrate_sleeper(vm);
}
}
if (status) {
*status = w.status;
}
if (w.ret == -1) errno = w.errnum;
return w.ret;
}
static VALUE
waitpid_sleep(VALUE x)
{
struct waitpid_state *w = (struct waitpid_state *)x;
while (!w->ret) {
rb_thread_sleep_interruptible();
}
return Qfalse;
}
static VALUE
waitpid_cleanup(VALUE x)
{
struct waitpid_state *w = (struct waitpid_state *)x;
/*
* XXX w->ret is sometimes set but list_del is still needed, here,
* Not sure why, so we unconditionally do list_del here:
*/
if (TRUE || w->ret == 0) {
rb_vm_t *vm = rb_ec_vm_ptr(w->ec);
rb_native_mutex_lock(&vm->waitpid_lock);
list_del(&w->wnode);
rb_native_mutex_unlock(&vm->waitpid_lock);
}
return Qfalse;
}
static void
waitpid_wait(struct waitpid_state *w)
{
rb_vm_t *vm = rb_ec_vm_ptr(w->ec);
int need_sleep = FALSE;
/*
* Lock here to prevent do_waitpid from stealing work from the
* ruby_waitpid_locked done by mjit workers since mjit works
* outside of GVL
*/
rb_native_mutex_lock(&vm->waitpid_lock);
if (w->pid > 0 || list_empty(&vm->waiting_pids))
w->ret = do_waitpid(w->pid, &w->status, w->options | WNOHANG);
if (w->ret) {
if (w->ret == -1) w->errnum = errno;
}
else if (w->options & WNOHANG) {
}
else {
need_sleep = TRUE;
}
if (need_sleep) {
w->cond = 0;
/* order matters, favor specified PIDs rather than -1 or 0 */
list_add(w->pid > 0 ? &vm->waiting_pids : &vm->waiting_grps, &w->wnode);
}
rb_native_mutex_unlock(&vm->waitpid_lock);
if (need_sleep) {
rb_ensure(waitpid_sleep, (VALUE)w, waitpid_cleanup, (VALUE)w);
}
}
static void *
waitpid_blocking_no_SIGCHLD(void *x)
{
struct waitpid_state *w = x;
w->ret = do_waitpid(w->pid, &w->status, w->options);
return 0;
}
static void
waitpid_no_SIGCHLD(struct waitpid_state *w)
{
if (w->options & WNOHANG) {
w->ret = do_waitpid(w->pid, &w->status, w->options);
}
else {
do {
rb_thread_call_without_gvl(waitpid_blocking_no_SIGCHLD, w,
RUBY_UBF_PROCESS, 0);
} while (w->ret < 0 && errno == EINTR && (RUBY_VM_CHECK_INTS(w->ec),1));
}
if (w->ret == -1)
w->errnum = errno;
}
rb_pid_t
rb_waitpid(rb_pid_t pid, int *st, int flags)
{
struct waitpid_state w;
waitpid_state_init(&w, pid, flags);
w.ec = GET_EC();
if (WAITPID_USE_SIGCHLD) {
waitpid_wait(&w);
}
else {
waitpid_no_SIGCHLD(&w);
}
if (st) *st = w.status;
if (w.ret == -1) {
errno = w.errnum;
}
else if (w.ret > 0) {
if (ruby_nocldwait) {
w.ret = -1;
errno = ECHILD;
}
else {
rb_last_status_set(w.status, w.ret);
}
}
return w.ret;
}
/* [MG]:FIXME: I wasn't sure how this should be done, since ::wait()
has historically been documented as if it didn't take any arguments
despite the fact that it's just an alias for ::waitpid(). The way I
have it below is more truthful, but a little confusing.
I also took the liberty of putting in the pid values, as they're
pretty useful, and it looked as if the original 'ri' output was
supposed to contain them after "[...]depending on the value of
aPid:".
The 'ansi' and 'bs' formats of the ri output don't display the
definition list for some reason, but the plain text one does.
*/
/*
* call-seq:
* Process.wait() -> integer
* Process.wait(pid=-1, flags=0) -> integer
* Process.waitpid(pid=-1, flags=0) -> integer
*
* Waits for a child process to exit, returns its process id, and
* sets <code>$?</code> to a Process::Status object
* containing information on that process. Which child it waits on
* depends on the value of _pid_:
*
* > 0:: Waits for the child whose process ID equals _pid_.
*
* 0:: Waits for any child whose process group ID equals that of the
* calling process.
*
* -1:: Waits for any child process (the default if no _pid_ is
* given).
*
* < -1:: Waits for any child whose process group ID equals the absolute
* value of _pid_.
*
* The _flags_ argument may be a logical or of the flag values
* Process::WNOHANG (do not block if no child available)
* or Process::WUNTRACED (return stopped children that
* haven't been reported). Not all flags are available on all
* platforms, but a flag value of zero will work on all platforms.
*
* Calling this method raises a SystemCallError if there are no child
* processes. Not available on all platforms.
*
* include Process
* fork { exit 99 } #=> 27429
* wait #=> 27429
* $?.exitstatus #=> 99
*
* pid = fork { sleep 3 } #=> 27440
* Time.now #=> 2008-03-08 19:56:16 +0900
* waitpid(pid, Process::WNOHANG) #=> nil
* Time.now #=> 2008-03-08 19:56:16 +0900
* waitpid(pid, 0) #=> 27440
* Time.now #=> 2008-03-08 19:56:19 +0900
*/
static VALUE
proc_wait(int argc, VALUE *argv)
{
rb_pid_t pid;
int flags, status;
flags = 0;
if (rb_check_arity(argc, 0, 2) == 0) {
pid = -1;
}
else {
VALUE vflags;
pid = NUM2PIDT(argv[0]);
if (argc == 2 && !NIL_P(vflags = argv[1])) {
flags = NUM2UINT(vflags);
}
}
if ((pid = rb_waitpid(pid, &status, flags)) < 0)
rb_sys_fail(0);
if (pid == 0) {
rb_last_status_clear();
return Qnil;
}
return PIDT2NUM(pid);
}
/*
* call-seq:
* Process.wait2(pid=-1, flags=0) -> [pid, status]
* Process.waitpid2(pid=-1, flags=0) -> [pid, status]
*
* Waits for a child process to exit (see Process::waitpid for exact
* semantics) and returns an array containing the process id and the
* exit status (a Process::Status object) of that
* child. Raises a SystemCallError if there are no child processes.
*
* Process.fork { exit 99 } #=> 27437
* pid, status = Process.wait2
* pid #=> 27437
* status.exitstatus #=> 99
*/
static VALUE
proc_wait2(int argc, VALUE *argv)
{
VALUE pid = proc_wait(argc, argv);
if (NIL_P(pid)) return Qnil;
return rb_assoc_new(pid, rb_last_status_get());
}
/*
* call-seq:
* Process.waitall -> [ [pid1,status1], ...]
*
* Waits for all children, returning an array of
* _pid_/_status_ pairs (where _status_ is a
* Process::Status object).
*
* fork { sleep 0.2; exit 2 } #=> 27432
* fork { sleep 0.1; exit 1 } #=> 27433
* fork { exit 0 } #=> 27434
* p Process.waitall
*
* <em>produces</em>:
*
* [[30982, #<Process::Status: pid 30982 exit 0>],
* [30979, #<Process::Status: pid 30979 exit 1>],
* [30976, #<Process::Status: pid 30976 exit 2>]]
*/
static VALUE
proc_waitall(void)
{
VALUE result;
rb_pid_t pid;
int status;
result = rb_ary_new();
rb_last_status_clear();
for (pid = -1;;) {
pid = rb_waitpid(-1, &status, 0);
if (pid == -1) {
int e = errno;
if (e == ECHILD)
break;
rb_syserr_fail(e, 0);
}
rb_ary_push(result, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get()));
}
return result;
}
static VALUE rb_cWaiter;
static VALUE
detach_process_pid(VALUE thread)
{
return rb_thread_local_aref(thread, id_pid);
}
static VALUE
detach_process_watcher(void *arg)
{
rb_pid_t cpid, pid = (rb_pid_t)(VALUE)arg;
int status;
while ((cpid = rb_waitpid(pid, &status, 0)) == 0) {
/* wait while alive */
}
return rb_last_status_get();
}
VALUE
rb_detach_process(rb_pid_t pid)
{
VALUE watcher = rb_thread_create(detach_process_watcher, (void*)(VALUE)pid);
rb_thread_local_aset(watcher, id_pid, PIDT2NUM(pid));
RBASIC_SET_CLASS(watcher, rb_cWaiter);
return watcher;
}
/*
* call-seq:
* Process.detach(pid) -> thread
*
* Some operating systems retain the status of terminated child
* processes until the parent collects that status (normally using
* some variant of <code>wait()</code>). If the parent never collects
* this status, the child stays around as a <em>zombie</em> process.
* Process::detach prevents this by setting up a separate Ruby thread
* whose sole job is to reap the status of the process _pid_ when it
* terminates. Use #detach only when you do not intend to explicitly
* wait for the child to terminate.
*
* The waiting thread returns the exit status of the detached process
* when it terminates, so you can use Thread#join to
* know the result. If specified _pid_ is not a valid child process
* ID, the thread returns +nil+ immediately.
*
* The waiting thread has #pid method which returns the pid.
*
* In this first example, we don't reap the first child process, so
* it appears as a zombie in the process status display.
*
* p1 = fork { sleep 0.1 }
* p2 = fork { sleep 0.2 }
* Process.waitpid(p2)
* sleep 2
* system("ps -ho pid,state -p #{p1}")
*
* <em>produces:</em>
*
* 27389 Z
*
* In the next example, Process::detach is used to reap
* the child automatically.
*
* p1 = fork { sleep 0.1 }
* p2 = fork { sleep 0.2 }
* Process.detach(p1)
* Process.waitpid(p2)
* sleep 2
* system("ps -ho pid,state -p #{p1}")
*
* <em>(produces no output)</em>
*/
static VALUE
proc_detach(VALUE obj, VALUE pid)
{
return rb_detach_process(NUM2PIDT(pid));
}
/* This function should be async-signal-safe. Actually it is. */
static void
before_exec_async_signal_safe(void)
{
}
static void
before_exec_non_async_signal_safe(void)
{
/*
* On Mac OS X 10.5.x (Leopard) or earlier, exec() may return ENOTSUP
* if the process have multiple threads. Therefore we have to kill
* internal threads temporary. [ruby-core:10583]
* This is also true on Haiku. It returns Errno::EPERM against exec()
* in multiple threads.
*
* Nowadays, we always stop the timer thread completely to allow redirects.
*/
rb_thread_stop_timer_thread();
}
#define WRITE_CONST(fd, str) (void)(write((fd),(str),sizeof(str)-1)<0)
#ifdef _WIN32
int rb_w32_set_nonblock2(int fd, int nonblock);
#endif
static int
set_blocking(int fd)
{
#ifdef _WIN32
return rb_w32_set_nonblock2(fd, 0);
#elif defined(F_GETFL) && defined(F_SETFL)
int fl = fcntl(fd, F_GETFL); /* async-signal-safe */
/* EBADF ought to be possible */
if (fl == -1) return fl;
if (fl & O_NONBLOCK) {
fl &= ~O_NONBLOCK;
return fcntl(fd, F_SETFL, fl);
}
return 0;
#endif
}
static void
stdfd_clear_nonblock(void)
{
/* many programs cannot deal with non-blocking stdin/stdout/stderr */
int fd;
for (fd = 0; fd < 3; fd++) {
(void)set_blocking(fd); /* can't do much about errors anyhow */
}
}
static void
before_exec(void)
{
before_exec_non_async_signal_safe();
before_exec_async_signal_safe();
}
/* This function should be async-signal-safe. Actually it is. */
static void
after_exec_async_signal_safe(void)
{
}
static void
after_exec_non_async_signal_safe(void)
{
rb_thread_reset_timer_thread();
rb_thread_start_timer_thread();
}
static void
after_exec(void)
{
after_exec_async_signal_safe();
after_exec_non_async_signal_safe();
}
#if defined HAVE_WORKING_FORK || defined HAVE_DAEMON
#define before_fork_ruby() before_exec()
static void
after_fork_ruby(void)
{
rb_threadptr_pending_interrupt_clear(GET_THREAD());
after_exec();
}
#endif
#include "dln.h"
static void
security(const char *str)
{
if (rb_env_path_tainted()) {
if (rb_safe_level() > 0) {
rb_raise(rb_eSecurityError, "Insecure PATH - %s", str);
}
}
}
#if defined(HAVE_WORKING_FORK)
/* try_with_sh and exec_with_sh should be async-signal-safe. Actually it is.*/
#define try_with_sh(err, prog, argv, envp) ((err == ENOEXEC) ? exec_with_sh((prog), (argv), (envp)) : (void)0)
static void
exec_with_sh(const char *prog, char **argv, char **envp)
{
*argv = (char *)prog;
*--argv = (char *)"sh";
if (envp)
execve("/bin/sh", argv, envp); /* async-signal-safe */
else
execv("/bin/sh", argv); /* async-signal-safe (since SUSv4) */
}
#else
#define try_with_sh(err, prog, argv, envp) (void)0
#endif
/* This function should be async-signal-safe. Actually it is. */
static int
proc_exec_cmd(const char *prog, VALUE argv_str, VALUE envp_str)
{
char **argv;
#ifndef _WIN32
char **envp;
int err;
#endif
argv = ARGVSTR2ARGV(argv_str);
if (!prog) {
return ENOENT;
}
#ifdef _WIN32
rb_w32_uaspawn(P_OVERLAY, prog, argv);
return errno;
#else
envp = envp_str ? RB_IMEMO_TMPBUF_PTR(envp_str) : NULL;
if (envp_str)
execve(prog, argv, envp); /* async-signal-safe */
else
execv(prog, argv); /* async-signal-safe (since SUSv4) */
err = errno;
try_with_sh(err, prog, argv, envp); /* try_with_sh() is async-signal-safe. */
return err;
#endif
}
/* This function should be async-signal-safe. Actually it is. */
static int
proc_exec_sh(const char *str, VALUE envp_str)
{
const char *s;
s = str;
while (*s == ' ' || *s == '\t' || *s == '\n')
s++;
if (!*s) {
return ENOENT;
}
#ifdef _WIN32
rb_w32_uspawn(P_OVERLAY, (char *)str, 0);
#elif defined(__CYGWIN32__)
{
char fbuf[MAXPATHLEN];
char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf));
int status = -1;
if (shell)
execl(shell, "sh", "-c", str, (char *) NULL);
else
status = system(str);
if (status != -1)
exit(status);
}
#else
if (envp_str)
execle("/bin/sh", "sh", "-c", str, (char *)NULL, RB_IMEMO_TMPBUF_PTR(envp_str)); /* async-signal-safe */
else
execl("/bin/sh", "sh", "-c", str, (char *)NULL); /* async-signal-safe (since SUSv4) */
#endif /* _WIN32 */
return errno;
}
int
rb_proc_exec(const char *str)
{
int ret;
before_exec();
ret = proc_exec_sh(str, Qfalse);
after_exec();
errno = ret;
return -1;
}
static void
mark_exec_arg(void *ptr)
{
struct rb_execarg *eargp = ptr;
if (eargp->use_shell)
rb_gc_mark(eargp->invoke.sh.shell_script);
else {
rb_gc_mark(eargp->invoke.cmd.command_name);
rb_gc_mark(eargp->invoke.cmd.command_abspath);
rb_gc_mark(eargp->invoke.cmd.argv_str);
rb_gc_mark(eargp->invoke.cmd.argv_buf);
}
rb_gc_mark(eargp->redirect_fds);
rb_gc_mark(eargp->envp_str);
rb_gc_mark(eargp->envp_buf);
rb_gc_mark(eargp->dup2_tmpbuf);
rb_gc_mark(eargp->rlimit_limits);
rb_gc_mark(eargp->fd_dup2);
rb_gc_mark(eargp->fd_close);
rb_gc_mark(eargp->fd_open);
rb_gc_mark(eargp->fd_dup2_child);
rb_gc_mark(eargp->env_modification);
rb_gc_mark(eargp->path_env);
rb_gc_mark(eargp->chdir_dir);
}
static size_t
memsize_exec_arg(const void *ptr)
{
return sizeof(struct rb_execarg);
}
static const rb_data_type_t exec_arg_data_type = {
"exec_arg",
{mark_exec_arg, RUBY_TYPED_DEFAULT_FREE, memsize_exec_arg},
0, 0, RUBY_TYPED_FREE_IMMEDIATELY
};
#ifdef _WIN32
# define DEFAULT_PROCESS_ENCODING rb_utf8_encoding()
#endif
#ifdef DEFAULT_PROCESS_ENCODING
# define EXPORT_STR(str) rb_str_export_to_enc((str), DEFAULT_PROCESS_ENCODING)
# define EXPORT_DUP(str) export_dup(str)
static VALUE
export_dup(VALUE str)
{
VALUE newstr = EXPORT_STR(str);
if (newstr == str) newstr = rb_str_dup(str);
return newstr;
}
#else
# define EXPORT_STR(str) (str)
# define EXPORT_DUP(str) rb_str_dup(str)
#endif
#if !defined(HAVE_WORKING_FORK) && defined(HAVE_SPAWNV)
# define USE_SPAWNV 1
#else
# define USE_SPAWNV 0
#endif
#ifndef P_NOWAIT
# define P_NOWAIT _P_NOWAIT
#endif
#if USE_SPAWNV
#if defined(_WIN32)
#define proc_spawn_cmd_internal(argv, prog) rb_w32_uaspawn(P_NOWAIT, (prog), (argv))
#else
static rb_pid_t
proc_spawn_cmd_internal(char **argv, char *prog)
{
char fbuf[MAXPATHLEN];
rb_pid_t status;
if (!prog)
prog = argv[0];
security(prog);
prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf));
if (!prog)
return -1;
before_exec();
status = spawnv(P_NOWAIT, prog, (const char **)argv);
if (status == -1 && errno == ENOEXEC) {
*argv = (char *)prog;
*--argv = (char *)"sh";
status = spawnv(P_NOWAIT, "/bin/sh", (const char **)argv);
after_exec();
if (status == -1) errno = ENOEXEC;
}
return status;
}
#endif
static rb_pid_t
proc_spawn_cmd(char **argv, VALUE prog, struct rb_execarg *eargp)
{
rb_pid_t pid = -1;
if (argv[0]) {
#if defined(_WIN32)
DWORD flags = 0;
if (eargp->new_pgroup_given && eargp->new_pgroup_flag) {
flags = CREATE_NEW_PROCESS_GROUP;
}
pid = rb_w32_uaspawn_flags(P_NOWAIT, prog ? RSTRING_PTR(prog) : 0, argv, flags);
#else
pid = proc_spawn_cmd_internal(argv, prog ? RSTRING_PTR(prog) : 0);
#endif
}
return pid;
}
#if defined(_WIN32)
#define proc_spawn_sh(str) rb_w32_uspawn(P_NOWAIT, (str), 0)
#else
static rb_pid_t
proc_spawn_sh(char *str)
{
char fbuf[MAXPATHLEN];
rb_pid_t status;
char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf));
before_exec();
status = spawnl(P_NOWAIT, (shell ? shell : "/bin/sh"), "sh", "-c", str, (char*)NULL);
after_exec();
return status;
}
#endif
#endif
static VALUE
hide_obj(VALUE obj)
{
RBASIC_CLEAR_CLASS(obj);
return obj;
}
static VALUE
check_exec_redirect_fd(VALUE v, int iskey)
{
VALUE tmp;
int fd;
if (FIXNUM_P(v)) {
fd = FIX2INT(v);
}
else if (SYMBOL_P(v)) {
ID id = rb_check_id(&v);
if (id == id_in)
fd = 0;
else if (id == id_out)
fd = 1;
else if (id == id_err)
fd = 2;
else
goto wrong;
}
else if (!NIL_P(tmp = rb_check_convert_type_with_id(v, T_FILE, "IO", idTo_io))) {
rb_io_t *fptr;
GetOpenFile(tmp, fptr);
if (fptr->tied_io_for_writing)
rb_raise(rb_eArgError, "duplex IO redirection");
fd = fptr->fd;
}
else {
wrong:
rb_raise(rb_eArgError, "wrong exec redirect");
}
if (fd < 0) {
rb_raise(rb_eArgError, "negative file descriptor");
}
#ifdef _WIN32
else if (fd >= 3 && iskey) {
rb_raise(rb_eArgError, "wrong file descriptor (%d)", fd);
}
#endif
return INT2FIX(fd);
}
static VALUE
check_exec_redirect1(VALUE ary, VALUE key, VALUE param)
{
if (ary == Qfalse) {
ary = hide_obj(rb_ary_new());
}
if (!RB_TYPE_P(key, T_ARRAY)) {
VALUE fd = check_exec_redirect_fd(key, !NIL_P(param));
rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param)));
}
else {
int i, n=0;
for (i = 0 ; i < RARRAY_LEN(key); i++) {
VALUE v = RARRAY_AREF(key, i);
VALUE fd = check_exec_redirect_fd(v, !NIL_P(param));
rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param)));
n++;
}
}
return ary;
}
static void
check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp)
{
VALUE param;
VALUE path, flags, perm;
VALUE tmp;
ID id;
switch (TYPE(val)) {
case T_SYMBOL:
if (!(id = rb_check_id(&val))) goto wrong_symbol;
if (id == id_close) {
param = Qnil;
eargp->fd_close = check_exec_redirect1(eargp->fd_close, key, param);
}
else if (id == id_in) {
param = INT2FIX(0);
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
}
else if (id == id_out) {
param = INT2FIX(1);
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
}
else if (id == id_err) {
param = INT2FIX(2);
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
}
else {
wrong_symbol:
rb_raise(rb_eArgError, "wrong exec redirect symbol: %"PRIsVALUE,
val);
}
break;
case T_FILE:
io:
val = check_exec_redirect_fd(val, 0);
/* fall through */
case T_FIXNUM:
param = val;
eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param);
break;
case T_ARRAY:
path = rb_ary_entry(val, 0);
if (RARRAY_LEN(val) == 2 && SYMBOL_P(path) &&
path == ID2SYM(id_child)) {
param = check_exec_redirect_fd(rb_ary_entry(val, 1), 0);
eargp->fd_dup2_child = check_exec_redirect1(eargp->fd_dup2_child, key, param);
}
else {
FilePathValue(path);
flags = rb_ary_entry(val, 1);
if (NIL_P(flags))
flags = INT2NUM(O_RDONLY);
else if (RB_TYPE_P(flags, T_STRING))
flags = INT2NUM(rb_io_modestr_oflags(StringValueCStr(flags)));
else
flags = rb_to_int(flags);
perm = rb_ary_entry(val, 2);
perm = NIL_P(perm) ? INT2FIX(0644) : rb_to_int(perm);
param = hide_obj(rb_ary_new3(4, hide_obj(EXPORT_DUP(path)),
flags, perm, Qnil));
eargp->fd_open = check_exec_redirect1(eargp->fd_open, key, param);
}
break;
case T_STRING:
path = val;
FilePathValue(path);
if (RB_TYPE_P(key, T_FILE))
key = check_exec_redirect_fd(key, 1);
if (FIXNUM_P(key) && (FIX2INT(key) == 1 || FIX2INT(key) == 2))
flags = INT2NUM(O_WRONLY|O_CREAT|O_TRUNC);
else if (RB_TYPE_P(key, T_ARRAY)) {
int i;
for (i = 0; i < RARRAY_LEN(key); i++) {
VALUE v = RARRAY_AREF(key, i);
VALUE fd = check_exec_redirect_fd(v, 1);
if (FIX2INT(fd) != 1 && FIX2INT(fd) != 2) break;
}
if (i == RARRAY_LEN(key))
flags = INT2NUM(O_WRONLY|O_CREAT|O_TRUNC);
else
flags = INT2NUM(O_RDONLY);
}
else
flags = INT2NUM(O_RDONLY);
perm = INT2FIX(0644);
param = hide_obj(rb_ary_new3(4, hide_obj(EXPORT_DUP(path)),
flags, perm, Qnil));
eargp->fd_open = check_exec_redirect1(eargp->fd_open, key, param);
break;
default:
tmp = val;
val = rb_io_check_io(tmp);
if (!NIL_P(val)) goto io;
rb_raise(rb_eArgError, "wrong exec redirect action");
}
}
#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
static int rlimit_type_by_sym(VALUE key);
static void
rb_execarg_addopt_rlimit(struct rb_execarg *eargp, int rtype, VALUE val)
{
VALUE ary = eargp->rlimit_limits;
VALUE tmp, softlim, hardlim;
if (eargp->rlimit_limits == Qfalse)
ary = eargp->rlimit_limits = hide_obj(rb_ary_new());
else
ary = eargp->rlimit_limits;
tmp = rb_check_array_type(val);
if (!NIL_P(tmp)) {
if (RARRAY_LEN(tmp) == 1)
softlim = hardlim = rb_to_int(rb_ary_entry(tmp, 0));
else if (RARRAY_LEN(tmp) == 2) {
softlim = rb_to_int(rb_ary_entry(tmp, 0));
hardlim = rb_to_int(rb_ary_entry(tmp, 1));
}
else {
rb_raise(rb_eArgError, "wrong exec rlimit option");
}
}
else {
softlim = hardlim = rb_to_int(val);
}
tmp = hide_obj(rb_ary_new3(3, INT2NUM(rtype), softlim, hardlim));
rb_ary_push(ary, tmp);
}
#endif
int
rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
{
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
ID id;
switch (TYPE(key)) {
case T_SYMBOL:
#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
{
int rtype = rlimit_type_by_sym(key);
if (rtype != -1) {
rb_execarg_addopt_rlimit(eargp, rtype, val);
RB_GC_GUARD(execarg_obj);
return ST_CONTINUE;
}
}
#endif
if (!(id = rb_check_id(&key))) return ST_STOP;
#ifdef HAVE_SETPGID
if (id == id_pgroup) {
rb_pid_t pgroup;
if (eargp->pgroup_given) {
rb_raise(rb_eArgError, "pgroup option specified twice");
}
if (!RTEST(val))
pgroup = -1; /* asis(-1) means "don't call setpgid()". */
else if (val == Qtrue)
pgroup = 0; /* new process group. */
else {
pgroup = NUM2PIDT(val);
if (pgroup < 0) {
rb_raise(rb_eArgError, "negative process group ID : %ld", (long)pgroup);
}
}
eargp->pgroup_given = 1;
eargp->pgroup_pgid = pgroup;
}
else
#endif
#ifdef _WIN32
if (id == id_new_pgroup) {
if (eargp->new_pgroup_given) {
rb_raise(rb_eArgError, "new_pgroup option specified twice");
}
eargp->new_pgroup_given = 1;
eargp->new_pgroup_flag = RTEST(val) ? 1 : 0;
}
else
#endif
if (id == id_unsetenv_others) {
if (eargp->unsetenv_others_given) {
rb_raise(rb_eArgError, "unsetenv_others option specified twice");
}
eargp->unsetenv_others_given = 1;
eargp->unsetenv_others_do = RTEST(val) ? 1 : 0;
}
else if (id == id_chdir) {
if (eargp->chdir_given) {
rb_raise(rb_eArgError, "chdir option specified twice");
}
FilePathValue(val);
val = rb_str_encode_ospath(val);
eargp->chdir_given = 1;
eargp->chdir_dir = hide_obj(EXPORT_DUP(val));
}
else if (id == id_umask) {
mode_t cmask = NUM2MODET(val);
if (eargp->umask_given) {
rb_raise(rb_eArgError, "umask option specified twice");
}
eargp->umask_given = 1;
eargp->umask_mask = cmask;
}
else if (id == id_close_others) {
if (eargp->close_others_given) {
rb_raise(rb_eArgError, "close_others option specified twice");
}
eargp->close_others_given = 1;
eargp->close_others_do = RTEST(val) ? 1 : 0;
}
else if (id == id_in) {
key = INT2FIX(0);
goto redirect;
}
else if (id == id_out) {
key = INT2FIX(1);
goto redirect;
}
else if (id == id_err) {
key = INT2FIX(2);
goto redirect;
}
else if (id == id_uid) {
#ifdef HAVE_SETUID
if (eargp->uid_given) {
rb_raise(rb_eArgError, "uid option specified twice");
}
check_uid_switch();
{
eargp->uid = OBJ2UID(val);
eargp->uid_given = 1;
}
#else
rb_raise(rb_eNotImpError,
"uid option is unimplemented on this machine");
#endif
}
else if (id == id_gid) {
#ifdef HAVE_SETGID
if (eargp->gid_given) {
rb_raise(rb_eArgError, "gid option specified twice");
}
check_gid_switch();
{
eargp->gid = OBJ2GID(val);
eargp->gid_given = 1;
}
#else
rb_raise(rb_eNotImpError,
"gid option is unimplemented on this machine");
#endif
}
else {
return ST_STOP;
}
break;
case T_FIXNUM:
case T_FILE:
case T_ARRAY:
redirect:
check_exec_redirect(key, val, eargp);
break;
default:
return ST_STOP;
}
RB_GC_GUARD(execarg_obj);
return ST_CONTINUE;
}
static int
check_exec_options_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
{
VALUE key = (VALUE)st_key;
VALUE val = (VALUE)st_val;
VALUE execarg_obj = (VALUE)arg;
if (rb_execarg_addopt(execarg_obj, key, val) != ST_CONTINUE) {
if (SYMBOL_P(key))
rb_raise(rb_eArgError, "wrong exec option symbol: % "PRIsVALUE,
key);
rb_raise(rb_eArgError, "wrong exec option");
}
return ST_CONTINUE;
}
static int
check_exec_options_i_extract(st_data_t st_key, st_data_t st_val, st_data_t arg)
{
VALUE key = (VALUE)st_key;
VALUE val = (VALUE)st_val;
VALUE *args = (VALUE *)arg;
VALUE execarg_obj = args[0];
if (rb_execarg_addopt(execarg_obj, key, val) != ST_CONTINUE) {
VALUE nonopts = args[1];
if (NIL_P(nonopts)) args[1] = nonopts = rb_hash_new();
rb_hash_aset(nonopts, key, val);
}
return ST_CONTINUE;
}
static int
check_exec_fds_1(struct rb_execarg *eargp, VALUE h, int maxhint, VALUE ary)
{
long i;
if (ary != Qfalse) {
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
int fd = FIX2INT(RARRAY_AREF(elt, 0));
if (RTEST(rb_hash_lookup(h, INT2FIX(fd)))) {
rb_raise(rb_eArgError, "fd %d specified twice", fd);
}
if (ary == eargp->fd_dup2)
rb_hash_aset(h, INT2FIX(fd), Qtrue);
else if (ary == eargp->fd_dup2_child)
rb_hash_aset(h, INT2FIX(fd), RARRAY_AREF(elt, 1));
else /* ary == eargp->fd_close */
rb_hash_aset(h, INT2FIX(fd), INT2FIX(-1));
if (maxhint < fd)
maxhint = fd;
if (ary == eargp->fd_dup2 || ary == eargp->fd_dup2_child) {
fd = FIX2INT(RARRAY_AREF(elt, 1));
if (maxhint < fd)
maxhint = fd;
}
}
}
return maxhint;
}
static VALUE
check_exec_fds(struct rb_execarg *eargp)
{
VALUE h = rb_hash_new();
VALUE ary;
int maxhint = -1;
long i;
maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_dup2);
maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_close);
maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_dup2_child);
if (eargp->fd_dup2_child) {
ary = eargp->fd_dup2_child;
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
int newfd = FIX2INT(RARRAY_AREF(elt, 0));
int oldfd = FIX2INT(RARRAY_AREF(elt, 1));
int lastfd = oldfd;
VALUE val = rb_hash_lookup(h, INT2FIX(lastfd));
long depth = 0;
while (FIXNUM_P(val) && 0 <= FIX2INT(val)) {
lastfd = FIX2INT(val);
val = rb_hash_lookup(h, val);
if (RARRAY_LEN(ary) < depth)
rb_raise(rb_eArgError, "cyclic child fd redirection from %d", oldfd);
depth++;
}
if (val != Qtrue)
rb_raise(rb_eArgError, "child fd %d is not redirected", oldfd);
if (oldfd != lastfd) {
VALUE val2;
rb_ary_store(elt, 1, INT2FIX(lastfd));
rb_hash_aset(h, INT2FIX(newfd), INT2FIX(lastfd));
val = INT2FIX(oldfd);
while (FIXNUM_P(val2 = rb_hash_lookup(h, val))) {
rb_hash_aset(h, val, INT2FIX(lastfd));
val = val2;
}
}
}
}
eargp->close_others_maxhint = maxhint;
return h;
}
static void
rb_check_exec_options(VALUE opthash, VALUE execarg_obj)
{
if (RHASH_EMPTY_P(opthash))
return;
rb_hash_stlike_foreach(opthash, check_exec_options_i, (st_data_t)execarg_obj);
}
VALUE
rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
{
VALUE args[2];
if (RHASH_EMPTY_P(opthash))
return Qnil;
args[0] = execarg_obj;
args[1] = Qnil;
rb_hash_stlike_foreach(opthash, check_exec_options_i_extract, (st_data_t)args);
return args[1];
}
#ifdef ENV_IGNORECASE
#define ENVMATCH(s1, s2) (STRCASECMP((s1), (s2)) == 0)
#else
#define ENVMATCH(n1, n2) (strcmp((n1), (n2)) == 0)
#endif
static int
check_exec_env_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
{
VALUE key = (VALUE)st_key;
VALUE val = (VALUE)st_val;
VALUE env = ((VALUE *)arg)[0];
VALUE *path = &((VALUE *)arg)[1];
char *k;
k = StringValueCStr(key);
if (strchr(k, '='))
rb_raise(rb_eArgError, "environment name contains a equal : %s", k);
if (!NIL_P(val))
StringValueCStr(val);
key = EXPORT_STR(key);
if (!NIL_P(val)) val = EXPORT_STR(val);
if (ENVMATCH(k, PATH_ENV)) {
*path = val;
}
rb_ary_push(env, hide_obj(rb_assoc_new(key, val)));
return ST_CONTINUE;
}
static VALUE
rb_check_exec_env(VALUE hash, VALUE *path)
{
VALUE env[2];
env[0] = hide_obj(rb_ary_new());
env[1] = Qfalse;
rb_hash_stlike_foreach(hash, check_exec_env_i, (st_data_t)env);
*path = env[1];
return env[0];
}
static VALUE
rb_check_argv(int argc, VALUE *argv)
{
VALUE tmp, prog;
int i;
const char *name = 0;
rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
prog = 0;
tmp = rb_check_array_type(argv[0]);
if (!NIL_P(tmp)) {
if (RARRAY_LEN(tmp) != 2) {
rb_raise(rb_eArgError, "wrong first argument");
}
prog = RARRAY_AREF(tmp, 0);
argv[0] = RARRAY_AREF(tmp, 1);
SafeStringValue(prog);
StringValueCStr(prog);
prog = rb_str_new_frozen(prog);
name = RSTRING_PTR(prog);
}
for (i = 0; i < argc; i++) {
SafeStringValue(argv[i]);
argv[i] = rb_str_new_frozen(argv[i]);
StringValueCStr(argv[i]);
}
security(name ? name : RSTRING_PTR(argv[0]));
return prog;
}
static VALUE
check_hash(VALUE obj)
{
if (RB_SPECIAL_CONST_P(obj)) return Qnil;
switch (RB_BUILTIN_TYPE(obj)) {
case T_STRING:
case T_ARRAY:
return Qnil;
}
return rb_check_hash_type(obj);
}
static VALUE
rb_exec_getargs(int *argc_p, VALUE **argv_p, int accept_shell, VALUE *env_ret, VALUE *opthash_ret)
{
VALUE hash, prog;
if (0 < *argc_p) {
hash = check_hash((*argv_p)[*argc_p-1]);
if (!NIL_P(hash)) {
*opthash_ret = hash;
(*argc_p)--;
}
}
if (0 < *argc_p) {
hash = check_hash((*argv_p)[0]);
if (!NIL_P(hash)) {
*env_ret = hash;
(*argc_p)--;
(*argv_p)++;
}
}
prog = rb_check_argv(*argc_p, *argv_p);
if (!prog) {
prog = (*argv_p)[0];
if (accept_shell && *argc_p == 1) {
*argc_p = 0;
*argv_p = 0;
}
}
return prog;
}
#ifndef _WIN32
struct string_part {
const char *ptr;
size_t len;
};
static int
compare_posix_sh(const void *key, const void *el)
{
const struct string_part *word = key;
int ret = strncmp(word->ptr, el, word->len);
if (!ret && ((const char *)el)[word->len]) ret = -1;
return ret;
}
#endif
static void
rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VALUE execarg_obj)
{
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
char fbuf[MAXPATHLEN];
MEMZERO(eargp, struct rb_execarg, 1);
if (!NIL_P(opthash)) {
rb_check_exec_options(opthash, execarg_obj);
}
if (!NIL_P(env)) {
env = rb_check_exec_env(env, &eargp->path_env);
eargp->env_modification = env;
}
prog = EXPORT_STR(prog);
eargp->use_shell = argc == 0;
if (eargp->use_shell)
eargp->invoke.sh.shell_script = prog;
else
eargp->invoke.cmd.command_name = prog;
#ifndef _WIN32
if (eargp->use_shell) {
static const char posix_sh_cmds[][9] = {
"!", /* reserved */
".", /* special built-in */
":", /* special built-in */
"break", /* special built-in */
"case", /* reserved */
"continue", /* special built-in */
"do", /* reserved */
"done", /* reserved */
"elif", /* reserved */
"else", /* reserved */
"esac", /* reserved */
"eval", /* special built-in */
"exec", /* special built-in */
"exit", /* special built-in */
"export", /* special built-in */
"fi", /* reserved */
"for", /* reserved */
"if", /* reserved */
"in", /* reserved */
"readonly", /* special built-in */
"return", /* special built-in */
"set", /* special built-in */
"shift", /* special built-in */
"then", /* reserved */
"times", /* special built-in */
"trap", /* special built-in */
"unset", /* special built-in */
"until", /* reserved */
"while", /* reserved */
};
const char *p;
struct string_part first = {0, 0};
int has_meta = 0;
/*
* meta characters:
*
* * Pathname Expansion
* ? Pathname Expansion
* {} Grouping Commands
* [] Pathname Expansion
* <> Redirection
* () Grouping Commands
* ~ Tilde Expansion
* & AND Lists, Asynchronous Lists
* | OR Lists, Pipelines
* \ Escape Character
* $ Parameter Expansion
* ; Sequential Lists
* ' Single-Quotes
* ` Command Substitution
* " Double-Quotes
* \n Lists
*
* # Comment
* = Assignment preceding command name
* % (used in Parameter Expansion)
*/
for (p = RSTRING_PTR(prog); *p; p++) {
if (*p == ' ' || *p == '\t') {
if (first.ptr && !first.len) first.len = p - first.ptr;
}
else {
if (!first.ptr) first.ptr = p;
}
if (!has_meta && strchr("*?{}[]<>()~&|\\$;'`\"\n#", *p))
has_meta = 1;
if (!first.len) {
if (*p == '=') {
has_meta = 1;
}
else if (*p == '/') {
first.len = 0x100; /* longer than any posix_sh_cmds */
}
}
if (has_meta)
break;
}
if (!has_meta && first.ptr) {
if (!first.len) first.len = p - first.ptr;
if (first.len > 0 && first.len <= sizeof(posix_sh_cmds[0]) &&
bsearch(&first, posix_sh_cmds, numberof(posix_sh_cmds), sizeof(posix_sh_cmds[0]), compare_posix_sh))
has_meta = 1;
}
if (!has_meta) {
/* avoid shell since no shell meta character found. */
eargp->use_shell = 0;
}
if (!eargp->use_shell) {
VALUE argv_buf;
argv_buf = hide_obj(rb_str_buf_new(0));
p = RSTRING_PTR(prog);
while (*p) {
while (*p == ' ' || *p == '\t')
p++;
if (*p) {
const char *w = p;
while (*p && *p != ' ' && *p != '\t')
p++;
rb_str_buf_cat(argv_buf, w, p-w);
rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */
}
}
eargp->invoke.cmd.argv_buf = argv_buf;
eargp->invoke.cmd.command_name =
hide_obj(rb_str_subseq(argv_buf, 0, strlen(RSTRING_PTR(argv_buf))));
rb_enc_copy(eargp->invoke.cmd.command_name, prog);
}
}
#endif
if (!eargp->use_shell) {
const char *abspath;
const char *path_env = 0;
if (RTEST(eargp->path_env)) path_env = RSTRING_PTR(eargp->path_env);
abspath = dln_find_exe_r(RSTRING_PTR(eargp->invoke.cmd.command_name),
path_env, fbuf, sizeof(fbuf));
if (abspath)
eargp->invoke.cmd.command_abspath = rb_str_new_cstr(abspath);
else
eargp->invoke.cmd.command_abspath = Qnil;
}
if (!eargp->use_shell && !eargp->invoke.cmd.argv_buf) {
int i;
VALUE argv_buf;
argv_buf = rb_str_buf_new(0);
hide_obj(argv_buf);
for (i = 0; i < argc; i++) {
VALUE arg = argv[i];
const char *s = StringValueCStr(arg);
#ifdef DEFAULT_PROCESS_ENCODING
arg = EXPORT_STR(arg);
s = RSTRING_PTR(arg);
#endif
rb_str_buf_cat(argv_buf, s, RSTRING_LEN(arg) + 1); /* include '\0' */
}
eargp->invoke.cmd.argv_buf = argv_buf;
}
if (!eargp->use_shell) {
const char *p, *ep, *null=NULL;
VALUE argv_str;
argv_str = hide_obj(rb_str_buf_new(sizeof(char*) * (argc + 2)));
rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* place holder for /bin/sh of try_with_sh. */
p = RSTRING_PTR(eargp->invoke.cmd.argv_buf);
ep = p + RSTRING_LEN(eargp->invoke.cmd.argv_buf);
while (p < ep) {
rb_str_buf_cat(argv_str, (char *)&p, sizeof(p));
p += strlen(p) + 1;
}
rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* terminator for execve. */
eargp->invoke.cmd.argv_str =
rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(argv_str);
}
RB_GC_GUARD(execarg_obj);
}
struct rb_execarg *
rb_execarg_get(VALUE execarg_obj)
{
struct rb_execarg *eargp;
TypedData_Get_Struct(execarg_obj, struct rb_execarg, &exec_arg_data_type, eargp);
return eargp;
}
static VALUE
rb_execarg_init(int argc, const VALUE *orig_argv, int accept_shell, VALUE execarg_obj, int allow_exc_opt)
{
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
VALUE prog, ret, exception = Qnil;
VALUE env = Qnil, opthash = Qnil;
VALUE argv_buf;
VALUE *argv = ALLOCV_N(VALUE, argv_buf, argc);
MEMCPY(argv, orig_argv, VALUE, argc);
prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash);
if (allow_exc_opt && !NIL_P(opthash) && rb_hash_has_key(opthash, ID2SYM(id_exception))) {
opthash = rb_hash_dup(opthash);
exception = rb_hash_delete(opthash, ID2SYM(id_exception));
}
rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj);
if (RTEST(exception)) {
eargp->exception = 1;
}
ALLOCV_END(argv_buf);
ret = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
RB_GC_GUARD(execarg_obj);
return ret;
}
VALUE
rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt)
{
VALUE execarg_obj;
struct rb_execarg *eargp;
execarg_obj = TypedData_Make_Struct(0, struct rb_execarg, &exec_arg_data_type, eargp);
rb_execarg_init(argc, argv, accept_shell, execarg_obj, allow_exc_opt);
return execarg_obj;
}
void
rb_execarg_setenv(VALUE execarg_obj, VALUE env)
{
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
env = !NIL_P(env) ? rb_check_exec_env(env, &eargp->path_env) : Qfalse;
eargp->env_modification = env;
}
static int
fill_envp_buf_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
{
VALUE key = (VALUE)st_key;
VALUE val = (VALUE)st_val;
VALUE envp_buf = (VALUE)arg;
rb_str_buf_cat2(envp_buf, StringValueCStr(key));
rb_str_buf_cat2(envp_buf, "=");
rb_str_buf_cat2(envp_buf, StringValueCStr(val));
rb_str_buf_cat(envp_buf, "", 1); /* append '\0' */
return ST_CONTINUE;
}
static long run_exec_dup2_tmpbuf_size(long n);
struct open_struct {
VALUE fname;
int oflags;
mode_t perm;
int ret;
int err;
};
static void *
open_func(void *ptr)
{
struct open_struct *data = ptr;
const char *fname = RSTRING_PTR(data->fname);
data->ret = parent_redirect_open(fname, data->oflags, data->perm);
data->err = errno;
return NULL;
}
static void
rb_execarg_allocate_dup2_tmpbuf(struct rb_execarg *eargp, long len)
{
VALUE tmpbuf = rb_imemo_tmpbuf_auto_free_pointer(NULL);
((rb_imemo_tmpbuf_t *)tmpbuf)->ptr = ruby_xmalloc(run_exec_dup2_tmpbuf_size(len));
eargp->dup2_tmpbuf = tmpbuf;
}
static VALUE
rb_execarg_parent_start1(VALUE execarg_obj)
{
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
int unsetenv_others;
VALUE envopts;
VALUE ary;
ary = eargp->fd_open;
if (ary != Qfalse) {
long i;
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
int fd = FIX2INT(RARRAY_AREF(elt, 0));
VALUE param = RARRAY_AREF(elt, 1);
VALUE vpath = RARRAY_AREF(param, 0);
int flags = NUM2INT(RARRAY_AREF(param, 1));
mode_t perm = NUM2MODET(RARRAY_AREF(param, 2));
VALUE fd2v = RARRAY_AREF(param, 3);
int fd2;
if (NIL_P(fd2v)) {
struct open_struct open_data;
FilePathValue(vpath);
vpath = rb_str_encode_ospath(vpath);
again:
open_data.fname = vpath;
open_data.oflags = flags;
open_data.perm = perm;
open_data.ret = -1;
open_data.err = EINTR;
rb_thread_call_without_gvl2(open_func, (void *)&open_data, RUBY_UBF_IO, 0);
if (open_data.ret == -1) {
if (open_data.err == EINTR) {
rb_thread_check_ints();
goto again;
}
rb_syserr_fail_str(open_data.err, vpath);
}
fd2 = open_data.ret;
rb_update_max_fd(fd2);
RARRAY_ASET(param, 3, INT2FIX(fd2));
rb_thread_check_ints();
}
else {
fd2 = NUM2INT(fd2v);
}
rb_execarg_addopt(execarg_obj, INT2FIX(fd), INT2FIX(fd2));
}
}
eargp->redirect_fds = check_exec_fds(eargp);
ary = eargp->fd_dup2;
if (ary != Qfalse) {
rb_execarg_allocate_dup2_tmpbuf(eargp, RARRAY_LEN(ary));
}
unsetenv_others = eargp->unsetenv_others_given && eargp->unsetenv_others_do;
envopts = eargp->env_modification;
if (ALWAYS_NEED_ENVP || unsetenv_others || envopts != Qfalse) {
VALUE envtbl, envp_str, envp_buf;
char *p, *ep;
if (unsetenv_others) {
envtbl = rb_hash_new();
}
else {
envtbl = rb_const_get(rb_cObject, id_ENV);
envtbl = rb_to_hash_type(envtbl);
}
hide_obj(envtbl);
if (envopts != Qfalse) {
st_table *stenv = RHASH_TBL_RAW(envtbl);
long i;
for (i = 0; i < RARRAY_LEN(envopts); i++) {
VALUE pair = RARRAY_AREF(envopts, i);
VALUE key = RARRAY_AREF(pair, 0);
VALUE val = RARRAY_AREF(pair, 1);
if (NIL_P(val)) {
st_data_t stkey = (st_data_t)key;
st_delete(stenv, &stkey, NULL);
}
else {
st_insert(stenv, (st_data_t)key, (st_data_t)val);
RB_OBJ_WRITTEN(envtbl, Qundef, key);
RB_OBJ_WRITTEN(envtbl, Qundef, val);
}
}
}
envp_buf = rb_str_buf_new(0);
hide_obj(envp_buf);
rb_hash_stlike_foreach(envtbl, fill_envp_buf_i, (st_data_t)envp_buf);
envp_str = rb_str_buf_new(sizeof(char*) * (RHASH_SIZE(envtbl) + 1));
hide_obj(envp_str);
p = RSTRING_PTR(envp_buf);
ep = p + RSTRING_LEN(envp_buf);
while (p < ep) {
rb_str_buf_cat(envp_str, (char *)&p, sizeof(p));
p += strlen(p) + 1;
}
p = NULL;
rb_str_buf_cat(envp_str, (char *)&p, sizeof(p));
eargp->envp_str =
rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(envp_str);
eargp->envp_buf = envp_buf;
/*
char **tmp_envp = (char **)RSTRING_PTR(envp_str);
while (*tmp_envp) {
printf("%s\n", *tmp_envp);
tmp_envp++;
}
*/
}
RB_GC_GUARD(execarg_obj);
return Qnil;
}
void
rb_execarg_parent_start(VALUE execarg_obj)
{
int state;
rb_protect(rb_execarg_parent_start1, execarg_obj, &state);
if (state) {
rb_execarg_parent_end(execarg_obj);
rb_jump_tag(state);
}
}
static VALUE
execarg_parent_end(VALUE execarg_obj)
{
struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
int err = errno;
VALUE ary;
ary = eargp->fd_open;
if (ary != Qfalse) {
long i;
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
VALUE param = RARRAY_AREF(elt, 1);
VALUE fd2v;
int fd2;
fd2v = RARRAY_AREF(param, 3);
if (!NIL_P(fd2v)) {
fd2 = FIX2INT(fd2v);
parent_redirect_close(fd2);
RARRAY_ASET(param, 3, Qnil);
}
}
}
errno = err;
return execarg_obj;
}
void
rb_execarg_parent_end(VALUE execarg_obj)
{
execarg_parent_end(execarg_obj);
RB_GC_GUARD(execarg_obj);
}
static void
rb_exec_fail(struct rb_execarg *eargp, int err, const char *errmsg)
{
if (!errmsg || !*errmsg) return;
if (strcmp(errmsg, "chdir") == 0) {
rb_sys_fail_str(eargp->chdir_dir);
}
rb_sys_fail(errmsg);
}
#if 0
void
rb_execarg_fail(VALUE execarg_obj, int err, const char *errmsg)
{
if (!errmsg || !*errmsg) return;
rb_exec_fail(rb_execarg_get(execarg_obj), err, errmsg);
RB_GC_GUARD(execarg_obj);
}
#endif
/*
* call-seq:
* exec([env,] command... [,options])
*
* Replaces the current process by running the given external _command_, which
* can take one of the following forms:
*
* [<code>exec(commandline)</code>]
* command line string which is passed to the standard shell
* [<code>exec(cmdname, arg1, ...)</code>]
* command name and one or more arguments (no shell)
* [<code>exec([cmdname, argv0], arg1, ...)</code>]
* command name, argv[0] and zero or more arguments (no shell)
*
* In the first form, the string is taken as a command line that is subject to
* shell expansion before being executed.
*
* The standard shell always means <code>"/bin/sh"</code> on Unix-like systems,
* same as <code>ENV["RUBYSHELL"]</code>
* (or <code>ENV["COMSPEC"]</code> on Windows NT series), and similar.
*
* If the string from the first form (<code>exec("command")</code>) follows
* these simple rules:
*
* * no meta characters
* * no shell reserved word and no special built-in
* * Ruby invokes the command directly without shell
*
* You can force shell invocation by adding ";" to the string (because ";" is
* a meta character).
*
* Note that this behavior is observable by pid obtained
* (return value of spawn() and IO#pid for IO.popen) is the pid of the invoked
* command, not shell.
*
* In the second form (<code>exec("command1", "arg1", ...)</code>), the first
* is taken as a command name and the rest are passed as parameters to command
* with no shell expansion.
*
* In the third form (<code>exec(["command", "argv0"], "arg1", ...)</code>),
* starting a two-element array at the beginning of the command, the first
* element is the command to be executed, and the second argument is used as
* the <code>argv[0]</code> value, which may show up in process listings.
*
* In order to execute the command, one of the <code>exec(2)</code> system
* calls are used, so the running command may inherit some of the environment
* of the original program (including open file descriptors).
*
* This behavior is modified by the given +env+ and +options+ parameters. See
* ::spawn for details.
*
* If the command fails to execute (typically Errno::ENOENT when
* it was not found) a SystemCallError exception is raised.
*
* This method modifies process attributes according to given +options+ before
* <code>exec(2)</code> system call. See ::spawn for more details about the
* given +options+.
*
* The modified attributes may be retained when <code>exec(2)</code> system
* call fails.
*
* For example, hard resource limits are not restorable.
*
* Consider to create a child process using ::spawn or Kernel#system if this
* is not acceptable.
*
* exec "echo *" # echoes list of files in current directory
* # never get here
*
* exec "echo", "*" # echoes an asterisk
* # never get here
*/
VALUE
rb_f_exec(int argc, const VALUE *argv)
{
VALUE execarg_obj, fail_str;
struct rb_execarg *eargp;
#define CHILD_ERRMSG_BUFLEN 80
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
int err;
execarg_obj = rb_execarg_new(argc, argv, TRUE, FALSE);
eargp = rb_execarg_get(execarg_obj);
if (mjit_enabled) mjit_finish(false); // avoid leaking resources, and do not leave files. XXX: JIT-ed handle can leak after exec error is rescued.
before_exec(); /* stop timer thread before redirects */
rb_execarg_parent_start(execarg_obj);
fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
err = exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
after_exec(); /* restart timer thread */
rb_exec_fail(eargp, err, errmsg);
RB_GC_GUARD(execarg_obj);
rb_syserr_fail_str(err, fail_str);
UNREACHABLE_RETURN(Qnil);
}
#define ERRMSG(str) do { if (errmsg && 0 < errmsg_buflen) strlcpy(errmsg, (str), errmsg_buflen); } while (0)
#define ERRMSG1(str, a) do { if (errmsg && 0 < errmsg_buflen) snprintf(errmsg, errmsg_buflen, (str), (a)); } while (0)
#define ERRMSG2(str, a, b) do { if (errmsg && 0 < errmsg_buflen) snprintf(errmsg, errmsg_buflen, (str), (a), (b)); } while (0)
static int fd_get_cloexec(int fd, char *errmsg, size_t errmsg_buflen);
static int fd_set_cloexec(int fd, char *errmsg, size_t errmsg_buflen);
static int fd_clear_cloexec(int fd, char *errmsg, size_t errmsg_buflen);
static int
save_redirect_fd(int fd, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
if (sargp) {
VALUE newary, redirection;
int save_fd = redirect_cloexec_dup(fd), cloexec;
if (save_fd == -1) {
if (errno == EBADF)
return 0;
ERRMSG("dup");
return -1;
}
rb_update_max_fd(save_fd);
newary = sargp->fd_dup2;
if (newary == Qfalse) {
newary = hide_obj(rb_ary_new());
sargp->fd_dup2 = newary;
}
cloexec = fd_get_cloexec(fd, errmsg, errmsg_buflen);
redirection = hide_obj(rb_assoc_new(INT2FIX(fd), INT2FIX(save_fd)));
if (cloexec) rb_ary_push(redirection, Qtrue);
rb_ary_push(newary, redirection);
newary = sargp->fd_close;
if (newary == Qfalse) {
newary = hide_obj(rb_ary_new());
sargp->fd_close = newary;
}
rb_ary_push(newary, hide_obj(rb_assoc_new(INT2FIX(save_fd), Qnil)));
}
return 0;
}
static int
intcmp(const void *a, const void *b)
{
return *(int*)a - *(int*)b;
}
static int
intrcmp(const void *a, const void *b)
{
return *(int*)b - *(int*)a;
}
struct run_exec_dup2_fd_pair {
int oldfd;
int newfd;
long older_index;
long num_newer;
int cloexec;
};
static long
run_exec_dup2_tmpbuf_size(long n)
{
return sizeof(struct run_exec_dup2_fd_pair) * n;
}
/* This function should be async-signal-safe. Actually it is. */
static int
fd_get_cloexec(int fd, char *errmsg, size_t errmsg_buflen)
{
#ifdef F_GETFD
int ret = 0;
ret = fcntl(fd, F_GETFD); /* async-signal-safe */
if (ret == -1) {
ERRMSG("fcntl(F_GETFD)");
return -1;
}
if (ret & FD_CLOEXEC) return 1;
#endif
return 0;
}
/* This function should be async-signal-safe. Actually it is. */
static int
fd_set_cloexec(int fd, char *errmsg, size_t errmsg_buflen)
{
#ifdef F_GETFD
int ret = 0;
ret = fcntl(fd, F_GETFD); /* async-signal-safe */
if (ret == -1) {
ERRMSG("fcntl(F_GETFD)");
return -1;
}
if (!(ret & FD_CLOEXEC)) {
ret |= FD_CLOEXEC;
ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */
if (ret == -1) {
ERRMSG("fcntl(F_SETFD)");
return -1;
}
}
#endif
return 0;
}
/* This function should be async-signal-safe. Actually it is. */
static int
fd_clear_cloexec(int fd, char *errmsg, size_t errmsg_buflen)
{
#ifdef F_GETFD
int ret;
ret = fcntl(fd, F_GETFD); /* async-signal-safe */
if (ret == -1) {
ERRMSG("fcntl(F_GETFD)");
return -1;
}
if (ret & FD_CLOEXEC) {
ret &= ~FD_CLOEXEC;
ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */
if (ret == -1) {
ERRMSG("fcntl(F_SETFD)");
return -1;
}
}
#endif
return 0;
}
/* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */
static int
run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
long n, i;
int ret;
int extra_fd = -1;
struct rb_imemo_tmpbuf_struct *buf = (void *)tmpbuf;
struct run_exec_dup2_fd_pair *pairs = (void *)buf->ptr;
n = RARRAY_LEN(ary);
/* initialize oldfd and newfd: O(n) */
for (i = 0; i < n; i++) {
VALUE elt = RARRAY_AREF(ary, i);
pairs[i].oldfd = FIX2INT(RARRAY_AREF(elt, 1));
pairs[i].newfd = FIX2INT(RARRAY_AREF(elt, 0)); /* unique */
pairs[i].cloexec = RARRAY_LEN(elt) > 2 && RTEST(RARRAY_AREF(elt, 2));
pairs[i].older_index = -1;
}
/* sort the table by oldfd: O(n log n) */
if (!sargp)
qsort(pairs, n, sizeof(struct run_exec_dup2_fd_pair), intcmp); /* hopefully async-signal-safe */
else
qsort(pairs, n, sizeof(struct run_exec_dup2_fd_pair), intrcmp);
/* initialize older_index and num_newer: O(n log n) */
for (i = 0; i < n; i++) {
int newfd = pairs[i].newfd;
struct run_exec_dup2_fd_pair key, *found;
key.oldfd = newfd;
found = bsearch(&key, pairs, n, sizeof(struct run_exec_dup2_fd_pair), intcmp); /* hopefully async-signal-safe */
pairs[i].num_newer = 0;
if (found) {
while (pairs < found && (found-1)->oldfd == newfd)
found--;
while (found < pairs+n && found->oldfd == newfd) {
pairs[i].num_newer++;
found->older_index = i;
found++;
}
}
}
/* non-cyclic redirection: O(n) */
for (i = 0; i < n; i++) {
long j = i;
while (j != -1 && pairs[j].oldfd != -1 && pairs[j].num_newer == 0) {
if (save_redirect_fd(pairs[j].newfd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */
goto fail;
ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("dup2");
goto fail;
}
if (pairs[j].cloexec &&
fd_set_cloexec(pairs[j].newfd, errmsg, errmsg_buflen)) {
goto fail;
}
rb_update_max_fd(pairs[j].newfd); /* async-signal-safe but don't need to call it in a child process. */
pairs[j].oldfd = -1;
j = pairs[j].older_index;
if (j != -1)
pairs[j].num_newer--;
}
}
/* cyclic redirection: O(n) */
for (i = 0; i < n; i++) {
long j;
if (pairs[i].oldfd == -1)
continue;
if (pairs[i].oldfd == pairs[i].newfd) { /* self cycle */
if (fd_clear_cloexec(pairs[i].oldfd, errmsg, errmsg_buflen) == -1) /* async-signal-safe */
goto fail;
pairs[i].oldfd = -1;
continue;
}
if (extra_fd == -1) {
extra_fd = redirect_dup(pairs[i].oldfd); /* async-signal-safe */
if (extra_fd == -1) {
ERRMSG("dup");
goto fail;
}
rb_update_max_fd(extra_fd);
}
else {
ret = redirect_dup2(pairs[i].oldfd, extra_fd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("dup2");
goto fail;
}
rb_update_max_fd(extra_fd);
}
pairs[i].oldfd = extra_fd;
j = pairs[i].older_index;
pairs[i].older_index = -1;
while (j != -1) {
ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("dup2");
goto fail;
}
rb_update_max_fd(ret);
pairs[j].oldfd = -1;
j = pairs[j].older_index;
}
}
if (extra_fd != -1) {
ret = redirect_close(extra_fd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("close");
goto fail;
}
}
return 0;
fail:
return -1;
}
/* This function should be async-signal-safe. Actually it is. */
static int
run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen)
{
long i;
int ret;
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
int fd = FIX2INT(RARRAY_AREF(elt, 0));
ret = redirect_close(fd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("close");
return -1;
}
}
return 0;
}
/* This function should be async-signal-safe when sargp is NULL. Actually it is. */
static int
run_exec_dup2_child(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
long i;
int ret;
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
int newfd = FIX2INT(RARRAY_AREF(elt, 0));
int oldfd = FIX2INT(RARRAY_AREF(elt, 1));
if (save_redirect_fd(newfd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */
return -1;
ret = redirect_dup2(oldfd, newfd); /* async-signal-safe */
if (ret == -1) {
ERRMSG("dup2");
return -1;
}
rb_update_max_fd(newfd);
}
return 0;
}
#ifdef HAVE_SETPGID
/* This function should be async-signal-safe when sargp is NULL. Actually it is. */
static int
run_exec_pgroup(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
/*
* If FD_CLOEXEC is available, rb_fork_async_signal_safe waits the child's execve.
* So setpgid is done in the child when rb_fork_async_signal_safe is returned in
* the parent.
* No race condition, even without setpgid from the parent.
* (Is there an environment which has setpgid but no FD_CLOEXEC?)
*/
int ret;
rb_pid_t pgroup;
pgroup = eargp->pgroup_pgid;
if (pgroup == -1)
return 0;
if (sargp) {
/* maybe meaningless with no fork environment... */
sargp->pgroup_given = 1;
sargp->pgroup_pgid = getpgrp();
}
if (pgroup == 0) {
pgroup = getpid(); /* async-signal-safe */
}
ret = setpgid(getpid(), pgroup); /* async-signal-safe */
if (ret == -1) ERRMSG("setpgid");
return ret;
}
#endif
#if defined(HAVE_SETRLIMIT) && defined(RLIM2NUM)
/* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */
static int
run_exec_rlimit(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
long i;
for (i = 0; i < RARRAY_LEN(ary); i++) {
VALUE elt = RARRAY_AREF(ary, i);
int rtype = NUM2INT(RARRAY_AREF(elt, 0));
struct rlimit rlim;
if (sargp) {
VALUE tmp, newary;
if (getrlimit(rtype, &rlim) == -1) {
ERRMSG("getrlimit");
return -1;
}
tmp = hide_obj(rb_ary_new3(3, RARRAY_AREF(elt, 0),
RLIM2NUM(rlim.rlim_cur),
RLIM2NUM(rlim.rlim_max)));
if (sargp->rlimit_limits == Qfalse)
newary = sargp->rlimit_limits = hide_obj(rb_ary_new());
else
newary = sargp->rlimit_limits;
rb_ary_push(newary, tmp);
}
rlim.rlim_cur = NUM2RLIM(RARRAY_AREF(elt, 1));
rlim.rlim_max = NUM2RLIM(RARRAY_AREF(elt, 2));
if (setrlimit(rtype, &rlim) == -1) { /* hopefully async-signal-safe */
ERRMSG("setrlimit");
return -1;
}
}
return 0;
}
#endif
#if !defined(HAVE_WORKING_FORK)
static VALUE
save_env_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
{
rb_ary_push(ary, hide_obj(rb_ary_dup(argv[0])));
return Qnil;
}
static void
save_env(struct rb_execarg *sargp)
{
if (!sargp)
return;
if (sargp->env_modification == Qfalse) {
VALUE env = rb_const_get(rb_cObject, id_ENV);
if (RTEST(env)) {
VALUE ary = hide_obj(rb_ary_new());
rb_block_call(env, idEach, 0, 0, save_env_i,
(VALUE)ary);
sargp->env_modification = ary;
}
sargp->unsetenv_others_given = 1;
sargp->unsetenv_others_do = 1;
}
}
#endif
#ifdef _WIN32
#undef chdir
#define chdir(p) rb_w32_uchdir(p)
#endif
/* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */
int
rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
{
VALUE obj;
if (sargp) {
/* assume that sargp is always NULL on fork-able environments */
MEMZERO(sargp, struct rb_execarg, 1);
sargp->redirect_fds = Qnil;
}
#ifdef HAVE_SETPGID
if (eargp->pgroup_given) {
if (run_exec_pgroup(eargp, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */
return -1;
}
#endif
#if defined(HAVE_SETRLIMIT) && defined(RLIM2NUM)
obj = eargp->rlimit_limits;
if (obj != Qfalse) {
if (run_exec_rlimit(obj, sargp, errmsg, errmsg_buflen) == -1) /* hopefully async-signal-safe */
return -1;
}
#endif
#if !defined(HAVE_WORKING_FORK)
if (eargp->unsetenv_others_given && eargp->unsetenv_others_do) {
save_env(sargp);
rb_env_clear();
}
obj = eargp->env_modification;
if (obj != Qfalse) {
long i;
save_env(sargp);
for (i = 0; i < RARRAY_LEN(obj); i++) {
VALUE pair = RARRAY_AREF(obj, i);
VALUE key = RARRAY_AREF(pair, 0);
VALUE val = RARRAY_AREF(pair, 1);
if (NIL_P(val))
ruby_setenv(StringValueCStr(key), 0);
else
ruby_setenv(StringValueCStr(key), StringValueCStr(val));
}
}
#endif
if (eargp->umask_given) {
mode_t mask = eargp->umask_mask;
mode_t oldmask = umask(mask); /* never fail */ /* async-signal-safe */
if (sargp) {
sargp->umask_given = 1;
sargp->umask_mask = oldmask;
}
}
obj = eargp->fd_dup2;
if (obj != Qfalse) {
if (run_exec_dup2(obj, eargp->dup2_tmpbuf, sargp, errmsg, errmsg_buflen) == -1) /* hopefully async-signal-safe */
return -1;
}
obj = eargp->fd_close;
if (obj != Qfalse) {
if (sargp)
rb_warn("cannot close fd before spawn");
else {
if (run_exec_close(obj, errmsg, errmsg_buflen) == -1) /* async-signal-safe */
return -1;
}
}
#ifdef HAVE_WORKING_FORK
if (eargp->close_others_do) {
rb_close_before_exec(3, eargp->close_others_maxhint, eargp->redirect_fds); /* async-signal-safe */
}
#endif
obj = eargp->fd_dup2_child;
if (obj != Qfalse) {
if (run_exec_dup2_child(obj, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */
return -1;
}
if (eargp->chdir_given) {
if (sargp) {
char *cwd = ruby_getcwd();
sargp->chdir_given = 1;
sargp->chdir_dir = hide_obj(rb_str_new2(cwd));
xfree(cwd);
}
if (chdir(RSTRING_PTR(eargp->chdir_dir)) == -1) { /* async-signal-safe */
ERRMSG("chdir");
return -1;
}
}
#ifdef HAVE_SETGID
if (eargp->gid_given) {
if (setgid(eargp->gid) < 0) {
ERRMSG("setgid");
return -1;
}
}
#endif
#ifdef HAVE_SETUID
if (eargp->uid_given) {
if (setuid(eargp->uid) < 0) {
ERRMSG("setuid");
return -1;
}
}
#endif
if (sargp) {
VALUE ary = sargp->fd_dup2;
if (ary != Qfalse) {
rb_execarg_allocate_dup2_tmpbuf(sargp, RARRAY_LEN(ary));
}
}
{
int preserve = errno;
stdfd_clear_nonblock();
errno = preserve;
}
return 0;
}
/* This function should be async-signal-safe. Hopefully it is. */
int
rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{
errno = exec_async_signal_safe(eargp, errmsg, errmsg_buflen);
return -1;
}
static int
exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{
#if !defined(HAVE_WORKING_FORK)
struct rb_execarg sarg, *const sargp = &sarg;
#else
struct rb_execarg *const sargp = NULL;
#endif
int err;
if (rb_execarg_run_options(eargp, sargp, errmsg, errmsg_buflen) < 0) { /* hopefully async-signal-safe */
return errno;
}
if (eargp->use_shell) {
err = proc_exec_sh(RSTRING_PTR(eargp->invoke.sh.shell_script), eargp->envp_str); /* async-signal-safe */
}
else {
char *abspath = NULL;
if (!NIL_P(eargp->invoke.cmd.command_abspath))
abspath = RSTRING_PTR(eargp->invoke.cmd.command_abspath);
err = proc_exec_cmd(abspath, eargp->invoke.cmd.argv_str, eargp->envp_str); /* async-signal-safe */
}
#if !defined(HAVE_WORKING_FORK)
rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen);
#endif
return err;
}
#ifdef HAVE_WORKING_FORK
/* This function should be async-signal-safe. Hopefully it is. */
static int
rb_exec_atfork(void* arg, char *errmsg, size_t errmsg_buflen)
{
return rb_exec_async_signal_safe(arg, errmsg, errmsg_buflen); /* hopefully async-signal-safe */
}
#endif
#ifdef HAVE_WORKING_FORK
#if SIZEOF_INT == SIZEOF_LONG
#define proc_syswait (VALUE (*)(VALUE))rb_syswait
#else
static VALUE
proc_syswait(VALUE pid)
{
rb_syswait((int)pid);
return Qnil;
}
#endif
static int
move_fds_to_avoid_crash(int *fdp, int n, VALUE fds)
{
int min = 0;
int i;
for (i = 0; i < n; i++) {
int ret;
while (RTEST(rb_hash_lookup(fds, INT2FIX(fdp[i])))) {
if (min <= fdp[i])
min = fdp[i]+1;
while (RTEST(rb_hash_lookup(fds, INT2FIX(min))))
min++;
ret = rb_cloexec_fcntl_dupfd(fdp[i], min);
if (ret == -1)
return -1;
rb_update_max_fd(ret);
close(fdp[i]);
fdp[i] = ret;
}
}
return 0;
}
static int
pipe_nocrash(int filedes[2], VALUE fds)
{
int ret;
ret = rb_pipe(filedes);
if (ret == -1)
return -1;
if (RTEST(fds)) {
int save = errno;
if (move_fds_to_avoid_crash(filedes, 2, fds) == -1) {
close(filedes[0]);
close(filedes[1]);
return -1;
}
errno = save;
}
return ret;
}
#ifndef O_BINARY
#define O_BINARY 0
#endif
static VALUE
rb_thread_sleep_that_takes_VALUE_as_sole_argument(VALUE n)
{
rb_thread_sleep(NUM2INT(n));
return Qundef;
}
static int
handle_fork_error(int err, int *status, int *ep, volatile int *try_gc_p)
{
int state = 0;
switch (err) {
case ENOMEM:
if ((*try_gc_p)-- > 0 && !rb_during_gc()) {
rb_gc();
return 0;
}
break;
case EAGAIN:
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
case EWOULDBLOCK:
#endif
if (!status && !ep) {
rb_thread_sleep(1);
return 0;
}
else {
rb_protect(rb_thread_sleep_that_takes_VALUE_as_sole_argument, INT2FIX(1), &state);
if (status) *status = state;
if (!state) return 0;
}
break;
}
if (ep) {
close(ep[0]);
close(ep[1]);
errno = err;
}
if (state && !status) rb_jump_tag(state);
return -1;
}
#define prefork() ( \
rb_io_flush(rb_stdout), \
rb_io_flush(rb_stderr) \
)
/*
* Forks child process, and returns the process ID in the parent
* process.
*
* If +status+ is given, protects from any exceptions and sets the
* jump status to it, and returns -1. If failed to fork new process
* but no exceptions occurred, sets 0 to it. Otherwise, if forked
* successfully, the value of +status+ is undetermined.
*
* In the child process, just returns 0 if +chfunc+ is +NULL+.
* Otherwise +chfunc+ will be called with +charg+, and then the child
* process exits with +EXIT_SUCCESS+ when it returned zero.
*
* In the case of the function is called and returns non-zero value,
* the child process exits with non-+EXIT_SUCCESS+ value (normally
* 127). And, on the platforms where +FD_CLOEXEC+ is available,
* +errno+ is propagated to the parent process, and this function
* returns -1 in the parent process. On the other platforms, just
* returns pid.
*
* If fds is not Qnil, internal pipe for the errno propagation is
* arranged to avoid conflicts of the hash keys in +fds+.
*
* +chfunc+ must not raise any exceptions.
*/
static ssize_t
write_retry(int fd, const void *buf, size_t len)
{
ssize_t w;
do {
w = write(fd, buf, len);
} while (w < 0 && errno == EINTR);
return w;
}
static ssize_t
read_retry(int fd, void *buf, size_t len)
{
ssize_t r;
if (set_blocking(fd) != 0) {
#ifndef _WIN32
rb_async_bug_errno("set_blocking failed reading child error", errno);
#endif
}
do {
r = read(fd, buf, len);
} while (r < 0 && errno == EINTR);
return r;
}
static void
send_child_error(int fd, char *errmsg, size_t errmsg_buflen)
{
int err;
err = errno;
if (write_retry(fd, &err, sizeof(err)) < 0) err = errno;
if (errmsg && 0 < errmsg_buflen) {
errmsg[errmsg_buflen-1] = '\0';
errmsg_buflen = strlen(errmsg);
if (errmsg_buflen > 0 && write_retry(fd, errmsg, errmsg_buflen) < 0)
err = errno;
}
}
static int
recv_child_error(int fd, int *errp, char *errmsg, size_t errmsg_buflen)
{
int err;
ssize_t size;
if ((size = read_retry(fd, &err, sizeof(err))) < 0) {
err = errno;
}
*errp = err;
if (size == sizeof(err) &&
errmsg && 0 < errmsg_buflen) {
ssize_t ret = read_retry(fd, errmsg, errmsg_buflen-1);
if (0 <= ret) {
errmsg[ret] = '\0';
}
}
close(fd);
return size != 0;
}
#ifdef HAVE_WORKING_VFORK
#if !defined(HAVE_GETRESUID) && defined(HAVE_GETUIDX)
/* AIX 7.1 */
static int
getresuid(rb_uid_t *ruid, rb_uid_t *euid, rb_uid_t *suid)
{
rb_uid_t ret;
*ruid = getuid();
*euid = geteuid();
ret = getuidx(ID_SAVED);
if (ret == (rb_uid_t)-1)
return -1;
*suid = ret;
return 0;
}
#define HAVE_GETRESUID
#endif
#if !defined(HAVE_GETRESGID) && defined(HAVE_GETGIDX)
/* AIX 7.1 */
static int
getresgid(rb_gid_t *rgid, rb_gid_t *egid, rb_gid_t *sgid)
{
rb_gid_t ret;
*rgid = getgid();
*egid = getegid();
ret = getgidx(ID_SAVED);
if (ret == (rb_gid_t)-1)
return -1;
*sgid = ret;
return 0;
}
#define HAVE_GETRESGID
#endif
static int
has_privilege(void)
{
/*
* has_privilege() is used to choose vfork() or fork().
*
* If the process has privilege, the parent process or
* the child process can change UID/GID.
* If vfork() is used to create the child process and
* the parent or child process change effective UID/GID,
* different privileged processes shares memory.
* It is a bad situation.
* So, fork() should be used.
*/
rb_uid_t ruid, euid;
rb_gid_t rgid, egid;
#if defined HAVE_ISSETUGID
if (issetugid())
return 1;
#endif
#ifdef HAVE_GETRESUID
{
int ret;
rb_uid_t suid;
ret = getresuid(&ruid, &euid, &suid);
if (ret == -1)
rb_sys_fail("getresuid(2)");
if (euid != suid)
return 1;
}
#else
ruid = getuid();
euid = geteuid();
#endif
if (euid == 0 || euid != ruid)
return 1;
#ifdef HAVE_GETRESGID
{
int ret;
rb_gid_t sgid;
ret = getresgid(&rgid, &egid, &sgid);
if (ret == -1)
rb_sys_fail("getresgid(2)");
if (egid != sgid)
return 1;
}
#else
rgid = getgid();
egid = getegid();
#endif
if (egid != rgid)
return 1;
return 0;
}
#endif
struct child_handler_disabler_state
{
sigset_t sigmask;
};
static void
disable_child_handler_before_fork(struct child_handler_disabler_state *old)
{
int ret;
sigset_t all;
#ifdef HAVE_PTHREAD_SIGMASK
ret = sigfillset(&all);
if (ret == -1)
rb_sys_fail("sigfillset");
ret = pthread_sigmask(SIG_SETMASK, &all, &old->sigmask); /* not async-signal-safe */
if (ret != 0) {
rb_syserr_fail(ret, "pthread_sigmask");
}
#else
# pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous"
#endif
}
static void
disable_child_handler_fork_parent(struct child_handler_disabler_state *old)
{
int ret;
#ifdef HAVE_PTHREAD_SIGMASK
ret = pthread_sigmask(SIG_SETMASK, &old->sigmask, NULL); /* not async-signal-safe */
if (ret != 0) {
rb_syserr_fail(ret, "pthread_sigmask");
}
#else
# pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous"
#endif
}
/* This function should be async-signal-safe. Actually it is. */
static int
disable_child_handler_fork_child(struct child_handler_disabler_state *old, char *errmsg, size_t errmsg_buflen)
{
int sig;
int ret;
for (sig = 1; sig < NSIG; sig++) {
sig_t handler = signal(sig, SIG_DFL);
if (handler == SIG_ERR && errno == EINVAL) {
continue; /* Ignore invalid signal number */
}
if (handler == SIG_ERR) {
ERRMSG("signal to obtain old action");
return -1;
}
#ifdef SIGPIPE
if (sig == SIGPIPE) {
continue;
}
#endif
/* it will be reset to SIG_DFL at execve time, instead */
if (handler == SIG_IGN) {
signal(sig, SIG_IGN);
}
}
/* non-Ruby child process, ensure cmake can see SIGCHLD */
sigemptyset(&old->sigmask);
ret = sigprocmask(SIG_SETMASK, &old->sigmask, NULL); /* async-signal-safe */
if (ret != 0) {
ERRMSG("sigprocmask");
return -1;
}
return 0;
}
COMPILER_WARNING_PUSH
#ifdef __GNUC__
COMPILER_WARNING_IGNORED(-Wdeprecated-declarations)
#endif
static rb_pid_t
retry_fork_async_signal_safe(int *status, int *ep,
int (*chfunc)(void*, char *, size_t), void *charg,
char *errmsg, size_t errmsg_buflen,
struct waitpid_state *w)
{
rb_pid_t pid;
volatile int try_gc = 1;
struct child_handler_disabler_state old;
int err;
rb_nativethread_lock_t *const waitpid_lock_init =
(w && WAITPID_USE_SIGCHLD) ? &GET_VM()->waitpid_lock : 0;
while (1) {
rb_nativethread_lock_t *waitpid_lock = waitpid_lock_init;
prefork();
disable_child_handler_before_fork(&old);
if (waitpid_lock) {
rb_native_mutex_lock(waitpid_lock);
}
#ifdef HAVE_WORKING_VFORK
if (!has_privilege())
pid = vfork();
else
pid = fork();
#else
pid = fork();
#endif
if (pid == 0) {/* fork succeed, child process */
int ret;
close(ep[0]);
ret = disable_child_handler_fork_child(&old, errmsg, errmsg_buflen); /* async-signal-safe */
if (ret == 0) {
ret = chfunc(charg, errmsg, errmsg_buflen);
if (!ret) _exit(EXIT_SUCCESS);
}
send_child_error(ep[1], errmsg, errmsg_buflen);
#if EXIT_SUCCESS == 127
_exit(EXIT_FAILURE);
#else
_exit(127);
#endif
}
err = errno;
waitpid_lock = waitpid_lock_init;
if (waitpid_lock) {
if (pid > 0 && w != WAITPID_LOCK_ONLY) {
w->pid = pid;
list_add(&GET_VM()->waiting_pids, &w->wnode);
}
rb_native_mutex_unlock(waitpid_lock);
}
disable_child_handler_fork_parent(&old);
if (0 < pid) /* fork succeed, parent process */
return pid;
/* fork failed */
if (handle_fork_error(err, status, ep, &try_gc))
return -1;
}
}
COMPILER_WARNING_POP
static rb_pid_t
fork_check_err(int *status, int (*chfunc)(void*, char *, size_t), void *charg,
VALUE fds, char *errmsg, size_t errmsg_buflen,
struct rb_execarg *eargp)
{
rb_pid_t pid;
int err;
int ep[2];
int error_occurred;
struct waitpid_state *w;
w = eargp && eargp->waitpid_state ? eargp->waitpid_state : 0;
if (status) *status = 0;
if (pipe_nocrash(ep, fds)) return -1;
pid = retry_fork_async_signal_safe(status, ep, chfunc, charg,
errmsg, errmsg_buflen, w);
if (pid < 0)
return pid;
close(ep[1]);
error_occurred = recv_child_error(ep[0], &err, errmsg, errmsg_buflen);