40 #define EXIT_SUCCESS 0 43 #define EXIT_FAILURE 1 46 #ifdef HAVE_SYS_WAIT_H 47 # include <sys/wait.h> 49 #ifdef HAVE_SYS_RESOURCE_H 50 # include <sys/resource.h> 55 #ifdef HAVE_SYS_PARAM_H 56 # include <sys/param.h> 59 # define MAXPATHLEN 1024 64 #if defined(__native_client__) && defined(NACL_NEWLIB) 65 # include <sys/unistd.h> 69 # undef HAVE_ISSETUGID 72 #ifdef HAVE_SYS_TIME_H 75 #ifdef HAVE_SYS_TIMES_H 76 #include <sys/times.h> 85 int initgroups(
const char *, rb_gid_t);
93 # include <mach/mach_time.h> 99 #define open rb_w32_uopen 102 #if defined(HAVE_TIMES) || defined(_WIN32) 103 static VALUE rb_cProcessTms;
107 #define WIFEXITED(w) (((w) & 0xff) == 0) 110 #define WIFSIGNALED(w) (((w) & 0x7f) > 0 && (((w) & 0x7f) < 0x7f)) 113 #define WIFSTOPPED(w) (((w) & 0xff) == 0x7f) 116 #define WEXITSTATUS(w) (((w) >> 8) & 0xff) 119 #define WTERMSIG(w) ((w) & 0x7f) 122 #define WSTOPSIG WEXITSTATUS 125 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__bsdi__) 126 #define HAVE_44BSD_SETUID 1 127 #define HAVE_44BSD_SETGID 1 135 #ifdef BROKEN_SETREUID 136 #define setreuid ruby_setreuid 137 int setreuid(rb_uid_t ruid, rb_uid_t euid);
139 #ifdef BROKEN_SETREGID 140 #define setregid ruby_setregid 141 int setregid(rb_gid_t rgid, rb_gid_t egid);
144 #if defined(HAVE_44BSD_SETUID) || defined(__APPLE__) 145 #if !defined(USE_SETREUID) && !defined(BROKEN_SETREUID) 146 #define OBSOLETE_SETREUID 1 148 #if !defined(USE_SETREGID) && !defined(BROKEN_SETREGID) 149 #define OBSOLETE_SETREGID 1 153 #define preserving_errno(stmts) \ 154 do {int saved_errno = errno; stmts; errno = saved_errno;} while (0) 160 #define p_uid_from_name p_uid_from_name 161 #define p_gid_from_name p_gid_from_name 164 #if defined(HAVE_PWD_H) 165 # if defined(HAVE_GETPWNAM_R) && defined(_SC_GETPW_R_SIZE_MAX) 166 # define USE_GETPWNAM_R 1 167 # define GETPW_R_SIZE_INIT sysconf(_SC_GETPW_R_SIZE_MAX) 168 # define GETPW_R_SIZE_DEFAULT 0x1000 169 # define GETPW_R_SIZE_LIMIT 0x10000 171 # ifdef USE_GETPWNAM_R 172 # define PREPARE_GETPWNAM \ 174 # define FINISH_GETPWNAM \ 175 (getpw_buf ? (void)rb_str_resize(getpw_buf, 0) : (void)0) 176 # define OBJ2UID1(id) obj2uid((id), &getpw_buf) 177 # define OBJ2UID(id) obj2uid0(id) 178 static rb_uid_t obj2uid(
VALUE id,
VALUE *getpw_buf);
179 static inline rb_uid_t
189 # define PREPARE_GETPWNAM 190 # define FINISH_GETPWNAM 191 # define OBJ2UID1(id) obj2uid((id)) 192 # define OBJ2UID(id) obj2uid((id)) 193 static rb_uid_t obj2uid(
VALUE id);
196 # define PREPARE_GETPWNAM 197 # define FINISH_GETPWNAM 198 # define OBJ2UID1(id) NUM2UIDT(id) 199 # define OBJ2UID(id) NUM2UIDT(id) 200 # ifdef p_uid_from_name 201 # undef p_uid_from_name 202 # define p_uid_from_name rb_f_notimplement 206 #if defined(HAVE_GRP_H) 207 # if defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX) 208 # define USE_GETGRNAM_R 209 # define GETGR_R_SIZE_INIT sysconf(_SC_GETGR_R_SIZE_MAX) 210 # define GETGR_R_SIZE_DEFAULT 0x1000 211 # define GETGR_R_SIZE_LIMIT 0x10000 213 # ifdef USE_GETGRNAM_R 214 # define PREPARE_GETGRNAM \ 216 # define FINISH_GETGRNAM \ 217 (getgr_buf ? (void)rb_str_resize(getgr_buf, 0) : (void)0) 218 # define OBJ2GID1(id) obj2gid((id), &getgr_buf) 219 # define OBJ2GID(id) obj2gid0(id) 220 static rb_gid_t obj2gid(
VALUE id,
VALUE *getgr_buf);
221 static inline rb_gid_t
230 static rb_gid_t obj2gid(
VALUE id,
VALUE *getgr_buf);
232 # define PREPARE_GETGRNAM 233 # define FINISH_GETGRNAM 234 # define OBJ2GID1(id) obj2gid((id)) 235 # define OBJ2GID(id) obj2gid((id)) 236 static rb_gid_t obj2gid(
VALUE id);
239 # define PREPARE_GETGRNAM 240 # define FINISH_GETGRNAM 241 # define OBJ2GID1(id) NUM2GIDT(id) 242 # define OBJ2GID(id) NUM2GIDT(id) 243 # ifdef p_gid_from_name 244 # undef p_gid_from_name 245 # define p_gid_from_name rb_f_notimplement 249 #if SIZEOF_CLOCK_T == SIZEOF_INT 251 #elif SIZEOF_CLOCK_T == SIZEOF_LONG 253 #elif defined(HAVE_LONG_LONG) && SIZEOF_CLOCK_T == SIZEOF_LONG_LONG 266 static ID id_new_pgroup;
273 static ID id_TIMES_BASED_CLOCK_MONOTONIC;
274 static ID id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID;
277 static ID id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID;
281 static ID id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC;
285 #define id_status ruby_static_id_status 288 #if defined(__sun) && !defined(_XPG7) 289 #define execv(path, argv) (rb_async_bug_errno("unreachable: async-signal-unsafe execv() is called", 0)) 290 #define execl(path, arg0, arg1, arg2, term) do { extern char **environ; execle((path), (arg0), (arg1), (arg2), (term), (environ)); } while (0) 291 #define ALWAYS_NEED_ENVP 1 293 #define ALWAYS_NEED_ENVP 0 308 #if defined(DEBUG_REDIRECT) 313 ttyprintf(
const char *fmt, ...)
319 tty = fopen(
"con",
"w");
321 tty = fopen(
"/dev/tty",
"w");
327 vfprintf(tty, fmt, ap);
338 ttyprintf(
"dup(%d) => %d\n", oldfd, ret);
346 ret =
dup2(oldfd, newfd);
347 ttyprintf(
"dup2(%d, %d) => %d\n", oldfd, newfd, ret);
356 ttyprintf(
"cloexec_dup(%d) => %d\n", oldfd, ret);
365 ttyprintf(
"cloexec_dup2(%d, %d) => %d\n", oldfd, newfd, ret);
374 ttyprintf(
"close(%d) => %d\n", fd, ret);
383 ttyprintf(
"parent_open(\"%s\", 0x%x, 0%o) => %d\n", pathname,
flags, perm, ret);
392 ttyprintf(
"parent_close(%d) => %d\n", fd, ret);
397 #define redirect_dup(oldfd) dup(oldfd) 398 #define redirect_dup2(oldfd, newfd) dup2((oldfd), (newfd)) 399 #define redirect_cloexec_dup(oldfd) rb_cloexec_dup(oldfd) 400 #define redirect_cloexec_dup2(oldfd, newfd) rb_cloexec_dup2((oldfd), (newfd)) 401 #define redirect_close(fd) close_unless_reserved(fd) 402 #define parent_redirect_open(pathname, flags, perm) rb_cloexec_open((pathname), (flags), (perm)) 403 #define parent_redirect_close(fd) close_unless_reserved(fd) 518 #define PST2INT(st) NUM2INT(pst_to_i(st)) 545 rb_str_catf(str,
" stopped SIG%s (signal %d)", signame, stopsig);
555 rb_str_catf(str,
" SIG%s (signal %d)", signame, termsig);
565 if (WCOREDUMP(status)) {
642 if (st1 == st2)
return Qtrue;
853 if (WCOREDUMP(status))
871 #if defined HAVE_WAITPID 872 return waitpid(pid, st, flags);
873 #elif defined HAVE_WAIT4 874 return wait4(pid, st, flags,
NULL);
876 # error waitpid or wait4 is required. 885 return (
void *)(
VALUE)result;
898 return (rb_pid_t)(
VALUE)result;
994 if (argc == 2 && !
NIL_P(vflags = argv[1])) {
998 if ((pid =
rb_waitpid(pid, &status, flags)) < 0)
1087 rb_pid_t cpid,
pid = (rb_pid_t)(
VALUE)arg;
1090 while ((cpid =
rb_waitpid(pid, &status, 0)) == 0) {
1207 #define before_fork_ruby() before_exec() 1208 #define after_fork_ruby() (rb_threadptr_pending_interrupt_clear(GET_THREAD()), after_exec()) 1222 #if defined(HAVE_WORKING_FORK) && !defined(__native_client__) 1225 #define try_with_sh(prog, argv, envp) ((saved_errno == ENOEXEC) ? exec_with_sh((prog), (argv), (envp)) : (void)0) 1227 exec_with_sh(
const char *prog,
char **
argv,
char **envp)
1229 *
argv = (
char *)prog;
1230 *--
argv = (
char *)
"sh";
1232 execve(
"/bin/sh",
argv, envp);
1234 execv(
"/bin/sh",
argv);
1238 #define try_with_sh(prog, argv, envp) (void)0 1245 #ifdef __native_client__ 1266 execve(prog, argv, envp);
1279 #ifdef __native_client__ 1286 while (*s ==
' ' || *s ==
'\t' || *s ==
'\n')
1298 #if defined(__CYGWIN32__) 1304 execl(shell,
"sh",
"-c", str, (
char *)
NULL);
1306 status = system(str);
1312 execle(
"/bin/sh",
"sh",
"-c", str, (
char *)
NULL, (
char **)
RSTRING_PTR(envp_str));
1314 execl(
"/bin/sh",
"sh",
"-c", str, (
char *)NULL);
1370 # define DEFAULT_PROCESS_ENCODING rb_utf8_encoding() 1372 #ifdef DEFAULT_PROCESS_ENCODING 1373 # define EXPORT_STR(str) rb_str_export_to_enc((str), DEFAULT_PROCESS_ENCODING) 1374 # define EXPORT_DUP(str) export_dup(str) 1376 export_dup(
VALUE str)
1383 # define EXPORT_STR(str) (str) 1384 # define EXPORT_DUP(str) rb_str_dup(str) 1387 #if !defined(HAVE_WORKING_FORK) && defined(HAVE_SPAWNV) 1388 # define USE_SPAWNV 1 1390 # define USE_SPAWNV 0 1393 # define P_NOWAIT _P_NOWAIT 1398 #define proc_spawn_cmd_internal(argv, prog) rb_w32_uaspawn(P_NOWAIT, (prog), (argv)) 1401 proc_spawn_cmd_internal(
char **
argv,
char *prog)
1414 status = spawnv(
P_NOWAIT, prog, (
const char **)argv);
1415 if (status == -1 &&
errno == ENOEXEC) {
1416 *argv = (
char *)prog;
1417 *--argv = (
char *)
"sh";
1418 status = spawnv(
P_NOWAIT,
"/bin/sh", (
const char **)argv);
1420 if (status == -1)
errno = ENOEXEC;
1435 flags = CREATE_NEW_PROCESS_GROUP;
1446 #define proc_spawn_sh(str) rb_w32_uspawn(P_NOWAIT, (str), 0) 1449 proc_spawn_sh(
char *str)
1456 status = spawnl(
P_NOWAIT, (shell ? shell :
"/bin/sh"),
"sh",
"-c", str, (
char*)
NULL);
1504 else if (fd >= 3 && iskey) {
1541 switch (
TYPE(val)) {
1548 else if (
id ==
id_in) {
1595 flags, perm,
Qnil));
1606 flags =
INT2NUM(O_WRONLY|O_CREAT|O_TRUNC);
1615 flags =
INT2NUM(O_WRONLY|O_CREAT|O_TRUNC);
1623 flags, perm,
Qnil));
1630 if (!
NIL_P(val))
goto io;
1636 #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) 1637 static int rlimit_type_by_sym(
VALUE key);
1643 VALUE tmp, softlim, hardlim;
1675 switch (
TYPE(key)) {
1677 #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) 1679 int rtype = rlimit_type_by_sym(key);
1681 rb_execarg_addopt_rlimit(eargp, rtype, val);
1689 if (
id == id_pgroup) {
1696 else if (val ==
Qtrue)
1710 if (
id == id_new_pgroup) {
1750 else if (
id ==
id_in) {
1774 "uid option is unimplemented on this machine");
1789 "gid option is unimplemented on this machine");
1833 VALUE execarg_obj = args[0];
1835 VALUE nonopts = args[1];
1902 if (oldfd != lastfd) {
1933 args[0] = execarg_obj;
1939 #ifdef ENV_IGNORECASE 1940 #define ENVMATCH(s1, s2) (STRCASECMP((s1), (s2)) == 0) 1942 #define ENVMATCH(n1, n2) (strcmp((n1), (n2)) == 0) 1990 const char *
name = 0;
2007 for (i = 0; i <
argc; i++) {
2036 *opthash_ret =
hash;
2051 prog = (*argv_p)[0];
2052 if (accept_shell && *argc_p == 1) {
2070 int ret = strncmp(word->
ptr, el, word->
len);
2071 if (!ret && ((
const char *)el)[word->
len]) ret = -1;
2084 if (!
NIL_P(opthash)) {
2095 eargp->
invoke.
sh.shell_script = prog;
2101 static const char posix_sh_cmds[][9] = {
2160 if (*p ==
' ' || *p ==
'\t') {
2161 if (first.
ptr && !first.
len) first.
len = p - first.
ptr;
2164 if (!first.
ptr) first.
ptr = p;
2166 if (!has_meta &&
strchr(
"*?{}[]<>()~&|\\$;'`\"\n#", *p))
2172 else if (*p ==
'/') {
2179 if (!has_meta && first.
ptr) {
2180 if (!first.
len) first.
len = p - first.
ptr;
2181 if (first.
len > 0 && first.
len <=
sizeof(posix_sh_cmds[0]) &&
2194 while (*p ==
' ' || *p ==
'\t')
2198 while (*p && *p !=
' ' && *p !=
'\t')
2211 const char *abspath;
2212 const char *path_env = 0;
2215 path_env, fbuf,
sizeof(fbuf));
2227 for (i = 0; i <
argc; i++) {
2228 VALUE arg = argv[i];
2230 #ifdef DEFAULT_PROCESS_ENCODING 2240 const char *p, *ep, *null=
NULL;
2340 int unsetenv_others;
2361 open_data.
fname = vpath;
2365 open_data.
err = EINTR;
2367 if (open_data.ret == -1) {
2368 if (open_data.err == EINTR) {
2374 fd2 = open_data.ret;
2401 if (unsetenv_others) {
2505 if (!errmsg || !*errmsg)
return;
2506 if (strcmp(errmsg,
"chdir") == 0) {
2514 rb_execarg_fail(
VALUE execarg_obj,
int err,
const char *errmsg)
2516 if (!errmsg || !*errmsg)
return;
2598 VALUE execarg_obj, fail_str;
2600 #define CHILD_ERRMSG_BUFLEN 80 2621 #define ERRMSG(str) do { if (errmsg && 0 < errmsg_buflen) strlcpy(errmsg, (str), errmsg_buflen); } while (0) 2622 #define ERRMSG1(str, a) do { if (errmsg && 0 < errmsg_buflen) snprintf(errmsg, errmsg_buflen, (str), (a)); } while (0) 2623 #define ERRMSG2(str, a, b) do { if (errmsg && 0 < errmsg_buflen) snprintf(errmsg, errmsg_buflen, (str), (a), (b)); } while (0) 2625 static int fd_get_cloexec(
int fd,
char *errmsg,
size_t errmsg_buflen);
2626 static int fd_set_cloexec(
int fd,
char *errmsg,
size_t errmsg_buflen);
2633 VALUE newary, redirection;
2635 if (save_fd == -1) {
2666 return *(
int*)a - *(
int*)b;
2672 return *(
int*)b - *(
int*)a;
2697 ERRMSG(
"fcntl(F_GETFD)");
2713 ERRMSG(
"fcntl(F_GETFD)");
2720 ERRMSG(
"fcntl(F_SETFD)");
2736 ERRMSG(
"fcntl(F_GETFD)");
2743 ERRMSG(
"fcntl(F_SETFD)");
2764 for (i = 0; i < n; i++) {
2779 for (i = 0; i < n; i++) {
2786 while (pairs < found && (found-1)->
oldfd == newfd)
2788 while (found < pairs+n && found->
oldfd == newfd) {
2797 for (i = 0; i < n; i++) {
2799 while (j != -1 && pairs[j].
oldfd != -1 && pairs[j].
num_newer == 0) {
2812 pairs[j].
oldfd = -1;
2820 for (i = 0; i < n; i++) {
2822 if (pairs[i].
oldfd == -1)
2827 pairs[i].
oldfd = -1;
2830 if (extra_fd == -1) {
2832 if (extra_fd == -1) {
2846 pairs[i].
oldfd = extra_fd;
2856 pairs[j].
oldfd = -1;
2860 if (extra_fd != -1) {
2920 run_exec_pgroup(
const struct rb_execarg *eargp,
struct rb_execarg *sargp,
char *errmsg,
size_t errmsg_buflen)
2945 ret = setpgid(getpid(), pgroup);
2946 if (ret == -1)
ERRMSG(
"setpgid");
2951 #if defined(HAVE_SETRLIMIT) && defined(RLIM2NUM) 2954 run_exec_rlimit(
VALUE ary,
struct rb_execarg *sargp,
char *errmsg,
size_t errmsg_buflen)
2963 if (getrlimit(rtype, &rlim) == -1) {
2968 RLIM2NUM(rlim.rlim_cur),
2969 RLIM2NUM(rlim.rlim_max)));
2978 if (setrlimit(rtype, &rlim) == -1) {
2987 #if !defined(HAVE_WORKING_FORK) 3016 #define chdir(p) rb_w32_uchdir(p) 3033 if (run_exec_pgroup(eargp, sargp, errmsg, errmsg_buflen) == -1)
3038 #if defined(HAVE_SETRLIMIT) && defined(RLIM2NUM) 3041 if (run_exec_rlimit(obj, sargp, errmsg, errmsg_buflen) == -1)
3046 #if !defined(HAVE_WORKING_FORK) 3086 rb_warn(
"cannot close fd before spawn");
3093 #ifdef HAVE_WORKING_FORK 3152 #if !defined(HAVE_WORKING_FORK) 3153 struct rb_execarg sarg, *
const sargp = &sarg;
3166 char *abspath =
NULL;
3171 #if !defined(HAVE_WORKING_FORK) 3179 #ifdef HAVE_WORKING_FORK 3182 rb_exec_atfork(
void* arg,
char *errmsg,
size_t errmsg_buflen)
3188 #ifdef HAVE_WORKING_FORK 3189 #if SIZEOF_INT == SIZEOF_LONG 3190 #define proc_syswait (VALUE (*)(VALUE))rb_syswait 3201 move_fds_to_avoid_crash(
int *fdp,
int n,
VALUE fds)
3205 for (i = 0; i < n; i++) {
3224 pipe_nocrash(
int filedes[2],
VALUE fds)
3232 if (move_fds_to_avoid_crash(filedes, 2, fds) == -1) {
3247 handle_fork_error(
int *status,
int *ep,
volatile int *try_gc_p)
3259 #if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN 3262 if (!status && !ep) {
3268 if (status) *status = state;
3269 if (!state)
return 0;
3280 #define prefork() ( \ 3281 rb_io_flush(rb_stdout), \ 3282 rb_io_flush(rb_stderr) \ 3312 write_retry(
int fd,
const void *
buf,
size_t len)
3317 w = write(fd, buf, len);
3318 }
while (w < 0 &&
errno == EINTR);
3324 read_retry(
int fd,
void *buf,
size_t len)
3329 r = read(fd, buf, len);
3330 }
while (r < 0 &&
errno == EINTR);
3336 send_child_error(
int fd,
char *errmsg,
size_t errmsg_buflen)
3341 if (write_retry(fd, &err,
sizeof(err)) < 0) err =
errno;
3342 if (errmsg && 0 < errmsg_buflen) {
3343 errmsg[errmsg_buflen-1] =
'\0';
3344 errmsg_buflen =
strlen(errmsg);
3345 if (errmsg_buflen > 0 && write_retry(fd, errmsg, errmsg_buflen) < 0)
3351 recv_child_error(
int fd,
int *errp,
char *errmsg,
size_t errmsg_buflen)
3355 if ((size = read_retry(fd, &err,
sizeof(err))) < 0) {
3359 if (size ==
sizeof(err) &&
3360 errmsg && 0 < errmsg_buflen) {
3361 ssize_t ret = read_retry(fd, errmsg, errmsg_buflen-1);
3370 #ifdef HAVE_WORKING_VFORK 3371 #if !defined(HAVE_GETRESUID) && defined(HAVE_GETUIDX) 3374 getresuid(rb_uid_t *ruid, rb_uid_t *euid, rb_uid_t *suid)
3380 ret = getuidx(ID_SAVED);
3381 if (ret == (rb_uid_t)-1)
3386 #define HAVE_GETRESUID 3389 #if !defined(HAVE_GETRESGID) && defined(HAVE_GETGIDX) 3392 getresgid(rb_gid_t *rgid, rb_gid_t *egid, rb_gid_t *sgid)
3398 ret = getgidx(ID_SAVED);
3399 if (ret == (rb_gid_t)-1)
3404 #define HAVE_GETRESGID 3422 rb_uid_t ruid, euid;
3423 rb_gid_t rgid, egid;
3425 #if defined HAVE_ISSETUGID 3430 #ifdef HAVE_GETRESUID 3434 ret = getresuid(&ruid, &euid, &suid);
3445 if (euid == 0 || euid != ruid)
3448 #ifdef HAVE_GETRESGID 3452 ret = getresgid(&rgid, &egid, &sgid);
3470 struct child_handler_disabler_state
3477 disable_child_handler_before_fork(
struct child_handler_disabler_state *old)
3482 #ifdef HAVE_PTHREAD_SIGMASK 3483 ret = sigfillset(&all);
3487 ret = pthread_sigmask(SIG_SETMASK, &all, &old->sigmask);
3492 # pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous" 3495 #ifdef PTHREAD_CANCEL_DISABLE 3496 ret = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old->cancelstate);
3504 disable_child_handler_fork_parent(
struct child_handler_disabler_state *old)
3508 #ifdef PTHREAD_CANCEL_DISABLE 3509 ret = pthread_setcancelstate(old->cancelstate,
NULL);
3515 #ifdef HAVE_PTHREAD_SIGMASK 3516 ret = pthread_sigmask(SIG_SETMASK, &old->sigmask,
NULL);
3521 # pragma GCC warning "pthread_sigmask on fork is not available. potentially dangerous" 3527 disable_child_handler_fork_child(
struct child_handler_disabler_state *old,
char *errmsg,
size_t errmsg_buflen)
3532 for (sig = 1; sig <
NSIG; sig++) {
3533 sig_t handler = signal(sig, SIG_DFL);
3535 if (handler == SIG_ERR &&
errno == EINVAL) {
3538 if (handler == SIG_ERR) {
3539 ERRMSG(
"signal to obtain old action");
3543 if (sig == SIGPIPE) {
3548 if (handler == SIG_IGN) {
3549 signal(sig, SIG_IGN);
3553 ret = sigprocmask(SIG_SETMASK, &old->sigmask,
NULL);
3562 retry_fork_async_signal_safe(
int *status,
int *ep,
3563 int (*
chfunc)(
void*,
char *,
size_t),
void *charg,
3564 char *errmsg,
size_t errmsg_buflen)
3567 volatile int try_gc = 1;
3568 struct child_handler_disabler_state old;
3572 disable_child_handler_before_fork(&old);
3573 #ifdef HAVE_WORKING_VFORK 3574 if (!has_privilege())
3584 ret = disable_child_handler_fork_child(&old, errmsg, errmsg_buflen);
3586 ret =
chfunc(charg, errmsg, errmsg_buflen);
3589 send_child_error(ep[1], errmsg, errmsg_buflen);
3590 #if EXIT_SUCCESS == 127 3600 if (handle_fork_error(status, ep, &try_gc))
3607 char *errmsg,
size_t errmsg_buflen)
3614 if (status) *status = 0;
3616 if (pipe_nocrash(ep, fds))
return -1;
3617 pid = retry_fork_async_signal_safe(status, ep,
chfunc, charg, errmsg, errmsg_buflen);
3621 error_occurred = recv_child_error(ep[0], &err, errmsg, errmsg_buflen);
3622 if (error_occurred) {
3636 retry_fork_ruby(
int *status)
3651 if (handle_fork_error(status,
NULL, &try_gc))
3661 if (status) *status = 0;
3663 pid = retry_fork_ruby(status);
3674 #if defined(HAVE_WORKING_FORK) && !defined(CANNOT_FORK_WITH_PTHREAD) 3725 #define rb_f_fork rb_f_notimplement 3742 #if EXIT_SUCCESS != 0 3874 args[1] = args[0] = argv[0];
3892 #if !defined HAVE_WORKING_FORK && !defined HAVE_SPAWNV 3905 for (i = 1; i <
argc; ++i) {
3906 p[argv[i] - start - 1] =
' ';
3919 #if !defined HAVE_WORKING_FORK || USE_SPAWNV 3922 # if !defined HAVE_SPAWNV 3927 #if defined HAVE_WORKING_FORK && !USE_SPAWNV 3940 # if defined HAVE_SPAWNV 3946 pid = proc_spawn_cmd(argv, prog, eargp);
4050 #if defined(SIGCLD) && !defined(SIGCHLD) 4051 # define SIGCHLD SIGCLD 4055 RETSIGTYPE (*
chfunc)(int);
4058 chfunc = signal(SIGCHLD, SIG_DFL);
4061 #if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) 4065 if (ret == (rb_pid_t)-1)
4066 rb_sys_fail(
"Another thread waited the process started by system().");
4353 VALUE execarg_obj, fail_str;
4368 #if defined(HAVE_WORKING_FORK) || defined(HAVE_SPAWNV) 4406 end = time(0) - beg;
4412 #if (defined(HAVE_GETPGRP) && defined(GETPGRP_VOID)) || defined(HAVE_GETPGID) 4429 #if defined(HAVE_GETPGRP) && defined(GETPGRP_VOID) 4440 #define proc_getpgrp rb_f_notimplement 4444 #if defined(HAVE_SETPGID) || (defined(HAVE_SETPGRP) && defined(SETPGRP_VOID)) 4462 #elif defined(HAVE_SETPGRP) && defined(SETPGRP_VOID) 4468 #define proc_setpgrp rb_f_notimplement 4472 #if defined(HAVE_GETPGID) 4493 #define proc_getpgid rb_f_notimplement 4509 rb_pid_t ipid, ipgrp;
4518 #define proc_setpgid rb_f_notimplement 4549 #define proc_getsid rb_f_notimplement 4553 #if defined(HAVE_SETSID) || (defined(HAVE_SETPGRP) && defined(TIOCNOTTY)) 4554 #if !defined(HAVE_SETSID) 4555 static rb_pid_t ruby_setsid(
void);
4556 #define setsid() ruby_setsid() 4579 #if !defined(HAVE_SETSID) 4580 #define HAVE_SETSID 1 4588 #if defined(SETPGRP_VOID) 4594 ret = setpgrp(0, pid);
4596 if (ret == -1)
return -1;
4607 #define proc_setsid rb_f_notimplement 4611 #ifdef HAVE_GETPRIORITY 4632 int prio, iwhich, iwho;
4638 prio = getpriority(iwhich, iwho);
4643 #define proc_getpriority rb_f_notimplement 4647 #ifdef HAVE_GETPRIORITY 4663 int iwhich, iwho, iprio;
4669 if (setpriority(iwhich, iwho, iprio) < 0)
4674 #define proc_setpriority rb_f_notimplement 4677 #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) 4679 rlimit_resource_name2int(
const char *
name,
long len,
int casetype)
4683 #define RESCHECK(r) \ 4685 if (len == rb_strlen_lit(#r) && STRCASECMP(name, #r) == 0) { \ 4686 resource = RLIMIT_##r; \ 4720 #ifdef RLIMIT_MEMLOCK 4723 #ifdef RLIMIT_MSGQUEUE 4729 #ifdef RLIMIT_NOFILE 4744 #ifdef RLIMIT_RTPRIO 4747 #ifdef RLIMIT_RTTIME 4756 #ifdef RLIMIT_SBSIZE 4759 #ifdef RLIMIT_SIGPENDING 4760 RESCHECK(SIGPENDING);
4769 for (p = name; *p; p++)
4775 for (p = name; *p; p++)
4781 rb_bug(
"unexpected casetype");
4788 rlimit_type_by_hname(
const char *
name,
long len)
4790 return rlimit_resource_name2int(name, len, 0);
4794 rlimit_type_by_lname(
const char *name,
long len)
4796 return rlimit_resource_name2int(name, len, 1);
4806 static const char prefix[] =
"rlimit_";
4807 enum {prefix_len =
sizeof(prefix)-1};
4809 if (len > prefix_len && strncmp(prefix, rname, prefix_len) == 0) {
4810 rtype = rlimit_type_by_lname(rname + prefix_len, len - prefix_len);
4818 rlimit_resource_type(
VALUE rtype)
4825 switch (
TYPE(rtype)) {
4848 r = rlimit_type_by_hname(name, len);
4858 rlimit_resource_value(
VALUE rval)
4863 switch (
TYPE(rval)) {
4881 return NUM2RLIM(rval);
4884 #ifdef RLIM_INFINITY 4885 if (strcmp(name,
"INFINITY") == 0)
return RLIM_INFINITY;
4887 #ifdef RLIM_SAVED_MAX 4888 if (strcmp(name,
"SAVED_MAX") == 0)
return RLIM_SAVED_MAX;
4890 #ifdef RLIM_SAVED_CUR 4891 if (strcmp(name,
"SAVED_CUR") == 0)
return RLIM_SAVED_CUR;
4899 #if defined(HAVE_GETRLIMIT) && defined(RLIM2NUM) 4925 if (getrlimit(rlimit_resource_type(resource), &rlim) < 0) {
4928 return rb_assoc_new(RLIM2NUM(rlim.rlim_cur), RLIM2NUM(rlim.rlim_max));
4931 #define proc_getrlimit rb_f_notimplement 4934 #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) 4989 VALUE resource, rlim_cur, rlim_max;
4995 if (argc < 3 ||
NIL_P(rlim_max = argv[2]))
4996 rlim_max = rlim_cur;
4998 rlim.rlim_cur = rlimit_resource_value(rlim_cur);
4999 rlim.rlim_max = rlimit_resource_value(rlim_max);
5001 if (setrlimit(rlimit_resource_type(resource), &rlim) < 0) {
5007 #define proc_setrlimit rb_f_notimplement 5014 if (under_uid_switch) {
5023 if (under_gid_switch) {
5039 #if defined(HAVE_PWD_H) 5042 # ifdef USE_GETPWNAM_R
5055 struct passwd *pwptr;
5056 #ifdef USE_GETPWNAM_R 5057 struct passwd pwbuf;
5061 getpw_buf_len = GETPW_R_SIZE_INIT;
5062 if (getpw_buf_len < 0) getpw_buf_len = GETPW_R_SIZE_DEFAULT;
5070 while (getpwnam_r(usrname, &pwbuf, getpw_buf, getpw_buf_len, &pwptr)) {
5072 if (e != ERANGE || getpw_buf_len >= GETPW_R_SIZE_LIMIT) {
5081 pwptr = getpwnam(usrname);
5084 #ifndef USE_GETPWNAM_R 5089 uid = pwptr->pw_uid;
5090 #ifndef USE_GETPWNAM_R 5097 # ifdef p_uid_from_name 5117 #if defined(HAVE_GRP_H) 5120 # ifdef USE_GETGRNAM_R
5133 struct group *grptr;
5134 #ifdef USE_GETGRNAM_R 5139 getgr_buf_len = GETGR_R_SIZE_INIT;
5140 if (getgr_buf_len < 0) getgr_buf_len = GETGR_R_SIZE_DEFAULT;
5148 while (getgrnam_r(grpname, &grbuf, getgr_buf, getgr_buf_len, &grptr)) {
5150 if (e != ERANGE || getgr_buf_len >= GETGR_R_SIZE_LIMIT) {
5158 #elif defined(HAVE_GETGRNAM) 5159 grptr = getgrnam(grpname);
5164 #if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) 5169 gid = grptr->gr_gid;
5170 #if !defined(USE_GETGRNAM_R) && defined(HAVE_ENDGRENT) 5177 # ifdef p_gid_from_name 5197 #if defined HAVE_SETUID 5215 #define p_sys_setuid rb_f_notimplement 5219 #if defined HAVE_SETRUID 5237 #define p_sys_setruid rb_f_notimplement 5241 #if defined HAVE_SETEUID 5259 #define p_sys_seteuid rb_f_notimplement 5263 #if defined HAVE_SETREUID 5278 rb_uid_t ruid, euid;
5288 #define p_sys_setreuid rb_f_notimplement 5292 #if defined HAVE_SETRESUID 5307 rb_uid_t ruid, euid, suid;
5314 if (setresuid(ruid, euid, suid) != 0)
rb_sys_fail(0);
5318 #define p_sys_setresuid rb_f_notimplement 5341 #if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETRUID) || defined(HAVE_SETUID) 5358 #if defined(HAVE_SETRESUID) 5360 #elif defined HAVE_SETREUID 5362 #elif defined HAVE_SETRUID 5364 #elif defined HAVE_SETUID 5377 #define proc_setuid rb_f_notimplement 5393 #ifdef BROKEN_SETREUID 5395 setreuid(rb_uid_t ruid, rb_uid_t euid)
5397 if (ruid != (rb_uid_t)-1 && ruid !=
getuid()) {
5398 if (euid == (rb_uid_t)-1) euid =
geteuid();
5399 if (
setuid(ruid) < 0)
return -1;
5401 if (euid != (rb_uid_t)-1 && euid !=
geteuid()) {
5402 if (
seteuid(euid) < 0)
return -1;
5431 #if defined(HAVE_SETRESUID) 5433 SAVED_USER_ID = uid;
5434 #elif defined(HAVE_SETUID) 5436 SAVED_USER_ID = uid;
5437 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) 5439 if (SAVED_USER_ID == uid) {
5444 if (setreuid(-1, SAVED_USER_ID) < 0)
rb_sys_fail(0);
5445 if (setreuid(SAVED_USER_ID, 0) < 0)
rb_sys_fail(0);
5448 SAVED_USER_ID = uid;
5454 SAVED_USER_ID = uid;
5460 SAVED_USER_ID = uid;
5462 #elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID) 5464 if (SAVED_USER_ID == uid) {
5478 SAVED_USER_ID = uid;
5485 SAVED_USER_ID = uid;
5493 #if defined(HAVE_SETRESUID) 5494 if (setresuid((
getuid() == uid)? (rb_uid_t)-1: uid,
5495 (
geteuid() == uid)? (rb_uid_t)-1: uid,
5496 (SAVED_USER_ID == uid)? (rb_uid_t)-1: uid) < 0)
rb_sys_fail(0);
5497 SAVED_USER_ID = uid;
5498 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) 5499 if (SAVED_USER_ID == uid) {
5500 if (setreuid((
getuid() == uid)? (rb_uid_t)-1: uid,
5501 (
geteuid() == uid)? (rb_uid_t)-1: uid) < 0)
5504 else if (
getuid() != uid) {
5505 if (setreuid(uid, (
geteuid() == uid)? (rb_uid_t)-1: uid) < 0)
5507 SAVED_USER_ID = uid;
5511 SAVED_USER_ID = uid;
5515 if (setreuid(-1, SAVED_USER_ID) < 0)
rb_sys_fail(0);
5516 if (setreuid(SAVED_USER_ID, uid) < 0)
rb_sys_fail(0);
5517 SAVED_USER_ID = uid;
5520 #elif defined(HAVE_SETRUID) && defined(HAVE_SETEUID) 5521 if (SAVED_USER_ID == uid) {
5528 SAVED_USER_ID = uid;
5532 SAVED_USER_ID = uid;
5536 else if (
getuid() == uid) {
5539 SAVED_USER_ID = uid;
5545 #elif defined HAVE_44BSD_SETUID 5549 SAVED_USER_ID = uid;
5554 #elif defined HAVE_SETEUID 5555 if (
getuid() == uid && SAVED_USER_ID == uid) {
5561 #elif defined HAVE_SETUID 5562 if (
getuid() == uid && SAVED_USER_ID == uid) {
5577 #if defined HAVE_SETGID 5595 #define p_sys_setgid rb_f_notimplement 5599 #if defined HAVE_SETRGID 5617 #define p_sys_setrgid rb_f_notimplement 5621 #if defined HAVE_SETEGID 5639 #define p_sys_setegid rb_f_notimplement 5643 #if defined HAVE_SETREGID 5658 rb_gid_t rgid, egid;
5668 #define p_sys_setregid rb_f_notimplement 5671 #if defined HAVE_SETRESGID 5686 rb_gid_t rgid, egid, sgid;
5693 if (setresgid(rgid, egid, sgid) != 0)
rb_sys_fail(0);
5697 #define p_sys_setresgid rb_f_notimplement 5701 #if defined HAVE_ISSETUGID 5725 #define p_sys_issetugid rb_f_notimplement 5748 #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETRGID) || defined(HAVE_SETGID) 5764 #if defined(HAVE_SETRESGID) 5766 #elif defined HAVE_SETREGID 5768 #elif defined HAVE_SETRGID 5770 #elif defined HAVE_SETGID 5783 #define proc_setgid rb_f_notimplement 5787 #if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX) 5808 static int _maxgroups = -1;
5810 get_sc_ngroups_max(
void)
5812 #ifdef _SC_NGROUPS_MAX 5813 return (
int)sysconf(_SC_NGROUPS_MAX);
5814 #elif defined(NGROUPS_MAX) 5815 return (
int)NGROUPS_MAX;
5823 if (_maxgroups < 0) {
5824 _maxgroups = get_sc_ngroups_max();
5835 #ifdef HAVE_GETGROUPS 5854 ngroups = getgroups(0,
NULL);
5858 groups =
ALLOCV_N(rb_gid_t, tmp, ngroups);
5860 ngroups = getgroups(ngroups, groups);
5865 for (i = 0; i < ngroups; i++)
5873 #define proc_getgroups rb_f_notimplement 5877 #ifdef HAVE_SETGROUPS 5902 if (ngroups > maxgroups())
5905 groups =
ALLOCV_N(rb_gid_t, tmp, ngroups);
5907 for (i = 0; i < ngroups; i++) {
5914 if (setgroups(ngroups, groups) == -1)
5922 #define proc_setgroups rb_f_notimplement 5926 #ifdef HAVE_INITGROUPS 5953 #define proc_initgroups rb_f_notimplement 5956 #if defined(_SC_NGROUPS_MAX) || defined(NGROUPS_MAX) 5973 #define proc_getmaxgroups rb_f_notimplement 5976 #ifdef HAVE_SETGROUPS 5989 int ngroups_max = get_sc_ngroups_max();
5997 if (ngroups_max > 0 && ngroups > ngroups_max)
5998 ngroups = ngroups_max;
6000 _maxgroups = ngroups;
6005 #define proc_setmaxgroups rb_f_notimplement 6008 #if defined(HAVE_DAEMON) || (defined(HAVE_WORKING_FORK) && defined(HAVE_SETSID)) 6009 static int rb_daemon(
int nochdir,
int noclose);
6031 case 2: noclose =
RTEST(argv[1]);
6032 case 1: nochdir =
RTEST(argv[0]);
6036 n = rb_daemon(nochdir, noclose);
6042 rb_daemon(
int nochdir,
int noclose)
6047 err = daemon(nochdir, noclose);
6053 #define fork_daemon() \ 6054 switch (rb_fork_ruby(NULL)) { \ 6055 case -1: return -1; \ 6056 case 0: rb_thread_atfork(); break; \ 6057 default: _exit(EXIT_SUCCESS); \ 6062 if (setsid() < 0)
return -1;
6070 if (!noclose && (n =
rb_cloexec_open(
"/dev/null", O_RDWR, 0)) != -1) {
6082 #define proc_daemon rb_f_notimplement 6097 #ifdef BROKEN_SETREGID 6099 setregid(rb_gid_t rgid, rb_gid_t egid)
6101 if (rgid != (rb_gid_t)-1 && rgid !=
getgid()) {
6102 if (egid == (rb_gid_t)-1) egid =
getegid();
6103 if (
setgid(rgid) < 0)
return -1;
6105 if (egid != (rb_gid_t)-1 && egid !=
getegid()) {
6106 if (
setegid(egid) < 0)
return -1;
6135 #if defined(HAVE_SETRESGID) 6137 SAVED_GROUP_ID = gid;
6138 #elif defined HAVE_SETGID 6140 SAVED_GROUP_ID = gid;
6141 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) 6143 if (SAVED_GROUP_ID == gid) {
6148 if (setregid(-1, SAVED_GROUP_ID) < 0)
rb_sys_fail(0);
6149 if (setregid(SAVED_GROUP_ID, 0) < 0)
rb_sys_fail(0);
6152 SAVED_GROUP_ID = gid;
6158 SAVED_GROUP_ID = gid;
6164 SAVED_GROUP_ID = gid;
6166 #elif defined(HAVE_SETRGID) && defined (HAVE_SETEGID) 6168 if (SAVED_GROUP_ID == gid) {
6183 SAVED_GROUP_ID = gid;
6190 SAVED_GROUP_ID = gid;
6197 #if defined(HAVE_SETRESGID) 6198 if (setresgid((
getgid() == gid)? (rb_gid_t)-1: gid,
6199 (
getegid() == gid)? (rb_gid_t)-1: gid,
6200 (SAVED_GROUP_ID == gid)? (rb_gid_t)-1: gid) < 0)
rb_sys_fail(0);
6201 SAVED_GROUP_ID = gid;
6202 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) 6203 if (SAVED_GROUP_ID == gid) {
6204 if (setregid((
getgid() == gid)? (rb_uid_t)-1: gid,
6205 (
getegid() == gid)? (rb_uid_t)-1: gid) < 0)
6208 else if (
getgid() != gid) {
6209 if (setregid(gid, (
getegid() == gid)? (rb_uid_t)-1: gid) < 0)
6211 SAVED_GROUP_ID = gid;
6215 SAVED_GROUP_ID = gid;
6219 if (setregid(-1, SAVED_GROUP_ID) < 0)
rb_sys_fail(0);
6220 if (setregid(SAVED_GROUP_ID, gid) < 0)
rb_sys_fail(0);
6221 SAVED_GROUP_ID = gid;
6224 #elif defined(HAVE_SETRGID) && defined(HAVE_SETEGID) 6225 if (SAVED_GROUP_ID == gid) {
6232 SAVED_GROUP_ID = gid;
6236 SAVED_GROUP_ID = gid;
6240 else if (
getgid() == gid) {
6243 SAVED_GROUP_ID = gid;
6249 #elif defined HAVE_44BSD_SETGID 6253 SAVED_GROUP_ID = gid;
6258 #elif defined HAVE_SETEGID 6259 if (
getgid() == gid && SAVED_GROUP_ID == gid) {
6265 #elif defined HAVE_SETGID 6266 if (
getgid() == gid && SAVED_GROUP_ID == gid) {
6299 #if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) || defined(_POSIX_SAVED_IDS) 6301 proc_seteuid(rb_uid_t uid)
6303 #if defined(HAVE_SETRESUID) 6305 #elif defined HAVE_SETREUID 6307 #elif defined HAVE_SETEUID 6309 #elif defined HAVE_SETUID 6322 #if defined(HAVE_SETRESUID) || defined(HAVE_SETREUID) || defined(HAVE_SETEUID) || defined(HAVE_SETUID) 6339 #define proc_seteuid_m rb_f_notimplement 6345 #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) 6351 #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) 6355 #if defined(HAVE_SETRESUID) 6358 SAVED_USER_ID = euid;
6363 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) 6368 SAVED_USER_ID = euid;
6370 #elif defined HAVE_SETEUID 6372 #elif defined HAVE_SETUID 6424 #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) || defined(_POSIX_SAVED_IDS) 6436 #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) 6442 #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) 6446 #if defined(HAVE_SETRESGID) 6448 #elif defined HAVE_SETREGID 6450 #elif defined HAVE_SETEGID 6452 #elif defined HAVE_SETGID 6466 #if defined(HAVE_SETRESGID) || defined(HAVE_SETREGID) || defined(HAVE_SETEGID) || defined(HAVE_SETGID) 6467 #define proc_setegid_m proc_setegid 6469 #define proc_setegid_m rb_f_notimplement 6475 #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) 6481 #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) 6485 #if defined(HAVE_SETRESGID) 6488 SAVED_GROUP_ID = egid;
6493 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) 6498 SAVED_GROUP_ID = egid;
6500 #elif defined HAVE_SETEGID 6502 #elif defined HAVE_SETGID 6546 #if defined(HAVE_SETRESUID) 6548 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) 6572 #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) 6579 #if defined(HAVE_SETRESUID) || (defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID)) 6583 #if defined(HAVE_SETRESUID) 6584 if (setresuid(euid, uid, uid) < 0)
rb_sys_fail(0);
6585 SAVED_USER_ID = uid;
6586 #elif defined(HAVE_SETREUID) && !defined(OBSOLETE_SETREUID) 6588 SAVED_USER_ID = uid;
6608 #if defined(HAVE_SETRESGID) 6610 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) 6634 #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) 6641 #if defined(HAVE_SETRESGID) || (defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID)) 6645 #if defined(HAVE_SETRESGID) 6646 if (setresgid(egid, gid, gid) < 0)
rb_sys_fail(0);
6647 SAVED_GROUP_ID = gid;
6648 #elif defined(HAVE_SETREGID) && !defined(OBSOLETE_SETREGID) 6650 SAVED_GROUP_ID = gid;
6671 #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) 6679 #if defined(HAVE_SETRESUID) || defined(HAVE_SETEUID) || defined(_POSIX_SAVED_IDS) 6683 under_uid_switch = 0;
6715 under_uid_switch = 1;
6722 else if (euid != SAVED_USER_ID) {
6723 proc_seteuid(SAVED_USER_ID);
6725 under_uid_switch = 1;
6742 under_uid_switch = 0;
6761 under_uid_switch = 1;
6785 #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) 6792 #if defined(HAVE_SETRESGID) || defined(HAVE_SETEGID) || defined(_POSIX_SAVED_IDS) 6796 under_gid_switch = 0;
6828 under_gid_switch = 1;
6835 else if (egid != SAVED_GROUP_ID) {
6836 proc_setegid(obj,
GIDT2NUM(SAVED_GROUP_ID));
6838 under_gid_switch = 1;
6855 under_gid_switch = 0;
6874 under_gid_switch = 1;
6884 #if defined(HAVE_TIMES) 6889 #ifdef HAVE__SC_CLK_TCK 6890 (double)sysconf(_SC_CLK_TCK);
6919 const double hertz = get_clk_tck();
6928 ret =
rb_struct_new(rb_cProcessTms, utime, stime, cutime, cstime);
6936 #define rb_proc_times rb_f_notimplement 6939 #ifdef HAVE_LONG_LONG 6941 #define TIMETICK_INT_MIN LLONG_MIN 6942 #define TIMETICK_INT_MAX LLONG_MAX 6943 #define TIMETICK_INT2NUM(v) LL2NUM(v) 6946 #define TIMETICK_INT_MIN LONG_MIN 6947 #define TIMETICK_INT_MAX LONG_MAX 6948 #define TIMETICK_INT2NUM(v) LONG2NUM(v) 6952 static timetick_int_t
6984 timetick_int_t *denominators,
int num_denominators)
6987 for (i = 0; i < num_numerators; i++) {
6988 if (numerators[i] == 1)
6990 for (j = 0; j < num_denominators; j++) {
6991 if (denominators[j] == 1)
7005 timetick_int_t *numerators,
int num_numerators,
7006 timetick_int_t *denominators,
int num_denominators)
7012 denominators, num_denominators);
7016 for (i = 0; i < num_numerators; i++)
7018 for (i = 0; i < num_denominators; i++)
7019 d /= denominators[i];
7026 timetick_int_t *numerators,
int num_numerators,
7027 timetick_int_t *denominators,
int num_denominators)
7033 denominators, num_denominators);
7036 for (i = 0; i < num_denominators; i++)
7037 d *= denominators[i];
7038 for (i = 0; i < num_numerators; i++)
7045 #define NDIV(x,y) (-(-((x)+1)/(y))-1) 7046 #define DIV(n,d) ((n)<0 ? NDIV((n),(d)) : (n)/(d)) 7050 timetick_int_t *numerators,
int num_numerators,
7051 timetick_int_t *denominators,
int num_denominators)
7057 denominators, num_denominators);
7062 for (i = 0; i < num_numerators; i++) {
7063 timetick_int_t factor = numerators[i];
7069 for (i = 0; i < num_denominators; i++) {
7070 t =
DIV(t, denominators[i]);
7079 for (i = 0; i < num_numerators; i++) {
7080 timetick_int_t factor = numerators[i];
7085 for (i = 0; i < num_denominators; i++) {
7093 timetick_int_t *numerators,
int num_numerators,
7094 timetick_int_t *denominators,
int num_denominators,
7098 numerators[num_numerators++] = 1000000000;
7099 return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
7102 numerators[num_numerators++] = 1000000;
7103 return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
7106 numerators[num_numerators++] = 1000;
7107 return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
7110 return timetick2integer(ttp, numerators, num_numerators, denominators, num_denominators);
7113 numerators[num_numerators++] = 1000000;
7114 return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators);
7117 numerators[num_numerators++] = 1000;
7118 return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators);
7121 return timetick2dblnum(ttp, numerators, num_numerators, denominators, num_denominators);
7128 static mach_timebase_info_data_t *
7129 get_mach_timebase_info(
void)
7131 static mach_timebase_info_data_t sTimebaseInfo;
7133 if ( sTimebaseInfo.denom == 0 ) {
7134 (void) mach_timebase_info(&sTimebaseInfo);
7137 return &sTimebaseInfo;
7273 timetick_int_t numerators[2];
7274 timetick_int_t denominators[2];
7275 int num_numerators = 0;
7276 int num_denominators = 0;
7279 VALUE clk_id = argv[0];
7289 #define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME ID2SYM(id_GETTIMEOFDAY_BASED_CLOCK_REALTIME) 7297 denominators[num_denominators++] = 1000000000;
7301 #define RUBY_TIME_BASED_CLOCK_REALTIME ID2SYM(id_TIME_BASED_CLOCK_REALTIME) 7305 if (t == (time_t)-1)
7309 denominators[num_denominators++] = 1000000000;
7314 #define RUBY_TIMES_BASED_CLOCK_MONOTONIC \ 7315 ID2SYM(id_TIMES_BASED_CLOCK_MONOTONIC) 7316 if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
7321 if (c == (clock_t)-1)
7324 tt.
count = (int32_t)(uc % 1000000000);
7326 denominators[num_denominators++] = get_clk_tck();
7332 #define RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID \ 7333 ID2SYM(id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) 7334 if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
7335 struct rusage
usage;
7340 tt.
giga_count = usage.ru_utime.tv_sec + usage.ru_stime.tv_sec;
7341 usec = (int32_t)(usage.ru_utime.tv_usec + usage.ru_stime.tv_usec);
7342 if (1000000 <= usec) {
7346 tt.
count = usec * 1000;
7347 denominators[num_denominators++] = 1000000000;
7353 #define RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID \ 7354 ID2SYM(id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) 7355 if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
7358 if (times(&buf) == (clock_t)-1)
7362 tt.
count = (int32_t)((utime % 1000000000) + (stime % 1000000000));
7363 tt.
giga_count = (utime / 1000000000) + (stime / 1000000000);
7364 if (1000000000 <= tt.
count) {
7365 tt.
count -= 1000000000;
7368 denominators[num_denominators++] = get_clk_tck();
7373 #define RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID \ 7374 ID2SYM(id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID) 7380 if (c == (clock_t)-1)
7383 tt.
count = (int32_t)(uc % 1000000000);
7385 denominators[num_denominators++] = CLOCKS_PER_SEC;
7390 #define RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC ID2SYM(id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) 7391 if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
7392 mach_timebase_info_data_t *info = get_mach_timebase_info();
7394 tt.
count = (int32_t)(t % 1000000000);
7396 numerators[num_numerators++] = info->numer;
7397 denominators[num_denominators++] = info->denom;
7398 denominators[num_denominators++] = 1000000000;
7404 #if defined(HAVE_CLOCK_GETTIME) 7407 c = NUM2CLOCKID(clk_id);
7413 denominators[num_denominators++] = 1000000000;
7421 return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
7466 timetick_int_t numerators[2];
7467 timetick_int_t denominators[2];
7468 int num_numerators = 0;
7469 int num_denominators = 0;
7472 VALUE clk_id = argv[0];
7475 #ifdef RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME 7479 denominators[num_denominators++] = 1000000000;
7484 #ifdef RUBY_TIME_BASED_CLOCK_REALTIME 7488 denominators[num_denominators++] = 1000000000;
7493 #ifdef RUBY_TIMES_BASED_CLOCK_MONOTONIC 7494 if (clk_id == RUBY_TIMES_BASED_CLOCK_MONOTONIC) {
7497 denominators[num_denominators++] = get_clk_tck();
7502 #ifdef RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID 7503 if (clk_id == RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) {
7506 denominators[num_denominators++] = 1000000000;
7511 #ifdef RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID 7512 if (clk_id == RUBY_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID) {
7515 denominators[num_denominators++] = get_clk_tck();
7520 #ifdef RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID 7524 denominators[num_denominators++] = CLOCKS_PER_SEC;
7529 #ifdef RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC 7530 if (clk_id == RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) {
7531 mach_timebase_info_data_t *info = get_mach_timebase_info();
7534 numerators[num_numerators++] = info->numer;
7535 denominators[num_denominators++] = info->denom;
7536 denominators[num_denominators++] = 1000000000;
7542 #if defined(HAVE_CLOCK_GETRES) 7550 denominators[num_denominators++] = 1000000000;
7562 return make_clock_result(&tt, numerators, num_numerators, denominators, num_denominators, unit);
7581 #define rb_intern(str) rb_intern_const(str) 7665 #ifdef HAVE_GETPRIORITY 7676 #if defined(RLIM2NUM) && defined(RLIM_INFINITY) 7678 VALUE inf = RLIM2NUM(RLIM_INFINITY);
7679 #ifdef RLIM_SAVED_MAX 7681 VALUE v = RLIM_INFINITY == RLIM_SAVED_MAX ?
inf : RLIM2NUM(RLIM_SAVED_MAX);
7688 #ifdef RLIM_SAVED_CUR 7690 VALUE v = RLIM_INFINITY == RLIM_SAVED_CUR ?
inf : RLIM2NUM(RLIM_SAVED_CUR);
7731 #ifdef RLIMIT_MEMLOCK 7738 #ifdef RLIMIT_MSGQUEUE 7753 #ifdef RLIMIT_NOFILE 7776 #ifdef RLIMIT_RTPRIO 7783 #ifdef RLIMIT_RTTIME 7791 #ifdef RLIMIT_SBSIZE 7796 #ifdef RLIMIT_SIGPENDING 7831 #ifdef CLOCK_REALTIME 7833 #elif defined(RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME) 7836 #ifdef CLOCK_MONOTONIC 7838 #elif defined(RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC) 7839 rb_define_const(rb_mProcess,
"CLOCK_MONOTONIC", RUBY_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC);
7841 #ifdef CLOCK_PROCESS_CPUTIME_ID 7842 rb_define_const(rb_mProcess,
"CLOCK_PROCESS_CPUTIME_ID", CLOCKID2NUM(CLOCK_PROCESS_CPUTIME_ID));
7843 #elif defined(RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID) 7844 rb_define_const(rb_mProcess,
"CLOCK_PROCESS_CPUTIME_ID", RUBY_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID);
7846 #ifdef CLOCK_THREAD_CPUTIME_ID 7847 rb_define_const(rb_mProcess,
"CLOCK_THREAD_CPUTIME_ID", CLOCKID2NUM(CLOCK_THREAD_CPUTIME_ID));
7849 #ifdef CLOCK_VIRTUAL 7850 rb_define_const(rb_mProcess,
"CLOCK_VIRTUAL", CLOCKID2NUM(CLOCK_VIRTUAL));
7855 #ifdef CLOCK_REALTIME_FAST 7856 rb_define_const(rb_mProcess,
"CLOCK_REALTIME_FAST", CLOCKID2NUM(CLOCK_REALTIME_FAST));
7858 #ifdef CLOCK_REALTIME_PRECISE 7859 rb_define_const(rb_mProcess,
"CLOCK_REALTIME_PRECISE", CLOCKID2NUM(CLOCK_REALTIME_PRECISE));
7861 #ifdef CLOCK_REALTIME_COARSE 7862 rb_define_const(rb_mProcess,
"CLOCK_REALTIME_COARSE", CLOCKID2NUM(CLOCK_REALTIME_COARSE));
7864 #ifdef CLOCK_REALTIME_ALARM 7865 rb_define_const(rb_mProcess,
"CLOCK_REALTIME_ALARM", CLOCKID2NUM(CLOCK_REALTIME_ALARM));
7867 #ifdef CLOCK_MONOTONIC_FAST 7868 rb_define_const(rb_mProcess,
"CLOCK_MONOTONIC_FAST", CLOCKID2NUM(CLOCK_MONOTONIC_FAST));
7870 #ifdef CLOCK_MONOTONIC_PRECISE 7871 rb_define_const(rb_mProcess,
"CLOCK_MONOTONIC_PRECISE", CLOCKID2NUM(CLOCK_MONOTONIC_PRECISE));
7873 #ifdef CLOCK_MONOTONIC_RAW 7874 rb_define_const(rb_mProcess,
"CLOCK_MONOTONIC_RAW", CLOCKID2NUM(CLOCK_MONOTONIC_RAW));
7876 #ifdef CLOCK_MONOTONIC_RAW_APPROX 7877 rb_define_const(rb_mProcess,
"CLOCK_MONOTONIC_RAW_APPROX", CLOCKID2NUM(CLOCK_MONOTONIC_RAW_APPROX));
7879 #ifdef CLOCK_MONOTONIC_COARSE 7880 rb_define_const(rb_mProcess,
"CLOCK_MONOTONIC_COARSE", CLOCKID2NUM(CLOCK_MONOTONIC_COARSE));
7882 #ifdef CLOCK_BOOTTIME 7883 rb_define_const(rb_mProcess,
"CLOCK_BOOTTIME", CLOCKID2NUM(CLOCK_BOOTTIME));
7885 #ifdef CLOCK_BOOTTIME_ALARM 7886 rb_define_const(rb_mProcess,
"CLOCK_BOOTTIME_ALARM", CLOCKID2NUM(CLOCK_BOOTTIME_ALARM));
7889 rb_define_const(rb_mProcess,
"CLOCK_UPTIME", CLOCKID2NUM(CLOCK_UPTIME));
7891 #ifdef CLOCK_UPTIME_FAST 7892 rb_define_const(rb_mProcess,
"CLOCK_UPTIME_FAST", CLOCKID2NUM(CLOCK_UPTIME_FAST));
7894 #ifdef CLOCK_UPTIME_PRECISE 7895 rb_define_const(rb_mProcess,
"CLOCK_UPTIME_PRECISE", CLOCKID2NUM(CLOCK_UPTIME_PRECISE));
7897 #ifdef CLOCK_UPTIME_RAW 7898 rb_define_const(rb_mProcess,
"CLOCK_UPTIME_RAW", CLOCKID2NUM(CLOCK_UPTIME_RAW));
7900 #ifdef CLOCK_UPTIME_RAW_APPROX 7901 rb_define_const(rb_mProcess,
"CLOCK_UPTIME_RAW_APPROX", CLOCKID2NUM(CLOCK_UPTIME_RAW_APPROX));
7904 rb_define_const(rb_mProcess,
"CLOCK_SECOND", CLOCKID2NUM(CLOCK_SECOND));
7909 #if defined(HAVE_TIMES) || defined(_WIN32) 7938 #ifdef p_uid_from_name 7941 #ifdef p_gid_from_name 7984 id_new_pgroup =
rb_intern(
"new_pgroup");
8001 id_TIMES_BASED_CLOCK_MONOTONIC =
rb_intern(
"TIMES_BASED_CLOCK_MONOTONIC");
8002 id_TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID =
rb_intern(
"TIMES_BASED_CLOCK_PROCESS_CPUTIME_ID");
8005 id_GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID =
rb_intern(
"GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID");
8009 id_MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC =
rb_intern(
"MACH_ABSOLUTE_TIME_BASED_CLOCK_MONOTONIC");
static VALUE timetick2dblnum(struct timetick *ttp, timetick_int_t *numerators, int num_numerators, timetick_int_t *denominators, int num_denominators)
static ID id_TIME_BASED_CLOCK_REALTIME
static VALUE p_uid_have_saved_id(void)
static int run_exec_close(VALUE ary, char *errmsg, size_t errmsg_buflen)
#define RBASIC_CLEAR_CLASS(obj)
struct timeval rb_time_interval(VALUE num)
void rb_syswait(rb_pid_t pid)
static VALUE rb_cProcessStatus
ID rb_check_id(volatile VALUE *)
Returns ID for the given name if it is interned already, or 0.
#define RUBY_VM_CHECK_INTS(th)
#define redirect_close(fd)
static void before_exec_async_signal_safe(void)
RUBY_EXTERN VALUE rb_cData
static VALUE proc_getgid(VALUE obj)
void rb_thread_atfork(void)
static void check_exec_redirect(VALUE key, VALUE val, struct rb_execarg *eargp)
int rb_cloexec_fcntl_dupfd(int fd, int minfd)
static VALUE rb_check_argv(int argc, VALUE *argv)
VALUE rb_ary_entry(VALUE ary, long offset)
void rb_bug(const char *fmt,...)
int gettimeofday(struct timeval *, struct timezone *)
#define RUBY_TYPED_FREE_IMMEDIATELY
static VALUE check_exec_fds(struct rb_execarg *eargp)
static void rb_check_exec_options(VALUE opthash, VALUE execarg_obj)
static timetick_int_t gcd_timetick_int(timetick_int_t a, timetick_int_t b)
size_t strlen(const char *)
unsigned int unsigned_clock_t
void rb_update_max_fd(int fd)
struct rb_execarg * rb_execarg_get(VALUE execarg_obj)
void rb_syserr_fail(int e, const char *mesg)
void rb_define_virtual_variable(const char *, VALUE(*)(ANYARGS), void(*)(ANYARGS))
static VALUE hide_obj(VALUE obj)
static VALUE p_uid_exchange(VALUE obj)
#define RB_OBJ_WRITTEN(a, oldv, b)
static void after_exec(void)
static unsigned int hash(str, len) register const char *str
CONSTFUNC(static timetick_int_t gcd_timetick_int(timetick_int_t, timetick_int_t))
void rb_undef_alloc_func(VALUE)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static VALUE rb_f_system(int argc, VALUE *argv)
#define RUBY_TIME_BASED_CLOCK_REALTIME
int rb_io_modestr_oflags(const char *modestr)
static int under_gid_switch
static VALUE pst_bitand(VALUE st1, VALUE st2)
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
static VALUE p_uid_exchangeable(void)
VALUE rb_f_exit(int argc, const VALUE *argv)
static VALUE pst_to_s(VALUE st)
int rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
void rb_execarg_setenv(VALUE execarg_obj, VALUE env)
static VALUE detach_process_pid(VALUE thread)
static long run_exec_dup2_tmpbuf_size(long n)
int rb_env_path_tainted(void)
#define TypedData_Get_Struct(obj, type, data_type, sval)
#define before_fork_ruby()
void * rb_thread_call_without_gvl2(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2)
unsigned unsetenv_others_given
static ID id_float_millisecond
static int check_exec_env_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
static int check_exec_fds_1(struct rb_execarg *eargp, VALUE h, int maxhint, VALUE ary)
static rb_gid_t SAVED_GROUP_ID
static rb_pid_t do_waitpid(rb_pid_t pid, int *st, int flags)
static VALUE p_uid_sw_ensure(VALUE obj)
static VALUE proc_waitall(void)
static int run_exec_dup2_child(VALUE ary, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
VALUE rb_struct_new(VALUE,...)
int rb_proc_exec(const char *str)
VALUE rb_ary_push(VALUE ary, VALUE item)
void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds)
#define RB_SPECIAL_CONST_P(x)
static VALUE p_gid_have_saved_id(void)
#define redirect_cloexec_dup2(oldfd, newfd)
static VALUE p_gid_exchangeable(void)
struct st_table * rb_hash_tbl_raw(VALUE hash)
rb_pid_t rb_fork_ruby(int *status)
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
void rb_async_bug_errno(const char *mesg, int errno_arg)
rb_pid_t rb_w32_uaspawn_flags(int, const char *, char *const *, DWORD)
void rb_str_set_len(VALUE, long)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
#define RBASIC_SET_CLASS(obj, cls)
static VALUE check_hash(VALUE obj)
VALUE rb_define_class_under(VALUE outer, const char *name, VALUE super)
Defines a class under the namespace of outer.
void rb_raise(VALUE exc, const char *fmt,...)
struct spawn_args::@151 errmsg
static int run_exec_dup2(VALUE ary, VALUE tmpbuf, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
VALUE rb_ivar_get(VALUE, ID)
rb_pid_t rb_waitpid(rb_pid_t pid, int *st, int flags)
static void check_gid_switch(void)
VALUE rb_convert_type(VALUE, int, const char *, const char *)
static VALUE p_gid_change_privilege(VALUE obj, VALUE id)
static VALUE check_exec_redirect_fd(VALUE v, int iskey)
#define after_fork_ruby()
#define RUBY_GETTIMEOFDAY_BASED_CLOCK_REALTIME
VALUE rb_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE)
void rb_gc_mark(VALUE ptr)
VALUE rb_hash_lookup(VALUE hash, VALUE key)
static VALUE pst_equal(VALUE st1, VALUE st2)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
static void rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VALUE execarg_obj)
static VALUE pst_success_p(VALUE st)
static VALUE proc_wait(int argc, VALUE *argv)
static void * rb_waitpid_blocking(void *data)
static const rb_data_type_t exec_arg_data_type
#define RUBY_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID
VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell)
VALUE rb_str_tmp_new(long)
static VALUE pst_wtermsig(VALUE st)
void rb_undef_method(VALUE klass, const char *name)
#define GetOpenFile(obj, fp)
static void reduce_fraction(timetick_int_t *np, timetick_int_t *dp)
VALUE rb_struct_define_under(VALUE, const char *,...)
void rb_thread_start_timer_thread(void)
static VALUE pst_wstopsig(VALUE st)
static ID id_CLOCK_BASED_CLOCK_PROCESS_CPUTIME_ID
VALUE rb_thread_local_aref(VALUE, ID)
VALUE rb_f_kill(int, const VALUE *)
VALUE rb_str_buf_cat(VALUE, const char *, long)
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
static void reduce_factors(timetick_int_t *numerators, int num_numerators, timetick_int_t *denominators, int num_denominators)
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
static VALUE pst_wifsignaled(VALUE st)
void rb_exc_raise(VALUE mesg)
unsigned unsetenv_others_do
static rb_pid_t rb_spawn_process(struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
VALUE rb_singleton_class(VALUE obj)
Returns the singleton class of obj.
#define preserving_errno(stmts)
#define RB_TYPE_P(obj, type)
VALUE rb_last_status_get(void)
#define MEMZERO(p, type, n)
static void before_exec_non_async_signal_safe(void)
static VALUE proc_wait2(int argc, VALUE *argv)
unsigned long long uint64_t
static rb_gid_t rb_setegid_core(rb_gid_t egid)
void rb_thread_sleep(int)
static void mark_exec_arg(void *ptr)
static int fd_get_cloexec(int fd, char *errmsg, size_t errmsg_buflen)
static rb_pid_t rb_execarg_spawn(VALUE execarg_obj, char *errmsg, size_t errmsg_buflen)
static VALUE rb_f_exit_bang(int argc, VALUE *argv, VALUE obj)
void rb_execarg_parent_start(VALUE execarg_obj)
int rb_block_given_p(void)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
VALUE rb_str_encode_ospath(VALUE path)
VALUE rb_f_exec(int argc, const VALUE *argv)
RUBY_EXTERN VALUE rb_cObject
static VALUE rb_f_spawn(int argc, VALUE *argv)
static rb_uid_t SAVED_USER_ID
#define proc_getmaxgroups
static VALUE proc_detach(VALUE obj, VALUE pid)
const char * ruby_signal_name(int)
VALUE rb_io_check_io(VALUE io)
static void * open_func(void *ptr)
static ID id_float_microsecond
VALUE rb_str_cat2(VALUE, const char *)
VALUE rb_str_buf_cat2(VALUE, const char *)
static void after_exec_async_signal_safe(void)
static VALUE pst_wifexited(VALUE st)
static void after_exec_non_async_signal_safe(void)
#define TIMETICK_INT2NUM(v)
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)
void rb_define_const(VALUE, const char *, VALUE)
void rb_ary_store(VALUE ary, long idx, VALUE val)
static VALUE pst_rshift(VALUE st1, VALUE st2)
void rb_sys_fail_str(VALUE mesg)
static ID id_close_others
static rb_pid_t rb_spawn_internal(int argc, const VALUE *argv, char *errmsg, size_t errmsg_buflen)
union rb_execarg::@139 invoke
void rb_thread_stop_timer_thread(void)
#define ALLOCV_N(type, v, n)
mode_t umask(mode_t mask)
int rb_cloexec_dup2(int oldfd, int newfd)
static VALUE execarg_parent_end(VALUE execarg_obj)
#define MEMCPY(p1, p2, type, n)
void ruby_stop(int ex)
Calls ruby_cleanup() and exits the process.
VALUE rb_obj_alloc(VALUE)
void InitVM_process(void)
static VALUE timetick2dblnum_reciprocal(struct timetick *ttp, timetick_int_t *numerators, int num_numerators, timetick_int_t *denominators, int num_denominators)
static size_t memsize_exec_arg(const void *ptr)
static VALUE make_clock_result(struct timetick *ttp, timetick_int_t *numerators, int num_numerators, timetick_int_t *denominators, int num_denominators, VALUE unit)
static int save_redirect_fd(int fd, struct rb_execarg *sargp, char *errmsg, size_t errmsg_buflen)
static VALUE save_env_i(RB_BLOCK_CALL_FUNC_ARGLIST(i, ary))
static VALUE proc_geteuid(VALUE obj)
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
void * rb_thread_call_without_gvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2)
int rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
rb_pid_t rb_spawn_err(int argc, const VALUE *argv, char *errmsg, size_t errmsg_buflen)
VALUE rb_str_resize(VALUE, long)
static void before_exec(void)
VALUE rb_const_get(VALUE, ID)
VALUE rb_thread_local_aset(VALUE, ID, VALUE)
VALUE rb_clock_gettime(int argc, VALUE *argv)
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
static VALUE rb_check_exec_env(VALUE hash, VALUE *path)
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for module.
timetick_int_t giga_count
unsigned close_others_given
static int compare_posix_sh(const void *key, const void *el)
static VALUE p_uid_switch(VALUE obj)
static VALUE pst_wcoredump(VALUE st)
VALUE rb_sprintf(const char *format,...)
static int chfunc(void *data, char *errbuf, size_t errbuf_len)
static int under_uid_switch
#define parent_redirect_close(fd)
static int close_unless_reserved(int fd)
static int proc_exec_cmd(const char *prog, VALUE argv_str, VALUE envp_str)
static ID id_float_second
static void save_env(struct rb_execarg *sargp)
static VALUE pst_pid(VALUE st)
void rb_str_modify_expand(VALUE, long)
static void pst_message(VALUE str, rb_pid_t pid, int status)
VALUE rb_ivar_set(VALUE, ID, VALUE)
VALUE rb_check_hash_type(VALUE hash)
unsigned char buf[MIME_BUF_SIZE]
VALUE rb_assoc_new(VALUE car, VALUE cdr)
VALUE tied_io_for_writing
static VALUE detach_process_watcher(void *arg)
unsigned new_pgroup_given
struct rb_execarg::@139::@141 cmd
static VALUE p_gid_switch(VALUE obj)
RUBY_EXTERN VALUE rb_cThread
void rb_execarg_parent_end(VALUE execarg_obj)
rb_pid_t rb_w32_uaspawn(int, const char *, char *const *)
#define CHILD_ERRMSG_BUFLEN
const char * rb_class2name(VALUE)
char * strchr(char *, char)
VALUE rb_io_puts(int, const VALUE *, VALUE)
int clock_gettime(clockid_t, struct timespec *)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
#define proc_setmaxgroups
VALUE rb_str_new_cstr(const char *)
static int check_exec_options_i_extract(st_data_t st_key, st_data_t st_val, st_data_t arg)
#define RARRAY_LENINT(ary)
void rb_sys_fail(const char *mesg)
static int intcmp(const void *a, const void *b)
void rb_jump_tag(int tag)
void ruby_error_print(void)
int rb_reserved_fd_p(int fd)
static void security(const char *str)
register unsigned int len
VALUE rb_define_module_under(VALUE outer, const char *name)
#define StringValueCStr(v)
static int check_exec_options_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
static rb_uid_t rb_seteuid_core(rb_uid_t euid)
static VALUE p_gid_grant_privilege(VALUE obj, VALUE id)
static VALUE do_spawn_process(VALUE arg)
void rb_thread_wait_for(struct timeval)
static VALUE timetick2integer(struct timetick *ttp, timetick_int_t *numerators, int num_numerators, timetick_int_t *denominators, int num_denominators)
VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
char * rb_execarg_commandline(const struct rb_execarg *eargp, VALUE *prog)
#define RARRAY_ASET(a, i, v)
#define try_with_sh(prog, argv, envp)
VALUE rb_equal(VALUE, VALUE)
RUBY_EXTERN VALUE rb_stderr
#define UNLIMITED_ARGUMENTS
void rb_last_status_set(int status, rb_pid_t pid)
int utime(const char *filename, const struct utimbuf *times)
RUBY_EXTERN VALUE rb_cStruct
#define RARRAY_AREF(a, i)
static VALUE pst_wifstopped(VALUE st)
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
#define redirect_dup2(oldfd, newfd)
static VALUE p_gid_exchange(VALUE obj)
static VALUE p_uid_grant_privilege(VALUE obj, VALUE id)
int getrusage(int who, struct rusage *usage)
static VALUE pst_to_i(VALUE st)
VALUE rb_check_array_type(VALUE ary)
static void check_uid_switch(void)
rb_pid_t rb_spawn(int argc, const VALUE *argv)
VALUE rb_str_catf(VALUE str, const char *format,...)
void rb_syserr_fail_str(int e, VALUE mesg)
void rb_thread_reset_timer_thread(void)
VALUE rb_check_string_type(VALUE)
static VALUE proc_getegid(VALUE obj)
static rb_pid_t do_waitpid_nonblocking(rb_pid_t pid, int *st, int flags)
int clock_getres(clockid_t, struct timespec *)
static VALUE get_ppid(void)
#define ARGVSTR2ARGV(argv_str)
static ID id_unsetenv_others
static int exit_status_code(VALUE status)
void rb_thread_check_ints(void)
size_t rb_str_capacity(VALUE str)
#define RB_BUILTIN_TYPE(x)
static int fill_envp_buf_i(st_data_t st_key, st_data_t st_val, st_data_t arg)
static VALUE p_gid_sw_ensure(VALUE obj)
static VALUE pst_inspect(VALUE st)
#define parent_redirect_open(pathname, flags, perm)
#define TypedData_Make_Struct(klass, type, data_type, sval)
VALUE rb_ary_dup(VALUE ary)
void rb_notimplement(void)
void rb_last_status_clear(void)
#define SafeStringValue(v)
static VALUE rb_f_sleep(int argc, VALUE *argv)
static int proc_exec_sh(const char *str, VALUE envp_str)
static VALUE p_uid_change_privilege(VALUE obj, VALUE id)
static VALUE rb_exec_getargs(int *argc_p, VALUE **argv_p, int accept_shell, VALUE *env_ret, VALUE *opthash_ret)
static ID id_GETTIMEOFDAY_BASED_CLOCK_REALTIME
#define StringValuePtr(v)
#define redirect_dup(oldfd)
RUBY_EXTERN int dup2(int, int)
static void rb_exec_fail(struct rb_execarg *eargp, int err, const char *errmsg)
VALUE rb_str_new_frozen(VALUE)
int rb_cloexec_dup(int oldfd)
static VALUE proc_getuid(VALUE obj)
#define RUBY_TYPED_DEFAULT_FREE
VALUE rb_define_module(const char *name)
static VALUE check_exec_redirect1(VALUE ary, VALUE key, VALUE param)
#define ARGVSTR2ARGC(argv_str)
VALUE rb_str_buf_new(long)
VALUE rb_detach_process(rb_pid_t pid)
static VALUE get_pid(void)
static VALUE rb_execarg_parent_start1(VALUE execarg_obj)
static int fd_set_cloexec(int fd, char *errmsg, size_t errmsg_buflen)
rb_pid_t rb_w32_uspawn(int, const char *, const char *)
#define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max)
VALUE rb_execarg_init(int argc, const VALUE *orig_argv, int accept_shell, VALUE execarg_obj)
VALUE rb_thread_create(VALUE(*)(ANYARGS), void *)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
void ruby_setenv(const char *name, const char *value)
void rb_warn(const char *fmt,...)
static VALUE pst_wexitstatus(VALUE st)
VALUE rb_clock_getres(int argc, VALUE *argv)
static int intrcmp(const void *a, const void *b)
struct rb_execarg::@139::@140 sh
rb_pid_t waitpid(rb_pid_t, int *, int)
VALUE rb_attr_get(VALUE, ID)
#define redirect_cloexec_dup(oldfd)
static int fd_clear_cloexec(int fd, char *errmsg, size_t errmsg_buflen)
VALUE rb_f_abort(int argc, const VALUE *argv)
void rb_thread_sleep_forever(void)
VALUE rb_str_new(const char *, long)