/********************************************************************** process.c - $Author$ created at: Tue Aug 10 14:30:50 JST 1993 Copyright (C) 1993-2007 Yukihiro Matsumoto Copyright (C) 2000 Network Applied Communication Laboratory, Inc. Copyright (C) 2000 Information-technology Promotion Agency, Japan **********************************************************************/ #include "ruby/ruby.h" #include "ruby/io.h" #include "ruby/thread.h" #include "ruby/util.h" #include "internal.h" #include "vm_core.h" #include #include #include #ifdef HAVE_STDLIB_H #include #endif #ifdef HAVE_UNISTD_H #include #endif #ifdef HAVE_FCNTL_H #include #endif #ifdef HAVE_PROCESS_H #include #endif #include #include #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif #ifdef HAVE_SYS_WAIT_H # include #endif #ifdef HAVE_SYS_RESOURCE_H # include #endif #ifdef HAVE_SYS_PARAM_H # include #endif #ifndef MAXPATHLEN # define MAXPATHLEN 1024 #endif #include "ruby/st.h" #ifdef __EMX__ #undef HAVE_GETPGRP #endif #include #if defined(__native_client__) && defined(NACL_NEWLIB) # include "nacl/stat.h" # include "nacl/unistd.h" #endif #ifdef HAVE_SYS_TIME_H #include #endif #ifdef HAVE_SYS_TIMES_H #include #endif #ifdef HAVE_PWD_H #include #endif #ifdef HAVE_GRP_H #include #endif #ifdef __APPLE__ # include #endif #if defined(HAVE_TIMES) || defined(_WIN32) static VALUE rb_cProcessTms; #endif #ifndef WIFEXITED #define WIFEXITED(w) (((w) & 0xff) == 0) #endif #ifndef WIFSIGNALED #define WIFSIGNALED(w) (((w) & 0x7f) > 0 && (((w) & 0x7f) < 0x7f)) #endif #ifndef WIFSTOPPED #define WIFSTOPPED(w) (((w) & 0xff) == 0x7f) #endif #ifndef WEXITSTATUS #define WEXITSTATUS(w) (((w) >> 8) & 0xff) #endif #ifndef WTERMSIG #define WTERMSIG(w) ((w) & 0x7f) #endif #ifndef WSTOPSIG #define WSTOPSIG WEXITSTATUS #endif #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) #define HAVE_44BSD_SETUID 1 #define HAVE_44BSD_SETGID 1 #endif #ifdef __NetBSD__ #undef HAVE_SETRUID #undef HAVE_SETRGID #endif #ifdef BROKEN_SETREUID #define setreuid ruby_setreuid int setreuid(rb_uid_t ruid, rb_uid_t euid); #endif #ifdef BROKEN_SETREGID #define setregid ruby_setregid int setregid(rb_gid_t rgid, rb_gid_t egid); #endif #if defined(HAVE_44BSD_SETUID) || defined(__APPLE__) #if !defined(USE_SETREUID) && !defined(BROKEN_SETREUID) #define OBSOLETE_SETREUID 1 #endif #if !defined(USE_SETREGID) && !defined(BROKEN_SETREGID) #define OBSOLETE_SETREGID 1 #endif #endif #define preserving_errno(stmts) \ do {int saved_errno = errno; stmts; errno = saved_errno;} while (0) static void check_uid_switch(void); static void check_gid_switch(void); #if 1 #define p_uid_from_name p_uid_from_name #define p_gid_from_name p_gid_from_name #endif #if defined(HAVE_PWD_H) # if defined(HAVE_GETPWNAM_R) && defined(_SC_GETPW_R_SIZE_MAX) # define USE_GETPWNAM_R 1 # endif # ifdef USE_GETPWNAM_R # define PREPARE_GETPWNAM \ long getpw_buf_len = sysconf(_SC_GETPW_R_SIZE_MAX); \ char *getpw_buf = ALLOCA_N(char, (getpw_buf_len < 0 ? (getpw_buf_len = 4096) : getpw_buf_len)); # define OBJ2UID(id) obj2uid((id), getpw_buf, getpw_buf_len) static rb_uid_t obj2uid(VALUE id, char *getpw_buf, size_t getpw_buf_len); # else # define PREPARE_GETPWNAM /* do nothing */ # define OBJ2UID(id) obj2uid((id)) static rb_uid_t obj2uid(VALUE id); # endif #else # define PREPARE_GETPWNAM /* do nothing */ # define OBJ2UID(id) NUM2UIDT(id) # ifdef p_uid_from_name # undef p_uid_from_name # define p_uid_from_name rb_f_notimplement # endif #endif #if defined(HAVE_GRP_H) # if defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX) # define USE_GETGRNAM_R # endif # ifdef USE_GETGRNAM_R # define PREPARE_GETGRNAM \ long getgr_buf_len = sysconf(_SC_GETGR_R_SIZE_MAX); \ char *getgr_buf = ALLOCA_N(char, (getgr_buf_len < 0 ? (getgr_buf_len = 4096) : getgr_buf_len)); # define OBJ2GID(id) obj2gid((id), getgr_buf, getgr_buf_len) static rb_gid_t obj2gid(VALUE id, char *getgr_buf, size_t getgr_buf_len); # else # define PREPARE_GETGRNAM /* do nothing */ # define OBJ2GID(id) obj2gid((id)) static rb_gid_t obj2gid(VALUE id); # endif #else # define PREPARE_GETGRNAM /* do nothing */ # define OBJ2GID(id) NUM2GIDT(id) # ifdef p_gid_from_name # undef p_gid_from_name # define p_gid_from_name rb_f_notimplement # endif #endif /* * call-seq: * Process.pid -> fixnum * * Returns the process id of this process. Not available on all * platforms. * * Process.pid #=> 27415 */ static VALUE get_pid(void) { rb_secure(2); return PIDT2NUM(getpid()); } /* * call-seq: * Process.ppid -> fixnum * * Returns the process id of the parent of this process. Returns * untrustworthy value on Win32/64. Not available on all platforms. * * puts "I am #{Process.pid}" * Process.fork { puts "Dad is #{Process.ppid}" } * * produces: * * I am 27417 * Dad is 27417 */ static VALUE get_ppid(void) { rb_secure(2); return PIDT2NUM(getppid()); } /********************************************************************* * * Document-class: Process::Status * * Process::Status encapsulates the information on the * status of a running or terminated system process. The built-in * variable $? is either +nil+ or a * Process::Status object. * * fork { exit 99 } #=> 26557 * Process.wait #=> 26557 * $?.class #=> Process::Status * $?.to_i #=> 25344 * $? >> 8 #=> 99 * $?.stopped? #=> false * $?.exited? #=> true * $?.exitstatus #=> 99 * * Posix systems record information on processes using a 16-bit * integer. The lower bits record the process status (stopped, * exited, signaled) and the upper bits possibly contain additional * information (for example the program's return code in the case of * exited processes). Pre Ruby 1.8, these bits were exposed directly * to the Ruby program. Ruby now encapsulates these in a * Process::Status object. To maximize compatibility, * however, these objects retain a bit-oriented interface. In the * descriptions that follow, when we talk about the integer value of * _stat_, we're referring to this 16 bit value. */ static VALUE rb_cProcessStatus; VALUE rb_last_status_get(void) { return GET_THREAD()->last_status; } void rb_last_status_set(int status, rb_pid_t pid) { rb_thread_t *th = GET_THREAD(); th->last_status = rb_obj_alloc(rb_cProcessStatus); rb_iv_set(th->last_status, "status", INT2FIX(status)); rb_iv_set(th->last_status, "pid", PIDT2NUM(pid)); } void rb_last_status_clear(void) { GET_THREAD()->last_status = Qnil; } /* * call-seq: * stat.to_i -> fixnum * stat.to_int -> fixnum * * Returns the bits in _stat_ as a Fixnum. Poking * around in these bits is platform dependent. * * fork { exit 0xab } #=> 26566 * Process.wait #=> 26566 * sprintf('%04x', $?.to_i) #=> "ab00" */ static VALUE pst_to_i(VALUE st) { return rb_iv_get(st, "status"); } #define PST2INT(st) NUM2INT(pst_to_i(st)) /* * call-seq: * stat.pid -> fixnum * * Returns the process ID that this status object represents. * * fork { exit } #=> 26569 * Process.wait #=> 26569 * $?.pid #=> 26569 */ static VALUE pst_pid(VALUE st) { return rb_attr_get(st, rb_intern("pid")); } static void pst_message(VALUE str, rb_pid_t pid, int status) { rb_str_catf(str, "pid %ld", (long)pid); if (WIFSTOPPED(status)) { int stopsig = WSTOPSIG(status); const char *signame = ruby_signal_name(stopsig); if (signame) { rb_str_catf(str, " stopped SIG%s (signal %d)", signame, stopsig); } else { rb_str_catf(str, " stopped signal %d", stopsig); } } if (WIFSIGNALED(status)) { int termsig = WTERMSIG(status); const char *signame = ruby_signal_name(termsig); if (signame) { rb_str_catf(str, " SIG%s (signal %d)", signame, termsig); } else { rb_str_catf(str, " signal %d", termsig); } } if (WIFEXITED(status)) { rb_str_catf(str, " exit %d", WEXITSTATUS(status)); } #ifdef WCOREDUMP if (WCOREDUMP(status)) { rb_str_cat2(str, " (core dumped)"); } #endif } /* * call-seq: * stat.to_s -> string * * Show pid and exit status as a string. * * system("false") * p $?.to_s #=> "pid 12766 exit 1" * */ static VALUE pst_to_s(VALUE st) { rb_pid_t pid; int status; VALUE str; pid = NUM2PIDT(pst_pid(st)); status = PST2INT(st); str = rb_str_buf_new(0); pst_message(str, pid, status); return str; } /* * call-seq: * stat.inspect -> string * * Override the inspection method. * * system("false") * p $?.inspect #=> "#" * */ static VALUE pst_inspect(VALUE st) { rb_pid_t pid; int status; VALUE vpid, str; vpid = pst_pid(st); if (NIL_P(vpid)) { return rb_sprintf("#<%s: uninitialized>", rb_class2name(CLASS_OF(st))); } pid = NUM2PIDT(vpid); status = PST2INT(st); str = rb_sprintf("#<%s: ", rb_class2name(CLASS_OF(st))); pst_message(str, pid, status); rb_str_cat2(str, ">"); return str; } /* * call-seq: * stat == other -> true or false * * Returns +true+ if the integer value of _stat_ * equals other. */ static VALUE pst_equal(VALUE st1, VALUE st2) { if (st1 == st2) return Qtrue; return rb_equal(pst_to_i(st1), st2); } /* * call-seq: * stat & num -> fixnum * * Logical AND of the bits in _stat_ with num. * * fork { exit 0x37 } * Process.wait * sprintf('%04x', $?.to_i) #=> "3700" * sprintf('%04x', $? & 0x1e00) #=> "1600" */ static VALUE pst_bitand(VALUE st1, VALUE st2) { int status = PST2INT(st1) & NUM2INT(st2); return INT2NUM(status); } /* * call-seq: * stat >> num -> fixnum * * Shift the bits in _stat_ right num places. * * fork { exit 99 } #=> 26563 * Process.wait #=> 26563 * $?.to_i #=> 25344 * $? >> 8 #=> 99 */ static VALUE pst_rshift(VALUE st1, VALUE st2) { int status = PST2INT(st1) >> NUM2INT(st2); return INT2NUM(status); } /* * call-seq: * stat.stopped? -> true or false * * Returns +true+ if this process is stopped. This is only * returned if the corresponding wait call had the * WUNTRACED flag set. */ static VALUE pst_wifstopped(VALUE st) { int status = PST2INT(st); if (WIFSTOPPED(status)) return Qtrue; else return Qfalse; } /* * call-seq: * stat.stopsig -> fixnum or nil * * Returns the number of the signal that caused _stat_ to stop * (or +nil+ if self is not stopped). */ static VALUE pst_wstopsig(VALUE st) { int status = PST2INT(st); if (WIFSTOPPED(status)) return INT2NUM(WSTOPSIG(status)); return Qnil; } /* * call-seq: * stat.signaled? -> true or false * * Returns +true+ if _stat_ terminated because of * an uncaught signal. */ static VALUE pst_wifsignaled(VALUE st) { int status = PST2INT(st); if (WIFSIGNALED(status)) return Qtrue; else return Qfalse; } /* * call-seq: * stat.termsig -> fixnum or nil * * Returns the number of the signal that caused _stat_ to * terminate (or +nil+ if self was not terminated by an * uncaught signal). */ static VALUE pst_wtermsig(VALUE st) { int status = PST2INT(st); if (WIFSIGNALED(status)) return INT2NUM(WTERMSIG(status)); return Qnil; } /* * call-seq: * stat.exited? -> true or false * * Returns +true+ if _stat_ exited normally (for * example using an exit() call or finishing the * program). */ static VALUE pst_wifexited(VALUE st) { int status = PST2INT(st); if (WIFEXITED(status)) return Qtrue; else return Qfalse; } /* * call-seq: * stat.exitstatus -> fixnum or nil * * Returns the least significant eight bits of the return code of * _stat_. Only available if exited? is * +true+. * * fork { } #=> 26572 * Process.wait #=> 26572 * $?.exited? #=> true * $?.exitstatus #=> 0 * * fork { exit 99 } #=> 26573 * Process.wait #=> 26573 * $?.exited? #=> true * $?.exitstatus #=> 99 */ static VALUE pst_wexitstatus(VALUE st) { int status = PST2INT(st); if (WIFEXITED(status)) return INT2NUM(WEXITSTATUS(status)); return Qnil; } /* * call-seq: * stat.success? -> true, false or nil * * Returns +true+ if _stat_ is successful, +false+ if not. * Returns +nil+ if exited? is not +true+. */ static VALUE pst_success_p(VALUE st) { int status = PST2INT(st); if (!WIFEXITED(status)) return Qnil; return WEXITSTATUS(status) == EXIT_SUCCESS ? Qtrue : Qfalse; } /* * call-seq: * stat.coredump? -> true or false * * Returns +true+ if _stat_ generated a coredump * when it terminated. Not available on all platforms. */ static VALUE pst_wcoredump(VALUE st) { #ifdef WCOREDUMP int status = PST2INT(st); if (WCOREDUMP(status)) return Qtrue; else return Qfalse; #else return Qfalse; #endif } #if !defined(HAVE_WAITPID) && !defined(HAVE_WAIT4) #define NO_WAITPID static st_table *pid_tbl; struct wait_data { rb_pid_t pid; int status; }; static int wait_each(rb_pid_t pid, int status, struct wait_data *data) { if (data->status != -1) return ST_STOP; data->pid = pid; data->status = status; return ST_DELETE; } static int waitall_each(rb_pid_t pid, int status, VALUE ary) { rb_last_status_set(status, pid); rb_ary_push(ary, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get())); return ST_DELETE; } #else struct waitpid_arg { rb_pid_t pid; int *st; int flags; }; #endif static void * rb_waitpid_blocking(void *data) { rb_pid_t result; #ifndef NO_WAITPID struct waitpid_arg *arg = data; #endif #if defined NO_WAITPID result = wait(data); #elif defined HAVE_WAITPID result = waitpid(arg->pid, arg->st, arg->flags); #else /* HAVE_WAIT4 */ result = wait4(arg->pid, arg->st, arg->flags, NULL); #endif return (void *)(VALUE)result; } rb_pid_t rb_waitpid(rb_pid_t pid, int *st, int flags) { rb_pid_t result; #ifndef NO_WAITPID struct waitpid_arg arg; retry: arg.pid = pid; arg.st = st; arg.flags = flags; result = (rb_pid_t)(VALUE)rb_thread_call_without_gvl(rb_waitpid_blocking, &arg, RUBY_UBF_PROCESS, 0); if (result < 0) { if (errno == EINTR) { RUBY_VM_CHECK_INTS(GET_THREAD()); goto retry; } return (rb_pid_t)-1; } #else /* NO_WAITPID */ if (pid_tbl) { st_data_t status, piddata = (st_data_t)pid; if (pid == (rb_pid_t)-1) { struct wait_data data; data.pid = (rb_pid_t)-1; data.status = -1; st_foreach(pid_tbl, wait_each, (st_data_t)&data); if (data.status != -1) { rb_last_status_set(data.status, data.pid); return data.pid; } } else if (st_delete(pid_tbl, &piddata, &status)) { rb_last_status_set(*st = (int)status, pid); return pid; } } if (flags) { rb_raise(rb_eArgError, "can't do waitpid with flags"); } for (;;) { result = (rb_pid_t)(VALUE)rb_thread_blocking_region(rb_waitpid_blocking, st, RUBY_UBF_PROCESS, 0); if (result < 0) { if (errno == EINTR) { rb_thread_schedule(); continue; } return (rb_pid_t)-1; } if (result == pid || pid == (rb_pid_t)-1) { break; } if (!pid_tbl) pid_tbl = st_init_numtable(); st_insert(pid_tbl, pid, (st_data_t)st); if (!rb_thread_alone()) rb_thread_schedule(); } #endif if (result > 0) { rb_last_status_set(*st, result); } return result; } /* [MG]:FIXME: I wasn't sure how this should be done, since ::wait() has historically been documented as if it didn't take any arguments despite the fact that it's just an alias for ::waitpid(). The way I have it below is more truthful, but a little confusing. I also took the liberty of putting in the pid values, as they're pretty useful, and it looked as if the original 'ri' output was supposed to contain them after "[...]depending on the value of aPid:". The 'ansi' and 'bs' formats of the ri output don't display the definition list for some reason, but the plain text one does. */ /* * call-seq: * Process.wait() -> fixnum * Process.wait(pid=-1, flags=0) -> fixnum * Process.waitpid(pid=-1, flags=0) -> fixnum * * Waits for a child process to exit, returns its process id, and * sets $? to a Process::Status object * containing information on that process. Which child it waits on * depends on the value of _pid_: * * > 0:: Waits for the child whose process ID equals _pid_. * * 0:: Waits for any child whose process group ID equals that of the * calling process. * * -1:: Waits for any child process (the default if no _pid_ is * given). * * < -1:: Waits for any child whose process group ID equals the absolute * value of _pid_. * * The _flags_ argument may be a logical or of the flag values * Process::WNOHANG (do not block if no child available) * or Process::WUNTRACED (return stopped children that * haven't been reported). Not all flags are available on all * platforms, but a flag value of zero will work on all platforms. * * Calling this method raises a SystemCallError if there are no child * processes. Not available on all platforms. * * include Process * fork { exit 99 } #=> 27429 * wait #=> 27429 * $?.exitstatus #=> 99 * * pid = fork { sleep 3 } #=> 27440 * Time.now #=> 2008-03-08 19:56:16 +0900 * waitpid(pid, Process::WNOHANG) #=> nil * Time.now #=> 2008-03-08 19:56:16 +0900 * waitpid(pid, 0) #=> 27440 * Time.now #=> 2008-03-08 19:56:19 +0900 */ static VALUE proc_wait(int argc, VALUE *argv) { VALUE vpid, vflags; rb_pid_t pid; int flags, status; rb_secure(2); flags = 0; if (argc == 0) { pid = -1; } else { rb_scan_args(argc, argv, "02", &vpid, &vflags); pid = NUM2PIDT(vpid); if (argc == 2 && !NIL_P(vflags)) { flags = NUM2UINT(vflags); } } if ((pid = rb_waitpid(pid, &status, flags)) < 0) rb_sys_fail(0); if (pid == 0) { rb_last_status_clear(); return Qnil; } return PIDT2NUM(pid); } /* * call-seq: * Process.wait2(pid=-1, flags=0) -> [pid, status] * Process.waitpid2(pid=-1, flags=0) -> [pid, status] * * Waits for a child process to exit (see Process::waitpid for exact * semantics) and returns an array containing the process id and the * exit status (a Process::Status object) of that * child. Raises a SystemCallError if there are no child processes. * * Process.fork { exit 99 } #=> 27437 * pid, status = Process.wait2 * pid #=> 27437 * status.exitstatus #=> 99 */ static VALUE proc_wait2(int argc, VALUE *argv) { VALUE pid = proc_wait(argc, argv); if (NIL_P(pid)) return Qnil; return rb_assoc_new(pid, rb_last_status_get()); } /* * call-seq: * Process.waitall -> [ [pid1,status1], ...] * * Waits for all children, returning an array of * _pid_/_status_ pairs (where _status_ is a * Process::Status object). * * fork { sleep 0.2; exit 2 } #=> 27432 * fork { sleep 0.1; exit 1 } #=> 27433 * fork { exit 0 } #=> 27434 * p Process.waitall * * produces: * * [[30982, #], * [30979, #], * [30976, #]] */ static VALUE proc_waitall(void) { VALUE result; rb_pid_t pid; int status; rb_secure(2); result = rb_ary_new(); #ifdef NO_WAITPID if (pid_tbl) { st_foreach(pid_tbl, waitall_each, result); } #else rb_last_status_clear(); #endif for (pid = -1;;) { #ifdef NO_WAITPID pid = wait(&status); #else pid = rb_waitpid(-1, &status, 0); #endif if (pid == -1) { if (errno == ECHILD) break; #ifdef NO_WAITPID if (errno == EINTR) { rb_thread_schedule(); continue; } #endif rb_sys_fail(0); } #ifdef NO_WAITPID rb_last_status_set(status, pid); #endif rb_ary_push(result, rb_assoc_new(PIDT2NUM(pid), rb_last_status_get())); } return result; } static inline ID id_pid(void) { ID pid; CONST_ID(pid, "pid"); return pid; } static VALUE detach_process_pid(VALUE thread) { return rb_thread_local_aref(thread, id_pid()); } static VALUE detach_process_watcher(void *arg) { rb_pid_t cpid, pid = (rb_pid_t)(VALUE)arg; int status; while ((cpid = rb_waitpid(pid, &status, 0)) == 0) { /* wait while alive */ } return rb_last_status_get(); } VALUE rb_detach_process(rb_pid_t pid) { VALUE watcher = rb_thread_create(detach_process_watcher, (void*)(VALUE)pid); rb_thread_local_aset(watcher, id_pid(), PIDT2NUM(pid)); rb_define_singleton_method(watcher, "pid", detach_process_pid, 0); return watcher; } /* * call-seq: * Process.detach(pid) -> thread * * Some operating systems retain the status of terminated child * processes until the parent collects that status (normally using * some variant of wait(). If the parent never collects * this status, the child stays around as a zombie process. * Process::detach prevents this by setting up a * separate Ruby thread whose sole job is to reap the status of the * process _pid_ when it terminates. Use detach * only when you do not intent to explicitly wait for the child to * terminate. * * The waiting thread returns the exit status of the detached process * when it terminates, so you can use Thread#join to * know the result. If specified _pid_ is not a valid child process * ID, the thread returns +nil+ immediately. * * The waiting thread has pid method which returns the pid. * * In this first example, we don't reap the first child process, so * it appears as a zombie in the process status display. * * p1 = fork { sleep 0.1 } * p2 = fork { sleep 0.2 } * Process.waitpid(p2) * sleep 2 * system("ps -ho pid,state -p #{p1}") * * produces: * * 27389 Z * * In the next example, Process::detach is used to reap * the child automatically. * * p1 = fork { sleep 0.1 } * p2 = fork { sleep 0.2 } * Process.detach(p1) * Process.waitpid(p2) * sleep 2 * system("ps -ho pid,state -p #{p1}") * * (produces no output) */ static VALUE proc_detach(VALUE obj, VALUE pid) { rb_secure(2); return rb_detach_process(NUM2PIDT(pid)); } static int forked_child = 0; #ifdef SIGPIPE static RETSIGTYPE (*saved_sigpipe_handler)(int) = 0; #endif #ifdef SIGPIPE static RETSIGTYPE sig_do_nothing(int sig) { } #endif /* This function should be async-signal-safe. Actually it is. */ static void before_exec_async_signal_safe(void) { #ifdef SIGPIPE /* * Some OS commands don't initialize signal handler properly. Thus we have * to reset signal handler before exec(). Otherwise, system() and similar * child process interaction might fail. (e.g. ruby -e "system 'yes | ls'") * [ruby-dev:12261] */ saved_sigpipe_handler = signal(SIGPIPE, sig_do_nothing); /* async-signal-safe */ #endif } static void before_exec_non_async_signal_safe(void) { if (!forked_child) { /* * On Mac OS X 10.5.x (Leopard) or earlier, exec() may return ENOTSUPP * if the process have multiple threads. Therefore we have to kill * internal threads temporary. [ruby-core:10583] * This is also true on Haiku. It returns Errno::EPERM against exec() * in multiple threads. */ rb_thread_stop_timer_thread(0); } } static void before_exec(void) { before_exec_non_async_signal_safe(); before_exec_async_signal_safe(); } /* This function should be async-signal-safe. Actually it is. */ static void after_exec_async_signal_safe(void) { #ifdef SIGPIPE signal(SIGPIPE, saved_sigpipe_handler); /* async-signal-safe */ #endif } static void after_exec_non_async_signal_safe(void) { rb_thread_reset_timer_thread(); rb_thread_start_timer_thread(); forked_child = 0; } static void after_exec(void) { after_exec_async_signal_safe(); after_exec_non_async_signal_safe(); } #define before_fork() before_exec() #define after_fork() (rb_threadptr_pending_interrupt_clear(GET_THREAD()), after_exec()) #include "dln.h" static void security(const char *str) { if (rb_env_path_tainted()) { if (rb_safe_level() > 0) { rb_raise(rb_eSecurityError, "Insecure PATH - %s", str); } } } #if defined(HAVE_FORK) && !defined(__native_client__) /* try_with_sh and exec_with_sh should be async-signal-safe. Actually it is.*/ #define try_with_sh(prog, argv, envp) ((saved_errno == ENOEXEC) ? exec_with_sh((prog), (argv), (envp)) : (void)0) static void exec_with_sh(const char *prog, char **argv, char **envp) { *argv = (char *)prog; *--argv = (char *)"sh"; if (envp) execve("/bin/sh", argv, envp); /* async-signal-safe */ else execv("/bin/sh", argv); /* async-signal-safe */ } #else #define try_with_sh(prog, argv, envp) (void)0 #endif /* This function should be async-signal-safe. Actually it is. */ static int proc_exec_cmd(const char *prog, VALUE argv_str, VALUE envp_str) { #ifdef __native_client__ rb_notimplement(); UNREACHABLE; #else char **argv; char **envp; # if defined(__EMX__) || defined(OS2) char **new_argv = NULL; # endif argv = ARGVSTR2ARGV(argv_str); if (!prog) { errno = ENOENT; return -1; } # if defined(__EMX__) || defined(OS2) { # define COMMAND "cmd.exe" char *extension; if ((extension = strrchr(prog, '.')) != NULL && STRCASECMP(extension, ".bat") == 0) { char *p; int n; for (n = 0; argv[n]; n++) /* no-op */; new_argv = ALLOC_N(char*, n + 2); for (; n > 0; n--) new_argv[n + 1] = argv[n]; new_argv[1] = strcpy(ALLOC_N(char, strlen(argv[0]) + 1), argv[0]); for (p = new_argv[1]; *p != '\0'; p++) if (*p == '/') *p = '\\'; new_argv[0] = COMMAND; argv = new_argv; prog = dln_find_exe_r(argv[0], 0, fbuf, sizeof(fbuf)); if (!prog) { errno = ENOENT; return -1; } } } # endif /* __EMX__ */ envp = envp_str ? (char **)RSTRING_PTR(envp_str) : NULL; if (envp_str) execve(prog, argv, envp); /* async-signal-safe */ else execv(prog, argv); /* async-signal-safe */ preserving_errno(try_with_sh(prog, argv, envp)); /* try_with_sh() is async-signal-safe. */ # if defined(__EMX__) || defined(OS2) if (new_argv) { xfree(new_argv[0]); xfree(new_argv); } # endif return -1; #endif } /* deprecated */ static int proc_exec_v(char **argv, const char *prog) { char fbuf[MAXPATHLEN]; if (!prog) prog = argv[0]; prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf)); if (!prog) { errno = ENOENT; return -1; } before_exec(); execv(prog, argv); preserving_errno(try_with_sh(prog, argv, 0); after_exec()); return -1; } /* deprecated */ int rb_proc_exec_n(int argc, VALUE *argv, const char *prog) { #define ARGV_COUNT(n) ((n)+1) #define ARGV_SIZE(n) (sizeof(char*) * ARGV_COUNT(n)) #define ALLOC_ARGV(n, v) ALLOCV_N(char*, (v), ARGV_COUNT(n)) char **args; int i; int ret = -1; VALUE v; args = ALLOC_ARGV(argc+1, v); for (i=0; iuse_shell) rb_gc_mark(eargp->invoke.sh.shell_script); else { rb_gc_mark(eargp->invoke.cmd.command_name); rb_gc_mark(eargp->invoke.cmd.command_abspath); rb_gc_mark(eargp->invoke.cmd.argv_str); rb_gc_mark(eargp->invoke.cmd.argv_buf); } rb_gc_mark(eargp->redirect_fds); rb_gc_mark(eargp->envp_str); rb_gc_mark(eargp->envp_buf); rb_gc_mark(eargp->dup2_tmpbuf); rb_gc_mark(eargp->rlimit_limits); rb_gc_mark(eargp->fd_dup2); rb_gc_mark(eargp->fd_close); rb_gc_mark(eargp->fd_open); rb_gc_mark(eargp->fd_dup2_child); rb_gc_mark(eargp->env_modification); rb_gc_mark(eargp->chdir_dir); } static void free_exec_arg(void *ptr) { xfree(ptr); } static size_t memsize_exec_arg(const void *ptr) { return ptr ? sizeof(struct rb_execarg) : 0; } static const rb_data_type_t exec_arg_data_type = { "exec_arg", {mark_exec_arg, free_exec_arg, memsize_exec_arg}, }; #ifdef _WIN32 # define DEFAULT_PROCESS_ENCODING rb_utf8_encoding() #endif #ifdef DEFAULT_PROCESS_ENCODING # define EXPORT_STR(str) rb_str_export_to_enc((str), DEFAULT_PROCESS_ENCODING) # define EXPORT_DUP(str) export_dup(str) static VALUE export_dup(VALUE str) { VALUE newstr = EXPORT_STR(str); if (newstr == str) newstr = rb_str_dup(str); return newstr; } #else # define EXPORT_STR(str) (str) # define EXPORT_DUP(str) rb_str_dup(str) #endif #if !defined(HAVE_FORK) && defined(HAVE_SPAWNV) # define USE_SPAWNV 1 #else # define USE_SPAWNV 0 #endif #ifndef P_NOWAIT # define P_NOWAIT _P_NOWAIT #endif #if USE_SPAWNV #if defined(_WIN32) #define proc_spawn_cmd_internal(argv, prog) rb_w32_uaspawn(P_NOWAIT, (prog), (argv)) #else static rb_pid_t proc_spawn_cmd_internal(char **argv, char *prog) { char fbuf[MAXPATHLEN]; rb_pid_t status; if (!prog) prog = argv[0]; security(prog); prog = dln_find_exe_r(prog, 0, fbuf, sizeof(fbuf)); if (!prog) return -1; before_exec(); status = spawnv(P_NOWAIT, prog, (const char **)argv); if (status == -1 && errno == ENOEXEC) { *argv = (char *)prog; *--argv = (char *)"sh"; status = spawnv(P_NOWAIT, "/bin/sh", (const char **)argv); after_exec(); if (status == -1) errno = ENOEXEC; } return status; } #endif static rb_pid_t proc_spawn_cmd(char **argv, VALUE prog, struct rb_execarg *eargp) { rb_pid_t pid = -1; if (argv[0]) { #if defined(_WIN32) DWORD flags = 0; if (eargp->new_pgroup_given && eargp->new_pgroup_flag) { flags = CREATE_NEW_PROCESS_GROUP; } pid = rb_w32_uaspawn_flags(P_NOWAIT, prog ? RSTRING_PTR(prog) : 0, argv, flags); #else pid = proc_spawn_cmd_internal(argv, prog ? RSTRING_PTR(prog) : 0); #endif } return pid; } #if defined(_WIN32) #define proc_spawn_sh(str) rb_w32_uspawn(P_NOWAIT, (str), 0) #else static rb_pid_t proc_spawn_sh(char *str) { char fbuf[MAXPATHLEN]; rb_pid_t status; char *shell = dln_find_exe_r("sh", 0, fbuf, sizeof(fbuf)); before_exec(); status = spawnl(P_NOWAIT, (shell ? shell : "/bin/sh"), "sh", "-c", str, (char*)NULL); after_exec(); return status; } #endif #endif static VALUE hide_obj(VALUE obj) { RBASIC_CLEAR_CLASS(obj); return obj; } static VALUE check_exec_redirect_fd(VALUE v, int iskey) { VALUE tmp; int fd; if (FIXNUM_P(v)) { fd = FIX2INT(v); } else if (SYMBOL_P(v)) { ID id = 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 { wrong: rb_raise(rb_eArgError, "wrong exec redirect"); } if (fd < 0) { rb_raise(rb_eArgError, "negative file descriptor"); } #ifdef _WIN32 else if (fd >= 3 && iskey) { rb_raise(rb_eArgError, "wrong file descriptor (%d)", fd); } #endif return INT2FIX(fd); } static VALUE check_exec_redirect1(VALUE ary, VALUE key, VALUE param) { if (ary == Qfalse) { ary = hide_obj(rb_ary_new()); } if (!RB_TYPE_P(key, T_ARRAY)) { VALUE fd = check_exec_redirect_fd(key, !NIL_P(param)); rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param))); } else { int i, n=0; for (i = 0 ; i < RARRAY_LEN(key); i++) { VALUE v = RARRAY_AREF(key, i); VALUE fd = check_exec_redirect_fd(v, !NIL_P(param)); rb_ary_push(ary, hide_obj(rb_assoc_new(fd, param))); n++; } } return ary; } static void check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp) { VALUE param; VALUE path, flags, perm; VALUE tmp; ID id; switch (TYPE(val)) { case T_SYMBOL: id = SYM2ID(val); if (id == rb_intern("close")) { param = Qnil; eargp->fd_close = check_exec_redirect1(eargp->fd_close, key, param); } else if (id == rb_intern("in")) { param = INT2FIX(0); eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param); } else if (id == rb_intern("out")) { param = INT2FIX(1); eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param); } else if (id == rb_intern("err")) { param = INT2FIX(2); eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param); } else { rb_raise(rb_eArgError, "wrong exec redirect symbol: %s", rb_id2name(id)); } break; case T_FILE: io: val = check_exec_redirect_fd(val, 0); /* fall through */ case T_FIXNUM: param = val; eargp->fd_dup2 = check_exec_redirect1(eargp->fd_dup2, key, param); break; case T_ARRAY: path = rb_ary_entry(val, 0); if (RARRAY_LEN(val) == 2 && SYMBOL_P(path) && SYM2ID(path) == rb_intern("child")) { param = check_exec_redirect_fd(rb_ary_entry(val, 1), 0); eargp->fd_dup2_child = check_exec_redirect1(eargp->fd_dup2_child, key, param); } else { FilePathValue(path); flags = rb_ary_entry(val, 1); if (NIL_P(flags)) flags = INT2NUM(O_RDONLY); else if (RB_TYPE_P(flags, T_STRING)) flags = INT2NUM(rb_io_modestr_oflags(StringValueCStr(flags))); else flags = rb_to_int(flags); perm = rb_ary_entry(val, 2); perm = NIL_P(perm) ? INT2FIX(0644) : rb_to_int(perm); param = hide_obj(rb_ary_new3(3, hide_obj(EXPORT_DUP(path)), flags, perm)); eargp->fd_open = check_exec_redirect1(eargp->fd_open, key, param); } break; case T_STRING: path = val; FilePathValue(path); if (RB_TYPE_P(key, T_FILE)) key = check_exec_redirect_fd(key, 1); if (FIXNUM_P(key) && (FIX2INT(key) == 1 || FIX2INT(key) == 2)) flags = INT2NUM(O_WRONLY|O_CREAT|O_TRUNC); else flags = INT2NUM(O_RDONLY); perm = INT2FIX(0644); param = hide_obj(rb_ary_new3(3, hide_obj(EXPORT_DUP(path)), flags, perm)); eargp->fd_open = check_exec_redirect1(eargp->fd_open, key, param); break; default: tmp = val; val = rb_io_check_io(tmp); if (!NIL_P(val)) goto io; rb_raise(rb_eArgError, "wrong exec redirect action"); } } #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) static int rlimit_type_by_lname(const char *name); #endif int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); ID id; #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) int rtype; #endif rb_secure(2); switch (TYPE(key)) { case T_SYMBOL: id = SYM2ID(key); #ifdef HAVE_SETPGID if (id == rb_intern("pgroup")) { rb_pid_t pgroup; if (eargp->pgroup_given) { rb_raise(rb_eArgError, "pgroup option specified twice"); } if (!RTEST(val)) pgroup = -1; /* asis(-1) means "don't call setpgid()". */ else if (val == Qtrue) pgroup = 0; /* new process group. */ else { pgroup = NUM2PIDT(val); if (pgroup < 0) { rb_raise(rb_eArgError, "negative process group ID : %ld", (long)pgroup); } } eargp->pgroup_given = 1; eargp->pgroup_pgid = pgroup; } else #endif #ifdef _WIN32 if (id == rb_intern("new_pgroup")) { if (eargp->new_pgroup_given) { rb_raise(rb_eArgError, "new_pgroup option specified twice"); } eargp->new_pgroup_given = 1; eargp->new_pgroup_flag = RTEST(val) ? 1 : 0; } else #endif #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) if (strncmp("rlimit_", rb_id2name(id), 7) == 0 && (rtype = rlimit_type_by_lname(rb_id2name(id)+7)) != -1) { VALUE ary = eargp->rlimit_limits; VALUE tmp, softlim, hardlim; if (eargp->rlimit_limits == Qfalse) ary = eargp->rlimit_limits = hide_obj(rb_ary_new()); else ary = eargp->rlimit_limits; tmp = rb_check_array_type(val); if (!NIL_P(tmp)) { if (RARRAY_LEN(tmp) == 1) softlim = hardlim = rb_to_int(rb_ary_entry(tmp, 0)); else if (RARRAY_LEN(tmp) == 2) { softlim = rb_to_int(rb_ary_entry(tmp, 0)); hardlim = rb_to_int(rb_ary_entry(tmp, 1)); } else { rb_raise(rb_eArgError, "wrong exec rlimit option"); } } else { softlim = hardlim = rb_to_int(val); } tmp = hide_obj(rb_ary_new3(3, INT2NUM(rtype), softlim, hardlim)); rb_ary_push(ary, tmp); } else #endif if (id == rb_intern("unsetenv_others")) { if (eargp->unsetenv_others_given) { rb_raise(rb_eArgError, "unsetenv_others option specified twice"); } eargp->unsetenv_others_given = 1; eargp->unsetenv_others_do = RTEST(val) ? 1 : 0; } else if (id == rb_intern("chdir")) { if (eargp->chdir_given) { rb_raise(rb_eArgError, "chdir option specified twice"); } FilePathValue(val); eargp->chdir_given = 1; eargp->chdir_dir = hide_obj(EXPORT_DUP(val)); } else if (id == rb_intern("umask")) { mode_t cmask = NUM2MODET(val); if (eargp->umask_given) { rb_raise(rb_eArgError, "umask option specified twice"); } eargp->umask_given = 1; eargp->umask_mask = cmask; } else if (id == rb_intern("close_others")) { if (eargp->close_others_given) { rb_raise(rb_eArgError, "close_others option specified twice"); } eargp->close_others_given = 1; eargp->close_others_do = RTEST(val) ? 1 : 0; } else if (id == 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 if (id == rb_intern("uid")) { #ifdef HAVE_SETUID if (eargp->uid_given) { rb_raise(rb_eArgError, "uid option specified twice"); } check_uid_switch(); { PREPARE_GETPWNAM; eargp->uid = OBJ2UID(val); eargp->uid_given = 1; } #else rb_raise(rb_eNotImpError, "uid option is unimplemented on this machine"); #endif } else if (id == rb_intern("gid")) { #ifdef HAVE_SETGID if (eargp->gid_given) { rb_raise(rb_eArgError, "gid option specified twice"); } check_gid_switch(); { PREPARE_GETGRNAM; eargp->gid = OBJ2GID(val); eargp->gid_given = 1; } #else rb_raise(rb_eNotImpError, "gid option is unimplemented on this machine"); #endif } else { return ST_STOP; } break; case T_FIXNUM: case T_FILE: case T_ARRAY: redirect: check_exec_redirect(key, val, eargp); break; default: return ST_STOP; } RB_GC_GUARD(execarg_obj); return ST_CONTINUE; } int rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val) { return rb_execarg_addopt(e->execarg_obj, key, val); } static int check_exec_options_i(st_data_t st_key, st_data_t st_val, st_data_t arg) { VALUE key = (VALUE)st_key; VALUE val = (VALUE)st_val; VALUE execarg_obj = (VALUE)arg; if (rb_execarg_addopt(execarg_obj, key, val) != ST_CONTINUE) { if (SYMBOL_P(key)) rb_raise(rb_eArgError, "wrong exec option symbol: %"PRIsVALUE, key); rb_raise(rb_eArgError, "wrong exec option"); } return ST_CONTINUE; } static int check_exec_options_i_extract(st_data_t st_key, st_data_t st_val, st_data_t arg) { VALUE key = (VALUE)st_key; VALUE val = (VALUE)st_val; VALUE *args = (VALUE *)arg; VALUE execarg_obj = args[0]; if (rb_execarg_addopt(execarg_obj, key, val) != ST_CONTINUE) { VALUE nonopts = args[1]; if (NIL_P(nonopts)) args[1] = nonopts = rb_hash_new(); rb_hash_aset(nonopts, key, val); } return ST_CONTINUE; } static int check_exec_fds_1(struct rb_execarg *eargp, VALUE h, int maxhint, VALUE ary) { long i; if (ary != Qfalse) { for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); int fd = FIX2INT(RARRAY_AREF(elt, 0)); if (RTEST(rb_hash_lookup(h, INT2FIX(fd)))) { rb_raise(rb_eArgError, "fd %d specified twice", fd); } if (ary == eargp->fd_open || ary == eargp->fd_dup2) rb_hash_aset(h, INT2FIX(fd), Qtrue); else if (ary == eargp->fd_dup2_child) rb_hash_aset(h, INT2FIX(fd), RARRAY_AREF(elt, 1)); else /* ary == eargp->fd_close */ rb_hash_aset(h, INT2FIX(fd), INT2FIX(-1)); if (maxhint < fd) maxhint = fd; if (ary == eargp->fd_dup2 || ary == eargp->fd_dup2_child) { fd = FIX2INT(RARRAY_AREF(elt, 1)); if (maxhint < fd) maxhint = fd; } } } return maxhint; } static VALUE check_exec_fds(struct rb_execarg *eargp) { VALUE h = rb_hash_new(); VALUE ary; int maxhint = -1; long i; maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_dup2); maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_close); maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_open); maxhint = check_exec_fds_1(eargp, h, maxhint, eargp->fd_dup2_child); if (eargp->fd_dup2_child) { ary = eargp->fd_dup2_child; for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); int newfd = FIX2INT(RARRAY_AREF(elt, 0)); int oldfd = FIX2INT(RARRAY_AREF(elt, 1)); int lastfd = oldfd; VALUE val = rb_hash_lookup(h, INT2FIX(lastfd)); long depth = 0; while (FIXNUM_P(val) && 0 <= FIX2INT(val)) { lastfd = FIX2INT(val); val = rb_hash_lookup(h, val); if (RARRAY_LEN(ary) < depth) rb_raise(rb_eArgError, "cyclic child fd redirection from %d", oldfd); depth++; } if (val != Qtrue) rb_raise(rb_eArgError, "child fd %d is not redirected", oldfd); if (oldfd != lastfd) { VALUE val2; rb_ary_store(elt, 1, INT2FIX(lastfd)); rb_hash_aset(h, INT2FIX(newfd), INT2FIX(lastfd)); val = INT2FIX(oldfd); while (FIXNUM_P(val2 = rb_hash_lookup(h, val))) { rb_hash_aset(h, val, INT2FIX(lastfd)); val = val2; } } } } eargp->close_others_maxhint = maxhint; return h; } static void rb_check_exec_options(VALUE opthash, VALUE execarg_obj) { if (RHASH_EMPTY_P(opthash)) return; st_foreach(rb_hash_tbl_raw(opthash), check_exec_options_i, (st_data_t)execarg_obj); } VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash) { VALUE args[2]; if (RHASH_EMPTY_P(opthash)) return Qnil; args[0] = execarg_obj; args[1] = Qnil; st_foreach(rb_hash_tbl_raw(opthash), check_exec_options_i_extract, (st_data_t)args); return args[1]; } static int check_exec_env_i(st_data_t st_key, st_data_t st_val, st_data_t arg) { VALUE key = (VALUE)st_key; VALUE val = (VALUE)st_val; VALUE env = (VALUE)arg; char *k; k = StringValueCStr(key); if (strchr(k, '=')) rb_raise(rb_eArgError, "environment name contains a equal : %s", k); if (!NIL_P(val)) StringValueCStr(val); key = EXPORT_STR(key); if (!NIL_P(val)) val = EXPORT_STR(val); rb_ary_push(env, hide_obj(rb_assoc_new(key, val))); return ST_CONTINUE; } static VALUE rb_check_exec_env(VALUE hash) { VALUE env; env = hide_obj(rb_ary_new()); st_foreach(rb_hash_tbl_raw(hash), check_exec_env_i, (st_data_t)env); return env; } static VALUE rb_check_argv(int argc, VALUE *argv) { VALUE tmp, prog; int i; const char *name = 0; rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS); prog = 0; tmp = rb_check_array_type(argv[0]); if (!NIL_P(tmp)) { if (RARRAY_LEN(tmp) != 2) { rb_raise(rb_eArgError, "wrong first argument"); } prog = RARRAY_AREF(tmp, 0); argv[0] = RARRAY_AREF(tmp, 1); SafeStringValue(prog); StringValueCStr(prog); prog = rb_str_new_frozen(prog); name = RSTRING_PTR(prog); } for (i = 0; i < argc; i++) { SafeStringValue(argv[i]); argv[i] = rb_str_new_frozen(argv[i]); StringValueCStr(argv[i]); } security(name ? name : RSTRING_PTR(argv[0])); return prog; } static VALUE rb_exec_getargs(int *argc_p, VALUE **argv_p, int accept_shell, VALUE *env_ret, VALUE *opthash_ret) { VALUE hash, prog; if (0 < *argc_p) { hash = rb_check_hash_type((*argv_p)[*argc_p-1]); if (!NIL_P(hash)) { *opthash_ret = hash; (*argc_p)--; } } if (0 < *argc_p) { hash = rb_check_hash_type((*argv_p)[0]); if (!NIL_P(hash)) { *env_ret = hash; (*argc_p)--; (*argv_p)++; } } prog = rb_check_argv(*argc_p, *argv_p); if (!prog) { prog = (*argv_p)[0]; if (accept_shell && *argc_p == 1) { *argc_p = 0; *argv_p = 0; } } return prog; } #ifndef _WIN32 struct string_part { const char *ptr; size_t len; }; static int compare_posix_sh(const void *key, const void *el) { const struct string_part *word = key; int ret = strncmp(word->ptr, el, word->len); if (!ret && ((const char *)el)[word->len]) ret = -1; return ret; } #endif static void rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VALUE execarg_obj) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); char fbuf[MAXPATHLEN]; MEMZERO(eargp, struct rb_execarg, 1); if (!NIL_P(opthash)) { rb_check_exec_options(opthash, execarg_obj); } if (!NIL_P(env)) { env = rb_check_exec_env(env); eargp->env_modification = env; } prog = EXPORT_STR(prog); eargp->use_shell = argc == 0; if (eargp->use_shell) eargp->invoke.sh.shell_script = prog; else eargp->invoke.cmd.command_name = prog; #ifndef _WIN32 if (eargp->use_shell) { static const char posix_sh_cmds[][9] = { "!", /* reserved */ ".", /* special built-in */ ":", /* special built-in */ "break", /* special built-in */ "case", /* reserved */ "continue", /* special built-in */ "do", /* reserved */ "done", /* reserved */ "elif", /* reserved */ "else", /* reserved */ "esac", /* reserved */ "eval", /* special built-in */ "exec", /* special built-in */ "exit", /* special built-in */ "export", /* special built-in */ "fi", /* reserved */ "for", /* reserved */ "if", /* reserved */ "in", /* reserved */ "readonly", /* special built-in */ "return", /* special built-in */ "set", /* special built-in */ "shift", /* special built-in */ "then", /* reserved */ "times", /* special built-in */ "trap", /* special built-in */ "unset", /* special built-in */ "until", /* reserved */ "while", /* reserved */ }; const char *p; struct string_part first = {0, 0}; int has_meta = 0; /* * meta characters: * * * Pathname Expansion * ? Pathname Expansion * {} Grouping Commands * [] Pathname Expansion * <> Redirection * () Grouping Commands * ~ Tilde Expansion * & AND Lists, Asynchronous Lists * | OR Lists, Pipelines * \ Escape Character * $ Parameter Expansion * ; Sequential Lists * ' Single-Quotes * ` Command Substitution * " Double-Quotes * \n Lists * * # Comment * = Assignment preceding command name * % (used in Parameter Expansion) */ for (p = RSTRING_PTR(prog); *p; p++) { if (*p == ' ' || *p == '\t') { if (first.ptr && !first.len) first.len = p - first.ptr; } else { if (!first.ptr) first.ptr = p; } if (!has_meta && strchr("*?{}[]<>()~&|\\$;'`\"\n#", *p)) has_meta = 1; if (!first.len) { if (*p == '=') { has_meta = 1; } else if (*p == '/') { first.len = 0x100; /* longer than any posix_sh_cmds */ } } if (has_meta) break; } if (!has_meta && first.ptr) { if (!first.len) first.len = p - first.ptr; if (first.len > 0 && first.len <= sizeof(posix_sh_cmds[0]) && bsearch(&first, posix_sh_cmds, numberof(posix_sh_cmds), sizeof(posix_sh_cmds[0]), compare_posix_sh)) has_meta = 1; } if (!has_meta) { /* avoid shell since no shell meta character found. */ eargp->use_shell = 0; } if (!eargp->use_shell) { VALUE argv_buf; argv_buf = hide_obj(rb_str_buf_new(0)); p = RSTRING_PTR(prog); while (*p) { while (*p == ' ' || *p == '\t') p++; if (*p) { const char *w = p; while (*p && *p != ' ' && *p != '\t') p++; rb_str_buf_cat(argv_buf, w, p-w); rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */ } } eargp->invoke.cmd.argv_buf = argv_buf; eargp->invoke.cmd.command_name = hide_obj(rb_str_new_cstr(RSTRING_PTR(argv_buf))); } } #endif if (!eargp->use_shell) { const char *abspath; abspath = dln_find_exe_r(RSTRING_PTR(eargp->invoke.cmd.command_name), 0, fbuf, sizeof(fbuf)); if (abspath) eargp->invoke.cmd.command_abspath = rb_str_new_cstr(abspath); else eargp->invoke.cmd.command_abspath = Qnil; } if (!eargp->use_shell && !eargp->invoke.cmd.argv_buf) { int i; VALUE argv_buf; argv_buf = rb_str_buf_new(0); hide_obj(argv_buf); for (i = 0; i < argc; i++) { VALUE arg = argv[i]; const char *s = StringValueCStr(arg); #ifdef DEFAULT_PROCESS_ENCODING arg = EXPORT_STR(arg); s = RSTRING_PTR(arg); #endif rb_str_buf_cat(argv_buf, s, RSTRING_LEN(arg) + 1); /* include '\0' */ } eargp->invoke.cmd.argv_buf = argv_buf; } if (!eargp->use_shell) { const char *p, *ep, *null=NULL; VALUE argv_str; argv_str = hide_obj(rb_str_buf_new(sizeof(char*) * (argc + 2))); rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* place holder for /bin/sh of try_with_sh. */ p = RSTRING_PTR(eargp->invoke.cmd.argv_buf); ep = p + RSTRING_LEN(eargp->invoke.cmd.argv_buf); while (p < ep) { rb_str_buf_cat(argv_str, (char *)&p, sizeof(p)); p += strlen(p) + 1; } rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* terminator for execve. */ eargp->invoke.cmd.argv_str = argv_str; } RB_GC_GUARD(execarg_obj); } VALUE rb_execarg_new(int argc, VALUE *argv, int accept_shell) { VALUE execarg_obj; struct rb_execarg *eargp; execarg_obj = TypedData_Make_Struct(rb_cData, struct rb_execarg, &exec_arg_data_type, eargp); hide_obj(execarg_obj); rb_execarg_init(argc, argv, accept_shell, execarg_obj); return execarg_obj; } struct rb_execarg * rb_execarg_get(VALUE execarg_obj) { struct rb_execarg *eargp; TypedData_Get_Struct(execarg_obj, struct rb_execarg, &exec_arg_data_type, eargp); return eargp; } VALUE rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); VALUE prog, ret; VALUE env = Qnil, opthash = Qnil; prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash); rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj); ret = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; RB_GC_GUARD(execarg_obj); return ret; } VALUE rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e) { return rb_execarg_init(argc, argv, accept_shell, e->execarg_obj); } void rb_execarg_setenv(VALUE execarg_obj, VALUE env) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); env = !NIL_P(env) ? rb_check_exec_env(env) : Qfalse; eargp->env_modification = env; } static int fill_envp_buf_i(st_data_t st_key, st_data_t st_val, st_data_t arg) { VALUE key = (VALUE)st_key; VALUE val = (VALUE)st_val; VALUE envp_buf = (VALUE)arg; rb_str_buf_cat2(envp_buf, StringValueCStr(key)); rb_str_buf_cat2(envp_buf, "="); rb_str_buf_cat2(envp_buf, StringValueCStr(val)); rb_str_buf_cat(envp_buf, "", 1); /* append '\0' */ return ST_CONTINUE; } static long run_exec_dup2_tmpbuf_size(long n); void rb_execarg_fixup(VALUE execarg_obj) { struct rb_execarg *eargp = rb_execarg_get(execarg_obj); int unsetenv_others; VALUE envopts; VALUE ary; eargp->redirect_fds = check_exec_fds(eargp); ary = eargp->fd_dup2; if (ary != Qfalse) { size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); VALUE tmpbuf = hide_obj(rb_str_new(0, len)); rb_str_set_len(tmpbuf, len); eargp->dup2_tmpbuf = tmpbuf; } unsetenv_others = eargp->unsetenv_others_given && eargp->unsetenv_others_do; envopts = eargp->env_modification; if (unsetenv_others || envopts != Qfalse) { VALUE envtbl, envp_str, envp_buf; char *p, *ep; if (unsetenv_others) { envtbl = rb_hash_new(); } else { envtbl = rb_const_get(rb_cObject, rb_intern("ENV")); envtbl = rb_convert_type(envtbl, T_HASH, "Hash", "to_hash"); } hide_obj(envtbl); if (envopts != Qfalse) { st_table *stenv = RHASH_TBL(envtbl); long i; for (i = 0; i < RARRAY_LEN(envopts); i++) { VALUE pair = RARRAY_AREF(envopts, i); VALUE key = RARRAY_AREF(pair, 0); VALUE val = RARRAY_AREF(pair, 1); if (NIL_P(val)) { st_data_t stkey = (st_data_t)key; st_delete(stenv, &stkey, NULL); } else { st_insert(stenv, (st_data_t)key, (st_data_t)val); } } } envp_buf = rb_str_buf_new(0); hide_obj(envp_buf); st_foreach(RHASH_TBL(envtbl), fill_envp_buf_i, (st_data_t)envp_buf); envp_str = rb_str_buf_new(sizeof(char*) * (RHASH_SIZE(envtbl) + 1)); hide_obj(envp_str); p = RSTRING_PTR(envp_buf); ep = p + RSTRING_LEN(envp_buf); while (p < ep) { rb_str_buf_cat(envp_str, (char *)&p, sizeof(p)); p += strlen(p) + 1; } p = NULL; rb_str_buf_cat(envp_str, (char *)&p, sizeof(p)); eargp->envp_str = envp_str; eargp->envp_buf = envp_buf; /* char **tmp_envp = (char **)RSTRING_PTR(envp_str); while (*tmp_envp) { printf("%s\n", *tmp_envp); tmp_envp++; } */ } RB_GC_GUARD(execarg_obj); } void rb_exec_arg_fixup(struct rb_exec_arg *e) { rb_execarg_fixup(e->execarg_obj); } static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen); /* * call-seq: * exec([env,] command... [,options]) * * Replaces the current process by running the given external _command_, which * can take one of the following forms: * * [exec(commandline)] * command line string which is passed to the standard shell * [exec(cmdname, arg1, ...)] * command name and one or more arguments (no shell) * [exec([cmdname, argv0], arg1, ...)] * command name, argv[0] and zero or more arguments (no shell) * * In the first form, the string is taken as a command line that is subject to * shell expansion before being executed. * * The standard shell always means "/bin/sh" on Unix-like systems, * same as ENV["RUBYSHELL"] * (or ENV["COMSPEC"] on Windows NT series), and similar. * * If the string from the first form (exec("command")) follows * these simple rules: * * * no meta characters * * no shell reserved word and no special built-in * * Ruby invokes the command directly without shell * * You can force shell invocation by adding ";" to the string (because ";" is * a meta character). * * Note that this behavior is observable by pid obtained * (return value of spawn() and IO#pid for IO.popen) is the pid of the invoked * command, not shell. * * In the second form (exec("command1", "arg1", ...)), the first * is taken as a command name and the rest are passed as parameters to command * with no shell expansion. * * In the third form (exec(["command", "argv0"], "arg1", ...)), * starting a two-element array at the beginning of the command, the first * element is the command to be executed, and the second argument is used as * the argv[0] value, which may show up in process listings. * * In order to execute the command, one of the exec(2) system * calls are used, so the running command may inherit some of the environment * of the original program (including open file descriptors). * * This behavior is modified by the given +env+ and +options+ parameters. See * ::spawn for details. * * If the command fails to execute (typically Errno::ENOENT when * it was not found) a SystemCallError exception is raised. * * This method modifies process attributes according to given +options+ before * exec(2) system call. See ::spawn for more details about the * given +options+. * * The modified attributes may be retained when exec(2) system * call fails. * * For example, hard resource limits are not restorable. * * Consider to create a child process using ::spawn or Kernel#system if this * is not acceptable. * * exec "echo *" # echoes list of files in current directory * # never get here * * exec "echo", "*" # echoes an asterisk * # never get here */ VALUE rb_f_exec(int argc, VALUE *argv) { VALUE execarg_obj, fail_str; struct rb_execarg *eargp; #define CHILD_ERRMSG_BUFLEN 80 char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; execarg_obj = rb_execarg_new(argc, argv, TRUE); eargp = rb_execarg_get(execarg_obj); rb_execarg_fixup(execarg_obj); fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; #if defined(__APPLE__) || defined(__HAIKU__) rb_exec_without_timer_thread(eargp, errmsg, sizeof(errmsg)); #else rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg)); #endif RB_GC_GUARD(execarg_obj); if (errmsg[0]) rb_sys_fail(errmsg); rb_sys_fail_str(fail_str); return Qnil; /* dummy */ } #define ERRMSG(str) do { if (errmsg && 0 < errmsg_buflen) strlcpy(errmsg, (str), errmsg_buflen); } while (0) /*#define DEBUG_REDIRECT*/ #if defined(DEBUG_REDIRECT) #include 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; } #else #define redirect_dup(oldfd) dup(oldfd) #endif #if defined(DEBUG_REDIRECT) || defined(_WIN32) static int redirect_dup2(int oldfd, int newfd) { int ret; ret = dup2(oldfd, newfd); if (newfd >= 0 && newfd <= 2) SetStdHandle(newfd == 0 ? STD_INPUT_HANDLE : newfd == 1 ? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE, (HANDLE)rb_w32_get_osfhandle(newfd)); #if defined(DEBUG_REDIRECT) ttyprintf("dup2(%d, %d)\n", oldfd, newfd); #endif return ret; } #else #define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd)) #endif #if defined(DEBUG_REDIRECT) 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_close(fd) close(fd) #define redirect_open(pathname, flags, perm) open((pathname), (flags), (perm)) #endif static int save_redirect_fd(int fd, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { if (sargp) { VALUE newary; int save_fd = redirect_dup(fd); if (save_fd == -1) { if (errno == EBADF) return 0; ERRMSG("dup"); return -1; } rb_update_max_fd(save_fd); newary = sargp->fd_dup2; if (newary == Qfalse) { newary = hide_obj(rb_ary_new()); sargp->fd_dup2 = newary; } rb_ary_push(newary, hide_obj(rb_assoc_new(INT2FIX(fd), INT2FIX(save_fd)))); newary = sargp->fd_close; if (newary == Qfalse) { newary = hide_obj(rb_ary_new()); sargp->fd_close = newary; } rb_ary_push(newary, hide_obj(rb_assoc_new(INT2FIX(save_fd), Qnil))); } return 0; } static int intcmp(const void *a, const void *b) { return *(int*)a - *(int*)b; } static int intrcmp(const void *a, const void *b) { return *(int*)b - *(int*)a; } struct run_exec_dup2_fd_pair { int oldfd; int newfd; long older_index; long num_newer; }; static long run_exec_dup2_tmpbuf_size(long n) { return sizeof(struct run_exec_dup2_fd_pair) * n; } /* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */ static int run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { long n, i; int ret; int extra_fd = -1; struct run_exec_dup2_fd_pair *pairs = 0; n = RARRAY_LEN(ary); pairs = (struct run_exec_dup2_fd_pair *)RSTRING_PTR(tmpbuf); /* initialize oldfd and newfd: O(n) */ for (i = 0; i < n; i++) { VALUE elt = RARRAY_AREF(ary, i); pairs[i].oldfd = FIX2INT(RARRAY_AREF(elt, 1)); pairs[i].newfd = FIX2INT(RARRAY_AREF(elt, 0)); /* unique */ pairs[i].older_index = -1; } /* sort the table by oldfd: O(n log n) */ if (!sargp) qsort(pairs, n, sizeof(struct run_exec_dup2_fd_pair), intcmp); /* hopefully async-signal-safe */ else qsort(pairs, n, sizeof(struct run_exec_dup2_fd_pair), intrcmp); /* initialize older_index and num_newer: O(n log n) */ for (i = 0; i < n; i++) { int newfd = pairs[i].newfd; struct run_exec_dup2_fd_pair key, *found; key.oldfd = newfd; found = bsearch(&key, pairs, n, sizeof(struct run_exec_dup2_fd_pair), intcmp); /* hopefully async-signal-safe */ pairs[i].num_newer = 0; if (found) { while (pairs < found && (found-1)->oldfd == newfd) found--; while (found < pairs+n && found->oldfd == newfd) { pairs[i].num_newer++; found->older_index = i; found++; } } } /* non-cyclic redirection: O(n) */ for (i = 0; i < n; i++) { long j = i; while (j != -1 && pairs[j].oldfd != -1 && pairs[j].num_newer == 0) { if (save_redirect_fd(pairs[j].newfd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */ goto fail; ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd); /* async-signal-safe */ if (ret == -1) { ERRMSG("dup2"); goto fail; } rb_update_max_fd(pairs[j].newfd); /* async-signal-safe but don't need to call it in a child process. */ pairs[j].oldfd = -1; j = pairs[j].older_index; if (j != -1) pairs[j].num_newer--; } } /* cyclic redirection: O(n) */ for (i = 0; i < n; i++) { long j; if (pairs[i].oldfd == -1) continue; if (pairs[i].oldfd == pairs[i].newfd) { /* self cycle */ #ifdef F_GETFD int fd = pairs[i].oldfd; ret = fcntl(fd, F_GETFD); /* async-signal-safe */ if (ret == -1) { ERRMSG("fcntl(F_GETFD)"); goto fail; } if (ret & FD_CLOEXEC) { ret &= ~FD_CLOEXEC; ret = fcntl(fd, F_SETFD, ret); /* async-signal-safe */ if (ret == -1) { ERRMSG("fcntl(F_SETFD)"); goto fail; } } #endif pairs[i].oldfd = -1; continue; } if (extra_fd == -1) { extra_fd = redirect_dup(pairs[i].oldfd); /* async-signal-safe */ if (extra_fd == -1) { ERRMSG("dup"); goto fail; } rb_update_max_fd(extra_fd); } else { ret = redirect_dup2(pairs[i].oldfd, extra_fd); /* async-signal-safe */ if (ret == -1) { ERRMSG("dup2"); goto fail; } rb_update_max_fd(extra_fd); } pairs[i].oldfd = extra_fd; j = pairs[i].older_index; pairs[i].older_index = -1; while (j != -1) { ret = redirect_dup2(pairs[j].oldfd, pairs[j].newfd); /* async-signal-safe */ if (ret == -1) { ERRMSG("dup2"); goto fail; } rb_update_max_fd(ret); pairs[j].oldfd = -1; j = pairs[j].older_index; } } if (extra_fd != -1) { ret = redirect_close(extra_fd); /* async-signal-safe */ if (ret == -1) { ERRMSG("close"); goto fail; } } return 0; fail: return -1; } /* This function should be async-signal-safe. Actually it is. */ static int run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen) { long i; int ret; for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); int fd = FIX2INT(RARRAY_AREF(elt, 0)); ret = redirect_close(fd); /* async-signal-safe */ if (ret == -1) { ERRMSG("close"); return -1; } } return 0; } /* This function should be async-signal-safe when sargp is NULL. Actually it is. */ static int run_exec_open(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { long i; int ret; for (i = 0; i < RARRAY_LEN(ary);) { VALUE elt = RARRAY_AREF(ary, i); int fd = FIX2INT(RARRAY_AREF(elt, 0)); VALUE param = RARRAY_AREF(elt, 1); char *path = RSTRING_PTR(RARRAY_AREF(param, 0)); int flags = NUM2INT(RARRAY_AREF(param, 1)); int perm = NUM2INT(RARRAY_AREF(param, 2)); int need_close = 1; int fd2 = redirect_open(path, flags, perm); /* async-signal-safe */ if (fd2 == -1) { ERRMSG("open"); return -1; } rb_update_max_fd(fd2); while (i < RARRAY_LEN(ary) && (elt = RARRAY_AREF(ary, i), RARRAY_AREF(elt, 1) == param)) { fd = FIX2INT(RARRAY_AREF(elt, 0)); if (fd == fd2) { need_close = 0; } else { if (save_redirect_fd(fd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */ return -1; ret = redirect_dup2(fd2, fd); /* async-signal-safe */ if (ret == -1) { ERRMSG("dup2"); return -1; } rb_update_max_fd(fd); } i++; } if (need_close) { ret = redirect_close(fd2); /* async-signal-safe */ if (ret == -1) { ERRMSG("close"); return -1; } } } return 0; } /* This function should be async-signal-safe when sargp is NULL. Actually it is. */ static int run_exec_dup2_child(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { long i; int ret; for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); int newfd = FIX2INT(RARRAY_AREF(elt, 0)); int oldfd = FIX2INT(RARRAY_AREF(elt, 1)); if (save_redirect_fd(newfd, sargp, errmsg, errmsg_buflen) < 0) /* async-signal-safe */ return -1; ret = redirect_dup2(oldfd, newfd); /* async-signal-safe */ if (ret == -1) { ERRMSG("dup2"); return -1; } rb_update_max_fd(newfd); } return 0; } #ifdef HAVE_SETPGID /* This function should be async-signal-safe when sargp is NULL. Actually it is. */ static int run_exec_pgroup(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { /* * If FD_CLOEXEC is available, rb_fork 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 no FD_CLOEXEC?) */ int ret; rb_pid_t pgroup; pgroup = eargp->pgroup_pgid; if (pgroup == -1) return 0; if (sargp) { /* maybe meaningless with no fork environment... */ sargp->pgroup_given = 1; sargp->pgroup_pgid = getpgrp(); } if (pgroup == 0) { pgroup = getpid(); /* async-signal-safe */ } ret = setpgid(getpid(), pgroup); /* async-signal-safe */ if (ret == -1) ERRMSG("setpgid"); return ret; } #endif #if defined(HAVE_SETRLIMIT) && defined(RLIM2NUM) /* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */ static int run_exec_rlimit(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { long i; for (i = 0; i < RARRAY_LEN(ary); i++) { VALUE elt = RARRAY_AREF(ary, i); int rtype = NUM2INT(RARRAY_AREF(elt, 0)); struct rlimit rlim; if (sargp) { VALUE tmp, newary; if (getrlimit(rtype, &rlim) == -1) { ERRMSG("getrlimit"); return -1; } tmp = hide_obj(rb_ary_new3(3, RARRAY_AREF(elt, 0), RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max))); if (sargp->rlimit_limits == Qfalse) newary = sargp->rlimit_limits = hide_obj(rb_ary_new()); else newary = sargp->rlimit_limits; rb_ary_push(newary, tmp); } rlim.rlim_cur = NUM2RLIM(RARRAY_AREF(elt, 1)); rlim.rlim_max = NUM2RLIM(RARRAY_AREF(elt, 2)); if (setrlimit(rtype, &rlim) == -1) { /* hopefully async-signal-safe */ ERRMSG("setrlimit"); return -1; } } return 0; } #endif #if !defined(HAVE_FORK) 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(struct rb_execarg *sargp) { if (!sargp) return; if (sargp->env_modification == Qfalse) { VALUE env = rb_const_get(rb_cObject, rb_intern("ENV")); if (RTEST(env)) { VALUE ary = hide_obj(rb_ary_new()); rb_block_call(env, idEach, 0, 0, save_env_i, (VALUE)ary); sargp->env_modification = ary; } sargp->unsetenv_others_given = 1; sargp->unsetenv_others_do = 1; } } #endif /* This function should be async-signal-safe when sargp is NULL. Hopefully it is. */ int rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen) { VALUE obj; if (sargp) { /* assume that sargp is always NULL on fork-able environments */ MEMZERO(sargp, struct rb_execarg, 1); sargp->redirect_fds = Qnil; } #ifdef HAVE_SETPGID if (eargp->pgroup_given) { if (run_exec_pgroup(eargp, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ return -1; } #endif #if defined(HAVE_SETRLIMIT) && defined(RLIM2NUM) obj = eargp->rlimit_limits; if (obj != Qfalse) { if (run_exec_rlimit(obj, sargp, errmsg, errmsg_buflen) == -1) /* hopefully async-signal-safe */ return -1; } #endif #if !defined(HAVE_FORK) if (eargp->unsetenv_others_given && eargp->unsetenv_others_do) { save_env(sargp); rb_env_clear(); } obj = eargp->env_modification; if (obj != Qfalse) { long i; save_env(sargp); for (i = 0; i < RARRAY_LEN(obj); i++) { VALUE pair = RARRAY_AREF(obj, i); VALUE key = RARRAY_AREF(pair, 0); VALUE val = RARRAY_AREF(pair, 1); if (NIL_P(val)) ruby_setenv(StringValueCStr(key), 0); else ruby_setenv(StringValueCStr(key), StringValueCStr(val)); } } #endif if (eargp->umask_given) { mode_t mask = eargp->umask_mask; mode_t oldmask = umask(mask); /* never fail */ /* async-signal-safe */ if (sargp) { sargp->umask_given = 1; sargp->umask_mask = oldmask; } } obj = eargp->fd_dup2; if (obj != Qfalse) { if (run_exec_dup2(obj, eargp->dup2_tmpbuf, sargp, errmsg, errmsg_buflen) == -1) /* hopefully async-signal-safe */ return -1; } obj = eargp->fd_close; if (obj != Qfalse) { if (sargp) rb_warn("cannot close fd before spawn"); else { if (run_exec_close(obj, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ return -1; } } #ifdef HAVE_FORK if (!eargp->close_others_given || eargp->close_others_do) { rb_close_before_exec(3, eargp->close_others_maxhint, eargp->redirect_fds); /* async-signal-safe */ } #endif obj = eargp->fd_open; if (obj != Qfalse) { if (run_exec_open(obj, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ return -1; } obj = eargp->fd_dup2_child; if (obj != Qfalse) { if (run_exec_dup2_child(obj, sargp, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ return -1; } if (eargp->chdir_given) { if (sargp) { char *cwd = my_getcwd(); sargp->chdir_given = 1; sargp->chdir_dir = hide_obj(rb_str_new2(cwd)); xfree(cwd); } if (chdir(RSTRING_PTR(eargp->chdir_dir)) == -1) { /* async-signal-safe */ ERRMSG("chdir"); return -1; } } #ifdef HAVE_SETGID if (eargp->gid_given) { if (setgid(eargp->gid) < 0) { ERRMSG("setgid"); return -1; } } #endif #ifdef HAVE_SETUID if (eargp->uid_given) { if (setuid(eargp->uid) < 0) { ERRMSG("setuid"); return -1; } } #endif if (sargp) { VALUE ary = sargp->fd_dup2; if (ary != Qfalse) { size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); VALUE tmpbuf = hide_obj(rb_str_new(0, len)); rb_str_set_len(tmpbuf, len); sargp->dup2_tmpbuf = tmpbuf; } } return 0; } int rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char *errmsg, size_t errmsg_buflen) { return rb_execarg_run_options(rb_execarg_get(e->execarg_obj), rb_execarg_get(s->execarg_obj), errmsg, errmsg_buflen); } int rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s) { return rb_execarg_run_options(rb_execarg_get(e->execarg_obj), rb_execarg_get(s->execarg_obj), NULL, 0); } /* This function should be async-signal-safe. Hopefully it is. */ int rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) { #if !defined(HAVE_FORK) struct rb_execarg sarg, *const sargp = &sarg; #else struct rb_execarg *const sargp = NULL; #endif before_exec_async_signal_safe(); /* async-signal-safe */ if (rb_execarg_run_options(eargp, sargp, errmsg, errmsg_buflen) < 0) { /* hopefully async-signal-safe */ goto failure; } if (eargp->use_shell) { proc_exec_sh(RSTRING_PTR(eargp->invoke.sh.shell_script), eargp->envp_str); /* async-signal-safe */ } else { char *abspath = NULL; if (!NIL_P(eargp->invoke.cmd.command_abspath)) abspath = RSTRING_PTR(eargp->invoke.cmd.command_abspath); proc_exec_cmd(abspath, eargp->invoke.cmd.argv_str, eargp->envp_str); /* async-signal-safe */ } #if !defined(HAVE_FORK) preserving_errno(rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen)); #endif failure: preserving_errno(after_exec_async_signal_safe()); /* async-signal-safe */ return -1; } static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) { int ret; before_exec_non_async_signal_safe(); /* async-signal-safe if forked_child is true */ ret = rb_exec_async_signal_safe(eargp, errmsg, errmsg_buflen); /* hopefully async-signal-safe */ preserving_errno(after_exec_non_async_signal_safe()); /* not async-signal-safe because it calls rb_thread_start_timer_thread. */ return ret; } int rb_exec_err(const struct rb_exec_arg *e, char *errmsg, size_t errmsg_buflen) { return rb_exec_without_timer_thread(rb_execarg_get(e->execarg_obj), errmsg, errmsg_buflen); } int rb_exec(const struct rb_exec_arg *e) { #if !defined FD_CLOEXEC && !defined HAVE_SPAWNV char errmsg[80] = { '\0' }; int ret = rb_exec_without_timer_thread(rb_execarg_get(e->execarg_obj), errmsg, sizeof(errmsg)); preserving_errno( if (errmsg[0]) { fprintf(stderr, "%s\n", errmsg); } else { fprintf(stderr, "%s:%d: command not found: %s\n", rb_sourcefile(), rb_sourceline(), RSTRING_PTR(e->use_shell ? e->invoke.sh.shell_script : e->invoke.cmd.command_name)); } ); return ret; #else return rb_exec_without_timer_thread(rb_execarg_get(e->execarg_obj), NULL, 0); #endif } #ifdef HAVE_FORK /* This function should be async-signal-safe. Hopefully it is. */ static int rb_exec_atfork(void* arg, char *errmsg, size_t errmsg_buflen) { return rb_exec_async_signal_safe(arg, errmsg, errmsg_buflen); /* hopefully async-signal-safe */ } #endif #ifdef HAVE_FORK #if SIZEOF_INT == SIZEOF_LONG #define proc_syswait (VALUE (*)(VALUE))rb_syswait #else static VALUE proc_syswait(VALUE pid) { rb_syswait((int)pid); return Qnil; } #endif static int move_fds_to_avoid_crash(int *fdp, int n, VALUE fds) { int min = 0; int i; for (i = 0; i < n; i++) { int ret; while (RTEST(rb_hash_lookup(fds, INT2FIX(fdp[i])))) { if (min <= fdp[i]) min = fdp[i]+1; while (RTEST(rb_hash_lookup(fds, INT2FIX(min)))) min++; ret = rb_cloexec_fcntl_dupfd(fdp[i], min); if (ret == -1) return -1; rb_update_max_fd(ret); close(fdp[i]); fdp[i] = ret; } } return 0; } static int pipe_nocrash(int filedes[2], VALUE fds) { int ret; ret = rb_pipe(filedes); if (ret == -1) return -1; if (RTEST(fds)) { int save = errno; if (move_fds_to_avoid_crash(filedes, 2, fds) == -1) { close(filedes[0]); close(filedes[1]); return -1; } errno = save; } return ret; } struct chfunc_protect_t { int (*chfunc)(void*, char *, size_t); void *arg; char *errmsg; size_t buflen; }; static VALUE chfunc_protect(VALUE arg) { struct chfunc_protect_t *p = (struct chfunc_protect_t *)arg; return (VALUE)(*p->chfunc)(p->arg, p->errmsg, p->buflen); } #ifndef O_BINARY #define O_BINARY 0 #endif /* * Forks child process, and returns the process ID in the parent * process. * * If +status+ is given, protects from any exceptions and sets the * jump status to it, and returns -1. If failed to fork new process * but no exceptions occurred, sets 0 to it. Otherwise, if forked * successfully, the value of +status+ is undetermined. * * In the child process, just returns 0 if +chfunc+ is +NULL+. * Otherwise +chfunc+ will be called with +charg+, and then the child * process exits with +EXIT_SUCCESS+ when it returned zero. * * In the case of the function is called and returns non-zero value, * the child process exits with non-+EXIT_SUCCESS+ value (normally * 127). And, on the platforms where +FD_CLOEXEC+ is available, * +errno+ is propagated to the parent process, and this function * returns -1 in the parent process. On the other platforms, just * returns pid. * * If fds is not Qnil, internal pipe for the errno propagation is * arranged to avoid conflicts of the hash keys in +fds+. * * +chfunc+ must not raise any exceptions. */ static rb_pid_t retry_fork(int *status, int *ep, int chfunc_is_async_signal_safe) { rb_pid_t pid; int state = 0; int try_gc = 1; #define prefork() ( \ rb_io_flush(rb_stdout), \ rb_io_flush(rb_stderr) \ ) while (1) { prefork(); if (!chfunc_is_async_signal_safe) before_fork(); pid = fork(); if (pid == 0) /* fork succeed, child process */ return pid; if (!chfunc_is_async_signal_safe) preserving_errno(after_fork()); if (0 < pid) /* fork succeed, parent process */ return pid; /* fork failed */ switch (errno) { case ENOMEM: if (try_gc-- > 0 && !rb_during_gc()) { rb_gc(); continue; } break; case EAGAIN: #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN case EWOULDBLOCK: #endif if (!status && !ep) { rb_thread_sleep(1); continue; } else { rb_protect((VALUE (*)())rb_thread_sleep, 1, &state); if (status) *status = state; if (!state) continue; } break; } if (ep) { preserving_errno((close(ep[0]), close(ep[1]))); } if (state && !status) rb_jump_tag(state); return -1; } } static void send_child_error(int fd, int state, char *errmsg, size_t errmsg_buflen, int chfunc_is_async_signal_safe) { VALUE io = Qnil; int err; if (!chfunc_is_async_signal_safe) { if (write(fd, &state, sizeof(state)) == sizeof(state) && state) { VALUE errinfo = rb_errinfo(); io = rb_io_fdopen(fd, O_WRONLY|O_BINARY, NULL); rb_marshal_dump(errinfo, io); rb_io_flush(io); } } err = errno; if (write(fd, &err, sizeof(err)) < 0) err = errno; if (errmsg && 0 < errmsg_buflen) { errmsg[errmsg_buflen-1] = '\0'; errmsg_buflen = strlen(errmsg); if (errmsg_buflen > 0 && write(fd, errmsg, errmsg_buflen) < 0) err = errno; } if (!NIL_P(io)) rb_io_close(io); } static int recv_child_error(int fd, int *statep, VALUE *excp, int *errp, char *errmsg, size_t errmsg_buflen, int chfunc_is_async_signal_safe) { int err, state = 0; VALUE io = Qnil; ssize_t size; VALUE exc = Qnil; if (!chfunc_is_async_signal_safe) { if ((read(fd, &state, sizeof(state))) == sizeof(state) && state) { io = rb_io_fdopen(fd, O_RDONLY|O_BINARY, NULL); exc = rb_marshal_load(io); rb_set_errinfo(exc); } if (!*statep && state) *statep = state; *excp = exc; } #define READ_FROM_CHILD(ptr, len) \ (NIL_P(io) ? read(fd, (ptr), (len)) : rb_io_bufread(io, (ptr), (len))) if ((size = READ_FROM_CHILD(&err, sizeof(err))) < 0) { err = errno; } *errp = err; if (size == sizeof(err) && errmsg && 0 < errmsg_buflen) { ssize_t ret = READ_FROM_CHILD(errmsg, errmsg_buflen-1); if (0 <= ret) { errmsg[ret] = '\0'; } } if (NIL_P(io)) close(fd); else rb_io_close(io); return size != 0; } static rb_pid_t rb_fork_internal(int *status, int (*chfunc)(void*, char *, size_t), void *charg, int chfunc_is_async_signal_safe, VALUE fds, char *errmsg, size_t errmsg_buflen) { rb_pid_t pid; int err, state = 0; int ep[2]; VALUE exc = Qnil; int error_occurred; if (status) *status = 0; if (!chfunc) { pid = retry_fork(status, NULL, FALSE); if (pid < 0) return pid; if (!pid) { forked_child = 1; after_fork(); } return pid; } else { 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; } pid = retry_fork(status, ep, chfunc_is_async_signal_safe); if (pid < 0) return pid; if (!pid) { int ret; forked_child = 1; close(ep[0]); if (chfunc_is_async_signal_safe) ret = chfunc(charg, errmsg, errmsg_buflen); else { struct chfunc_protect_t arg; arg.chfunc = chfunc; arg.arg = charg; arg.errmsg = errmsg; arg.buflen = errmsg_buflen; ret = (int)rb_protect(chfunc_protect, (VALUE)&arg, &state); } if (!ret) _exit(EXIT_SUCCESS); send_child_error(ep[1], state, errmsg, errmsg_buflen, chfunc_is_async_signal_safe); #if EXIT_SUCCESS == 127 _exit(EXIT_FAILURE); #else _exit(127); #endif } close(ep[1]); error_occurred = recv_child_error(ep[0], &state, &exc, &err, errmsg, errmsg_buflen, chfunc_is_async_signal_safe); if (state || error_occurred) { if (status) { rb_protect(proc_syswait, (VALUE)pid, status); if (state) *status = state; } else { rb_syswait(pid); if (state) rb_exc_raise(exc); } errno = err; return -1; } return pid; } } rb_pid_t rb_fork_err(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, char *errmsg, size_t errmsg_buflen) { return rb_fork_internal(status, chfunc, charg, FALSE, fds, errmsg, errmsg_buflen); } rb_pid_t rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, char *errmsg, size_t errmsg_buflen) { return rb_fork_internal(status, chfunc, charg, TRUE, fds, errmsg, errmsg_buflen); } 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_internal(status, chfunc_wrapper, &warg, FALSE, fds, NULL, 0); } else { return rb_fork_internal(status, NULL, NULL, FALSE, fds, NULL, 0); } } rb_pid_t rb_fork_ruby(int *status) { return rb_fork_internal(status, NULL, NULL, FALSE, Qnil, NULL, 0); } #endif #if defined(HAVE_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD) /* * call-seq: * Kernel.fork [{ block }] -> fixnum or nil * Process.fork [{ block }] -> fixnum or nil * * Creates a subprocess. If a block is specified, that block is run * in the subprocess, and the subprocess terminates with a status of * zero. Otherwise, the +fork+ call returns twice, once in * the parent, returning the process ID of the child, and once in * the child, returning _nil_. The child process can exit using * Kernel.exit! to avoid running any * at_exit functions. The parent process should * use Process.wait to collect the termination statuses * of its children or use Process.detach to register * disinterest in their status; otherwise, the operating system * may accumulate zombie processes. * * The thread calling fork is the only thread in the created child process. * fork doesn't copy other threads. * * If fork is not usable, Process.respond_to?(:fork) returns false. * * Note that fork(2) is not avaiable on some platforms like Windows and NetBSD 4. * Therefore you should use spawn() instead of fork(). */ static VALUE rb_f_fork(VALUE obj) { rb_pid_t pid; rb_secure(2); switch (pid = rb_fork_ruby(NULL)) { case 0: rb_thread_atfork(); if (rb_block_given_p()) { int status; rb_protect(rb_yield, Qundef, &status); ruby_stop(status); } return Qnil; case -1: rb_sys_fail("fork(2)"); return Qnil; default: return PIDT2NUM(pid); } } #else #define rb_f_fork rb_f_notimplement #endif static int exit_status_code(VALUE status) { int istatus; switch (status) { case Qtrue: istatus = EXIT_SUCCESS; break; case Qfalse: istatus = EXIT_FAILURE; break; default: istatus = NUM2INT(status); #if EXIT_SUCCESS != 0 if (istatus == 0) istatus = EXIT_SUCCESS; #endif break; } return istatus; } /* * call-seq: * Process.exit!(status=false) * * Exits the process immediately. No exit handlers are * run. status is returned to the underlying system as the * exit status. * * Process.exit!(true) */ static VALUE rb_f_exit_bang(int argc, VALUE *argv, VALUE obj) { VALUE status; int istatus; if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { istatus = exit_status_code(status); } else { istatus = EXIT_FAILURE; } _exit(istatus); UNREACHABLE; } void rb_exit(int status) { if (GET_THREAD()->tag) { VALUE args[2]; args[0] = INT2NUM(status); args[1] = rb_str_new2("exit"); rb_exc_raise(rb_class_new_instance(2, args, rb_eSystemExit)); } ruby_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 * SystemExit 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" * * produces: * * rescued a SystemExit exception * after begin block * * Just prior to termination, Ruby executes any at_exit 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 * * produces: * * at_exit function * in finalizer */ VALUE rb_f_exit(int argc, VALUE *argv) { VALUE status; int istatus; if (argc > 0 && rb_scan_args(argc, argv, "01", &status) == 1) { istatus = exit_status_code(status); } else { istatus = EXIT_SUCCESS; } rb_exit(istatus); UNREACHABLE; } /* * call-seq: * abort * Kernel::abort([msg]) * Process::abort([msg]) * * Terminate execution immediately, effectively by calling * Kernel.exit(false). If _msg_ is given, it is written * to STDERR prior to terminating. */ VALUE rb_f_abort(int argc, VALUE *argv) { 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)); } UNREACHABLE; } void rb_syswait(rb_pid_t pid) { int status; rb_waitpid(pid, &status, 0); } static rb_pid_t rb_spawn_process(struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen) { rb_pid_t pid; #if !USE_SPAWNV int status; #endif #if !defined HAVE_FORK || USE_SPAWNV VALUE prog; struct rb_execarg sarg; #endif #if defined HAVE_FORK && !USE_SPAWNV pid = rb_fork_async_signal_safe(&status, rb_exec_atfork, eargp, eargp->redirect_fds, errmsg, errmsg_buflen); #else prog = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; if (rb_execarg_run_options(eargp, &sarg, errmsg, errmsg_buflen) < 0) { return -1; } if (prog && !eargp->use_shell) { char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); argv[0] = RSTRING_PTR(prog); } # if defined HAVE_SPAWNV if (eargp->use_shell) { pid = proc_spawn_sh(RSTRING_PTR(prog)); } else { char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); pid = proc_spawn_cmd(argv, prog, eargp); } if (pid == -1) rb_last_status_set(0x7f << 8, 0); # else if (!eargp->use_shell) { char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str); int argc = ARGVSTR2ARGC(eargp->invoke.cmd.argv_str); prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); } status = system(StringValuePtr(prog)); rb_last_status_set((status & 0xff) << 8, 0); # endif rb_execarg_run_options(&sarg, NULL, errmsg, errmsg_buflen); #endif return pid; } static rb_pid_t rb_spawn_internal(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen) { VALUE execarg_obj; struct rb_execarg *eargp; rb_pid_t ret; execarg_obj = rb_execarg_new(argc, argv, TRUE); eargp = rb_execarg_get(execarg_obj); rb_execarg_fixup(execarg_obj); ret = rb_spawn_process(eargp, errmsg, errmsg_buflen); RB_GC_GUARD(execarg_obj); return ret; } rb_pid_t rb_spawn_err(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen) { return rb_spawn_internal(argc, argv, errmsg, errmsg_buflen); } rb_pid_t rb_spawn(int argc, VALUE *argv) { return rb_spawn_internal(argc, argv, NULL, 0); } /* * call-seq: * system([env,] command... [,options]) -> true, false or nil * * Executes _command..._ in a subshell. * _command..._ is one of following forms. * * commandline : command line string which is passed to the standard shell * cmdname, arg1, ... : command name and one or more arguments (no shell) * [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell) * * system returns +true+ if the command gives zero exit status, * +false+ for non zero exit status. * Returns +nil+ if command execution fails. * An error status is available in $?. * The arguments are processed in the same way as * for Kernel.spawn. * * The hash arguments, env and options, are same as * exec and spawn. * See Kernel.spawn for details. * * system("echo *") * system("echo", "*") * * produces: * * config.h main.rb * * * * See Kernel.exec for the standard shell. */ static VALUE rb_f_system(int argc, VALUE *argv) { rb_pid_t pid; int status; #if defined(SIGCLD) && !defined(SIGCHLD) # define SIGCHLD SIGCLD #endif #ifdef SIGCHLD RETSIGTYPE (*chfunc)(int); rb_last_status_clear(); chfunc = signal(SIGCHLD, SIG_DFL); #endif pid = rb_spawn_internal(argc, argv, NULL, 0); #if defined(HAVE_FORK) || defined(HAVE_SPAWNV) if (pid > 0) { int ret, status; ret = rb_waitpid(pid, &status, 0); if (ret == (rb_pid_t)-1) rb_sys_fail("Another thread waited the process started by system()."); } #endif #ifdef SIGCHLD signal(SIGCHLD, chfunc); #endif if (pid < 0) { return Qnil; } status = PST2INT(rb_last_status_get()); if (status == EXIT_SUCCESS) return Qtrue; return Qfalse; } /* * call-seq: * spawn([env,] command... [,options]) -> pid * Process.spawn([env,] command... [,options]) -> pid * * spawn executes specified command and return its pid. * * pid = spawn("tar xf ruby-2.0.0-p195.tar.bz2") * Process.wait pid * * pid = spawn(RbConfig.ruby, "-eputs'Hello, world!'") * Process.wait pid * * This method is similar to Kernel#system but it doesn't wait for the command * to finish. * * The parent process should * use Process.wait to collect * the termination status of its child or * use Process.detach to register * disinterest in their status; * otherwise, the operating system may accumulate zombie processes. * * spawn has bunch of options to specify process attributes: * * env: hash * name => val : set the environment variable * name => nil : unset the environment variable * command...: * commandline : command line string which is passed to the standard shell * cmdname, arg1, ... : command name and one or more arguments (This form does not use the shell. See below for caveats.) * [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell) * options: hash * clearing environment variables: * :unsetenv_others => true : clear environment variables except specified by env * :unsetenv_others => false : don't clear (default) * process group: * :pgroup => true or 0 : make a new process group * :pgroup => pgid : join to specified process group * :pgroup => nil : don't change the process group (default) * create new process group: Windows only * :new_pgroup => true : the new process is the root process of a new process group * :new_pgroup => false : don't create a new process group (default) * resource limit: resourcename is core, cpu, data, etc. See Process.setrlimit. * :rlimit_resourcename => limit * :rlimit_resourcename => [cur_limit, max_limit] * umask: * :umask => int * redirection: * key: * FD : single file descriptor in child process * [FD, FD, ...] : multiple file descriptor in child process * value: * FD : redirect to the file descriptor in parent process * string : redirect to file with open(string, "r" or "w") * [string] : redirect to file with open(string, File::RDONLY) * [string, open_mode] : redirect to file with open(string, open_mode, 0644) * [string, open_mode, perm] : redirect to file with open(string, open_mode, perm) * [:child, FD] : redirect to the redirected file descriptor * :close : close the file descriptor in child process * FD is one of follows * :in : the file descriptor 0 which is the standard input * :out : the file descriptor 1 which is the standard output * :err : the file descriptor 2 which is the standard error * integer : the file descriptor of specified the integer * io : the file descriptor specified as io.fileno * file descriptor inheritance: close non-redirected non-standard fds (3, 4, 5, ...) or not * :close_others => true : don't inherit * current directory: * :chdir => str * * The 'cmdname, arg1, ...' form does not use the shell. However, * on different OSes, different things are provided as built-in * commands. An example of this is 'echo', which is a built-in * on Windows, but is a normal program on Linux and Mac OS X. * This means that `Process.spawn 'echo', '%Path%'` will display * the contents of the `%Path%` environment variable on Windows, * but `Process.spawn 'echo', '$PATH'` prints the literal '$PATH'. * * If a hash is given as +env+, the environment is * updated by +env+ before exec(2) in the child process. * If a pair in +env+ has nil as the value, the variable is deleted. * * # set FOO as BAR and unset BAZ. * pid = spawn({"FOO"=>"BAR", "BAZ"=>nil}, command) * * If a hash is given as +options+, * it specifies * process group, * create new process group, * resource limit, * current directory, * umask and * redirects for the child process. * Also, it can be specified to clear environment variables. * * The :unsetenv_others 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 :pgroup 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 :new_pgroup key in +options+ specifies to pass * +CREATE_NEW_PROCESS_GROUP+ flag to CreateProcessW() that is * Windows API. This option is only for Windows. * true means the new process is the root process of the new process group. * The new process has CTRL+C disabled. This flag is necessary for * Process.kill(:SIGINT, pid) on the subprocess. * :new_pgroup is false by default. * * pid = spawn(command, :new_pgroup=>true) # new process group * pid = spawn(command, :new_pgroup=>false) # same process group * * The :rlimit_foo key specifies a resource limit. * foo should be one of resource types such as core. * 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 :umask 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 spawn. * :err, 2 and STDERR specifies the standard error stream (stderr). * * The hash values specifies a file descriptor * in the parent process which invokes spawn. * :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 differ if stdout is redirected in the child process as follows. * * # stdout and stderr is redirected to log file. * # The file "log" is opened just once. * pid = spawn(command, :out=>["log", "w"], :err=>[:child, :out]) * * \[:child, :out] can be used to merge stderr into stdout in IO.popen. * In this case, IO.popen redirects stdout to a pipe in the child process * and [:child, :out] refers the redirected stdout. * * io = IO.popen(["sh", "-c", "echo out; echo err >&2", :err=>[:child, :out]]) * p io.read #=> "out\nerr\n" * * The :chdir key in +options+ specifies the current directory. * * pid = spawn(command, :chdir=>"/var/tmp") * * spawn closes all non-standard unspecified descriptors by default. * The "standard" descriptors are 0, 1 and 2. * This behavior is specified by :close_others option. * :close_others doesn't affect the standard descriptors which are * closed only if :close is specified explicitly. * * pid = spawn(command, :close_others=>true) # close 3,4,5,... (default) * pid = spawn(command, :close_others=>false) # don't close 3,4,5,... * * :close_others is true by default for spawn and IO.popen. * * Note that fds which close-on-exec flag is already set are closed * regardless of :close_others option. * * So IO.pipe and spawn can be used as IO.popen. * * # similar to r = IO.popen(command) * r, w = IO.pipe * pid = spawn(command, :out=>w) # r, w is closed in the child process. * w.close * * :close is specified as a hash value to close a fd individually. * * f = open(foo) * system(command, f=>:close) # don't inherit f. * * If a file descriptor need to be inherited, * io=>io can be used. * * # valgrind has --log-fd option for log destination. * # log_w=>log_w indicates log_w.fileno inherits to child process. * log_r, log_w = IO.pipe * pid = spawn("valgrind", "--log-fd=#{log_w.fileno}", "echo", "a", log_w=>log_w) * log_w.close * p log_r.read * * It is also possible to exchange file descriptors. * * pid = spawn(command, :out=>:err, :err=>:out) * * The hash keys specify file descriptors in the child process. * The hash values specifies file descriptors in the parent process. * So the above specifies exchanging stdout and stderr. * Internally, +spawn+ uses an extra file descriptor to resolve such cyclic * file descriptor mapping. * * See Kernel.exec for the standard shell. */ static VALUE rb_f_spawn(int argc, VALUE *argv) { rb_pid_t pid; char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; VALUE execarg_obj, fail_str; struct rb_execarg *eargp; execarg_obj = rb_execarg_new(argc, argv, TRUE); eargp = rb_execarg_get(execarg_obj); rb_execarg_fixup(execarg_obj); fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name; pid = rb_spawn_process(eargp, errmsg, sizeof(errmsg)); RB_GC_GUARD(execarg_obj); if (pid == -1) { const char *prog = errmsg; if (!prog[0]) { rb_sys_fail_str(fail_str); } rb_sys_fail(prog); } #if defined(HAVE_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 Thread#run. Called without an argument, sleep() * will sleep forever. * * Time.new #=> 2008-03-08 19:56:19 +0900 * sleep 1.2 #=> 1 * Time.new #=> 2008-03-08 19:56:20 +0900 * sleep 1.9 #=> 2 * Time.new #=> 2008-03-08 19:56:22 +0900 */ static VALUE rb_f_sleep(int argc, VALUE *argv) { time_t beg, end; beg = time(0); if (argc == 0) { rb_thread_sleep_forever(); } else { rb_check_arity(argc, 0, 1); rb_thread_wait_for(rb_time_interval(argv[0])); } end = time(0) - beg; return INT2FIX(end); } #if (defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)) || defined(HAVE_GETPGID) /* * call-seq: * Process.getpgrp -> integer * * Returns the process group ID for this process. Not available on * all platforms. * * Process.getpgid(0) #=> 25527 * Process.getpgrp #=> 25527 */ static VALUE proc_getpgrp(void) { rb_pid_t pgrp; rb_secure(2); #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) pgrp = getpgrp(); if (pgrp < 0) rb_sys_fail(0); return PIDT2NUM(pgrp); #else /* defined(HAVE_GETPGID) */ pgrp = getpgid(0); if (pgrp < 0) rb_sys_fail(0); return PIDT2NUM(pgrp); #endif } #else #define proc_getpgrp rb_f_notimplement #endif #if defined(HAVE_SETPGID) || (defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)) /* * call-seq: * Process.setpgrp -> 0 * * Equivalent to setpgid(0,0). Not available on all * platforms. */ static VALUE proc_setpgrp(void) { rb_secure(2); /* check for posix setpgid() first; this matches the posix */ /* getpgrp() above. It appears that configure will set SETPGRP_VOID */ /* even though setpgrp(0,0) would be preferred. The posix call avoids */ /* this confusion. */ #ifdef HAVE_SETPGID if (setpgid(0,0) < 0) rb_sys_fail(0); #elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID) if (setpgrp() < 0) rb_sys_fail(0); #endif return INT2FIX(0); } #else #define proc_setpgrp rb_f_notimplement #endif #if defined(HAVE_GETPGID) /* * call-seq: * Process.getpgid(pid) -> integer * * Returns the process group ID for the given process id. Not * available on all platforms. * * Process.getpgid(Process.ppid()) #=> 25527 */ static VALUE proc_getpgid(VALUE obj, VALUE pid) { rb_pid_t i; rb_secure(2); i = getpgid(NUM2PIDT(pid)); if (i < 0) rb_sys_fail(0); return PIDT2NUM(i); } #else #define proc_getpgid rb_f_notimplement #endif #ifdef HAVE_SETPGID /* * call-seq: * Process.setpgid(pid, integer) -> 0 * * Sets the process group ID of _pid_ (0 indicates this * process) to integer. Not available on all platforms. */ static VALUE proc_setpgid(VALUE obj, VALUE pid, VALUE pgrp) { rb_pid_t ipid, ipgrp; rb_secure(2); ipid = NUM2PIDT(pid); ipgrp = NUM2PIDT(pgrp); if (setpgid(ipid, ipgrp) < 0) rb_sys_fail(0); return INT2FIX(0); } #else #define proc_setpgid rb_f_notimplement #endif #ifdef HAVE_GETSID /* * call-seq: * Process.getsid() -> integer * Process.getsid(pid) -> integer * * Returns the session ID for for the given process id. If not give, * return current process sid. Not available on all platforms. * * Process.getsid() #=> 27422 * Process.getsid(0) #=> 27422 * Process.getsid(Process.pid()) #=> 27422 */ static VALUE proc_getsid(int argc, VALUE *argv) { rb_pid_t sid; VALUE pid; rb_secure(2); rb_scan_args(argc, argv, "01", &pid); if (NIL_P(pid)) pid = INT2FIX(0); sid = getsid(NUM2PIDT(pid)); if (sid < 0) rb_sys_fail(0); return PIDT2NUM(sid); } #else #define proc_getsid rb_f_notimplement #endif #if defined(HAVE_SETSID) || (defined(HAVE_SETPGRP) && defined(TIOCNOTTY)) #if !defined(HAVE_SETSID) static rb_pid_t ruby_setsid(void); #define setsid() ruby_setsid() #endif /* * call-seq: * Process.setsid -> fixnum * * Establishes this process as a new session and process group * leader, with no controlling tty. Returns the session id. Not * available on all platforms. * * Process.setsid #=> 27422 */ static VALUE proc_setsid(void) { rb_pid_t pid; rb_secure(2); pid = setsid(); if (pid < 0) rb_sys_fail(0); return PIDT2NUM(pid); } #if !defined(HAVE_SETSID) #define HAVE_SETSID 1 static rb_pid_t ruby_setsid(void) { rb_pid_t pid; int ret; pid = getpid(); #if defined(SETPGRP_VOID) ret = setpgrp(); /* If `pid_t setpgrp(void)' is equivalent to setsid(), `ret' will be the same value as `pid', and following open() will fail. In Linux, `int setpgrp(void)' is equivalent to setpgid(0, 0). */ #else ret = setpgrp(0, pid); #endif if (ret == -1) return -1; if ((fd = rb_cloexec_open("/dev/tty", O_RDWR, 0)) >= 0) { rb_update_max_fd(fd); ioctl(fd, TIOCNOTTY, NULL); close(fd); } return pid; } #endif #else #define proc_setsid rb_f_notimplement #endif #ifdef HAVE_GETPRIORITY /* * call-seq: * Process.getpriority(kind, integer) -> fixnum * * Gets the scheduling priority for specified process, process group, * or user. kind indicates the kind of entity to find: one * of Process::PRIO_PGRP, * Process::PRIO_USER, or * Process::PRIO_PROCESS. _integer_ is an id * indicating the particular process, process group, or user (an id * of 0 means _current_). Lower priorities are more favorable * for scheduling. Not available on all platforms. * * Process.getpriority(Process::PRIO_USER, 0) #=> 19 * Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19 */ static VALUE proc_getpriority(VALUE obj, VALUE which, VALUE who) { int prio, iwhich, iwho; rb_secure(2); iwhich = NUM2INT(which); iwho = NUM2INT(who); errno = 0; prio = getpriority(iwhich, iwho); if (errno) rb_sys_fail(0); return INT2FIX(prio); } #else #define proc_getpriority rb_f_notimplement #endif #ifdef HAVE_GETPRIORITY /* * call-seq: * Process.setpriority(kind, integer, priority) -> 0 * * See Process#getpriority. * * Process.setpriority(Process::PRIO_USER, 0, 19) #=> 0 * Process.setpriority(Process::PRIO_PROCESS, 0, 19) #=> 0 * Process.getpriority(Process::PRIO_USER, 0) #=> 19 * Process.getpriority(Process::PRIO_PROCESS, 0) #=> 19 */ static VALUE proc_setpriority(VALUE obj, VALUE which, VALUE who, VALUE prio) { int iwhich, iwho, iprio; rb_secure(2); iwhich = NUM2INT(which); iwho = NUM2INT(who); iprio = NUM2INT(prio); if (setpriority(iwhich, iwho, iprio) < 0) rb_sys_fail(0); return INT2FIX(0); } #else #define proc_setpriority rb_f_notimplement #endif #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) static int rlimit_resource_name2int(const char *name, int casetype) { int resource; const char *p; #define RESCHECK(r) \ do { \ if (STRCASECMP(name, #r) == 0) { \ resource = RLIMIT_##r; \ goto found; \ } \ } while (0) switch (TOUPPER(*name)) { case 'A': #ifdef RLIMIT_AS RESCHECK(AS); #endif break; case 'C': #ifdef RLIMIT_CORE RESCHECK(CORE); #endif #ifdef RLIMIT_CPU RESCHECK(CPU); #endif break; case 'D': #ifdef RLIMIT_DATA RESCHECK(DATA); #endif break; case 'F': #ifdef RLIMIT_FSIZE RESCHECK(FSIZE); #endif break; case 'M': #ifdef RLIMIT_MEMLOCK RESCHECK(MEMLOCK); #endif #ifdef RLIMIT_MSGQUEUE RESCHECK(MSGQUEUE); #endif break; case 'N': #ifdef RLIMIT_NOFILE RESCHECK(NOFILE); #endif #ifdef RLIMIT_NPROC RESCHECK(NPROC); #endif #ifdef RLIMIT_NICE RESCHECK(NICE); #endif break; case 'R': #ifdef RLIMIT_RSS RESCHECK(RSS); #endif #ifdef RLIMIT_RTPRIO RESCHECK(RTPRIO); #endif #ifdef RLIMIT_RTTIME RESCHECK(RTTIME); #endif break; case 'S': #ifdef RLIMIT_STACK RESCHECK(STACK); #endif #ifdef RLIMIT_SBSIZE RESCHECK(SBSIZE); #endif #ifdef RLIMIT_SIGPENDING RESCHECK(SIGPENDING); #endif break; } return -1; found: switch (casetype) { case 0: for (p = name; *p; p++) if (!ISUPPER(*p)) return -1; break; case 1: for (p = name; *p; p++) if (!ISLOWER(*p)) return -1; break; default: rb_bug("unexpected casetype"); } return resource; #undef RESCHECK } static int rlimit_type_by_hname(const char *name) { return rlimit_resource_name2int(name, 0); } static int rlimit_type_by_lname(const char *name) { return rlimit_resource_name2int(name, 1); } static int rlimit_resource_type(VALUE rtype) { const char *name; VALUE v; int r; switch (TYPE(rtype)) { case T_SYMBOL: 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); UNREACHABLE; } 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); UNREACHABLE; } #endif #if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM) /* * call-seq: * Process.getrlimit(resource) -> [cur_limit, max_limit] * * Gets the resource limit of the process. * _cur_limit_ means current (soft) limit and * _max_limit_ means maximum (hard) limit. * * _resource_ indicates the kind of resource to limit. * It is specified as a symbol such as :CORE, * a string such as "CORE" or * a constant such as Process::RLIMIT_CORE. * See Process.setrlimit for details. * * _cur_limit_ and _max_limit_ may be Process::RLIM_INFINITY, * Process::RLIM_SAVED_MAX or * Process::RLIM_SAVED_CUR. * See Process.setrlimit and the system getrlimit(2) manual for details. */ static VALUE proc_getrlimit(VALUE obj, VALUE resource) { struct rlimit rlim; rb_secure(2); if (getrlimit(rlimit_resource_type(resource), &rlim) < 0) { rb_sys_fail("getrlimit"); } return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max)); } #else #define proc_getrlimit rb_f_notimplement #endif #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) /* * call-seq: * Process.setrlimit(resource, cur_limit, max_limit) -> nil * Process.setrlimit(resource, cur_limit) -> nil * * Sets the resource limit of the process. * _cur_limit_ means current (soft) limit and * _max_limit_ means maximum (hard) limit. * * If _max_limit_ is not given, _cur_limit_ is used. * * _resource_ indicates the kind of resource to limit. * It should be a symbol such as :CORE, * a string such as "CORE" or * a constant such as Process::RLIMIT_CORE. * The available resources are OS dependent. * Ruby may support following resources. * * [AS] total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite) * [CORE] core size (bytes) (SUSv3) * [CPU] CPU time (seconds) (SUSv3) * [DATA] data segment (bytes) (SUSv3) * [FSIZE] file size (bytes) (SUSv3) * [MEMLOCK] total size for mlock(2) (bytes) (4.4BSD, GNU/Linux) * [MSGQUEUE] allocation for POSIX message queues (bytes) (GNU/Linux) * [NICE] ceiling on process's nice(2) value (number) (GNU/Linux) * [NOFILE] file descriptors (number) (SUSv3) * [NPROC] number of processes for the user (number) (4.4BSD, GNU/Linux) * [RSS] resident memory size (bytes) (4.2BSD, GNU/Linux) * [RTPRIO] ceiling on the process's real-time priority (number) (GNU/Linux) * [RTTIME] CPU time for real-time process (us) (GNU/Linux) * [SBSIZE] all socket buffers (bytes) (NetBSD, FreeBSD) * [SIGPENDING] number of queued signals allowed (signals) (GNU/Linux) * [STACK] stack size (bytes) (SUSv3) * * _cur_limit_ and _max_limit_ may be * :INFINITY, "INFINITY" or * Process::RLIM_INFINITY, * which means that the resource is not limited. * They may be Process::RLIM_SAVED_MAX, * Process::RLIM_SAVED_CUR and * corresponding symbols and strings too. * See system setrlimit(2) manual for details. * * The following example raises the soft limit of core size to * the hard limit to try to make core dump possible. * * Process.setrlimit(:CORE, Process.getrlimit(:CORE)[1]) * */ static VALUE proc_setrlimit(int argc, VALUE *argv, VALUE obj) { VALUE resource, rlim_cur, rlim_max; struct rlimit rlim; rb_secure(2); rb_scan_args(argc, argv, "21", &resource, &rlim_cur, &rlim_max); if (rlim_max == Qnil) rlim_max = rlim_cur; rlim.rlim_cur = rlimit_resource_value(rlim_cur); rlim.rlim_max = rlimit_resource_value(rlim_max); if (setrlimit(rlimit_resource_type(resource), &rlim) < 0) { rb_sys_fail("setrlimit"); } return Qnil; } #else #define proc_setrlimit rb_f_notimplement #endif static int under_uid_switch = 0; static void check_uid_switch(void) { rb_secure(2); if (under_uid_switch) { rb_raise(rb_eRuntimeError, "can't handle UID while evaluating block given to Process::UID.switch method"); } } static int under_gid_switch = 0; static void check_gid_switch(void) { rb_secure(2); if (under_gid_switch) { rb_raise(rb_eRuntimeError, "can't handle GID while evaluating block given to Process::UID.switch method"); } } /********************************************************************* * Document-class: Process::Sys * * The Process::Sys module contains UID and GID * functions which provide direct bindings to the system calls of the * same names instead of the more-portable versions of the same * functionality found in the Process, * Process::UID, and Process::GID modules. */ #if defined(HAVE_PWD_H) static rb_uid_t obj2uid(VALUE id # ifdef USE_GETPWNAM_R , char *getpw_buf, size_t getpw_buf_len # endif ) { rb_uid_t uid; VALUE tmp; if (FIXNUM_P(id) || NIL_P(tmp = rb_check_string_type(id))) { uid = NUM2UIDT(id); } else { const char *usrname = StringValueCStr(id); struct passwd *pwptr; #ifdef USE_GETPWNAM_R struct passwd pwbuf; if (getpwnam_r(usrname, &pwbuf, getpw_buf, getpw_buf_len, &pwptr)) rb_sys_fail("getpwnam_r"); #else pwptr = getpwnam(usrname); #endif if (!pwptr) { #ifndef USE_GETPWNAM_R endpwent(); #endif rb_raise(rb_eArgError, "can't find user for %s", usrname); } uid = pwptr->pw_uid; #ifndef USE_GETPWNAM_R endpwent(); #endif } return uid; } # ifdef p_uid_from_name /* * call-seq: * Process::UID.from_name(name) -> uid * * Get the user ID by the _name_. * If the user is not found, +ArgumentError+ will be raised. * * Process::UID.from_name("root") #=> 0 * Process::UID.from_name("nosuchuser") #=> can't find user for nosuchuser (ArgumentError) */ static VALUE p_uid_from_name(VALUE self, VALUE id) { PREPARE_GETPWNAM return UIDT2NUM(OBJ2UID(id)); } # endif #endif #if defined(HAVE_GRP_H) static rb_gid_t obj2gid(VALUE id # ifdef USE_GETGRNAM_R , char *getgr_buf, size_t getgr_buf_len # endif ) { rb_gid_t gid; VALUE tmp; if (FIXNUM_P(id) || NIL_P(tmp = rb_check_string_type(id))) { gid = NUM2GIDT(id); } else { const char *grpname = StringValueCStr(id); struct group *grptr; #ifdef USE_GETGRNAM_R struct group grbuf; if (getgrnam_r(grpname, &grbuf, getgr_buf, getgr_buf_len, &grptr)) rb_sys_fail("getgrnam_r"); #else grptr = getgrnam(grpname); #endif if (!grptr) { #if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) endgrent(); #endif rb_raise(rb_eArgError, "can't find group for %s", grpname); } gid = grptr->gr_gid; #if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) endgrent(); #endif } return gid; } # ifdef p_gid_from_name /* * call-seq: * Process::GID.from_name(name) -> gid * * Get the group ID by the _name_. * If the group is not found, +ArgumentError+ will be raised. * * Process::GID.from_name("wheel") #=> 0 * Process::GID.from_name("nosuchgroup") #=> can't find group for nosuchgroup (ArgumentError) */ static VALUE p_gid_from_name(VALUE self, VALUE id) { PREPARE_GETGRNAM; return GIDT2NUM(OBJ2GID(id)); } # endif #endif #if defined HAVE_SETUID /* * call-seq: * Process::Sys.setuid(user) -> nil * * Set the user ID of the current process to _user_. Not * available on all platforms. * */ static VALUE p_sys_setuid(VALUE obj, VALUE id) { PREPARE_GETPWNAM; check_uid_switch(); if (setuid(OBJ2UID(id)) != 0) rb_sys_fail(0); return Qnil; } #else #define p_sys_setuid rb_f_notimplement #endif #if defined HAVE_SETRUID /* * call-seq: * Process::Sys.setruid(user) -> nil * * Set the real user ID of the calling process to _user_. * Not available on all platforms. * */ static VALUE p_sys_setruid(VALUE obj, VALUE id) { PREPARE_GETPWNAM; check_uid_switch(); if (setruid(OBJ2UID(id)) != 0) rb_sys_fail(0); return Qnil; } #else #define p_sys_setruid rb_f_notimplement #endif #if defined HAVE_SETEUID /* * call-seq: * Process::Sys.seteuid(user) -> nil * * Set the effective user ID of the calling process to * _user_. Not available on all platforms. * */ static VALUE p_sys_seteuid(VALUE obj, VALUE id) { PREPARE_GETPWNAM; check_uid_switch(); if (seteuid(OBJ2UID(id)) != 0) rb_sys_fail(0); return Qnil; } #else #define p_sys_seteuid rb_f_notimplement #endif #if defined HAVE_SETREUID /* * call-seq: * Process::Sys.setreuid(rid, eid) -> nil * * Sets the (user) real and/or effective user IDs of the current * process to _rid_ and _eid_, respectively. A value of * -1 for either means to leave that ID unchanged. Not * available on all platforms. * */ static VALUE p_sys_setreuid(VALUE obj, VALUE rid, VALUE eid) { PREPARE_GETPWNAM; check_uid_switch(); if (setreuid(OBJ2UID(rid), OBJ2UID(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 * * Sets the (user) real, effective, and saved user IDs of the * current process to _rid_, _eid_, and _sid_ respectively. A * value of -1 for any value means to * leave that ID unchanged. Not available on all platforms. * */ static VALUE p_sys_setresuid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) { PREPARE_GETPWNAM; check_uid_switch(); if (setresuid(OBJ2UID(rid), OBJ2UID(eid), OBJ2UID(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 * * Returns the (real) user ID of this process. * * Process.uid #=> 501 */ static VALUE proc_getuid(VALUE obj) { rb_uid_t uid = getuid(); return UIDT2NUM(uid); } #if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETRUID) || defined(HAVE_SETUID) /* * call-seq: * Process.uid= user -> numeric * * Sets the (user) user ID for this process. Not available on all * platforms. */ static VALUE proc_setuid(VALUE obj, VALUE id) { rb_uid_t uid; PREPARE_GETPWNAM; check_uid_switch(); uid = OBJ2UID(id); #if defined(HAVE_SETRESUID) if (setresuid(uid, -1, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETREUID if (setreuid(uid, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETRUID if (setruid(uid) < 0) rb_sys_fail(0); #elif defined HAVE_SETUID { if (geteuid() == uid) { if (setuid(uid) < 0) rb_sys_fail(0); } else { rb_notimplement(); } } #endif return id; } #else #define proc_setuid rb_f_notimplement #endif /******************************************************************** * * Document-class: Process::UID * * The Process::UID module contains a collection of * module functions which can be used to portably get, set, and * switch the current process's real, effective, and saved user IDs. * */ static rb_uid_t SAVED_USER_ID = -1; #ifdef BROKEN_SETREUID int setreuid(rb_uid_t ruid, rb_uid_t euid) { if (ruid != (rb_uid_t)-1 && ruid != getuid()) { if (euid == (rb_uid_t)-1) euid = geteuid(); if (setuid(ruid) < 0) return -1; } if (euid != (rb_uid_t)-1 && euid != geteuid()) { if (seteuid(euid) < 0) return -1; } return 0; } #endif /* * call-seq: * Process::UID.change_privilege(user) -> fixnum * * Change the current process's real and effective user ID to that * specified by _user_. Returns the new user ID. Not * available on all platforms. * * [Process.uid, Process.euid] #=> [0, 0] * Process::UID.change_privilege(31) #=> 31 * [Process.uid, Process.euid] #=> [31, 31] */ static VALUE p_uid_change_privilege(VALUE obj, VALUE id) { rb_uid_t uid; PREPARE_GETPWNAM; check_uid_switch(); uid = OBJ2UID(id); if (geteuid() == 0) { /* root-user */ #if defined(HAVE_SETRESUID) if (setresuid(uid, uid, uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; #elif defined(HAVE_SETUID) if (setuid(uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) if (getuid() == uid) { if (SAVED_USER_ID == uid) { if (setreuid(-1, uid) < 0) rb_sys_fail(0); } else { if (uid == 0) { /* (r,e,s) == (root, root, x) */ if (setreuid(-1, SAVED_USER_ID) < 0) rb_sys_fail(0); if (setreuid(SAVED_USER_ID, 0) < 0) rb_sys_fail(0); SAVED_USER_ID = 0; /* (r,e,s) == (x, root, root) */ if (setreuid(uid, uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } else { if (setreuid(0, -1) < 0) rb_sys_fail(0); SAVED_USER_ID = 0; if (setreuid(uid, uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } } } else { if (setreuid(uid, uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } #elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID) if (getuid() == uid) { if (SAVED_USER_ID == uid) { if (seteuid(uid) < 0) rb_sys_fail(0); } else { if (uid == 0) { if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0); SAVED_USER_ID = 0; if (setruid(0) < 0) rb_sys_fail(0); } else { if (setruid(0) < 0) rb_sys_fail(0); SAVED_USER_ID = 0; if (seteuid(uid) < 0) rb_sys_fail(0); if (setruid(uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } } } else { if (seteuid(uid) < 0) rb_sys_fail(0); if (setruid(uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } #else (void)uid; rb_notimplement(); #endif } else { /* unprivileged user */ #if defined(HAVE_SETRESUID) if (setresuid((getuid() == uid)? (rb_uid_t)-1: uid, (geteuid() == uid)? (rb_uid_t)-1: uid, (SAVED_USER_ID == uid)? (rb_uid_t)-1: uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) if (SAVED_USER_ID == uid) { if (setreuid((getuid() == uid)? (rb_uid_t)-1: uid, (geteuid() == uid)? (rb_uid_t)-1: uid) < 0) rb_sys_fail(0); } else if (getuid() != uid) { if (setreuid(uid, (geteuid() == uid)? (rb_uid_t)-1: uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } else if (/* getuid() == uid && */ geteuid() != uid) { if (setreuid(geteuid(), uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; if (setreuid(uid, -1) < 0) rb_sys_fail(0); } else { /* getuid() == uid && geteuid() == uid */ if (setreuid(-1, SAVED_USER_ID) < 0) rb_sys_fail(0); if (setreuid(SAVED_USER_ID, uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; if (setreuid(uid, -1) < 0) rb_sys_fail(0); } #elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID) if (SAVED_USER_ID == uid) { if (geteuid() != uid && seteuid(uid) < 0) rb_sys_fail(0); if (getuid() != uid && setruid(uid) < 0) rb_sys_fail(0); } else if (/* SAVED_USER_ID != uid && */ geteuid() == uid) { if (getuid() != uid) { if (setruid(uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } else { if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; if (setruid(uid) < 0) rb_sys_fail(0); } } else if (/* geteuid() != uid && */ getuid() == uid) { if (seteuid(uid) < 0) rb_sys_fail(0); if (setruid(SAVED_USER_ID) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; if (setruid(uid) < 0) rb_sys_fail(0); } else { errno = EPERM; rb_sys_fail(0); } #elif defined HAVE_44BSD_SETUID if (getuid() == uid) { /* (r,e,s)==(uid,?,?) ==> (uid,uid,uid) */ if (setuid(uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; } else { errno = EPERM; rb_sys_fail(0); } #elif defined HAVE_SETEUID if (getuid() == uid && SAVED_USER_ID == uid) { if (seteuid(uid) < 0) rb_sys_fail(0); } else { errno = EPERM; rb_sys_fail(0); } #elif defined HAVE_SETUID if (getuid() == uid && SAVED_USER_ID == uid) { if (setuid(uid) < 0) rb_sys_fail(0); } else { errno = EPERM; rb_sys_fail(0); } #else rb_notimplement(); #endif } return id; } #if defined HAVE_SETGID /* * call-seq: * Process::Sys.setgid(group) -> nil * * Set the group ID of the current process to _group_. Not * available on all platforms. * */ static VALUE p_sys_setgid(VALUE obj, VALUE id) { PREPARE_GETGRNAM; check_gid_switch(); if (setgid(OBJ2GID(id)) != 0) rb_sys_fail(0); return Qnil; } #else #define p_sys_setgid rb_f_notimplement #endif #if defined HAVE_SETRGID /* * call-seq: * Process::Sys.setrgid(group) -> nil * * Set the real group ID of the calling process to _group_. * Not available on all platforms. * */ static VALUE p_sys_setrgid(VALUE obj, VALUE id) { PREPARE_GETGRNAM; check_gid_switch(); if (setrgid(OBJ2GID(id)) != 0) rb_sys_fail(0); return Qnil; } #else #define p_sys_setrgid rb_f_notimplement #endif #if defined HAVE_SETEGID /* * call-seq: * Process::Sys.setegid(group) -> nil * * Set the effective group ID of the calling process to * _group_. Not available on all platforms. * */ static VALUE p_sys_setegid(VALUE obj, VALUE id) { PREPARE_GETGRNAM; check_gid_switch(); if (setegid(OBJ2GID(id)) != 0) rb_sys_fail(0); return Qnil; } #else #define p_sys_setegid rb_f_notimplement #endif #if defined HAVE_SETREGID /* * call-seq: * Process::Sys.setregid(rid, eid) -> nil * * Sets the (group) real and/or effective group IDs of the current * process to rid and eid, respectively. A value of * -1 for either means to leave that ID unchanged. Not * available on all platforms. * */ static VALUE p_sys_setregid(VALUE obj, VALUE rid, VALUE eid) { PREPARE_GETGRNAM; check_gid_switch(); if (setregid(OBJ2GID(rid), OBJ2GID(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 * * Sets the (group) real, effective, and saved user IDs of the * current process to rid, eid, and sid * respectively. A value of -1 for any value means to * leave that ID unchanged. Not available on all platforms. * */ static VALUE p_sys_setresgid(VALUE obj, VALUE rid, VALUE eid, VALUE sid) { PREPARE_GETGRNAM; check_gid_switch(); if (setresgid(OBJ2GID(rid), OBJ2GID(eid), OBJ2GID(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 * * Returns +true+ if the process was created as a result * of an execve(2) system call which had either of the setuid or * setgid bits set (and extra privileges were given as a result) or * if it has changed any of its real, effective or saved user or * group IDs since it began execution. * */ static VALUE p_sys_issetugid(VALUE obj) { rb_secure(2); if (issetugid()) { return Qtrue; } else { return Qfalse; } } #else #define p_sys_issetugid rb_f_notimplement #endif /* * call-seq: * Process.gid -> fixnum * Process::GID.rid -> fixnum * Process::Sys.getgid -> fixnum * * Returns the (real) group ID for this process. * * Process.gid #=> 500 */ static VALUE proc_getgid(VALUE obj) { rb_gid_t gid = getgid(); return GIDT2NUM(gid); } #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETRGID) || defined(HAVE_SETGID) /* * call-seq: * Process.gid= fixnum -> fixnum * * Sets the group ID for this process. */ static VALUE proc_setgid(VALUE obj, VALUE id) { rb_gid_t gid; PREPARE_GETGRNAM; check_gid_switch(); gid = OBJ2GID(id); #if defined(HAVE_SETRESGID) if (setresgid(gid, -1, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETREGID if (setregid(gid, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETRGID if (setrgid(gid) < 0) rb_sys_fail(0); #elif defined HAVE_SETGID { if (getegid() == gid) { if (setgid(gid) < 0) rb_sys_fail(0); } else { rb_notimplement(); } } #endif return GIDT2NUM(gid); } #else #define proc_setgid rb_f_notimplement #endif #if defined(HAVE_SETGROUPS) || defined(HAVE_GETGROUPS) /* * Maximum supplementary groups are platform dependent. * FWIW, 65536 is enough big for our supported OSs. * * OS Name max groups * ----------------------------------------------- * Linux Kernel >= 2.6.3 65536 * Linux Kernel < 2.6.3 32 * IBM AIX 5.2 64 * IBM AIX 5.3 ... 6.1 128 * IBM AIX 7.1 128 (can be configured to be up to 2048) * OpenBSD, NetBSD 16 * FreeBSD < 8.0 16 * FreeBSD >=8.0 1023 * Darwin (Mac OS X) 16 * Sun Solaris 7,8,9,10 16 * Sun Solaris 11 / OpenSolaris 1024 * HP-UX 20 * Windows 1015 */ static int _maxgroups = -1; static int get_sc_ngroups_max(void) { #ifdef _SC_NGROUPS_MAX return (int)sysconf(_SC_NGROUPS_MAX); #elif defined(NGROUPS_MAX) return (int)NGROUPS_MAX; #else return -1; #endif } static int maxgroups(void) { if (_maxgroups < 0) { _maxgroups = get_sc_ngroups_max(); if (_maxgroups < 0) _maxgroups = RB_MAX_GROUPS; } return _maxgroups; } #endif #ifdef HAVE_GETGROUPS /* * call-seq: * Process.groups -> array * * Get an Array of the gids of groups in the * supplemental group access list for this process. * * Process.groups #=> [27, 6, 10, 11] * */ static VALUE proc_getgroups(VALUE obj) { VALUE ary; int i, ngroups; rb_gid_t *groups; ngroups = getgroups(0, NULL); if (ngroups == -1) rb_sys_fail(0); groups = ALLOCA_N(rb_gid_t, ngroups); ngroups = getgroups(ngroups, groups); if (ngroups == -1) rb_sys_fail(0); ary = rb_ary_new(); for (i = 0; i < ngroups; i++) rb_ary_push(ary, GIDT2NUM(groups[i])); return ary; } #else #define proc_getgroups rb_f_notimplement #endif #ifdef HAVE_SETGROUPS /* * call-seq: * Process.groups= array -> array * * Set the supplemental group access list to the given * Array of group IDs. * * Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] * Process.groups = [27, 6, 10, 11] #=> [27, 6, 10, 11] * Process.groups #=> [27, 6, 10, 11] * */ static VALUE proc_setgroups(VALUE obj, VALUE ary) { int ngroups, i; rb_gid_t *groups; PREPARE_GETGRNAM; Check_Type(ary, T_ARRAY); ngroups = RARRAY_LENINT(ary); if (ngroups > maxgroups()) rb_raise(rb_eArgError, "too many groups, %d max", maxgroups()); groups = ALLOCA_N(rb_gid_t, ngroups); for (i = 0; i < ngroups; i++) { VALUE g = RARRAY_AREF(ary, i); groups[i] = OBJ2GID(g); } if (setgroups(ngroups, groups) == -1) /* ngroups <= maxgroups */ rb_sys_fail(0); return proc_getgroups(obj); } #else #define proc_setgroups rb_f_notimplement #endif #ifdef HAVE_INITGROUPS /* * call-seq: * Process.initgroups(username, gid) -> array * * Initializes the supplemental group access list by reading the * system group database and using all groups of which the given user * is a member. The group with the specified gid is also * added to the list. Returns the resulting Array of the * gids of all the groups in the supplementary group access list. Not * available on all platforms. * * Process.groups #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27] * Process.initgroups( "mgranger", 30 ) #=> [30, 6, 10, 11] * Process.groups #=> [30, 6, 10, 11] * */ static VALUE proc_initgroups(VALUE obj, VALUE uname, VALUE base_grp) { PREPARE_GETGRNAM; if (initgroups(StringValuePtr(uname), OBJ2GID(base_grp)) != 0) { rb_sys_fail(0); } return proc_getgroups(obj); } #else #define proc_initgroups rb_f_notimplement #endif #if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX) /* * call-seq: * Process.maxgroups -> fixnum * * Returns the maximum number of gids allowed in the supplemental * group access list. * * Process.maxgroups #=> 32 */ static VALUE proc_getmaxgroups(VALUE obj) { return INT2FIX(maxgroups()); } #else #define proc_getmaxgroups rb_f_notimplement #endif #ifdef HAVE_SETGROUPS /* * call-seq: * Process.maxgroups= fixnum -> fixnum * * Sets the maximum number of gids allowed in the supplemental group * access list. */ static VALUE proc_setmaxgroups(VALUE obj, VALUE val) { int ngroups = FIX2INT(val); int ngroups_max = get_sc_ngroups_max(); if (ngroups <= 0) rb_raise(rb_eArgError, "maxgroups %d shold be positive", ngroups); if (ngroups > RB_MAX_GROUPS) ngroups = RB_MAX_GROUPS; if (ngroups_max > 0 && ngroups > ngroups_max) ngroups = ngroups_max; _maxgroups = ngroups; return INT2FIX(_maxgroups); } #else #define proc_setmaxgroups rb_f_notimplement #endif #if defined(HAVE_DAEMON) || (defined(HAVE_FORK) && defined(HAVE_SETSID)) static int rb_daemon(int nochdir, int noclose); /* * call-seq: * Process.daemon() -> 0 * Process.daemon(nochdir=nil,noclose=nil) -> 0 * * Detach the process from controlling terminal and run in * the background as system daemon. Unless the argument * nochdir is true (i.e. non false), it changes the current * working directory to the root ("/"). Unless the argument * noclose is true, daemon() will redirect standard input, * standard output and standard error to /dev/null. * Return zero on success, or raise one of Errno::*. */ static VALUE proc_daemon(int argc, VALUE *argv) { VALUE nochdir, noclose; int n; rb_secure(2); rb_scan_args(argc, argv, "02", &nochdir, &noclose); prefork(); n = rb_daemon(RTEST(nochdir), RTEST(noclose)); if (n < 0) rb_sys_fail("daemon"); return INT2FIX(n); } static int rb_daemon(int nochdir, int noclose) { int err = 0; #ifdef HAVE_DAEMON before_fork(); err = daemon(nochdir, noclose); after_fork(); rb_thread_atfork(); #else int n; #define fork_daemon() \ switch (rb_fork_ruby(NULL)) { \ case -1: return -1; \ case 0: rb_thread_atfork(); break; \ default: _exit(EXIT_SUCCESS); \ } fork_daemon(); if (setsid() < 0) return -1; /* must not be process-leader */ fork_daemon(); if (!nochdir) err = chdir("/"); if (!noclose && (n = rb_cloexec_open("/dev/null", O_RDWR, 0)) != -1) { rb_update_max_fd(n); (void)dup2(n, 0); (void)dup2(n, 1); (void)dup2(n, 2); if (n > 2) (void)close (n); } #endif return err; } #else #define proc_daemon rb_f_notimplement #endif /******************************************************************** * * Document-class: Process::GID * * The Process::GID module contains a collection of * module functions which can be used to portably get, set, and * switch the current process's real, effective, and saved group IDs. * */ static rb_gid_t SAVED_GROUP_ID = -1; #ifdef BROKEN_SETREGID int setregid(rb_gid_t rgid, rb_gid_t egid) { if (rgid != (rb_gid_t)-1 && rgid != getgid()) { if (egid == (rb_gid_t)-1) egid = getegid(); if (setgid(rgid) < 0) return -1; } if (egid != (rb_gid_t)-1 && egid != getegid()) { if (setegid(egid) < 0) return -1; } return 0; } #endif /* * call-seq: * Process::GID.change_privilege(group) -> fixnum * * Change the current process's real and effective group ID to that * specified by _group_. Returns the new group ID. Not * available on all platforms. * * [Process.gid, Process.egid] #=> [0, 0] * Process::GID.change_privilege(33) #=> 33 * [Process.gid, Process.egid] #=> [33, 33] */ static VALUE p_gid_change_privilege(VALUE obj, VALUE id) { rb_gid_t gid; PREPARE_GETGRNAM; check_gid_switch(); gid = OBJ2GID(id); if (geteuid() == 0) { /* root-user */ #if defined(HAVE_SETRESGID) if (setresgid(gid, gid, gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; #elif defined HAVE_SETGID if (setgid(gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) if (getgid() == gid) { if (SAVED_GROUP_ID == gid) { if (setregid(-1, gid) < 0) rb_sys_fail(0); } else { if (gid == 0) { /* (r,e,s) == (root, y, x) */ if (setregid(-1, SAVED_GROUP_ID) < 0) rb_sys_fail(0); if (setregid(SAVED_GROUP_ID, 0) < 0) rb_sys_fail(0); SAVED_GROUP_ID = 0; /* (r,e,s) == (x, root, root) */ if (setregid(gid, gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } else { /* (r,e,s) == (z, y, x) */ if (setregid(0, 0) < 0) rb_sys_fail(0); SAVED_GROUP_ID = 0; if (setregid(gid, gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } } } else { if (setregid(gid, gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } #elif defined(HAVE_SETRGID) && defined (HAVE_SETEGID) if (getgid() == gid) { if (SAVED_GROUP_ID == gid) { if (setegid(gid) < 0) rb_sys_fail(0); } else { if (gid == 0) { if (setegid(gid) < 0) rb_sys_fail(0); if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0); SAVED_GROUP_ID = 0; if (setrgid(0) < 0) rb_sys_fail(0); } else { if (setrgid(0) < 0) rb_sys_fail(0); SAVED_GROUP_ID = 0; if (setegid(gid) < 0) rb_sys_fail(0); if (setrgid(gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } } } else { if (setegid(gid) < 0) rb_sys_fail(0); if (setrgid(gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } #else rb_notimplement(); #endif } else { /* unprivileged user */ #if defined(HAVE_SETRESGID) if (setresgid((getgid() == gid)? (rb_gid_t)-1: gid, (getegid() == gid)? (rb_gid_t)-1: gid, (SAVED_GROUP_ID == gid)? (rb_gid_t)-1: gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) if (SAVED_GROUP_ID == gid) { if (setregid((getgid() == gid)? (rb_uid_t)-1: gid, (getegid() == gid)? (rb_uid_t)-1: gid) < 0) rb_sys_fail(0); } else if (getgid() != gid) { if (setregid(gid, (getegid() == gid)? (rb_uid_t)-1: gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } else if (/* getgid() == gid && */ getegid() != gid) { if (setregid(getegid(), gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; if (setregid(gid, -1) < 0) rb_sys_fail(0); } else { /* getgid() == gid && getegid() == gid */ if (setregid(-1, SAVED_GROUP_ID) < 0) rb_sys_fail(0); if (setregid(SAVED_GROUP_ID, gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; if (setregid(gid, -1) < 0) rb_sys_fail(0); } #elif defined(HAVE_SETRGID) && defined(HAVE_SETEGID) if (SAVED_GROUP_ID == gid) { if (getegid() != gid && setegid(gid) < 0) rb_sys_fail(0); if (getgid() != gid && setrgid(gid) < 0) rb_sys_fail(0); } else if (/* SAVED_GROUP_ID != gid && */ getegid() == gid) { if (getgid() != gid) { if (setrgid(gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } else { if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; if (setrgid(gid) < 0) rb_sys_fail(0); } } else if (/* getegid() != gid && */ getgid() == gid) { if (setegid(gid) < 0) rb_sys_fail(0); if (setrgid(SAVED_GROUP_ID) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; if (setrgid(gid) < 0) rb_sys_fail(0); } else { errno = EPERM; rb_sys_fail(0); } #elif defined HAVE_44BSD_SETGID if (getgid() == gid) { /* (r,e,s)==(gid,?,?) ==> (gid,gid,gid) */ if (setgid(gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; } else { errno = EPERM; rb_sys_fail(0); } #elif defined HAVE_SETEGID if (getgid() == gid && SAVED_GROUP_ID == gid) { if (setegid(gid) < 0) rb_sys_fail(0); } else { errno = EPERM; rb_sys_fail(0); } #elif defined HAVE_SETGID if (getgid() == gid && SAVED_GROUP_ID == gid) { if (setgid(gid) < 0) rb_sys_fail(0); } else { errno = EPERM; rb_sys_fail(0); } #else (void)gid; rb_notimplement(); #endif } return id; } /* * call-seq: * Process.euid -> fixnum * Process::UID.eid -> fixnum * Process::Sys.geteuid -> fixnum * * Returns the effective user ID for this process. * * Process.euid #=> 501 */ static VALUE proc_geteuid(VALUE obj) { rb_uid_t euid = geteuid(); return UIDT2NUM(euid); } #if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) || defined(_POSIX_SAVED_IDS) static void proc_seteuid(rb_uid_t uid) { #if defined(HAVE_SETRESUID) if (setresuid(-1, uid, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETREUID if (setreuid(-1, uid) < 0) rb_sys_fail(0); #elif defined HAVE_SETEUID if (seteuid(uid) < 0) rb_sys_fail(0); #elif defined HAVE_SETUID if (uid == getuid()) { if (setuid(uid) < 0) rb_sys_fail(0); } else { rb_notimplement(); } #else rb_notimplement(); #endif } #endif #if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) /* * call-seq: * Process.euid= user * * Sets the effective user ID for this process. Not available on all * platforms. */ static VALUE proc_seteuid_m(VALUE mod, VALUE euid) { PREPARE_GETPWNAM; check_uid_switch(); proc_seteuid(OBJ2UID(euid)); return euid; } #else #define proc_seteuid_m rb_f_notimplement #endif static rb_uid_t rb_seteuid_core(rb_uid_t euid) { #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) rb_uid_t uid; #endif check_uid_switch(); #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) uid = getuid(); #endif #if defined(HAVE_SETRESUID) if (uid != euid) { if (setresuid(-1,euid,euid) < 0) rb_sys_fail(0); SAVED_USER_ID = euid; } else { if (setresuid(-1,euid,-1) < 0) rb_sys_fail(0); } #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) if (setreuid(-1, euid) < 0) rb_sys_fail(0); if (uid != euid) { if (setreuid(euid,uid) < 0) rb_sys_fail(0); if (setreuid(uid,euid) < 0) rb_sys_fail(0); SAVED_USER_ID = euid; } #elif defined HAVE_SETEUID if (seteuid(euid) < 0) rb_sys_fail(0); #elif defined HAVE_SETUID if (geteuid() == 0) rb_sys_fail(0); if (setuid(euid) < 0) rb_sys_fail(0); #else rb_notimplement(); #endif return euid; } /* * call-seq: * Process::UID.grant_privilege(user) -> fixnum * Process::UID.eid= user -> fixnum * * Set the effective user ID, and if possible, the saved user ID of * the process to the given _user_. Returns the new * effective user ID. Not available on all platforms. * * [Process.uid, Process.euid] #=> [0, 0] * Process::UID.grant_privilege(31) #=> 31 * [Process.uid, Process.euid] #=> [0, 31] */ static VALUE p_uid_grant_privilege(VALUE obj, VALUE id) { PREPARE_GETPWNAM; rb_seteuid_core(OBJ2UID(id)); return id; } /* * call-seq: * Process.egid -> fixnum * Process::GID.eid -> fixnum * Process::Sys.geteid -> fixnum * * Returns the effective group ID for this process. Not available on * all platforms. * * Process.egid #=> 500 */ static VALUE proc_getegid(VALUE obj) { rb_gid_t egid = getegid(); return GIDT2NUM(egid); } #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) || defined(_POSIX_SAVED_IDS) /* * call-seq: * Process.egid = fixnum -> fixnum * * Sets the effective group ID for this process. Not available on all * platforms. */ static VALUE proc_setegid(VALUE obj, VALUE egid) { #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) rb_gid_t gid; PREPARE_GETGRNAM; #endif check_gid_switch(); #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) gid = OBJ2GID(egid); #endif #if defined(HAVE_SETRESGID) if (setresgid(-1, gid, -1) < 0) rb_sys_fail(0); #elif defined HAVE_SETREGID if (setregid(-1, gid) < 0) rb_sys_fail(0); #elif defined HAVE_SETEGID if (setegid(gid) < 0) rb_sys_fail(0); #elif defined HAVE_SETGID if (gid == getgid()) { if (setgid(gid) < 0) rb_sys_fail(0); } else { rb_notimplement(); } #else rb_notimplement(); #endif return egid; } #endif #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) #define proc_setegid_m proc_setegid #else #define proc_setegid_m rb_f_notimplement #endif static rb_gid_t rb_setegid_core(rb_gid_t egid) { #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) rb_gid_t gid; #endif check_gid_switch(); #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) gid = getgid(); #endif #if defined(HAVE_SETRESGID) if (gid != egid) { if (setresgid(-1,egid,egid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = egid; } else { if (setresgid(-1,egid,-1) < 0) rb_sys_fail(0); } #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) if (setregid(-1, egid) < 0) rb_sys_fail(0); if (gid != egid) { if (setregid(egid,gid) < 0) rb_sys_fail(0); if (setregid(gid,egid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = egid; } #elif defined HAVE_SETEGID if (setegid(egid) < 0) rb_sys_fail(0); #elif defined HAVE_SETGID if (geteuid() == 0 /* root user */) rb_sys_fail(0); if (setgid(egid) < 0) rb_sys_fail(0); #else rb_notimplement(); #endif return egid; } /* * call-seq: * Process::GID.grant_privilege(group) -> fixnum * Process::GID.eid = group -> fixnum * * Set the effective group ID, and if possible, the saved group ID of * the process to the given _group_. Returns the new * effective group ID. Not available on all platforms. * * [Process.gid, Process.egid] #=> [0, 0] * Process::GID.grant_privilege(31) #=> 33 * [Process.gid, Process.egid] #=> [0, 33] */ static VALUE p_gid_grant_privilege(VALUE obj, VALUE id) { PREPARE_GETGRNAM; rb_setegid_core(OBJ2GID(id)); return id; } /* * call-seq: * Process::UID.re_exchangeable? -> true or false * * Returns +true+ if the real and effective user IDs of a * process may be exchanged on the current platform. * */ static VALUE p_uid_exchangeable(void) { #if defined(HAVE_SETRESUID) return Qtrue; #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) return Qtrue; #else return Qfalse; #endif } /* * call-seq: * Process::UID.re_exchange -> fixnum * * Exchange real and effective user IDs and return the new effective * user ID. Not available on all platforms. * * [Process.uid, Process.euid] #=> [0, 31] * Process::UID.re_exchange #=> 0 * [Process.uid, Process.euid] #=> [31, 0] */ static VALUE p_uid_exchange(VALUE obj) { rb_uid_t uid; #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) rb_uid_t euid; #endif check_uid_switch(); uid = getuid(); #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) euid = geteuid(); #endif #if defined(HAVE_SETRESUID) if (setresuid(euid, uid, uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) if (setreuid(euid,uid) < 0) rb_sys_fail(0); SAVED_USER_ID = uid; #else rb_notimplement(); #endif return UIDT2NUM(uid); } /* * call-seq: * Process::GID.re_exchangeable? -> true or false * * Returns +true+ if the real and effective group IDs of a * process may be exchanged on the current platform. * */ static VALUE p_gid_exchangeable(void) { #if defined(HAVE_SETRESGID) return Qtrue; #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) return Qtrue; #else return Qfalse; #endif } /* * call-seq: * Process::GID.re_exchange -> fixnum * * Exchange real and effective group IDs and return the new effective * group ID. Not available on all platforms. * * [Process.gid, Process.egid] #=> [0, 33] * Process::GID.re_exchange #=> 0 * [Process.gid, Process.egid] #=> [33, 0] */ static VALUE p_gid_exchange(VALUE obj) { rb_gid_t gid; #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) rb_gid_t egid; #endif check_gid_switch(); gid = getgid(); #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) egid = getegid(); #endif #if defined(HAVE_SETRESGID) if (setresgid(egid, gid, gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) if (setregid(egid,gid) < 0) rb_sys_fail(0); SAVED_GROUP_ID = gid; #else rb_notimplement(); #endif return GIDT2NUM(gid); } /* [MG] :FIXME: Is this correct? I'm not sure how to phrase this. */ /* * call-seq: * Process::UID.sid_available? -> true or false * * Returns +true+ if the current platform has saved user * ID functionality. * */ static VALUE p_uid_have_saved_id(void) { #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) return Qtrue; #else return Qfalse; #endif } #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) static VALUE p_uid_sw_ensure(rb_uid_t id) { under_uid_switch = 0; id = rb_seteuid_core(id); return UIDT2NUM(id); } /* * call-seq: * Process::UID.switch -> fixnum * Process::UID.switch {|| block} -> object * * Switch the effective and real user IDs of the current process. If * a block is given, the user IDs will be switched back * after the block is executed. Returns the new effective user ID if * called without a block, and the return value of the block if one * is given. * */ static VALUE p_uid_switch(VALUE obj) { rb_uid_t uid, euid; check_uid_switch(); uid = getuid(); euid = geteuid(); if (uid != euid) { proc_seteuid(uid); if (rb_block_given_p()) { under_uid_switch = 1; return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, SAVED_USER_ID); } else { return UIDT2NUM(euid); } } else if (euid != SAVED_USER_ID) { proc_seteuid(SAVED_USER_ID); if (rb_block_given_p()) { under_uid_switch = 1; return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, euid); } else { return UIDT2NUM(uid); } } else { errno = EPERM; rb_sys_fail(0); } UNREACHABLE; } #else static VALUE p_uid_sw_ensure(VALUE obj) { under_uid_switch = 0; return p_uid_exchange(obj); } static VALUE p_uid_switch(VALUE obj) { rb_uid_t uid, euid; check_uid_switch(); uid = getuid(); euid = geteuid(); if (uid == euid) { errno = EPERM; rb_sys_fail(0); } p_uid_exchange(obj); if (rb_block_given_p()) { under_uid_switch = 1; return rb_ensure(rb_yield, Qnil, p_uid_sw_ensure, obj); } else { return UIDT2NUM(euid); } } #endif /* [MG] :FIXME: Is this correct? I'm not sure how to phrase this. */ /* * call-seq: * Process::GID.sid_available? -> true or false * * Returns +true+ if the current platform has saved group * ID functionality. * */ static VALUE p_gid_have_saved_id(void) { #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) return Qtrue; #else return Qfalse; #endif } #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) static VALUE p_gid_sw_ensure(rb_gid_t id) { under_gid_switch = 0; id = rb_setegid_core(id); return GIDT2NUM(id); } /* * call-seq: * Process::GID.switch -> fixnum * Process::GID.switch {|| block} -> object * * Switch the effective and real group IDs of the current process. If * a block is given, the group IDs will be switched back * after the block is executed. Returns the new effective group ID if * called without a block, and the return value of the block if one * is given. * */ static VALUE p_gid_switch(VALUE obj) { rb_gid_t gid, egid; check_gid_switch(); gid = getgid(); egid = getegid(); if (gid != egid) { proc_setegid(obj, GIDT2NUM(gid)); if (rb_block_given_p()) { under_gid_switch = 1; return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, SAVED_GROUP_ID); } else { return GIDT2NUM(egid); } } else if (egid != SAVED_GROUP_ID) { proc_setegid(obj, GIDT2NUM(SAVED_GROUP_ID)); if (rb_block_given_p()) { under_gid_switch = 1; return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, egid); } else { return GIDT2NUM(gid); } } else { errno = EPERM; rb_sys_fail(0); } UNREACHABLE; } #else static VALUE p_gid_sw_ensure(VALUE obj) { under_gid_switch = 0; return p_gid_exchange(obj); } static VALUE p_gid_switch(VALUE obj) { rb_gid_t gid, egid; check_gid_switch(); gid = getgid(); egid = getegid(); if (gid == egid) { errno = EPERM; rb_sys_fail(0); } p_gid_exchange(obj); if (rb_block_given_p()) { under_gid_switch = 1; return rb_ensure(rb_yield, Qnil, p_gid_sw_ensure, obj); } else { return GIDT2NUM(egid); } } #endif #if defined(HAVE_TIMES) static long get_clk_tck(void) { long hertz = #ifdef HAVE__SC_CLK_TCK (double)sysconf(_SC_CLK_TCK); #else #ifndef HZ # ifdef CLK_TCK # define HZ CLK_TCK # else # define HZ 60 # endif #endif /* HZ */ HZ; #endif return hertz; } /* * call-seq: * Process.times -> aStructTms * * Returns a Tms structure (see Struct::Tms) * that contains user and system CPU times for this process, * and also for children processes. * * t = Process.times * [ t.utime, t.stime, t.cutime, t.cstime ] #=> [0.0, 0.02, 0.00, 0.00] */ VALUE rb_proc_times(VALUE obj) { const double hertz = get_clk_tck(); struct tms buf; VALUE utime, stime, cutime, cstime, ret; times(&buf); utime = DBL2NUM(buf.tms_utime / hertz); stime = DBL2NUM(buf.tms_stime / hertz); cutime = DBL2NUM(buf.tms_cutime / hertz); cstime = DBL2NUM(buf.tms_cstime / hertz); ret = rb_struct_new(rb_cProcessTms, utime, stime, cutime, cstime); RB_GC_GUARD(utime); RB_GC_GUARD(stime); RB_GC_GUARD(cutime); RB_GC_GUARD(cstime); return ret; } #else #define rb_proc_times rb_f_notimplement #endif static VALUE make_clock_result(struct timespec *tsp, VALUE unit) { long factor; if (unit == ID2SYM(rb_intern("nanoseconds"))) { factor = 1000000000; goto return_integer; } else if (unit == ID2SYM(rb_intern("microseconds"))) { factor = 1000000; goto return_integer; } else if (unit == ID2SYM(rb_intern("milliseconds"))) { factor = 1000; goto return_integer; } else if (unit == ID2SYM(rb_intern("float_microseconds"))) { factor = 1000000; goto return_float; } else if (unit == ID2SYM(rb_intern("float_milliseconds"))) { factor = 1000; goto return_float; } else if (NIL_P(unit) || unit == ID2SYM(rb_intern("float_seconds"))) { factor = 1; goto return_float; } else { rb_raise(rb_eArgError, "unexpected unit: %"PRIsVALUE, unit); } return_float: return DBL2NUM((tsp->tv_sec + 1e-9 * (double)tsp->tv_nsec) / factor); return_integer: #if defined(HAVE_LONG_LONG) if (!MUL_OVERFLOW_SIGNED_INTEGER_P(factor, (LONG_LONG)tsp->tv_sec, LLONG_MIN, LLONG_MAX-(factor-1))) { return LL2NUM(tsp->tv_nsec/(1000000000/factor) + factor * (LONG_LONG)tsp->tv_sec); } #endif return rb_funcall(LONG2FIX(tsp->tv_nsec/(1000000000/factor)), '+', 1, rb_funcall(LONG2FIX(factor), '*', 1, TIMET2NUM(tsp->tv_sec))); } /* * call-seq: * Process.clock_gettime(clock_id [, unit]) -> number * * Returns a time returned by POSIX clock_gettime() function. * * +clock_id+ specifies a kind of clock. * It is specifed as a constant which begins with Process::CLOCK_ * such as Process::CLOCK_REALTIME and Process::CLOCK_MONOTONIC. * * The supported constants depends on OS and version. * Ruby provides following types of +clock_id+ if available. * * [CLOCK_REALTIME] SUSv2 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 2.1 * [CLOCK_MONOTONIC] SUSv3 to 4, Linux 2.5.63, FreeBSD 3.0, NetBSD 2.0, OpenBSD 3.4 * [CLOCK_PROCESS_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63 * [CLOCK_THREAD_CPUTIME_ID] SUSv3 to 4, Linux 2.5.63, FreeBSD 7.1 * [CLOCK_VIRTUAL] FreeBSD 3.0, OpenBSD 2.1 * [CLOCK_PROF] FreeBSD 3.0, OpenBSD 2.1 * [CLOCK_REALTIME_FAST] FreeBSD 8.1 * [CLOCK_REALTIME_PRECISE] FreeBSD 8.1 * [CLOCK_REALTIME_COARSE] Linux 2.6.32 * [CLOCK_REALTIME_ALARM] Linux 3.0 * [CLOCK_MONOTONIC_FAST] FreeBSD 8.1 * [CLOCK_MONOTONIC_PRECISE] FreeBSD 8.1 * [CLOCK_MONOTONIC_COARSE] Linux 2.6.32 * [CLOCK_MONOTONIC_RAW] Linux 2.6.28 * [CLOCK_BOOTTIME] Linux 2.6.39 * [CLOCK_BOOTTIME_ALARM] Linux 3.0 * [CLOCK_UPTIME] FreeBSD 7.0 * [CLOCK_UPTIME_FAST] FreeBSD 8.1 * [CLOCK_UPTIME_PRECISE] FreeBSD 8.1 * [CLOCK_SECOND] FreeBSD 8.1 * * Also, several other symbols are accepted as +clock_id+. * There are emulations for clock_gettime(). * * For example, Process::CLOCK_REALTIME is defined as * +:SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME+ when clock_gettime() is not available. * * Emulations for +CLOCK_REALTIME+: * [:SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME] * Use gettimeofday(). * The resolution is 1 micro second. * [:ISO_C_TIME_BASED_CLOCK_REALTIME] * Use time(). * The resolution is 1 second. * * Emulations for +CLOCK_MONOTONIC+: * [:MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC] Use mach_absolute_time(), available on Darwin. * The resolution is CPU dependent. * * Emulations for +CLOCK_PROCESS_CPUTIME_ID+: * [:SUS_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID] * Use getrusage() with RUSAGE_SELF. * getrusage() is defined by Single Unix Specification. * The result is addition of ru_utime and ru_stime. * The resolution is 1 micro second. * [:POSIX_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID] * Use times() defined by POSIX. * The result is addition of tms_utime and tms_stime. * tms_cutime and tms_cstime are ignored. * The resolution is the clock tick. * "getconf CLK_TCK" command shows the clock ticks per second. * (The clock ticks per second is defined by HZ macro in older systems.) * If it is 100, the resolution is 10 milli second. * [:ISO_C_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID] * Use clock() defined by ISO C. * The resolution is 1/CLOCKS_PER_SEC. * CLOCKS_PER_SEC is the C-level macro defined by time.h. * Single Unix Specification defines CLOCKS_PER_SEC is 1000000. * Non-Unix systems may define it a different value, though. * If CLOCKS_PER_SEC is 1000000 as SUS, the resolution is 1 micro second. * * If the given +clock_id+ is not supported, Errno::EINVAL is raised. * * +unit+ specifies a type of the return value. * * [:float_seconds] number of seconds as a float (default) * [:float_milliseconds] number of milliseconds as a float * [:float_microseconds] number of microseconds as a float * [:milliseconds] number of milliseconds as an integer * [:microseconds] number of microseconds as an integer * [:nanoseconds] number of nanoseconds as an integer * * The underlying function, clock_gettime(), returns a number of nanoseconds. * Float object (IEEE 754 double) is not enough to represent * the return value for CLOCK_REALTIME. * If the exact nanoseconds value is required, use +:nanoseconds+ as the +unit+. * * The origin (zero) of the returned value varies. * For example, system start up time, process start up time, the Epoch, etc. * * The origin in CLOCK_REALTIME is defined as the Epoch * (1970-01-01 00:00:00 UTC). * But some systems count leap seconds and others doesn't. * So the result can be interpreted differently across systems. * Time.now is recommended over CLOCK_REALTIME. * * p Process.clock_gettime(Process::CLOCK_MONOTONIC) * #=> 896053.968060096 * */ VALUE rb_clock_gettime(int argc, VALUE *argv) { struct timespec ts; VALUE clk_id, unit; int ret; rb_scan_args(argc, argv, "11", &clk_id, &unit); if (SYMBOL_P(clk_id)) { /* * Non-clock_gettime clocks are provided by symbol clk_id. * * gettimeofday is always available on platforms supported by Ruby. * SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME is used for * CLOCK_REALTIME if clock_gettime is not available. */ #define RUBY_SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(rb_intern("SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME")) if (clk_id == RUBY_SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME) { struct timeval tv; ret = gettimeofday(&tv, 0); if (ret != 0) rb_sys_fail("gettimeofday"); ts.tv_sec = tv.tv_sec; ts.tv_nsec = tv.tv_usec * 1000; goto success; } #define RUBY_ISO_C_TIME_BASED_CLOCK_REALTIME ID2SYM(rb_intern("ISO_C_TIME_BASED_CLOCK_REALTIME")) if (clk_id == RUBY_ISO_C_TIME_BASED_CLOCK_REALTIME) { time_t t; t = time(NULL); if (t == (time_t)-1) rb_sys_fail("time"); ts.tv_sec = t; ts.tv_nsec = 0; goto success; } #ifdef RUSAGE_SELF #define RUBY_SUS_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID \ ID2SYM(rb_intern("SUS_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID")) if (clk_id == RUBY_SUS_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) { struct rusage usage; long usec; ret = getrusage(RUSAGE_SELF, &usage); if (ret != 0) rb_sys_fail("getrusage"); ts.tv_sec = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec; usec = usage.ru_utime.tv_usec + usage.ru_stime.tv_usec; if (1000000 <= usec) { ts.tv_sec++; usec -= 1000000; } ts.tv_nsec = usec * 1000; goto success; } #endif #ifdef HAVE_TIMES #define RUBY_POSIX_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID \ ID2SYM(rb_intern("POSIX_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID")) if (clk_id == RUBY_POSIX_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) { double ns; struct tms buf; if (times(&buf) == (clock_t)-1) rb_sys_fail("times"); ns = ((double)buf.tms_utime + buf.tms_stime) * (1e9 / get_clk_tck()); ts.tv_sec = (time_t)(ns*1e-9); ts.tv_nsec = ns - ts.tv_sec*1e9; goto success; } #endif #define RUBY_ISO_C_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID \ ID2SYM(rb_intern("ISO_C_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID")) if (clk_id == RUBY_ISO_C_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) { double ns; clock_t c; c = clock(); errno = 0; if (c == (clock_t)-1) rb_sys_fail("clock"); ns = c * (1e9 / CLOCKS_PER_SEC); ts.tv_sec = (time_t)(ns*1e-9); ts.tv_nsec = ns - ts.tv_sec*1e9; goto success; } #ifdef __APPLE__ #define RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC ID2SYM(rb_intern("MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC")) if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) { static mach_timebase_info_data_t sTimebaseInfo; uint64_t t = mach_absolute_time(); if ( sTimebaseInfo.denom == 0 ) { (void) mach_timebase_info(&sTimebaseInfo); } t = t * sTimebaseInfo.numer / sTimebaseInfo.denom; /* TODO: time_t overflow */ ts.tv_sec = (time_t)(t / 1000000000); ts.tv_nsec = t % 1000000000; goto success; } #endif } else { #if defined(HAVE_CLOCK_GETTIME) clockid_t c; c = NUM2CLOCKID(clk_id); ret = clock_gettime(c, &ts); if (ret == -1) rb_sys_fail("clock_gettime"); goto success; #endif } /* EINVAL emulates clock_gettime behavior when clock_id is invalid. */ errno = EINVAL; rb_sys_fail(0); success: return make_clock_result(&ts, unit); } VALUE rb_mProcess; VALUE rb_mProcUID; VALUE rb_mProcGID; VALUE rb_mProcID_Syscall; /* * The Process module is a collection of methods used to * manipulate processes. */ void Init_process(void) { rb_define_virtual_variable("$?", rb_last_status_get, 0); rb_define_virtual_variable("$$", get_pid, 0); rb_define_global_function("exec", rb_f_exec, -1); rb_define_global_function("fork", rb_f_fork, 0); rb_define_global_function("exit!", rb_f_exit_bang, -1); rb_define_global_function("system", rb_f_system, -1); rb_define_global_function("spawn", rb_f_spawn, -1); rb_define_global_function("sleep", rb_f_sleep, -1); rb_define_global_function("exit", rb_f_exit, -1); rb_define_global_function("abort", rb_f_abort, -1); rb_mProcess = rb_define_module("Process"); #ifdef WNOHANG /* see Process.wait */ rb_define_const(rb_mProcess, "WNOHANG", INT2FIX(WNOHANG)); #else /* see Process.wait */ rb_define_const(rb_mProcess, "WNOHANG", INT2FIX(0)); #endif #ifdef WUNTRACED /* see Process.wait */ rb_define_const(rb_mProcess, "WUNTRACED", INT2FIX(WUNTRACED)); #else /* see Process.wait */ rb_define_const(rb_mProcess, "WUNTRACED", INT2FIX(0)); #endif rb_define_singleton_method(rb_mProcess, "exec", rb_f_exec, -1); rb_define_singleton_method(rb_mProcess, "fork", rb_f_fork, 0); rb_define_singleton_method(rb_mProcess, "spawn", rb_f_spawn, -1); rb_define_singleton_method(rb_mProcess, "exit!", rb_f_exit_bang, -1); rb_define_singleton_method(rb_mProcess, "exit", rb_f_exit, -1); rb_define_singleton_method(rb_mProcess, "abort", rb_f_abort, -1); rb_define_module_function(rb_mProcess, "kill", rb_f_kill, -1); /* in signal.c */ rb_define_module_function(rb_mProcess, "wait", proc_wait, -1); rb_define_module_function(rb_mProcess, "wait2", proc_wait2, -1); rb_define_module_function(rb_mProcess, "waitpid", proc_wait, -1); rb_define_module_function(rb_mProcess, "waitpid2", proc_wait2, -1); rb_define_module_function(rb_mProcess, "waitall", proc_waitall, 0); rb_define_module_function(rb_mProcess, "detach", proc_detach, 1); rb_cProcessStatus = rb_define_class_under(rb_mProcess, "Status", rb_cObject); rb_undef_method(CLASS_OF(rb_cProcessStatus), "new"); rb_define_method(rb_cProcessStatus, "==", pst_equal, 1); rb_define_method(rb_cProcessStatus, "&", pst_bitand, 1); rb_define_method(rb_cProcessStatus, ">>", pst_rshift, 1); rb_define_method(rb_cProcessStatus, "to_i", pst_to_i, 0); rb_define_method(rb_cProcessStatus, "to_s", pst_to_s, 0); rb_define_method(rb_cProcessStatus, "inspect", pst_inspect, 0); rb_define_method(rb_cProcessStatus, "pid", pst_pid, 0); rb_define_method(rb_cProcessStatus, "stopped?", pst_wifstopped, 0); rb_define_method(rb_cProcessStatus, "stopsig", pst_wstopsig, 0); rb_define_method(rb_cProcessStatus, "signaled?", pst_wifsignaled, 0); rb_define_method(rb_cProcessStatus, "termsig", pst_wtermsig, 0); rb_define_method(rb_cProcessStatus, "exited?", pst_wifexited, 0); rb_define_method(rb_cProcessStatus, "exitstatus", pst_wexitstatus, 0); rb_define_method(rb_cProcessStatus, "success?", pst_success_p, 0); rb_define_method(rb_cProcessStatus, "coredump?", pst_wcoredump, 0); rb_define_module_function(rb_mProcess, "pid", get_pid, 0); rb_define_module_function(rb_mProcess, "ppid", get_ppid, 0); rb_define_module_function(rb_mProcess, "getpgrp", proc_getpgrp, 0); rb_define_module_function(rb_mProcess, "setpgrp", proc_setpgrp, 0); rb_define_module_function(rb_mProcess, "getpgid", proc_getpgid, 1); rb_define_module_function(rb_mProcess, "setpgid", proc_setpgid, 2); rb_define_module_function(rb_mProcess, "getsid", proc_getsid, -1); rb_define_module_function(rb_mProcess, "setsid", proc_setsid, 0); rb_define_module_function(rb_mProcess, "getpriority", proc_getpriority, 2); rb_define_module_function(rb_mProcess, "setpriority", proc_setpriority, 3); #ifdef HAVE_GETPRIORITY /* see Process.setpriority */ rb_define_const(rb_mProcess, "PRIO_PROCESS", INT2FIX(PRIO_PROCESS)); /* see Process.setpriority */ rb_define_const(rb_mProcess, "PRIO_PGRP", INT2FIX(PRIO_PGRP)); /* see Process.setpriority */ rb_define_const(rb_mProcess, "PRIO_USER", INT2FIX(PRIO_USER)); #endif rb_define_module_function(rb_mProcess, "getrlimit", proc_getrlimit, 1); rb_define_module_function(rb_mProcess, "setrlimit", proc_setrlimit, -1); #if defined(RLIM2NUM) && defined(RLIM_INFINITY) { VALUE inf = RLIM2NUM(RLIM_INFINITY); #ifdef RLIM_SAVED_MAX { VALUE v = RLIM_INFINITY == RLIM_SAVED_MAX ? inf : RLIM2NUM(RLIM_SAVED_MAX); /* see Process.setrlimit */ rb_define_const(rb_mProcess, "RLIM_SAVED_MAX", v); } #endif /* see Process.setrlimit */ rb_define_const(rb_mProcess, "RLIM_INFINITY", inf); #ifdef RLIM_SAVED_CUR { VALUE v = RLIM_INFINITY == RLIM_SAVED_CUR ? inf : RLIM2NUM(RLIM_SAVED_CUR); /* see Process.setrlimit */ rb_define_const(rb_mProcess, "RLIM_SAVED_CUR", v); } #endif } #ifdef RLIMIT_AS /* Maximum size of the process's virtual memory (address space) in bytes. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_AS", INT2FIX(RLIMIT_AS)); #endif #ifdef RLIMIT_CORE /* Maximum size of the core file. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_CORE", INT2FIX(RLIMIT_CORE)); #endif #ifdef RLIMIT_CPU /* CPU time limit in seconds. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_CPU", INT2FIX(RLIMIT_CPU)); #endif #ifdef RLIMIT_DATA /* Maximum size of the process's data segment. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_DATA", INT2FIX(RLIMIT_DATA)); #endif #ifdef RLIMIT_FSIZE /* Maximum size of files that the process may create. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_FSIZE", INT2FIX(RLIMIT_FSIZE)); #endif #ifdef RLIMIT_MEMLOCK /* Maximum number of bytes of memory that may be locked into RAM. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_MEMLOCK", INT2FIX(RLIMIT_MEMLOCK)); #endif #ifdef RLIMIT_MSGQUEUE /* Specifies the limit on the number of bytes that can be allocated * for POSIX message queues for the real user ID of the calling process. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_MSGQUEUE", INT2FIX(RLIMIT_MSGQUEUE)); #endif #ifdef RLIMIT_NICE /* Specifies a ceiling to which the process's nice value can be raised. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_NICE", INT2FIX(RLIMIT_NICE)); #endif #ifdef RLIMIT_NOFILE /* Specifies a value one greater than the maximum file descriptor * number that can be opened by this process. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_NOFILE", INT2FIX(RLIMIT_NOFILE)); #endif #ifdef RLIMIT_NPROC /* The maximum number of processes that can be created for the * real user ID of the calling process. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_NPROC", INT2FIX(RLIMIT_NPROC)); #endif #ifdef RLIMIT_RSS /* Specifies the limit (in pages) of the process's resident set. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_RSS", INT2FIX(RLIMIT_RSS)); #endif #ifdef RLIMIT_RTPRIO /* Specifies a ceiling on the real-time priority that may be set for this process. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_RTPRIO", INT2FIX(RLIMIT_RTPRIO)); #endif #ifdef RLIMIT_RTTIME /* Specifies limit on CPU time this process scheduled under a real-time * scheduling policy can consume. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_RTTIME", INT2FIX(RLIMIT_RTTIME)); #endif #ifdef RLIMIT_SBSIZE /* Maximum size of the socket buffer. */ rb_define_const(rb_mProcess, "RLIMIT_SBSIZE", INT2FIX(RLIMIT_SBSIZE)); #endif #ifdef RLIMIT_SIGPENDING /* Specifies a limit on the number of signals that may be queued for * the real user ID of the calling process. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_SIGPENDING", INT2FIX(RLIMIT_SIGPENDING)); #endif #ifdef RLIMIT_STACK /* Maximum size of the stack, in bytes. * * see the system getrlimit(2) manual for details. */ rb_define_const(rb_mProcess, "RLIMIT_STACK", INT2FIX(RLIMIT_STACK)); #endif #endif rb_define_module_function(rb_mProcess, "uid", proc_getuid, 0); rb_define_module_function(rb_mProcess, "uid=", proc_setuid, 1); rb_define_module_function(rb_mProcess, "gid", proc_getgid, 0); rb_define_module_function(rb_mProcess, "gid=", proc_setgid, 1); rb_define_module_function(rb_mProcess, "euid", proc_geteuid, 0); rb_define_module_function(rb_mProcess, "euid=", proc_seteuid_m, 1); rb_define_module_function(rb_mProcess, "egid", proc_getegid, 0); rb_define_module_function(rb_mProcess, "egid=", proc_setegid_m, 1); rb_define_module_function(rb_mProcess, "initgroups", proc_initgroups, 2); rb_define_module_function(rb_mProcess, "groups", proc_getgroups, 0); rb_define_module_function(rb_mProcess, "groups=", proc_setgroups, 1); rb_define_module_function(rb_mProcess, "maxgroups", proc_getmaxgroups, 0); rb_define_module_function(rb_mProcess, "maxgroups=", proc_setmaxgroups, 1); rb_define_module_function(rb_mProcess, "daemon", proc_daemon, -1); rb_define_module_function(rb_mProcess, "times", rb_proc_times, 0); #ifdef CLOCK_REALTIME rb_define_const(rb_mProcess, "CLOCK_REALTIME", CLOCKID2NUM(CLOCK_REALTIME)); #elif defined(RUBY_SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME) rb_define_const(rb_mProcess, "CLOCK_REALTIME", RUBY_SUS_GETTIMEOFDAY_BASED_CLOCK_REALTIME); #endif #ifdef CLOCK_MONOTONIC rb_define_const(rb_mProcess, "CLOCK_MONOTONIC", CLOCKID2NUM(CLOCK_MONOTONIC)); #elif defined(RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) rb_define_const(rb_mProcess, "CLOCK_MONOTONIC", RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC); #endif #ifdef CLOCK_PROCESS_CPUTIME_ID rb_define_const(rb_mProcess, "CLOCK_PROCESS_CPUTIME_ID", CLOCKID2NUM(CLOCK_PROCESS_CPUTIME_ID)); #elif defined(RUBY_SUS_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) rb_define_const(rb_mProcess, "CLOCK_PROCESS_CPUTIME_ID", RUBY_SUS_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID); #endif #ifdef CLOCK_THREAD_CPUTIME_ID rb_define_const(rb_mProcess, "CLOCK_THREAD_CPUTIME_ID", CLOCKID2NUM(CLOCK_THREAD_CPUTIME_ID)); #endif #ifdef CLOCK_VIRTUAL rb_define_const(rb_mProcess, "CLOCK_VIRTUAL", CLOCKID2NUM(CLOCK_VIRTUAL)); #endif #ifdef CLOCK_PROF rb_define_const(rb_mProcess, "CLOCK_PROF", CLOCKID2NUM(CLOCK_PROF)); #endif #ifdef CLOCK_REALTIME_FAST rb_define_const(rb_mProcess, "CLOCK_REALTIME_FAST", CLOCKID2NUM(CLOCK_REALTIME_FAST)); #endif #ifdef CLOCK_REALTIME_PRECISE rb_define_const(rb_mProcess, "CLOCK_REALTIME_PRECISE", CLOCKID2NUM(CLOCK_REALTIME_PRECISE)); #endif #ifdef CLOCK_REALTIME_COARSE rb_define_const(rb_mProcess, "CLOCK_REALTIME_COARSE", CLOCKID2NUM(CLOCK_REALTIME_COARSE)); #endif #ifdef CLOCK_REALTIME_ALARM rb_define_const(rb_mProcess, "CLOCK_REALTIME_ALARM", CLOCKID2NUM(CLOCK_REALTIME_ALARM)); #endif #ifdef CLOCK_MONOTONIC_FAST rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_FAST", CLOCKID2NUM(CLOCK_MONOTONIC_FAST)); #endif #ifdef CLOCK_MONOTONIC_PRECISE rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_PRECISE", CLOCKID2NUM(CLOCK_MONOTONIC_PRECISE)); #endif #ifdef CLOCK_MONOTONIC_RAW rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_RAW", CLOCKID2NUM(CLOCK_MONOTONIC_RAW)); #endif #ifdef CLOCK_MONOTONIC_COARSE rb_define_const(rb_mProcess, "CLOCK_MONOTONIC_COARSE", CLOCKID2NUM(CLOCK_MONOTONIC_COARSE)); #endif #ifdef CLOCK_BOOTTIME rb_define_const(rb_mProcess, "CLOCK_BOOTTIME", CLOCKID2NUM(CLOCK_BOOTTIME)); #endif #ifdef CLOCK_BOOTTIME_ALARM rb_define_const(rb_mProcess, "CLOCK_BOOTTIME_ALARM", CLOCKID2NUM(CLOCK_BOOTTIME_ALARM)); #endif #ifdef CLOCK_UPTIME rb_define_const(rb_mProcess, "CLOCK_UPTIME", CLOCKID2NUM(CLOCK_UPTIME)); #endif #ifdef CLOCK_UPTIME_FAST rb_define_const(rb_mProcess, "CLOCK_UPTIME_FAST", CLOCKID2NUM(CLOCK_UPTIME_FAST)); #endif #ifdef CLOCK_UPTIME_PRECISE rb_define_const(rb_mProcess, "CLOCK_UPTIME_PRECISE", CLOCKID2NUM(CLOCK_UPTIME_PRECISE)); #endif #ifdef CLOCK_SECOND rb_define_const(rb_mProcess, "CLOCK_SECOND", CLOCKID2NUM(CLOCK_SECOND)); #endif rb_define_module_function(rb_mProcess, "clock_gettime", rb_clock_gettime, -1); #if defined(HAVE_TIMES) || defined(_WIN32) rb_cProcessTms = rb_struct_define("Tms", "utime", "stime", "cutime", "cstime", NULL); #endif SAVED_USER_ID = geteuid(); SAVED_GROUP_ID = getegid(); rb_mProcUID = rb_define_module_under(rb_mProcess, "UID"); rb_mProcGID = rb_define_module_under(rb_mProcess, "GID"); rb_define_module_function(rb_mProcUID, "rid", proc_getuid, 0); rb_define_module_function(rb_mProcGID, "rid", proc_getgid, 0); rb_define_module_function(rb_mProcUID, "eid", proc_geteuid, 0); rb_define_module_function(rb_mProcGID, "eid", proc_getegid, 0); rb_define_module_function(rb_mProcUID, "change_privilege", p_uid_change_privilege, 1); rb_define_module_function(rb_mProcGID, "change_privilege", p_gid_change_privilege, 1); rb_define_module_function(rb_mProcUID, "grant_privilege", p_uid_grant_privilege, 1); rb_define_module_function(rb_mProcGID, "grant_privilege", p_gid_grant_privilege, 1); rb_define_alias(rb_singleton_class(rb_mProcUID), "eid=", "grant_privilege"); rb_define_alias(rb_singleton_class(rb_mProcGID), "eid=", "grant_privilege"); rb_define_module_function(rb_mProcUID, "re_exchange", p_uid_exchange, 0); rb_define_module_function(rb_mProcGID, "re_exchange", p_gid_exchange, 0); rb_define_module_function(rb_mProcUID, "re_exchangeable?", p_uid_exchangeable, 0); rb_define_module_function(rb_mProcGID, "re_exchangeable?", p_gid_exchangeable, 0); rb_define_module_function(rb_mProcUID, "sid_available?", p_uid_have_saved_id, 0); rb_define_module_function(rb_mProcGID, "sid_available?", p_gid_have_saved_id, 0); rb_define_module_function(rb_mProcUID, "switch", p_uid_switch, 0); rb_define_module_function(rb_mProcGID, "switch", p_gid_switch, 0); #ifdef p_uid_from_name rb_define_module_function(rb_mProcUID, "from_name", p_uid_from_name, 1); #endif #ifdef p_gid_from_name rb_define_module_function(rb_mProcGID, "from_name", p_gid_from_name, 1); #endif rb_mProcID_Syscall = rb_define_module_under(rb_mProcess, "Sys"); rb_define_module_function(rb_mProcID_Syscall, "getuid", proc_getuid, 0); rb_define_module_function(rb_mProcID_Syscall, "geteuid", proc_geteuid, 0); rb_define_module_function(rb_mProcID_Syscall, "getgid", proc_getgid, 0); rb_define_module_function(rb_mProcID_Syscall, "getegid", proc_getegid, 0); rb_define_module_function(rb_mProcID_Syscall, "setuid", p_sys_setuid, 1); rb_define_module_function(rb_mProcID_Syscall, "setgid", p_sys_setgid, 1); rb_define_module_function(rb_mProcID_Syscall, "setruid", p_sys_setruid, 1); rb_define_module_function(rb_mProcID_Syscall, "setrgid", p_sys_setrgid, 1); rb_define_module_function(rb_mProcID_Syscall, "seteuid", p_sys_seteuid, 1); rb_define_module_function(rb_mProcID_Syscall, "setegid", p_sys_setegid, 1); rb_define_module_function(rb_mProcID_Syscall, "setreuid", p_sys_setreuid, 2); rb_define_module_function(rb_mProcID_Syscall, "setregid", p_sys_setregid, 2); rb_define_module_function(rb_mProcID_Syscall, "setresuid", p_sys_setresuid, 3); rb_define_module_function(rb_mProcID_Syscall, "setresgid", p_sys_setresgid, 3); rb_define_module_function(rb_mProcID_Syscall, "issetugid", p_sys_issetugid, 0); }