builtins/evalstring.c

   1 /* evalstring.c - evaluate a string as one or more shell commands.
   2
   3 /* Copyright (C) 1996-2009 Free Software Foundation, Inc.
   4
   5    This file is part of GNU Bash, the Bourne Again SHell.
   6
   7    Bash is free software: you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation, either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    Bash is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with Bash.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <config.h>
  22
  23 #if defined (HAVE_UNISTD_H)
  24 #  ifdef _MINIX
  25 #    include <sys/types.h>
  26 #  endif
  27 #  include <unistd.h>
  28 #endif
  29
  30 #include <stdio.h>
  31 #include <signal.h>
  32
  33 #include <errno.h>
  34
  35 #include "filecntl.h"
  36 #include "../bashansi.h"
  37
  38 #include "../shell.h"
  39 #include "../jobs.h"
  40 #include "../builtins.h"
  41 #include "../flags.h"
  42 #include "../input.h"
  43 #include "../execute_cmd.h"
  44 #include "../redir.h"
  45 #include "../trap.h"
  46
  47 #include <y.tab.h>
  48
  49 #if defined (HISTORY)
  50 #  include "../bashhist.h"
  51 #endif
  52
  53 #include "common.h"
  54
  55 #if !defined (errno)
  56 extern int errno;
  57 #endif
  58
  59 #define IS_BUILTIN(s)   (builtin_address_internal(s, 0) != (struct builtin *)NULL)
  60
  61 extern int indirection_level, subshell_environment;
  62 extern int line_number;
  63 extern int current_token, shell_eof_token;
  64 extern int last_command_exit_value;
  65 extern int running_trap;
  66 extern int loop_level;
  67 extern int executing_list;
  68 extern int comsub_ignore_return;
  69 extern int posixly_correct;
  70
  71 int parse_and_execute_level = 0;
  72
  73 static int cat_file __P((REDIRECT *));
  74
  75 #define PE_TAG "parse_and_execute top"
  76 #define PS_TAG "parse_string top"
  77
  78 #if defined (HISTORY)
  79 static void
  80 set_history_remembering ()
  81 {
  82   remember_on_history = enable_history_list;
  83 }
  84 #endif
  85
  86 /* How to force parse_and_execute () to clean up after itself. */
  87 void
  88 parse_and_execute_cleanup ()
  89 {
  90   if (running_trap)
  91     {
  92       run_trap_cleanup (running_trap - 1);
  93       unfreeze_jobs_list ();
  94     }
  95
  96   if (have_unwind_protects ())
  97      run_unwind_frame (PE_TAG);
  98   else
  99     parse_and_execute_level = 0;                        /* XXX */
 100 }
 101
 102 static void
 103 parse_prologue (string, flags, tag)
 104      char *string;
 105      int flags;
 106      char *tag;
 107 {
 108   char *orig_string;
 109   int x;
 110
 111   orig_string = string;
 112   /* Unwind protect this invocation of parse_and_execute (). */
 113   begin_unwind_frame (tag);
 114   unwind_protect_int (parse_and_execute_level);
 115   unwind_protect_jmp_buf (top_level);
 116   unwind_protect_int (indirection_level);
 117   unwind_protect_int (line_number);
 118   unwind_protect_int (loop_level);
 119   unwind_protect_int (executing_list);
 120   unwind_protect_int (comsub_ignore_return);
 121   if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
 122     unwind_protect_int (interactive);
 123
 124 #if defined (HISTORY)
 125   if (parse_and_execute_level == 0)
 126     add_unwind_protect (set_history_remembering, (char *)NULL);
 127   else
 128     unwind_protect_int (remember_on_history);   /* can be used in scripts */
 129 #  if defined (BANG_HISTORY)
 130   if (interactive_shell)
 131     unwind_protect_int (history_expansion_inhibited);
 132 #  endif /* BANG_HISTORY */
 133 #endif /* HISTORY */
 134
 135   if (interactive_shell)
 136     {
 137       x = get_current_prompt_level ();
 138       add_unwind_protect (set_current_prompt_level, x);
 139     }
 140
 141   add_unwind_protect (pop_stream, (char *)NULL);
 142   if (orig_string && ((flags & SEVAL_NOFREE) == 0))
 143     add_unwind_protect (xfree, orig_string);
 144   end_unwind_frame ();
 145
 146   if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
 147     interactive = (flags & SEVAL_NONINT) ? 0 : 1;
 148
 149 #if defined (HISTORY)
 150   if (flags & SEVAL_NOHIST)
 151     bash_history_disable ();
 152 #endif /* HISTORY */
 153 }
 154
 155 /* Parse and execute the commands in STRING.  Returns whatever
 156    execute_command () returns.  This frees STRING.  FLAGS is a
 157    flags word; look in common.h for the possible values.  Actions
 158    are:
 159         (flags & SEVAL_NONINT) -> interactive = 0;
 160         (flags & SEVAL_INTERACT) -> interactive = 1;
 161         (flags & SEVAL_NOHIST) -> call bash_history_disable ()
 162         (flags & SEVAL_NOFREE) -> don't free STRING when finished
 163         (flags & SEVAL_RESETLINE) -> reset line_number to 1
 164 */
 165
 166 int
 167 parse_and_execute (string, from_file, flags)
 168      char *string;
 169      const char *from_file;
 170      int flags;
 171 {
 172   int code, lreset;
 173   volatile int should_jump_to_top_level, last_result;
 174   COMMAND *volatile command;
 175
 176   parse_prologue (string, flags, PE_TAG);
 177
 178   parse_and_execute_level++;
 179
 180   lreset = flags & SEVAL_RESETLINE;
 181
 182   /* Reset the line number if the caller wants us to.  If we don't reset the
 183      line number, we have to subtract one, because we will add one just
 184      before executing the next command (resetting the line number sets it to
 185      0; the first line number is 1). */
 186   push_stream (lreset);
 187   if (lreset == 0)
 188     line_number--;
 189
 190   indirection_level++;
 191
 192   code = should_jump_to_top_level = 0;
 193   last_result = EXECUTION_SUCCESS;
 194
 195   with_input_from_string (string, from_file);
 196   while (*(bash_input.location.string))
 197     {
 198       command = (COMMAND *)NULL;
 199
 200       if (interrupt_state)
 201         {
 202           last_result = EXECUTION_FAILURE;
 203           break;
 204         }
 205
 206       /* Provide a location for functions which `longjmp (top_level)' to
 207          jump to.  This prevents errors in substitution from restarting
 208          the reader loop directly, for example. */
 209       code = setjmp (top_level);
 210
 211       if (code)
 212         {
 213           should_jump_to_top_level = 0;
 214           switch (code)
 215             {
 216             case FORCE_EOF:
 217             case ERREXIT:
 218             case EXITPROG:
 219               if (command)
 220                 run_unwind_frame ("pe_dispose");
 221               /* Remember to call longjmp (top_level) after the old
 222                  value for it is restored. */
 223               should_jump_to_top_level = 1;
 224               goto out;
 225
 226             case DISCARD:
 227               if (command)
 228                 run_unwind_frame ("pe_dispose");
 229               last_result = last_command_exit_value = EXECUTION_FAILURE; /* XXX */
 230               if (subshell_environment)
 231                 {
 232                   should_jump_to_top_level = 1;
 233                   goto out;
 234                 }
 235               else
 236                 {
 237 #if 0
 238                   dispose_command (command);    /* pe_dispose does this */
 239 #endif
 240                   continue;
 241                 }
 242
 243             default:
 244               command_error ("parse_and_execute", CMDERR_BADJUMP, code, 0);
 245               break;
 246             }
 247         }
 248
 249       if (parse_command () == 0)
 250         {
 251           if ((flags & SEVAL_PARSEONLY) || (interactive_shell == 0 && read_but_dont_execute))
 252             {
 253               last_result = EXECUTION_SUCCESS;
 254               dispose_command (global_command);
 255               global_command = (COMMAND *)NULL;
 256             }
 257           else if (command = global_command)
 258             {
 259               struct fd_bitmap *bitmap;
 260
 261               bitmap = new_fd_bitmap (FD_BITMAP_SIZE);
 262               begin_unwind_frame ("pe_dispose");
 263               add_unwind_protect (dispose_fd_bitmap, bitmap);
 264               add_unwind_protect (dispose_command, command);    /* XXX */
 265
 266               global_command = (COMMAND *)NULL;
 267
 268               if ((subshell_environment & SUBSHELL_COMSUB) && comsub_ignore_return)
 269                 command->flags |= CMD_IGNORE_RETURN;
 270
 271 #if defined (ONESHOT)
 272               /*
 273                * IF
 274                *   we were invoked as `bash -c' (startup_state == 2) AND
 275                *   parse_and_execute has not been called recursively AND
 276                *   we're not running a trap AND
 277                *   we have parsed the full command (string == '\0') AND
 278                *   we're not going to run the exit trap AND
 279                *   we have a simple command without redirections AND
 280                *   the command is not being timed AND
 281                *   the command's return status is not being inverted
 282                * THEN
 283                *   tell the execution code that we don't need to fork
 284                */
 285               if (startup_state == 2 && parse_and_execute_level == 1 &&
 286                   running_trap == 0 &&
 287                   *bash_input.location.string == '\0' &&
 288                   command->type == cm_simple &&
 289                   signal_is_trapped (EXIT_TRAP) == 0 &&
 290                   command->redirects == 0 && command->value.Simple->redirects == 0 &&
 291                   ((command->flags & CMD_TIME_PIPELINE) == 0) &&
 292                   ((command->flags & CMD_INVERT_RETURN) == 0))
 293                 {
 294                   command->flags |= CMD_NO_FORK;
 295                   command->value.Simple->flags |= CMD_NO_FORK;
 296                 }
 297 #endif /* ONESHOT */
 298
 299               /* See if this is a candidate for $( <file ). */
 300               if (startup_state == 2 &&
 301                   (subshell_environment & SUBSHELL_COMSUB) &&
 302                   *bash_input.location.string == '\0' &&
 303                   command->type == cm_simple && !command->redirects &&
 304                   (command->flags & CMD_TIME_PIPELINE) == 0 &&
 305                   command->value.Simple->words == 0 &&
 306                   command->value.Simple->redirects &&
 307                   command->value.Simple->redirects->next == 0 &&
 308                   command->value.Simple->redirects->instruction == r_input_direction)
 309                 {
 310                   int r;
 311                   r = cat_file (command->value.Simple->redirects);
 312                   last_result = (r < 0) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
 313                 }
 314               else
 315                 last_result = execute_command_internal
 316                                 (command, 0, NO_PIPE, NO_PIPE, bitmap);
 317
 318               dispose_command (command);
 319               dispose_fd_bitmap (bitmap);
 320               discard_unwind_frame ("pe_dispose");
 321             }
 322         }
 323       else
 324         {
 325           last_result = EXECUTION_FAILURE;
 326
 327           /* Since we are shell compatible, syntax errors in a script
 328              abort the execution of the script.  Right? */
 329           break;
 330         }
 331     }
 332
 333  out:
 334
 335   run_unwind_frame (PE_TAG);
 336
 337   if (interrupt_state && parse_and_execute_level == 0)
 338     {
 339       /* An interrupt during non-interactive execution in an
 340          interactive shell (e.g. via $PROMPT_COMMAND) should
 341          not cause the shell to exit. */
 342       interactive = interactive_shell;
 343       throw_to_top_level ();
 344     }
 345
 346   if (should_jump_to_top_level)
 347     jump_to_top_level (code);
 348
 349   return (last_result);
 350 }
 351
 352 /* Parse a command contained in STRING according to FLAGS and return the
 353    number of characters consumed from the string.  If non-NULL, set *ENDP
 354    to the position in the string where the parse ended.  Used to validate
 355    command substitutions during parsing to obey Posix rules about finding
 356    the end of the command and balancing parens. */
 357 int
 358 parse_string (string, from_file, flags, endp)
 359      char *string;
 360      const char *from_file;
 361      int flags;
 362      char **endp;
 363 {
 364   int code, nc;
 365   volatile int should_jump_to_top_level;
 366   COMMAND *volatile command, *oglobal;
 367   char *ostring;
 368
 369   parse_prologue (string, flags, PS_TAG);
 370
 371   /* Reset the line number if the caller wants us to.  If we don't reset the
 372      line number, we have to subtract one, because we will add one just
 373      before executing the next command (resetting the line number sets it to
 374      0; the first line number is 1). */
 375   push_stream (0);
 376
 377   code = should_jump_to_top_level = 0;
 378   oglobal = global_command;
 379   ostring = string;
 380
 381   with_input_from_string (string, from_file);
 382   while (*(bash_input.location.string))
 383     {
 384       command = (COMMAND *)NULL;
 385
 386 #if 0
 387       if (interrupt_state)
 388         break;
 389 #endif
 390
 391       /* Provide a location for functions which `longjmp (top_level)' to
 392          jump to. */
 393       code = setjmp (top_level);
 394
 395       if (code)
 396         {
 397 #if defined (DEBUG)
 398 itrace("parse_string: longjmp executed: code = %d", code);
 399 #endif
 400           should_jump_to_top_level = 0;
 401           switch (code)
 402             {
 403             case FORCE_EOF:
 404             case ERREXIT:
 405             case EXITPROG:
 406             case DISCARD:               /* XXX */
 407               if (command)
 408                 dispose_command (command);
 409               /* Remember to call longjmp (top_level) after the old
 410                  value for it is restored. */
 411               should_jump_to_top_level = 1;
 412               goto out;
 413
 414             default:
 415               command_error ("parse_string", CMDERR_BADJUMP, code, 0);
 416               break;
 417             }
 418         }
 419
 420       if (parse_command () == 0)
 421         {
 422           dispose_command (global_command);
 423           global_command = (COMMAND *)NULL;
 424         }
 425       else
 426         {
 427           if ((flags & SEVAL_NOLONGJMP) == 0)
 428             {
 429               should_jump_to_top_level = 1;
 430               code = DISCARD;
 431             }
 432           else
 433             reset_parser ();    /* XXX - sets token_to_read */
 434           break;
 435         }
 436
 437       if (current_token == yacc_EOF || current_token == shell_eof_token)
 438           break;
 439     }
 440
 441  out:
 442
 443   global_command = oglobal;
 444   nc = bash_input.location.string - ostring;
 445   if (endp)
 446     *endp = bash_input.location.string;
 447
 448   run_unwind_frame (PS_TAG);
 449
 450   if (should_jump_to_top_level)
 451     jump_to_top_level (code);
 452
 453   return (nc);
 454 }
 455
 456 /* Handle a $( < file ) command substitution.  This expands the filename,
 457    returning errors as appropriate, then just cats the file to the standard
 458    output. */
 459 static int
 460 cat_file (r)
 461      REDIRECT *r;
 462 {
 463   char *fn;
 464   int fd, rval;
 465
 466   if (r->instruction != r_input_direction)
 467     return -1;
 468
 469   /* Get the filename. */
 470   if (posixly_correct && !interactive_shell)
 471     disallow_filename_globbing++;
 472   fn = redirection_expand (r->redirectee.filename);
 473   if (posixly_correct && !interactive_shell)
 474     disallow_filename_globbing--;
 475
 476   if (fn == 0)
 477     {
 478       redirection_error (r, AMBIGUOUS_REDIRECT);
 479       return -1;
 480     }
 481
 482   fd = open(fn, O_RDONLY);
 483   if (fd < 0)
 484     {
 485       file_error (fn);
 486       free (fn);
 487       return -1;
 488     }
 489
 490   rval = zcatfd (fd, 1, fn);
 491
 492   free (fn);
 493   close (fd);
 494
 495   return (rval);
 496 }