line_input_t *line_input_state;
#endif
pid_t root_pid;
+ pid_t last_bg_pid;
#if ENABLE_HUSH_JOB
int run_list_level;
- pid_t saved_task_pgrp;
+// pid_t saved_task_pgrp;
pid_t saved_tty_pgrp;
int last_jobid;
struct pipe *job_list;
unsigned depth_break_continue;
unsigned depth_of_loop;
#endif
- pid_t last_bg_pid;
const char *ifs;
const char *cwd;
- struct variable *top_var; /* = &shell_ver (set in main()) */
+ struct variable *top_var; /* = &G.shell_ver (set in main()) */
struct variable shell_ver;
#if ENABLE_FEATURE_SH_STANDALONE
struct nofork_save_area nofork_save;
};
#define G (*ptr_to_globals)
-
-#if !ENABLE_HUSH_INTERACTIVE
-enum { interactive_fd = 0 };
-#endif
-#if !ENABLE_HUSH_JOB
-enum { run_list_level = 0 };
-#endif
-
-#if ENABLE_HUSH_INTERACTIVE
-#define interactive_fd (G.interactive_fd )
-#define PS1 (G.PS1 )
-#define PS2 (G.PS2 )
-#endif
-#if ENABLE_FEATURE_EDITING
-#define line_input_state (G.line_input_state)
-#endif
-#define root_pid (G.root_pid )
-#if ENABLE_HUSH_JOB
-#define run_list_level (G.run_list_level )
-#define saved_task_pgrp (G.saved_task_pgrp )
-#define saved_tty_pgrp (G.saved_tty_pgrp )
-#define last_jobid (G.last_jobid )
-#define job_list (G.job_list )
-#define toplevel_list (G.toplevel_list )
-#define toplevel_jb (G.toplevel_jb )
-#define ctrl_z_flag (G.ctrl_z_flag )
-#endif /* JOB */
-#define global_argv (G.global_argv )
-#define global_argc (G.global_argc )
-#define last_return_code (G.last_return_code)
-#define ifs (G.ifs )
-#define flag_break_continue (G.flag_break_continue )
-#define depth_break_continue (G.depth_break_continue)
-#define depth_of_loop (G.depth_of_loop )
-#define fake_mode (G.fake_mode )
-#define cwd (G.cwd )
-#define last_bg_pid (G.last_bg_pid )
-#define top_var (G.top_var )
-#define shell_ver (G.shell_ver )
-#if ENABLE_FEATURE_SH_STANDALONE
-#define nofork_save (G.nofork_save )
-#endif
-#if ENABLE_HUSH_JOB
-#define toplevel_jb (G.toplevel_jb )
-#endif
-#define charmap (G.charmap )
-#define user_input_buf (G.user_input_buf )
+/* Not #defining name to G.name - this quickly gets unwieldy
+ * (too many defines). Also, I actually prefer to see when a variable
+ * is global, thus "G." prefix is a useful hint */
#define INIT_G() do { \
SET_PTR_TO_GLOBALS(xzalloc(sizeof(G))); \
} while (0)
/* Normal */
static void syntax(const char *msg)
{
+#if ENABLE_HUSH_INTERACTIVE
/* Was using fancy stuff:
- * (interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
+ * (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die)(...params...)
* but it SEGVs. ?! Oh well... explicit temp ptr works around that */
void FAST_FUNC (*fp)(const char *s, ...);
-
- fp = (interactive_fd ? bb_error_msg : bb_error_msg_and_die);
+ fp = (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die);
fp(msg ? "%s: %s" : "syntax error", "syntax error", msg);
+#else
+ bb_error_msg_and_die(msg ? "%s: %s" : "syntax error", "syntax error", msg);
+#endif
}
#else
/* Debug */
static void syntax_lineno(int line)
{
+#if ENABLE_HUSH_INTERACTIVE
void FAST_FUNC (*fp)(const char *s, ...);
-
- fp = (interactive_fd ? bb_error_msg : bb_error_msg_and_die);
+ fp = (G.interactive_fd ? bb_error_msg : bb_error_msg_and_die);
fp("syntax error hush.c:%d", line);
+#else
+ bb_error_msg_and_die("syntax error hush.c:%d", line);
+#endif
}
#define syntax(str) syntax_lineno(__LINE__)
#endif
{
debug_printf_jobs("got sig %d\n", sig);
// as usual we can have all kinds of nasty problems with leaked malloc data here
- siglongjmp(toplevel_jb, 1);
+ siglongjmp(G.toplevel_jb, 1);
}
static void handler_ctrl_z(int sig UNUSED_PARAM)
pid = fork();
if (pid < 0) /* can't fork. Pretend there was no ctrl-Z */
return;
- ctrl_z_flag = 1;
+ G.ctrl_z_flag = 1;
if (!pid) { /* child */
if (ENABLE_HUSH_JOB)
die_sleep = 0; /* let nofork's xfuncs die */
}
/* parent */
/* finish filling up pipe info */
- toplevel_list->pgrp = pid; /* child is in its own pgrp */
- toplevel_list->progs[0].pid = pid;
+ G.toplevel_list->pgrp = pid; /* child is in its own pgrp */
+ G.toplevel_list->progs[0].pid = pid;
/* parent needs to longjmp out of running nofork.
* we will "return" exitcode 0, with child put in background */
// as usual we can have all kinds of nasty problems with leaked malloc data here
debug_printf_jobs("siglongjmp in parent\n");
- siglongjmp(toplevel_jb, 1);
+ siglongjmp(G.toplevel_jb, 1);
}
/* Restores tty foreground process group, and exits.
/* Disable all signals: job control, SIGPIPE, etc. */
sigprocmask_allsigs(SIG_BLOCK);
- if (interactive_fd)
- tcsetpgrp(interactive_fd, saved_tty_pgrp);
+#if ENABLE_HUSH_INTERACTIVE
+ if (G.interactive_fd)
+ tcsetpgrp(G.interactive_fd, G.saved_tty_pgrp);
+#endif
/* Not a signal, just exit */
if (sig <= 0)
static const char *set_cwd(void)
{
- if (cwd == bb_msg_unknown)
- cwd = NULL; /* xrealloc_getcwd_or_warn(arg) calls free(arg)! */
- cwd = xrealloc_getcwd_or_warn((char *)cwd);
- if (!cwd)
- cwd = bb_msg_unknown;
- return cwd;
+ if (G.cwd == bb_msg_unknown)
+ G.cwd = NULL; /* xrealloc_getcwd_or_warn(arg) calls free(arg)! */
+ G.cwd = xrealloc_getcwd_or_warn((char *)G.cwd);
+ if (!G.cwd)
+ G.cwd = bb_msg_unknown;
+ return G.cwd;
}
static void cmdedit_set_initial_prompt(void)
{
#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
- PS1 = NULL;
+ G.PS1 = NULL;
#else
- PS1 = getenv("PS1");
- if (PS1 == NULL)
- PS1 = "\\w \\$ ";
+ G.PS1 = getenv("PS1");
+ if (G.PS1 == NULL)
+ G.PS1 = "\\w \\$ ";
#endif
}
#endif /* EDITING */
#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
/* Set up the prompt */
if (promptmode == 0) { /* PS1 */
- free((char*)PS1);
- PS1 = xasprintf("%s %c ", cwd, (geteuid() != 0) ? '$' : '#');
- prompt_str = PS1;
+ free((char*)G.PS1);
+ G.PS1 = xasprintf("%s %c ", G.cwd, (geteuid() != 0) ? '$' : '#');
+ prompt_str = G.PS1;
} else {
- prompt_str = PS2;
+ prompt_str = G.PS2;
}
#else
- prompt_str = (promptmode == 0) ? PS1 : PS2;
+ prompt_str = (promptmode == 0) ? G.PS1 : G.PS2;
#endif
debug_printf("result '%s'\n", prompt_str);
return prompt_str;
/* Enable command line editing only while a command line
* is actually being read */
do {
- r = read_line_input(prompt_str, user_input_buf, BUFSIZ-1, line_input_state);
+ r = read_line_input(prompt_str, G.user_input_buf, BUFSIZ-1, G.line_input_state);
} while (r == 0); /* repeat if Ctrl-C */
i->eof_flag = (r < 0);
if (i->eof_flag) { /* EOF/error detected */
- user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
- user_input_buf[1] = '\0';
+ G.user_input_buf[0] = EOF; /* yes, it will be truncated, it's ok */
+ G.user_input_buf[1] = '\0';
}
#else
fputs(prompt_str, stdout);
fflush(stdout);
- user_input_buf[0] = r = fgetc(i->file);
- /*user_input_buf[1] = '\0'; - already is and never changed */
+ G.user_input_buf[0] = r = fgetc(i->file);
+ /*G.user_input_buf[1] = '\0'; - already is and never changed */
i->eof_flag = (r == EOF);
#endif
- i->p = user_input_buf;
+ i->p = G.user_input_buf;
}
#endif /* INTERACTIVE */
/* need to double check i->file because we might be doing something
* more complicated by now, like sourcing or substituting. */
#if ENABLE_HUSH_INTERACTIVE
- if (interactive_fd && i->promptme && i->file == stdin) {
+ if (G.interactive_fd && i->promptme && i->file == stdin) {
do {
get_user_input(i);
} while (!*i->p); /* need non-empty line */
/* Linear search for the ID of the job to use */
pi->jobid = 1;
- for (thejob = job_list; thejob; thejob = thejob->next)
+ for (thejob = G.job_list; thejob; thejob = thejob->next)
if (thejob->jobid >= pi->jobid)
pi->jobid = thejob->jobid + 1;
/* Add thejob to the list of running jobs */
- if (!job_list) {
- thejob = job_list = xmalloc(sizeof(*thejob));
+ if (!G.job_list) {
+ thejob = G.job_list = xmalloc(sizeof(*thejob));
} else {
- for (thejob = job_list; thejob->next; thejob = thejob->next)
+ for (thejob = G.job_list; thejob->next; thejob = thejob->next)
continue;
thejob->next = xmalloc(sizeof(*thejob));
thejob = thejob->next;
/* We don't wait for background thejobs to return -- append it
to the list of backgrounded thejobs and leave it alone */
printf("[%d] %d %s\n", thejob->jobid, thejob->progs[0].pid, thejob->cmdtext);
- last_bg_pid = thejob->progs[0].pid;
- last_jobid = thejob->jobid;
+ G.last_bg_pid = thejob->progs[0].pid;
+ G.last_jobid = thejob->jobid;
}
static void remove_bg_job(struct pipe *pi)
{
struct pipe *prev_pipe;
- if (pi == job_list) {
- job_list = pi->next;
+ if (pi == G.job_list) {
+ G.job_list = pi->next;
} else {
- prev_pipe = job_list;
+ prev_pipe = G.job_list;
while (prev_pipe->next != pi)
prev_pipe = prev_pipe->next;
prev_pipe->next = pi->next;
}
- if (job_list)
- last_jobid = job_list->jobid;
+ if (G.job_list)
+ G.last_jobid = G.job_list->jobid;
else
- last_jobid = 0;
+ G.last_jobid = 0;
}
/* Remove a backgrounded job */
#if ENABLE_HUSH_JOB
/* We asked to wait for bg or orphaned children */
/* No need to remember exitcode in this case */
- for (pi = job_list; pi; pi = pi->next) {
+ for (pi = G.job_list; pi; pi = pi->next) {
for (i = 0; i < pi->num_progs; i++) {
if (pi->progs[i].pid == childpid)
goto found_pi_and_prognum;
/* Job finished, move the shell to the foreground */
p = getpgid(0); /* pgid of our process */
debug_printf_jobs("fg'ing ourself: getpgid(0)=%d\n", (int)p);
- tcsetpgrp(interactive_fd, p);
-// if (tcsetpgrp(interactive_fd, p) && errno != ENOTTY)
+ tcsetpgrp(G.interactive_fd, p);
+// if (tcsetpgrp(G.interactive_fd, p) && errno != ENOTTY)
// bb_perror_msg("tcsetpgrp-4a");
return rcode;
}
int a = find_applet_by_name(argv_expanded[0]);
if (a >= 0 && APPLET_IS_NOFORK(a)) {
setup_redirects(child, squirrel);
- save_nofork_data(&nofork_save);
+ save_nofork_data(&G.nofork_save);
debug_printf_exec(": run_nofork_applet '%s' '%s'...\n", argv_expanded[0], argv_expanded[1]);
- rcode = run_nofork_applet_prime(&nofork_save, a, argv_expanded);
+ rcode = run_nofork_applet_prime(&G.nofork_save, a, argv_expanded);
free(argv_expanded);
restore_redirects(squirrel);
debug_printf_exec("run_pipe return %d\n", rcode);
#if ENABLE_HUSH_JOB
/* Every child adds itself to new process group
* with pgid == pid_of_first_child_in_pipe */
- if (run_list_level == 1 && interactive_fd) {
+ if (G.run_list_level == 1 && G.interactive_fd) {
pid_t pgrp;
/* Don't do pgrp restore anymore on fatal signals */
set_fatal_sighandler(SIG_DFL);
if (setpgid(0, pgrp) == 0 && pi->followup != PIPE_BG) {
/* We do it in *every* child, not just first,
* to avoid races */
- tcsetpgrp(interactive_fd, pgrp);
+ tcsetpgrp(G.interactive_fd, pgrp);
}
}
#endif
/*enum reserved_style*/ smallint rword = RES_NONE;
/*enum reserved_style*/ smallint skip_more_for_this_rword = RES_XXXX;
- debug_printf_exec("run_list start lvl %d\n", run_list_level + 1);
+ debug_printf_exec("run_list start lvl %d\n", G.run_list_level + 1);
#if ENABLE_HUSH_LOOPS
/* Check syntax for "for" */
/* current word is FOR or IN (BOLD in comments below) */
if (cpipe->next == NULL) {
syntax("malformed for");
- debug_printf_exec("run_list lvl %d return 1\n", run_list_level);
+ debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
return 1;
}
/* "FOR v; do ..." and "for v IN a b; do..." are ok */
|| cpipe->next->res_word != RES_IN /* FOR v not_do_and_not_in..."? */
) {
syntax("malformed for");
- debug_printf_exec("run_list lvl %d return 1\n", run_list_level);
+ debug_printf_exec("run_list lvl %d return 1\n", G.run_list_level);
return 1;
}
}
* We are saving state before entering outermost list ("while...done")
* so that ctrl-Z will correctly background _entire_ outermost list,
* not just a part of it (like "sleep 1 | exit 2") */
- if (++run_list_level == 1 && interactive_fd) {
- if (sigsetjmp(toplevel_jb, 1)) {
+ if (++G.run_list_level == 1 && G.interactive_fd) {
+ if (sigsetjmp(G.toplevel_jb, 1)) {
/* ctrl-Z forked and we are parent; or ctrl-C.
* Sighandler has longjmped us here */
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
/* Restore level (we can be coming from deep inside
* nested levels) */
- run_list_level = 1;
+ G.run_list_level = 1;
#if ENABLE_FEATURE_SH_STANDALONE
- if (nofork_save.saved) { /* if save area is valid */
+ if (G.nofork_save.saved) { /* if save area is valid */
debug_printf_jobs("exiting nofork early\n");
- restore_nofork_data(&nofork_save);
+ restore_nofork_data(&G.nofork_save);
}
#endif
- if (ctrl_z_flag) {
+ if (G.ctrl_z_flag) {
/* ctrl-Z has forked and stored pid of the child in pi->pid.
* Remember this child as background job */
insert_bg_job(pi);
bb_putchar('\n');
}
USE_HUSH_LOOPS(loop_top = NULL;)
- USE_HUSH_LOOPS(depth_of_loop = 0;)
+ USE_HUSH_LOOPS(G.depth_of_loop = 0;)
rcode = 0;
goto ret;
}
/* ctrl-Z handler will store pid etc in pi */
- toplevel_list = pi;
- ctrl_z_flag = 0;
+ G.toplevel_list = pi;
+ G.ctrl_z_flag = 0;
#if ENABLE_FEATURE_SH_STANDALONE
- nofork_save.saved = 0; /* in case we will run a nofork later */
+ G.nofork_save.saved = 0; /* in case we will run a nofork later */
#endif
signal_SA_RESTART_empty_mask(SIGTSTP, handler_ctrl_z);
signal(SIGINT, handler_ctrl_c);
rword, cond_code, skip_more_for_this_rword);
#if ENABLE_HUSH_LOOPS
if ((rword == RES_WHILE || rword == RES_UNTIL || rword == RES_FOR)
- && loop_top == NULL /* avoid bumping depth_of_loop twice */
+ && loop_top == NULL /* avoid bumping G.depth_of_loop twice */
) {
/* start of a loop: remember where loop starts */
loop_top = pi;
- depth_of_loop++;
+ G.depth_of_loop++;
}
#endif
if (rword == skip_more_for_this_rword && flag_skip) {
{
int r;
#if ENABLE_HUSH_LOOPS
- flag_break_continue = 0;
+ G.flag_break_continue = 0;
#endif
rcode = r = run_pipe(pi); /* NB: rcode is a smallint */
if (r != -1) {
* and we don't need to wait for anything. */
#if ENABLE_HUSH_LOOPS
/* was it "break" or "continue"? */
- if (flag_break_continue) {
- smallint fbc = flag_break_continue;
+ if (G.flag_break_continue) {
+ smallint fbc = G.flag_break_continue;
/* we might fall into outer *loop*,
* don't want to break it too */
if (loop_top) {
- depth_break_continue--;
- if (depth_break_continue == 0)
- flag_break_continue = 0;
+ G.depth_break_continue--;
+ if (G.depth_break_continue == 0)
+ G.flag_break_continue = 0;
/* else: e.g. "continue 2" should *break* once, *then* continue */
} /* else: "while... do... { we are here (innermost list is not a loop!) };...done" */
- if (depth_break_continue != 0 || fbc == BC_BREAK)
+ if (G.depth_break_continue != 0 || fbc == BC_BREAK)
goto check_jobs_and_break;
/* "continue": simulate end of loop */
rword = RES_DONE;
* try "{ { sleep 10; echo DEEP; } & echo HERE; } &".
* I'm NOT treating inner &'s as jobs */
#if ENABLE_HUSH_JOB
- if (run_list_level == 1)
+ if (G.run_list_level == 1)
insert_bg_job(pi);
#endif
rcode = 0; /* EXIT_SUCCESS */
} else {
#if ENABLE_HUSH_JOB
- if (run_list_level == 1 && interactive_fd) {
+ if (G.run_list_level == 1 && G.interactive_fd) {
/* waits for completion, then fg's main shell */
rcode = checkjobs_and_fg_shell(pi);
debug_printf_exec(": checkjobs_and_fg_shell returned %d\n", rcode);
}
}
debug_printf_exec(": setting last_return_code=%d\n", rcode);
- last_return_code = rcode;
+ G.last_return_code = rcode;
/* Analyze how result affects subsequent commands */
#if ENABLE_HUSH_IF
} /* for (pi) */
#if ENABLE_HUSH_JOB
- if (ctrl_z_flag) {
+ if (G.ctrl_z_flag) {
/* ctrl-Z forked somewhere in the past, we are the child,
* and now we completed running the list. Exit. */
//TODO: _exit?
exit(rcode);
}
ret:
- if (!--run_list_level && interactive_fd) {
+ if (!--G.run_list_level && G.interactive_fd) {
signal(SIGTSTP, SIG_IGN);
signal(SIGINT, SIG_IGN);
}
#endif
- debug_printf_exec("run_list lvl %d return %d\n", run_list_level + 1, rcode);
+ debug_printf_exec("run_list lvl %d return %d\n", G.run_list_level + 1, rcode);
#if ENABLE_HUSH_LOOPS
if (loop_top)
- depth_of_loop--;
+ G.depth_of_loop--;
free(for_list);
#endif
#if ENABLE_HUSH_CASE
{
int rcode = 0;
debug_printf_exec("run_and_free_list entered\n");
- if (!fake_mode) {
+ if (!G.fake_mode) {
debug_printf_exec(": run_list with %d members\n", pi->num_progs);
rcode = run_list(pi);
}
* Caller can deallocate entire list by single free(list). */
/* Store given string, finalizing the word and starting new one whenever
- * we encounter ifs char(s). This is used for expanding variable values.
+ * we encounter IFS char(s). This is used for expanding variable values.
* End-of-string does NOT finalize word: think about 'echo -$VAR-' */
static int expand_on_ifs(o_string *output, int n, const char *str)
{
while (1) {
- int word_len = strcspn(str, ifs);
+ int word_len = strcspn(str, G.ifs);
if (word_len) {
if (output->o_quote || !output->o_glob)
o_addQstr(output, str, word_len);
o_addchr(output, '\0');
debug_print_list("expand_on_ifs", output, n);
n = o_save_ptr(output, n);
- str += strspn(str, ifs); /* skip ifs chars */
+ str += strspn(str, G.ifs); /* skip ifs chars */
}
debug_print_list("expand_on_ifs[1]", output, n);
return n;
switch (first_ch & 0x7f) {
/* Highest bit in first_ch indicates that var is double-quoted */
case '$': /* pid */
- val = utoa(root_pid);
+ val = utoa(G.root_pid);
break;
case '!': /* bg pid */
- val = last_bg_pid ? utoa(last_bg_pid) : (char*)"";
+ val = G.last_bg_pid ? utoa(G.last_bg_pid) : (char*)"";
break;
case '?': /* exitcode */
- val = utoa(last_return_code);
+ val = utoa(G.last_return_code);
break;
case '#': /* argc */
- val = utoa(global_argc ? global_argc-1 : 0);
+ val = utoa(G.global_argc ? G.global_argc-1 : 0);
break;
case '*':
case '@':
i = 1;
- if (!global_argv[i])
+ if (!G.global_argv[i])
break;
ored_ch |= first_ch; /* do it for "$@" _now_, when we know it's not empty */
if (!(first_ch & 0x80)) { /* unquoted $* or $@ */
smallint sv = output->o_quote;
/* unquoted var's contents should be globbed, so don't quote */
output->o_quote = 0;
- while (global_argv[i]) {
- n = expand_on_ifs(output, n, global_argv[i]);
- debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, global_argc-1);
- if (global_argv[i++][0] && global_argv[i]) {
+ while (G.global_argv[i]) {
+ n = expand_on_ifs(output, n, G.global_argv[i]);
+ debug_printf_expand("expand_vars_to_list: argv %d (last %d)\n", i, G.global_argc - 1);
+ if (G.global_argv[i++][0] && G.global_argv[i]) {
/* this argv[] is not empty and not last:
* put terminating NUL, start new word */
o_addchr(output, '\0');
* and in this case should treat it like '$*' - see 'else...' below */
if (first_ch == ('@'|0x80) && !or_mask) { /* quoted $@ */
while (1) {
- o_addQstr(output, global_argv[i], strlen(global_argv[i]));
- if (++i >= global_argc)
+ o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
+ if (++i >= G.global_argc)
break;
o_addchr(output, '\0');
debug_print_list("expand_vars_to_list[4]", output, n);
}
} else { /* quoted $*: add as one word */
while (1) {
- o_addQstr(output, global_argv[i], strlen(global_argv[i]));
- if (!global_argv[++i])
+ o_addQstr(output, G.global_argv[i], strlen(G.global_argv[i]));
+ if (!G.global_argv[++i])
break;
- if (ifs[0])
- o_addchr(output, ifs[0]);
+ if (G.ifs[0])
+ o_addchr(output, G.ifs[0]);
}
}
break;
arg[0] = first_ch & 0x7f;
if (isdigit(arg[0])) {
i = xatoi_u(arg);
- if (i < global_argc)
- val = global_argv[i];
+ if (i < G.global_argc)
+ val = G.global_argv[i];
/* else val remains NULL: $N with too big N */
} else
val = lookup_param(arg);
if (HUSH_DEBUG)
if (list[n-1] + strlen(list[n-1]) + 1 != list[n])
bb_error_msg_and_die("BUG in varexp3");
- list[n][-1] = ' '; /* TODO: or to ifs[0]? */
+ list[n][-1] = ' '; /* TODO: or to G.ifs[0]? */
n++;
}
}
if (!name)
return NULL;
len = strlen(name);
- for (cur = top_var; cur; cur = cur->next) {
+ for (cur = G.top_var; cur; cur = cur->next) {
if (strncmp(cur->varstr, name, len) == 0 && cur->varstr[len] == '=')
return cur;
}
}
name_len = value - str + 1; /* including '=' */
- cur = top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
+ cur = G.top_var; /* cannot be NULL (we have HUSH_VERSION and it's RO) */
while (1) {
if (strncmp(cur->varstr, str, name_len) != 0) {
if (!cur->next) {
if (!name)
return;
name_len = strlen(name);
- cur = top_var;
+ cur = G.top_var;
while (cur) {
if (strncmp(cur->varstr, name, name_len) == 0 && cur->varstr[name_len] == '=') {
if (cur->flg_read_only) {
xmove_fd(channel[1], 1);
/* Prevent it from trying to handle ctrl-z etc */
#if ENABLE_HUSH_JOB
- run_list_level = 1;
+ G.run_list_level = 1;
#endif
/* Process substitution is not considered to be usual
* 'command execution'.
next = '\0';
ch = i_getch(input);
if (ch != EOF) {
- m = charmap[ch];
+ m = G.charmap[ch];
if (ch != '\n') {
next = i_peek(input);
}
static void set_in_charmap(const char *set, int code)
{
while (*set)
- charmap[(unsigned char)*set++] = code;
+ G.charmap[(unsigned char)*set++] = code;
}
static void update_charmap(void)
{
- /* char *ifs and char charmap[256] are both globals. */
- ifs = getenv("IFS");
- if (ifs == NULL)
- ifs = " \t\n";
+ G.ifs = getenv("IFS");
+ if (G.ifs == NULL)
+ G.ifs = " \t\n";
/* Precompute a list of 'flow through' behavior so it can be treated
* quickly up front. Computation is necessary because of IFS.
* Special case handling of IFS == " \t\n" is not implemented.
* The charmap[] array only really needs two bits each,
* and on most machines that would be faster (reduced L1 cache use).
*/
- memset(charmap, CHAR_ORDINARY, sizeof(charmap));
+ memset(G.charmap, CHAR_ORDINARY, sizeof(G.charmap));
#if ENABLE_HUSH_TICK
set_in_charmap("\\$\"`", CHAR_SPECIAL);
#else
set_in_charmap("\\$\"", CHAR_SPECIAL);
#endif
set_in_charmap("<>;&|(){}#'", CHAR_ORDINARY_IF_QUOTED);
- set_in_charmap(ifs, CHAR_IFS); /* are ordinary if quoted */
+ set_in_charmap(G.ifs, CHAR_IFS); /* are ordinary if quoted */
}
/* Most recursion does not come through here, the exception is
{
pid_t shell_pgrp;
- saved_task_pgrp = shell_pgrp = getpgrp();
- debug_printf_jobs("saved_task_pgrp=%d\n", saved_task_pgrp);
- close_on_exec_on(interactive_fd);
+// G.saved_task_pgrp =
+ shell_pgrp = getpgrp();
+// debug_printf_jobs("saved_task_pgrp=%d\n", G.saved_task_pgrp);
+ close_on_exec_on(G.interactive_fd);
/* If we were ran as 'hush &',
* sleep until we are in the foreground. */
- while (tcgetpgrp(interactive_fd) != shell_pgrp) {
+ while (tcgetpgrp(G.interactive_fd) != shell_pgrp) {
/* Send TTIN to ourself (should stop us) */
kill(- shell_pgrp, SIGTTIN);
shell_pgrp = getpgrp();
/* Put ourselves in our own process group. */
setpgrp(); /* is the same as setpgid(our_pid, our_pid); */
/* Grab control of the terminal. */
- tcsetpgrp(interactive_fd, getpid());
+ tcsetpgrp(G.interactive_fd, getpid());
}
#endif
INIT_G();
- root_pid = getpid();
+ G.root_pid = getpid();
/* Deal with HUSH_VERSION */
- shell_ver = const_shell_ver; /* copying struct here */
- top_var = &shell_ver;
+ G.shell_ver = const_shell_ver; /* copying struct here */
+ G.top_var = &G.shell_ver;
unsetenv("HUSH_VERSION"); /* in case it exists in initial env */
/* Initialize our shell local variables with the values
* currently living in the environment */
- cur_var = top_var;
+ cur_var = G.top_var;
e = environ;
if (e) while (*e) {
char *value = strchr(*e, '=');
putenv((char *)version_str); /* reinstate HUSH_VERSION */
#if ENABLE_FEATURE_EDITING
- line_input_state = new_line_input_t(FOR_SHELL);
+ G.line_input_state = new_line_input_t(FOR_SHELL);
#endif
/* XXX what should these be while sourcing /etc/profile? */
- global_argc = argc;
- global_argv = argv;
+ G.global_argc = argc;
+ G.global_argv = argv;
/* Initialize some more globals to non-zero values */
set_cwd();
#if ENABLE_HUSH_INTERACTIVE
#if ENABLE_FEATURE_EDITING
cmdedit_set_initial_prompt();
#endif
- PS2 = "> ";
+ G.PS2 = "> ";
#endif
if (EXIT_SUCCESS) /* otherwise is already done */
- last_return_code = EXIT_SUCCESS;
+ G.last_return_code = EXIT_SUCCESS;
if (argv[0] && argv[0][0] == '-') {
debug_printf("sourcing /etc/profile\n");
while ((opt = getopt(argc, argv, "c:xif")) > 0) {
switch (opt) {
case 'c':
- global_argv = argv + optind;
- global_argc = argc - optind;
+ G.global_argv = argv + optind;
+ G.global_argc = argc - optind;
opt = parse_and_run_string(optarg, 0 /* parse_flag */);
goto final_return;
case 'i':
/* Well, we cannot just declare interactiveness,
* we have to have some stuff (ctty, etc) */
- /* interactive_fd++; */
+ /* G.interactive_fd++; */
break;
case 'f':
- fake_mode = 1;
+ G.fake_mode = 1;
break;
default:
#ifndef BB_VER
if (argv[optind] == NULL && input == stdin
&& isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
) {
- saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
- debug_printf("saved_tty_pgrp=%d\n", saved_tty_pgrp);
- if (saved_tty_pgrp >= 0) {
+ G.saved_tty_pgrp = tcgetpgrp(STDIN_FILENO);
+ debug_printf("saved_tty_pgrp=%d\n", G.saved_tty_pgrp);
+ if (G.saved_tty_pgrp >= 0) {
/* try to dup to high fd#, >= 255 */
- interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
- if (interactive_fd < 0) {
+ G.interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
+ if (G.interactive_fd < 0) {
/* try to dup to any fd */
- interactive_fd = dup(STDIN_FILENO);
- if (interactive_fd < 0)
+ G.interactive_fd = dup(STDIN_FILENO);
+ if (G.interactive_fd < 0)
/* give up */
- interactive_fd = 0;
+ G.interactive_fd = 0;
}
// TODO: track & disallow any attempts of user
// to (inadvertently) close/redirect it
}
}
- debug_printf("interactive_fd=%d\n", interactive_fd);
- if (interactive_fd) {
- fcntl(interactive_fd, F_SETFD, FD_CLOEXEC);
+ debug_printf("G.interactive_fd=%d\n", G.interactive_fd);
+ if (G.interactive_fd) {
+ fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
/* Looks like they want an interactive shell */
setup_job_control();
/* -1 is special - makes xfuncs longjmp, not exit
if (argv[optind] == NULL && input == stdin
&& isatty(STDIN_FILENO) && isatty(STDOUT_FILENO)
) {
- interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
- if (interactive_fd < 0) {
+ G.interactive_fd = fcntl(STDIN_FILENO, F_DUPFD, 255);
+ if (G.interactive_fd < 0) {
/* try to dup to any fd */
- interactive_fd = dup(STDIN_FILENO);
- if (interactive_fd < 0)
+ G.interactive_fd = dup(STDIN_FILENO);
+ if (G.interactive_fd < 0)
/* give up */
- interactive_fd = 0;
+ G.interactive_fd = 0;
}
- if (interactive_fd) {
- fcntl(interactive_fd, F_SETFD, FD_CLOEXEC);
+ if (G.interactive_fd) {
+ fcntl(G.interactive_fd, F_SETFD, FD_CLOEXEC);
set_misc_sighandler(SIG_IGN);
}
}
opt = parse_and_run_file(stdin);
} else {
debug_printf("\nrunning script '%s'\n", argv[optind]);
- global_argv = argv + optind;
- global_argc = argc - optind;
+ G.global_argv = argv + optind;
+ G.global_argc = argc - optind;
input = xfopen_for_read(argv[optind]);
fcntl(fileno(input), F_SETFD, FD_CLOEXEC);
opt = parse_and_run_file(input);
#if ENABLE_FEATURE_CLEAN_UP
fclose(input);
- if (cwd != bb_msg_unknown)
- free((char*)cwd);
- cur_var = top_var->next;
+ if (G.cwd != bb_msg_unknown)
+ free((char*)G.cwd);
+ cur_var = G.top_var->next;
while (cur_var) {
struct variable *tmp = cur_var;
if (!cur_var->max_len)
free(tmp);
}
#endif
- hush_exit(opt ? opt : last_return_code);
+ hush_exit(opt ? opt : G.last_return_code);
}
char *str = expand_strvec_to_string(argv + 1);
parse_and_run_string(str, PARSEFLAG_EXIT_FROM_LOOP);
free(str);
- rcode = last_return_code;
+ rcode = G.last_return_code;
}
return rcode;
}
// TODO: warn if we have background jobs: "There are stopped jobs"
// On second consecutive 'exit', exit anyway.
if (argv[1] == NULL)
- hush_exit(last_return_code);
+ hush_exit(G.last_return_code);
/* mimic bash: exit 123abc == exit 255 + error msg */
xfunc_error_retval = 255;
/* bash: exit -2 == exit 254, no error msg */
int i, jobnum;
struct pipe *pi;
- if (!interactive_fd)
+ if (!G.interactive_fd)
return EXIT_FAILURE;
/* If they gave us no args, assume they want the last backgrounded task */
if (!argv[1]) {
- for (pi = job_list; pi; pi = pi->next) {
- if (pi->jobid == last_jobid) {
+ for (pi = G.job_list; pi; pi = pi->next) {
+ if (pi->jobid == G.last_jobid) {
goto found;
}
}
bb_error_msg("%s: bad argument '%s'", argv[0], argv[1]);
return EXIT_FAILURE;
}
- for (pi = job_list; pi; pi = pi->next) {
+ for (pi = G.job_list; pi; pi = pi->next) {
if (pi->jobid == jobnum) {
goto found;
}
// of job being foregrounded (like "sleep 1 | cat")
if (*argv[0] == 'f') {
/* Put the job into the foreground. */
- tcsetpgrp(interactive_fd, pi->pgrp);
+ tcsetpgrp(G.interactive_fd, pi->pgrp);
}
/* Restart the processes in the job */
struct pipe *job;
const char *status_string;
- for (job = job_list; job; job = job->next) {
+ for (job = G.job_list; job; job = job->next) {
if (job->alive_progs == job->stopped_progs)
status_string = "Stopped";
else
struct variable *e;
if (temp == NULL)
- for (e = top_var; e; e = e->next)
+ for (e = G.top_var; e; e = e->next)
puts(e->varstr);
else
set_local_var(xstrdup(temp), 0);
if (argv[1]) {
n = atoi(argv[1]);
}
- if (n >= 0 && n < global_argc) {
- global_argv[n] = global_argv[0];
- global_argc -= n;
- global_argv += n;
+ if (n >= 0 && n < G.global_argc) {
+ G.global_argv[n] = G.global_argv[0];
+ G.global_argc -= n;
+ G.global_argv += n;
return EXIT_SUCCESS;
}
return EXIT_FAILURE;
close_on_exec_on(fileno(input));
/* Now run the file */
- /* XXX argv and argc are broken; need to save old global_argv
+ /* XXX argv and argc are broken; need to save old G.global_argv
* (pointer only is OK!) on this stack frame,
- * set global_argv=argv+1, recurse, and restore. */
+ * set G.global_argv=argv+1, recurse, and restore. */
status = parse_and_run_file(input);
fclose(input);
return status;
#if ENABLE_HUSH_LOOPS
static int builtin_break(char **argv)
{
- if (depth_of_loop == 0) {
+ if (G.depth_of_loop == 0) {
bb_error_msg("%s: only meaningful in a loop", "break");
return EXIT_SUCCESS; /* bash compat */
}
- flag_break_continue++; /* BC_BREAK = 1 */
- depth_break_continue = 1;
+ G.flag_break_continue++; /* BC_BREAK = 1 */
+ G.depth_break_continue = 1;
if (argv[1]) {
- depth_break_continue = bb_strtou(argv[1], NULL, 10);
- if (errno || !depth_break_continue || argv[2]) {
+ G.depth_break_continue = bb_strtou(argv[1], NULL, 10);
+ if (errno || !G.depth_break_continue || argv[2]) {
bb_error_msg("bad arguments");
- flag_break_continue = BC_BREAK;
- depth_break_continue = UINT_MAX;
+ G.flag_break_continue = BC_BREAK;
+ G.depth_break_continue = UINT_MAX;
}
}
- if (depth_of_loop < depth_break_continue)
- depth_break_continue = depth_of_loop;
+ if (G.depth_of_loop < G.depth_break_continue)
+ G.depth_break_continue = G.depth_of_loop;
return EXIT_SUCCESS;
}
static int builtin_continue(char **argv)
{
- if (depth_of_loop) {
- flag_break_continue++; /* BC_CONTINUE = 2 = 1+1 */
+ if (G.depth_of_loop) {
+ G.flag_break_continue = 1; /* BC_CONTINUE = 2 = 1+1 */
return builtin_break(argv);
}
bb_error_msg("%s: only meaningful in a loop", "continue");
projects / oweals / busybox.git / commitdiff