1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* process.c: use the name "eargp" for struct rb_execarg variables

Browse Source 
consistently except for saving process attributes. 

* io.c: ditto.

* ext/pty/pty.c: ditto.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@36189 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
akr 2012-06-22 23:09:16 +00:00
parent f7fc42a7af
commit 3eafc1660f
4 changed files with 117 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@ -1,3 +1,12 @@
Sat Jun 23 07:59:57 2012 Tanaka Akira <akr@fsij.org>
* process.c: use the name "eargp" for struct rb_execarg variables
consistently except for saving process attributes.
* io.c: ditto.
* ext/pty/pty.c: ditto.
Wed Jun 20 18:27:03 2012 Yuki Yugui Sonoda <yugui@google.com> Wed Jun 20 18:27:03 2012 Yuki Yugui Sonoda <yugui@google.com>
* common.mk: Add missing dependencies. * common.mk: Add missing dependencies.

6
ext/pty/pty.c
View File

@ -79,7 +79,7 @@ struct child_info {
int master, slave; int master, slave;
char *slavename; char *slavename;
VALUE execarg_obj; VALUE execarg_obj;
struct rb_execarg *earg; struct rb_execarg *eargp;
}; };
static int static int
@ -143,7 +143,7 @@ chfunc(void *data, char *errbuf, size_t errbuf_len)
seteuid(getuid()); seteuid(getuid());
#endif #endif
return rb_exec_async_signal_safe(carg->earg, errbuf, sizeof(errbuf_len)); return rb_exec_async_signal_safe(carg->eargp, errbuf, sizeof(errbuf_len));
#undef ERROR_EXIT #undef ERROR_EXIT
} }
@ -178,7 +178,7 @@ establishShell(int argc, VALUE *argv, struct pty_info *info,
} }
carg.execarg_obj = rb_execarg_new(argc, argv, 1); carg.execarg_obj = rb_execarg_new(argc, argv, 1);
carg.earg = rb_execarg_get(carg.execarg_obj); carg.eargp = rb_execarg_get(carg.execarg_obj);
rb_execarg_fixup(carg.execarg_obj); rb_execarg_fixup(carg.execarg_obj);
getDevice(&master, &slave, SlaveName, 0); getDevice(&master, &slave, SlaveName, 0);

8
io.c
View File

@ -5343,7 +5343,7 @@ rb_pipe(int *pipes)
#ifdef HAVE_FORK #ifdef HAVE_FORK
struct popen_arg { struct popen_arg {
VALUE execarg_obj; VALUE execarg_obj;
struct rb_execarg *execp; struct rb_execarg *eargp;
int modef; int modef;
int pair[2]; int pair[2];
int write_pair[2]; int write_pair[2];
@ -5462,7 +5462,7 @@ popen_exec(void *pp, char *errmsg, size_t errmsg_len)
{ {
struct popen_arg *p = (struct popen_arg*)pp; struct popen_arg *p = (struct popen_arg*)pp;
return rb_exec_async_signal_safe(p->execp, errmsg, errmsg_len); return rb_exec_async_signal_safe(p->eargp, errmsg, errmsg_len);
} }
#endif #endif
@ -5504,7 +5504,7 @@ pipe_open(VALUE execarg_obj, const char *modestr, int fmode, convconfig_t *convc
#if defined(HAVE_FORK) #if defined(HAVE_FORK)
arg.execarg_obj = execarg_obj; arg.execarg_obj = execarg_obj;
arg.execp = eargp; arg.eargp = eargp;
arg.modef = fmode; arg.modef = fmode;
arg.pair[0] = arg.pair[1] = -1; arg.pair[0] = arg.pair[1] = -1;
arg.write_pair[0] = arg.write_pair[1] = -1; arg.write_pair[0] = arg.write_pair[1] = -1;
@ -5541,7 +5541,7 @@ pipe_open(VALUE execarg_obj, const char *modestr, int fmode, convconfig_t *convc
} }
if (!NIL_P(execarg_obj)) { if (!NIL_P(execarg_obj)) {
rb_execarg_fixup(execarg_obj); rb_execarg_fixup(execarg_obj);
pid = rb_fork_async_signal_safe(&status, popen_exec, &arg, arg.execp->redirect_fds, errmsg, sizeof(errmsg)); pid = rb_fork_async_signal_safe(&status, popen_exec, &arg, arg.eargp->redirect_fds, errmsg, sizeof(errmsg));
} }
else { else {
pid = rb_fork_ruby(&status); pid = rb_fork_ruby(&status);

202
process.c
View File

@ -1269,20 +1269,20 @@ enum {
static void static void
mark_exec_arg(void *ptr) mark_exec_arg(void *ptr)
{ {
struct rb_execarg *earg = ptr; struct rb_execarg *eargp = ptr;
if (earg->use_shell) if (eargp->use_shell)
rb_gc_mark(earg->invoke.sh.shell_script); rb_gc_mark(eargp->invoke.sh.shell_script);
else { else {
rb_gc_mark(earg->invoke.cmd.command_name); rb_gc_mark(eargp->invoke.cmd.command_name);
rb_gc_mark(earg->invoke.cmd.command_abspath); rb_gc_mark(eargp->invoke.cmd.command_abspath);
rb_gc_mark(earg->invoke.cmd.argv_str); rb_gc_mark(eargp->invoke.cmd.argv_str);
rb_gc_mark(earg->invoke.cmd.argv_buf); rb_gc_mark(eargp->invoke.cmd.argv_buf);
} }
rb_gc_mark(earg->options); rb_gc_mark(eargp->options);
rb_gc_mark(earg->redirect_fds); rb_gc_mark(eargp->redirect_fds);
rb_gc_mark(earg->envp_str); rb_gc_mark(eargp->envp_str);
rb_gc_mark(earg->envp_buf); rb_gc_mark(eargp->envp_buf);
rb_gc_mark(earg->dup2_tmpbuf); rb_gc_mark(eargp->dup2_tmpbuf);
} }
static void static void
@ -1543,9 +1543,9 @@ static int rlimit_type_by_lname(const char *name);
int int
rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val) rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
{ {
struct rb_execarg *e = rb_execarg_get(execarg_obj); struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
VALUE options = e->options; VALUE options = eargp->options;
ID id; ID id;
#if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM) #if defined(HAVE_SETRLIMIT) && defined(NUM2RLIM)
int rtype; int rtype;
@ -1559,7 +1559,7 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
#ifdef HAVE_SETPGID #ifdef HAVE_SETPGID
if (id == rb_intern("pgroup")) { if (id == rb_intern("pgroup")) {
pid_t pgroup; pid_t pgroup;
if (e->pgroup_given) { if (eargp->pgroup_given) {
rb_raise(rb_eArgError, "pgroup option specified twice"); rb_raise(rb_eArgError, "pgroup option specified twice");
} }
if (!RTEST(val)) if (!RTEST(val))
@ -1572,8 +1572,8 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
rb_raise(rb_eArgError, "negative process group ID : %ld", (long)pgroup); rb_raise(rb_eArgError, "negative process group ID : %ld", (long)pgroup);
} }
} }
e->pgroup_given = 1; eargp->pgroup_given = 1;
e->pgroup_pgid = pgroup; eargp->pgroup_pgid = pgroup;
} }
else else
#endif #endif
@ -1633,11 +1633,11 @@ rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
} }
else if (id == rb_intern("umask")) { else if (id == rb_intern("umask")) {
mode_t cmask = NUM2MODET(val); mode_t cmask = NUM2MODET(val);
if (e->umask_given) { if (eargp->umask_given) {
rb_raise(rb_eArgError, "umask option specified twice"); rb_raise(rb_eArgError, "umask option specified twice");
} }
e->umask_given = 1; eargp->umask_given = 1;
e->umask_mask = cmask; eargp->umask_mask = cmask;
} }
else if (id == rb_intern("close_others")) { else if (id == rb_intern("close_others")) {
if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS))) { if (!NIL_P(rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS))) {
@ -1886,13 +1886,13 @@ compare_posix_sh(const void *key, const void *el)
static void static void
rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VALUE execarg_obj) rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VALUE execarg_obj)
{ {
struct rb_execarg *e = rb_execarg_get(execarg_obj); struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
VALUE options; VALUE options;
char fbuf[MAXPATHLEN]; char fbuf[MAXPATHLEN];
MEMZERO(e, struct rb_execarg, 1); MEMZERO(eargp, struct rb_execarg, 1);
options = hide_obj(rb_ary_new()); options = hide_obj(rb_ary_new());
e->options = options; eargp->options = options;
if (!NIL_P(opthash)) { if (!NIL_P(opthash)) {
rb_check_exec_options(opthash, execarg_obj); rb_check_exec_options(opthash, execarg_obj);
@ -1902,14 +1902,14 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL
rb_ary_store(options, EXEC_OPTION_ENV, env); rb_ary_store(options, EXEC_OPTION_ENV, env);
} }
e->use_shell = argc == 0; eargp->use_shell = argc == 0;
if (e->use_shell) if (eargp->use_shell)
e->invoke.sh.shell_script = prog; eargp->invoke.sh.shell_script = prog;
else else
e->invoke.cmd.command_name = prog; eargp->invoke.cmd.command_name = prog;
#ifndef _WIN32 #ifndef _WIN32
if (e->use_shell) { if (eargp->use_shell) {
static const char posix_sh_cmds[][9] = { static const char posix_sh_cmds[][9] = {
"!", /* reserved */ "!", /* reserved */
".", /* special built-in */ ".", /* special built-in */
@ -1996,9 +1996,9 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL
} }
if (!has_meta) { if (!has_meta) {
/* avoid shell since no shell meta charactor found. */ /* avoid shell since no shell meta charactor found. */
e->use_shell = 0; eargp->use_shell = 0;
} }
if (!e->use_shell) { if (!eargp->use_shell) {
VALUE argv_buf; VALUE argv_buf;
argv_buf = hide_obj(rb_str_buf_new(0)); argv_buf = hide_obj(rb_str_buf_new(0));
p = RSTRING_PTR(prog); p = RSTRING_PTR(prog);
@ -2013,22 +2013,22 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL
rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */ rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */
} }
} }
e->invoke.cmd.argv_buf = argv_buf; eargp->invoke.cmd.argv_buf = argv_buf;
e->invoke.cmd.command_name = hide_obj(rb_str_new_cstr(RSTRING_PTR(argv_buf))); eargp->invoke.cmd.command_name = hide_obj(rb_str_new_cstr(RSTRING_PTR(argv_buf)));
} }
} }
#endif #endif
if (!e->use_shell) { if (!eargp->use_shell) {
const char *abspath; const char *abspath;
abspath = dln_find_exe_r(RSTRING_PTR(e->invoke.cmd.command_name), 0, fbuf, sizeof(fbuf)); abspath = dln_find_exe_r(RSTRING_PTR(eargp->invoke.cmd.command_name), 0, fbuf, sizeof(fbuf));
if (abspath) if (abspath)
e->invoke.cmd.command_abspath = rb_str_new_cstr(abspath); eargp->invoke.cmd.command_abspath = rb_str_new_cstr(abspath);
else else
e->invoke.cmd.command_abspath = Qnil; eargp->invoke.cmd.command_abspath = Qnil;
} }
if (!e->use_shell && !e->invoke.cmd.argv_buf) { if (!eargp->use_shell && !eargp->invoke.cmd.argv_buf) {
int i; int i;
VALUE argv_buf; VALUE argv_buf;
argv_buf = rb_str_buf_new(0); argv_buf = rb_str_buf_new(0);
@ -2037,22 +2037,22 @@ rb_exec_fillarg(VALUE prog, int argc, VALUE *argv, VALUE env, VALUE opthash, VAL
rb_str_buf_cat2(argv_buf, StringValueCStr(argv[i])); rb_str_buf_cat2(argv_buf, StringValueCStr(argv[i]));
rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */ rb_str_buf_cat(argv_buf, "", 1); /* append '\0' */
} }
e->invoke.cmd.argv_buf = argv_buf; eargp->invoke.cmd.argv_buf = argv_buf;
} }
if (!e->use_shell) { if (!eargp->use_shell) {
const char *p, *ep, *null=NULL; const char *p, *ep, *null=NULL;
VALUE argv_str; VALUE argv_str;
argv_str = hide_obj(rb_str_buf_new(sizeof(char*) * (argc + 2))); 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. */ rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* place holder for /bin/sh of try_with_sh. */
p = RSTRING_PTR(e->invoke.cmd.argv_buf); p = RSTRING_PTR(eargp->invoke.cmd.argv_buf);
ep = p + RSTRING_LEN(e->invoke.cmd.argv_buf); ep = p + RSTRING_LEN(eargp->invoke.cmd.argv_buf);
while (p < ep) { while (p < ep) {
rb_str_buf_cat(argv_str, (char *)&p, sizeof(p)); rb_str_buf_cat(argv_str, (char *)&p, sizeof(p));
p += strlen(p) + 1; p += strlen(p) + 1;
} }
rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* terminator for execve. */ rb_str_buf_cat(argv_str, (char *)&null, sizeof(null)); /* terminator for execve. */
e->invoke.cmd.argv_str = argv_str; eargp->invoke.cmd.argv_str = argv_str;
} }
RB_GC_GUARD(execarg_obj); RB_GC_GUARD(execarg_obj);
} }
@ -2061,8 +2061,8 @@ VALUE
rb_execarg_new(int argc, VALUE *argv, int accept_shell) rb_execarg_new(int argc, VALUE *argv, int accept_shell)
{ {
VALUE execarg_obj; VALUE execarg_obj;
struct rb_execarg *e; struct rb_execarg *eargp;
execarg_obj = TypedData_Make_Struct(rb_cData, struct rb_execarg, &exec_arg_data_type, e); execarg_obj = TypedData_Make_Struct(rb_cData, struct rb_execarg, &exec_arg_data_type, eargp);
hide_obj(execarg_obj); hide_obj(execarg_obj);
rb_execarg_init(argc, argv, accept_shell, execarg_obj); rb_execarg_init(argc, argv, accept_shell, execarg_obj);
return execarg_obj; return execarg_obj;
@ -2070,20 +2070,20 @@ rb_execarg_new(int argc, VALUE *argv, int accept_shell)
struct rb_execarg *rb_execarg_get(VALUE execarg_obj) struct rb_execarg *rb_execarg_get(VALUE execarg_obj)
{ {
struct rb_execarg *e; struct rb_execarg *eargp;
TypedData_Get_Struct(execarg_obj, struct rb_execarg, &exec_arg_data_type, e); TypedData_Get_Struct(execarg_obj, struct rb_execarg, &exec_arg_data_type, eargp);
return e; return eargp;
} }
VALUE VALUE
rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj) rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj)
{ {
struct rb_execarg *e = rb_execarg_get(execarg_obj); struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
VALUE prog, ret; VALUE prog, ret;
VALUE env = Qnil, opthash = Qnil; VALUE env = Qnil, opthash = Qnil;
prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash); prog = rb_exec_getargs(&argc, &argv, accept_shell, &env, &opthash);
rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj); rb_exec_fillarg(prog, argc, argv, env, opthash, execarg_obj);
ret = e->use_shell ? e->invoke.sh.shell_script : e->invoke.cmd.command_name; ret = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
RB_GC_GUARD(execarg_obj); RB_GC_GUARD(execarg_obj);
return ret; return ret;
} }
@ -2115,22 +2115,22 @@ static long run_exec_dup2_tmpbuf_size(long n);
void void
rb_execarg_fixup(VALUE execarg_obj) rb_execarg_fixup(VALUE execarg_obj)
{ {
struct rb_execarg *e = rb_execarg_get(execarg_obj); struct rb_execarg *eargp = rb_execarg_get(execarg_obj);
VALUE unsetenv_others, envopts; VALUE unsetenv_others, envopts;
VALUE ary; VALUE ary;
e->redirect_fds = check_exec_fds(e->options); eargp->redirect_fds = check_exec_fds(eargp->options);
ary = rb_ary_entry(e->options, EXEC_OPTION_DUP2); ary = rb_ary_entry(eargp->options, EXEC_OPTION_DUP2);
if (!NIL_P(ary)) { if (!NIL_P(ary)) {
size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary)); size_t len = run_exec_dup2_tmpbuf_size(RARRAY_LEN(ary));
VALUE tmpbuf = hide_obj(rb_str_new(0, len)); VALUE tmpbuf = hide_obj(rb_str_new(0, len));
rb_str_set_len(tmpbuf, len); rb_str_set_len(tmpbuf, len);
e->dup2_tmpbuf = tmpbuf; eargp->dup2_tmpbuf = tmpbuf;
} }
unsetenv_others = rb_ary_entry(e->options, EXEC_OPTION_UNSETENV_OTHERS); unsetenv_others = rb_ary_entry(eargp->options, EXEC_OPTION_UNSETENV_OTHERS);
envopts = rb_ary_entry(e->options, EXEC_OPTION_ENV); envopts = rb_ary_entry(eargp->options, EXEC_OPTION_ENV);
if (RTEST(unsetenv_others) || !NIL_P(envopts)) { if (RTEST(unsetenv_others) || !NIL_P(envopts)) {
VALUE envtbl, envp_str, envp_buf; VALUE envtbl, envp_str, envp_buf;
char *p, *ep; char *p, *ep;
@ -2171,8 +2171,8 @@ rb_execarg_fixup(VALUE execarg_obj)
} }
p = NULL; p = NULL;
rb_str_buf_cat(envp_str, (char *)&p, sizeof(p)); rb_str_buf_cat(envp_str, (char *)&p, sizeof(p));
e->envp_str = envp_str; eargp->envp_str = envp_str;
e->envp_buf = envp_buf; eargp->envp_buf = envp_buf;
/* /*
char **tmp_envp = (char **)RSTRING_PTR(envp_str); char **tmp_envp = (char **)RSTRING_PTR(envp_str);
@ -2191,7 +2191,7 @@ rb_exec_arg_fixup(struct rb_exec_arg *e)
rb_execarg_fixup(e->execarg_obj); rb_execarg_fixup(e->execarg_obj);
} }
static int rb_exec_without_timer_thread(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen); static int rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen);
/* /*
* call-seq: * call-seq:
@ -2248,19 +2248,19 @@ VALUE
rb_f_exec(int argc, VALUE *argv) rb_f_exec(int argc, VALUE *argv)
{ {
VALUE execarg_obj, fail_str; VALUE execarg_obj, fail_str;
struct rb_execarg *earg; struct rb_execarg *eargp;
#define CHILD_ERRMSG_BUFLEN 80 #define CHILD_ERRMSG_BUFLEN 80
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
execarg_obj = rb_execarg_new(argc, argv, TRUE); execarg_obj = rb_execarg_new(argc, argv, TRUE);
earg = rb_execarg_get(execarg_obj); eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj); rb_execarg_fixup(execarg_obj);
fail_str = earg->use_shell ? earg->invoke.sh.shell_script : earg->invoke.cmd.command_name; fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
#ifdef __MacOS_X__ #ifdef __MacOS_X__
rb_exec_without_timer_thread(earg, errmsg, sizeof(errmsg)); rb_exec_without_timer_thread(eargp, errmsg, sizeof(errmsg));
#else #else
rb_exec_async_signal_safe(earg, errmsg, sizeof(errmsg)); rb_exec_async_signal_safe(eargp, errmsg, sizeof(errmsg));
#endif #endif
RB_GC_GUARD(execarg_obj); RB_GC_GUARD(execarg_obj);
if (errmsg[0]) if (errmsg[0])
@ -2626,7 +2626,7 @@ run_exec_dup2_child(VALUE ary, struct rb_execarg *s, char *errmsg, size_t errmsg
#ifdef HAVE_SETPGID #ifdef HAVE_SETPGID
/* This function should be async-signal-safe when _save_ is Qnil. Actually it is. */ /* This function should be async-signal-safe when _save_ is Qnil. Actually it is. */
static int static int
run_exec_pgroup(const struct rb_execarg *e, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen) run_exec_pgroup(const struct rb_execarg *eargp, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen)
{ {
/* /*
* If FD_CLOEXEC is available, rb_fork waits the child's execve. * If FD_CLOEXEC is available, rb_fork waits the child's execve.
@ -2637,7 +2637,7 @@ run_exec_pgroup(const struct rb_execarg *e, struct rb_execarg *s, char *errmsg,
int ret; int ret;
pid_t pgroup; pid_t pgroup;
pgroup = e->pgroup_pgid; pgroup = eargp->pgroup_pgid;
if (pgroup == -1) if (pgroup == -1)
return 0; return 0;
@ -2724,9 +2724,9 @@ save_env(struct rb_execarg *s)
/* This function should be async-signal-safe when _s_ is NULL. Hopefully it is. */ /* This function should be async-signal-safe when _s_ is NULL. Hopefully it is. */
int int
rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen) rb_execarg_run_options(const struct rb_execarg *eargp, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen)
{ {
VALUE options = e->options; VALUE options = eargp->options;
VALUE obj; VALUE obj;
if (!RTEST(options)) if (!RTEST(options))
@ -2740,8 +2740,8 @@ rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *e
} }
#ifdef HAVE_SETPGID #ifdef HAVE_SETPGID
if (e->pgroup_given) { if (eargp->pgroup_given) {
if (run_exec_pgroup(e, s, errmsg, errmsg_buflen) == -1) /* async-signal-safe */ if (run_exec_pgroup(eargp, s, errmsg, errmsg_buflen) == -1) /* async-signal-safe */
return -1; return -1;
} }
#endif #endif
@ -2777,8 +2777,8 @@ rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *e
} }
#endif #endif
if (e->umask_given) { if (eargp->umask_given) {
mode_t mask = e->umask_mask; mode_t mask = eargp->umask_mask;
mode_t oldmask = umask(mask); /* never fail */ /* async-signal-safe */ mode_t oldmask = umask(mask); /* never fail */ /* async-signal-safe */
if (s) { if (s) {
s->umask_given = 1; s->umask_given = 1;
@ -2788,7 +2788,7 @@ rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *e
obj = rb_ary_entry(options, EXEC_OPTION_DUP2); obj = rb_ary_entry(options, EXEC_OPTION_DUP2);
if (!NIL_P(obj)) { if (!NIL_P(obj)) {
if (run_exec_dup2(obj, e->dup2_tmpbuf, s, errmsg, errmsg_buflen) == -1) /* hopefully async-signal-safe */ if (run_exec_dup2(obj, eargp->dup2_tmpbuf, s, errmsg, errmsg_buflen) == -1) /* hopefully async-signal-safe */
return -1; return -1;
} }
@ -2805,7 +2805,7 @@ rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *e
#ifdef HAVE_FORK #ifdef HAVE_FORK
obj = rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS); obj = rb_ary_entry(options, EXEC_OPTION_CLOSE_OTHERS);
if (obj != Qfalse) { if (obj != Qfalse) {
rb_close_before_exec(3, FIX2INT(obj), e->redirect_fds); /* async-signal-safe */ rb_close_before_exec(3, FIX2INT(obj), eargp->redirect_fds); /* async-signal-safe */
} }
#endif #endif
@ -2862,7 +2862,7 @@ rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s)
/* This function should be async-signal-safe. Hopefully it is. */ /* This function should be async-signal-safe. Hopefully it is. */
int int
rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen) rb_exec_async_signal_safe(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{ {
#if !defined(HAVE_FORK) #if !defined(HAVE_FORK)
struct rb_execarg sarg, *const sargp = &sarg; struct rb_execarg sarg, *const sargp = &sarg;
@ -2872,18 +2872,18 @@ rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errms
before_exec_async_signal_safe(); /* async-signal-safe */ before_exec_async_signal_safe(); /* async-signal-safe */
if (rb_execarg_run_options(e, sargp, errmsg, errmsg_buflen) < 0) { /* hopefully async-signal-safe */ if (rb_execarg_run_options(eargp, sargp, errmsg, errmsg_buflen) < 0) { /* hopefully async-signal-safe */
goto failure; goto failure;
} }
if (e->use_shell) { if (eargp->use_shell) {
proc_exec_sh(RSTRING_PTR(e->invoke.sh.shell_script), e->envp_str); /* async-signal-safe */ proc_exec_sh(RSTRING_PTR(eargp->invoke.sh.shell_script), eargp->envp_str); /* async-signal-safe */
} }
else { else {
char *abspath = NULL; char *abspath = NULL;
if (!NIL_P(e->invoke.cmd.command_abspath)) if (!NIL_P(eargp->invoke.cmd.command_abspath))
abspath = RSTRING_PTR(e->invoke.cmd.command_abspath); abspath = RSTRING_PTR(eargp->invoke.cmd.command_abspath);
proc_exec_cmd(abspath, e->invoke.cmd.argv_str, e->envp_str); /* async-signal-safe */ proc_exec_cmd(abspath, eargp->invoke.cmd.argv_str, eargp->envp_str); /* async-signal-safe */
} }
#if !defined(HAVE_FORK) #if !defined(HAVE_FORK)
preserving_errno(rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen)); preserving_errno(rb_execarg_run_options(sargp, NULL, errmsg, errmsg_buflen));
@ -2895,11 +2895,11 @@ failure:
} }
static int static int
rb_exec_without_timer_thread(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen) rb_exec_without_timer_thread(const struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{ {
int ret; int ret;
before_exec_non_async_signal_safe(); /* async-signal-safe if forked_child is true */ before_exec_non_async_signal_safe(); /* async-signal-safe if forked_child is true */
ret = rb_exec_async_signal_safe(e, errmsg, errmsg_buflen); /* hopefully async-signal-safe */ 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. */ preserving_errno(after_exec_non_async_signal_safe()); /* not async-signal-safe because it calls rb_thread_start_timer_thread. */
return ret; return ret;
} }
@ -3494,7 +3494,7 @@ rb_syswait(rb_pid_t pid)
} }
static rb_pid_t static rb_pid_t
rb_spawn_process(struct rb_execarg *earg, char *errmsg, size_t errmsg_buflen) rb_spawn_process(struct rb_execarg *eargp, char *errmsg, size_t errmsg_buflen)
{ {
rb_pid_t pid; rb_pid_t pid;
#if !USE_SPAWNV #if !USE_SPAWNV
@ -3506,34 +3506,34 @@ rb_spawn_process(struct rb_execarg *earg, char *errmsg, size_t errmsg_buflen)
#endif #endif
#if defined HAVE_FORK && !USE_SPAWNV #if defined HAVE_FORK && !USE_SPAWNV
pid = rb_fork_async_signal_safe(&status, rb_exec_atfork, earg, earg->redirect_fds, errmsg, errmsg_buflen); pid = rb_fork_async_signal_safe(&status, rb_exec_atfork, eargp, eargp->redirect_fds, errmsg, errmsg_buflen);
#else #else
prog = earg->use_shell ? earg->invoke.sh.shell_script : earg->invoke.cmd.command_name; prog = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
if (rb_execarg_run_options(earg, &sarg, errmsg, errmsg_buflen) < 0) { if (rb_execarg_run_options(eargp, &sarg, errmsg, errmsg_buflen) < 0) {
return -1; return -1;
} }
if (prog && !earg->use_shell) { if (prog && !eargp->use_shell) {
char **argv = ARGVSTR2ARGV(earg->invoke.cmd.argv_str); char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str);
argv[0] = RSTRING_PTR(prog); argv[0] = RSTRING_PTR(prog);
} }
# if defined HAVE_SPAWNV # if defined HAVE_SPAWNV
if (earg->use_shell) { if (eargp->use_shell) {
pid = proc_spawn_sh(RSTRING_PTR(prog)); pid = proc_spawn_sh(RSTRING_PTR(prog));
} }
else { else {
char **argv = ARGVSTR2ARGV(earg->invoke.cmd.argv_str); char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str);
pid = proc_spawn_cmd(argv, prog, earg->options); pid = proc_spawn_cmd(argv, prog, eargp->options);
} }
# if defined(_WIN32) # if defined(_WIN32)
if (pid == -1) if (pid == -1)
rb_last_status_set(0x7f << 8, 0); rb_last_status_set(0x7f << 8, 0);
# endif # endif
# else # else
if (!earg->use_shell) { if (!eargp->use_shell) {
char **argv = ARGVSTR2ARGV(earg->invoke.cmd.argv_str); char **argv = ARGVSTR2ARGV(eargp->invoke.cmd.argv_str);
int argc = ARGVSTR2ARGC(earg->invoke.cmd.argv_str); int argc = ARGVSTR2ARGC(eargp->invoke.cmd.argv_str);
prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" ")); prog = rb_ary_join(rb_ary_new4(argc, argv), rb_str_new2(" "));
} }
status = system(StringValuePtr(prog)); status = system(StringValuePtr(prog));
@ -3549,13 +3549,13 @@ static rb_pid_t
rb_spawn_internal(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen) rb_spawn_internal(int argc, VALUE *argv, char *errmsg, size_t errmsg_buflen)
{ {
VALUE execarg_obj; VALUE execarg_obj;
struct rb_execarg *earg; struct rb_execarg *eargp;
rb_pid_t ret; rb_pid_t ret;
execarg_obj = rb_execarg_new(argc, argv, TRUE); execarg_obj = rb_execarg_new(argc, argv, TRUE);
earg = rb_execarg_get(execarg_obj); eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj); rb_execarg_fixup(execarg_obj);
ret = rb_spawn_process(earg, errmsg, errmsg_buflen); ret = rb_spawn_process(eargp, errmsg, errmsg_buflen);
RB_GC_GUARD(execarg_obj); RB_GC_GUARD(execarg_obj);
return ret; return ret;
} }
@ -3889,14 +3889,14 @@ rb_f_spawn(int argc, VALUE *argv)
rb_pid_t pid; rb_pid_t pid;
char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' }; char errmsg[CHILD_ERRMSG_BUFLEN] = { '\0' };
VALUE execarg_obj, fail_str; VALUE execarg_obj, fail_str;
struct rb_execarg *earg; struct rb_execarg *eargp;
execarg_obj = rb_execarg_new(argc, argv, TRUE); execarg_obj = rb_execarg_new(argc, argv, TRUE);
earg = rb_execarg_get(execarg_obj); eargp = rb_execarg_get(execarg_obj);
rb_execarg_fixup(execarg_obj); rb_execarg_fixup(execarg_obj);
fail_str = earg->use_shell ? earg->invoke.sh.shell_script : earg->invoke.cmd.command_name; fail_str = eargp->use_shell ? eargp->invoke.sh.shell_script : eargp->invoke.cmd.command_name;
pid = rb_spawn_process(earg, errmsg, sizeof(errmsg)); pid = rb_spawn_process(eargp, errmsg, sizeof(errmsg));
RB_GC_GUARD(execarg_obj); RB_GC_GUARD(execarg_obj);
if (pid == -1) { if (pid == -1) {