diff options
Diffstat (limited to 'process.c')
| -rw-r--r-- | process.c | 3974 |
1 files changed, 2948 insertions, 1026 deletions
@@ -2,18 +2,20 @@ process.c - - $Author: nobu $ - $Date: 2006/08/16 02:46:10 $ + $Author$ created at: Tue Aug 10 14:30:50 JST 1993 - Copyright (C) 1993-2003 Yukihiro Matsumoto + Copyright (C) 1993-2007 Yukihiro Matsumoto Copyright (C) 2000 Network Applied Communication Laboratory, Inc. Copyright (C) 2000 Information-technology Promotion Agency, Japan **********************************************************************/ -#include "ruby.h" -#include "rubysig.h" +#include "ruby/ruby.h" +#include "ruby/io.h" +#include "ruby/util.h" +#include "vm_core.h" + #include <stdio.h> #include <errno.h> #include <signal.h> @@ -23,8 +25,8 @@ #ifdef HAVE_UNISTD_H #include <unistd.h> #endif -#ifdef __DJGPP__ -#include <process.h> +#ifdef HAVE_FCNTL_H +#include <fcntl.h> #endif #include <time.h> @@ -37,20 +39,28 @@ #define EXIT_FAILURE 1 #endif -struct timeval rb_time_interval _((VALUE)); +struct timeval rb_time_interval(VALUE); #ifdef HAVE_SYS_WAIT_H # include <sys/wait.h> #endif -#ifdef HAVE_GETPRIORITY +#ifdef HAVE_SYS_RESOURCE_H # include <sys/resource.h> #endif -#include "st.h" +#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> + #ifdef HAVE_SYS_TIMES_H #include <sys/times.h> #endif @@ -60,7 +70,7 @@ struct timeval rb_time_interval _((VALUE)); #endif #if defined(HAVE_TIMES) || defined(_WIN32) -static VALUE S_Tms; +static VALUE rb_cProcessTms; #endif #ifndef WIFEXITED @@ -96,11 +106,6 @@ static VALUE S_Tms; #undef HAVE_SETRGID #endif -#if defined(__MacOS_X__) || defined(__bsdi__) -#define BROKEN_SETREUID 1 -#define BROKEN_SETREGID 1 -#endif - #ifdef BROKEN_SETREUID #define setreuid ruby_setreuid #endif @@ -117,13 +122,24 @@ static VALUE S_Tms; #endif #endif +#if SIZEOF_RLIM_T == SIZEOF_INT +# define RLIM2NUM(v) UINT2NUM(v) +# define NUM2RLIM(v) NUM2UINT(v) +#elif SIZEOF_RLIM_T == SIZEOF_LONG +# define RLIM2NUM(v) ULONG2NUM(v) +# define NUM2RLIM(v) NUM2ULONG(v) +#elif SIZEOF_RLIM_T == SIZEOF_LONG_LONG +# define RLIM2NUM(v) ULL2NUM(v) +# define NUM2RLIM(v) NUM2ULL(v) +#endif + #define preserving_errno(stmts) \ do {int saved_errno = errno; stmts; errno = saved_errno;} while (0) /* * call-seq: - * Process.pid => fixnum + * Process.pid -> fixnum * * Returns the process id of this process. Not available on all * platforms. @@ -132,19 +148,19 @@ static VALUE S_Tms; */ static VALUE -get_pid() +get_pid(void) { rb_secure(2); - return INT2FIX(getpid()); + return PIDT2NUM(getpid()); } /* * call-seq: - * Process.ppid => fixnum + * Process.ppid -> fixnum * - * Returns the process id of the parent of this process. Always - * returns 0 on NT. Not available on all platforms. + * 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}" } @@ -156,14 +172,10 @@ get_pid() */ static VALUE -get_ppid() +get_ppid(void) { rb_secure(2); -#ifdef _WIN32 - return INT2FIX(0); -#else - return INT2FIX(getppid()); -#endif + return PIDT2NUM(getppid()); } @@ -197,23 +209,33 @@ get_ppid() * _stat_, we're referring to this 16 bit value. */ -static VALUE rb_cProcStatus; -VALUE rb_last_status = Qnil; +static VALUE rb_cProcessStatus; -static void -last_status_set(status, pid) - int status, pid; +VALUE +rb_last_status_get(void) +{ + return GET_THREAD()->last_status; +} + +void +rb_last_status_set(int status, rb_pid_t pid) { - rb_last_status = rb_obj_alloc(rb_cProcStatus); - rb_iv_set(rb_last_status, "status", INT2FIX(status)); - rb_iv_set(rb_last_status, "pid", INT2FIX(pid)); + rb_thread_t *th = GET_THREAD(); + th->last_status = rb_obj_alloc(rb_cProcessStatus); + rb_iv_set(th->last_status, "status", INT2FIX(status)); + rb_iv_set(th->last_status, "pid", PIDT2NUM(pid)); } +static void +rb_last_status_clear(void) +{ + GET_THREAD()->last_status = Qnil; +} /* * call-seq: - * stat.to_i => fixnum - * stat.to_int => fixnum + * 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. @@ -224,31 +246,16 @@ last_status_set(status, pid) */ static VALUE -pst_to_i(st) - VALUE st; +pst_to_i(VALUE st) { return rb_iv_get(st, "status"); } +#define PST2INT(st) NUM2INT(pst_to_i(st)) /* * call-seq: - * stat.to_s => string - * - * Equivalent to _stat_<code>.to_i.to_s</code>. - */ - -static VALUE -pst_to_s(st) - VALUE st; -{ - return rb_fix2str(pst_to_i(st), 10); -} - - -/* - * call-seq: - * stat.pid => fixnum + * stat.pid -> fixnum * * Returns the process ID that this status object represents. * @@ -258,65 +265,92 @@ pst_to_s(st) */ static VALUE -pst_pid(st) - VALUE st; +pst_pid(VALUE st) { - return rb_iv_get(st, "pid"); + return rb_attr_get(st, rb_intern("pid")); } - -/* - * call-seq: - * stat.inspect => string - * - * Override the inspection method. - */ - -static VALUE -pst_inspect(st) - VALUE st; +static void +pst_message(VALUE str, rb_pid_t pid, int status) { - VALUE pid; - int status; - VALUE str; - char buf[256]; - - pid = pst_pid(st); - status = NUM2INT(st); - - snprintf(buf, sizeof(buf), "#<%s: pid=%ld", rb_class2name(CLASS_OF(st)), NUM2LONG(pid)); - str = rb_str_new2(buf); + rb_str_catf(str, "pid %ld", (long)pid); if (WIFSTOPPED(status)) { int stopsig = WSTOPSIG(status); const char *signame = ruby_signal_name(stopsig); if (signame) { - snprintf(buf, sizeof(buf), ",stopped(SIG%s=%d)", signame, stopsig); + rb_str_catf(str, " stopped SIG%s (signal %d)", signame, stopsig); } else { - snprintf(buf, sizeof(buf), ",stopped(%d)", stopsig); + rb_str_catf(str, " stopped signal %d", stopsig); } - rb_str_cat2(str, buf); } if (WIFSIGNALED(status)) { int termsig = WTERMSIG(status); const char *signame = ruby_signal_name(termsig); if (signame) { - snprintf(buf, sizeof(buf), ",signaled(SIG%s=%d)", signame, termsig); + rb_str_catf(str, " SIG%s (signal %d)", signame, termsig); } else { - snprintf(buf, sizeof(buf), ",signaled(%d)", termsig); + rb_str_catf(str, " signal %d", termsig); } - rb_str_cat2(str, buf); } if (WIFEXITED(status)) { - snprintf(buf, sizeof(buf), ",exited(%d)", WEXITSTATUS(status)); - rb_str_cat2(str, buf); + rb_str_catf(str, " exit %d", WEXITSTATUS(status)); } #ifdef WCOREDUMP if (WCOREDUMP(status)) { - rb_str_cat2(str, ",coredumped"); + rb_str_cat2(str, " (core dumped)"); } #endif +} + + +/* + * call-seq: + * stat.to_s -> string + * + * Show pid and exit status as a string. + */ + +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. + */ + +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; } @@ -324,15 +358,14 @@ pst_inspect(st) /* * call-seq: - * stat == other => true or false + * stat == other -> true or false * * Returns +true+ if the integer value of _stat_ * equals <em>other</em>. */ static VALUE -pst_equal(st1, st2) - VALUE st1, st2; +pst_equal(VALUE st1, VALUE st2) { if (st1 == st2) return Qtrue; return rb_equal(pst_to_i(st1), st2); @@ -341,7 +374,7 @@ pst_equal(st1, st2) /* * call-seq: - * stat & num => fixnum + * stat & num -> fixnum * * Logical AND of the bits in _stat_ with <em>num</em>. * @@ -352,10 +385,9 @@ pst_equal(st1, st2) */ static VALUE -pst_bitand(st1, st2) - VALUE st1, st2; +pst_bitand(VALUE st1, VALUE st2) { - int status = NUM2INT(st1) & NUM2INT(st2); + int status = PST2INT(st1) & NUM2INT(st2); return INT2NUM(status); } @@ -363,7 +395,7 @@ pst_bitand(st1, st2) /* * call-seq: - * stat >> num => fixnum + * stat >> num -> fixnum * * Shift the bits in _stat_ right <em>num</em> places. * @@ -374,10 +406,9 @@ pst_bitand(st1, st2) */ static VALUE -pst_rshift(st1, st2) - VALUE st1, st2; +pst_rshift(VALUE st1, VALUE st2) { - int status = NUM2INT(st1) >> NUM2INT(st2); + int status = PST2INT(st1) >> NUM2INT(st2); return INT2NUM(status); } @@ -385,7 +416,7 @@ pst_rshift(st1, st2) /* * call-seq: - * stat.stopped? => true or false + * 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 @@ -393,10 +424,9 @@ pst_rshift(st1, st2) */ static VALUE -pst_wifstopped(st) - VALUE st; +pst_wifstopped(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (WIFSTOPPED(status)) return Qtrue; @@ -407,17 +437,16 @@ pst_wifstopped(st) /* * call-seq: - * stat.stopsig => fixnum or nil + * 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(st) - VALUE st; +pst_wstopsig(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (WIFSTOPPED(status)) return INT2NUM(WSTOPSIG(status)); @@ -427,17 +456,16 @@ pst_wstopsig(st) /* * call-seq: - * stat.signaled? => true or false + * stat.signaled? -> true or false * * Returns +true+ if _stat_ terminated because of * an uncaught signal. */ static VALUE -pst_wifsignaled(st) - VALUE st; +pst_wifsignaled(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (WIFSIGNALED(status)) return Qtrue; @@ -448,7 +476,7 @@ pst_wifsignaled(st) /* * call-seq: - * stat.termsig => fixnum or nil + * 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 @@ -456,10 +484,9 @@ pst_wifsignaled(st) */ static VALUE -pst_wtermsig(st) - VALUE st; +pst_wtermsig(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (WIFSIGNALED(status)) return INT2NUM(WTERMSIG(status)); @@ -469,7 +496,7 @@ pst_wtermsig(st) /* * call-seq: - * stat.exited? => true or false + * stat.exited? -> true or false * * Returns +true+ if _stat_ exited normally (for * example using an <code>exit()</code> call or finishing the @@ -477,10 +504,9 @@ pst_wtermsig(st) */ static VALUE -pst_wifexited(st) - VALUE st; +pst_wifexited(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (WIFEXITED(status)) return Qtrue; @@ -491,7 +517,7 @@ pst_wifexited(st) /* * call-seq: - * stat.exitstatus => fixnum or nil + * stat.exitstatus -> fixnum or nil * * Returns the least significant eight bits of the return code of * _stat_. Only available if <code>exited?</code> is @@ -509,10 +535,9 @@ pst_wifexited(st) */ static VALUE -pst_wexitstatus(st) - VALUE st; +pst_wexitstatus(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (WIFEXITED(status)) return INT2NUM(WEXITSTATUS(status)); @@ -522,17 +547,16 @@ pst_wexitstatus(st) /* * call-seq: - * stat.success? => true, false or nil + * 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(st) - VALUE st; +pst_success_p(VALUE st) { - int status = NUM2INT(st); + int status = PST2INT(st); if (!WIFEXITED(status)) return Qnil; @@ -542,18 +566,17 @@ pst_success_p(st) /* * call-seq: - * stat.coredump? => true or false + * stat.coredump? -> true or false * * Returns +true+ if _stat_ generated a coredump * when it terminated. Not available on all platforms. */ static VALUE -pst_wcoredump(st) - VALUE st; +pst_wcoredump(VALUE st) { #ifdef WCOREDUMP - int status = NUM2INT(st); + int status = PST2INT(st); if (WCOREDUMP(status)) return Qtrue; @@ -567,47 +590,93 @@ pst_wcoredump(st) #if !defined(HAVE_WAITPID) && !defined(HAVE_WAIT4) #define NO_WAITPID static st_table *pid_tbl; -#endif -int -rb_waitpid(pid, st, flags) - int pid; +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 *st; int flags; +}; +#endif + +static VALUE +rb_waitpid_blocking(void *data) { - int result; + rb_pid_t result; #ifndef NO_WAITPID - int oflags = flags; - if (!rb_thread_alone()) { /* there're other threads to run */ - flags |= WNOHANG; - } + struct waitpid_arg *arg = data; +#endif - retry: - TRAP_BEG; -#ifdef HAVE_WAITPID - result = waitpid(pid, st, flags); +#if defined NO_WAITPID + result = wait(data); +#elif defined HAVE_WAITPID + result = waitpid(arg->pid, arg->st, arg->flags); #else /* HAVE_WAIT4 */ - result = wait4(pid, st, flags, NULL); + result = wait4(arg->pid, arg->st, arg->flags, NULL); #endif - TRAP_END; + + return (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)rb_thread_blocking_region(rb_waitpid_blocking, &arg, + RUBY_UBF_PROCESS, 0); if (result < 0) { if (errno == EINTR) { - rb_thread_polling(); - goto retry; - } - return -1; - } - if (result == 0) { - if (oflags & WNOHANG) return 0; - rb_thread_polling(); - if (rb_thread_alone()) flags = oflags; - goto retry; + RUBY_VM_CHECK_INTS(); + goto retry; + } + return (rb_pid_t)-1; } #else /* NO_WAITPID */ - if (pid_tbl && st_lookup(pid_tbl, pid, st)) { - last_status_set(*st, pid); - st_delete(pid_tbl, (st_data_t*)&pid, NULL); - return pid; + 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) { @@ -615,60 +684,30 @@ rb_waitpid(pid, st, flags) } for (;;) { - TRAP_BEG; - result = wait(st); - TRAP_END; + result = (rb_pid_t)rb_thread_blocking_region(rb_waitpid_blocking, + st, RUBY_UBF_PROCESS, 0); if (result < 0) { if (errno == EINTR) { rb_thread_schedule(); continue; } - return -1; + return (rb_pid_t)-1; } - if (result == pid) { + if (result == pid || pid == (rb_pid_t)-1) { break; } if (!pid_tbl) pid_tbl = st_init_numtable(); - st_insert(pid_tbl, pid, st); + st_insert(pid_tbl, pid, (st_data_t)st); if (!rb_thread_alone()) rb_thread_schedule(); } #endif if (result > 0) { - last_status_set(*st, result); + rb_last_status_set(*st, result); } return result; } -#ifdef NO_WAITPID -struct wait_data { - int pid; - int status; -}; - -static int -wait_each(pid, status, data) - int pid, 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(pid, status, ary) - int pid, status; - VALUE ary; -{ - last_status_set(status, pid); - rb_ary_push(ary, rb_assoc_new(INT2NUM(pid), rb_last_status)); - return ST_DELETE; -} -#endif - /* [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 @@ -686,9 +725,9 @@ waitall_each(pid, status, ary) /* * call-seq: - * Process.wait() => fixnum - * Process.wait(pid=-1, flags=0) => fixnum - * Process.waitpid(pid=-1, flags=0) => fixnum + * 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 @@ -721,29 +760,28 @@ waitall_each(pid, status, ary) * $?.exitstatus #=> 99 * * pid = fork { sleep 3 } #=> 27440 - * Time.now #=> Wed Apr 09 08:57:09 CDT 2003 + * Time.now #=> 2008-03-08 19:56:16 +0900 * waitpid(pid, Process::WNOHANG) #=> nil - * Time.now #=> Wed Apr 09 08:57:09 CDT 2003 + * Time.now #=> 2008-03-08 19:56:16 +0900 * waitpid(pid, 0) #=> 27440 - * Time.now #=> Wed Apr 09 08:57:12 CDT 2003 + * Time.now #=> 2008-03-08 19:56:19 +0900 */ static VALUE -proc_wait(argc, argv) - int argc; - VALUE *argv; +proc_wait(int argc, VALUE *argv) { VALUE vpid, vflags; - int pid, flags, status; + rb_pid_t pid; + int flags, status; rb_secure(2); flags = 0; - rb_scan_args(argc, argv, "02", &vpid, &vflags); if (argc == 0) { pid = -1; } else { - pid = NUM2INT(vpid); + rb_scan_args(argc, argv, "02", &vpid, &vflags); + pid = NUM2PIDT(vpid); if (argc == 2 && !NIL_P(vflags)) { flags = NUM2UINT(vflags); } @@ -751,16 +789,17 @@ proc_wait(argc, argv) if ((pid = rb_waitpid(pid, &status, flags)) < 0) rb_sys_fail(0); if (pid == 0) { - return rb_last_status = Qnil; + rb_last_status_clear(); + return Qnil; } - return INT2FIX(pid); + return PIDT2NUM(pid); } /* * call-seq: - * Process.wait2(pid=-1, flags=0) => [pid, status] - * Process.waitpid2(pid=-1, flags=0) => [pid, status] + * 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 @@ -775,19 +814,17 @@ proc_wait(argc, argv) */ static VALUE -proc_wait2(argc, argv) - int argc; - VALUE *argv; +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); + return rb_assoc_new(pid, rb_last_status_get()); } /* * call-seq: - * Process.waitall => [ [pid1,status1], ...] + * Process.waitall -> [ [pid1,status1], ...] * * Waits for all children, returning an array of * _pid_/_status_ pairs (where _status_ is a @@ -806,10 +843,11 @@ proc_wait2(argc, argv) */ static VALUE -proc_waitall() +proc_waitall(void) { VALUE result; - int pid, status; + rb_pid_t pid; + int status; rb_secure(2); result = rb_ary_new(); @@ -817,60 +855,74 @@ proc_waitall() 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); } - last_status_set(status, pid); - rb_ary_push(result, rb_assoc_new(INT2NUM(pid), rb_last_status)); - } -#else - rb_last_status = Qnil; - for (pid = -1;;) { - pid = rb_waitpid(-1, &status, 0); - if (pid == -1) { - if (errno == ECHILD) - break; - rb_sys_fail(0); - } - rb_ary_push(result, rb_assoc_new(INT2NUM(pid), rb_last_status)); - } +#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 inline ID +id_pid(void) +{ + ID pid; + CONST_ID(pid, "pid"); + return pid; +} + static VALUE -detach_process_watcher(pid_p) - int *pid_p; +detach_process_pid(VALUE thread) { - int cpid, status; + return rb_thread_local_aref(thread, id_pid()); +} - for (;;) { - cpid = rb_waitpid(*pid_p, &status, WNOHANG); - if (cpid != 0) return Qnil; - rb_thread_sleep(1); +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(pid) - int pid; +rb_detach_process(rb_pid_t pid) { - return rb_thread_create(detach_process_watcher, (void*)&pid); + VALUE watcher = rb_thread_create(detach_process_watcher, (void*)(VALUE)pid); + rb_thread_local_aset(watcher, id_pid(), PIDT2NUM(pid)); + rb_define_singleton_method(watcher, "pid", detach_process_pid, 0); + return watcher; } /* * call-seq: - * Process.detach(pid) => thread + * Process.detach(pid) -> thread * * Some operating systems retain the status of terminated child * processes until the parent collects that status (normally using @@ -880,8 +932,14 @@ rb_detach_process(pid) * 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. <code>detach</code> only checks the status - * periodically (currently once each second). + * 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. @@ -913,26 +971,30 @@ static VALUE proc_detach(VALUE obj, VALUE pid) { rb_secure(2); - return rb_detach_process(NUM2INT(pid)); + return rb_detach_process(NUM2PIDT(pid)); } #ifndef HAVE_STRING_H char *strtok(); #endif -#ifdef HAVE_SETITIMER -#define before_exec() rb_thread_stop_timer() -#define after_exec() rb_thread_start_timer() -#else -#define before_exec() -#define after_exec() -#endif +void rb_thread_stop_timer_thread(void); +void rb_thread_start_timer_thread(void); +void rb_thread_reset_timer_thread(void); + +static int forked_child = 0; -extern char *dln_find_exe(); +#define before_exec() \ + (rb_enable_interrupt(), (forked_child ? 0 : (rb_thread_stop_timer_thread(), 1))) +#define after_exec() \ + (rb_thread_reset_timer_thread(), rb_thread_start_timer_thread(), forked_child = 0, rb_disable_interrupt()) +#define before_fork() before_exec() +#define after_fork() (GET_THREAD()->thrown_errinfo = 0, after_exec()) + +#include "dln.h" static void -security(str) - char *str; +security(const char *str) { if (rb_env_path_tainted()) { if (rb_safe_level() > 0) { @@ -942,31 +1004,24 @@ security(str) } static int -proc_exec_v(argv, prog) - char **argv; - char *prog; +proc_exec_v(char **argv, const char *prog) { + char fbuf[MAXPATHLEN]; + if (!prog) prog = argv[0]; - security(prog); - prog = dln_find_exe(prog, 0); - if (!prog) + prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf)); + if (!prog) { + errno = ENOENT; return -1; + } -#if (defined(MSDOS) && !defined(DJGPP)) || defined(__human68k__) || defined(__EMX__) || defined(OS2) +#if defined(__EMX__) || defined(OS2) { -#if defined(__human68k__) -#define COMMAND "command.x" -#endif -#if defined(__EMX__) || defined(OS2) /* OS/2 emx */ #define COMMAND "cmd.exe" -#endif -#if (defined(MSDOS) && !defined(DJGPP)) -#define COMMAND "command.com" -#endif char *extension; - if ((extension = strrchr(prog, '.')) != NULL && strcasecmp(extension, ".bat") == 0) { + if ((extension = strrchr(prog, '.')) != NULL && STRCASECMP(extension, ".bat") == 0) { char **new_argv; char *p; int n; @@ -982,37 +1037,29 @@ proc_exec_v(argv, prog) *p = '\\'; new_argv[0] = COMMAND; argv = new_argv; - prog = dln_find_exe(argv[0], 0); + prog = dln_find_exe_r(argv[0], 0, fbuf, sizeof(fbuf)); if (!prog) { errno = ENOENT; return -1; } } } -#endif /* MSDOS or __human68k__ or __EMX__ */ +#endif /* __EMX__ */ before_exec(); execv(prog, argv); preserving_errno(after_exec()); return -1; } -static int -proc_exec_n(argc, argv, progv) - int argc; - VALUE *argv; - VALUE progv; +int +rb_proc_exec_n(int argc, VALUE *argv, const char *prog) { - char *prog = 0; char **args; int i; - if (progv) { - prog = RSTRING(progv)->ptr; - } args = ALLOCA_N(char*, argc+1); for (i=0; i<argc; i++) { - SafeStringValue(argv[i]); - args[i] = RSTRING(argv[i])->ptr; + args[i] = RSTRING_PTR(argv[i]); } args[i] = 0; if (args[0]) { @@ -1022,33 +1069,35 @@ proc_exec_n(argc, argv, progv) } int -rb_proc_exec(str) - const char *str; +rb_proc_exec(const char *str) { +#ifndef _WIN32 const char *s = str; char *ss, *t; char **argv, **a; +#endif while (*str && ISSPACE(*str)) str++; #ifdef _WIN32 before_exec(); - do_spawn(P_OVERLAY, (char *)str); + rb_w32_spawn(P_OVERLAY, (char *)str, 0); after_exec(); #else for (s=str; *s; s++) { + if (ISSPACE(*s)) { + const char *p, *nl = NULL; + for (p = s; ISSPACE(*p); p++) { + if (*p == '\n') nl = p; + } + if (!*p) break; + if (nl) s = nl; + } if (*s != ' ' && !ISALPHA(*s) && strchr("*?{}[]<>()~&|\\$;'`\"\n",*s)) { -#if defined(MSDOS) - int status; - before_exec(); - status = system(str); - after_exec(); - if (status != -1) - exit(status); -#else -#if defined(__human68k__) || defined(__CYGWIN32__) || defined(__EMX__) - char *shell = dln_find_exe("sh", 0); +#if defined(__CYGWIN32__) || defined(__EMX__) + char fbuf[MAXPATHLEN]; + char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf)); int status = -1; before_exec(); if (shell) @@ -1063,15 +1112,15 @@ rb_proc_exec(str) execl("/bin/sh", "sh", "-c", str, (char *)NULL); preserving_errno(after_exec()); #endif -#endif return -1; } } a = argv = ALLOCA_N(char*, (s-str)/2+2); ss = ALLOCA_N(char, s-str+1); - strcpy(ss, str); - if (*a++ = strtok(ss, " \t")) { - while (t = strtok(NULL, " \t")) { + memcpy(ss, str, s-str); + ss[s-str] = '\0'; + if ((*a++ = strtok(ss, " \t")) != 0) { + while ((t = strtok(NULL, " \t")) != 0) { *a++ = t; } *a = NULL; @@ -1084,95 +1133,68 @@ rb_proc_exec(str) return -1; } -#if defined(__human68k__) || defined(__DJGPP__) || defined(_WIN32) -static int -proc_spawn_v(argv, prog) - char **argv; - char *prog; +#if defined(_WIN32) +#define HAVE_SPAWNV 1 +#endif + +#if !defined(HAVE_FORK) && defined(HAVE_SPAWNV) +#if defined(_WIN32) +#define proc_spawn_v(argv, prog) rb_w32_aspawn(P_NOWAIT, prog, argv) +#else +static rb_pid_t +proc_spawn_v(char **argv, char *prog) { - char *extension; - int status; + char fbuf[MAXPATHLEN]; + rb_pid_t status; if (!prog) prog = argv[0]; security(prog); - prog = dln_find_exe(prog, 0); + prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf)); if (!prog) return -1; -#if defined(__human68k__) - if ((extension = strrchr(prog, '.')) != NULL && strcasecmp(extension, ".bat") == 0) { - char **new_argv; - char *p; - int n; - - for (n = 0; argv[n]; n++) - /* no-op */; - new_argv = ALLOCA_N(char*, n + 2); - for (; n > 0; n--) - new_argv[n + 1] = argv[n]; - new_argv[1] = strcpy(ALLOCA_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(argv[0], 0); - if (!prog) { - errno = ENOENT; - return -1; - } - } -#endif before_exec(); -#if defined(_WIN32) - status = do_aspawn(P_WAIT, prog, argv); -#else status = spawnv(P_WAIT, prog, argv); -#endif + rb_last_status_set(status == -1 ? 127 : status, 0); after_exec(); return status; } +#endif -static int -proc_spawn_n(argc, argv, prog) - int argc; - VALUE *argv; - VALUE prog; +static rb_pid_t +proc_spawn_n(int argc, VALUE *argv, VALUE prog) { char **args; int i; args = ALLOCA_N(char*, argc + 1); for (i = 0; i < argc; i++) { - SafeStringValue(argv[i]); - args[i] = RSTRING(argv[i])->ptr; + args[i] = RSTRING_PTR(argv[i]); } - if (prog) - SafeStringValue(prog); args[i] = (char*) 0; if (args[0]) - return proc_spawn_v(args, prog ? RSTRING(prog)->ptr : 0); + return proc_spawn_v(args, prog ? RSTRING_PTR(prog) : 0); return -1; } -#if !defined(_WIN32) -static int -proc_spawn(sv) - VALUE sv; +#if defined(_WIN32) +#define proc_spawn(str) rb_w32_spawn(P_NOWAIT, str, 0) +#else +static rb_pid_t +proc_spawn(char *str) { - char *str; + char fbuf[MAXPATHLEN]; char *s, *t; char **argv, **a; - int status; + rb_pid_t status; - SafeStringValue(sv); - str = s = RSTRING(sv)->ptr; for (s = str; *s; s++) { if (*s != ' ' && !ISALPHA(*s) && strchr("*?{}[]<>()~&|\\$;'`\"\n",*s)) { - char *shell = dln_find_exe("sh", 0); + char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf)); before_exec(); status = shell?spawnl(P_WAIT,shell,"sh","-c",str,(char*)NULL):system(str); + rb_last_status_set(status == -1 ? 127 : status, 0); after_exec(); return status; } @@ -1190,22 +1212,551 @@ proc_spawn(sv) #endif #endif +static VALUE +hide_obj(VALUE obj) +{ + RBASIC(obj)->klass = 0; + return obj; +} + +enum { + EXEC_OPTION_PGROUP, + EXEC_OPTION_RLIMIT, + EXEC_OPTION_UNSETENV_OTHERS, + EXEC_OPTION_ENV, + EXEC_OPTION_CHDIR, + EXEC_OPTION_UMASK, + EXEC_OPTION_DUP2, + EXEC_OPTION_CLOSE, + EXEC_OPTION_OPEN, + EXEC_OPTION_DUP2_CHILD, + EXEC_OPTION_CLOSE_OTHERS +}; + +static VALUE +check_exec_redirect_fd(VALUE v) +{ + VALUE tmp; + int fd; + if (FIXNUM_P(v)) { + fd = FIX2INT(v); + } + else if (SYMBOL_P(v)) { + ID id = SYM2ID(v); + if (id == rb_intern("in")) + fd = 0; + else if (id == rb_intern("out")) + fd = 1; + else if (id == rb_intern("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 { + rb_raise(rb_eArgError, "wrong exec redirect"); + } + if (fd < 0) { + wrong: + rb_raise(rb_eArgError, "negative file descriptor"); + } + return INT2FIX(fd); +} + +static void +check_exec_redirect(VALUE key, VALUE val, VALUE options) +{ + int index; + VALUE ary, param; + VALUE path, flags, perm; + ID id; + + switch (TYPE(val)) { + case T_SYMBOL: + id = SYM2ID(val); + if (id == rb_intern("close")) { + index = EXEC_OPTION_CLOSE; + param = Qnil; + } + else if (id == rb_intern("in")) { + index = EXEC_OPTION_DUP2; + param = INT2FIX(0); + } + else if (id == rb_intern("out")) { + index = EXEC_OPTION_DUP2; + param = INT2FIX(1); + } + else if (id == rb_intern("err")) { + index = EXEC_OPTION_DUP2; + param = INT2FIX(2); + } + else { + rb_raise(rb_eArgError, "wrong exec redirect symbol: %s", + rb_id2name(id)); + } + break; + + case T_FILE: + val = check_exec_redirect_fd(val); + /* fall through */ + case T_FIXNUM: + index = EXEC_OPTION_DUP2; + param = val; + break; + + case T_ARRAY: + path = rb_ary_entry(val, 0); + if (RARRAY_LEN(val) == 2 && SYMBOL_P(path) && + SYM2ID(path) == rb_intern("child")) { + index = EXEC_OPTION_DUP2_CHILD; + param = check_exec_redirect_fd(rb_ary_entry(val, 1)); + } + else { + index = EXEC_OPTION_OPEN; + FilePathValue(path); + flags = rb_ary_entry(val, 1); + if (NIL_P(flags)) + flags = INT2NUM(O_RDONLY); + else if (TYPE(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(rb_str_dup(path)), + flags, perm)); + } + break; + + case T_STRING: + index = EXEC_OPTION_OPEN; + path = val; + FilePathValue(path); + if (TYPE(key) == T_FILE) + key = check_exec_redirect_fd(key); + if (FIXNUM_P(key) && (FIX2INT(key) == 1 || FIX2INT(key) == 2)) + flags = INT2NUM(O_WRONLY|O_CREAT|O_TRUNC); + else + flags = INT2NUM(O_RDONLY); + perm = INT2FIX(0644); + param = hide_obj(rb_ary_new3(3, hide_obj(rb_str_dup(path)), + flags, perm)); + break; + + default: + rb_raise(rb_eArgError, "wrong exec redirect action"); + } + + ary = rb_ary_entry(options, index); + if (NIL_P(ary)) { + ary = hide_obj(rb_ary_new()); + rb_ary_store(options, index, ary); + } + if (TYPE(key) != T_ARRAY) { + VALUE fd = check_exec_redirect_fd(key); + 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_PTR(key)[i]; + VALUE fd = check_exec_redirect_fd(v); + rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param))); + n++; + } + } +} + +#ifdef RLIM2NUM +static int rlimit_type_by_lname(const char *name); +#endif + +int +rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val) +{ + VALUE options = e->options; + ID id; +#ifdef RLIM2NUM + int rtype; +#endif + + rb_secure(2); + + switch (TYPE(key)) { + case T_SYMBOL: + id = SYM2ID(key); +#ifdef HAVE_SETPGID + if (id == rb_intern("pgroup")) { + if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_PGROUP))) { + rb_raise(rb_eArgError, "pgroup option specified twice"); + } + if (!RTEST(val)) + val = Qfalse; + else if (val == Qtrue) + val = INT2FIX(0); + else { + pid_t pgroup = NUM2PIDT(val); + if (pgroup < 0) { + rb_raise(rb_eArgError, "negative process group ID : %ld", (long)pgroup); + } + val = PIDT2NUM(pgroup); + } + rb_ary_store(options, EXEC_OPTION_PGROUP, val); + } + else +#endif +#ifdef RLIM2NUM + if (strncmp("rlimit_", rb_id2name(id), 7) == 0 && + (rtype = rlimit_type_by_lname(rb_id2name(id)+7)) != -1) { + VALUE ary = rb_ary_entry(options, EXEC_OPTION_RLIMIT); + VALUE tmp, softlim, hardlim; + if (NIL_P(ary)) { + ary = hide_obj(rb_ary_new()); + rb_ary_store(options, EXEC_OPTION_RLIMIT, ary); + } + 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 == rb_intern("unsetenv_others")) { + if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_UNSETENV_OTHERS))) { + rb_raise(rb_eArgError, "unsetenv_others option specified twice"); + } + val = RTEST(val) ? Qtrue : Qfalse; + rb_ary_store(options, EXEC_OPTION_UNSETENV_OTHERS, val); + } + else if (id == rb_intern("chdir")) { + if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_CHDIR))) { + rb_raise(rb_eArgError, "chdir option specified twice"); + } + FilePathValue(val); + rb_ary_store(options, EXEC_OPTION_CHDIR, + hide_obj(rb_str_dup(val))); + } + else if (id == rb_intern("umask")) { + mode_t cmask = NUM2LONG(val); + if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_UMASK))) { + rb_raise(rb_eArgError, "umask option specified twice"); + } + rb_ary_store(options, EXEC_OPTION_UMASK, LONG2NUM(cmask)); + } + else if (id == rb_intern("close_others")) { + if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS))) { + rb_raise(rb_eArgError, "close_others option specified twice"); + } + val = RTEST(val) ? Qtrue : Qfalse; + rb_ary_store(options, EXEC_OPTION_CLOSE_OTHERS, val); + } + else if (id == rb_intern("in")) { + key = INT2FIX(0); + goto redirect; + } + else if (id == rb_intern("out")) { + key = INT2FIX(1); + goto redirect; + } + else if (id == rb_intern("err")) { + key = INT2FIX(2); + goto redirect; + } + else { + rb_raise(rb_eArgError, "wrong exec option symbol: %s", + rb_id2name(id)); + } + break; + + case T_FIXNUM: + case T_FILE: + case T_ARRAY: +redirect: + check_exec_redirect(key, val, options); + break; + + default: + rb_raise(rb_eArgError, "wrong exec option"); + } + + 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; + struct rb_exec_arg *e = (struct rb_exec_arg *)arg; + return rb_exec_arg_addopt(e, key, val); +} + +static VALUE +check_exec_fds(VALUE options) +{ + VALUE h = rb_hash_new(); + VALUE ary; + int index, i; + int maxhint = -1; + + for (index = EXEC_OPTION_DUP2; index <= EXEC_OPTION_DUP2_CHILD; index++) { + ary = rb_ary_entry(options, index); + if (NIL_P(ary)) + continue; + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_PTR(ary)[i]; + int fd = FIX2INT(RARRAY_PTR(elt)[0]); + if (RTEST(rb_hash_lookup(h, INT2FIX(fd)))) { + rb_raise(rb_eArgError, "fd %d specified twice", fd); + } + if (index == EXEC_OPTION_OPEN || index == EXEC_OPTION_DUP2) + rb_hash_aset(h, INT2FIX(fd), Qtrue); + else if (index == EXEC_OPTION_DUP2_CHILD) + rb_hash_aset(h, INT2FIX(fd), RARRAY_PTR(elt)[1]); + else /* index == EXEC_OPTION_CLOSE */ + rb_hash_aset(h, INT2FIX(fd), INT2FIX(-1)); + if (maxhint < fd) + maxhint = fd; + if (index == EXEC_OPTION_DUP2 || index == EXEC_OPTION_DUP2_CHILD) { + fd = FIX2INT(RARRAY_PTR(elt)[1]); + if (maxhint < fd) + maxhint = fd; + } + } + } + + ary = rb_ary_entry(options, EXEC_OPTION_DUP2_CHILD); + if (!NIL_P(ary)) { + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_PTR(ary)[i]; + int newfd = FIX2INT(RARRAY_PTR(elt)[0]); + int oldfd = FIX2INT(RARRAY_PTR(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; + } + } + } + } + + if (rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS) != Qfalse) { + rb_ary_store(options, EXEC_OPTION_CLOSE_OTHERS, INT2FIX(maxhint)); + } + return h; +} + +static void +rb_check_exec_options(VALUE opthash, struct rb_exec_arg *e) +{ + if (RHASH_EMPTY_P(opthash)) + return; + st_foreach(RHASH_TBL(opthash), check_exec_options_i, (st_data_t)e); +} + +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); + + 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(RHASH_TBL(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; + + if (argc == 0) { + rb_raise(rb_eArgError, "wrong number of 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_PTR(tmp)[0]; + argv[0] = RARRAY_PTR(tmp)[1]; + SafeStringValue(prog); + StringValueCStr(prog); + prog = rb_str_new4(prog); + name = RSTRING_PTR(prog); + } + for (i = 0; i < argc; i++) { + SafeStringValue(argv[i]); + argv[i] = rb_str_new4(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, struct rb_exec_arg *e) +{ + VALUE hash, prog; + + if (0 < *argc_p) { + hash = rb_check_convert_type((*argv_p)[*argc_p-1], T_HASH, "Hash", "to_hash"); + if (!NIL_P(hash)) { + *opthash_ret = hash; + (*argc_p)--; + } + } + + if (0 < *argc_p) { + hash = rb_check_convert_type((*argv_p)[0], T_HASH, "Hash", "to_hash"); + 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; +} + +static void +rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, struct rb_exec_arg *e) +{ + VALUE options; + MEMZERO(e, struct rb_exec_arg, 1); + options = hide_obj(rb_ary_new()); + e->options = options; + + if (!NIL_P(opthash)) { + rb_check_exec_options(opthash, e); + } + if (!NIL_P(env)) { + env = rb_check_exec_env(env); + rb_ary_store(options, EXEC_OPTION_ENV, env); + } + + e->argc = argc; + e->argv = argv; + e->prog = prog ? RSTRING_PTR(prog) : 0; +} + +VALUE +rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e) +{ + VALUE prog; + VALUE env = Qnil, opthash = Qnil; + prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash, e); + rb_exec_fillarg(prog, argc, argv, env, opthash, e); + return prog; +} + +void +rb_exec_arg_fixup(struct rb_exec_arg *e) +{ + e->redirect_fds = check_exec_fds(e->options); +} + /* * call-seq: - * exec(command [, arg, ...]) + * exec([env,] command... [,options]) * * Replaces the current process by running the given external _command_. - * If +exec+ is given a single argument, that argument is - * taken as a line that is subject to shell expansion before being - * executed. If multiple arguments are given, the second and subsequent - * arguments are passed as parameters to _command_ with no shell - * expansion. If the first argument is a two-element array, 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 MSDOS environments, the command is executed in a - * subshell; otherwise, one of the <code>exec(2)</code> system calls is - * used, so the running command may inherit some of the environment of - * the original program (including open file descriptors). + * _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) + * + * If single string is given as the command, + * it is taken as a command line that is subject to shell expansion before being executed. + * + * The standard shell means always <code>"/bin/sh"</code> on Unix-like systems, + * <code>ENV["RUBYSHELL"]</code> or <code>ENV["COMSPEC"]</code> on Windows NT series, and + * similar. + * + * If two or more +string+ given, + * the first is taken as a command name and + * the rest are passed as parameters to command with no shell expansion. + * + * If 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 is used, so the running command may inherit some of the environment + * of the original program (including open file descriptors). + * This behavior is modified by env and options. + * See <code>spawn</code> for details. + * + * Raises SystemCallError if the command couldn't execute (typically + * <code>Errno::ENOENT</code> when it was not found). * * exec "echo *" # echoes list of files in current directory * # never get here @@ -1216,44 +1767,831 @@ proc_spawn(sv) */ VALUE -rb_f_exec(argc, argv) - int argc; - VALUE *argv; +rb_f_exec(int argc, VALUE *argv) { - VALUE prog = 0; - VALUE tmp; + struct rb_exec_arg earg; +#define CHILD_ERRMSG_BUFLEN 80 + char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; + + rb_exec_arg_init(argc, argv, TRUE, &earg); + if (NIL_P(rb_ary_entry(earg.options, EXEC_OPTION_CLOSE_OTHERS))) + rb_exec_arg_addopt(&earg, ID2SYM(rb_intern("close_others")), Qfalse); + rb_exec_arg_fixup(&earg); + + rb_exec_err(&earg, errmsg, sizeof(errmsg)); + if (errmsg[0]) + rb_sys_fail(errmsg); + rb_sys_fail(earg.prog); + 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, VALUE save, char *errmsg, size_t errmsg_buflen) +{ + if (!NIL_P(save)) { + VALUE newary; + int save_fd = redirect_dup(fd); + if (save_fd == -1) { + if (errno == EBADF) + return 0; + ERRMSG("dup"); + return -1; + } + newary = rb_ary_entry(save, EXEC_OPTION_DUP2); + if (NIL_P(newary)) { + newary = hide_obj(rb_ary_new()); + rb_ary_store(save, EXEC_OPTION_DUP2, newary); + } + rb_ary_push(newary, + hide_obj(rb_assoc_new(INT2FIX(fd), INT2FIX(save_fd)))); + + newary = rb_ary_entry(save, EXEC_OPTION_CLOSE); + if (NIL_P(newary)) { + newary = hide_obj(rb_ary_new()); + rb_ary_store(save, EXEC_OPTION_CLOSE, newary); + } + rb_ary_push(newary, hide_obj(rb_assoc_new(INT2FIX(save_fd), Qnil))); + } + + return 0; +} + +static VALUE +save_env_i(VALUE i, VALUE ary, int argc, VALUE *argv) +{ + rb_ary_push(ary, hide_obj(rb_ary_dup(argv[0]))); + return Qnil; +} + +static void +save_env(VALUE save) +{ + if (!NIL_P(save) && NIL_P(rb_ary_entry(save, EXEC_OPTION_ENV))) { + VALUE env = rb_const_get(rb_cObject, rb_intern("ENV")); + if (RTEST(env)) { + VALUE ary = hide_obj(rb_ary_new()); + rb_block_call(env, rb_intern("each"), 0, 0, save_env_i, + (VALUE)ary); + rb_ary_store(save, EXEC_OPTION_ENV, ary); + } + rb_ary_store(save, EXEC_OPTION_UNSETENV_OTHERS, Qtrue); + } +} + +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; +} + +static int +run_exec_dup2(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen) +{ + long n, i; + int ret; + int extra_fd = -1; + struct fd_pair { + int oldfd; + int newfd; + long older_index; + long num_newer; + } *pairs = 0; + + n = RARRAY_LEN(ary); + pairs = (struct fd_pair *)malloc(sizeof(struct fd_pair) * n); + if (pairs == NULL) { + ERRMSG("malloc"); + return -1; + } + + /* initialize oldfd and newfd: O(n) */ + for (i = 0; i < n; i++) { + VALUE elt = RARRAY_PTR(ary)[i]; + pairs[i].oldfd = FIX2INT(RARRAY_PTR(elt)[1]); + pairs[i].newfd = FIX2INT(RARRAY_PTR(elt)[0]); /* unique */ + pairs[i].older_index = -1; + } + + /* sort the table by oldfd: O(n log n) */ + if (!RTEST(save)) + qsort(pairs, n, sizeof(struct fd_pair), intcmp); + else + qsort(pairs, n, sizeof(struct 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 fd_pair key, *found; + key.oldfd = newfd; + found = bsearch(&key, pairs, n, sizeof(struct fd_pair), intcmp); + 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, save, errmsg, errmsg_buflen) < 0) + goto fail; + ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd); + if (ret == -1) { + ERRMSG("dup2"); + goto fail; + } + 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); + if (ret == -1) { + ERRMSG("fcntl(F_GETFD)"); + goto fail; + } + if (ret & FD_CLOEXEC) { + ret &= ~FD_CLOEXEC; + ret = fcntl(fd, F_SETFD, ret); + 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); + if (extra_fd == -1) { + ERRMSG("dup"); + goto fail; + } + } + else { + ret = redirect_dup2(pairs[i].oldfd, extra_fd); + if (ret == -1) { + ERRMSG("dup2"); + goto fail; + } + } + 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); + if (ret == -1) { + ERRMSG("dup2"); + goto fail; + } + pairs[j].oldfd = -1; + j = pairs[j].older_index; + } + } + if (extra_fd != -1) { + ret = redirect_close(extra_fd); + if (ret == -1) { + ERRMSG("close"); + goto fail; + } + } + + xfree(pairs); + return 0; + + fail: + xfree(pairs); + return -1; +} + +static int +run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen) +{ + int i, ret; + + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_PTR(ary)[i]; + int fd = FIX2INT(RARRAY_PTR(elt)[0]); + ret = redirect_close(fd); + if (ret == -1) { + ERRMSG("close"); + return -1; + } + } + return 0; +} + +static int +run_exec_open(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen) +{ + int i, ret; + + for (i = 0; i < RARRAY_LEN(ary);) { + VALUE elt = RARRAY_PTR(ary)[i]; + int fd = FIX2INT(RARRAY_PTR(elt)[0]); + VALUE param = RARRAY_PTR(elt)[1]; + char *path = RSTRING_PTR(RARRAY_PTR(param)[0]); + int flags = NUM2INT(RARRAY_PTR(param)[1]); + int perm = NUM2INT(RARRAY_PTR(param)[2]); + int need_close = 1; + int fd2 = redirect_open(path, flags, perm); + if (fd2 == -1) { + ERRMSG("open"); + return -1; + } + while (i < RARRAY_LEN(ary) && + (elt = RARRAY_PTR(ary)[i], RARRAY_PTR(elt)[1] == param)) { + fd = FIX2INT(RARRAY_PTR(elt)[0]); + if (fd == fd2) { + need_close = 0; + } + else { + if (save_redirect_fd(fd, save, errmsg, errmsg_buflen) < 0) + return -1; + ret = redirect_dup2(fd2, fd); + if (ret == -1) { + ERRMSG("dup2"); + return -1; + } + } + i++; + } + if (need_close) { + ret = redirect_close(fd2); + if (ret == -1) { + ERRMSG("close"); + return -1; + } + } + } + return 0; +} + +static int +run_exec_dup2_child(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen) +{ + int i, ret; + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_PTR(ary)[i]; + int newfd = FIX2INT(RARRAY_PTR(elt)[0]); + int oldfd = FIX2INT(RARRAY_PTR(elt)[1]); + + if (save_redirect_fd(newfd, save, errmsg, errmsg_buflen) < 0) + return -1; + ret = redirect_dup2(oldfd, newfd); + if (ret == -1) { + ERRMSG("dup2"); + return -1; + } + } + return 0; +} + +#ifdef HAVE_SETPGID +static int +run_exec_pgroup(VALUE obj, VALUE save, char *errmsg, size_t errmsg_buflen) +{ + /* + * If FD_CLOEXEC is available, rb_fork waits the child's execve. + * So setpgid is done in the child when rb_fork is returned in the parent. + * No race condition, even without setpgid from the parent. + * (Is there an environment which has setpgid but FD_CLOEXEC?) + */ + int ret; + pid_t pgroup; + if (!NIL_P(save)) { + /* maybe meaningless with no fork environment... */ + rb_ary_store(save, EXEC_OPTION_PGROUP, PIDT2NUM(getpgrp())); + } + pgroup = NUM2PIDT(obj); + if (pgroup == 0) { + pgroup = getpid(); + } + ret = setpgid(getpid(), pgroup); + if (ret == -1) ERRMSG("setpgid"); + return ret; +} +#endif + +#ifdef RLIM2NUM +static int +run_exec_rlimit(VALUE ary, VALUE save, char *errmsg, size_t errmsg_buflen) +{ + int i; + for (i = 0; i < RARRAY_LEN(ary); i++) { + VALUE elt = RARRAY_PTR(ary)[i]; + int rtype = NUM2INT(RARRAY_PTR(elt)[0]); + struct rlimit rlim; + if (!NIL_P(save)) { + VALUE tmp, newary; + if (getrlimit(rtype, &rlim) == -1) { + ERRMSG("getrlimit"); + return -1; + } + tmp = hide_obj(rb_ary_new3(3, RARRAY_PTR(elt)[0], + RLIM2NUM(rlim.rlim_cur), + RLIM2NUM(rlim.rlim_max))); + newary = rb_ary_entry(save, EXEC_OPTION_RLIMIT); + if (NIL_P(newary)) { + newary = hide_obj(rb_ary_new()); + rb_ary_store(save, EXEC_OPTION_RLIMIT, newary); + } + rb_ary_push(newary, tmp); + } + rlim.rlim_cur = NUM2RLIM(RARRAY_PTR(elt)[1]); + rlim.rlim_max = NUM2RLIM(RARRAY_PTR(elt)[2]); + if (setrlimit(rtype, &rlim) == -1) { + ERRMSG("setrlimit"); + return -1; + } + } + return 0; +} +#endif + +int +rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char *errmsg, size_t errmsg_buflen) +{ + VALUE options = e->options; + VALUE soptions = Qnil; + VALUE obj; + + if (!RTEST(options)) + return 0; + + if (s) { + s->argc = 0; + s->argv = NULL; + s->prog = NULL; + s->options = soptions = hide_obj(rb_ary_new()); + s->redirect_fds = Qnil; + } + +#ifdef HAVE_SETPGID + obj = rb_ary_entry(options, EXEC_OPTION_PGROUP); + if (RTEST(obj)) { + if (run_exec_pgroup(obj, soptions, errmsg, errmsg_buflen) == -1) + return -1; + } +#endif + +#ifdef RLIM2NUM + obj = rb_ary_entry(options, EXEC_OPTION_RLIMIT); + if (!NIL_P(obj)) { + if (run_exec_rlimit(obj, soptions, errmsg, errmsg_buflen) == -1) + return -1; + } +#endif + + obj = rb_ary_entry(options, EXEC_OPTION_UNSETENV_OTHERS); + if (RTEST(obj)) { + save_env(soptions); + rb_env_clear(); + } + + obj = rb_ary_entry(options, EXEC_OPTION_ENV); + if (!NIL_P(obj)) { + int i; + save_env(soptions); + for (i = 0; i < RARRAY_LEN(obj); i++) { + VALUE pair = RARRAY_PTR(obj)[i]; + VALUE key = RARRAY_PTR(pair)[0]; + VALUE val = RARRAY_PTR(pair)[1]; + if (NIL_P(val)) + ruby_setenv(StringValueCStr(key), 0); + else + ruby_setenv(StringValueCStr(key), StringValueCStr(val)); + } + } + + obj = rb_ary_entry(options, EXEC_OPTION_CHDIR); + if (!NIL_P(obj)) { + if (!NIL_P(soptions)) { + char *cwd = my_getcwd(); + rb_ary_store(soptions, EXEC_OPTION_CHDIR, + hide_obj(rb_str_new2(cwd))); + xfree(cwd); + } + if (chdir(RSTRING_PTR(obj)) == -1) { + ERRMSG("chdir"); + return -1; + } + } + + obj = rb_ary_entry(options, EXEC_OPTION_UMASK); + if (!NIL_P(obj)) { + mode_t mask = NUM2LONG(obj); + mode_t oldmask = umask(mask); /* never fail */ + if (!NIL_P(soptions)) + rb_ary_store(soptions, EXEC_OPTION_UMASK, LONG2NUM(oldmask)); + } + + obj = rb_ary_entry(options, EXEC_OPTION_DUP2); + if (!NIL_P(obj)) { + if (run_exec_dup2(obj, soptions, errmsg, errmsg_buflen) == -1) + return -1; + } + + obj = rb_ary_entry(options, EXEC_OPTION_CLOSE); + if (!NIL_P(obj)) { + if (!NIL_P(soptions)) + rb_warn("cannot close fd before spawn"); + else { + if (run_exec_close(obj, errmsg, errmsg_buflen) == -1) + return -1; + } + } + +#ifdef HAVE_FORK + obj = rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS); + if (obj != Qfalse) { + rb_close_before_exec(3, FIX2INT(obj), e->redirect_fds); + } +#endif + + obj = rb_ary_entry(options, EXEC_OPTION_OPEN); + if (!NIL_P(obj)) { + if (run_exec_open(obj, soptions, errmsg, errmsg_buflen) == -1) + return -1; + } + + obj = rb_ary_entry(options, EXEC_OPTION_DUP2_CHILD); + if (!NIL_P(obj)) { + if (run_exec_dup2_child(obj, soptions, errmsg, errmsg_buflen) == -1) + return -1; + } + + return 0; +} + +int +rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s) +{ + return rb_run_exec_options_err(e, s, NULL, 0); +} + +int +rb_exec_err(const struct rb_exec_arg *e, char *errmsg, size_t errmsg_buflen) +{ + int argc = e->argc; + VALUE *argv = e->argv; + const char *prog = e->prog; + + if (rb_run_exec_options_err(e, NULL, errmsg, errmsg_buflen) < 0) { + return -1; + } if (argc == 0) { - rb_raise(rb_eArgError, "wrong number of arguments"); + rb_proc_exec(prog); + } + else { + rb_proc_exec_n(argc, argv, prog); } + return -1; +} - tmp = rb_check_array_type(argv[0]); - if (!NIL_P(tmp)) { - if (RARRAY(tmp)->len != 2) { - rb_raise(rb_eArgError, "wrong first argument"); +int +rb_exec(const struct rb_exec_arg *e) +{ +#if !defined FD_CLOEXEC && !defined HAVE_SPAWNV + char errmsg[80] = { '\0' }; + int ret = rb_exec_err(e, errmsg, sizeof(errmsg)); + preserving_errno( + if (errmsg[0]) { + fprintf(stderr, "%s\n", errmsg); } - prog = RARRAY(tmp)->ptr[0]; - argv[0] = RARRAY(tmp)->ptr[1]; - SafeStringValue(prog); + else { + fprintf(stderr, "%s:%d: command not found: %s\n", + rb_sourcefile(), rb_sourceline(), e->prog); + } + ); + return ret; +#else + return rb_exec_err(e, NULL, 0); +#endif +} + +#ifdef HAVE_FORK +static int +rb_exec_atfork(void* arg, char *errmsg, size_t errmsg_buflen) +{ + rb_thread_atfork_before_exec(); + return rb_exec_err(arg, errmsg, errmsg_buflen); +} +#endif + +#ifdef HAVE_FORK +#ifdef FD_CLOEXEC +#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 +#endif + +static int +move_fds_to_avoid_crash(int *fdp, int n, VALUE fds) +{ + long 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 = fcntl(fdp[i], F_DUPFD, min); + if (ret == -1) + return -1; + close(fdp[i]); + fdp[i] = ret; + } } - if (argc == 1 && prog == 0) { - VALUE cmd = argv[0]; + 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; +} - SafeStringValue(cmd); - rb_proc_exec(RSTRING(cmd)->ptr); +/* + * 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. + * + * 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. + */ +rb_pid_t +rb_fork_err(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, + char *errmsg, size_t errmsg_buflen) +{ + rb_pid_t pid; + int err, state = 0; +#ifdef FD_CLOEXEC + int ep[2]; +#endif + +#define prefork() ( \ + rb_io_flush(rb_stdout), \ + rb_io_flush(rb_stderr) \ + ) + prefork(); + +#ifdef FD_CLOEXEC + if (chfunc) { + if (pipe_nocrash(ep, fds)) return -1; + if (fcntl(ep[1], F_SETFD, FD_CLOEXEC)) { + preserving_errno((close(ep[0]), close(ep[1]))); + return -1; + } + } +#endif + for (; before_fork(), (pid = fork()) < 0; prefork()) { + after_fork(); + switch (errno) { + case EAGAIN: +#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: +#endif + if (!status && !chfunc) { + rb_thread_sleep(1); + continue; + } + else { + rb_protect((VALUE (*)())rb_thread_sleep, 1, &state); + if (status) *status = state; + if (!state) continue; + } + default: +#ifdef FD_CLOEXEC + if (chfunc) { + preserving_errno((close(ep[0]), close(ep[1]))); + } +#endif + if (state && !status) rb_jump_tag(state); + return -1; + } + } + if (!pid) { + forked_child = 1; + if (chfunc) { +#ifdef FD_CLOEXEC + close(ep[0]); +#endif + if (!(*chfunc)(charg, errmsg, errmsg_buflen)) _exit(EXIT_SUCCESS); +#ifdef FD_CLOEXEC + err = errno; + (void)write(ep[1], &err, sizeof(err)); + if (errmsg && 0 < errmsg_buflen) { + errmsg[errmsg_buflen-1] = '\0'; + (void)write(ep[1], errmsg, strlen(errmsg)); + } +#endif +#if EXIT_SUCCESS == 127 + _exit(EXIT_FAILURE); +#else + _exit(127); +#endif + } + } + after_fork(); +#ifdef FD_CLOEXEC + if (pid && chfunc) { + ssize_t size; + close(ep[1]); + if ((size = read(ep[0], &err, sizeof(err))) < 0) { + err = errno; + } + if (size == sizeof(err) && + errmsg && 0 < errmsg_buflen) { + ssize_t ret; + ret = read(ep[0], errmsg, errmsg_buflen-1); + if (0 <= ret) { + errmsg[ret] = '\0'; + } + } + close(ep[0]); + if (size) { + if (status) { + rb_protect(proc_syswait, (VALUE)pid, status); + } + else { + rb_syswait(pid); + } + errno = err; + return -1; + } + } +#endif + return pid; +} + +struct chfunc_wrapper_t { + int (*chfunc)(void*); + void *arg; +}; + +static int +chfunc_wrapper(void *arg_, char *errmsg, size_t errmsg_buflen) +{ + struct chfunc_wrapper_t *arg = arg_; + return arg->chfunc(arg->arg); +} + +rb_pid_t +rb_fork(int *status, int (*chfunc)(void*), void *charg, VALUE fds) +{ + if (chfunc) { + struct chfunc_wrapper_t warg; + warg.chfunc = chfunc; + warg.arg = charg; + return rb_fork_err(status, chfunc_wrapper, &warg, fds, NULL, 0); } else { - proc_exec_n(argc, argv, prog); + return rb_fork_err(status, NULL, NULL, fds, NULL, 0); } - rb_sys_fail(RSTRING(argv[0])->ptr); - return Qnil; /* dummy */ + } +#endif +#if defined(HAVE_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD) /* * call-seq: - * Kernel.fork [{ block }] => fixnum or nil - * Process.fork [{ block }] => fixnum or nil + * 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 @@ -1269,27 +2607,19 @@ rb_f_exec(argc, argv) * * 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. */ static VALUE -rb_f_fork(obj) - VALUE obj; +rb_f_fork(VALUE obj) { -#if !defined(__human68k__) && !defined(_WIN32) && !defined(__MACOS__) && !defined(__EMX__) && !defined(__VMS) - int pid; + rb_pid_t pid; rb_secure(2); -#ifndef __VMS - fflush(stdout); - fflush(stderr); -#endif - - switch (pid = fork()) { + switch (pid = rb_fork(0, 0, 0, Qnil)) { case 0: -#ifdef linux - after_exec(); -#endif rb_thread_atfork(); if (rb_block_given_p()) { int status; @@ -1304,36 +2634,32 @@ rb_f_fork(obj) return Qnil; default: - return INT2FIX(pid); + return PIDT2NUM(pid); } +} #else - rb_notimplement(); +#define rb_f_fork rb_f_notimplement #endif -} - /* * call-seq: - * Process.exit!(fixnum=-1) + * Process.exit!(status=false) * * Exits the process immediately. No exit handlers are - * run. <em>fixnum</em> is returned to the underlying system as the + * run. <em>status</em> is returned to the underlying system as the * exit status. * - * Process.exit!(0) + * Process.exit!(true) */ static VALUE -rb_f_exit_bang(argc, argv, obj) - int argc; - VALUE *argv; - VALUE obj; +rb_f_exit_bang(int argc, VALUE *argv, VALUE obj) { VALUE status; int istatus; rb_secure(4); - if (rb_scan_args(argc, argv, "01", &status) == 1) { + if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { switch (status) { case Qtrue: istatus = EXIT_SUCCESS; @@ -1354,24 +2680,147 @@ rb_f_exit_bang(argc, argv, obj) return Qnil; /* not reached */ } -#if defined(sun) -#define signal(a,b) sigset(a,b) +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_finalize(); + exit(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, VALUE *argv) +{ + VALUE status; + int istatus; + + rb_secure(4); + if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { + 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; + } + } + else { + istatus = EXIT_SUCCESS; + } + rb_exit(istatus); + return Qnil; /* not reached */ +} + + +/* + * 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, VALUE *argv) +{ + extern void ruby_error_print(void); + + rb_secure(4); + if (argc == 0) { + if (!NIL_P(GET_THREAD()->errinfo)) { + ruby_error_print(); + } + rb_exit(EXIT_FAILURE); + } + else { + VALUE args[2]; + + rb_scan_args(argc, argv, "1", &args[1]); + StringValue(argv[0]); + rb_io_puts(argc, argv, rb_stderr); + args[0] = INT2NUM(EXIT_FAILURE); + rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)); + } + return Qnil; /* not reached */ +} + + +#if defined(POSIX_SIGNAL) +# define signal(a,b) posix_signal(a,b) #endif void -rb_syswait(pid) - int pid; +rb_syswait(rb_pid_t pid) { static int overriding; #ifdef SIGHUP - RETSIGTYPE (*hfunc)_((int)); + RETSIGTYPE (*hfunc)(int) = 0; #endif #ifdef SIGQUIT - RETSIGTYPE (*qfunc)_((int)); + RETSIGTYPE (*qfunc)(int) = 0; #endif - RETSIGTYPE (*ifunc)_((int)); + RETSIGTYPE (*ifunc)(int) = 0; int status; - int i, hooked = Qfalse; + int i, hooked = FALSE; if (!overriding) { #ifdef SIGHUP @@ -1381,8 +2830,8 @@ rb_syswait(pid) qfunc = signal(SIGQUIT, SIG_IGN); #endif ifunc = signal(SIGINT, SIG_IGN); - overriding = Qtrue; - hooked = Qtrue; + overriding = TRUE; + hooked = TRUE; } do { @@ -1397,19 +2846,109 @@ rb_syswait(pid) signal(SIGQUIT, qfunc); #endif signal(SIGINT, ifunc); - overriding = Qfalse; + overriding = FALSE; } } +static VALUE +rb_exec_arg_prepare(struct rb_exec_arg *earg, int argc, VALUE *argv, int default_close_others) +{ + VALUE prog = rb_exec_arg_init(argc, argv, TRUE, earg); + if (NIL_P(rb_ary_entry(earg->options, EXEC_OPTION_CLOSE_OTHERS))) { + VALUE v = default_close_others ? Qtrue : Qfalse; + rb_exec_arg_addopt(earg, ID2SYM(rb_intern("close_others")), v); + } + rb_exec_arg_fixup(earg); + return prog; +} + +static rb_pid_t +rb_spawn_process(struct rb_exec_arg *earg, VALUE prog, char *errmsg, size_t errmsg_buflen) +{ + rb_pid_t pid; +#if defined HAVE_FORK || !defined HAVE_SPAWNV + int status; +#endif +#if !defined HAVE_FORK + struct rb_exec_arg sarg; + int argc; + VALUE *argv; +#endif + +#if defined HAVE_FORK + pid = rb_fork_err(&status, rb_exec_atfork, earg, earg->redirect_fds, errmsg, errmsg_buflen); +#else + if (rb_run_exec_options_err(earg, &sarg, errmsg, errmsg_buflen) < 0) { + return -1; + } + + argc = earg->argc; + argv = earg->argv; + if (prog && argc) argv[0] = prog; +# if defined HAVE_SPAWNV + if (!argc) { + pid = proc_spawn(RSTRING_PTR(prog)); + } + else { + pid = proc_spawn_n(argc, argv, prog); + } +# if defined(_WIN32) + if (pid == -1) + rb_last_status_set(0x7f << 8, 0); +# endif +# else + if (argc) 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_run_exec_options_err(&sarg, NULL, errmsg, errmsg_buflen); +#endif + return pid; +} + +static rb_pid_t +rb_spawn_internal(int argc, VALUE *argv, int default_close_others, + char *errmsg, size_t errmsg_buflen) +{ + struct rb_exec_arg earg; + VALUE prog = rb_exec_arg_prepare(&earg, argc, argv, default_close_others); + return rb_spawn_process(&earg, prog, errmsg, errmsg_buflen); +} + +rb_pid_t +rb_spawn_err(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen) +{ + return rb_spawn_internal(argc, argv, TRUE, errmsg, errmsg_buflen); +} + +rb_pid_t +rb_spawn(int argc, VALUE *argv) +{ + return rb_spawn_internal(argc, argv, TRUE, NULL, 0); +} + /* * call-seq: - * system(cmd [, arg, ...]) => true or false + * 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) * - * Executes _cmd_ in a subshell, returning +true+ if - * the command was found and ran successfully, +false+ - * otherwise. An error status is available in <code>$?</code>. The - * arguments are processed in the same way as for - * <code>Kernel::exec</code>. + * 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", "*") @@ -1418,168 +2957,317 @@ rb_syswait(pid) * * config.h main.rb * * + * + * See <code>Kernel.exec</code> for the standard shell. */ static VALUE -rb_f_system(argc, argv) - int argc; - VALUE *argv; +rb_f_system(int argc, VALUE *argv) { + rb_pid_t pid; int status; -#if defined(__EMX__) - VALUE cmd; - fflush(stdout); - fflush(stderr); - if (argc == 0) { - rb_last_status = Qnil; - rb_raise(rb_eArgError, "wrong number of arguments"); - } - - if (TYPE(argv[0]) == T_ARRAY) { - if (RARRAY(argv[0])->len != 2) { - rb_raise(rb_eArgError, "wrong first argument"); - } - argv[0] = RARRAY(argv[0])->ptr[0]; - } - cmd = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); - - SafeStringValue(cmd); - status = do_spawn(RSTRING(cmd)->ptr); - last_status_set(status, 0); -#elif defined(__human68k__) || defined(__DJGPP__) || defined(_WIN32) - volatile VALUE prog = 0; - - fflush(stdout); - fflush(stderr); - if (argc == 0) { - rb_last_status = Qnil; - rb_raise(rb_eArgError, "wrong number of arguments"); - } - - if (TYPE(argv[0]) == T_ARRAY) { - if (RARRAY(argv[0])->len != 2) { - rb_raise(rb_eArgError, "wrong first argument"); - } - prog = RARRAY(argv[0])->ptr[0]; - argv[0] = RARRAY(argv[0])->ptr[1]; - } - - if (argc == 1 && prog == 0) { -#if defined(_WIN32) - SafeStringValue(argv[0]); - status = do_spawn(P_WAIT, RSTRING(argv[0])->ptr); -#else - status = proc_spawn(argv[0]); -#endif - } - else { - status = proc_spawn_n(argc, argv, prog); - } -#if !defined(_WIN32) - last_status_set(status == -1 ? 127 : status, 0); +#if defined(SIGCLD) && !defined(SIGCHLD) +# define SIGCHLD SIGCLD #endif -#elif defined(__VMS) - VALUE cmd; - - if (argc == 0) { - rb_last_status = Qnil; - rb_raise(rb_eArgError, "wrong number of arguments"); - } - - if (TYPE(argv[0]) == T_ARRAY) { - if (RARRAY(argv[0])->len != 2) { - rb_raise(rb_eArgError, "wrong first argument"); - } - argv[0] = RARRAY(argv[0])->ptr[0]; - } - cmd = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); - SafeStringValue(cmd); - status = system(RSTRING(cmd)->ptr); - last_status_set((status & 0xff) << 8, 0); -#else - volatile VALUE prog = 0; - int pid; - int i; +#ifdef SIGCHLD RETSIGTYPE (*chfunc)(int); - fflush(stdout); - fflush(stderr); - if (argc == 0) { - rb_last_status = Qnil; - rb_raise(rb_eArgError, "wrong number of arguments"); - } - - if (TYPE(argv[0]) == T_ARRAY) { - if (RARRAY(argv[0])->len != 2) { - rb_raise(rb_eArgError, "wrong first argument"); - } - prog = RARRAY(argv[0])->ptr[0]; - argv[0] = RARRAY(argv[0])->ptr[1]; - } - - if (prog) { - SafeStringValue(prog); - } - for (i = 0; i < argc; i++) { - SafeStringValue(argv[i]); - } - security(RSTRING(prog ? prog : argv[0])->ptr); chfunc = signal(SIGCHLD, SIG_DFL); - retry: - pid = fork(); - if (pid == 0) { - /* child process */ - if (argc == 1 && prog == 0) { - rb_proc_exec(RSTRING(argv[0])->ptr); - } - else { - proc_exec_n(argc, argv, prog); - } - _exit(127); - } - if (pid < 0) { - if (errno == EAGAIN) { - rb_thread_sleep(1); - goto retry; - } - } - else { +#endif + pid = rb_spawn_internal(argc, argv, FALSE, NULL, 0); +#if defined(HAVE_FORK) || defined(HAVE_SPAWNV) + if (pid > 0) { rb_syswait(pid); } +#endif +#ifdef SIGCHLD signal(SIGCHLD, chfunc); - if (pid < 0) rb_sys_fail(0); - status = NUM2INT(rb_last_status); #endif - + if (pid < 0) { + return Qnil; + } + status = PST2INT(rb_last_status_get()); if (status == EXIT_SUCCESS) return Qtrue; return Qfalse; } /* * call-seq: - * sleep([duration]) => fixnum + * spawn([env,] command... [,options]) -> pid + * Process.spawn([env,] command... [,options]) -> pid + * + * spawn executes specified command and return its pid. + * + * This method doesn't wait for end of the command. + * 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 (no shell) + * [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) + * resource limit: resourcename is core, cpu, data, etc. See Process.setrlimit. + * :rlimit_resourcename => limit + * :rlimit_resourcename => [cur_limit, max_limit] + * current directory: + * :chdir => str + * 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 => false : inherit fds (default for system and exec) + * :close_others => true : don't inherit (default for spawn and IO.popen) + * + * 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, + * 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>: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>:chdir</code> key in +options+ specifies the current directory. + * + * pid = spawn(command, :chdir=>"/var/tmp") + * + * 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, 3=>"/dev/null") # read mode + * + * For stdout and stderr, + * 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 differs 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" + * + * 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. + * + * 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' }; + struct rb_exec_arg earg; + + pid = rb_spawn_process(&earg, rb_exec_arg_prepare(&earg, argc, argv, TRUE), errmsg, sizeof(errmsg)); + if (pid == -1) { + const char *prog = errmsg; + if (!prog[0] && !(prog = earg.prog) && earg.argc) { + prog = RSTRING_PTR(earg.argv[0]); + } + rb_sys_fail(prog); + } +#if defined(HAVE_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>. Zero arguments causes +sleep+ to sleep - * forever. + * thread calls <code>Thread#run</code>. Called without an argument, sleep() + * will sleep forever. * - * Time.new #=> Wed Apr 09 08:56:32 CDT 2003 + * Time.new #=> 2008-03-08 19:56:19 +0900 * sleep 1.2 #=> 1 - * Time.new #=> Wed Apr 09 08:56:33 CDT 2003 + * Time.new #=> 2008-03-08 19:56:20 +0900 * sleep 1.9 #=> 2 - * Time.new #=> Wed Apr 09 08:56:35 CDT 2003 + * Time.new #=> 2008-03-08 19:56:22 +0900 */ static VALUE -rb_f_sleep(argc, argv) - int argc; - VALUE *argv; +rb_f_sleep(int argc, VALUE *argv) { - int beg, end; + time_t beg, end; beg = time(0); if (argc == 0) { @@ -1589,7 +3277,7 @@ rb_f_sleep(argc, argv) rb_thread_wait_for(rb_time_interval(argv[0])); } else { - rb_raise(rb_eArgError, "wrong number of arguments"); + rb_raise(rb_eArgError, "wrong number of arguments (%d for 0..1)", argc); } end = time(0) - beg; @@ -1598,9 +3286,10 @@ rb_f_sleep(argc, argv) } +#if (defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)) || defined(HAVE_GETPGID) /* * call-seq: - * Process.getpgrp => integer + * Process.getpgrp -> integer * * Returns the process group ID for this process. Not available on * all platforms. @@ -1609,62 +3298,60 @@ rb_f_sleep(argc, argv) * Process.getpgrp #=> 25527 */ -#if defined(SIGCLD) && !defined(SIGCHLD) -# define SIGCHLD SIGCLD -#endif - static VALUE -proc_getpgrp() +proc_getpgrp(void) { - int pgrp; + rb_pid_t pgrp; rb_secure(2); #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) pgrp = getpgrp(); if (pgrp < 0) rb_sys_fail(0); - return INT2FIX(pgrp); -#else -# ifdef HAVE_GETPGID + return PIDT2NUM(pgrp); +#else /* defined(HAVE_GETPGID) */ pgrp = getpgid(0); if (pgrp < 0) rb_sys_fail(0); - return INT2FIX(pgrp); -# else - rb_notimplement(); -# endif + 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 + * Process.setpgrp -> 0 * * Equivalent to <code>setpgid(0,0)</code>. Not available on all * platforms. */ static VALUE -proc_setpgrp() +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 prefered. The posix call avoids */ + /* 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); -#else - rb_notimplement(); #endif return INT2FIX(0); } +#else +#define proc_setpgrp rb_f_notimplement +#endif +#if defined(HAVE_GETPGID) /* * call-seq: - * Process.getpgid(pid) => integer + * Process.getpgid(pid) -> integer * * Returns the process group ID for the given process id. Not * available on all platforms. @@ -1673,52 +3360,54 @@ proc_setpgrp() */ static VALUE -proc_getpgid(obj, pid) - VALUE obj, pid; +proc_getpgid(VALUE obj, VALUE pid) { -#if defined(HAVE_GETPGID) && !defined(__CHECKER__) - int i; + rb_pid_t i; rb_secure(2); - i = getpgid(NUM2INT(pid)); + i = getpgid(NUM2PIDT(pid)); if (i < 0) rb_sys_fail(0); - return INT2NUM(i); + return PIDT2NUM(i); +} #else - rb_notimplement(); +#define proc_getpgid rb_f_notimplement #endif -} +#ifdef HAVE_SETPGID /* * call-seq: - * Process.setpgid(pid, integer) => 0 + * 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(obj, pid, pgrp) - VALUE obj, pid, pgrp; +proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp) { -#ifdef HAVE_SETPGID - int ipid, ipgrp; + rb_pid_t ipid, ipgrp; rb_secure(2); - ipid = NUM2INT(pid); - ipgrp = NUM2INT(pgrp); + ipid = NUM2PIDT(pid); + ipgrp = NUM2PIDT(pgrp); if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0); return INT2FIX(0); +} #else - rb_notimplement(); +#define proc_setpgid 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 + * Process.setsid -> fixnum * * Establishes this process as a new session and process group * leader, with no controlling tty. Returns the session id. Not @@ -1728,45 +3417,51 @@ proc_setpgid(obj, pid, pgrp) */ static VALUE -proc_setsid() +proc_setsid(void) { -#if defined(HAVE_SETSID) - int pid; + rb_pid_t pid; rb_secure(2); pid = setsid(); if (pid < 0) rb_sys_fail(0); - return INT2FIX(pid); -#elif defined(HAVE_SETPGRP) && defined(TIOCNOTTY) - rb_pid_t pid; - int ret; + return PIDT2NUM(pid); +} + +#if !defined(HAVE_SETSID) +#define HAVE_SETSID 1 +static rb_pid_t +ruby_setsid(void) +{ + rb_pid_t pid; + int ret; - rb_secure(2); - pid = getpid(); + 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). */ + 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); + ret = setpgrp(0, pid); #endif - if (ret == -1) rb_sys_fail(0); + if (ret == -1) return -1; - if ((fd = open("/dev/tty", O_RDWR)) >= 0) { - ioctl(fd, TIOCNOTTY, NULL); - close(fd); - } - return INT2FIX(pid); + if ((fd = open("/dev/tty", O_RDWR)) >= 0) { + ioctl(fd, TIOCNOTTY, NULL); + close(fd); + } + return pid; +} +#endif #else - rb_notimplement(); +#define proc_setsid rb_f_notimplement #endif -} +#ifdef HAVE_GETPRIORITY /* * call-seq: - * Process.getpriority(kind, integer) => fixnum + * 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 @@ -1782,10 +3477,8 @@ proc_setsid() */ static VALUE -proc_getpriority(obj, which, who) - VALUE obj, which, who; +proc_getpriority(VALUE obj, VALUE which, VALUE who) { -#ifdef HAVE_GETPRIORITY int prio, iwhich, iwho; rb_secure(2); @@ -1796,15 +3489,16 @@ proc_getpriority(obj, which, who) prio = getpriority(iwhich, iwho); if (errno) rb_sys_fail(0); return INT2FIX(prio); +} #else - rb_notimplement(); +#define proc_getpriority rb_f_notimplement #endif -} +#ifdef HAVE_GETPRIORITY /* * call-seq: - * Process.setpriority(kind, integer, priority) => 0 + * Process.setpriority(kind, integer, priority) -> 0 * * See <code>Process#getpriority</code>. * @@ -1815,10 +3509,8 @@ proc_getpriority(obj, which, who) */ static VALUE -proc_setpriority(obj, which, who, prio) - VALUE obj, which, who, prio; +proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio) { -#ifdef HAVE_GETPRIORITY int iwhich, iwho, iprio; rb_secure(2); @@ -1829,33 +3521,188 @@ proc_setpriority(obj, which, who, prio) if (setpriority(iwhich, iwho, iprio) < 0) rb_sys_fail(0); return INT2FIX(0); +} #else - rb_notimplement(); +#define proc_setpriority rb_f_notimplement #endif + +#if defined(RLIM2NUM) +static int +rlimit_resource_name2int(const char *name, int casetype) +{ + size_t len = strlen(name); + if (16 < len) return -1; + if (casetype == 1) { + size_t i; + char *name2 = ALLOCA_N(char, len+1); + for (i = 0; i < len; i++) { + if (!ISLOWER(name[i])) + return -1; + name2[i] = TOUPPER(name[i]); + } + name2[len] = '\0'; + name = name2; + } + + switch (*name) { + case 'A': +#ifdef RLIMIT_AS + if (strcmp(name, "AS") == 0) return RLIMIT_AS; +#endif + break; + + case 'C': +#ifdef RLIMIT_CORE + if (strcmp(name, "CORE") == 0) return RLIMIT_CORE; +#endif +#ifdef RLIMIT_CPU + if (strcmp(name, "CPU") == 0) return RLIMIT_CPU; +#endif + break; + + case 'D': +#ifdef RLIMIT_DATA + if (strcmp(name, "DATA") == 0) return RLIMIT_DATA; +#endif + break; + + case 'F': +#ifdef RLIMIT_FSIZE + if (strcmp(name, "FSIZE") == 0) return RLIMIT_FSIZE; +#endif + break; + + case 'M': +#ifdef RLIMIT_MEMLOCK + if (strcmp(name, "MEMLOCK") == 0) return RLIMIT_MEMLOCK; +#endif + break; + + case 'N': +#ifdef RLIMIT_NOFILE + if (strcmp(name, "NOFILE") == 0) return RLIMIT_NOFILE; +#endif +#ifdef RLIMIT_NPROC + if (strcmp(name, "NPROC") == 0) return RLIMIT_NPROC; +#endif + break; + + case 'R': +#ifdef RLIMIT_RSS + if (strcmp(name, "RSS") == 0) return RLIMIT_RSS; +#endif + break; + + case 'S': +#ifdef RLIMIT_STACK + if (strcmp(name, "STACK") == 0) return RLIMIT_STACK; +#endif +#ifdef RLIMIT_SBSIZE + if (strcmp(name, "SBSIZE") == 0) return RLIMIT_SBSIZE; +#endif + break; + } + return -1; } -#if SIZEOF_RLIM_T == SIZEOF_INT -# define RLIM2NUM(v) UINT2NUM(v) -# define NUM2RLIM(v) NUM2UINT(v) -#elif SIZEOF_RLIM_T == SIZEOF_LONG -# define RLIM2NUM(v) ULONG2NUM(v) -# define NUM2RLIM(v) NUM2ULONG(v) -#elif SIZEOF_RLIM_T == SIZEOF_LONG_LONG -# define RLIM2NUM(v) ULL2NUM(v) -# define NUM2RLIM(v) NUM2ULL(v) +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: + name = rb_id2name(SYM2ID(rtype)); + 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: %s", name); +} + +static rlim_t +rlimit_resource_value(VALUE rval) +{ + const char *name; + VALUE v; + + switch (TYPE(rval)) { + case T_SYMBOL: + name = rb_id2name(SYM2ID(rval)); + 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: %s", name); +} #endif +#if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM) /* * call-seq: - * Process.getrlimit(resource) => [cur_limit, max_limit] + * 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: - * such as <code>Process::RLIMIT_CORE</code>, - * <code>Process::RLIMIT_CPU</code>, etc. + * _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>, @@ -1867,24 +3714,24 @@ proc_setpriority(obj, which, who, prio) static VALUE proc_getrlimit(VALUE obj, VALUE resource) { -#if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM) struct rlimit rlim; rb_secure(2); - if (getrlimit(NUM2INT(resource), &rlim) < 0) { - rb_sys_fail("getrlimit"); + 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 - rb_notimplement(); +#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 + * 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 @@ -1893,35 +3740,43 @@ proc_getrlimit(VALUE obj, VALUE resource) * If _max_limit_ is not given, _cur_limit_ is used. * * _resource_ indicates the kind of resource to limit. - * The list of resources are OS dependent. + * 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. * - * [Process::RLIMIT_CORE] core size (bytes) (SUSv3) - * [Process::RLIMIT_CPU] CPU time (seconds) (SUSv3) - * [Process::RLIMIT_DATA] data segment (bytes) (SUSv3) - * [Process::RLIMIT_FSIZE] file size (bytes) (SUSv3) - * [Process::RLIMIT_NOFILE] file descriptors (number) (SUSv3) - * [Process::RLIMIT_STACK] stack size (bytes) (SUSv3) - * [Process::RLIMIT_AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite) - * [Process::RLIMIT_MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux) - * [Process::RLIMIT_NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux) - * [Process::RLIMIT_RSS] resident memory size (bytes) (4.2BSD, GNU/Linux) - * [Process::RLIMIT_SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD) - * - * Other <code>Process::RLIMIT_???</code> constants may be defined. - * - * _cur_limit_ and _max_limit_ may be <code>Process::RLIM_INFINITY</code>, + * [CORE] core size (bytes) (SUSv3) + * [CPU] CPU time (seconds) (SUSv3) + * [DATA] data segment (bytes) (SUSv3) + * [FSIZE] file size (bytes) (SUSv3) + * [NOFILE] file descriptors (number) (SUSv3) + * [STACK] stack size (bytes) (SUSv3) + * [AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite) + * [MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux) + * [NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux) + * [RSS] resident memory size (bytes) (4.2BSD, GNU/Linux) + * [SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD) + * + * _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> or - * <code>Process::RLIM_SAVED_CUR</code> too. + * 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 raise 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) { -#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) VALUE resource, rlim_cur, rlim_max; struct rlimit rlim; @@ -1931,21 +3786,21 @@ proc_setrlimit(int argc, VALUE *argv, VALUE obj) if (rlim_max == Qnil) rlim_max = rlim_cur; - rlim.rlim_cur = NUM2RLIM(rlim_cur); - rlim.rlim_max = NUM2RLIM(rlim_max); + rlim.rlim_cur = rlimit_resource_value(rlim_cur); + rlim.rlim_max = rlimit_resource_value(rlim_max); - if (setrlimit(NUM2INT(resource), &rlim) < 0) { - rb_sys_fail("setrlimit"); + if (setrlimit(rlimit_resource_type(resource), &rlim) < 0) { + rb_sys_fail("setrlimit"); } return Qnil; +} #else - rb_notimplement(); +#define proc_setrlimit rb_f_notimplement #endif -} static int under_uid_switch = 0; static void -check_uid_switch() +check_uid_switch(void) { rb_secure(2); if (under_uid_switch) { @@ -1955,7 +3810,7 @@ check_uid_switch() static int under_gid_switch = 0; static void -check_gid_switch() +check_gid_switch(void) { rb_secure(2); if (under_gid_switch) { @@ -1975,9 +3830,10 @@ check_gid_switch() */ +#if defined HAVE_SETUID /* * call-seq: - * Process::Sys.setuid(integer) => nil + * Process::Sys.setuid(integer) -> nil * * Set the user ID of the current process to _integer_. Not * available on all platforms. @@ -1985,23 +3841,21 @@ check_gid_switch() */ static VALUE -p_sys_setuid(obj, id) - VALUE obj, id; +p_sys_setuid(VALUE obj, VALUE id) { -#if defined HAVE_SETUID check_uid_switch(); - if (setuid(NUM2INT(id)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setuid(NUM2UIDT(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(integer) => nil + * Process::Sys.setruid(integer) -> nil * * Set the real user ID of the calling process to _integer_. * Not available on all platforms. @@ -2009,22 +3863,21 @@ p_sys_setuid(obj, id) */ static VALUE -p_sys_setruid(obj, id) - VALUE obj, id; +p_sys_setruid(VALUE obj, VALUE id) { -#if defined HAVE_SETRUID check_uid_switch(); - if (setruid(NUM2INT(id)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setruid(NUM2UIDT(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(integer) => nil + * Process::Sys.seteuid(integer) -> nil * * Set the effective user ID of the calling process to * _integer_. Not available on all platforms. @@ -2032,22 +3885,21 @@ p_sys_setruid(obj, id) */ static VALUE -p_sys_seteuid(obj, id) - VALUE obj, id; +p_sys_seteuid(VALUE obj, VALUE id) { -#if defined HAVE_SETEUID check_uid_switch(); - if (seteuid(NUM2INT(id)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (seteuid(NUM2UIDT(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 + * Process::Sys.setreuid(rid, eid) -> nil * * Sets the (integer) real and/or effective user IDs of the current * process to _rid_ and _eid_, respectively. A value of @@ -2057,22 +3909,21 @@ p_sys_seteuid(obj, id) */ static VALUE -p_sys_setreuid(obj, rid, eid) - VALUE obj, rid, eid; +p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid) { -#if defined HAVE_SETREUID check_uid_switch(); - if (setreuid(NUM2INT(rid),NUM2INT(eid)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setreuid(NUM2UIDT(rid),NUM2UIDT(eid)) != 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 + * Process::Sys.setresuid(rid, eid, sid) -> nil * * Sets the (integer) real, effective, and saved user IDs of the * current process to _rid_, _eid_, and _sid_ respectively. A @@ -2082,24 +3933,22 @@ p_sys_setreuid(obj, rid, eid) */ static VALUE -p_sys_setresuid(obj, rid, eid, sid) - VALUE obj, rid, eid, sid; +p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) { -#if defined HAVE_SETRESUID check_uid_switch(); - if (setresuid(NUM2INT(rid),NUM2INT(eid),NUM2INT(sid)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setresuid(NUM2UIDT(rid),NUM2UIDT(eid),NUM2UIDT(sid)) != 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 + * Process.uid -> fixnum + * Process::UID.rid -> fixnum + * Process::Sys.getuid -> fixnum * * Returns the (real) user ID of this process. * @@ -2107,30 +3956,31 @@ p_sys_setresuid(obj, rid, eid, sid) */ static VALUE -proc_getuid(obj) - VALUE obj; +proc_getuid(VALUE obj) { - int uid = getuid(); - return INT2FIX(uid); + 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= integer => numeric + * Process.uid= integer -> numeric * * Sets the (integer) user ID for this process. Not available on all * platforms. */ static VALUE -proc_setuid(obj, id) - VALUE obj, id; +proc_setuid(VALUE obj, VALUE id) { - int uid = NUM2INT(id); + rb_uid_t uid; check_uid_switch(); -#if defined(HAVE_SETRESUID) && !defined(__CHECKER__) + + uid = NUM2UIDT(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); @@ -2145,11 +3995,12 @@ proc_setuid(obj, id) rb_notimplement(); } } -#else - rb_notimplement(); #endif - return INT2FIX(uid); + return id; } +#else +#define proc_setuid rb_f_notimplement +#endif /******************************************************************** @@ -2162,12 +4013,11 @@ proc_setuid(obj, id) * */ -static int SAVED_USER_ID = -1; +static rb_uid_t SAVED_USER_ID = -1; #ifdef BROKEN_SETREUID int -setreuid(ruid, euid) - rb_uid_t ruid, euid; +setreuid(rb_uid_t ruid, rb_uid_t euid) { if (ruid != -1 && ruid != getuid()) { if (euid == -1) euid = geteuid(); @@ -2182,7 +4032,7 @@ setreuid(ruid, euid) /* * call-seq: - * Process::UID.change_privilege(integer) => fixnum + * Process::UID.change_privilege(integer) -> fixnum * * Change the current process's real and effective user ID to that * specified by _integer_. Returns the new user ID. Not @@ -2194,14 +4044,13 @@ setreuid(ruid, euid) */ static VALUE -p_uid_change_privilege(obj, id) - VALUE obj, id; +p_uid_change_privilege(VALUE obj, VALUE id) { - int uid; + rb_uid_t uid; check_uid_switch(); - uid = NUM2INT(id); + uid = NUM2UIDT(id); if (geteuid() == 0) { /* root-user */ #if defined(HAVE_SETRESUID) @@ -2329,14 +4178,15 @@ p_uid_change_privilege(obj, id) rb_notimplement(); #endif } - return INT2FIX(uid); + return id; } +#if defined HAVE_SETGID /* * call-seq: - * Process::Sys.setgid(integer) => nil + * Process::Sys.setgid(integer) -> nil * * Set the group ID of the current process to _integer_. Not * available on all platforms. @@ -2344,22 +4194,21 @@ p_uid_change_privilege(obj, id) */ static VALUE -p_sys_setgid(obj, id) - VALUE obj, id; +p_sys_setgid(VALUE obj, VALUE id) { -#if defined HAVE_SETGID check_gid_switch(); - if (setgid(NUM2INT(id)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setgid(NUM2GIDT(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(integer) => nil + * Process::Sys.setrgid(integer) -> nil * * Set the real group ID of the calling process to _integer_. * Not available on all platforms. @@ -2367,23 +4216,21 @@ p_sys_setgid(obj, id) */ static VALUE -p_sys_setrgid(obj, id) - VALUE obj, id; +p_sys_setrgid(VALUE obj, VALUE id) { -#if defined HAVE_SETRGID check_gid_switch(); - if (setrgid(NUM2INT(id)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setrgid(NUM2GIDT(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(integer) => nil + * Process::Sys.setegid(integer) -> nil * * Set the effective group ID of the calling process to * _integer_. Not available on all platforms. @@ -2391,22 +4238,21 @@ p_sys_setrgid(obj, id) */ static VALUE -p_sys_setegid(obj, id) - VALUE obj, id; +p_sys_setegid(VALUE obj, VALUE id) { -#if defined HAVE_SETEGID check_gid_switch(); - if (setegid(NUM2INT(id)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setegid(NUM2GIDT(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 + * Process::Sys.setregid(rid, eid) -> nil * * Sets the (integer) real and/or effective group IDs of the current * process to <em>rid</em> and <em>eid</em>, respectively. A value of @@ -2416,21 +4262,20 @@ p_sys_setegid(obj, id) */ static VALUE -p_sys_setregid(obj, rid, eid) - VALUE obj, rid, eid; +p_sys_setregid(VALUE obj, VALUE rid, VALUE eid) { -#if defined HAVE_SETREGID check_gid_switch(); - if (setregid(NUM2INT(rid),NUM2INT(eid)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setregid(NUM2GIDT(rid),NUM2GIDT(eid)) != 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 + * Process::Sys.setresgid(rid, eid, sid) -> nil * * Sets the (integer) real, effective, and saved user IDs of the * current process to <em>rid</em>, <em>eid</em>, and <em>sid</em> @@ -2440,22 +4285,21 @@ p_sys_setregid(obj, rid, eid) */ static VALUE -p_sys_setresgid(obj, rid, eid, sid) - VALUE obj, rid, eid, sid; +p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) { -#if defined HAVE_SETRESGID check_gid_switch(); - if (setresgid(NUM2INT(rid),NUM2INT(eid),NUM2INT(sid)) != 0) rb_sys_fail(0); -#else - rb_notimplement(); -#endif + if (setresgid(NUM2GIDT(rid),NUM2GIDT(eid),NUM2GIDT(sid)) != 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 + * 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 @@ -2466,28 +4310,25 @@ p_sys_setresgid(obj, rid, eid, sid) */ static VALUE -p_sys_issetugid(obj) - VALUE obj; +p_sys_issetugid(VALUE obj) { -#if defined HAVE_ISSETUGID rb_secure(2); if (issetugid()) { return Qtrue; } else { return Qfalse; } +} #else - rb_notimplement(); - return Qnil; /* not reached */ +#define p_sys_issetugid rb_f_notimplement #endif -} /* * call-seq: - * Process.gid => fixnum - * Process::GID.rid => fixnum - * Process::Sys.getgid => fixnum + * Process.gid -> fixnum + * Process::GID.rid -> fixnum + * Process::Sys.getgid -> fixnum * * Returns the (real) group ID for this process. * @@ -2495,29 +4336,30 @@ p_sys_issetugid(obj) */ static VALUE -proc_getgid(obj) - VALUE obj; +proc_getgid(VALUE obj) { - int gid = getgid(); - return INT2FIX(gid); + 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 + * Process.gid= fixnum -> fixnum * * Sets the group ID for this process. */ static VALUE -proc_setgid(obj, id) - VALUE obj, id; +proc_setgid(VALUE obj, VALUE id) { - int gid = NUM2INT(id); + rb_gid_t gid; check_gid_switch(); -#if defined(HAVE_SETRESGID) && !defined(__CHECKER__) + + gid = NUM2GIDT(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); @@ -2532,19 +4374,21 @@ proc_setgid(obj, id) rb_notimplement(); } } -#else - rb_notimplement(); #endif - return INT2FIX(gid); + return GIDT2NUM(gid); } +#else +#define proc_setgid rb_f_notimplement +#endif -static size_t maxgroups = 32; +static int maxgroups = 32; +#ifdef HAVE_GETGROUPS /* * call-seq: - * Process.groups => array + * Process.groups -> array * * Get an <code>Array</code> of the gids of groups in the * supplemental group access list for this process. @@ -2556,11 +4400,9 @@ static size_t maxgroups = 32; static VALUE proc_getgroups(VALUE obj) { -#ifdef HAVE_GETGROUPS VALUE ary; - size_t ngroups; + int i, ngroups; rb_gid_t *groups; - int i; groups = ALLOCA_N(rb_gid_t, maxgroups); @@ -2570,19 +4412,19 @@ proc_getgroups(VALUE obj) ary = rb_ary_new(); for (i = 0; i < ngroups; i++) - rb_ary_push(ary, INT2NUM(groups[i])); + rb_ary_push(ary, GIDT2NUM(groups[i])); return ary; +} #else - rb_notimplement(); - return Qnil; +#define proc_getgroups rb_f_notimplement #endif -} +#ifdef HAVE_SETGROUPS /* * call-seq: - * Process.groups= array => array + * Process.groups= array -> array * * Set the supplemental group access list to the given * <code>Array</code> of group IDs. @@ -2596,57 +4438,56 @@ proc_getgroups(VALUE obj) static VALUE proc_setgroups(VALUE obj, VALUE ary) { -#ifdef HAVE_SETGROUPS - size_t ngroups; + size_t ngroups, i; rb_gid_t *groups; - int i; struct group *gr; Check_Type(ary, T_ARRAY); - ngroups = RARRAY(ary)->len; - if (ngroups > maxgroups) - rb_raise(rb_eArgError, "too many groups, %d max", maxgroups); + ngroups = RARRAY_LEN(ary); + if (ngroups > (size_t)maxgroups) + rb_raise(rb_eArgError, "too many groups, %u max", maxgroups); groups = ALLOCA_N(rb_gid_t, ngroups); - for (i = 0; i < ngroups && i < RARRAY(ary)->len; i++) { - VALUE g = RARRAY(ary)->ptr[i]; + for (i = 0; i < ngroups && i < (size_t)RARRAY_LEN(ary); i++) { + VALUE g = RARRAY_PTR(ary)[i]; if (FIXNUM_P(g)) { - groups[i] = FIX2INT(g); + groups[i] = NUM2GIDT(g); } else { VALUE tmp = rb_check_string_type(g); if (NIL_P(tmp)) { - groups[i] = NUM2INT(g); + groups[i] = NUM2GIDT(g); } else { - gr = getgrnam(RSTRING(tmp)->ptr); - if (gr == NULL) + gr = getgrnam(RSTRING_PTR(tmp)); + if (gr == NULL) { + RB_GC_GUARD(tmp); rb_raise(rb_eArgError, - "can't find group for %s", RSTRING(tmp)->ptr); + "can't find group for %s", RSTRING_PTR(tmp)); + } groups[i] = gr->gr_gid; } } } - i = setgroups(ngroups, groups); - if (i == -1) + if (setgroups((int)ngroups, groups) == -1) /* ngroups <= maxgroups */ rb_sys_fail(0); return proc_getgroups(obj); +} #else - rb_notimplement(); - return Qnil; +#define proc_setgroups rb_f_notimplement #endif -} +#ifdef HAVE_INITGROUPS /* * call-seq: - * Process.initgroups(username, gid) => array + * 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 @@ -2662,24 +4503,21 @@ proc_setgroups(VALUE obj, VALUE ary) */ static VALUE -proc_initgroups(obj, uname, base_grp) - VALUE obj, uname, base_grp; +proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp) { -#ifdef HAVE_INITGROUPS - if (initgroups(StringValuePtr(uname), (rb_gid_t)NUM2INT(base_grp)) != 0) { + if (initgroups(StringValuePtr(uname), NUM2GIDT(base_grp)) != 0) { rb_sys_fail(0); } return proc_getgroups(obj); +} #else - rb_notimplement(); - return Qnil; +#define proc_initgroups rb_f_notimplement #endif -} /* * call-seq: - * Process.maxgroups => fixnum + * Process.maxgroups -> fixnum * * Returns the maximum number of gids allowed in the supplemental * group access list. @@ -2688,8 +4526,7 @@ proc_initgroups(obj, uname, base_grp) */ static VALUE -proc_getmaxgroups(obj) - VALUE obj; +proc_getmaxgroups(VALUE obj) { return INT2FIX(maxgroups); } @@ -2697,7 +4534,7 @@ proc_getmaxgroups(obj) /* * call-seq: - * Process.maxgroups= fixnum => fixnum + * Process.maxgroups= fixnum -> fixnum * * Sets the maximum number of gids allowed in the supplemental group * access list. @@ -2706,7 +4543,7 @@ proc_getmaxgroups(obj) static VALUE proc_setmaxgroups(VALUE obj, VALUE val) { - size_t ngroups = FIX2INT(val); + int ngroups = FIX2UINT(val); if (ngroups > 4096) ngroups = 4096; @@ -2716,6 +4553,75 @@ proc_setmaxgroups(VALUE obj, VALUE val) return INT2FIX(maxgroups); } +#if defined(HAVE_DAEMON) || (defined(HAVE_FORK) && defined(HAVE_SETSID)) +/* + * 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); + +#if defined(HAVE_DAEMON) + prefork(); + before_fork(); + n = daemon(RTEST(nochdir), RTEST(noclose)); + after_fork(); + if (n < 0) rb_sys_fail("daemon"); + return INT2FIX(n); +#elif defined(HAVE_FORK) + switch (rb_fork(0, 0, 0, Qnil)) { + case -1: + rb_sys_fail("daemon"); + case 0: + break; + default: + _exit(EXIT_SUCCESS); + } + + proc_setsid(); + + /* must not be process-leader */ + switch (rb_fork(0, 0, 0, Qnil)) { + case -1: + rb_sys_fail("daemon"); + case 0: + break; + default: + _exit(EXIT_SUCCESS); + } + + if (!RTEST(nochdir)) + (void)chdir("/"); + + if (!RTEST(noclose) && (n = open("/dev/null", O_RDWR, 0)) != -1) { + (void)dup2(n, 0); + (void)dup2(n, 1); + (void)dup2(n, 2); + if (n > 2) + (void)close (n); + } + return INT2FIX(0); +#endif +} +#else +#define proc_daemon rb_f_notimplement +#endif /******************************************************************** * @@ -2727,12 +4633,11 @@ proc_setmaxgroups(VALUE obj, VALUE val) * */ -static int SAVED_GROUP_ID = -1; +static rb_gid_t SAVED_GROUP_ID = -1; #ifdef BROKEN_SETREGID int -setregid(rgid, egid) - rb_gid_t rgid, egid; +setregid(rb_gid_t rgid, rb_gid_t egid) { if (rgid != -1 && rgid != getgid()) { if (egid == -1) egid = getegid(); @@ -2747,7 +4652,7 @@ setregid(rgid, egid) /* * call-seq: - * Process::GID.change_privilege(integer) => fixnum + * Process::GID.change_privilege(integer) -> fixnum * * Change the current process's real and effective group ID to that * specified by _integer_. Returns the new group ID. Not @@ -2759,14 +4664,13 @@ setregid(rgid, egid) */ static VALUE -p_gid_change_privilege(obj, id) - VALUE obj, id; +p_gid_change_privilege(VALUE obj, VALUE id) { - int gid; + rb_gid_t gid; check_gid_switch(); - gid = NUM2INT(id); + gid = NUM2GIDT(id); if (geteuid() == 0) { /* root-user */ #if defined(HAVE_SETRESGID) @@ -2858,7 +4762,7 @@ p_gid_change_privilege(obj, id) 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); @@ -2895,15 +4799,15 @@ p_gid_change_privilege(obj, id) rb_notimplement(); #endif } - return INT2FIX(gid); + return id; } /* * call-seq: - * Process.euid => fixnum - * Process::UID.eid => fixnum - * Process::Sys.geteuid => fixnum + * Process.euid -> fixnum + * Process::UID.eid -> fixnum + * Process::Sys.geteuid -> fixnum * * Returns the effective user ID for this process. * @@ -2911,14 +4815,13 @@ p_gid_change_privilege(obj, id) */ static VALUE -proc_geteuid(obj) - VALUE obj; +proc_geteuid(VALUE obj) { - int euid = geteuid(); - return INT2FIX(euid); + 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) /* * call-seq: * Process.euid= integer @@ -2928,20 +4831,22 @@ proc_geteuid(obj) */ static VALUE -proc_seteuid(obj, euid) - VALUE obj, euid; +proc_seteuid(VALUE obj, VALUE euid) { + rb_uid_t uid; + check_uid_switch(); -#if defined(HAVE_SETRESUID) && !defined(__CHECKER__) - if (setresuid(-1, NUM2INT(euid), -1) < 0) rb_sys_fail(0); + + uid = NUM2UIDT(euid); +#if defined(HAVE_SETRESUID) + if (setresuid(-1, uid, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETREUID - if (setreuid(-1, NUM2INT(euid)) < 0) rb_sys_fail(0); + if (setreuid(-1, uid) < 0) rb_sys_fail(0); #elif defined HAVE_SETEUID - if (seteuid(NUM2INT(euid)) < 0) rb_sys_fail(0); + if (seteuid(uid) < 0) rb_sys_fail(0); #elif defined HAVE_SETUID - euid = NUM2INT(euid); - if (euid == getuid()) { - if (setuid(euid) < 0) rb_sys_fail(0); + if (uid == getuid()) { + if (setuid(uid) < 0) rb_sys_fail(0); } else { rb_notimplement(); @@ -2951,18 +4856,24 @@ proc_seteuid(obj, euid) #endif return euid; } +#endif -static VALUE -rb_seteuid_core(euid) - int euid; +#if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) +#define proc_seteuid_m proc_seteuid +#else +#define proc_seteuid_m rb_f_notimplement +#endif + +static rb_uid_t +rb_seteuid_core(rb_uid_t euid) { - int uid; + rb_uid_t uid; check_uid_switch(); uid = getuid(); -#if defined(HAVE_SETRESUID) && !defined(__CHECKER__) +#if defined(HAVE_SETRESUID) if (uid != euid) { if (setresuid(-1,euid,euid) < 0) rb_sys_fail(0); SAVED_USER_ID = euid; @@ -2984,14 +4895,14 @@ rb_seteuid_core(euid) #else rb_notimplement(); #endif - return INT2FIX(euid); + return euid; } /* * call-seq: - * Process::UID.grant_privilege(integer) => fixnum - * Process::UID.eid= integer => fixnum + * Process::UID.grant_privilege(integer) -> fixnum + * Process::UID.eid= integer -> fixnum * * Set the effective user ID, and if possible, the saved user ID of * the process to the given _integer_. Returns the new @@ -3003,18 +4914,18 @@ rb_seteuid_core(euid) */ static VALUE -p_uid_grant_privilege(obj, id) - VALUE obj, id; +p_uid_grant_privilege(VALUE obj, VALUE id) { - return rb_seteuid_core(NUM2INT(id)); + rb_seteuid_core(NUM2UIDT(id)); + return id; } /* * call-seq: - * Process.egid => fixnum - * Process::GID.eid => fixnum - * Process::Sys.geteid => fixnum + * Process.egid -> fixnum + * Process::GID.eid -> fixnum + * Process::Sys.geteid -> fixnum * * Returns the effective group ID for this process. Not available on * all platforms. @@ -3023,39 +4934,39 @@ p_uid_grant_privilege(obj, id) */ static VALUE -proc_getegid(obj) - VALUE obj; +proc_getegid(VALUE obj) { - int egid = getegid(); + rb_gid_t egid = getegid(); - return INT2FIX(egid); + 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 + * Process.egid = fixnum -> fixnum * * Sets the effective group ID for this process. Not available on all * platforms. */ static VALUE -proc_setegid(obj, egid) - VALUE obj, egid; +proc_setegid(VALUE obj, VALUE egid) { + rb_gid_t gid; + check_gid_switch(); -#if defined(HAVE_SETRESGID) && !defined(__CHECKER__) - if (setresgid(-1, NUM2INT(egid), -1) < 0) rb_sys_fail(0); + gid = NUM2GIDT(egid); +#if defined(HAVE_SETRESGID) + if (setresgid(-1, gid, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETREGID - if (setregid(-1, NUM2INT(egid)) < 0) rb_sys_fail(0); + if (setregid(-1, gid) < 0) rb_sys_fail(0); #elif defined HAVE_SETEGID - if (setegid(NUM2INT(egid)) < 0) rb_sys_fail(0); + if (setegid(gid) < 0) rb_sys_fail(0); #elif defined HAVE_SETGID - egid = NUM2INT(egid); - if (egid == getgid()) { - if (setgid(egid) < 0) rb_sys_fail(0); + if (gid == getgid()) { + if (setgid(gid) < 0) rb_sys_fail(0); } else { rb_notimplement(); @@ -3065,18 +4976,24 @@ proc_setegid(obj, egid) #endif return egid; } +#endif -static VALUE -rb_setegid_core(egid) - int egid; +#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) { - int gid; + rb_gid_t gid; check_gid_switch(); gid = getgid(); -#if defined(HAVE_SETRESGID) && !defined(__CHECKER__) +#if defined(HAVE_SETRESGID) if (gid != egid) { if (setresgid(-1,egid,egid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = egid; @@ -3098,14 +5015,14 @@ rb_setegid_core(egid) #else rb_notimplement(); #endif - return INT2FIX(egid); + return egid; } /* * call-seq: - * Process::GID.grant_privilege(integer) => fixnum - * Process::GID.eid = integer => fixnum + * Process::GID.grant_privilege(integer) -> fixnum + * Process::GID.eid = integer -> fixnum * * Set the effective group ID, and if possible, the saved group ID of * the process to the given _integer_. Returns the new @@ -3117,16 +5034,16 @@ rb_setegid_core(egid) */ static VALUE -p_gid_grant_privilege(obj, id) - VALUE obj, id; +p_gid_grant_privilege(VALUE obj, VALUE id) { - return rb_setegid_core(NUM2INT(id)); + rb_setegid_core(NUM2GIDT(id)); + return id; } /* * call-seq: - * Process::UID.re_exchangeable? => true or false + * 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. @@ -3134,9 +5051,9 @@ p_gid_grant_privilege(obj, id) */ static VALUE -p_uid_exchangeable() +p_uid_exchangeable(void) { -#if defined(HAVE_SETRESUID) && !defined(__CHECKER__) +#if defined(HAVE_SETRESUID) return Qtrue; #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) return Qtrue; @@ -3148,7 +5065,7 @@ p_uid_exchangeable() /* * call-seq: - * Process::UID.re_exchange => fixnum + * Process::UID.re_exchange -> fixnum * * Exchange real and effective user IDs and return the new effective * user ID. Not available on all platforms. @@ -3159,17 +5076,16 @@ p_uid_exchangeable() */ static VALUE -p_uid_exchange(obj) - VALUE obj; +p_uid_exchange(VALUE obj) { - int uid, euid; + rb_uid_t uid, euid; check_uid_switch(); uid = getuid(); euid = geteuid(); -#if defined(HAVE_SETRESUID) && !defined(__CHECKER__) +#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) @@ -3178,13 +5094,13 @@ p_uid_exchange(obj) #else rb_notimplement(); #endif - return INT2FIX(uid); + return UIDT2NUM(uid); } /* * call-seq: - * Process::GID.re_exchangeable? => true or false + * 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. @@ -3192,9 +5108,9 @@ p_uid_exchange(obj) */ static VALUE -p_gid_exchangeable() +p_gid_exchangeable(void) { -#if defined(HAVE_SETRESGID) && !defined(__CHECKER__) +#if defined(HAVE_SETRESGID) return Qtrue; #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) return Qtrue; @@ -3206,7 +5122,7 @@ p_gid_exchangeable() /* * call-seq: - * Process::GID.re_exchange => fixnum + * Process::GID.re_exchange -> fixnum * * Exchange real and effective group IDs and return the new effective * group ID. Not available on all platforms. @@ -3217,17 +5133,16 @@ p_gid_exchangeable() */ static VALUE -p_gid_exchange(obj) - VALUE obj; +p_gid_exchange(VALUE obj) { - int gid, egid; + rb_gid_t gid, egid; check_gid_switch(); gid = getgid(); egid = getegid(); -#if defined(HAVE_SETRESGID) && !defined(__CHECKER__) +#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) @@ -3236,14 +5151,14 @@ p_gid_exchange(obj) #else rb_notimplement(); #endif - return INT2FIX(gid); + 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 + * Process::UID.sid_available? -> true or false * * Returns +true+ if the current platform has saved user * ID functionality. @@ -3251,7 +5166,7 @@ p_gid_exchange(obj) */ static VALUE -p_uid_have_saved_id() +p_uid_have_saved_id(void) { #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) return Qtrue; @@ -3263,18 +5178,18 @@ p_uid_have_saved_id() #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) static VALUE -p_uid_sw_ensure(id) - int id; +p_uid_sw_ensure(rb_uid_t id) { under_uid_switch = 0; - return rb_seteuid_core(id); + id = rb_seteuid_core(id); + return UIDT2NUM(id); } /* * call-seq: - * Process::UID.switch => fixnum - * Process::UID.switch {|| block} => object + * 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 @@ -3285,10 +5200,9 @@ p_uid_sw_ensure(id) */ static VALUE -p_uid_switch(obj) - VALUE obj; +p_uid_switch(VALUE obj) { - int uid, euid; + rb_uid_t uid, euid; check_uid_switch(); @@ -3296,40 +5210,38 @@ p_uid_switch(obj) euid = geteuid(); if (uid != euid) { - proc_seteuid(obj, INT2FIX(uid)); + proc_seteuid(obj, UIDT2NUM(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 INT2FIX(euid); + return UIDT2NUM(euid); } } else if (euid != SAVED_USER_ID) { - proc_seteuid(obj, INT2FIX(SAVED_USER_ID)); + proc_seteuid(obj, UIDT2NUM(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 INT2FIX(uid); + return UIDT2NUM(uid); } } else { errno = EPERM; rb_sys_fail(0); } - +} #else static VALUE -p_uid_sw_ensure(obj) - VALUE obj; +p_uid_sw_ensure(VALUE obj) { under_uid_switch = 0; return p_uid_exchange(obj); } static VALUE -p_uid_switch(obj) - VALUE obj; +p_uid_switch(VALUE obj) { - int uid, euid; + rb_uid_t uid, euid; check_uid_switch(); @@ -3345,17 +5257,17 @@ p_uid_switch(obj) under_uid_switch = 1; return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, obj); } else { - return INT2FIX(euid); + return UIDT2NUM(euid); } -#endif } +#endif /* [MG] :FIXME: Is this correct? I'm not sure how to phrase this. */ /* * call-seq: - * Process::GID.sid_available? => true or false + * Process::GID.sid_available? -> true or false * * Returns +true+ if the current platform has saved group * ID functionality. @@ -3363,7 +5275,7 @@ p_uid_switch(obj) */ static VALUE -p_gid_have_saved_id() +p_gid_have_saved_id(void) { #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) return Qtrue; @@ -3374,18 +5286,18 @@ p_gid_have_saved_id() #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) static VALUE -p_gid_sw_ensure(id) - int id; +p_gid_sw_ensure(rb_gid_t id) { under_gid_switch = 0; - return rb_setegid_core(id); + id = rb_setegid_core(id); + return GIDT2NUM(id); } /* * call-seq: - * Process::GID.switch => fixnum - * Process::GID.switch {|| block} => object + * 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 @@ -3396,10 +5308,9 @@ p_gid_sw_ensure(id) */ static VALUE -p_gid_switch(obj) - VALUE obj; +p_gid_switch(VALUE obj) { - int gid, egid; + rb_gid_t gid, egid; check_gid_switch(); @@ -3407,39 +5318,40 @@ p_gid_switch(obj) egid = getegid(); if (gid != egid) { - proc_setegid(obj, INT2FIX(gid)); + 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 INT2FIX(egid); + return GIDT2NUM(egid); } - } else if (egid != SAVED_GROUP_ID) { - proc_setegid(obj, INT2FIX(SAVED_GROUP_ID)); + } + 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 INT2FIX(gid); + return GIDT2NUM(gid); } - } else { + } + else { errno = EPERM; rb_sys_fail(0); } +} #else static VALUE -p_gid_sw_ensure(obj) - VALUE obj; +p_gid_sw_ensure(VALUE obj) { under_gid_switch = 0; return p_gid_exchange(obj); } static VALUE -p_gid_switch(obj) - VALUE obj; +p_gid_switch(VALUE obj) { - int gid, egid; + rb_gid_t gid, egid; check_gid_switch(); @@ -3455,15 +5367,16 @@ p_gid_switch(obj) under_gid_switch = 1; return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, obj); } else { - return INT2FIX(egid); + return GIDT2NUM(egid); } -#endif } +#endif +#if defined(HAVE_TIMES) /* * call-seq: - * Process.times => aStructTms + * Process.times -> aStructTms * * Returns a <code>Tms</code> structure (see <code>Struct::Tms</code> * on page 388) that contains user and system CPU times for this @@ -3474,10 +5387,8 @@ p_gid_switch(obj) */ VALUE -rb_proc_times(obj) - VALUE obj; +rb_proc_times(VALUE obj) { -#if defined(HAVE_TIMES) && !defined(__CHECKER__) const double hertz = #ifdef HAVE__SC_CLK_TCK (double)sysconf(_SC_CLK_TCK); @@ -3495,15 +5406,15 @@ rb_proc_times(obj) volatile VALUE utime, stime, cutime, sctime; times(&buf); - return rb_struct_new(S_Tms, - utime = rb_float_new(buf.tms_utime / hertz), - stime = rb_float_new(buf.tms_stime / hertz), - cutime = rb_float_new(buf.tms_cutime / hertz), - sctime = rb_float_new(buf.tms_cstime / hertz)); + return rb_struct_new(rb_cProcessTms, + utime = DBL2NUM(buf.tms_utime / hertz), + stime = DBL2NUM(buf.tms_stime / hertz), + cutime = DBL2NUM(buf.tms_cutime / hertz), + sctime = DBL2NUM(buf.tms_cstime / hertz)); +} #else - rb_notimplement(); +#define rb_proc_times rb_f_notimplement #endif -} VALUE rb_mProcess; VALUE rb_mProcUID; @@ -3517,19 +5428,21 @@ VALUE rb_mProcID_Syscall; */ void -Init_process() +Init_process(void) { + rb_define_virtual_variable("$?", rb_last_status_get, 0); rb_define_virtual_variable("$$", get_pid, 0); - rb_define_readonly_variable("$?", &rb_last_status); 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"); -#if !defined(_WIN32) && !defined(DJGPP) #ifdef WNOHANG rb_define_const(rb_mProcess, "WNOHANG", INT2FIX(WNOHANG)); #else @@ -3540,12 +5453,13 @@ Init_process() #else rb_define_const(rb_mProcess, "WUNTRACED", INT2FIX(0)); #endif -#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); /* in eval.c */ - rb_define_singleton_method(rb_mProcess, "abort", rb_f_abort, -1); /* in eval.c */ + 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); @@ -3555,27 +5469,26 @@ Init_process() rb_define_module_function(rb_mProcess, "waitall", proc_waitall, 0); rb_define_module_function(rb_mProcess, "detach", proc_detach, 1); - rb_cProcStatus = rb_define_class_under(rb_mProcess, "Status", rb_cObject); - rb_undef_method(CLASS_OF(rb_cProcStatus), "new"); + rb_cProcessStatus = rb_define_class_under(rb_mProcess, "Status", rb_cObject); + rb_undef_method(CLASS_OF(rb_cProcessStatus), "new"); - rb_define_method(rb_cProcStatus, "==", pst_equal, 1); - rb_define_method(rb_cProcStatus, "&", pst_bitand, 1); - rb_define_method(rb_cProcStatus, ">>", pst_rshift, 1); - rb_define_method(rb_cProcStatus, "to_i", pst_to_i, 0); - rb_define_method(rb_cProcStatus, "to_int", pst_to_i, 0); - rb_define_method(rb_cProcStatus, "to_s", pst_to_s, 0); - rb_define_method(rb_cProcStatus, "inspect", pst_inspect, 0); + 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_cProcStatus, "pid", pst_pid, 0); + rb_define_method(rb_cProcessStatus, "pid", pst_pid, 0); - rb_define_method(rb_cProcStatus, "stopped?", pst_wifstopped, 0); - rb_define_method(rb_cProcStatus, "stopsig", pst_wstopsig, 0); - rb_define_method(rb_cProcStatus, "signaled?", pst_wifsignaled, 0); - rb_define_method(rb_cProcStatus, "termsig", pst_wtermsig, 0); - rb_define_method(rb_cProcStatus, "exited?", pst_wifexited, 0); - rb_define_method(rb_cProcStatus, "exitstatus", pst_wexitstatus, 0); - rb_define_method(rb_cProcStatus, "success?", pst_success_p, 0); - rb_define_method(rb_cProcStatus, "coredump?", pst_wcoredump, 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); @@ -3599,15 +5512,22 @@ Init_process() rb_define_module_function(rb_mProcess, "getrlimit", proc_getrlimit, 1); rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, -1); #ifdef RLIM2NUM -#ifdef RLIM_INFINITY - rb_define_const(rb_mProcess, "RLIM_INFINITY", RLIM2NUM(RLIM_INFINITY)); -#endif + { + VALUE inf = RLIM2NUM(RLIM_INFINITY); #ifdef RLIM_SAVED_MAX - rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", RLIM2NUM(RLIM_SAVED_MAX)); + { + VALUE v = RLIM_INFINITY == RLIM_SAVED_MAX ? inf : RLIM2NUM(RLIM_SAVED_MAX); + rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", v); + } #endif + rb_define_const(rb_mProcess, "RLIM_INFINITY", inf); #ifdef RLIM_SAVED_CUR - rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", RLIM2NUM(RLIM_SAVED_CUR)); + { + VALUE v = RLIM_INFINITY == RLIM_SAVED_CUR ? inf : RLIM2NUM(RLIM_SAVED_CUR); + rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", v); + } #endif + } #ifdef RLIMIT_CORE rb_define_const(rb_mProcess, "RLIMIT_CORE", INT2FIX(RLIMIT_CORE)); #endif @@ -3648,19 +5568,21 @@ Init_process() 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, 1); + 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, 1); + 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); #if defined(HAVE_TIMES) || defined(_WIN32) - S_Tms = rb_struct_define("Tms", "utime", "stime", "cutime", "cstime", NULL); + rb_cProcessTms = rb_struct_define("Tms", "utime", "stime", "cutime", "cstime", NULL); #endif SAVED_USER_ID = geteuid(); |