userapps/opensource/busybox/shell/lash.c

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