diff options
Diffstat (limited to 'jni/ruby/process.c')
-rw-r--r-- | jni/ruby/process.c | 7947 |
1 files changed, 7947 insertions, 0 deletions
diff --git a/jni/ruby/process.c b/jni/ruby/process.c new file mode 100644 index 0000000..036e36d --- /dev/null +++ b/jni/ruby/process.c @@ -0,0 +1,7947 @@ +/********************************************************************** + + process.c - + + $Author: nobu $ + 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 "internal.h" +#include "ruby/io.h" +#include "ruby/thread.h" +#include "ruby/util.h" +#include "vm_core.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" + +#ifdef __EMX__ +#undef HAVE_GETPGRP +#endif + +#include <sys/stat.h> +#if defined(__native_client__) && defined(NACL_NEWLIB) +# include <sys/unistd.h> +# include "nacl/stat.h" +# include "nacl/unistd.h" +# include "nacl/resource.h" +# undef HAVE_ISSETUGID +#endif + +#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> +#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 + +#define preserving_errno(stmts) \ + do {int saved_errno = errno; stmts; errno = saved_errno;} while (0) + +static void check_uid_switch(void); +static void check_gid_switch(void); + +#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 \ + ALLOCV_END(getpw_buf) +# 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 \ + ALLOCV_END(getgr_buf) +# 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 + +static ID id_in, id_out, id_err, id_pid, id_uid, id_gid; +static ID id_close, id_child, id_status; +#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; + +/* + * call-seq: + * Process.pid -> fixnum + * + * Returns the process id of this process. Not available on all + * platforms. + * + * Process.pid #=> 27415 + */ + +static VALUE +get_pid(void) +{ + rb_secure(2); + return PIDT2NUM(getpid()); +} + + +/* + * call-seq: + * Process.ppid -> fixnum + * + * 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) +{ + rb_secure(2); + return PIDT2NUM(getppid()); +} + + +/********************************************************************* + * + * Document-class: Process::Status + * + * <code>Process::Status</code> encapsulates the information on the + * status of a running or terminated system process. The built-in + * variable <code>$?</code> is either +nil+ or a + * <code>Process::Status</code> 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 + * <code>Process::Status</code> 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; +} + +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 -> fixnum + * stat.to_int -> fixnum + * + * Returns the bits in _stat_ as a <code>Fixnum</code>. 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 -> fixnum + * + * 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 void +pst_message(VALUE str, rb_pid_t pid, int status) +{ + rb_str_catf(str, "pid %ld", (long)pid); + 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 +} + + +/* + * 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 -> fixnum + * + * 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 -> fixnum + * + * 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 <code>wait</code> call had the + * <code>WUNTRACED</code> flag set. + */ + +static VALUE +pst_wifstopped(VALUE st) +{ + int status = PST2INT(st); + + if (WIFSTOPPED(status)) + return Qtrue; + else + return Qfalse; +} + + +/* + * call-seq: + * stat.stopsig -> fixnum 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 -> fixnum 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 -> fixnum or nil + * + * Returns the least significant eight bits of the return code of + * _stat_. Only available if <code>exited?</code> 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 <code>exited?</code> 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 +} + +#if !defined(HAVE_WAITPID) && !defined(HAVE_WAIT4) +#define NO_WAITPID +static st_table *pid_tbl; + +struct wait_data { + rb_pid_t pid; + int status; +}; + +static int +wait_each(rb_pid_t pid, int status, struct wait_data *data) +{ + if (data->status != -1) return ST_STOP; + + data->pid = pid; + data->status = status; + return ST_DELETE; +} + +static int +waitall_each(rb_pid_t pid, int status, VALUE ary) +{ + rb_last_status_set(status, pid); + rb_ary_push(ary, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get())); + return ST_DELETE; +} +#else +struct waitpid_arg { + rb_pid_t pid; + int flags; + int *st; +}; +#endif + +static void * +rb_waitpid_blocking(void *data) +{ + rb_pid_t result; +#ifndef NO_WAITPID + struct waitpid_arg *arg = data; +#endif + +#if defined NO_WAITPID + result = wait(data); +#elif defined HAVE_WAITPID + result = waitpid(arg->pid, arg->st, arg->flags); +#else /* HAVE_WAIT4 */ + result = wait4(arg->pid, arg->st, arg->flags, NULL); +#endif + + return (void *)(VALUE)result; +} + +rb_pid_t +rb_waitpid(rb_pid_t pid, int *st, int flags) +{ + rb_pid_t result; +#ifndef NO_WAITPID + struct waitpid_arg arg; + + retry: + arg.pid = pid; + arg.st = st; + arg.flags = flags; + result = (rb_pid_t)(VALUE)rb_thread_call_without_gvl(rb_waitpid_blocking, &arg, + RUBY_UBF_PROCESS, 0); + if (result < 0) { + if (errno == EINTR) { + RUBY_VM_CHECK_INTS(GET_THREAD()); + goto retry; + } + return (rb_pid_t)-1; + } +#else /* NO_WAITPID */ + if (pid_tbl) { + st_data_t status, piddata = (st_data_t)pid; + if (pid == (rb_pid_t)-1) { + struct wait_data data; + data.pid = (rb_pid_t)-1; + data.status = -1; + st_foreach(pid_tbl, wait_each, (st_data_t)&data); + if (data.status != -1) { + rb_last_status_set(data.status, data.pid); + return data.pid; + } + } + else if (st_delete(pid_tbl, &piddata, &status)) { + rb_last_status_set(*st = (int)status, pid); + return pid; + } + } + + if (flags) { + rb_raise(rb_eArgError, "can't do waitpid with flags"); + } + + for (;;) { + result = (rb_pid_t)(VALUE)rb_thread_blocking_region(rb_waitpid_blocking, + st, RUBY_UBF_PROCESS, 0); + if (result < 0) { + if (errno == EINTR) { + rb_thread_schedule(); + continue; + } + return (rb_pid_t)-1; + } + if (result == pid || pid == (rb_pid_t)-1) { + break; + } + if (!pid_tbl) + pid_tbl = st_init_numtable(); + st_insert(pid_tbl, pid, (st_data_t)st); + if (!rb_thread_alone()) rb_thread_schedule(); + } +#endif + if (result > 0) { + rb_last_status_set(*st, result); + } + return result; +} + + +/* [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() -> fixnum + * Process.wait(pid=-1, flags=0) -> fixnum + * Process.waitpid(pid=-1, flags=0) -> fixnum + * + * Waits for a child process to exit, returns its process id, and + * sets <code>$?</code> to a <code>Process::Status</code> 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 + * <code>Process::WNOHANG</code> (do not block if no child available) + * or <code>Process::WUNTRACED</code> (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) +{ + VALUE vpid, vflags; + rb_pid_t pid; + int flags, status; + + rb_secure(2); + flags = 0; + if (argc == 0) { + pid = -1; + } + else { + rb_scan_args(argc, argv, "02", &vpid, &vflags); + pid = NUM2PIDT(vpid); + if (argc == 2 && !NIL_P(vflags)) { + 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 <code>Process::Status</code> 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 + * <code>Process::Status</code> 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; + + rb_secure(2); + result = rb_ary_new(); +#ifdef NO_WAITPID + if (pid_tbl) { + st_foreach(pid_tbl, waitall_each, result); + } +#else + rb_last_status_clear(); +#endif + + for (pid = -1;;) { +#ifdef NO_WAITPID + pid = wait(&status); +#else + pid = rb_waitpid(-1, &status, 0); +#endif + if (pid == -1) { + if (errno == ECHILD) + break; +#ifdef NO_WAITPID + if (errno == EINTR) { + rb_thread_schedule(); + continue; + } +#endif + rb_sys_fail(0); + } +#ifdef NO_WAITPID + rb_last_status_set(status, pid); +#endif + 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. + * <code>Process::detach</code> 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 <code>detach</code> + * only when you do not intent 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 <code>Thread#join</code> to + * know the result. If specified _pid_ is not a valid child process + * ID, the thread returns +nil+ immediately. + * + * The waiting thread has <code>pid</code> 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, <code>Process::detach</code> 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) +{ + rb_secure(2); + return rb_detach_process(NUM2PIDT(pid)); +} + +#ifdef SIGPIPE +static RETSIGTYPE (*saved_sigpipe_handler)(int) = 0; +#endif + +#ifdef SIGPIPE +static RETSIGTYPE +sig_do_nothing(int sig) +{ +} +#endif + +/* This function should be async-signal-safe. Actually it is. */ +static void +before_exec_async_signal_safe(void) +{ +#ifdef SIGPIPE + /* + * Some OS commands don't initialize signal handler properly. Thus we have + * to reset signal handler before exec(). Otherwise, system() and similar + * child process interaction might fail. (e.g. ruby -e "system 'yes | ls'") + * [ruby-dev:12261] + */ + saved_sigpipe_handler = signal(SIGPIPE, sig_do_nothing); /* async-signal-safe */ +#endif +} + +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. + */ + rb_thread_stop_timer_thread(0); +} + +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) +{ +#ifdef SIGPIPE + signal(SIGPIPE, saved_sigpipe_handler); /* async-signal-safe */ +#endif +} + +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(); +} + +#define before_fork_ruby() before_exec() +#define after_fork_ruby() (rb_threadptr_pending_interrupt_clear(GET_THREAD()), after_exec()) + +#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) && !defined(__native_client__) + +/* try_with_sh and exec_with_sh should be async-signal-safe. Actually it is.*/ +#define try_with_sh(prog, argv, envp) ((saved_errno == 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 */ +} + +#else +#define try_with_sh(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) +{ +#ifdef __native_client__ + rb_notimplement(); + UNREACHABLE; +#else + char **argv; + char **envp; +# if defined(__EMX__) || defined(OS2) + char **new_argv = NULL; +# endif + + argv = ARGVSTR2ARGV(argv_str); + + if (!prog) { + errno = ENOENT; + return -1; + } + +# if defined(__EMX__) || defined(OS2) + { +# define COMMAND "cmd.exe" + char *extension; + + if ((extension = strrchr(prog, '.')) != NULL && STRCASECMP(extension, ".bat") == 0) { + char *p; + int n; + + for (n = 0; argv[n]; n++) + /* no-op */; + new_argv = ALLOC_N(char*, n + 2); + for (; n > 0; n--) + new_argv[n + 1] = argv[n]; + new_argv[1] = strcpy(ALLOC_N(char, strlen(argv[0]) + 1), argv[0]); + for (p = new_argv[1]; *p != '\0'; p++) + if (*p == '/') + *p = '\\'; + new_argv[0] = COMMAND; + argv = new_argv; + prog = dln_find_exe_r(argv[0], 0, fbuf, sizeof(fbuf)); + if (!prog) { + errno = ENOENT; + return -1; + } + } + } +# endif /* __EMX__ */ + envp = envp_str ? (char **)RSTRING_PTR(envp_str) : NULL; + if (envp_str) + execve(prog, argv, envp); /* async-signal-safe */ + else + execv(prog, argv); /* async-signal-safe */ + preserving_errno(try_with_sh(prog, argv, envp)); /* try_with_sh() is async-signal-safe. */ +# if defined(__EMX__) || defined(OS2) + if (new_argv) { + xfree(new_argv[0]); + xfree(new_argv); + } +# endif + return -1; +#endif +} + +/* This function should be async-signal-safe. Actually it is. */ +static int +proc_exec_sh(const char *str, VALUE envp_str) +{ +#ifdef __native_client__ + rb_notimplement(); + UNREACHABLE; +#else + const char *s; + + s = str; + while (*s == ' ' || *s == '\t' || *s == '\n') + s++; + + if (!*s) { + errno = ENOENT; + return -1; + } + +#ifdef _WIN32 + rb_w32_uspawn(P_OVERLAY, (char *)str, 0); + return -1; +#else +#if defined(__CYGWIN32__) || defined(__EMX__) + { + 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, (char **)RSTRING_PTR(envp_str)); /* async-signal-safe */ + else + execl("/bin/sh", "sh", "-c", str, (char *)NULL); /* async-signal-safe */ +#endif + return -1; +#endif /* _WIN32 */ +#endif +} + +int +rb_proc_exec(const char *str) +{ + int ret; + before_exec(); + ret = proc_exec_sh(str, Qfalse); + preserving_errno(after_exec()); + return ret; +} + +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->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(v, T_FILE, "IO", "to_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(3, hide_obj(EXPORT_DUP(path)), + flags, perm)); + 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_PTR(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(3, hide_obj(EXPORT_DUP(path)), + flags, perm)); + 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_lname(const char *name); +#endif + +int +rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) +{ + struct rb_execarg *eargp = rb_execarg_get(execarg_obj); + + ID id; +#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) + int rtype; +#endif + + rb_secure(2); + + switch (TYPE(key)) { + case T_SYMBOL: + 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 defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) + if (strncmp("rlimit_", rb_id2name(id), 7) == 0 && + (rtype = rlimit_type_by_lname(rb_id2name(id)+7)) != -1) { + 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); + } + 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); + 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_open || 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_open); + 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; + st_foreach(rb_hash_tbl_raw(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; + st_foreach(rb_hash_tbl_raw(opthash), check_exec_options_i_extract, (st_data_t)args); + return args[1]; +} + +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; + 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); + + rb_ary_push(env, hide_obj(rb_assoc_new(key, val))); + + return ST_CONTINUE; +} + +static VALUE +rb_check_exec_env(VALUE hash) +{ + VALUE env; + + env = hide_obj(rb_ary_new()); + st_foreach(rb_hash_tbl_raw(hash), check_exec_env_i, (st_data_t)env); + + return env; +} + +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 +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 = rb_check_hash_type((*argv_p)[*argc_p-1]); + if (!NIL_P(hash)) { + *opthash_ret = hash; + (*argc_p)--; + } + } + + if (0 < *argc_p) { + hash = rb_check_hash_type((*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->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_new_cstr(RSTRING_PTR(argv_buf))); + } + } +#endif + + if (!eargp->use_shell) { + const char *abspath; + abspath = dln_find_exe_r(RSTRING_PTR(eargp->invoke.cmd.command_name), 0, 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 = argv_str; + } + RB_GC_GUARD(execarg_obj); +} + +VALUE +rb_execarg_new(int argc, const VALUE *argv, int accept_shell) +{ + VALUE execarg_obj; + struct rb_execarg *eargp; + execarg_obj = TypedData_Make_Struct(rb_cData, struct rb_execarg, &exec_arg_data_type, eargp); + hide_obj(execarg_obj); + rb_execarg_init(argc, argv, accept_shell, execarg_obj); + return 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; +} + +VALUE +rb_execarg_init(int argc, const VALUE *orig_argv, int accept_shell, VALUE execarg_obj) +{ + struct rb_execarg *eargp = rb_execarg_get(execarg_obj); + VALUE prog, ret; + 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); + rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj); + 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; +} + +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) : 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); + +void +rb_execarg_fixup(VALUE execarg_obj) +{ + struct rb_execarg *eargp = rb_execarg_get(execarg_obj); + int unsetenv_others; + VALUE envopts; + VALUE ary; + + eargp->redirect_fds = check_exec_fds(eargp); + + ary = eargp->fd_dup2; + if (ary != Qfalse) { + size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); + VALUE tmpbuf = hide_obj(rb_str_new(0, len)); + rb_str_set_len(tmpbuf, len); + eargp->dup2_tmpbuf = tmpbuf; + } + + unsetenv_others = eargp->unsetenv_others_given && eargp->unsetenv_others_do; + envopts = eargp->env_modification; + if (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_convert_type(envtbl, T_HASH, "Hash", "to_hash"); + } + 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); + st_foreach(RHASH_TBL_RAW(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 = 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); +} + +#if defined(__APPLE__) || defined(__HAIKU__) +static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen); +#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 <code>Errno::ENOENT</code> 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' }; + + execarg_obj = rb_execarg_new(argc, argv, TRUE); + eargp = rb_execarg_get(execarg_obj); + rb_execarg_fixup(execarg_obj); + fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; + +#if defined(__APPLE__) || defined(__HAIKU__) + rb_exec_without_timer_thread(eargp, errmsg, sizeof(errmsg)); +#else + before_exec_async_signal_safe(); /* async-signal-safe */ + rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); + preserving_errno(after_exec_async_signal_safe()); /* async-signal-safe */ +#endif + RB_GC_GUARD(execarg_obj); + if (errmsg[0]) + rb_sys_fail(errmsg); + rb_sys_fail_str(fail_str); + return Qnil; /* dummy */ +} + +#define ERRMSG(str) do { if (errmsg && 0 < errmsg_buflen) strlcpy(errmsg, (str), errmsg_buflen); } while (0) + +/*#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)\n", oldfd, newfd); + return ret; +} + +static int +redirect_close(int fd) +{ + int ret; + ret = close(fd); + ttyprintf("close(%d)\n", fd); + return ret; +} + +static int +redirect_open(const char *pathname, int flags, mode_t perm) +{ + int ret; + ret = open(pathname, flags, perm); + ttyprintf("open(\"%s\", 0x%x, 0%o) => %d\n", pathname, flags, perm, ret); + return ret; +} + +#else +#define redirect_dup(oldfd) dup(oldfd) +#define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd)) +#define redirect_close(fd) close(fd) +#define redirect_open(pathname, flags, perm) open((pathname), (flags), (perm)) +#endif + +static int +save_redirect_fd(int fd, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) +{ + if (sargp) { + VALUE newary; + int save_fd = redirect_dup(fd); + 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; + } + rb_ary_push(newary, + hide_obj(rb_assoc_new(INT2FIX(fd), INT2FIX(save_fd)))); + + 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; +}; + +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 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 run_exec_dup2_fd_pair *pairs = 0; + + n = RARRAY_LEN(ary); + pairs = (struct run_exec_dup2_fd_pair *)RSTRING_PTR(tmpbuf); + + /* 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].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; + } + 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 */ +#ifdef F_GETFD + int fd = pairs[i].oldfd; + ret = fcntl(fd, F_GETFD); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_GETFD)"); + goto fail; + } + if (ret & FD_CLOEXEC) { + ret &= ~FD_CLOEXEC; + ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("fcntl(F_SETFD)"); + goto fail; + } + } +#endif + 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_open(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) +{ + long i; + int ret; + + for (i = 0; i < RARRAY_LEN(ary);) { + VALUE elt = RARRAY_AREF(ary, i); + int fd = FIX2INT(RARRAY_AREF(elt, 0)); + VALUE param = RARRAY_AREF(elt, 1); + const VALUE vpath = RARRAY_AREF(param, 0); + const char *path = RSTRING_PTR(vpath); + int flags = NUM2INT(RARRAY_AREF(param, 1)); + int perm = NUM2INT(RARRAY_AREF(param, 2)); + int need_close = 1; + int fd2 = redirect_open(path, flags, perm); /* async-signal-safe */ + if (fd2 == -1) { + ERRMSG("open"); + return -1; + } + rb_update_max_fd(fd2); + while (i < RARRAY_LEN(ary) && + (elt = RARRAY_AREF(ary, i), RARRAY_AREF(elt, 1) == param)) { + fd = FIX2INT(RARRAY_AREF(elt, 0)); + if (fd == fd2) { + need_close = 0; + } + else { + if (save_redirect_fd(fd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */ + return -1; + ret = redirect_dup2(fd2, fd); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("dup2"); + return -1; + } + rb_update_max_fd(fd); + } + i++; + } + if (need_close) { + ret = redirect_close(fd2); /* 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 + +/* 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_given || eargp->close_others_do) { + rb_close_before_exec(3, eargp->close_others_maxhint, eargp->redirect_fds); /* async-signal-safe */ + } +#endif + + obj = eargp->fd_open; + if (obj != Qfalse) { + if (run_exec_open(obj, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ + return -1; + } + + 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 = my_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) { + size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); + VALUE tmpbuf = hide_obj(rb_str_new(0, len)); + rb_str_set_len(tmpbuf, len); + sargp->dup2_tmpbuf = tmpbuf; + } + } + + 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) +{ +#if !defined(HAVE_WORKING_FORK) + struct rb_execarg sarg, *const sargp = &sarg; +#else + struct rb_execarg *const sargp = NULL; +#endif + + if (rb_execarg_run_options(eargp, sargp, errmsg, errmsg_buflen) < 0) { /* hopefully async-signal-safe */ + goto failure; + } + + if (eargp->use_shell) { + 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); + proc_exec_cmd(abspath, eargp->invoke.cmd.argv_str, eargp->envp_str); /* async-signal-safe */ + } +#if !defined(HAVE_WORKING_FORK) + preserving_errno(rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen)); +#endif + +failure: + return -1; +} + +#if defined(__APPLE__) || defined(__HAIKU__) +static int +rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) +{ + int ret; + before_exec(); + ret = rb_exec_async_signal_safe(eargp, errmsg, errmsg_buflen); /* hopefully async-signal-safe */ + preserving_errno(after_exec()); /* not async-signal-safe because it calls rb_thread_start_timer_thread. */ + return ret; +} +#endif + +#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 int +handle_fork_error(int *status, int *ep, volatile int *try_gc_p) +{ + int state = 0; + + switch (errno) { + 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((VALUE (*)())rb_thread_sleep, 1, &state); + if (status) *status = state; + if (!state) return 0; + } + break; + } + if (ep) { + preserving_errno((close(ep[0]), close(ep[1]))); + } + 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; + + 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; + int cancelstate; +}; + +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) { + errno = ret; + rb_sys_fail("pthread_sigmask"); + } +#else +# pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous" +#endif + +#ifdef PTHREAD_CANCEL_DISABLE + ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old->cancelstate); + if (ret != 0) { + errno = ret; + rb_sys_fail("pthread_setcancelstate"); + } +#endif +} + +static void +disable_child_handler_fork_parent(struct child_handler_disabler_state *old) +{ + int ret; + +#ifdef PTHREAD_CANCEL_DISABLE + ret = pthread_setcancelstate(old->cancelstate, NULL); + if (ret != 0) { + errno = ret; + rb_sys_fail("pthread_setcancelstate"); + } +#endif + +#ifdef HAVE_PTHREAD_SIGMASK + ret = pthread_sigmask(SIG_SETMASK, &old->sigmask, NULL); /* not async-signal-safe */ + if (ret != 0) { + errno = ret; + rb_sys_fail("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; +#ifdef POSIX_SIGNAL + struct sigaction act, oact; + + act.sa_handler = SIG_DFL; + act.sa_flags = 0; + ret = sigemptyset(&act.sa_mask); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("sigemptyset"); + return -1; + } +#else + sig_t handler; +#endif + + for (sig = 1; sig < NSIG; sig++) { + int reset = 0; +#ifdef SIGPIPE + if (sig == SIGPIPE) + reset = 1; +#endif + if (!reset) { +#ifdef POSIX_SIGNAL + ret = sigaction(sig, NULL, &oact); /* async-signal-safe */ + if (ret == -1 && errno == EINVAL) { + continue; /* Ignore invalid signal number. */ + } + if (ret == -1) { + ERRMSG("sigaction to obtain old action"); + return -1; + } + reset = (oact.sa_flags & SA_SIGINFO) || + (oact.sa_handler != SIG_IGN && oact.sa_handler != SIG_DFL); +#else + 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; + } + reset = (handler != SIG_IGN && handler != SIG_DFL); +#endif + } + if (reset) { +#ifdef POSIX_SIGNAL + ret = sigaction(sig, &act, NULL); /* async-signal-safe */ + if (ret == -1) { + ERRMSG("sigaction to set default action"); + return -1; + } +#else + handler = signal(sig, handler); + if (handler == SIG_ERR) { + ERRMSG("signal to set default action"); + return -1; + } +#endif + } + } + + ret = sigprocmask(SIG_SETMASK, &old->sigmask, NULL); /* async-signal-safe */ + if (ret != 0) { + ERRMSG("sigprocmask"); + return -1; + } + return 0; +} + +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) +{ + rb_pid_t pid; + volatile int try_gc = 1; + struct child_handler_disabler_state old; + + while (1) { + prefork(); + disable_child_handler_before_fork(&old); +#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 + } + preserving_errno(disable_child_handler_fork_parent(&old)); + if (0 < pid) /* fork succeed, parent process */ + return pid; + /* fork failed */ + if (handle_fork_error(status, ep, &try_gc)) + return -1; + } +} + +rb_pid_t +rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, + char *errmsg, size_t errmsg_buflen) +{ + rb_pid_t pid; + int err; + int ep[2]; + int error_occurred; + + if (status) *status = 0; + + if (pipe_nocrash(ep, fds)) return -1; + pid = retry_fork_async_signal_safe(status, ep, chfunc, charg, errmsg, errmsg_buflen); + if (pid < 0) + return pid; + close(ep[1]); + error_occurred = recv_child_error(ep[0], &err, errmsg, errmsg_buflen); + if (error_occurred) { + if (status) { + rb_protect(proc_syswait, (VALUE)pid, status); + } + else { + rb_syswait(pid); + } + errno = err; + return -1; + } + return pid; +} + +static rb_pid_t +retry_fork_ruby(int *status) +{ + rb_pid_t pid; + int try_gc = 1; + + while (1) { + prefork(); + before_fork_ruby(); + pid = fork(); + if (pid == 0) /* fork succeed, child process */ + return pid; + preserving_errno(after_fork_ruby()); + if (0 < pid) /* fork succeed, parent process */ + return pid; + /* fork failed */ + if (handle_fork_error(status, NULL, &try_gc)) + return -1; + } +} + +rb_pid_t +rb_fork_ruby(int *status) +{ + rb_pid_t pid; + + if (status) *status = 0; + + pid = retry_fork_ruby(status); + if (pid < 0) + return pid; + if (!pid) { + after_fork_ruby(); + } + return pid; +} + +#endif + +#if defined(HAVE_WORKING_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD) +/* + * call-seq: + * Kernel.fork [{ block }] -> fixnum or nil + * Process.fork [{ block }] -> fixnum or nil + * + * Creates a subprocess. If a block is specified, that block is run + * in the subprocess, and the subprocess terminates with a status of + * zero. Otherwise, the +fork+ call returns twice, once in + * the parent, returning the process ID of the child, and once in + * the child, returning _nil_. The child process can exit using + * <code>Kernel.exit!</code> to avoid running any + * <code>at_exit</code> functions. The parent process should + * use <code>Process.wait</code> to collect the termination statuses + * of its children or use <code>Process.detach</code> to register + * disinterest in their status; otherwise, the operating system + * may accumulate zombie processes. + * + * The thread calling fork is the only thread in the created child process. + * fork doesn't copy other threads. + * + * If fork is not usable, Process.respond_to?(:fork) returns false. + * + * Note that fork(2) is not available on some platforms like Windows and NetBSD 4. + * Therefore you should use spawn() instead of fork(). + */ + +static VALUE +rb_f_fork(VALUE obj) +{ + rb_pid_t pid; + + rb_secure(2); + + switch (pid = rb_fork_ruby(NULL)) { + case 0: + rb_thread_atfork(); + if (rb_block_given_p()) { + int status; + + rb_protect(rb_yield, Qundef, &status); + ruby_stop(status); + } + return Qnil; + + case -1: + rb_sys_fail("fork(2)"); + return Qnil; + + default: + return PIDT2NUM(pid); + } +} +#else +#define rb_f_fork rb_f_notimplement +#endif + +static int +exit_status_code(VALUE status) +{ + int istatus; + + switch (status) { + case Qtrue: + istatus = EXIT_SUCCESS; + break; + case Qfalse: + istatus = EXIT_FAILURE; + break; + default: + istatus = NUM2INT(status); +#if EXIT_SUCCESS != 0 + if (istatus == 0) + istatus = EXIT_SUCCESS; +#endif + break; + } + return istatus; +} + +/* + * call-seq: + * Process.exit!(status=false) + * + * Exits the process immediately. No exit handlers are + * run. <em>status</em> is returned to the underlying system as the + * exit status. + * + * Process.exit!(true) + */ + +static VALUE +rb_f_exit_bang(int argc, VALUE *argv, VALUE obj) +{ + VALUE status; + int istatus; + + if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { + istatus = exit_status_code(status); + } + else { + istatus = EXIT_FAILURE; + } + _exit(istatus); + + UNREACHABLE; +} + +void +rb_exit(int status) +{ + if (GET_THREAD()->tag) { + VALUE args[2]; + + args[0] = INT2NUM(status); + args[1] = rb_str_new2("exit"); + rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)); + } + ruby_stop(status); +} + + +/* + * call-seq: + * exit(status=true) + * Kernel::exit(status=true) + * Process::exit(status=true) + * + * Initiates the termination of the Ruby script by raising the + * <code>SystemExit</code> exception. This exception may be caught. The + * optional parameter is used to return a status code to the invoking + * environment. + * +true+ and +FALSE+ of _status_ means success and failure + * respectively. The interpretation of other integer values are + * system dependent. + * + * begin + * exit + * puts "never get here" + * rescue SystemExit + * puts "rescued a SystemExit exception" + * end + * puts "after begin block" + * + * <em>produces:</em> + * + * rescued a SystemExit exception + * after begin block + * + * Just prior to termination, Ruby executes any <code>at_exit</code> functions + * (see Kernel::at_exit) and runs any object finalizers (see + * ObjectSpace::define_finalizer). + * + * at_exit { puts "at_exit function" } + * ObjectSpace.define_finalizer("string", proc { puts "in finalizer" }) + * exit + * + * <em>produces:</em> + * + * at_exit function + * in finalizer + */ + +VALUE +rb_f_exit(int argc, const VALUE *argv) +{ + VALUE status; + int istatus; + + if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { + istatus = exit_status_code(status); + } + else { + istatus = EXIT_SUCCESS; + } + rb_exit(istatus); + + UNREACHABLE; +} + + +/* + * call-seq: + * abort + * Kernel::abort([msg]) + * Process::abort([msg]) + * + * Terminate execution immediately, effectively by calling + * <code>Kernel.exit(false)</code>. If _msg_ is given, it is written + * to STDERR prior to terminating. + */ + +VALUE +rb_f_abort(int argc, const VALUE *argv) +{ + rb_check_arity(argc, 0, 1); + if (argc == 0) { + if (!NIL_P(GET_THREAD()->errinfo)) { + ruby_error_print(); + } + rb_exit(EXIT_FAILURE); + } + else { + VALUE args[2]; + + args[1] = args[0] = argv[0]; + StringValue(args[0]); + rb_io_puts(1, args, rb_stderr); + args[0] = INT2NUM(EXIT_FAILURE); + rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)); + } + + UNREACHABLE; +} + +void +rb_syswait(rb_pid_t pid) +{ + int status; + + rb_waitpid(pid, &status, 0); +} + +static rb_pid_t +rb_spawn_process(struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) +{ + rb_pid_t pid; +#if !USE_SPAWNV + int status; +#endif +#if !defined HAVE_WORKING_FORK || USE_SPAWNV + VALUE prog; + struct rb_execarg sarg; +#endif + +#if defined HAVE_WORKING_FORK && !USE_SPAWNV + pid = rb_fork_async_signal_safe(&status, rb_exec_atfork, eargp, eargp->redirect_fds, errmsg, errmsg_buflen); +#else + prog = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; + + if (rb_execarg_run_options(eargp, &sarg, errmsg, errmsg_buflen) < 0) { + return -1; + } + + if (prog && !eargp->use_shell) { + char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); + argv[0] = RSTRING_PTR(prog); + } +# if defined HAVE_SPAWNV + if (eargp->use_shell) { + pid = proc_spawn_sh(RSTRING_PTR(prog)); + } + else { + char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); + pid = proc_spawn_cmd(argv, prog, eargp); + } + if (pid == -1) + rb_last_status_set(0x7f << 8, 0); +# else + if (!eargp->use_shell) { + char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); + int argc = ARGVSTR2ARGC(eargp->invoke.cmd.argv_str); + prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); + } + status = system(StringValuePtr(prog)); + rb_last_status_set((status & 0xff) << 8, 0); +# endif + + rb_execarg_run_options(&sarg, NULL, errmsg, errmsg_buflen); +#endif + return pid; +} + +static rb_pid_t +rb_spawn_internal(int argc, const VALUE *argv, char *errmsg, size_t errmsg_buflen) +{ + VALUE execarg_obj; + struct rb_execarg *eargp; + rb_pid_t ret; + + execarg_obj = rb_execarg_new(argc, argv, TRUE); + eargp = rb_execarg_get(execarg_obj); + rb_execarg_fixup(execarg_obj); + ret = rb_spawn_process(eargp, errmsg, errmsg_buflen); + RB_GC_GUARD(execarg_obj); + return ret; +} + +rb_pid_t +rb_spawn_err(int argc, const VALUE *argv, char *errmsg, size_t errmsg_buflen) +{ + return rb_spawn_internal(argc, argv, errmsg, errmsg_buflen); +} + +rb_pid_t +rb_spawn(int argc, const VALUE *argv) +{ + return rb_spawn_internal(argc, argv, NULL, 0); +} + +/* + * call-seq: + * system([env,] command... [,options]) -> true, false or nil + * + * Executes _command..._ in a subshell. + * _command..._ is one of following forms. + * + * commandline : command line string which is passed to the standard shell + * cmdname, arg1, ... : command name and one or more arguments (no shell) + * [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell) + * + * system returns +true+ if the command gives zero exit status, + * +false+ for non zero exit status. + * Returns +nil+ if command execution fails. + * An error status is available in <code>$?</code>. + * The arguments are processed in the same way as + * for <code>Kernel.spawn</code>. + * + * The hash arguments, env and options, are same as + * <code>exec</code> and <code>spawn</code>. + * See <code>Kernel.spawn</code> for details. + * + * system("echo *") + * system("echo", "*") + * + * <em>produces:</em> + * + * config.h main.rb + * * + * + * See <code>Kernel.exec</code> for the standard shell. + */ + +static VALUE +rb_f_system(int argc, VALUE *argv) +{ + rb_pid_t pid; + int status; + +#if defined(SIGCLD) && !defined(SIGCHLD) +# define SIGCHLD SIGCLD +#endif + +#ifdef SIGCHLD + RETSIGTYPE (*chfunc)(int); + + rb_last_status_clear(); + chfunc = signal(SIGCHLD, SIG_DFL); +#endif + pid = rb_spawn_internal(argc, argv, NULL, 0); +#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) + if (pid > 0) { + int ret, status; + ret = rb_waitpid(pid, &status, 0); + if (ret == (rb_pid_t)-1) + rb_sys_fail("Another thread waited the process started by system()."); + } +#endif +#ifdef SIGCHLD + signal(SIGCHLD, chfunc); +#endif + if (pid < 0) { + return Qnil; + } + status = PST2INT(rb_last_status_get()); + if (status == EXIT_SUCCESS) return Qtrue; + return Qfalse; +} + +/* + * call-seq: + * spawn([env,] command... [,options]) -> pid + * Process.spawn([env,] command... [,options]) -> pid + * + * spawn executes specified command and return its pid. + * + * pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2") + * Process.wait pid + * + * pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'") + * Process.wait pid + * + * This method is similar to Kernel#system but it doesn't wait for the command + * to finish. + * + * The parent process should + * use <code>Process.wait</code> to collect + * the termination status of its child or + * use <code>Process.detach</code> to register + * disinterest in their status; + * otherwise, the operating system may accumulate zombie processes. + * + * spawn has bunch of options to specify process attributes: + * + * env: hash + * name => val : set the environment variable + * name => nil : unset the environment variable + * command...: + * commandline : command line string which is passed to the standard shell + * cmdname, arg1, ... : command name and one or more arguments (This form does not use the shell. See below for caveats.) + * [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell) + * options: hash + * clearing environment variables: + * :unsetenv_others => true : clear environment variables except specified by env + * :unsetenv_others => false : don't clear (default) + * process group: + * :pgroup => true or 0 : make a new process group + * :pgroup => pgid : join to specified process group + * :pgroup => nil : don't change the process group (default) + * create new process group: Windows only + * :new_pgroup => true : the new process is the root process of a new process group + * :new_pgroup => false : don't create a new process group (default) + * resource limit: resourcename is core, cpu, data, etc. See Process.setrlimit. + * :rlimit_resourcename => limit + * :rlimit_resourcename => [cur_limit, max_limit] + * umask: + * :umask => int + * redirection: + * key: + * FD : single file descriptor in child process + * [FD, FD, ...] : multiple file descriptor in child process + * value: + * FD : redirect to the file descriptor in parent process + * string : redirect to file with open(string, "r" or "w") + * [string] : redirect to file with open(string, File::RDONLY) + * [string, open_mode] : redirect to file with open(string, open_mode, 0644) + * [string, open_mode, perm] : redirect to file with open(string, open_mode, perm) + * [:child, FD] : redirect to the redirected file descriptor + * :close : close the file descriptor in child process + * FD is one of follows + * :in : the file descriptor 0 which is the standard input + * :out : the file descriptor 1 which is the standard output + * :err : the file descriptor 2 which is the standard error + * integer : the file descriptor of specified the integer + * io : the file descriptor specified as io.fileno + * file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not + * :close_others => true : don't inherit + * current directory: + * :chdir => str + * + * The 'cmdname, arg1, ...' form does not use the shell. However, + * on different OSes, different things are provided as built-in + * commands. An example of this is 'echo', which is a built-in + * on Windows, but is a normal program on Linux and Mac OS X. + * This means that `Process.spawn 'echo', '%Path%'` will display + * the contents of the `%Path%` environment variable on Windows, + * but `Process.spawn 'echo', '$PATH'` prints the literal '$PATH'. + * + * If a hash is given as +env+, the environment is + * updated by +env+ before <code>exec(2)</code> in the child process. + * If a pair in +env+ has nil as the value, the variable is deleted. + * + * # set FOO as BAR and unset BAZ. + * pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command) + * + * If a hash is given as +options+, + * it specifies + * process group, + * create new process group, + * resource limit, + * current directory, + * umask and + * redirects for the child process. + * Also, it can be specified to clear environment variables. + * + * The <code>:unsetenv_others</code> key in +options+ specifies + * to clear environment variables, other than specified by +env+. + * + * pid = spawn(command, :unsetenv_others=>true) # no environment variable + * pid = spawn({"FOO"=>"BAR"}, command, :unsetenv_others=>true) # FOO only + * + * The <code>:pgroup</code> key in +options+ specifies a process group. + * The corresponding value should be true, zero or positive integer. + * true and zero means the process should be a process leader of a new + * process group. + * Other values specifies a process group to be belongs. + * + * pid = spawn(command, :pgroup=>true) # process leader + * pid = spawn(command, :pgroup=>10) # belongs to the process group 10 + * + * The <code>:new_pgroup</code> key in +options+ specifies to pass + * +CREATE_NEW_PROCESS_GROUP+ flag to <code>CreateProcessW()</code> that is + * Windows API. This option is only for Windows. + * true means the new process is the root process of the new process group. + * The new process has CTRL+C disabled. This flag is necessary for + * <code>Process.kill(:SIGINT, pid)</code> on the subprocess. + * :new_pgroup is false by default. + * + * pid = spawn(command, :new_pgroup=>true) # new process group + * pid = spawn(command, :new_pgroup=>false) # same process group + * + * The <code>:rlimit_</code><em>foo</em> key specifies a resource limit. + * <em>foo</em> should be one of resource types such as <code>core</code>. + * The corresponding value should be an integer or an array which have one or + * two integers: same as cur_limit and max_limit arguments for + * Process.setrlimit. + * + * cur, max = Process.getrlimit(:CORE) + * pid = spawn(command, :rlimit_core=>[0,max]) # disable core temporary. + * pid = spawn(command, :rlimit_core=>max) # enable core dump + * pid = spawn(command, :rlimit_core=>0) # never dump core. + * + * The <code>:umask</code> key in +options+ specifies the umask. + * + * pid = spawn(command, :umask=>077) + * + * The :in, :out, :err, a fixnum, an IO and an array key specifies a redirection. + * The redirection maps a file descriptor in the child process. + * + * For example, stderr can be merged into stdout as follows: + * + * pid = spawn(command, :err=>:out) + * pid = spawn(command, 2=>1) + * pid = spawn(command, STDERR=>:out) + * pid = spawn(command, STDERR=>STDOUT) + * + * The hash keys specifies a file descriptor + * in the child process started by <code>spawn</code>. + * :err, 2 and STDERR specifies the standard error stream (stderr). + * + * The hash values specifies a file descriptor + * in the parent process which invokes <code>spawn</code>. + * :out, 1 and STDOUT specifies the standard output stream (stdout). + * + * In the above example, + * the standard output in the child process is not specified. + * So it is inherited from the parent process. + * + * The standard input stream (stdin) can be specified by :in, 0 and STDIN. + * + * A filename can be specified as a hash value. + * + * pid = spawn(command, :in=>"/dev/null") # read mode + * pid = spawn(command, :out=>"/dev/null") # write mode + * pid = spawn(command, :err=>"log") # write mode + * pid = spawn(command, [:out, :err]=>"/dev/null") # write mode + * pid = spawn(command, 3=>"/dev/null") # read mode + * + * For stdout and stderr (and combination of them), + * it is opened in write mode. + * Otherwise read mode is used. + * + * For specifying flags and permission of file creation explicitly, + * an array is used instead. + * + * pid = spawn(command, :in=>["file"]) # read mode is assumed + * pid = spawn(command, :in=>["file", "r"]) + * pid = spawn(command, :out=>["log", "w"]) # 0644 assumed + * pid = spawn(command, :out=>["log", "w", 0600]) + * pid = spawn(command, :out=>["log", File::WRONLY|File::EXCL|File::CREAT, 0600]) + * + * The array specifies a filename, flags and permission. + * The flags can be a string or an integer. + * If the flags is omitted or nil, File::RDONLY is assumed. + * The permission should be an integer. + * If the permission is omitted or nil, 0644 is assumed. + * + * If an array of IOs and integers are specified as a hash key, + * all the elements are redirected. + * + * # stdout and stderr is redirected to log file. + * # The file "log" is opened just once. + * pid = spawn(command, [:out, :err]=>["log", "w"]) + * + * Another way to merge multiple file descriptors is [:child, fd]. + * \[:child, fd] means the file descriptor in the child process. + * This is different from fd. + * For example, :err=>:out means redirecting child stderr to parent stdout. + * But :err=>[:child, :out] means redirecting child stderr to child stdout. + * They differ if stdout is redirected in the child process as follows. + * + * # stdout and stderr is redirected to log file. + * # The file "log" is opened just once. + * pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out]) + * + * \[:child, :out] can be used to merge stderr into stdout in IO.popen. + * In this case, IO.popen redirects stdout to a pipe in the child process + * and [:child, :out] refers the redirected stdout. + * + * io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]]) + * p io.read #=> "out\nerr\n" + * + * The <code>:chdir</code> key in +options+ specifies the current directory. + * + * pid = spawn(command, :chdir=>"/var/tmp") + * + * spawn closes all non-standard unspecified descriptors by default. + * The "standard" descriptors are 0, 1 and 2. + * This behavior is specified by :close_others option. + * :close_others doesn't affect the standard descriptors which are + * closed only if :close is specified explicitly. + * + * pid = spawn(command, :close_others=>true) # close 3,4,5,... (default) + * pid = spawn(command, :close_others=>false) # don't close 3,4,5,... + * + * :close_others is true by default for spawn and IO.popen. + * + * Note that fds which close-on-exec flag is already set are closed + * regardless of :close_others option. + * + * So IO.pipe and spawn can be used as IO.popen. + * + * # similar to r = IO.popen(command) + * r, w = IO.pipe + * pid = spawn(command, :out=>w) # r, w is closed in the child process. + * w.close + * + * :close is specified as a hash value to close a fd individually. + * + * f = open(foo) + * system(command, f=>:close) # don't inherit f. + * + * If a file descriptor need to be inherited, + * io=>io can be used. + * + * # valgrind has --log-fd option for log destination. + * # log_w=>log_w indicates log_w.fileno inherits to child process. + * log_r, log_w = IO.pipe + * pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w) + * log_w.close + * p log_r.read + * + * It is also possible to exchange file descriptors. + * + * pid = spawn(command, :out=>:err, :err=>:out) + * + * The hash keys specify file descriptors in the child process. + * The hash values specifies file descriptors in the parent process. + * So the above specifies exchanging stdout and stderr. + * Internally, +spawn+ uses an extra file descriptor to resolve such cyclic + * file descriptor mapping. + * + * See <code>Kernel.exec</code> for the standard shell. + */ + +static VALUE +rb_f_spawn(int argc, VALUE *argv) +{ + rb_pid_t pid; + char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; + VALUE execarg_obj, fail_str; + struct rb_execarg *eargp; + + execarg_obj = rb_execarg_new(argc, argv, TRUE); + eargp = rb_execarg_get(execarg_obj); + rb_execarg_fixup(execarg_obj); + fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; + + pid = rb_spawn_process(eargp, errmsg, sizeof(errmsg)); + RB_GC_GUARD(execarg_obj); + + if (pid == -1) { + const char *prog = errmsg; + if (!prog[0]) { + rb_sys_fail_str(fail_str); + } + rb_sys_fail(prog); + } +#if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) + return PIDT2NUM(pid); +#else + return Qnil; +#endif +} + +/* + * call-seq: + * sleep([duration]) -> fixnum + * + * Suspends the current thread for _duration_ seconds (which may be any number, + * including a +Float+ with fractional seconds). Returns the actual number of + * seconds slept (rounded), which may be less than that asked for if another + * thread calls <code>Thread#run</code>. Called without an argument, sleep() + * will sleep forever. + * + * Time.new #=> 2008-03-08 19:56:19 +0900 + * sleep 1.2 #=> 1 + * Time.new #=> 2008-03-08 19:56:20 +0900 + * sleep 1.9 #=> 2 + * Time.new #=> 2008-03-08 19:56:22 +0900 + */ + +static VALUE +rb_f_sleep(int argc, VALUE *argv) +{ + time_t beg, end; + + beg = time(0); + if (argc == 0) { + rb_thread_sleep_forever(); + } + else { + rb_check_arity(argc, 0, 1); + rb_thread_wait_for(rb_time_interval(argv[0])); + } + + end = time(0) - beg; + + return INT2FIX(end); +} + + +#if (defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)) || defined(HAVE_GETPGID) +/* + * call-seq: + * Process.getpgrp -> integer + * + * Returns the process group ID for this process. Not available on + * all platforms. + * + * Process.getpgid(0) #=> 25527 + * Process.getpgrp #=> 25527 + */ + +static VALUE +proc_getpgrp(void) +{ + rb_pid_t pgrp; + + rb_secure(2); +#if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) + pgrp = getpgrp(); + if (pgrp < 0) rb_sys_fail(0); + return PIDT2NUM(pgrp); +#else /* defined(HAVE_GETPGID) */ + pgrp = getpgid(0); + if (pgrp < 0) rb_sys_fail(0); + return PIDT2NUM(pgrp); +#endif +} +#else +#define proc_getpgrp rb_f_notimplement +#endif + + +#if defined(HAVE_SETPGID) || (defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)) +/* + * call-seq: + * Process.setpgrp -> 0 + * + * Equivalent to <code>setpgid(0,0)</code>. Not available on all + * platforms. + */ + +static VALUE +proc_setpgrp(void) +{ + rb_secure(2); + /* check for posix setpgid() first; this matches the posix */ + /* getpgrp() above. It appears that configure will set SETPGRP_VOID */ + /* even though setpgrp(0,0) would be preferred. The posix call avoids */ + /* this confusion. */ +#ifdef HAVE_SETPGID + if (setpgid(0,0) < 0) rb_sys_fail(0); +#elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID) + if (setpgrp() < 0) rb_sys_fail(0); +#endif + return INT2FIX(0); +} +#else +#define proc_setpgrp rb_f_notimplement +#endif + + +#if defined(HAVE_GETPGID) +/* + * call-seq: + * Process.getpgid(pid) -> integer + * + * Returns the process group ID for the given process id. Not + * available on all platforms. + * + * Process.getpgid(Process.ppid()) #=> 25527 + */ + +static VALUE +proc_getpgid(VALUE obj, VALUE pid) +{ + rb_pid_t i; + + rb_secure(2); + i = getpgid(NUM2PIDT(pid)); + if (i < 0) rb_sys_fail(0); + return PIDT2NUM(i); +} +#else +#define proc_getpgid rb_f_notimplement +#endif + + +#ifdef HAVE_SETPGID +/* + * call-seq: + * Process.setpgid(pid, integer) -> 0 + * + * Sets the process group ID of _pid_ (0 indicates this + * process) to <em>integer</em>. Not available on all platforms. + */ + +static VALUE +proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp) +{ + rb_pid_t ipid, ipgrp; + + rb_secure(2); + ipid = NUM2PIDT(pid); + ipgrp = NUM2PIDT(pgrp); + + if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0); + return INT2FIX(0); +} +#else +#define proc_setpgid rb_f_notimplement +#endif + + +#ifdef HAVE_GETSID +/* + * call-seq: + * Process.getsid() -> integer + * Process.getsid(pid) -> integer + * + * Returns the session ID for for the given process id. If not give, + * return current process sid. Not available on all platforms. + * + * Process.getsid() #=> 27422 + * Process.getsid(0) #=> 27422 + * Process.getsid(Process.pid()) #=> 27422 + */ +static VALUE +proc_getsid(int argc, VALUE *argv) +{ + rb_pid_t sid; + VALUE pid; + + rb_secure(2); + rb_scan_args(argc, argv, "01", &pid); + + if (NIL_P(pid)) + pid = INT2FIX(0); + + sid = getsid(NUM2PIDT(pid)); + if (sid < 0) rb_sys_fail(0); + return PIDT2NUM(sid); +} +#else +#define proc_getsid rb_f_notimplement +#endif + + +#if defined(HAVE_SETSID) || (defined(HAVE_SETPGRP) && defined(TIOCNOTTY)) +#if !defined(HAVE_SETSID) +static rb_pid_t ruby_setsid(void); +#define setsid() ruby_setsid() +#endif +/* + * call-seq: + * Process.setsid -> fixnum + * + * Establishes this process as a new session and process group + * leader, with no controlling tty. Returns the session id. Not + * available on all platforms. + * + * Process.setsid #=> 27422 + */ + +static VALUE +proc_setsid(void) +{ + rb_pid_t pid; + + rb_secure(2); + pid = setsid(); + if (pid < 0) rb_sys_fail(0); + return PIDT2NUM(pid); +} + +#if !defined(HAVE_SETSID) +#define HAVE_SETSID 1 +static rb_pid_t +ruby_setsid(void) +{ + rb_pid_t pid; + int ret; + + pid = getpid(); +#if defined(SETPGRP_VOID) + ret = setpgrp(); + /* If `pid_t setpgrp(void)' is equivalent to setsid(), + `ret' will be the same value as `pid', and following open() will fail. + In Linux, `int setpgrp(void)' is equivalent to setpgid(0, 0). */ +#else + ret = setpgrp(0, pid); +#endif + if (ret == -1) return -1; + + if ((fd = rb_cloexec_open("/dev/tty", O_RDWR, 0)) >= 0) { + rb_update_max_fd(fd); + ioctl(fd, TIOCNOTTY, NULL); + close(fd); + } + return pid; +} +#endif +#else +#define proc_setsid rb_f_notimplement +#endif + + +#ifdef HAVE_GETPRIORITY +/* + * call-seq: + * Process.getpriority(kind, integer) -> fixnum + * + * Gets the scheduling priority for specified process, process group, + * or user. <em>kind</em> indicates the kind of entity to find: one + * of <code>Process::PRIO_PGRP</code>, + * <code>Process::PRIO_USER</code>, or + * <code>Process::PRIO_PROCESS</code>. _integer_ is an id + * indicating the particular process, process group, or user (an id + * of 0 means _current_). Lower priorities are more favorable + * for scheduling. Not available on all platforms. + * + * Process.getpriority(Process::PRIO_USER, 0) #=> 19 + * Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19 + */ + +static VALUE +proc_getpriority(VALUE obj, VALUE which, VALUE who) +{ + int prio, iwhich, iwho; + + rb_secure(2); + iwhich = NUM2INT(which); + iwho = NUM2INT(who); + + errno = 0; + prio = getpriority(iwhich, iwho); + if (errno) rb_sys_fail(0); + return INT2FIX(prio); +} +#else +#define proc_getpriority rb_f_notimplement +#endif + + +#ifdef HAVE_GETPRIORITY +/* + * call-seq: + * Process.setpriority(kind, integer, priority) -> 0 + * + * See <code>Process#getpriority</code>. + * + * Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0 + * Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0 + * Process.getpriority(Process::PRIO_USER, 0) #=> 19 + * Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19 + */ + +static VALUE +proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio) +{ + int iwhich, iwho, iprio; + + rb_secure(2); + iwhich = NUM2INT(which); + iwho = NUM2INT(who); + iprio = NUM2INT(prio); + + if (setpriority(iwhich, iwho, iprio) < 0) + rb_sys_fail(0); + return INT2FIX(0); +} +#else +#define proc_setpriority rb_f_notimplement +#endif + +#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) +static int +rlimit_resource_name2int(const char *name, int casetype) +{ + int resource; + const char *p; +#define RESCHECK(r) \ + do { \ + if (STRCASECMP(name, #r) == 0) { \ + resource = RLIMIT_##r; \ + goto found; \ + } \ + } while (0) + + switch (TOUPPER(*name)) { + case 'A': +#ifdef RLIMIT_AS + RESCHECK(AS); +#endif + break; + + case 'C': +#ifdef RLIMIT_CORE + RESCHECK(CORE); +#endif +#ifdef RLIMIT_CPU + RESCHECK(CPU); +#endif + break; + + case 'D': +#ifdef RLIMIT_DATA + RESCHECK(DATA); +#endif + break; + + case 'F': +#ifdef RLIMIT_FSIZE + RESCHECK(FSIZE); +#endif + break; + + case 'M': +#ifdef RLIMIT_MEMLOCK + RESCHECK(MEMLOCK); +#endif +#ifdef RLIMIT_MSGQUEUE + RESCHECK(MSGQUEUE); +#endif + break; + + case 'N': +#ifdef RLIMIT_NOFILE + RESCHECK(NOFILE); +#endif +#ifdef RLIMIT_NPROC + RESCHECK(NPROC); +#endif +#ifdef RLIMIT_NICE + RESCHECK(NICE); +#endif + break; + + case 'R': +#ifdef RLIMIT_RSS + RESCHECK(RSS); +#endif +#ifdef RLIMIT_RTPRIO + RESCHECK(RTPRIO); +#endif +#ifdef RLIMIT_RTTIME + RESCHECK(RTTIME); +#endif + break; + + case 'S': +#ifdef RLIMIT_STACK + RESCHECK(STACK); +#endif +#ifdef RLIMIT_SBSIZE + RESCHECK(SBSIZE); +#endif +#ifdef RLIMIT_SIGPENDING + RESCHECK(SIGPENDING); +#endif + break; + } + return -1; + + found: + switch (casetype) { + case 0: + for (p = name; *p; p++) + if (!ISUPPER(*p)) + return -1; + break; + + case 1: + for (p = name; *p; p++) + if (!ISLOWER(*p)) + return -1; + break; + + default: + rb_bug("unexpected casetype"); + } + return resource; +#undef RESCHECK +} + +static int +rlimit_type_by_hname(const char *name) +{ + return rlimit_resource_name2int(name, 0); +} + +static int +rlimit_type_by_lname(const char *name) +{ + return rlimit_resource_name2int(name, 1); +} + +static int +rlimit_resource_type(VALUE rtype) +{ + const char *name; + VALUE v; + int r; + + switch (TYPE(rtype)) { + case T_SYMBOL: + v = rb_sym2str(rtype); + name = RSTRING_PTR(v); + break; + + default: + v = rb_check_string_type(rtype); + if (!NIL_P(v)) { + rtype = v; + case T_STRING: + name = StringValueCStr(rtype); + break; + } + /* fall through */ + + case T_FIXNUM: + case T_BIGNUM: + return NUM2INT(rtype); + } + + r = rlimit_type_by_hname(name); + if (r != -1) + return r; + + rb_raise(rb_eArgError, "invalid resource name: %"PRIsVALUE, rtype); + + UNREACHABLE; +} + +static rlim_t +rlimit_resource_value(VALUE rval) +{ + const char *name; + VALUE v; + + switch (TYPE(rval)) { + case T_SYMBOL: + v = rb_sym2str(rval); + name = RSTRING_PTR(v); + break; + + default: + v = rb_check_string_type(rval); + if (!NIL_P(v)) { + rval = v; + case T_STRING: + name = StringValueCStr(rval); + break; + } + /* fall through */ + + case T_FIXNUM: + case T_BIGNUM: + return NUM2RLIM(rval); + } + +#ifdef RLIM_INFINITY + if (strcmp(name, "INFINITY") == 0) return RLIM_INFINITY; +#endif +#ifdef RLIM_SAVED_MAX + if (strcmp(name, "SAVED_MAX") == 0) return RLIM_SAVED_MAX; +#endif +#ifdef RLIM_SAVED_CUR + if (strcmp(name, "SAVED_CUR") == 0) return RLIM_SAVED_CUR; +#endif + rb_raise(rb_eArgError, "invalid resource value: %"PRIsVALUE, rval); + + UNREACHABLE; +} +#endif + +#if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM) +/* + * call-seq: + * Process.getrlimit(resource) -> [cur_limit, max_limit] + * + * Gets the resource limit of the process. + * _cur_limit_ means current (soft) limit and + * _max_limit_ means maximum (hard) limit. + * + * _resource_ indicates the kind of resource to limit. + * It is specified as a symbol such as <code>:CORE</code>, + * a string such as <code>"CORE"</code> or + * a constant such as <code>Process::RLIMIT_CORE</code>. + * See Process.setrlimit for details. + * + * _cur_limit_ and _max_limit_ may be <code>Process::RLIM_INFINITY</code>, + * <code>Process::RLIM_SAVED_MAX</code> or + * <code>Process::RLIM_SAVED_CUR</code>. + * See Process.setrlimit and the system getrlimit(2) manual for details. + */ + +static VALUE +proc_getrlimit(VALUE obj, VALUE resource) +{ + struct rlimit rlim; + + rb_secure(2); + + if (getrlimit(rlimit_resource_type(resource), &rlim) < 0) { + rb_sys_fail("getrlimit"); + } + return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max)); +} +#else +#define proc_getrlimit rb_f_notimplement +#endif + +#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) +/* + * call-seq: + * Process.setrlimit(resource, cur_limit, max_limit) -> nil + * Process.setrlimit(resource, cur_limit) -> nil + * + * Sets the resource limit of the process. + * _cur_limit_ means current (soft) limit and + * _max_limit_ means maximum (hard) limit. + * + * If _max_limit_ is not given, _cur_limit_ is used. + * + * _resource_ indicates the kind of resource to limit. + * It should be a symbol such as <code>:CORE</code>, + * a string such as <code>"CORE"</code> or + * a constant such as <code>Process::RLIMIT_CORE</code>. + * The available resources are OS dependent. + * Ruby may support following resources. + * + * [AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite) + * [CORE] core size (bytes) (SUSv3) + * [CPU] CPU time (seconds) (SUSv3) + * [DATA] data segment (bytes) (SUSv3) + * [FSIZE] file size (bytes) (SUSv3) + * [MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux) + * [MSGQUEUE] allocation for POSIX message queues (bytes) (GNU/Linux) + * [NICE] ceiling on process's nice(2) value (number) (GNU/Linux) + * [NOFILE] file descriptors (number) (SUSv3) + * [NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux) + * [RSS] resident memory size (bytes) (4.2BSD, GNU/Linux) + * [RTPRIO] ceiling on the process's real-time priority (number) (GNU/Linux) + * [RTTIME] CPU time for real-time process (us) (GNU/Linux) + * [SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD) + * [SIGPENDING] number of queued signals allowed (signals) (GNU/Linux) + * [STACK] stack size (bytes) (SUSv3) + * + * _cur_limit_ and _max_limit_ may be + * <code>:INFINITY</code>, <code>"INFINITY"</code> or + * <code>Process::RLIM_INFINITY</code>, + * which means that the resource is not limited. + * They may be <code>Process::RLIM_SAVED_MAX</code>, + * <code>Process::RLIM_SAVED_CUR</code> and + * corresponding symbols and strings too. + * See system setrlimit(2) manual for details. + * + * The following example raises the soft limit of core size to + * the hard limit to try to make core dump possible. + * + * Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1]) + * + */ + +static VALUE +proc_setrlimit(int argc, VALUE *argv, VALUE obj) +{ + VALUE resource, rlim_cur, rlim_max; + struct rlimit rlim; + + rb_secure(2); + + rb_scan_args(argc, argv, "21", &resource, &rlim_cur, &rlim_max); + if (rlim_max == Qnil) + rlim_max = rlim_cur; + + rlim.rlim_cur = rlimit_resource_value(rlim_cur); + rlim.rlim_max = rlimit_resource_value(rlim_max); + + if (setrlimit(rlimit_resource_type(resource), &rlim) < 0) { + rb_sys_fail("setrlimit"); + } + return Qnil; +} +#else +#define proc_setrlimit rb_f_notimplement +#endif + +static int under_uid_switch = 0; +static void +check_uid_switch(void) +{ + rb_secure(2); + if (under_uid_switch) { + rb_raise(rb_eRuntimeError, "can't handle UID while evaluating block given to Process::UID.switch method"); + } +} + +static int under_gid_switch = 0; +static void +check_gid_switch(void) +{ + rb_secure(2); + if (under_gid_switch) { + rb_raise(rb_eRuntimeError, "can't handle GID while evaluating block given to Process::UID.switch method"); + } +} + + +/********************************************************************* + * Document-class: Process::Sys + * + * The <code>Process::Sys</code> module contains UID and GID + * functions which provide direct bindings to the system calls of the + * same names instead of the more-portable versions of the same + * functionality found in the <code>Process</code>, + * <code>Process::UID</code>, and <code>Process::GID</code> modules. + */ + +#if defined(HAVE_PWD_H) +static rb_uid_t +obj2uid(VALUE id +# ifdef USE_GETPWNAM_R + , VALUE *getpw_tmp +# endif + ) +{ + rb_uid_t uid; + VALUE tmp; + + if (FIXNUM_P(id) || NIL_P(tmp = rb_check_string_type(id))) { + uid = NUM2UIDT(id); + } + else { + const char *usrname = StringValueCStr(id); + struct passwd *pwptr; +#ifdef USE_GETPWNAM_R + struct passwd pwbuf; + char *getpw_buf; + long getpw_buf_len; + if (!*getpw_tmp) { + getpw_buf_len = GETPW_R_SIZE_INIT; + if (getpw_buf_len < 0) getpw_buf_len = GETPW_R_SIZE_DEFAULT; + getpw_buf = rb_alloc_tmp_buffer(getpw_tmp, getpw_buf_len); + } + else { + getpw_buf = RSTRING_PTR(*getpw_tmp); + getpw_buf_len = rb_str_capacity(*getpw_tmp); + } + errno = ERANGE; + /* gepwnam_r() on MacOS X doesn't set errno if buffer size is insufficient */ + while (getpwnam_r(usrname, &pwbuf, getpw_buf, getpw_buf_len, &pwptr)) { + if (errno != ERANGE || getpw_buf_len >= GETPW_R_SIZE_LIMIT) { + rb_free_tmp_buffer(getpw_tmp); + rb_sys_fail("getpwnam_r"); + } + rb_str_modify_expand(*getpw_tmp, getpw_buf_len); + getpw_buf = RSTRING_PTR(*getpw_tmp); + getpw_buf_len = rb_str_capacity(*getpw_tmp); + } +#else + pwptr = getpwnam(usrname); +#endif + if (!pwptr) { +#ifndef USE_GETPWNAM_R + endpwent(); +#endif + rb_raise(rb_eArgError, "can't find user for %s", usrname); + } + uid = pwptr->pw_uid; +#ifndef USE_GETPWNAM_R + endpwent(); +#endif + } + return uid; +} + +# ifdef p_uid_from_name +/* + * call-seq: + * Process::UID.from_name(name) -> uid + * + * Get the user ID by the _name_. + * If the user is not found, +ArgumentError+ will be raised. + * + * Process::UID.from_name("root") #=> 0 + * Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError) + */ + +static VALUE +p_uid_from_name(VALUE self, VALUE id) +{ + return UIDT2NUM(OBJ2UID(id)); +} +# endif +#endif + +#if defined(HAVE_GRP_H) +static rb_gid_t +obj2gid(VALUE id +# ifdef USE_GETGRNAM_R + , VALUE *getgr_tmp +# endif + ) +{ + rb_gid_t gid; + VALUE tmp; + + if (FIXNUM_P(id) || NIL_P(tmp = rb_check_string_type(id))) { + gid = NUM2GIDT(id); + } + else { + const char *grpname = StringValueCStr(id); + struct group *grptr; +#ifdef USE_GETGRNAM_R + struct group grbuf; + char *getgr_buf; + long getgr_buf_len; + if (!*getgr_tmp) { + getgr_buf_len = GETGR_R_SIZE_INIT; + if (getgr_buf_len < 0) getgr_buf_len = GETGR_R_SIZE_DEFAULT; + getgr_buf = rb_alloc_tmp_buffer(getgr_tmp, getgr_buf_len); + } + else { + getgr_buf = RSTRING_PTR(*getgr_tmp); + getgr_buf_len = rb_str_capacity(*getgr_tmp); + } + errno = ERANGE; + /* gegrnam_r() on MacOS X doesn't set errno if buffer size is insufficient */ + while (getgrnam_r(grpname, &grbuf, getgr_buf, getgr_buf_len, &grptr)) { + if (errno != ERANGE || getgr_buf_len >= GETGR_R_SIZE_LIMIT) { + rb_free_tmp_buffer(getgr_tmp); + rb_sys_fail("getgrnam_r"); + } + rb_str_modify_expand(*getgr_tmp, getgr_buf_len); + getgr_buf = RSTRING_PTR(*getgr_tmp); + getgr_buf_len = rb_str_capacity(*getgr_tmp); + } +#elif defined(HAVE_GETGRNAM) + grptr = getgrnam(grpname); +#else + grptr = NULL; +#endif + if (!grptr) { +#if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) + endgrent(); +#endif + rb_raise(rb_eArgError, "can't find group for %s", grpname); + } + gid = grptr->gr_gid; +#if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) + endgrent(); +#endif + } + return gid; +} + +# ifdef p_gid_from_name +/* + * call-seq: + * Process::GID.from_name(name) -> gid + * + * Get the group ID by the _name_. + * If the group is not found, +ArgumentError+ will be raised. + * + * Process::GID.from_name("wheel") #=> 0 + * Process::GID.from_name("nosuchgroup") #=> can't find group for nosuchgroup (ArgumentError) + */ + +static VALUE +p_gid_from_name(VALUE self, VALUE id) +{ + return GIDT2NUM(OBJ2GID(id)); +} +# endif +#endif + +#if defined HAVE_SETUID +/* + * call-seq: + * Process::Sys.setuid(user) -> nil + * + * Set the user ID of the current process to _user_. Not + * available on all platforms. + * + */ + +static VALUE +p_sys_setuid(VALUE obj, VALUE id) +{ + check_uid_switch(); + if (setuid(OBJ2UID(id)) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setuid rb_f_notimplement +#endif + + +#if defined HAVE_SETRUID +/* + * call-seq: + * Process::Sys.setruid(user) -> nil + * + * Set the real user ID of the calling process to _user_. + * Not available on all platforms. + * + */ + +static VALUE +p_sys_setruid(VALUE obj, VALUE id) +{ + check_uid_switch(); + if (setruid(OBJ2UID(id)) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setruid rb_f_notimplement +#endif + + +#if defined HAVE_SETEUID +/* + * call-seq: + * Process::Sys.seteuid(user) -> nil + * + * Set the effective user ID of the calling process to + * _user_. Not available on all platforms. + * + */ + +static VALUE +p_sys_seteuid(VALUE obj, VALUE id) +{ + check_uid_switch(); + if (seteuid(OBJ2UID(id)) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_seteuid rb_f_notimplement +#endif + + +#if defined HAVE_SETREUID +/* + * call-seq: + * Process::Sys.setreuid(rid, eid) -> nil + * + * Sets the (user) real and/or effective user IDs of the current + * process to _rid_ and _eid_, respectively. A value of + * <code>-1</code> for either means to leave that ID unchanged. Not + * available on all platforms. + * + */ + +static VALUE +p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid) +{ + rb_uid_t ruid, euid; + PREPARE_GETPWNAM; + check_uid_switch(); + ruid = OBJ2UID1(rid); + euid = OBJ2UID1(eid); + FINISH_GETPWNAM; + if (setreuid(ruid, euid) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setreuid rb_f_notimplement +#endif + + +#if defined HAVE_SETRESUID +/* + * call-seq: + * Process::Sys.setresuid(rid, eid, sid) -> nil + * + * Sets the (user) real, effective, and saved user IDs of the + * current process to _rid_, _eid_, and _sid_ respectively. A + * value of <code>-1</code> for any value means to + * leave that ID unchanged. Not available on all platforms. + * + */ + +static VALUE +p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) +{ + rb_uid_t ruid, euid, suid; + PREPARE_GETPWNAM; + check_uid_switch(); + ruid = OBJ2UID1(rid); + euid = OBJ2UID1(eid); + suid = OBJ2UID1(sid); + FINISH_GETPWNAM; + if (setresuid(ruid, euid, suid) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setresuid rb_f_notimplement +#endif + + +/* + * call-seq: + * Process.uid -> fixnum + * Process::UID.rid -> fixnum + * Process::Sys.getuid -> fixnum + * + * Returns the (real) user ID of this process. + * + * Process.uid #=> 501 + */ + +static VALUE +proc_getuid(VALUE obj) +{ + rb_uid_t uid = getuid(); + return UIDT2NUM(uid); +} + + +#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETRUID) || defined(HAVE_SETUID) +/* + * call-seq: + * Process.uid= user -> numeric + * + * Sets the (user) user ID for this process. Not available on all + * platforms. + */ + +static VALUE +proc_setuid(VALUE obj, VALUE id) +{ + rb_uid_t uid; + + check_uid_switch(); + + uid = OBJ2UID(id); +#if defined(HAVE_SETRESUID) + if (setresuid(uid, -1, -1) < 0) rb_sys_fail(0); +#elif defined HAVE_SETREUID + if (setreuid(uid, -1) < 0) rb_sys_fail(0); +#elif defined HAVE_SETRUID + if (setruid(uid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETUID + { + if (geteuid() == uid) { + if (setuid(uid) < 0) rb_sys_fail(0); + } + else { + rb_notimplement(); + } + } +#endif + return id; +} +#else +#define proc_setuid rb_f_notimplement +#endif + + +/******************************************************************** + * + * Document-class: Process::UID + * + * The <code>Process::UID</code> module contains a collection of + * module functions which can be used to portably get, set, and + * switch the current process's real, effective, and saved user IDs. + * + */ + +static rb_uid_t SAVED_USER_ID = -1; + +#ifdef BROKEN_SETREUID +int +setreuid(rb_uid_t ruid, rb_uid_t euid) +{ + if (ruid != (rb_uid_t)-1 && ruid != getuid()) { + if (euid == (rb_uid_t)-1) euid = geteuid(); + if (setuid(ruid) < 0) return -1; + } + if (euid != (rb_uid_t)-1 && euid != geteuid()) { + if (seteuid(euid) < 0) return -1; + } + return 0; +} +#endif + +/* + * call-seq: + * Process::UID.change_privilege(user) -> fixnum + * + * Change the current process's real and effective user ID to that + * specified by _user_. Returns the new user ID. Not + * available on all platforms. + * + * [Process.uid, Process.euid] #=> [0, 0] + * Process::UID.change_privilege(31) #=> 31 + * [Process.uid, Process.euid] #=> [31, 31] + */ + +static VALUE +p_uid_change_privilege(VALUE obj, VALUE id) +{ + rb_uid_t uid; + + check_uid_switch(); + + uid = OBJ2UID(id); + + if (geteuid() == 0) { /* root-user */ +#if defined(HAVE_SETRESUID) + if (setresuid(uid, uid, uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; +#elif defined(HAVE_SETUID) + if (setuid(uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; +#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) + if (getuid() == uid) { + if (SAVED_USER_ID == uid) { + if (setreuid(-1, uid) < 0) rb_sys_fail(0); + } + else { + if (uid == 0) { /* (r,e,s) == (root, root, x) */ + if (setreuid(-1, SAVED_USER_ID) < 0) rb_sys_fail(0); + if (setreuid(SAVED_USER_ID, 0) < 0) rb_sys_fail(0); + SAVED_USER_ID = 0; /* (r,e,s) == (x, root, root) */ + if (setreuid(uid, uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } + else { + if (setreuid(0, -1) < 0) rb_sys_fail(0); + SAVED_USER_ID = 0; + if (setreuid(uid, uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } + } + } + else { + if (setreuid(uid, uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } +#elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID) + if (getuid() == uid) { + if (SAVED_USER_ID == uid) { + if (seteuid(uid) < 0) rb_sys_fail(0); + } + else { + if (uid == 0) { + if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0); + SAVED_USER_ID = 0; + if (setruid(0) < 0) rb_sys_fail(0); + } + else { + if (setruid(0) < 0) rb_sys_fail(0); + SAVED_USER_ID = 0; + if (seteuid(uid) < 0) rb_sys_fail(0); + if (setruid(uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } + } + } + else { + if (seteuid(uid) < 0) rb_sys_fail(0); + if (setruid(uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } +#else + (void)uid; + rb_notimplement(); +#endif + } + else { /* unprivileged user */ +#if defined(HAVE_SETRESUID) + if (setresuid((getuid() == uid)? (rb_uid_t)-1: uid, + (geteuid() == uid)? (rb_uid_t)-1: uid, + (SAVED_USER_ID == uid)? (rb_uid_t)-1: uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; +#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) + if (SAVED_USER_ID == uid) { + if (setreuid((getuid() == uid)? (rb_uid_t)-1: uid, + (geteuid() == uid)? (rb_uid_t)-1: uid) < 0) + rb_sys_fail(0); + } + else if (getuid() != uid) { + if (setreuid(uid, (geteuid() == uid)? (rb_uid_t)-1: uid) < 0) + rb_sys_fail(0); + SAVED_USER_ID = uid; + } + else if (/* getuid() == uid && */ geteuid() != uid) { + if (setreuid(geteuid(), uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + if (setreuid(uid, -1) < 0) rb_sys_fail(0); + } + else { /* getuid() == uid && geteuid() == uid */ + if (setreuid(-1, SAVED_USER_ID) < 0) rb_sys_fail(0); + if (setreuid(SAVED_USER_ID, uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + if (setreuid(uid, -1) < 0) rb_sys_fail(0); + } +#elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID) + if (SAVED_USER_ID == uid) { + if (geteuid() != uid && seteuid(uid) < 0) rb_sys_fail(0); + if (getuid() != uid && setruid(uid) < 0) rb_sys_fail(0); + } + else if (/* SAVED_USER_ID != uid && */ geteuid() == uid) { + if (getuid() != uid) { + if (setruid(uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } + else { + if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + if (setruid(uid) < 0) rb_sys_fail(0); + } + } + else if (/* geteuid() != uid && */ getuid() == uid) { + if (seteuid(uid) < 0) rb_sys_fail(0); + if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + if (setruid(uid) < 0) rb_sys_fail(0); + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#elif defined HAVE_44BSD_SETUID + if (getuid() == uid) { + /* (r,e,s)==(uid,?,?) ==> (uid,uid,uid) */ + if (setuid(uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#elif defined HAVE_SETEUID + if (getuid() == uid && SAVED_USER_ID == uid) { + if (seteuid(uid) < 0) rb_sys_fail(0); + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#elif defined HAVE_SETUID + if (getuid() == uid && SAVED_USER_ID == uid) { + if (setuid(uid) < 0) rb_sys_fail(0); + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#else + rb_notimplement(); +#endif + } + return id; +} + + + +#if defined HAVE_SETGID +/* + * call-seq: + * Process::Sys.setgid(group) -> nil + * + * Set the group ID of the current process to _group_. Not + * available on all platforms. + * + */ + +static VALUE +p_sys_setgid(VALUE obj, VALUE id) +{ + check_gid_switch(); + if (setgid(OBJ2GID(id)) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setgid rb_f_notimplement +#endif + + +#if defined HAVE_SETRGID +/* + * call-seq: + * Process::Sys.setrgid(group) -> nil + * + * Set the real group ID of the calling process to _group_. + * Not available on all platforms. + * + */ + +static VALUE +p_sys_setrgid(VALUE obj, VALUE id) +{ + check_gid_switch(); + if (setrgid(OBJ2GID(id)) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setrgid rb_f_notimplement +#endif + + +#if defined HAVE_SETEGID +/* + * call-seq: + * Process::Sys.setegid(group) -> nil + * + * Set the effective group ID of the calling process to + * _group_. Not available on all platforms. + * + */ + +static VALUE +p_sys_setegid(VALUE obj, VALUE id) +{ + check_gid_switch(); + if (setegid(OBJ2GID(id)) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setegid rb_f_notimplement +#endif + + +#if defined HAVE_SETREGID +/* + * call-seq: + * Process::Sys.setregid(rid, eid) -> nil + * + * Sets the (group) real and/or effective group IDs of the current + * process to <em>rid</em> and <em>eid</em>, respectively. A value of + * <code>-1</code> for either means to leave that ID unchanged. Not + * available on all platforms. + * + */ + +static VALUE +p_sys_setregid(VALUE obj, VALUE rid, VALUE eid) +{ + rb_gid_t rgid, egid; + PREPARE_GETGRNAM; + check_gid_switch(); + rgid = OBJ2GID(rid); + egid = OBJ2GID(eid); + FINISH_GETGRNAM; + if (setregid(rgid, egid) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setregid rb_f_notimplement +#endif + +#if defined HAVE_SETRESGID +/* + * call-seq: + * Process::Sys.setresgid(rid, eid, sid) -> nil + * + * Sets the (group) real, effective, and saved user IDs of the + * current process to <em>rid</em>, <em>eid</em>, and <em>sid</em> + * respectively. A value of <code>-1</code> for any value means to + * leave that ID unchanged. Not available on all platforms. + * + */ + +static VALUE +p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) +{ + rb_gid_t rgid, egid, sgid; + PREPARE_GETGRNAM; + check_gid_switch(); + rgid = OBJ2GID(rid); + egid = OBJ2GID(eid); + sgid = OBJ2GID(sid); + FINISH_GETGRNAM; + if (setresgid(rgid, egid, sgid) != 0) rb_sys_fail(0); + return Qnil; +} +#else +#define p_sys_setresgid rb_f_notimplement +#endif + + +#if defined HAVE_ISSETUGID +/* + * call-seq: + * Process::Sys.issetugid -> true or false + * + * Returns +true+ if the process was created as a result + * of an execve(2) system call which had either of the setuid or + * setgid bits set (and extra privileges were given as a result) or + * if it has changed any of its real, effective or saved user or + * group IDs since it began execution. + * + */ + +static VALUE +p_sys_issetugid(VALUE obj) +{ + rb_secure(2); + if (issetugid()) { + return Qtrue; + } + else { + return Qfalse; + } +} +#else +#define p_sys_issetugid rb_f_notimplement +#endif + + +/* + * call-seq: + * Process.gid -> fixnum + * Process::GID.rid -> fixnum + * Process::Sys.getgid -> fixnum + * + * Returns the (real) group ID for this process. + * + * Process.gid #=> 500 + */ + +static VALUE +proc_getgid(VALUE obj) +{ + rb_gid_t gid = getgid(); + return GIDT2NUM(gid); +} + + +#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETRGID) || defined(HAVE_SETGID) +/* + * call-seq: + * Process.gid= fixnum -> fixnum + * + * Sets the group ID for this process. + */ + +static VALUE +proc_setgid(VALUE obj, VALUE id) +{ + rb_gid_t gid; + + check_gid_switch(); + + gid = OBJ2GID(id); +#if defined(HAVE_SETRESGID) + if (setresgid(gid, -1, -1) < 0) rb_sys_fail(0); +#elif defined HAVE_SETREGID + if (setregid(gid, -1) < 0) rb_sys_fail(0); +#elif defined HAVE_SETRGID + if (setrgid(gid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETGID + { + if (getegid() == gid) { + if (setgid(gid) < 0) rb_sys_fail(0); + } + else { + rb_notimplement(); + } + } +#endif + return GIDT2NUM(gid); +} +#else +#define proc_setgid rb_f_notimplement +#endif + + +#if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX) +/* + * Maximum supplementary groups are platform dependent. + * FWIW, 65536 is enough big for our supported OSs. + * + * OS Name max groups + * ----------------------------------------------- + * Linux Kernel >= 2.6.3 65536 + * Linux Kernel < 2.6.3 32 + * IBM AIX 5.2 64 + * IBM AIX 5.3 ... 6.1 128 + * IBM AIX 7.1 128 (can be configured to be up to 2048) + * OpenBSD, NetBSD 16 + * FreeBSD < 8.0 16 + * FreeBSD >=8.0 1023 + * Darwin (Mac OS X) 16 + * Sun Solaris 7,8,9,10 16 + * Sun Solaris 11 / OpenSolaris 1024 + * HP-UX 20 + * Windows 1015 + */ +static int _maxgroups = -1; +static int +get_sc_ngroups_max(void) +{ +#ifdef _SC_NGROUPS_MAX + return (int)sysconf(_SC_NGROUPS_MAX); +#elif defined(NGROUPS_MAX) + return (int)NGROUPS_MAX; +#else + return -1; +#endif +} +static int +maxgroups(void) +{ + if (_maxgroups < 0) { + _maxgroups = get_sc_ngroups_max(); + if (_maxgroups < 0) + _maxgroups = RB_MAX_GROUPS; + } + + return _maxgroups; +} +#endif + + + +#ifdef HAVE_GETGROUPS +/* + * call-seq: + * Process.groups -> array + * + * Get an <code>Array</code> of the gids of groups in the + * supplemental group access list for this process. + * + * Process.groups #=> [27, 6, 10, 11] + * + */ + +static VALUE +proc_getgroups(VALUE obj) +{ + VALUE ary, tmp; + int i, ngroups; + rb_gid_t *groups; + + ngroups = getgroups(0, NULL); + if (ngroups == -1) + rb_sys_fail(0); + + groups = ALLOCV_N(rb_gid_t, tmp, ngroups); + + ngroups = getgroups(ngroups, groups); + if (ngroups == -1) + rb_sys_fail(0); + + ary = rb_ary_new(); + for (i = 0; i < ngroups; i++) + rb_ary_push(ary, GIDT2NUM(groups[i])); + + ALLOCV_END(tmp); + + return ary; +} +#else +#define proc_getgroups rb_f_notimplement +#endif + + +#ifdef HAVE_SETGROUPS +/* + * call-seq: + * Process.groups= array -> array + * + * Set the supplemental group access list to the given + * <code>Array</code> of group IDs. + * + * Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] + * Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11] + * Process.groups #=> [27, 6, 10, 11] + * + */ + +static VALUE +proc_setgroups(VALUE obj, VALUE ary) +{ + int ngroups, i; + rb_gid_t *groups; + VALUE tmp; + PREPARE_GETGRNAM; + + Check_Type(ary, T_ARRAY); + + ngroups = RARRAY_LENINT(ary); + if (ngroups > maxgroups()) + rb_raise(rb_eArgError, "too many groups, %d max", maxgroups()); + + groups = ALLOCV_N(rb_gid_t, tmp, ngroups); + + for (i = 0; i < ngroups; i++) { + VALUE g = RARRAY_AREF(ary, i); + + groups[i] = OBJ2GID1(g); + } + FINISH_GETGRNAM; + + if (setgroups(ngroups, groups) == -1) /* ngroups <= maxgroups */ + rb_sys_fail(0); + + ALLOCV_END(tmp); + + return proc_getgroups(obj); +} +#else +#define proc_setgroups rb_f_notimplement +#endif + + +#ifdef HAVE_INITGROUPS +/* + * call-seq: + * Process.initgroups(username, gid) -> array + * + * Initializes the supplemental group access list by reading the + * system group database and using all groups of which the given user + * is a member. The group with the specified <em>gid</em> is also + * added to the list. Returns the resulting <code>Array</code> of the + * gids of all the groups in the supplementary group access list. Not + * available on all platforms. + * + * Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] + * Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11] + * Process.groups #=> [30, 6, 10, 11] + * + */ + +static VALUE +proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp) +{ + if (initgroups(StringValuePtr(uname), OBJ2GID(base_grp)) != 0) { + rb_sys_fail(0); + } + return proc_getgroups(obj); +} +#else +#define proc_initgroups rb_f_notimplement +#endif + +#if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX) +/* + * call-seq: + * Process.maxgroups -> fixnum + * + * Returns the maximum number of gids allowed in the supplemental + * group access list. + * + * Process.maxgroups #=> 32 + */ + +static VALUE +proc_getmaxgroups(VALUE obj) +{ + return INT2FIX(maxgroups()); +} +#else +#define proc_getmaxgroups rb_f_notimplement +#endif + +#ifdef HAVE_SETGROUPS +/* + * call-seq: + * Process.maxgroups= fixnum -> fixnum + * + * Sets the maximum number of gids allowed in the supplemental group + * access list. + */ + +static VALUE +proc_setmaxgroups(VALUE obj, VALUE val) +{ + int ngroups = FIX2INT(val); + int ngroups_max = get_sc_ngroups_max(); + + if (ngroups <= 0) + rb_raise(rb_eArgError, "maxgroups %d shold be positive", ngroups); + + if (ngroups > RB_MAX_GROUPS) + ngroups = RB_MAX_GROUPS; + + if (ngroups_max > 0 && ngroups > ngroups_max) + ngroups = ngroups_max; + + _maxgroups = ngroups; + + return INT2FIX(_maxgroups); +} +#else +#define proc_setmaxgroups rb_f_notimplement +#endif + +#if defined(HAVE_DAEMON) || (defined(HAVE_WORKING_FORK) && defined(HAVE_SETSID)) +static int rb_daemon(int nochdir, int noclose); + +/* + * call-seq: + * Process.daemon() -> 0 + * Process.daemon(nochdir=nil,noclose=nil) -> 0 + * + * Detach the process from controlling terminal and run in + * the background as system daemon. Unless the argument + * nochdir is true (i.e. non false), it changes the current + * working directory to the root ("/"). Unless the argument + * noclose is true, daemon() will redirect standard input, + * standard output and standard error to /dev/null. + * Return zero on success, or raise one of Errno::*. + */ + +static VALUE +proc_daemon(int argc, VALUE *argv) +{ + VALUE nochdir, noclose; + int n; + + rb_secure(2); + rb_scan_args(argc, argv, "02", &nochdir, &noclose); + + prefork(); + n = rb_daemon(RTEST(nochdir), RTEST(noclose)); + if (n < 0) rb_sys_fail("daemon"); + return INT2FIX(n); +} + +static int +rb_daemon(int nochdir, int noclose) +{ + int err = 0; +#ifdef HAVE_DAEMON + before_fork_ruby(); + err = daemon(nochdir, noclose); + after_fork_ruby(); + rb_thread_atfork(); +#else + int n; + +#define fork_daemon() \ + switch (rb_fork_ruby(NULL)) { \ + case -1: return -1; \ + case 0: rb_thread_atfork(); break; \ + default: _exit(EXIT_SUCCESS); \ + } + + fork_daemon(); + + if (setsid() < 0) return -1; + + /* must not be process-leader */ + fork_daemon(); + + if (!nochdir) + err = chdir("/"); + + if (!noclose && (n = rb_cloexec_open("/dev/null", O_RDWR, 0)) != -1) { + rb_update_max_fd(n); + (void)dup2(n, 0); + (void)dup2(n, 1); + (void)dup2(n, 2); + if (n > 2) + (void)close (n); + } +#endif + return err; +} +#else +#define proc_daemon rb_f_notimplement +#endif + +/******************************************************************** + * + * Document-class: Process::GID + * + * The <code>Process::GID</code> module contains a collection of + * module functions which can be used to portably get, set, and + * switch the current process's real, effective, and saved group IDs. + * + */ + +static rb_gid_t SAVED_GROUP_ID = -1; + +#ifdef BROKEN_SETREGID +int +setregid(rb_gid_t rgid, rb_gid_t egid) +{ + if (rgid != (rb_gid_t)-1 && rgid != getgid()) { + if (egid == (rb_gid_t)-1) egid = getegid(); + if (setgid(rgid) < 0) return -1; + } + if (egid != (rb_gid_t)-1 && egid != getegid()) { + if (setegid(egid) < 0) return -1; + } + return 0; +} +#endif + +/* + * call-seq: + * Process::GID.change_privilege(group) -> fixnum + * + * Change the current process's real and effective group ID to that + * specified by _group_. Returns the new group ID. Not + * available on all platforms. + * + * [Process.gid, Process.egid] #=> [0, 0] + * Process::GID.change_privilege(33) #=> 33 + * [Process.gid, Process.egid] #=> [33, 33] + */ + +static VALUE +p_gid_change_privilege(VALUE obj, VALUE id) +{ + rb_gid_t gid; + + check_gid_switch(); + + gid = OBJ2GID(id); + + if (geteuid() == 0) { /* root-user */ +#if defined(HAVE_SETRESGID) + if (setresgid(gid, gid, gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; +#elif defined HAVE_SETGID + if (setgid(gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; +#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) + if (getgid() == gid) { + if (SAVED_GROUP_ID == gid) { + if (setregid(-1, gid) < 0) rb_sys_fail(0); + } + else { + if (gid == 0) { /* (r,e,s) == (root, y, x) */ + if (setregid(-1, SAVED_GROUP_ID) < 0) rb_sys_fail(0); + if (setregid(SAVED_GROUP_ID, 0) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = 0; /* (r,e,s) == (x, root, root) */ + if (setregid(gid, gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } + else { /* (r,e,s) == (z, y, x) */ + if (setregid(0, 0) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = 0; + if (setregid(gid, gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } + } + } + else { + if (setregid(gid, gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } +#elif defined(HAVE_SETRGID) && defined (HAVE_SETEGID) + if (getgid() == gid) { + if (SAVED_GROUP_ID == gid) { + if (setegid(gid) < 0) rb_sys_fail(0); + } + else { + if (gid == 0) { + if (setegid(gid) < 0) rb_sys_fail(0); + if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = 0; + if (setrgid(0) < 0) rb_sys_fail(0); + } + else { + if (setrgid(0) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = 0; + if (setegid(gid) < 0) rb_sys_fail(0); + if (setrgid(gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } + } + } + else { + if (setegid(gid) < 0) rb_sys_fail(0); + if (setrgid(gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } +#else + rb_notimplement(); +#endif + } + else { /* unprivileged user */ +#if defined(HAVE_SETRESGID) + if (setresgid((getgid() == gid)? (rb_gid_t)-1: gid, + (getegid() == gid)? (rb_gid_t)-1: gid, + (SAVED_GROUP_ID == gid)? (rb_gid_t)-1: gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; +#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) + if (SAVED_GROUP_ID == gid) { + if (setregid((getgid() == gid)? (rb_uid_t)-1: gid, + (getegid() == gid)? (rb_uid_t)-1: gid) < 0) + rb_sys_fail(0); + } + else if (getgid() != gid) { + if (setregid(gid, (getegid() == gid)? (rb_uid_t)-1: gid) < 0) + rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } + else if (/* getgid() == gid && */ getegid() != gid) { + if (setregid(getegid(), gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + if (setregid(gid, -1) < 0) rb_sys_fail(0); + } + else { /* getgid() == gid && getegid() == gid */ + if (setregid(-1, SAVED_GROUP_ID) < 0) rb_sys_fail(0); + if (setregid(SAVED_GROUP_ID, gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + if (setregid(gid, -1) < 0) rb_sys_fail(0); + } +#elif defined(HAVE_SETRGID) && defined(HAVE_SETEGID) + if (SAVED_GROUP_ID == gid) { + if (getegid() != gid && setegid(gid) < 0) rb_sys_fail(0); + if (getgid() != gid && setrgid(gid) < 0) rb_sys_fail(0); + } + else if (/* SAVED_GROUP_ID != gid && */ getegid() == gid) { + if (getgid() != gid) { + if (setrgid(gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } + else { + if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + if (setrgid(gid) < 0) rb_sys_fail(0); + } + } + else if (/* getegid() != gid && */ getgid() == gid) { + if (setegid(gid) < 0) rb_sys_fail(0); + if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + if (setrgid(gid) < 0) rb_sys_fail(0); + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#elif defined HAVE_44BSD_SETGID + if (getgid() == gid) { + /* (r,e,s)==(gid,?,?) ==> (gid,gid,gid) */ + if (setgid(gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#elif defined HAVE_SETEGID + if (getgid() == gid && SAVED_GROUP_ID == gid) { + if (setegid(gid) < 0) rb_sys_fail(0); + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#elif defined HAVE_SETGID + if (getgid() == gid && SAVED_GROUP_ID == gid) { + if (setgid(gid) < 0) rb_sys_fail(0); + } + else { + errno = EPERM; + rb_sys_fail(0); + } +#else + (void)gid; + rb_notimplement(); +#endif + } + return id; +} + + +/* + * call-seq: + * Process.euid -> fixnum + * Process::UID.eid -> fixnum + * Process::Sys.geteuid -> fixnum + * + * Returns the effective user ID for this process. + * + * Process.euid #=> 501 + */ + +static VALUE +proc_geteuid(VALUE obj) +{ + rb_uid_t euid = geteuid(); + return UIDT2NUM(euid); +} + +#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) || defined(_POSIX_SAVED_IDS) +static void +proc_seteuid(rb_uid_t uid) +{ +#if defined(HAVE_SETRESUID) + if (setresuid(-1, uid, -1) < 0) rb_sys_fail(0); +#elif defined HAVE_SETREUID + if (setreuid(-1, uid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETEUID + if (seteuid(uid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETUID + if (uid == getuid()) { + if (setuid(uid) < 0) rb_sys_fail(0); + } + else { + rb_notimplement(); + } +#else + rb_notimplement(); +#endif +} +#endif + +#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) +/* + * call-seq: + * Process.euid= user + * + * Sets the effective user ID for this process. Not available on all + * platforms. + */ + +static VALUE +proc_seteuid_m(VALUE mod, VALUE euid) +{ + check_uid_switch(); + proc_seteuid(OBJ2UID(euid)); + return euid; +} +#else +#define proc_seteuid_m rb_f_notimplement +#endif + +static rb_uid_t +rb_seteuid_core(rb_uid_t euid) +{ +#if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) + rb_uid_t uid; +#endif + + check_uid_switch(); + +#if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) + uid = getuid(); +#endif + +#if defined(HAVE_SETRESUID) + if (uid != euid) { + if (setresuid(-1,euid,euid) < 0) rb_sys_fail(0); + SAVED_USER_ID = euid; + } + else { + if (setresuid(-1,euid,-1) < 0) rb_sys_fail(0); + } +#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) + if (setreuid(-1, euid) < 0) rb_sys_fail(0); + if (uid != euid) { + if (setreuid(euid,uid) < 0) rb_sys_fail(0); + if (setreuid(uid,euid) < 0) rb_sys_fail(0); + SAVED_USER_ID = euid; + } +#elif defined HAVE_SETEUID + if (seteuid(euid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETUID + if (geteuid() == 0) rb_sys_fail(0); + if (setuid(euid) < 0) rb_sys_fail(0); +#else + rb_notimplement(); +#endif + return euid; +} + + +/* + * call-seq: + * Process::UID.grant_privilege(user) -> fixnum + * Process::UID.eid= user -> fixnum + * + * Set the effective user ID, and if possible, the saved user ID of + * the process to the given _user_. Returns the new + * effective user ID. Not available on all platforms. + * + * [Process.uid, Process.euid] #=> [0, 0] + * Process::UID.grant_privilege(31) #=> 31 + * [Process.uid, Process.euid] #=> [0, 31] + */ + +static VALUE +p_uid_grant_privilege(VALUE obj, VALUE id) +{ + rb_seteuid_core(OBJ2UID(id)); + return id; +} + + +/* + * call-seq: + * Process.egid -> fixnum + * Process::GID.eid -> fixnum + * Process::Sys.geteid -> fixnum + * + * Returns the effective group ID for this process. Not available on + * all platforms. + * + * Process.egid #=> 500 + */ + +static VALUE +proc_getegid(VALUE obj) +{ + rb_gid_t egid = getegid(); + + return GIDT2NUM(egid); +} + +#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) || defined(_POSIX_SAVED_IDS) +/* + * call-seq: + * Process.egid = fixnum -> fixnum + * + * Sets the effective group ID for this process. Not available on all + * platforms. + */ + +static VALUE +proc_setegid(VALUE obj, VALUE egid) +{ +#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) + rb_gid_t gid; +#endif + + check_gid_switch(); + +#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) + gid = OBJ2GID(egid); +#endif + +#if defined(HAVE_SETRESGID) + if (setresgid(-1, gid, -1) < 0) rb_sys_fail(0); +#elif defined HAVE_SETREGID + if (setregid(-1, gid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETEGID + if (setegid(gid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETGID + if (gid == getgid()) { + if (setgid(gid) < 0) rb_sys_fail(0); + } + else { + rb_notimplement(); + } +#else + rb_notimplement(); +#endif + return egid; +} +#endif + +#if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) +#define proc_setegid_m proc_setegid +#else +#define proc_setegid_m rb_f_notimplement +#endif + +static rb_gid_t +rb_setegid_core(rb_gid_t egid) +{ +#if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) + rb_gid_t gid; +#endif + + check_gid_switch(); + +#if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) + gid = getgid(); +#endif + +#if defined(HAVE_SETRESGID) + if (gid != egid) { + if (setresgid(-1,egid,egid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = egid; + } + else { + if (setresgid(-1,egid,-1) < 0) rb_sys_fail(0); + } +#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) + if (setregid(-1, egid) < 0) rb_sys_fail(0); + if (gid != egid) { + if (setregid(egid,gid) < 0) rb_sys_fail(0); + if (setregid(gid,egid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = egid; + } +#elif defined HAVE_SETEGID + if (setegid(egid) < 0) rb_sys_fail(0); +#elif defined HAVE_SETGID + if (geteuid() == 0 /* root user */) rb_sys_fail(0); + if (setgid(egid) < 0) rb_sys_fail(0); +#else + rb_notimplement(); +#endif + return egid; +} + + +/* + * call-seq: + * Process::GID.grant_privilege(group) -> fixnum + * Process::GID.eid = group -> fixnum + * + * Set the effective group ID, and if possible, the saved group ID of + * the process to the given _group_. Returns the new + * effective group ID. Not available on all platforms. + * + * [Process.gid, Process.egid] #=> [0, 0] + * Process::GID.grant_privilege(31) #=> 33 + * [Process.gid, Process.egid] #=> [0, 33] + */ + +static VALUE +p_gid_grant_privilege(VALUE obj, VALUE id) +{ + rb_setegid_core(OBJ2GID(id)); + return id; +} + + +/* + * call-seq: + * Process::UID.re_exchangeable? -> true or false + * + * Returns +true+ if the real and effective user IDs of a + * process may be exchanged on the current platform. + * + */ + +static VALUE +p_uid_exchangeable(void) +{ +#if defined(HAVE_SETRESUID) + return Qtrue; +#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) + return Qtrue; +#else + return Qfalse; +#endif +} + + +/* + * call-seq: + * Process::UID.re_exchange -> fixnum + * + * Exchange real and effective user IDs and return the new effective + * user ID. Not available on all platforms. + * + * [Process.uid, Process.euid] #=> [0, 31] + * Process::UID.re_exchange #=> 0 + * [Process.uid, Process.euid] #=> [31, 0] + */ + +static VALUE +p_uid_exchange(VALUE obj) +{ + rb_uid_t uid; +#if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) + rb_uid_t euid; +#endif + + check_uid_switch(); + + uid = getuid(); +#if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) + euid = geteuid(); +#endif + +#if defined(HAVE_SETRESUID) + if (setresuid(euid, uid, uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; +#elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) + if (setreuid(euid,uid) < 0) rb_sys_fail(0); + SAVED_USER_ID = uid; +#else + rb_notimplement(); +#endif + return UIDT2NUM(uid); +} + + +/* + * call-seq: + * Process::GID.re_exchangeable? -> true or false + * + * Returns +true+ if the real and effective group IDs of a + * process may be exchanged on the current platform. + * + */ + +static VALUE +p_gid_exchangeable(void) +{ +#if defined(HAVE_SETRESGID) + return Qtrue; +#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) + return Qtrue; +#else + return Qfalse; +#endif +} + + +/* + * call-seq: + * Process::GID.re_exchange -> fixnum + * + * Exchange real and effective group IDs and return the new effective + * group ID. Not available on all platforms. + * + * [Process.gid, Process.egid] #=> [0, 33] + * Process::GID.re_exchange #=> 0 + * [Process.gid, Process.egid] #=> [33, 0] + */ + +static VALUE +p_gid_exchange(VALUE obj) +{ + rb_gid_t gid; +#if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) + rb_gid_t egid; +#endif + + check_gid_switch(); + + gid = getgid(); +#if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) + egid = getegid(); +#endif + +#if defined(HAVE_SETRESGID) + if (setresgid(egid, gid, gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; +#elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) + if (setregid(egid,gid) < 0) rb_sys_fail(0); + SAVED_GROUP_ID = gid; +#else + rb_notimplement(); +#endif + return GIDT2NUM(gid); +} + +/* [MG] :FIXME: Is this correct? I'm not sure how to phrase this. */ + +/* + * call-seq: + * Process::UID.sid_available? -> true or false + * + * Returns +true+ if the current platform has saved user + * ID functionality. + * + */ + +static VALUE +p_uid_have_saved_id(void) +{ +#if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) + return Qtrue; +#else + return Qfalse; +#endif +} + + +#if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) +static VALUE +p_uid_sw_ensure(rb_uid_t id) +{ + under_uid_switch = 0; + id = rb_seteuid_core(id); + return UIDT2NUM(id); +} + + +/* + * call-seq: + * Process::UID.switch -> fixnum + * Process::UID.switch {|| block} -> object + * + * Switch the effective and real user IDs of the current process. If + * a <em>block</em> is given, the user IDs will be switched back + * after the block is executed. Returns the new effective user ID if + * called without a block, and the return value of the block if one + * is given. + * + */ + +static VALUE +p_uid_switch(VALUE obj) +{ + rb_uid_t uid, euid; + + check_uid_switch(); + + uid = getuid(); + euid = geteuid(); + + if (uid != euid) { + proc_seteuid(uid); + if (rb_block_given_p()) { + under_uid_switch = 1; + return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, SAVED_USER_ID); + } + else { + return UIDT2NUM(euid); + } + } + else if (euid != SAVED_USER_ID) { + proc_seteuid(SAVED_USER_ID); + if (rb_block_given_p()) { + under_uid_switch = 1; + return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, euid); + } + else { + return UIDT2NUM(uid); + } + } + else { + errno = EPERM; + rb_sys_fail(0); + } + + UNREACHABLE; +} +#else +static VALUE +p_uid_sw_ensure(VALUE obj) +{ + under_uid_switch = 0; + return p_uid_exchange(obj); +} + +static VALUE +p_uid_switch(VALUE obj) +{ + rb_uid_t uid, euid; + + check_uid_switch(); + + uid = getuid(); + euid = geteuid(); + + if (uid == euid) { + errno = EPERM; + rb_sys_fail(0); + } + p_uid_exchange(obj); + if (rb_block_given_p()) { + under_uid_switch = 1; + return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, obj); + } + else { + return UIDT2NUM(euid); + } +} +#endif + + +/* [MG] :FIXME: Is this correct? I'm not sure how to phrase this. */ + +/* + * call-seq: + * Process::GID.sid_available? -> true or false + * + * Returns +true+ if the current platform has saved group + * ID functionality. + * + */ + +static VALUE +p_gid_have_saved_id(void) +{ +#if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) + return Qtrue; +#else + return Qfalse; +#endif +} + +#if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) +static VALUE +p_gid_sw_ensure(rb_gid_t id) +{ + under_gid_switch = 0; + id = rb_setegid_core(id); + return GIDT2NUM(id); +} + + +/* + * call-seq: + * Process::GID.switch -> fixnum + * Process::GID.switch {|| block} -> object + * + * Switch the effective and real group IDs of the current process. If + * a <em>block</em> is given, the group IDs will be switched back + * after the block is executed. Returns the new effective group ID if + * called without a block, and the return value of the block if one + * is given. + * + */ + +static VALUE +p_gid_switch(VALUE obj) +{ + rb_gid_t gid, egid; + + check_gid_switch(); + + gid = getgid(); + egid = getegid(); + + if (gid != egid) { + proc_setegid(obj, GIDT2NUM(gid)); + if (rb_block_given_p()) { + under_gid_switch = 1; + return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, SAVED_GROUP_ID); + } + else { + return GIDT2NUM(egid); + } + } + else if (egid != SAVED_GROUP_ID) { + proc_setegid(obj, GIDT2NUM(SAVED_GROUP_ID)); + if (rb_block_given_p()) { + under_gid_switch = 1; + return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, egid); + } + else { + return GIDT2NUM(gid); + } + } + else { + errno = EPERM; + rb_sys_fail(0); + } + + UNREACHABLE; +} +#else +static VALUE +p_gid_sw_ensure(VALUE obj) +{ + under_gid_switch = 0; + return p_gid_exchange(obj); +} + +static VALUE +p_gid_switch(VALUE obj) +{ + rb_gid_t gid, egid; + + check_gid_switch(); + + gid = getgid(); + egid = getegid(); + + if (gid == egid) { + errno = EPERM; + rb_sys_fail(0); + } + p_gid_exchange(obj); + if (rb_block_given_p()) { + under_gid_switch = 1; + return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, obj); + } + else { + return GIDT2NUM(egid); + } +} +#endif + + +#if defined(HAVE_TIMES) +static long +get_clk_tck(void) +{ + long hertz = +#ifdef HAVE__SC_CLK_TCK + (double)sysconf(_SC_CLK_TCK); +#else +#ifndef HZ +# ifdef CLK_TCK +# define HZ CLK_TCK +# else +# define HZ 60 +# endif +#endif /* HZ */ + HZ; +#endif + return hertz; +} + +/* + * call-seq: + * Process.times -> aProcessTms + * + * Returns a <code>Tms</code> structure (see <code>Process::Tms</code>) + * that contains user and system CPU times for this process, + * and also for children processes. + * + * t = Process.times + * [ t.utime, t.stime, t.cutime, t.cstime ] #=> [0.0, 0.02, 0.00, 0.00] + */ + +VALUE +rb_proc_times(VALUE obj) +{ + const double hertz = get_clk_tck(); + struct tms buf; + VALUE utime, stime, cutime, cstime, ret; + + times(&buf); + utime = DBL2NUM(buf.tms_utime / hertz); + stime = DBL2NUM(buf.tms_stime / hertz); + cutime = DBL2NUM(buf.tms_cutime / hertz); + cstime = DBL2NUM(buf.tms_cstime / hertz); + ret = rb_struct_new(rb_cProcessTms, utime, stime, cutime, cstime); + RB_GC_GUARD(utime); + RB_GC_GUARD(stime); + RB_GC_GUARD(cutime); + RB_GC_GUARD(cstime); + return ret; +} +#else +#define rb_proc_times rb_f_notimplement +#endif + +#ifdef HAVE_LONG_LONG +typedef LONG_LONG timetick_int_t; +#define TIMETICK_INT_MIN LLONG_MIN +#define TIMETICK_INT_MAX LLONG_MAX +#define TIMETICK_INT2NUM(v) LL2NUM(v) +#else +typedef long timetick_int_t; +#define TIMETICK_INT_MIN LONG_MIN +#define TIMETICK_INT_MAX LONG_MAX +#define TIMETICK_INT2NUM(v) LONG2NUM(v) +#endif + +static timetick_int_t +gcd_timetick_int(timetick_int_t a, timetick_int_t b) +{ + timetick_int_t t; + + if (a < b) { + t = a; + a = b; + b = t; + } + + while (1) { + t = a % b; + if (t == 0) + return b; + a = b; + b = t; + } +} + +static void +reduce_fraction(timetick_int_t *np, timetick_int_t *dp) +{ + timetick_int_t gcd = gcd_timetick_int(*np, *dp); + if (gcd != 1) { + *np /= gcd; + *dp /= gcd; + } +} + +static void +reduce_factors(timetick_int_t *numerators, int num_numerators, + timetick_int_t *denominators, int num_denominators) +{ + int i, j; + for (i = 0; i < num_numerators; i++) { + if (numerators[i] == 1) + continue; + for (j = 0; j < num_denominators; j++) { + if (denominators[j] == 1) + continue; + reduce_fraction(&numerators[i], &denominators[j]); + } + } +} + +struct timetick { + timetick_int_t giga_count; + int32_t count; /* 0 .. 999999999 */ +}; + +static VALUE +timetick2dblnum(struct timetick *ttp, + timetick_int_t *numerators, int num_numerators, + timetick_int_t *denominators, int num_denominators) +{ + double d; + int i; + + reduce_factors(numerators, num_numerators, + denominators, num_denominators); + + d = ttp->giga_count * 1e9 + ttp->count; + + for (i = 0; i < num_numerators; i++) + d *= numerators[i]; + for (i = 0; i < num_denominators; i++) + d /= denominators[i]; + + return DBL2NUM(d); +} + +static VALUE +timetick2dblnum_reciprocal(struct timetick *ttp, + timetick_int_t *numerators, int num_numerators, + timetick_int_t *denominators, int num_denominators) +{ + double d; + int i; + + reduce_factors(numerators, num_numerators, + denominators, num_denominators); + + d = 1.0; + for (i = 0; i < num_denominators; i++) + d *= denominators[i]; + for (i = 0; i < num_numerators; i++) + d /= numerators[i]; + d /= ttp->giga_count * 1e9 + ttp->count; + + return DBL2NUM(d); +} + +#define NDIV(x,y) (-(-((x)+1)/(y))-1) +#define DIV(n,d) ((n)<0 ? NDIV((n),(d)) : (n)/(d)) + +static VALUE +timetick2integer(struct timetick *ttp, + timetick_int_t *numerators, int num_numerators, + timetick_int_t *denominators, int num_denominators) +{ + VALUE v; + int i; + + reduce_factors(numerators, num_numerators, + denominators, num_denominators); + + if (!MUL_OVERFLOW_SIGNED_INTEGER_P(1000000000, ttp->giga_count, + TIMETICK_INT_MIN, TIMETICK_INT_MAX-ttp->count)) { + timetick_int_t t = ttp->giga_count * 1000000000 + ttp->count; + for (i = 0; i < num_numerators; i++) { + timetick_int_t factor = numerators[i]; + if (MUL_OVERFLOW_SIGNED_INTEGER_P(factor, t, + TIMETICK_INT_MIN, TIMETICK_INT_MAX)) + goto generic; + t *= factor; + } + for (i = 0; i < num_denominators; i++) { + t = DIV(t, denominators[i]); + } + return TIMETICK_INT2NUM(t); + } + + generic: + v = TIMETICK_INT2NUM(ttp->giga_count); + v = rb_funcall(v, '*', 1, LONG2FIX(1000000000)); + v = rb_funcall(v, '+', 1, LONG2FIX(ttp->count)); + for (i = 0; i < num_numerators; i++) { + timetick_int_t factor = numerators[i]; + if (factor == 1) + continue; + v = rb_funcall(v, '*', 1, TIMETICK_INT2NUM(factor)); + } + for (i = 0; i < num_denominators; i++) { + v = rb_funcall(v, '/', 1, TIMETICK_INT2NUM(denominators[i])); /* Ruby's '/' is div. */ + } + return v; +} + +static VALUE +make_clock_result(struct timetick *ttp, + timetick_int_t *numerators, int num_numerators, + timetick_int_t *denominators, int num_denominators, + VALUE unit) +{ + if (unit == ID2SYM(id_nanosecond)) { + numerators[num_numerators++] = 1000000000; + return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators); + } + else if (unit == ID2SYM(id_microsecond)) { + numerators[num_numerators++] = 1000000; + return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators); + } + else if (unit == ID2SYM(id_millisecond)) { + numerators[num_numerators++] = 1000; + return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators); + } + else if (unit == ID2SYM(id_second)) { + return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators); + } + else if (unit == ID2SYM(id_float_microsecond)) { + numerators[num_numerators++] = 1000000; + return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators); + } + else if (unit == ID2SYM(id_float_millisecond)) { + numerators[num_numerators++] = 1000; + return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators); + } + else if (NIL_P(unit) || unit == ID2SYM(id_float_second)) { + return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators); + } + else + rb_raise(rb_eArgError, "unexpected unit: %"PRIsVALUE, unit); +} + +#ifdef __APPLE__ +static mach_timebase_info_data_t * +get_mach_timebase_info(void) +{ + static mach_timebase_info_data_t sTimebaseInfo; + + if ( sTimebaseInfo.denom == 0 ) { + (void) mach_timebase_info(&sTimebaseInfo); + } + + return &sTimebaseInfo; +} +#endif + +/* + * call-seq: + * Process.clock_gettime(clock_id [, unit]) -> number + * + * Returns a time returned by POSIX clock_gettime() function. + * + * p Process.clock_gettime(Process::CLOCK_MONOTONIC) + * #=> 896053.968060096 + * + * +clock_id+ specifies a kind of clock. + * It is specifed as a constant which begins with <code>Process::CLOCK_</code> + * such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC. + * + * The supported constants depends on OS and version. + * Ruby provides following types of +clock_id+ if available. + * + * [CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1 + * [CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4 + * [CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, OpenBSD 5.4 + * [CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1, OpenBSD 5.4 + * [CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1 + * [CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1 + * [CLOCK_REALTIME_FAST] FreeBSD 8.1 + * [CLOCK_REALTIME_PRECISE] FreeBSD 8.1 + * [CLOCK_REALTIME_COARSE] Linux 2.6.32 + * [CLOCK_REALTIME_ALARM] Linux 3.0 + * [CLOCK_MONOTONIC_FAST] FreeBSD 8.1 + * [CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1 + * [CLOCK_MONOTONIC_COARSE] Linux 2.6.32 + * [CLOCK_MONOTONIC_RAW] Linux 2.6.28 + * [CLOCK_BOOTTIME] Linux 2.6.39 + * [CLOCK_BOOTTIME_ALARM] Linux 3.0 + * [CLOCK_UPTIME] FreeBSD 7.0, OpenBSD 5.5 + * [CLOCK_UPTIME_FAST] FreeBSD 8.1 + * [CLOCK_UPTIME_PRECISE] FreeBSD 8.1 + * [CLOCK_SECOND] FreeBSD 8.1 + * + * Note that SUS stands for Single Unix Specification. + * SUS contains POSIX and clock_gettime is defined in the POSIX part. + * SUS defines CLOCK_REALTIME mandatory but + * CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID and CLOCK_THREAD_CPUTIME_ID are optional. + * + * Also, several symbols are accepted as +clock_id+. + * There are emulations for clock_gettime(). + * + * For example, Process::CLOCK_REALTIME is defined as + * +:GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available. + * + * Emulations for +CLOCK_REALTIME+: + * [:GETTIMEOFDAY_BASED_CLOCK_REALTIME] + * Use gettimeofday() defined by SUS. + * (SUSv4 obsoleted it, though.) + * The resolution is 1 microsecond. + * [:TIME_BASED_CLOCK_REALTIME] + * Use time() defined by ISO C. + * The resolution is 1 second. + * + * Emulations for +CLOCK_MONOTONIC+: + * [:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC] + * Use mach_absolute_time(), available on Darwin. + * The resolution is CPU dependent. + * [:TIMES_BASED_CLOCK_MONOTONIC] + * Use the result value of times() defined by POSIX. + * POSIX defines it as "times() shall return the elapsed real time, in clock ticks, since an arbitrary point in the past (for example, system start-up time)". + * For example, GNU/Linux returns a value based on jiffies and it is monotonic. + * However, 4.4BSD uses gettimeofday() and it is not monotonic. + * (FreeBSD uses clock_gettime(CLOCK_MONOTONIC) instead, though.) + * The resolution is the clock tick. + * "getconf CLK_TCK" command shows the clock ticks per second. + * (The clock ticks per second is defined by HZ macro in older systems.) + * If it is 100 and clock_t is 32 bits integer type, the resolution is 10 millisecond and + * cannot represent over 497 days. + * + * Emulations for +CLOCK_PROCESS_CPUTIME_ID+: + * [:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID] + * Use getrusage() defined by SUS. + * getrusage() is used with RUSAGE_SELF to obtain the time only for + * the calling process (excluding the time for child processes). + * The result is addition of user time (ru_utime) and system time (ru_stime). + * The resolution is 1 microsecond. + * [:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID] + * Use times() defined by POSIX. + * The result is addition of user time (tms_utime) and system time (tms_stime). + * tms_cutime and tms_cstime are ignored to exclude the time for child processes. + * The resolution is the clock tick. + * "getconf CLK_TCK" command shows the clock ticks per second. + * (The clock ticks per second is defined by HZ macro in older systems.) + * If it is 100, the resolution is 10 millisecond. + * [:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID] + * Use clock() defined by ISO C. + * The resolution is 1/CLOCKS_PER_SEC. + * CLOCKS_PER_SEC is the C-level macro defined by time.h. + * SUS defines CLOCKS_PER_SEC is 1000000. + * Non-Unix systems may define it a different value, though. + * If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 microsecond. + * If CLOCKS_PER_SEC is 1000000 and clock_t is 32 bits integer type, it cannot represent over 72 minutes. + * + * If the given +clock_id+ is not supported, Errno::EINVAL is raised. + * + * +unit+ specifies a type of the return value. + * + * [:float_second] number of seconds as a float (default) + * [:float_millisecond] number of milliseconds as a float + * [:float_microsecond] number of microseconds as a float + * [:second] number of seconds as an integer + * [:millisecond] number of milliseconds as an integer + * [:microsecond] number of microseconds as an integer + * [:nanosecond] number of nanoseconds as an integer + * + * The underlying function, clock_gettime(), returns a number of nanoseconds. + * Float object (IEEE 754 double) is not enough to represent + * the return value for CLOCK_REALTIME. + * If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+. + * + * The origin (zero) of the returned value varies. + * For example, system start up time, process start up time, the Epoch, etc. + * + * The origin in CLOCK_REALTIME is defined as the Epoch + * (1970-01-01 00:00:00 UTC). + * But some systems count leap seconds and others doesn't. + * So the result can be interpreted differently across systems. + * Time.now is recommended over CLOCK_REALTIME. + */ +VALUE +rb_clock_gettime(int argc, VALUE *argv) +{ + VALUE clk_id, unit; + int ret; + + struct timetick tt; + timetick_int_t numerators[2]; + timetick_int_t denominators[2]; + int num_numerators = 0; + int num_denominators = 0; + + rb_scan_args(argc, argv, "11", &clk_id, &unit); + + if (SYMBOL_P(clk_id)) { + /* + * Non-clock_gettime clocks are provided by symbol clk_id. + * + * gettimeofday is always available on platforms supported by Ruby. + * GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for + * CLOCK_REALTIME if clock_gettime is not available. + */ +#define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(id_GETTIMEOFDAY_BASED_CLOCK_REALTIME) + if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) { + struct timeval tv; + ret = gettimeofday(&tv, 0); + if (ret != 0) + rb_sys_fail("gettimeofday"); + tt.giga_count = tv.tv_sec; + tt.count = (int32_t)tv.tv_usec * 1000; + denominators[num_denominators++] = 1000000000; + goto success; + } + +#define RUBY_TIME_BASED_CLOCK_REALTIME ID2SYM(id_TIME_BASED_CLOCK_REALTIME) + if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) { + time_t t; + t = time(NULL); + if (t == (time_t)-1) + rb_sys_fail("time"); + tt.giga_count = t; + tt.count = 0; + denominators[num_denominators++] = 1000000000; + goto success; + } + +#ifdef HAVE_TIMES +#define RUBY_TIMES_BASED_CLOCK_MONOTONIC \ + ID2SYM(id_TIMES_BASED_CLOCK_MONOTONIC) + if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) { + struct tms buf; + clock_t c; + unsigned_clock_t uc; + c = times(&buf); + if (c == (clock_t)-1) + rb_sys_fail("times"); + uc = (unsigned_clock_t)c; + tt.count = (int32_t)(uc % 1000000000); + tt.giga_count = (uc / 1000000000); + denominators[num_denominators++] = get_clk_tck(); + goto success; + } +#endif + +#ifdef RUSAGE_SELF +#define RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID \ + ID2SYM(id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) + if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) { + struct rusage usage; + int32_t usec; + ret = getrusage(RUSAGE_SELF, &usage); + if (ret != 0) + rb_sys_fail("getrusage"); + tt.giga_count = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec; + usec = (int32_t)(usage.ru_utime.tv_usec + usage.ru_stime.tv_usec); + if (1000000 <= usec) { + tt.giga_count++; + usec -= 1000000; + } + tt.count = usec * 1000; + denominators[num_denominators++] = 1000000000; + goto success; + } +#endif + +#ifdef HAVE_TIMES +#define RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID \ + ID2SYM(id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) + if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) { + struct tms buf; + unsigned_clock_t utime, stime; + if (times(&buf) == (clock_t)-1) + rb_sys_fail("times"); + utime = (unsigned_clock_t)buf.tms_utime; + stime = (unsigned_clock_t)buf.tms_stime; + tt.count = (int32_t)((utime % 1000000000) + (stime % 1000000000)); + tt.giga_count = (utime / 1000000000) + (stime / 1000000000); + if (1000000000 <= tt.count) { + tt.count -= 1000000000; + tt.giga_count++; + } + denominators[num_denominators++] = get_clk_tck(); + goto success; + } +#endif + +#define RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID \ + ID2SYM(id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) + if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) { + clock_t c; + unsigned_clock_t uc; + errno = 0; + c = clock(); + if (c == (clock_t)-1) + rb_sys_fail("clock"); + uc = (unsigned_clock_t)c; + tt.count = (int32_t)(uc % 1000000000); + tt.giga_count = uc / 1000000000; + denominators[num_denominators++] = CLOCKS_PER_SEC; + goto success; + } + +#ifdef __APPLE__ +#define RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC ID2SYM(id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) + if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) { + mach_timebase_info_data_t *info = get_mach_timebase_info(); + uint64_t t = mach_absolute_time(); + tt.count = (int32_t)(t % 1000000000); + tt.giga_count = t / 1000000000; + numerators[num_numerators++] = info->numer; + denominators[num_denominators++] = info->denom; + denominators[num_denominators++] = 1000000000; + goto success; + } +#endif + } + else { +#if defined(HAVE_CLOCK_GETTIME) + struct timespec ts; + clockid_t c; + c = NUM2CLOCKID(clk_id); + ret = clock_gettime(c, &ts); + if (ret == -1) + rb_sys_fail("clock_gettime"); + tt.count = (int32_t)ts.tv_nsec; + tt.giga_count = ts.tv_sec; + denominators[num_denominators++] = 1000000000; + goto success; +#endif + } + /* EINVAL emulates clock_gettime behavior when clock_id is invalid. */ + errno = EINVAL; + rb_sys_fail(0); + + success: + return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit); +} + +/* + * call-seq: + * Process.clock_getres(clock_id [, unit]) -> number + * + * Returns the time resolution returned by POSIX clock_getres() function. + * + * +clock_id+ specifies a kind of clock. + * See the document of +Process.clock_gettime+ for details. + * + * +clock_id+ can be a symbol as +Process.clock_gettime+. + * However the result may not be accurate. + * For example, +Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME)+ + * returns 1.0e-06 which means 1 microsecond, but actual resolution can be more coarse. + * + * If the given +clock_id+ is not supported, Errno::EINVAL is raised. + * + * +unit+ specifies a type of the return value. + * +Process.clock_getres+ accepts +unit+ as +Process.clock_gettime+. + * The default value, +:float_second+, is also same as + * +Process.clock_gettime+. + * + * +Process.clock_getres+ also accepts +:hertz+ as +unit+. + * +:hertz+ means a the reciprocal of +:float_second+. + * + * +:hertz+ can be used to obtain the exact value of + * the clock ticks per second for times() function and + * CLOCKS_PER_SEC for clock() function. + * + * +Process.clock_getres(:TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)+ + * returns the clock ticks per second. + * + * +Process.clock_getres(:CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID, :hertz)+ + * returns CLOCKS_PER_SEC. + * + * p Process.clock_getres(Process::CLOCK_MONOTONIC) + * #=> 1.0e-09 + * + */ +VALUE +rb_clock_getres(int argc, VALUE *argv) +{ + VALUE clk_id, unit; + + struct timetick tt; + timetick_int_t numerators[2]; + timetick_int_t denominators[2]; + int num_numerators = 0; + int num_denominators = 0; + + rb_scan_args(argc, argv, "11", &clk_id, &unit); + + if (SYMBOL_P(clk_id)) { +#ifdef RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME + if (clk_id == RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) { + tt.giga_count = 0; + tt.count = 1000; + denominators[num_denominators++] = 1000000000; + goto success; + } +#endif + +#ifdef RUBY_TIME_BASED_CLOCK_REALTIME + if (clk_id == RUBY_TIME_BASED_CLOCK_REALTIME) { + tt.giga_count = 1; + tt.count = 0; + denominators[num_denominators++] = 1000000000; + goto success; + } +#endif + +#ifdef RUBY_TIMES_BASED_CLOCK_MONOTONIC + if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) { + tt.count = 1; + tt.giga_count = 0; + denominators[num_denominators++] = get_clk_tck(); + goto success; + } +#endif + +#ifdef RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID + if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) { + tt.giga_count = 0; + tt.count = 1000; + denominators[num_denominators++] = 1000000000; + goto success; + } +#endif + +#ifdef RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID + if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) { + tt.count = 1; + tt.giga_count = 0; + denominators[num_denominators++] = get_clk_tck(); + goto success; + } +#endif + +#ifdef RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID + if (clk_id == RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) { + tt.count = 1; + tt.giga_count = 0; + denominators[num_denominators++] = CLOCKS_PER_SEC; + goto success; + } +#endif + +#ifdef RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC + if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) { + mach_timebase_info_data_t *info = get_mach_timebase_info(); + tt.count = 1; + tt.giga_count = 0; + numerators[num_numerators++] = info->numer; + denominators[num_denominators++] = info->denom; + denominators[num_denominators++] = 1000000000; + goto success; + } +#endif + } + else { +#if defined(HAVE_CLOCK_GETRES) + struct timespec ts; + clockid_t c = NUM2CLOCKID(clk_id); + int ret = clock_getres(c, &ts); + if (ret == -1) + rb_sys_fail("clock_getres"); + tt.count = (int32_t)ts.tv_nsec; + tt.giga_count = ts.tv_sec; + denominators[num_denominators++] = 1000000000; + goto success; +#endif + } + /* EINVAL emulates clock_getres behavior when clock_id is invalid. */ + errno = EINVAL; + rb_sys_fail(0); + + success: + if (unit == ID2SYM(id_hertz)) { + return timetick2dblnum_reciprocal(&tt, numerators, num_numerators, denominators, num_denominators); + } + else { + return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit); + } +} + +VALUE rb_mProcess; +VALUE rb_mProcUID; +VALUE rb_mProcGID; +VALUE rb_mProcID_Syscall; + + +/* + * The <code>Process</code> module is a collection of methods used to + * manipulate processes. + */ + +void +InitVM_process(void) +{ +#undef rb_intern +#define rb_intern(str) rb_intern_const(str) + rb_define_virtual_variable("$?", rb_last_status_get, 0); + rb_define_virtual_variable("$$", get_pid, 0); + rb_define_global_function("exec", rb_f_exec, -1); + rb_define_global_function("fork", rb_f_fork, 0); + rb_define_global_function("exit!", rb_f_exit_bang, -1); + rb_define_global_function("system", rb_f_system, -1); + rb_define_global_function("spawn", rb_f_spawn, -1); + rb_define_global_function("sleep", rb_f_sleep, -1); + rb_define_global_function("exit", rb_f_exit, -1); + rb_define_global_function("abort", rb_f_abort, -1); + + rb_mProcess = rb_define_module("Process"); + +#ifdef WNOHANG + /* see Process.wait */ + rb_define_const(rb_mProcess, "WNOHANG", INT2FIX(WNOHANG)); +#else + /* see Process.wait */ + rb_define_const(rb_mProcess, "WNOHANG", INT2FIX(0)); +#endif +#ifdef WUNTRACED + /* see Process.wait */ + rb_define_const(rb_mProcess, "WUNTRACED", INT2FIX(WUNTRACED)); +#else + /* see Process.wait */ + rb_define_const(rb_mProcess, "WUNTRACED", INT2FIX(0)); +#endif + + rb_define_singleton_method(rb_mProcess, "exec", rb_f_exec, -1); + rb_define_singleton_method(rb_mProcess, "fork", rb_f_fork, 0); + rb_define_singleton_method(rb_mProcess, "spawn", rb_f_spawn, -1); + rb_define_singleton_method(rb_mProcess, "exit!", rb_f_exit_bang, -1); + rb_define_singleton_method(rb_mProcess, "exit", rb_f_exit, -1); + rb_define_singleton_method(rb_mProcess, "abort", rb_f_abort, -1); + + rb_define_module_function(rb_mProcess, "kill", rb_f_kill, -1); /* in signal.c */ + rb_define_module_function(rb_mProcess, "wait", proc_wait, -1); + rb_define_module_function(rb_mProcess, "wait2", proc_wait2, -1); + rb_define_module_function(rb_mProcess, "waitpid", proc_wait, -1); + rb_define_module_function(rb_mProcess, "waitpid2", proc_wait2, -1); + rb_define_module_function(rb_mProcess, "waitall", proc_waitall, 0); + rb_define_module_function(rb_mProcess, "detach", proc_detach, 1); + + rb_cWaiter = rb_define_class_under(rb_mProcess, "Waiter", rb_cThread); + rb_undef_alloc_func(rb_cWaiter); + rb_undef_method(CLASS_OF(rb_cWaiter), "new"); + rb_define_method(rb_cWaiter, "pid", detach_process_pid, 0); + + rb_cProcessStatus = rb_define_class_under(rb_mProcess, "Status", rb_cObject); + rb_undef_method(CLASS_OF(rb_cProcessStatus), "new"); + + rb_define_method(rb_cProcessStatus, "==", pst_equal, 1); + rb_define_method(rb_cProcessStatus, "&", pst_bitand, 1); + rb_define_method(rb_cProcessStatus, ">>", pst_rshift, 1); + rb_define_method(rb_cProcessStatus, "to_i", pst_to_i, 0); + rb_define_method(rb_cProcessStatus, "to_s", pst_to_s, 0); + rb_define_method(rb_cProcessStatus, "inspect", pst_inspect, 0); + + rb_define_method(rb_cProcessStatus, "pid", pst_pid, 0); + + rb_define_method(rb_cProcessStatus, "stopped?", pst_wifstopped, 0); + rb_define_method(rb_cProcessStatus, "stopsig", pst_wstopsig, 0); + rb_define_method(rb_cProcessStatus, "signaled?", pst_wifsignaled, 0); + rb_define_method(rb_cProcessStatus, "termsig", pst_wtermsig, 0); + rb_define_method(rb_cProcessStatus, "exited?", pst_wifexited, 0); + rb_define_method(rb_cProcessStatus, "exitstatus", pst_wexitstatus, 0); + rb_define_method(rb_cProcessStatus, "success?", pst_success_p, 0); + rb_define_method(rb_cProcessStatus, "coredump?", pst_wcoredump, 0); + + rb_define_module_function(rb_mProcess, "pid", get_pid, 0); + rb_define_module_function(rb_mProcess, "ppid", get_ppid, 0); + + rb_define_module_function(rb_mProcess, "getpgrp", proc_getpgrp, 0); + rb_define_module_function(rb_mProcess, "setpgrp", proc_setpgrp, 0); + rb_define_module_function(rb_mProcess, "getpgid", proc_getpgid, 1); + rb_define_module_function(rb_mProcess, "setpgid", proc_setpgid, 2); + + rb_define_module_function(rb_mProcess, "getsid", proc_getsid, -1); + rb_define_module_function(rb_mProcess, "setsid", proc_setsid, 0); + + rb_define_module_function(rb_mProcess, "getpriority", proc_getpriority, 2); + rb_define_module_function(rb_mProcess, "setpriority", proc_setpriority, 3); + +#ifdef HAVE_GETPRIORITY + /* see Process.setpriority */ + rb_define_const(rb_mProcess, "PRIO_PROCESS", INT2FIX(PRIO_PROCESS)); + /* see Process.setpriority */ + rb_define_const(rb_mProcess, "PRIO_PGRP", INT2FIX(PRIO_PGRP)); + /* see Process.setpriority */ + rb_define_const(rb_mProcess, "PRIO_USER", INT2FIX(PRIO_USER)); +#endif + + rb_define_module_function(rb_mProcess, "getrlimit", proc_getrlimit, 1); + rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, -1); +#if defined(RLIM2NUM) && defined(RLIM_INFINITY) + { + VALUE inf = RLIM2NUM(RLIM_INFINITY); +#ifdef RLIM_SAVED_MAX + { + VALUE v = RLIM_INFINITY == RLIM_SAVED_MAX ? inf : RLIM2NUM(RLIM_SAVED_MAX); + /* see Process.setrlimit */ + rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", v); + } +#endif + /* see Process.setrlimit */ + rb_define_const(rb_mProcess, "RLIM_INFINITY", inf); +#ifdef RLIM_SAVED_CUR + { + VALUE v = RLIM_INFINITY == RLIM_SAVED_CUR ? inf : RLIM2NUM(RLIM_SAVED_CUR); + /* see Process.setrlimit */ + rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", v); + } +#endif + } +#ifdef RLIMIT_AS + /* Maximum size of the process's virtual memory (address space) in bytes. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_AS", INT2FIX(RLIMIT_AS)); +#endif +#ifdef RLIMIT_CORE + /* Maximum size of the core file. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_CORE", INT2FIX(RLIMIT_CORE)); +#endif +#ifdef RLIMIT_CPU + /* CPU time limit in seconds. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_CPU", INT2FIX(RLIMIT_CPU)); +#endif +#ifdef RLIMIT_DATA + /* Maximum size of the process's data segment. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_DATA", INT2FIX(RLIMIT_DATA)); +#endif +#ifdef RLIMIT_FSIZE + /* Maximum size of files that the process may create. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_FSIZE", INT2FIX(RLIMIT_FSIZE)); +#endif +#ifdef RLIMIT_MEMLOCK + /* Maximum number of bytes of memory that may be locked into RAM. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_MEMLOCK", INT2FIX(RLIMIT_MEMLOCK)); +#endif +#ifdef RLIMIT_MSGQUEUE + /* Specifies the limit on the number of bytes that can be allocated + * for POSIX message queues for the real user ID of the calling process. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_MSGQUEUE", INT2FIX(RLIMIT_MSGQUEUE)); +#endif +#ifdef RLIMIT_NICE + /* Specifies a ceiling to which the process's nice value can be raised. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_NICE", INT2FIX(RLIMIT_NICE)); +#endif +#ifdef RLIMIT_NOFILE + /* Specifies a value one greater than the maximum file descriptor + * number that can be opened by this process. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_NOFILE", INT2FIX(RLIMIT_NOFILE)); +#endif +#ifdef RLIMIT_NPROC + /* The maximum number of processes that can be created for the + * real user ID of the calling process. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_NPROC", INT2FIX(RLIMIT_NPROC)); +#endif +#ifdef RLIMIT_RSS + /* Specifies the limit (in pages) of the process's resident set. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_RSS", INT2FIX(RLIMIT_RSS)); +#endif +#ifdef RLIMIT_RTPRIO + /* Specifies a ceiling on the real-time priority that may be set for this process. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_RTPRIO", INT2FIX(RLIMIT_RTPRIO)); +#endif +#ifdef RLIMIT_RTTIME + /* Specifies limit on CPU time this process scheduled under a real-time + * scheduling policy can consume. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_RTTIME", INT2FIX(RLIMIT_RTTIME)); +#endif +#ifdef RLIMIT_SBSIZE + /* Maximum size of the socket buffer. + */ + rb_define_const(rb_mProcess, "RLIMIT_SBSIZE", INT2FIX(RLIMIT_SBSIZE)); +#endif +#ifdef RLIMIT_SIGPENDING + /* Specifies a limit on the number of signals that may be queued for + * the real user ID of the calling process. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_SIGPENDING", INT2FIX(RLIMIT_SIGPENDING)); +#endif +#ifdef RLIMIT_STACK + /* Maximum size of the stack, in bytes. + * + * see the system getrlimit(2) manual for details. + */ + rb_define_const(rb_mProcess, "RLIMIT_STACK", INT2FIX(RLIMIT_STACK)); +#endif +#endif + + rb_define_module_function(rb_mProcess, "uid", proc_getuid, 0); + rb_define_module_function(rb_mProcess, "uid=", proc_setuid, 1); + rb_define_module_function(rb_mProcess, "gid", proc_getgid, 0); + rb_define_module_function(rb_mProcess, "gid=", proc_setgid, 1); + rb_define_module_function(rb_mProcess, "euid", proc_geteuid, 0); + rb_define_module_function(rb_mProcess, "euid=", proc_seteuid_m, 1); + rb_define_module_function(rb_mProcess, "egid", proc_getegid, 0); + rb_define_module_function(rb_mProcess, "egid=", proc_setegid_m, 1); + rb_define_module_function(rb_mProcess, "initgroups", proc_initgroups, 2); + rb_define_module_function(rb_mProcess, "groups", proc_getgroups, 0); + rb_define_module_function(rb_mProcess, "groups=", proc_setgroups, 1); + rb_define_module_function(rb_mProcess, "maxgroups", proc_getmaxgroups, 0); + rb_define_module_function(rb_mProcess, "maxgroups=", proc_setmaxgroups, 1); + + rb_define_module_function(rb_mProcess, "daemon", proc_daemon, -1); + + rb_define_module_function(rb_mProcess, "times", rb_proc_times, 0); + +#ifdef CLOCK_REALTIME + rb_define_const(rb_mProcess, "CLOCK_REALTIME", CLOCKID2NUM(CLOCK_REALTIME)); +#elif defined(RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) + rb_define_const(rb_mProcess, "CLOCK_REALTIME", RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME); +#endif +#ifdef CLOCK_MONOTONIC + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC", CLOCKID2NUM(CLOCK_MONOTONIC)); +#elif defined(RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC", RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC); +#endif +#ifdef CLOCK_PROCESS_CPUTIME_ID + rb_define_const(rb_mProcess, "CLOCK_PROCESS_CPUTIME_ID", CLOCKID2NUM(CLOCK_PROCESS_CPUTIME_ID)); +#elif defined(RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) + rb_define_const(rb_mProcess, "CLOCK_PROCESS_CPUTIME_ID", RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID); +#endif +#ifdef CLOCK_THREAD_CPUTIME_ID + rb_define_const(rb_mProcess, "CLOCK_THREAD_CPUTIME_ID", CLOCKID2NUM(CLOCK_THREAD_CPUTIME_ID)); +#endif +#ifdef CLOCK_VIRTUAL + rb_define_const(rb_mProcess, "CLOCK_VIRTUAL", CLOCKID2NUM(CLOCK_VIRTUAL)); +#endif +#ifdef CLOCK_PROF + rb_define_const(rb_mProcess, "CLOCK_PROF", CLOCKID2NUM(CLOCK_PROF)); +#endif +#ifdef CLOCK_REALTIME_FAST + rb_define_const(rb_mProcess, "CLOCK_REALTIME_FAST", CLOCKID2NUM(CLOCK_REALTIME_FAST)); +#endif +#ifdef CLOCK_REALTIME_PRECISE + rb_define_const(rb_mProcess, "CLOCK_REALTIME_PRECISE", CLOCKID2NUM(CLOCK_REALTIME_PRECISE)); +#endif +#ifdef CLOCK_REALTIME_COARSE + rb_define_const(rb_mProcess, "CLOCK_REALTIME_COARSE", CLOCKID2NUM(CLOCK_REALTIME_COARSE)); +#endif +#ifdef CLOCK_REALTIME_ALARM + rb_define_const(rb_mProcess, "CLOCK_REALTIME_ALARM", CLOCKID2NUM(CLOCK_REALTIME_ALARM)); +#endif +#ifdef CLOCK_MONOTONIC_FAST + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_FAST", CLOCKID2NUM(CLOCK_MONOTONIC_FAST)); +#endif +#ifdef CLOCK_MONOTONIC_PRECISE + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_PRECISE", CLOCKID2NUM(CLOCK_MONOTONIC_PRECISE)); +#endif +#ifdef CLOCK_MONOTONIC_RAW + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_RAW", CLOCKID2NUM(CLOCK_MONOTONIC_RAW)); +#endif +#ifdef CLOCK_MONOTONIC_COARSE + rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_COARSE", CLOCKID2NUM(CLOCK_MONOTONIC_COARSE)); +#endif +#ifdef CLOCK_BOOTTIME + rb_define_const(rb_mProcess, "CLOCK_BOOTTIME", CLOCKID2NUM(CLOCK_BOOTTIME)); +#endif +#ifdef CLOCK_BOOTTIME_ALARM + rb_define_const(rb_mProcess, "CLOCK_BOOTTIME_ALARM", CLOCKID2NUM(CLOCK_BOOTTIME_ALARM)); +#endif +#ifdef CLOCK_UPTIME + rb_define_const(rb_mProcess, "CLOCK_UPTIME", CLOCKID2NUM(CLOCK_UPTIME)); +#endif +#ifdef CLOCK_UPTIME_FAST + rb_define_const(rb_mProcess, "CLOCK_UPTIME_FAST", CLOCKID2NUM(CLOCK_UPTIME_FAST)); +#endif +#ifdef CLOCK_UPTIME_PRECISE + rb_define_const(rb_mProcess, "CLOCK_UPTIME_PRECISE", CLOCKID2NUM(CLOCK_UPTIME_PRECISE)); +#endif +#ifdef CLOCK_SECOND + rb_define_const(rb_mProcess, "CLOCK_SECOND", CLOCKID2NUM(CLOCK_SECOND)); +#endif + rb_define_module_function(rb_mProcess, "clock_gettime", rb_clock_gettime, -1); + rb_define_module_function(rb_mProcess, "clock_getres", rb_clock_getres, -1); + +#if defined(HAVE_TIMES) || defined(_WIN32) + rb_cProcessTms = rb_struct_define_under(rb_mProcess, "Tms", "utime", "stime", "cutime", "cstime", NULL); + rb_define_const(rb_cStruct, "Tms", rb_cProcessTms); /* for the backward compatibility */ +#endif + + SAVED_USER_ID = geteuid(); + SAVED_GROUP_ID = getegid(); + + rb_mProcUID = rb_define_module_under(rb_mProcess, "UID"); + rb_mProcGID = rb_define_module_under(rb_mProcess, "GID"); + + rb_define_module_function(rb_mProcUID, "rid", proc_getuid, 0); + rb_define_module_function(rb_mProcGID, "rid", proc_getgid, 0); + rb_define_module_function(rb_mProcUID, "eid", proc_geteuid, 0); + rb_define_module_function(rb_mProcGID, "eid", proc_getegid, 0); + rb_define_module_function(rb_mProcUID, "change_privilege", p_uid_change_privilege, 1); + rb_define_module_function(rb_mProcGID, "change_privilege", p_gid_change_privilege, 1); + rb_define_module_function(rb_mProcUID, "grant_privilege", p_uid_grant_privilege, 1); + rb_define_module_function(rb_mProcGID, "grant_privilege", p_gid_grant_privilege, 1); + rb_define_alias(rb_singleton_class(rb_mProcUID), "eid=", "grant_privilege"); + rb_define_alias(rb_singleton_class(rb_mProcGID), "eid=", "grant_privilege"); + rb_define_module_function(rb_mProcUID, "re_exchange", p_uid_exchange, 0); + rb_define_module_function(rb_mProcGID, "re_exchange", p_gid_exchange, 0); + rb_define_module_function(rb_mProcUID, "re_exchangeable?", p_uid_exchangeable, 0); + rb_define_module_function(rb_mProcGID, "re_exchangeable?", p_gid_exchangeable, 0); + rb_define_module_function(rb_mProcUID, "sid_available?", p_uid_have_saved_id, 0); + rb_define_module_function(rb_mProcGID, "sid_available?", p_gid_have_saved_id, 0); + rb_define_module_function(rb_mProcUID, "switch", p_uid_switch, 0); + rb_define_module_function(rb_mProcGID, "switch", p_gid_switch, 0); +#ifdef p_uid_from_name + rb_define_module_function(rb_mProcUID, "from_name", p_uid_from_name, 1); +#endif +#ifdef p_gid_from_name + rb_define_module_function(rb_mProcGID, "from_name", p_gid_from_name, 1); +#endif + + rb_mProcID_Syscall = rb_define_module_under(rb_mProcess, "Sys"); + + rb_define_module_function(rb_mProcID_Syscall, "getuid", proc_getuid, 0); + rb_define_module_function(rb_mProcID_Syscall, "geteuid", proc_geteuid, 0); + rb_define_module_function(rb_mProcID_Syscall, "getgid", proc_getgid, 0); + rb_define_module_function(rb_mProcID_Syscall, "getegid", proc_getegid, 0); + + rb_define_module_function(rb_mProcID_Syscall, "setuid", p_sys_setuid, 1); + rb_define_module_function(rb_mProcID_Syscall, "setgid", p_sys_setgid, 1); + + rb_define_module_function(rb_mProcID_Syscall, "setruid", p_sys_setruid, 1); + rb_define_module_function(rb_mProcID_Syscall, "setrgid", p_sys_setrgid, 1); + + rb_define_module_function(rb_mProcID_Syscall, "seteuid", p_sys_seteuid, 1); + rb_define_module_function(rb_mProcID_Syscall, "setegid", p_sys_setegid, 1); + + rb_define_module_function(rb_mProcID_Syscall, "setreuid", p_sys_setreuid, 2); + rb_define_module_function(rb_mProcID_Syscall, "setregid", p_sys_setregid, 2); + + rb_define_module_function(rb_mProcID_Syscall, "setresuid", p_sys_setresuid, 3); + rb_define_module_function(rb_mProcID_Syscall, "setresgid", p_sys_setresgid, 3); + rb_define_module_function(rb_mProcID_Syscall, "issetugid", p_sys_issetugid, 0); +} + +void +Init_process(void) +{ + id_in = rb_intern("in"); + id_out = rb_intern("out"); + id_err = rb_intern("err"); + id_pid = rb_intern("pid"); + id_uid = rb_intern("uid"); + id_gid = rb_intern("gid"); + id_close = rb_intern("close"); + id_child = rb_intern("child"); + id_status = rb_intern("status"); +#ifdef HAVE_SETPGID + id_pgroup = rb_intern("pgroup"); +#endif +#ifdef _WIN32 + id_new_pgroup = rb_intern("new_pgroup"); +#endif + id_unsetenv_others = rb_intern("unsetenv_others"); + id_chdir = rb_intern("chdir"); + id_umask = rb_intern("umask"); + id_close_others = rb_intern("close_others"); + id_ENV = rb_intern("ENV"); + id_nanosecond = rb_intern("nanosecond"); + id_microsecond = rb_intern("microsecond"); + id_millisecond = rb_intern("millisecond"); + id_second = rb_intern("second"); + id_float_microsecond = rb_intern("float_microsecond"); + id_float_millisecond = rb_intern("float_millisecond"); + id_float_second = rb_intern("float_second"); + id_GETTIMEOFDAY_BASED_CLOCK_REALTIME = rb_intern("GETTIMEOFDAY_BASED_CLOCK_REALTIME"); + id_TIME_BASED_CLOCK_REALTIME = rb_intern("TIME_BASED_CLOCK_REALTIME"); +#ifdef HAVE_TIMES + id_TIMES_BASED_CLOCK_MONOTONIC = rb_intern("TIMES_BASED_CLOCK_MONOTONIC"); + id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern("TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID"); +#endif +#ifdef RUSAGE_SELF + id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern("GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID"); +#endif + id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID = rb_intern("CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID"); +#ifdef __APPLE__ + id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC = rb_intern("MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC"); +#endif + id_hertz = rb_intern("hertz"); + + InitVM(process); +} |