lash.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * lash -- the BusyBox Lame-Ass SHell
   4  *
   5  * Copyright (C) 1999,2000,2001 by Lineo, inc.
   6  * Written by Erik Andersen <andersen@lineo.com>, <andersee@debian.org>
   7  *
   8  * Based in part on ladsh.c by Michael K. Johnson and Erik W. Troan, which is
   9  * under the following liberal license: "We have placed this source code in the
  10  * public domain. Use it in any project, free or commercial."
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  20  * General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  25  *
  26  */
  27
  28 /* This shell's parsing engine is officially at a dead-end.
  29  * Future work shell work should be done using hush.c
  30  */
  31
  32 //For debugging/development on the shell only...
  33 //#define DEBUG_SHELL
  34
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <ctype.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <signal.h>
  42 #include <string.h>
  43 #include <sys/ioctl.h>
  44 #include <sys/wait.h>
  45 #include <unistd.h>
  46 #include <getopt.h>
  47 #include <termios.h>
  48 #include "busybox.h"
  49 #include "cmdedit.h"
  50
  51 #ifdef BB_LOCALE_SUPPORT
  52 #include <locale.h>
  53 #endif
  54
  55 #include <glob.h>
  56 #define expand_t        glob_t
  57
  58
  59 static const int MAX_READ = 128;        /* size of input buffer for `read' builtin */
  60 #define JOB_STATUS_FORMAT "[%d] %-22s %.40s\n"
  61
  62
  63 enum redir_type { REDIRECT_INPUT, REDIRECT_OVERWRITE,
  64         REDIRECT_APPEND
  65 };
  66
  67 static const unsigned int DEFAULT_CONTEXT=0x1;
  68 static const unsigned int IF_TRUE_CONTEXT=0x2;
  69 static const unsigned int IF_FALSE_CONTEXT=0x4;
  70 static const unsigned int THEN_EXP_CONTEXT=0x8;
  71 static const unsigned int ELSE_EXP_CONTEXT=0x10;
  72
  73
  74 struct jobset {
  75         struct job *head;                       /* head of list of running jobs */
  76         struct job *fg;                         /* current foreground job */
  77 };
  78
  79 struct redir_struct {
  80         enum redir_type type;   /* type of redirection */
  81         int fd;                                         /* file descriptor being redirected */
  82         char *filename;                         /* file to redirect fd to */
  83 };
  84
  85 struct child_prog {
  86         pid_t pid;                                      /* 0 if exited */
  87         char **argv;                            /* program name and arguments */
  88         int num_redirects;                      /* elements in redirection array */
  89         struct redir_struct *redirects; /* I/O redirects */
  90         int is_stopped;                         /* is the program currently running? */
  91         struct job *family;                     /* pointer back to the child's parent job */
  92 };
  93
  94 struct job {
  95         int jobid;                                      /* job number */
  96         int num_progs;                          /* total number of programs in job */
  97         int running_progs;                      /* number of programs running */
  98         char *text;                                     /* name of job */
  99         char *cmdbuf;                           /* buffer various argv's point into */
 100         pid_t pgrp;                                     /* process group ID for the job */
 101         struct child_prog *progs;       /* array of programs in job */
 102         struct job *next;                       /* to track background commands */
 103         int stopped_progs;                      /* number of programs alive, but stopped */
 104         unsigned int job_context;       /* bitmask defining current context */
 105         struct jobset *job_list;
 106 };
 107
 108 struct built_in_command {
 109         char *cmd;                                      /* name */
 110         char *descr;                            /* description */
 111         int (*function) (struct child_prog *);  /* function ptr */
 112 };
 113
 114 struct close_me {
 115         int fd;
 116         struct close_me *next;
 117 };
 118
 119 /* function prototypes for builtins */
 120 static int builtin_cd(struct child_prog *cmd);
 121 static int builtin_exec(struct child_prog *cmd);
 122 static int builtin_exit(struct child_prog *cmd);
 123 static int builtin_fg_bg(struct child_prog *cmd);
 124 static int builtin_help(struct child_prog *cmd);
 125 static int builtin_jobs(struct child_prog *dummy);
 126 static int builtin_pwd(struct child_prog *dummy);
 127 static int builtin_export(struct child_prog *cmd);
 128 static int builtin_source(struct child_prog *cmd);
 129 static int builtin_unset(struct child_prog *cmd);
 130 static int builtin_read(struct child_prog *cmd);
 131
 132
 133 /* function prototypes for shell stuff */
 134 static void mark_open(int fd);
 135 static void mark_closed(int fd);
 136 static void close_all(void);
 137 static void checkjobs(struct jobset *job_list);
 138 static void remove_job(struct jobset *j_list, struct job *job);
 139 static int get_command(FILE * source, char *command);
 140 static int parse_command(char **command_ptr, struct job *job, int *inbg);
 141 static int run_command(struct job *newjob, int inbg, int outpipe[2]);
 142 static int pseudo_exec(struct child_prog *cmd) __attribute__ ((noreturn));
 143 static int busy_loop(FILE * input);
 144
 145
 146 /* Table of built-in functions (these are non-forking builtins, meaning they
 147  * can change global variables in the parent shell process but they will not
 148  * work with pipes and redirects; 'unset foo | whatever' will not work) */
 149 static struct built_in_command bltins[] = {
 150         {"bg", "Resume a job in the background", builtin_fg_bg},
 151         {"cd", "Change working directory", builtin_cd},
 152         {"exec", "Exec command, replacing this shell with the exec'd process", builtin_exec},
 153         {"exit", "Exit from shell()", builtin_exit},
 154         {"fg", "Bring job into the foreground", builtin_fg_bg},
 155         {"jobs", "Lists the active jobs", builtin_jobs},
 156         {"export", "Set environment variable", builtin_export},
 157         {"unset", "Unset environment variable", builtin_unset},
 158         {"read", "Input environment variable", builtin_read},
 159         {".", "Source-in and run commands in a file", builtin_source},
 160         /* to do: add ulimit */
 161         {NULL, NULL, NULL}
 162 };
 163
 164 /* Table of forking built-in functions (things that fork cannot change global
 165  * variables in the parent process, such as the current working directory) */
 166 static struct built_in_command bltins_forking[] = {
 167         {"pwd", "Print current directory", builtin_pwd},
 168         {"help", "List shell built-in commands", builtin_help},
 169         {NULL, NULL, NULL}
 170 };
 171
 172
 173 /* Variables we export */
 174 unsigned int shell_context;  /* Used in cmdedit.c to reset the
 175                                                                 context when someone hits ^C */
 176
 177
 178 /* Globals that are static to this file */
 179 static const char *cwd;
 180 static char *local_pending_command = NULL;
 181 static struct jobset job_list = { NULL, NULL };
 182 static int argc;
 183 static char **argv;
 184 static struct close_me *close_me_head;
 185 static int last_return_code;
 186 static int last_bg_pid;
 187 static unsigned int last_jobid;
 188 static int shell_terminal;
 189 static pid_t shell_pgrp;
 190 static char *PS1;
 191 static char *PS2 = "> ";
 192
 193
 194 #ifdef DEBUG_SHELL
 195 static inline void debug_printf(const char *format, ...)
 196 {
 197         va_list args;
 198         va_start(args, format);
 199         vfprintf(stderr, format, args);
 200         va_end(args);
 201 }
 202 #else
 203 static inline void debug_printf(const char *format, ...) { }
 204 #endif
 205
 206 /*
 207         Most builtins need access to the struct child_prog that has
 208         their arguments, previously coded as cmd->progs[0].  That coding
 209         can exhibit a bug, if the builtin is not the first command in
 210         a pipeline: "echo foo | exec sort" will attempt to exec foo.
 211
 212 builtin   previous use      notes
 213 ------ -----------------  ---------
 214 cd      cmd->progs[0]
 215 exec    cmd->progs[0]  squashed bug: didn't look for applets or forking builtins
 216 exit    cmd->progs[0]
 217 fg_bg   cmd->progs[0], job_list->head, job_list->fg
 218 help    0
 219 jobs    job_list->head
 220 pwd     0
 221 export  cmd->progs[0]
 222 source  cmd->progs[0]
 223 unset   cmd->progs[0]
 224 read    cmd->progs[0]
 225
 226 I added "struct job *family;" to struct child_prog,
 227 and switched API to builtin_foo(struct child_prog *child);
 228 So   cmd->text        becomes  child->family->text
 229      cmd->job_context  becomes  child->family->job_context
 230      cmd->progs[0]    becomes  *child
 231      job_list          becomes  child->family->job_list
 232  */
 233
 234 /* built-in 'cd <path>' handler */
 235 static int builtin_cd(struct child_prog *child)
 236 {
 237         char *newdir;
 238
 239         if (child->argv[1] == NULL)
 240                 newdir = getenv("HOME");
 241         else
 242                 newdir = child->argv[1];
 243         if (chdir(newdir)) {
 244                 printf("cd: %s: %m\n", newdir);
 245                 return EXIT_FAILURE;
 246         }
 247         cwd = xgetcwd((char *)cwd);
 248         if (!cwd)
 249                 cwd = unknown;
 250         return EXIT_SUCCESS;
 251 }
 252
 253 /* built-in 'exec' handler */
 254 static int builtin_exec(struct child_prog *child)
 255 {
 256         if (child->argv[1] == NULL)
 257                 return EXIT_SUCCESS;   /* Really? */
 258         child->argv++;
 259         close_all();
 260         pseudo_exec(child);
 261         /* never returns */
 262 }
 263
 264 /* built-in 'exit' handler */
 265 static int builtin_exit(struct child_prog *child)
 266 {
 267         if (child->argv[1] == NULL)
 268                 exit(EXIT_SUCCESS);
 269
 270         exit (atoi(child->argv[1]));
 271 }
 272
 273 /* built-in 'fg' and 'bg' handler */
 274 static int builtin_fg_bg(struct child_prog *child)
 275 {
 276         int i, jobnum;
 277         struct job *job=NULL;
 278
 279         /* If they gave us no args, assume they want the last backgrounded task */
 280         if (!child->argv[1]) {
 281                 for (job = child->family->job_list->head; job; job = job->next) {
 282                         if (job->jobid == last_jobid) {
 283                                 break;
 284                         }
 285                 }
 286                 if (!job) {
 287                         error_msg("%s: no current job", child->argv[0]);
 288                         return EXIT_FAILURE;
 289                 }
 290         } else {
 291                 if (sscanf(child->argv[1], "%%%d", &jobnum) != 1) {
 292                         error_msg("%s: bad argument '%s'", child->argv[0], child->argv[1]);
 293                         return EXIT_FAILURE;
 294                 }
 295                 for (job = child->family->job_list->head; job; job = job->next) {
 296                         if (job->jobid == jobnum) {
 297                                 break;
 298                         }
 299                 }
 300                 if (!job) {
 301                         error_msg("%s: %d: no such job", child->argv[0], jobnum);
 302                         return EXIT_FAILURE;
 303                 }
 304         }
 305
 306         if (*child->argv[0] == 'f') {
 307                 /* Put the job into the foreground.  */
 308                 tcsetpgrp(shell_terminal, job->pgrp);
 309
 310                 child->family->job_list->fg = job;
 311         }
 312
 313         /* Restart the processes in the job */
 314         for (i = 0; i < job->num_progs; i++)
 315                 job->progs[i].is_stopped = 0;
 316
 317         job->stopped_progs = 0;
 318
 319         if ( (i=kill(- job->pgrp, SIGCONT)) < 0) {
 320                 if (i == ESRCH) {
 321                         remove_job(&job_list, job);
 322                 }
 323                 perror_msg("kill (SIGCONT)");
 324         }
 325
 326         return EXIT_SUCCESS;
 327 }
 328
 329 /* built-in 'help' handler */
 330 static int builtin_help(struct child_prog *dummy)
 331 {
 332         struct built_in_command *x;
 333
 334         printf("\nBuilt-in commands:\n");
 335         printf("-------------------\n");
 336         for (x = bltins; x->cmd; x++) {
 337                 if (x->descr==NULL)
 338                         continue;
 339                 printf("%s\t%s\n", x->cmd, x->descr);
 340         }
 341         for (x = bltins_forking; x->cmd; x++) {
 342                 if (x->descr==NULL)
 343                         continue;
 344                 printf("%s\t%s\n", x->cmd, x->descr);
 345         }
 346         printf("\n\n");
 347         return EXIT_SUCCESS;
 348 }
 349
 350 /* built-in 'jobs' handler */
 351 static int builtin_jobs(struct child_prog *child)
 352 {
 353         struct job *job;
 354         char *status_string;
 355
 356         for (job = child->family->job_list->head; job; job = job->next) {
 357                 if (job->running_progs == job->stopped_progs)
 358                         status_string = "Stopped";
 359                 else
 360                         status_string = "Running";
 361
 362                 printf(JOB_STATUS_FORMAT, job->jobid, status_string, job->text);
 363         }
 364         return EXIT_SUCCESS;
 365 }
 366
 367
 368 /* built-in 'pwd' handler */
 369 static int builtin_pwd(struct child_prog *dummy)
 370 {
 371         cwd = xgetcwd((char *)cwd);
 372         if (!cwd)
 373                 cwd = unknown;
 374         puts(cwd);
 375         return EXIT_SUCCESS;
 376 }
 377
 378 /* built-in 'export VAR=value' handler */
 379 static int builtin_export(struct child_prog *child)
 380 {
 381         int res;
 382         char *v = child->argv[1];
 383
 384         if (v == NULL) {
 385                 char **e;
 386                 for (e = environ; *e; e++) {
 387                         puts(*e);
 388                 }
 389                 return 0;
 390         }
 391         res = putenv(v);
 392         if (res)
 393                 fprintf(stderr, "export: %m\n");
 394 #ifdef BB_FEATURE_SH_FANCY_PROMPT
 395         if (strncmp(v, "PS1=", 4)==0)
 396                 PS1 = getenv("PS1");
 397 #endif
 398
 399 #ifdef BB_LOCALE_SUPPORT
 400         if(strncmp(v, "LC_ALL=", 7)==0)
 401                 setlocale(LC_ALL, getenv("LC_ALL"));
 402         if(strncmp(v, "LC_CTYPE=", 9)==0)
 403                 setlocale(LC_CTYPE, getenv("LC_CTYPE"));
 404 #endif
 405
 406         return (res);
 407 }
 408
 409 /* built-in 'read VAR' handler */
 410 static int builtin_read(struct child_prog *child)
 411 {
 412         int res = 0, len, newlen;
 413         char *s;
 414         char string[MAX_READ];
 415
 416         if (child->argv[1]) {
 417                 /* argument (VAR) given: put "VAR=" into buffer */
 418                 strcpy(string, child->argv[1]);
 419                 len = strlen(string);
 420                 string[len++] = '=';
 421                 string[len]   = '\0';
 422                 fgets(&string[len], sizeof(string) - len, stdin);       /* read string */
 423                 newlen = strlen(string);
 424                 if(newlen > len)
 425                         string[--newlen] = '\0';        /* chomp trailing newline */
 426                 /*
 427                 ** string should now contain "VAR=<value>"
 428                 ** copy it (putenv() won't do that, so we must make sure
 429                 ** the string resides in a static buffer!)
 430                 */
 431                 res = -1;
 432                 if((s = strdup(string)))
 433                         res = putenv(s);
 434                 if (res)
 435                         fprintf(stderr, "read: %m\n");
 436         }
 437         else
 438                 fgets(string, sizeof(string), stdin);
 439
 440         return (res);
 441 }
 442
 443 /* Built-in '.' handler (read-in and execute commands from file) */
 444 static int builtin_source(struct child_prog *child)
 445 {
 446         FILE *input;
 447         int status;
 448         int fd;
 449
 450         if (child->argv[1] == NULL)
 451                 return EXIT_FAILURE;
 452
 453         input = fopen(child->argv[1], "r");
 454         if (!input) {
 455                 printf( "Couldn't open file '%s'\n", child->argv[1]);
 456                 return EXIT_FAILURE;
 457         }
 458
 459         fd=fileno(input);
 460         mark_open(fd);
 461         /* Now run the file */
 462         status = busy_loop(input);
 463         fclose(input);
 464         mark_closed(fd);
 465         return (status);
 466 }
 467
 468 /* built-in 'unset VAR' handler */
 469 static int builtin_unset(struct child_prog *child)
 470 {
 471         if (child->argv[1] == NULL) {
 472                 printf( "unset: parameter required.\n");
 473                 return EXIT_FAILURE;
 474         }
 475         unsetenv(child->argv[1]);
 476         return EXIT_SUCCESS;
 477 }
 478
 479 static void mark_open(int fd)
 480 {
 481         struct close_me *new = xmalloc(sizeof(struct close_me));
 482         new->fd = fd;
 483         new->next = close_me_head;
 484         close_me_head = new;
 485 }
 486
 487 static void mark_closed(int fd)
 488 {
 489         struct close_me *tmp;
 490         if (close_me_head == NULL || close_me_head->fd != fd)
 491                 error_msg_and_die("corrupt close_me");
 492         tmp = close_me_head;
 493         close_me_head = close_me_head->next;
 494         free(tmp);
 495 }
 496
 497 static void close_all()
 498 {
 499         struct close_me *c, *tmp;
 500         for (c=close_me_head; c; c=tmp) {
 501                 close(c->fd);
 502                 tmp=c->next;
 503                 free(c);
 504         }
 505         close_me_head = NULL;
 506 }
 507
 508
 509 /* free up all memory from a job */
 510 static void free_job(struct job *cmd)
 511 {
 512         int i;
 513         struct jobset *keep;
 514
 515         for (i = 0; i < cmd->num_progs; i++) {
 516                 free(cmd->progs[i].argv);
 517                 if (cmd->progs[i].redirects)
 518                         free(cmd->progs[i].redirects);
 519         }
 520         if (cmd->progs)
 521                 free(cmd->progs);
 522         if (cmd->text)
 523                 free(cmd->text);
 524         if (cmd->cmdbuf)
 525                 free(cmd->cmdbuf);
 526         keep = cmd->job_list;
 527         memset(cmd, 0, sizeof(struct job));
 528         cmd->job_list = keep;
 529 }
 530
 531 /* remove a job from a jobset */
 532 static void remove_job(struct jobset *j_list, struct job *job)
 533 {
 534         struct job *prevjob;
 535
 536         free_job(job);
 537         if (job == j_list->head) {
 538                 j_list->head = job->next;
 539         } else {
 540                 prevjob = j_list->head;
 541                 while (prevjob->next != job)
 542                         prevjob = prevjob->next;
 543                 prevjob->next = job->next;
 544         }
 545
 546         if (j_list->head)
 547                 last_jobid = j_list->head->jobid;
 548         else
 549                 last_jobid = 0;
 550
 551         free(job);
 552 }
 553
 554 /* Checks to see if any background processes have exited -- if they
 555    have, figure out why and see if a job has completed */
 556 static void checkjobs(struct jobset *j_list)
 557 {
 558         struct job *job;
 559         pid_t childpid;
 560         int status;
 561         int prognum = 0;
 562
 563         while ((childpid = waitpid(-1, &status, WNOHANG | WUNTRACED)) > 0) {
 564                 for (job = j_list->head; job; job = job->next) {
 565                         prognum = 0;
 566                         while (prognum < job->num_progs &&
 567                                    job->progs[prognum].pid != childpid) prognum++;
 568                         if (prognum < job->num_progs)
 569                                 break;
 570                 }
 571
 572                 /* This happens on backticked commands */
 573                 if(job==NULL)
 574                         return;
 575
 576                 if (WIFEXITED(status) || WIFSIGNALED(status)) {
 577                         /* child exited */
 578                         job->running_progs--;
 579                         job->progs[prognum].pid = 0;
 580
 581                         if (!job->running_progs) {
 582                                 printf(JOB_STATUS_FORMAT, job->jobid, "Done", job->text);
 583                                 last_jobid=0;
 584                                 remove_job(j_list, job);
 585                         }
 586                 } else {
 587                         /* child stopped */
 588                         job->stopped_progs++;
 589                         job->progs[prognum].is_stopped = 1;
 590
 591 #if 0
 592                         /* Printing this stuff is a pain, since it tends to
 593                          * overwrite the prompt an inconveinient moments.  So
 594                          * don't do that.  */
 595                         if (job->stopped_progs == job->num_progs) {
 596                                 printf(JOB_STATUS_FORMAT, job->jobid, "Stopped",
 597                                            job->text);
 598                         }
 599 #endif
 600                 }
 601         }
 602
 603         if (childpid == -1 && errno != ECHILD)
 604                 perror_msg("waitpid");
 605 }
 606
 607 /* squirrel != NULL means we squirrel away copies of stdin, stdout,
 608  * and stderr if they are redirected. */
 609 static int setup_redirects(struct child_prog *prog, int squirrel[])
 610 {
 611         int i;
 612         int openfd;
 613         int mode = O_RDONLY;
 614         struct redir_struct *redir = prog->redirects;
 615
 616         for (i = 0; i < prog->num_redirects; i++, redir++) {
 617                 switch (redir->type) {
 618                 case REDIRECT_INPUT:
 619                         mode = O_RDONLY;
 620                         break;
 621                 case REDIRECT_OVERWRITE:
 622                         mode = O_WRONLY | O_CREAT | O_TRUNC;
 623                         break;
 624                 case REDIRECT_APPEND:
 625                         mode = O_WRONLY | O_CREAT | O_APPEND;
 626                         break;
 627                 }
 628
 629                 openfd = open(redir->filename, mode, 0666);
 630                 if (openfd < 0) {
 631                         /* this could get lost if stderr has been redirected, but
 632                            bash and ash both lose it as well (though zsh doesn't!) */
 633                         perror_msg("error opening %s", redir->filename);
 634                         return 1;
 635                 }
 636
 637                 if (openfd != redir->fd) {
 638                         if (squirrel && redir->fd < 3) {
 639                                 squirrel[redir->fd] = dup(redir->fd);
 640                         }
 641                         dup2(openfd, redir->fd);
 642                         close(openfd);
 643                 }
 644         }
 645
 646         return 0;
 647 }
 648
 649 static void restore_redirects(int squirrel[])
 650 {
 651         int i, fd;
 652         for (i=0; i<3; i++) {
 653                 fd = squirrel[i];
 654                 if (fd != -1) {
 655                         /* No error checking.  I sure wouldn't know what
 656                          * to do with an error if I found one! */
 657                         dup2(fd, i);
 658                         close(fd);
 659                 }
 660         }
 661 }
 662
 663 static inline void cmdedit_set_initial_prompt(void)
 664 {
 665 #ifndef BB_FEATURE_SH_FANCY_PROMPT
 666         PS1 = NULL;
 667 #else
 668         PS1 = getenv("PS1");
 669         if(PS1==0)
 670                 PS1 = "\\w \\$ ";
 671 #endif
 672 }
 673
 674 static inline void setup_prompt_string(char **prompt_str)
 675 {
 676 #ifndef BB_FEATURE_SH_FANCY_PROMPT
 677         /* Set up the prompt */
 678         if (shell_context == 0) {
 679                 if (PS1)
 680                         free(PS1);
 681                 PS1=xmalloc(strlen(cwd)+4);
 682                 sprintf(PS1, "%s %s", cwd, ( geteuid() != 0 ) ?  "$ ":"# ");
 683                 *prompt_str = PS1;
 684         } else {
 685                 *prompt_str = PS2;
 686         }
 687 #else
 688         *prompt_str = (shell_context==0)? PS1 : PS2;
 689 #endif
 690 }
 691
 692 static int get_command(FILE * source, char *command)
 693 {
 694         char *prompt_str;
 695
 696         if (source == NULL) {
 697                 if (local_pending_command) {
 698                         /* a command specified (-c option): return it & mark it done */
 699                         strcpy(command, local_pending_command);
 700                         free(local_pending_command);
 701                         local_pending_command = NULL;
 702                         return 0;
 703                 }
 704                 return 1;
 705         }
 706
 707         if (source == stdin) {
 708                 setup_prompt_string(&prompt_str);
 709
 710 #ifdef BB_FEATURE_COMMAND_EDITING
 711                 /*
 712                 ** enable command line editing only while a command line
 713                 ** is actually being read; otherwise, we'll end up bequeathing
 714                 ** atexit() handlers and other unwanted stuff to our
 715                 ** child processes (rob@sysgo.de)
 716                 */
 717                 cmdedit_read_input(prompt_str, command);
 718                 cmdedit_terminate();
 719                 return 0;
 720 #else
 721                 fputs(prompt_str, stdout);
 722 #endif
 723         }
 724
 725         if (!fgets(command, BUFSIZ - 2, source)) {
 726                 if (source == stdin)
 727                         printf("\n");
 728                 return 1;
 729         }
 730
 731         return 0;
 732 }
 733
 734 static char* itoa(register int i)
 735 {
 736         static char a[7]; /* Max 7 ints */
 737         register char *b = a + sizeof(a) - 1;
 738         int   sign = (i < 0);
 739
 740         if (sign)
 741                 i = -i;
 742         *b = 0;
 743         do
 744         {
 745                 *--b = '0' + (i % 10);
 746                 i /= 10;
 747         }
 748         while (i);
 749         if (sign)
 750                 *--b = '-';
 751         return b;
 752 }
 753
 754 char * strsep_space( char *string, int * ix)
 755 {
 756         char *token, *begin;
 757
 758         begin = string;
 759
 760         /* Short circuit the trivial case */
 761         if ( !string || ! string[*ix])
 762                 return NULL;
 763
 764         /* Find the end of the token. */
 765         while( string && string[*ix] && !isspace(string[*ix]) ) {
 766                 (*ix)++;
 767         }
 768
 769         /* Find the end of any whitespace trailing behind
 770          * the token and let that be part of the token */
 771         while( string && string[*ix] && isspace(string[*ix]) ) {
 772                 (*ix)++;
 773         }
 774
 775         if (! string && *ix==0) {
 776                 /* Nothing useful was found */
 777                 return NULL;
 778         }
 779
 780         token = xmalloc(*ix+1);
 781         token[*ix] = '\0';
 782         strncpy(token, string,  *ix);
 783
 784         return token;
 785 }
 786
 787 static int expand_arguments(char *command)
 788 {
 789         int total_length=0, length, i, retval, ix = 0;
 790         expand_t expand_result;
 791         char *tmpcmd, *cmd, *cmd_copy;
 792         char *src, *dst, *var;
 793         const char *out_of_space = "out of space during expansion";
 794         int flags = GLOB_NOCHECK
 795 #ifdef GLOB_BRACE
 796                 | GLOB_BRACE
 797 #endif
 798 #ifdef GLOB_TILDE
 799                 | GLOB_TILDE
 800 #endif
 801                 ;
 802
 803         /* get rid of the terminating \n */
 804         chomp(command);
 805
 806         /* Fix up escape sequences to be the Real Thing(tm) */
 807         while( command && command[ix]) {
 808                 if (command[ix] == '\\') {
 809                         const char *tmp = command+ix+1;
 810                         command[ix] = process_escape_sequence(  &tmp );
 811                         memmove(command+ix + 1, tmp, strlen(tmp)+1);
 812                 }
 813                 ix++;
 814         }
 815         /* Use glob and then fixup environment variables and such */
 816
 817         /* It turns out that glob is very stupid.  We have to feed it one word at a
 818          * time since it can't cope with a full string.  Here we convert command
 819          * (char*) into cmd (char**, one word per string) */
 820
 821         /* We need a clean copy, so strsep can mess up the copy while
 822          * we write stuff into the original (in a minute) */
 823         cmd = cmd_copy = strdup(command);
 824         *command = '\0';
 825         for (ix = 0, tmpcmd = cmd;
 826                         (tmpcmd = strsep_space(cmd, &ix)) != NULL; cmd += ix, ix=0) {
 827                 if (*tmpcmd == '\0')
 828                         break;
 829                 /* we need to trim() the result for glob! */
 830                 trim(tmpcmd);
 831                 retval = glob(tmpcmd, flags, NULL, &expand_result);
 832                 free(tmpcmd); /* Free mem allocated by strsep_space */
 833                 if (retval == GLOB_NOSPACE) {
 834                         /* Mem may have been allocated... */
 835                         globfree (&expand_result);
 836                         error_msg(out_of_space);
 837                         return FALSE;
 838                 } else if (retval != 0) {
 839                         /* Some other error.  GLOB_NOMATCH shouldn't
 840                          * happen because of the GLOB_NOCHECK flag in
 841                          * the glob call. */
 842                         error_msg("syntax error");
 843                         return FALSE;
 844                 } else {
 845                         /* Convert from char** (one word per string) to a simple char*,
 846                          * but don't overflow command which is BUFSIZ in length */
 847                         for (i=0; i < expand_result.gl_pathc; i++) {
 848                                 length=strlen(expand_result.gl_pathv[i]);
 849                                 if (total_length+length+1 >= BUFSIZ) {
 850                                         error_msg(out_of_space);
 851                                         return FALSE;
 852                                 }
 853                                 strcat(command+total_length, " ");
 854                                 total_length+=1;
 855                                 strcat(command+total_length, expand_result.gl_pathv[i]);
 856                                 total_length+=length;
 857                         }
 858                         globfree (&expand_result);
 859                 }
 860         }
 861         free(cmd_copy);
 862         trim(command);
 863
 864         /* Now do the shell variable substitutions which
 865          * wordexp can't do for us, namely $? and $! */
 866         src = command;
 867         while((dst = strchr(src,'$')) != NULL){
 868                 var = NULL;
 869                 switch(*(dst+1)) {
 870                         case '?':
 871                                 var = itoa(last_return_code);
 872                                 break;
 873                         case '!':
 874                                 if (last_bg_pid==-1)
 875                                         *(var)='\0';
 876                                 else
 877                                         var = itoa(last_bg_pid);
 878                                 break;
 879                                 /* Everything else like $$, $#, $[0-9], etc. should all be
 880                                  * expanded by wordexp(), so we can in theory skip that stuff
 881                                  * here, but just to be on the safe side (i.e., since uClibc
 882                                  * wordexp doesn't do this stuff yet), lets leave it in for
 883                                  * now. */
 884                         case '$':
 885                                 var = itoa(getpid());
 886                                 break;
 887                         case '#':
 888                                 var = itoa(argc-1);
 889                                 break;
 890                         case '0':case '1':case '2':case '3':case '4':
 891                         case '5':case '6':case '7':case '8':case '9':
 892                                 {
 893                                         int ixx=*(dst + 1)-48;
 894                                         if (ixx >= argc) {
 895                                                 var='\0';
 896                                         } else {
 897                                                 var = argv[ixx];
 898                                         }
 899                                 }
 900                                 break;
 901
 902                 }
 903                 if (var) {
 904                         /* a single character construction was found, and
 905                          * already handled in the case statement */
 906                         src=dst+2;
 907                 } else {
 908                         /* Looks like an environment variable */
 909                         char delim_hold;
 910                         int num_skip_chars=0;
 911                         int dstlen = strlen(dst);
 912                         /* Is this a ${foo} type variable? */
 913                         if (dstlen >=2 && *(dst+1) == '{') {
 914                                 src=strchr(dst+1, '}');
 915                                 num_skip_chars=1;
 916                         } else {
 917                                 src=dst+1;
 918                                 while(isalnum(*src) || *src=='_') src++;
 919                         }
 920                         if (src == NULL) {
 921                                 src = dst+dstlen;
 922                         }
 923                         delim_hold=*src;
 924                         *src='\0';  /* temporary */
 925                         var = getenv(dst + 1 + num_skip_chars);
 926                         *src=delim_hold;
 927                         src += num_skip_chars;
 928                 }
 929                 if (var == NULL) {
 930                         /* Seems we got an un-expandable variable.  So delete it. */
 931                         var = "";
 932                 }
 933                 {
 934                         int subst_len = strlen(var);
 935                         int trail_len = strlen(src);
 936                         if (dst+subst_len+trail_len >= command+BUFSIZ) {
 937                                 error_msg(out_of_space);
 938                                 return FALSE;
 939                         }
 940                         /* Move stuff to the end of the string to accommodate
 941                          * filling the created gap with the new stuff */
 942                         memmove(dst+subst_len, src, trail_len+1);
 943                         /* Now copy in the new stuff */
 944                         memcpy(dst, var, subst_len);
 945                         src = dst+subst_len;
 946                 }
 947         }
 948
 949         return TRUE;
 950 }
 951
 952 /* Return cmd->num_progs as 0 if no command is present (e.g. an empty
 953    line). If a valid command is found, command_ptr is set to point to
 954    the beginning of the next command (if the original command had more
 955    then one job associated with it) or NULL if no more commands are
 956    present. */
 957 static int parse_command(char **command_ptr, struct job *job, int *inbg)
 958 {
 959         char *command;
 960         char *return_command = NULL;
 961         char *src, *buf, *chptr;
 962         int argc_l = 0;
 963         int done = 0;
 964         int argv_alloced;
 965         int i, saw_quote = 0;
 966         char quote = '\0';
 967         int count;
 968         struct child_prog *prog;
 969
 970         /* skip leading white space */
 971         while (**command_ptr && isspace(**command_ptr))
 972                 (*command_ptr)++;
 973
 974         /* this handles empty lines or leading '#' characters */
 975         if (!**command_ptr || (**command_ptr == '#')) {
 976                 job->num_progs=0;
 977                 return 0;
 978         }
 979
 980         *inbg = 0;
 981         job->num_progs = 1;
 982         job->progs = xmalloc(sizeof(*job->progs));
 983
 984         /* We set the argv elements to point inside of this string. The
 985            memory is freed by free_job(). Allocate twice the original
 986            length in case we need to quote every single character.
 987
 988            Getting clean memory relieves us of the task of NULL
 989            terminating things and makes the rest of this look a bit
 990            cleaner (though it is, admittedly, a tad less efficient) */
 991         job->cmdbuf = command = xcalloc(2*strlen(*command_ptr) + 1, sizeof(char));
 992         job->text = NULL;
 993
 994         prog = job->progs;
 995         prog->num_redirects = 0;
 996         prog->redirects = NULL;
 997         prog->is_stopped = 0;
 998         prog->family = job;
 999
1000         argv_alloced = 5;
1001         prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1002         prog->argv[0] = job->cmdbuf;
1003
1004         buf = command;
1005         src = *command_ptr;
1006         while (*src && !done) {
1007                 if (quote == *src) {
1008                         quote = '\0';
1009                 } else if (quote) {
1010                         if (*src == '\\') {
1011                                 src++;
1012                                 if (!*src) {
1013                                         error_msg("character expected after \\");
1014                                         free_job(job);
1015                                         return 1;
1016                                 }
1017
1018                                 /* in shell, "\'" should yield \' */
1019                                 if (*src != quote) {
1020                                         *buf++ = '\\';
1021                                         *buf++ = '\\';
1022                                 }
1023                         } else if (*src == '*' || *src == '?' || *src == '[' ||
1024                                            *src == ']') *buf++ = '\\';
1025                         *buf++ = *src;
1026                 } else if (isspace(*src)) {
1027                         if (*prog->argv[argc_l] || saw_quote) {
1028                                 buf++, argc_l++;
1029                                 /* +1 here leaves room for the NULL which ends argv */
1030                                 if ((argc_l + 1) == argv_alloced) {
1031                                         argv_alloced += 5;
1032                                         prog->argv = xrealloc(prog->argv,
1033                                                                                   sizeof(*prog->argv) *
1034                                                                                   argv_alloced);
1035                                 }
1036                                 prog->argv[argc_l] = buf;
1037                                 saw_quote = 0;
1038                         }
1039                 } else
1040                         switch (*src) {
1041                         case '"':
1042                         case '\'':
1043                                 quote = *src;
1044                                 saw_quote = 1;
1045                                 break;
1046
1047                         case '#':                       /* comment */
1048                                 if (*(src-1)== '$')
1049                                         *buf++ = *src;
1050                                 else
1051                                         done = 1;
1052                                 break;
1053
1054                         case '>':                       /* redirects */
1055                         case '<':
1056                                 i = prog->num_redirects++;
1057                                 prog->redirects = xrealloc(prog->redirects,
1058                                                                                           sizeof(*prog->redirects) *
1059                                                                                           (i + 1));
1060
1061                                 prog->redirects[i].fd = -1;
1062                                 if (buf != prog->argv[argc_l]) {
1063                                         /* the stuff before this character may be the file number
1064                                            being redirected */
1065                                         prog->redirects[i].fd =
1066                                                 strtol(prog->argv[argc_l], &chptr, 10);
1067
1068                                         if (*chptr && *prog->argv[argc_l]) {
1069                                                 buf++, argc_l++;
1070                                                 prog->argv[argc_l] = buf;
1071                                         }
1072                                 }
1073
1074                                 if (prog->redirects[i].fd == -1) {
1075                                         if (*src == '>')
1076                                                 prog->redirects[i].fd = 1;
1077                                         else
1078                                                 prog->redirects[i].fd = 0;
1079                                 }
1080
1081                                 if (*src++ == '>') {
1082                                         if (*src == '>')
1083                                                 prog->redirects[i].type =
1084                                                         REDIRECT_APPEND, src++;
1085                                         else
1086                                                 prog->redirects[i].type = REDIRECT_OVERWRITE;
1087                                 } else {
1088                                         prog->redirects[i].type = REDIRECT_INPUT;
1089                                 }
1090
1091                                 /* This isn't POSIX sh compliant. Oh well. */
1092                                 chptr = src;
1093                                 while (isspace(*chptr))
1094                                         chptr++;
1095
1096                                 if (!*chptr) {
1097                                         error_msg("file name expected after %c", *(src-1));
1098                                         free_job(job);
1099                                         job->num_progs=0;
1100                                         return 1;
1101                                 }
1102
1103                                 prog->redirects[i].filename = buf;
1104                                 while (*chptr && !isspace(*chptr))
1105                                         *buf++ = *chptr++;
1106
1107                                 src = chptr - 1;        /* we src++ later */
1108                                 prog->argv[argc_l] = ++buf;
1109                                 break;
1110
1111                         case '|':                       /* pipe */
1112                                 /* finish this command */
1113                                 if (*prog->argv[argc_l] || saw_quote)
1114                                         argc_l++;
1115                                 if (!argc_l) {
1116                                         error_msg("empty command in pipe");
1117                                         free_job(job);
1118                                         job->num_progs=0;
1119                                         return 1;
1120                                 }
1121                                 prog->argv[argc_l] = NULL;
1122
1123                                 /* and start the next */
1124                                 job->num_progs++;
1125                                 job->progs = xrealloc(job->progs,
1126                                                                           sizeof(*job->progs) * job->num_progs);
1127                                 prog = job->progs + (job->num_progs - 1);
1128                                 prog->num_redirects = 0;
1129                                 prog->redirects = NULL;
1130                                 prog->is_stopped = 0;
1131                                 prog->family = job;
1132                                 argc_l = 0;
1133
1134                                 argv_alloced = 5;
1135                                 prog->argv = xmalloc(sizeof(*prog->argv) * argv_alloced);
1136                                 prog->argv[0] = ++buf;
1137
1138                                 src++;
1139                                 while (*src && isspace(*src))
1140                                         src++;
1141
1142                                 if (!*src) {
1143                                         error_msg("empty command in pipe");
1144                                         free_job(job);
1145                                         job->num_progs=0;
1146                                         return 1;
1147                                 }
1148                                 src--;                  /* we'll ++ it at the end of the loop */
1149
1150                                 break;
1151
1152                         case '&':                       /* background */
1153                                 *inbg = 1;
1154                         case ';':                       /* multiple commands */
1155                                 done = 1;
1156                                 return_command = *command_ptr + (src - *command_ptr) + 1;
1157                                 break;
1158
1159                         case '\\':
1160                                 src++;
1161                                 if (!*src) {
1162                                         error_msg("character expected after \\");
1163                                         free_job(job);
1164                                         return 1;
1165                                 }
1166                                 if (*src == '*' || *src == '[' || *src == ']'
1167                                         || *src == '?') *buf++ = '\\';
1168                                 /* fallthrough */
1169                         default:
1170                                 *buf++ = *src;
1171                         }
1172
1173                 src++;
1174         }
1175
1176         if (*prog->argv[argc_l] || saw_quote) {
1177                 argc_l++;
1178         }
1179         if (!argc_l) {
1180                 free_job(job);
1181                 return 0;
1182         }
1183         prog->argv[argc_l] = NULL;
1184
1185         if (!return_command) {
1186                 job->text = xmalloc(strlen(*command_ptr) + 1);
1187                 strcpy(job->text, *command_ptr);
1188         } else {
1189                 /* This leaves any trailing spaces, which is a bit sloppy */
1190                 count = return_command - *command_ptr;
1191                 job->text = xmalloc(count + 1);
1192                 strncpy(job->text, *command_ptr, count);
1193                 job->text[count] = '\0';
1194         }
1195
1196         *command_ptr = return_command;
1197
1198         return 0;
1199 }
1200
1201 /* Run the child_prog, no matter what kind of command it uses.
1202  */
1203 static int pseudo_exec(struct child_prog *child)
1204 {
1205         struct built_in_command *x;
1206 #ifdef BB_FEATURE_SH_STANDALONE_SHELL
1207         char *name;
1208 #endif
1209
1210         /* Check if the command matches any of the non-forking builtins.
1211          * Depending on context, this might be redundant.  But it's
1212          * easier to waste a few CPU cycles than it is to figure out
1213          * if this is one of those cases.
1214          */
1215         for (x = bltins; x->cmd; x++) {
1216                 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1217                         exit(x->function(child));
1218                 }
1219         }
1220
1221         /* Check if the command matches any of the forking builtins. */
1222         for (x = bltins_forking; x->cmd; x++) {
1223                 if (strcmp(child->argv[0], x->cmd) == 0) {
1224                         applet_name=x->cmd;
1225                         exit (x->function(child));
1226                 }
1227         }
1228 #ifdef BB_FEATURE_SH_STANDALONE_SHELL
1229         /* Check if the command matches any busybox internal
1230          * commands ("applets") here.  Following discussions from
1231          * November 2000 on busybox@opensource.lineo.com, don't use
1232          * get_last_path_component().  This way explicit (with
1233          * slashes) filenames will never be interpreted as an
1234          * applet, just like with builtins.  This way the user can
1235          * override an applet with an explicit filename reference.
1236          * The only downside to this change is that an explicit
1237          * /bin/foo invocation will fork and exec /bin/foo, even if
1238          * /bin/foo is a symlink to busybox.
1239          */
1240         name = child->argv[0];
1241
1242 #ifdef BB_FEATURE_SH_APPLETS_ALWAYS_WIN
1243         /* If you enable BB_FEATURE_SH_APPLETS_ALWAYS_WIN, then
1244          * if you run /bin/cat, it will use BusyBox cat even if
1245          * /bin/cat exists on the filesystem and is _not_ busybox.
1246          * Some systems want this, others do not.  Choose wisely.  :-)
1247          */
1248         name = get_last_path_component(name);
1249 #endif
1250
1251         {
1252             char** argv_l=child->argv;
1253             int argc_l;
1254             for(argc_l=0;*argv_l!=NULL; argv_l++, argc_l++);
1255             optind = 1;
1256             run_applet_by_name(name, argc_l, child->argv);
1257         }
1258 #endif
1259
1260         execvp(child->argv[0], child->argv);
1261         perror_msg_and_die("%s", child->argv[0]);
1262 }
1263
1264 static void insert_job(struct job *newjob, int inbg)
1265 {
1266         struct job *thejob;
1267         struct jobset *j_list=newjob->job_list;
1268
1269         /* find the ID for thejob to use */
1270         newjob->jobid = 1;
1271         for (thejob = j_list->head; thejob; thejob = thejob->next)
1272                 if (thejob->jobid >= newjob->jobid)
1273                         newjob->jobid = thejob->jobid + 1;
1274
1275         /* add thejob to the list of running jobs */
1276         if (!j_list->head) {
1277                 thejob = j_list->head = xmalloc(sizeof(*thejob));
1278         } else {
1279                 for (thejob = j_list->head; thejob->next; thejob = thejob->next) /* nothing */;
1280                 thejob->next = xmalloc(sizeof(*thejob));
1281                 thejob = thejob->next;
1282         }
1283
1284         *thejob = *newjob;   /* physically copy the struct job */
1285         thejob->next = NULL;
1286         thejob->running_progs = thejob->num_progs;
1287         thejob->stopped_progs = 0;
1288
1289         if (inbg) {
1290                 /* we don't wait for background thejobs to return -- append it
1291                    to the list of backgrounded thejobs and leave it alone */
1292                 printf("[%d] %d\n", thejob->jobid,
1293                            newjob->progs[newjob->num_progs - 1].pid);
1294                 last_jobid = newjob->jobid;
1295                 last_bg_pid=newjob->progs[newjob->num_progs - 1].pid;
1296         } else {
1297                 newjob->job_list->fg = thejob;
1298
1299                 /* move the new process group into the foreground */
1300                 /* suppress messages when run from /linuxrc mag@sysgo.de */
1301                 if (tcsetpgrp(shell_terminal, newjob->pgrp) && errno != ENOTTY)
1302                         perror_msg("tcsetpgrp");
1303         }
1304 }
1305
1306 static int run_command(struct job *newjob, int inbg, int outpipe[2])
1307 {
1308         /* struct job *thejob; */
1309         int i;
1310         int nextin, nextout;
1311         int pipefds[2];                         /* pipefd[0] is for reading */
1312         struct built_in_command *x;
1313         struct child_prog *child;
1314
1315         nextin = 0, nextout = 1;
1316         for (i = 0; i < newjob->num_progs; i++) {
1317                 child = & (newjob->progs[i]);
1318
1319                 if ((i + 1) < newjob->num_progs) {
1320                         if (pipe(pipefds)<0) perror_msg_and_die("pipe");
1321                         nextout = pipefds[1];
1322                 } else {
1323                         if (outpipe[1]!=-1) {
1324                                 nextout = outpipe[1];
1325                         } else {
1326                                 nextout = 1;
1327                         }
1328                 }
1329
1330
1331                 /* Check if the command matches any non-forking builtins,
1332                  * but only if this is a simple command.
1333                  * Non-forking builtins within pipes have to fork anyway,
1334                  * and are handled in pseudo_exec.  "echo foo | read bar"
1335                  * is doomed to failure, and doesn't work on bash, either.
1336                  */
1337                 if (newjob->num_progs == 1) {
1338                         for (x = bltins; x->cmd; x++) {
1339                                 if (strcmp(child->argv[0], x->cmd) == 0 ) {
1340                                         int squirrel[] = {-1, -1, -1};
1341                                         int rcode;
1342                                         setup_redirects(child, squirrel);
1343                                         rcode = x->function(child);
1344                                         restore_redirects(squirrel);
1345                                         return rcode;
1346                                 }
1347                         }
1348                 }
1349
1350                 if (!(child->pid = fork())) {
1351                         /* Set the handling for job control signals back to the default.  */
1352                         signal(SIGINT, SIG_DFL);
1353                         signal(SIGQUIT, SIG_DFL);
1354                         signal(SIGTSTP, SIG_DFL);
1355                         signal(SIGTTIN, SIG_DFL);
1356                         signal(SIGTTOU, SIG_DFL);
1357                         signal(SIGCHLD, SIG_DFL);
1358
1359                         close_all();
1360
1361                         if (outpipe[1]!=-1) {
1362                                 close(outpipe[0]);
1363                         }
1364                         if (nextin != 0) {
1365                                 dup2(nextin, 0);
1366                                 close(nextin);
1367                         }
1368
1369                         if (nextout != 1) {
1370                                 dup2(nextout, 1);
1371                                 dup2(nextout, 2);  /* Really? */
1372                                 close(nextout);
1373                                 close(pipefds[0]);
1374                         }
1375
1376                         /* explicit redirects override pipes */
1377                         setup_redirects(child,NULL);
1378
1379                         pseudo_exec(child);
1380                 }
1381                 if (outpipe[1]!=-1) {
1382                         close(outpipe[1]);
1383                 }
1384
1385                 /* put our child in the process group whose leader is the
1386                    first process in this pipe */
1387                 setpgid(child->pid, newjob->progs[0].pid);
1388                 if (nextin != 0)
1389                         close(nextin);
1390                 if (nextout != 1)
1391                         close(nextout);
1392
1393                 /* If there isn't another process, nextin is garbage
1394                    but it doesn't matter */
1395                 nextin = pipefds[0];
1396         }
1397
1398         newjob->pgrp = newjob->progs[0].pid;
1399
1400         insert_job(newjob, inbg);
1401
1402         return 0;
1403 }
1404
1405 static int busy_loop(FILE * input)
1406 {
1407         char *command;
1408         char *next_command = NULL;
1409         struct job newjob;
1410         pid_t  parent_pgrp;
1411         int i;
1412         int inbg;
1413         int status;
1414         newjob.job_list = &job_list;
1415         newjob.job_context = DEFAULT_CONTEXT;
1416
1417         /* save current owner of TTY so we can restore it on exit */
1418         parent_pgrp = tcgetpgrp(shell_terminal);
1419
1420         command = (char *) xcalloc(BUFSIZ, sizeof(char));
1421
1422         while (1) {
1423                 if (!job_list.fg) {
1424                         /* no job is in the foreground */
1425
1426                         /* see if any background processes have exited */
1427                         checkjobs(&job_list);
1428
1429                         if (!next_command) {
1430                                 if (get_command(input, command))
1431                                         break;
1432                                 next_command = command;
1433                         }
1434
1435                         if (expand_arguments(next_command) == FALSE) {
1436                                 free(command);
1437                                 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1438                                 next_command = NULL;
1439                                 continue;
1440                         }
1441
1442                         if (!parse_command(&next_command, &newjob, &inbg) &&
1443                                 newjob.num_progs) {
1444                                 int pipefds[2] = {-1,-1};
1445                                 debug_printf( "job=%p fed to run_command by busy_loop()'\n",
1446                                                 &newjob);
1447                                 run_command(&newjob, inbg, pipefds);
1448                         }
1449                         else {
1450                                 free(command);
1451                                 command = (char *) xcalloc(BUFSIZ, sizeof(char));
1452                                 next_command = NULL;
1453                         }
1454                 } else {
1455                         /* a job is running in the foreground; wait for it */
1456                         i = 0;
1457                         while (!job_list.fg->progs[i].pid ||
1458                                    job_list.fg->progs[i].is_stopped == 1) i++;
1459
1460                         if (waitpid(job_list.fg->progs[i].pid, &status, WUNTRACED)<0)
1461                                 perror_msg_and_die("waitpid(%d)",job_list.fg->progs[i].pid);
1462
1463                         if (WIFEXITED(status) || WIFSIGNALED(status)) {
1464                                 /* the child exited */
1465                                 job_list.fg->running_progs--;
1466                                 job_list.fg->progs[i].pid = 0;
1467
1468                                 last_return_code=WEXITSTATUS(status);
1469
1470                                 if (!job_list.fg->running_progs) {
1471                                         /* child exited */
1472                                         remove_job(&job_list, job_list.fg);
1473                                         job_list.fg = NULL;
1474                                 }
1475                         } else {
1476                                 /* the child was stopped */
1477                                 job_list.fg->stopped_progs++;
1478                                 job_list.fg->progs[i].is_stopped = 1;
1479
1480                                 if (job_list.fg->stopped_progs == job_list.fg->running_progs) {
1481                                         printf("\n" JOB_STATUS_FORMAT, job_list.fg->jobid,
1482                                                    "Stopped", job_list.fg->text);
1483                                         job_list.fg = NULL;
1484                                 }
1485                         }
1486
1487                         if (!job_list.fg) {
1488                                 /* move the shell to the foreground */
1489                                 /* suppress messages when run from /linuxrc mag@sysgo.de */
1490                                 if (tcsetpgrp(shell_terminal, getpgrp()) && errno != ENOTTY)
1491                                         perror_msg("tcsetpgrp");
1492                         }
1493                 }
1494         }
1495         free(command);
1496
1497         /* return controlling TTY back to parent process group before exiting */
1498         if (tcsetpgrp(shell_terminal, parent_pgrp))
1499                 perror_msg("tcsetpgrp");
1500
1501         /* return exit status if called with "-c" */
1502         if (input == NULL && WIFEXITED(status))
1503                 return WEXITSTATUS(status);
1504
1505         return 0;
1506 }
1507
1508
1509 #ifdef BB_FEATURE_CLEAN_UP
1510 void free_memory(void)
1511 {
1512         if (cwd) {
1513                 free(cwd);
1514         }
1515         if (local_pending_command)
1516                 free(local_pending_command);
1517
1518         if (job_list.fg && !job_list.fg->running_progs) {
1519                 remove_job(&job_list, job_list.fg);
1520         }
1521 }
1522 #endif
1523
1524 /* Make sure we have a controlling tty.  If we get started under a job
1525  * aware app (like bash for example), make sure we are now in charge so
1526  * we don't fight over who gets the foreground */
1527 static void setup_job_control()
1528 {
1529         /* Loop until we are in the foreground.  */
1530         while (tcgetpgrp (shell_terminal) != (shell_pgrp = getpgrp ()))
1531                 kill (- shell_pgrp, SIGTTIN);
1532
1533         /* Ignore interactive and job-control signals.  */
1534         signal(SIGINT, SIG_IGN);
1535         signal(SIGQUIT, SIG_IGN);
1536         signal(SIGTSTP, SIG_IGN);
1537         signal(SIGTTIN, SIG_IGN);
1538         signal(SIGTTOU, SIG_IGN);
1539         signal(SIGCHLD, SIG_IGN);
1540
1541         /* Put ourselves in our own process group.  */
1542         setsid();
1543         shell_pgrp = getpid ();
1544         setpgid (shell_pgrp, shell_pgrp);
1545
1546         /* Grab control of the terminal.  */
1547         tcsetpgrp(shell_terminal, shell_pgrp);
1548 }
1549
1550 int shell_main(int argc_l, char **argv_l)
1551 {
1552         int opt, interactive=FALSE;
1553         FILE *input = stdin;
1554         argc = argc_l;
1555         argv = argv_l;
1556
1557         /* These variables need re-initializing when recursing */
1558         last_jobid = 0;
1559         shell_context = 0;
1560         local_pending_command = NULL;
1561         close_me_head = NULL;
1562         job_list.head = NULL;
1563         job_list.fg = NULL;
1564         last_return_code=1;
1565
1566         if (argv[0] && argv[0][0] == '-') {
1567                 FILE *prof_input;
1568                 prof_input = fopen("/etc/profile", "r");
1569                 if (prof_input) {
1570                         int tmp_fd = fileno(prof_input);
1571                         mark_open(tmp_fd);
1572                         /* Now run the file */
1573                         busy_loop(prof_input);
1574                         fclose(prof_input);
1575                         mark_closed(tmp_fd);
1576                 }
1577         }
1578
1579         while ((opt = getopt(argc_l, argv_l, "cxi")) > 0) {
1580                 switch (opt) {
1581                         case 'c':
1582                                 input = NULL;
1583                                 if (local_pending_command != 0)
1584                                         error_msg_and_die("multiple -c arguments");
1585                                 local_pending_command = xstrdup(argv[optind]);
1586                                 optind++;
1587                                 argv = argv+optind;
1588                                 break;
1589                         case 'i':
1590                                 interactive = TRUE;
1591                                 break;
1592                         default:
1593                                 show_usage();
1594                 }
1595         }
1596         /* A shell is interactive if the `-i' flag was given, or if all of
1597          * the following conditions are met:
1598          *        no -c command
1599          *    no arguments remaining or the -s flag given
1600          *    standard input is a terminal
1601          *    standard output is a terminal
1602          *    Refer to Posix.2, the description of the `sh' utility. */
1603         if (argv[optind]==NULL && input==stdin &&
1604                         isatty(fileno(stdin)) && isatty(fileno(stdout))) {
1605                 interactive=TRUE;
1606         }
1607         setup_job_control();
1608         if (interactive==TRUE) {
1609                 //printf( "optind=%d  argv[optind]='%s'\n", optind, argv[optind]);
1610                 /* Looks like they want an interactive shell */
1611                 printf( "\n\n" BB_BANNER " Built-in shell (lash)\n");
1612                 printf( "Enter 'help' for a list of built-in commands.\n\n");
1613         } else if (local_pending_command==NULL) {
1614                 //printf( "optind=%d  argv[optind]='%s'\n", optind, argv[optind]);
1615                 input = xfopen(argv[optind], "r");
1616                 mark_open(fileno(input));  /* be lazy, never mark this closed */
1617         }
1618
1619         /* initialize the cwd -- this is never freed...*/
1620         cwd = xgetcwd(0);
1621         if (!cwd)
1622                 cwd = unknown;
1623
1624 #ifdef BB_FEATURE_CLEAN_UP
1625         atexit(free_memory);
1626 #endif
1627
1628 #ifdef BB_FEATURE_COMMAND_EDITING
1629         cmdedit_set_initial_prompt();
1630 #else
1631         PS1 = NULL;
1632 #endif
1633
1634         return (busy_loop(input));
1635 }