builtins/evalstring.c

   1 /* evalstring.c - evaluate a string as one or more shell commands. */
   2
   3 /* Copyright (C) 1996-2012 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 #include "../bashintl.h"
  47
  48 #include <y.tab.h>
  49
  50 #if defined (HISTORY)
  51 #  include "../bashhist.h"
  52 #endif
  53
  54 #include "common.h"
  55 #include "builtext.h"
  56
  57 #if !defined (errno)
  58 extern int errno;
  59 #endif
  60
  61 #define IS_BUILTIN(s)   (builtin_address_internal(s, 0) != (struct builtin *)NULL)
  62
  63 extern int indirection_level, subshell_environment;
  64 extern int line_number, line_number_for_err_trap;
  65 extern int current_token, shell_eof_token;
  66 extern int last_command_exit_value;
  67 extern int running_trap;
  68 extern int loop_level;
  69 extern int executing_list;
  70 extern int comsub_ignore_return;
  71 extern int posixly_correct;
  72 extern int return_catch_flag, return_catch_value;
  73 extern sh_builtin_func_t *this_shell_builtin;
  74 extern char *the_printed_command_except_trap;
  75
  76 int parse_and_execute_level = 0;
  77
  78 static int cat_file __P((REDIRECT *));
  79
  80 #define PE_TAG "parse_and_execute top"
  81 #define PS_TAG "parse_string top"
  82
  83 #if defined (HISTORY)
  84 static void
  85 set_history_remembering ()
  86 {
  87   remember_on_history = enable_history_list;
  88 }
  89 #endif
  90
  91 static void
  92 restore_lastcom (x)
  93      char *x;
  94 {
  95   FREE (the_printed_command_except_trap);
  96   the_printed_command_except_trap = x;
  97 }
  98
  99 /* How to force parse_and_execute () to clean up after itself. */
 100 void
 101 parse_and_execute_cleanup ()
 102 {
 103   if (running_trap)
 104     {
 105       run_trap_cleanup (running_trap - 1);
 106       unfreeze_jobs_list ();
 107     }
 108
 109   if (have_unwind_protects ())
 110      run_unwind_frame (PE_TAG);
 111   else
 112     parse_and_execute_level = 0;                        /* XXX */
 113 }
 114
 115 static void
 116 parse_prologue (string, flags, tag)
 117      char *string;
 118      int flags;
 119      char *tag;
 120 {
 121   char *orig_string, *lastcom;
 122   int x;
 123
 124   orig_string = string;
 125   /* Unwind protect this invocation of parse_and_execute (). */
 126   begin_unwind_frame (tag);
 127   unwind_protect_int (parse_and_execute_level);
 128   unwind_protect_jmp_buf (top_level);
 129   unwind_protect_int (indirection_level);
 130   unwind_protect_int (line_number);
 131   unwind_protect_int (line_number_for_err_trap);
 132   unwind_protect_int (loop_level);
 133   unwind_protect_int (executing_list);
 134   unwind_protect_int (comsub_ignore_return);
 135   if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
 136     unwind_protect_int (interactive);
 137
 138 #if defined (HISTORY)
 139   if (parse_and_execute_level == 0)
 140     add_unwind_protect (set_history_remembering, (char *)NULL);
 141   else
 142     unwind_protect_int (remember_on_history);   /* can be used in scripts */
 143 #  if defined (BANG_HISTORY)
 144   if (interactive_shell)
 145     unwind_protect_int (history_expansion_inhibited);
 146 #  endif /* BANG_HISTORY */
 147 #endif /* HISTORY */
 148
 149   if (interactive_shell)
 150     {
 151       x = get_current_prompt_level ();
 152       add_unwind_protect (set_current_prompt_level, x);
 153     }
 154
 155   if (the_printed_command_except_trap)
 156     {
 157       lastcom = savestring (the_printed_command_except_trap);
 158       add_unwind_protect (restore_lastcom, lastcom);
 159     }
 160
 161   add_unwind_protect (pop_stream, (char *)NULL);
 162   if (parser_expanding_alias ())
 163     add_unwind_protect (parser_restore_alias, (char *)NULL);
 164
 165   if (orig_string && ((flags & SEVAL_NOFREE) == 0))
 166     add_unwind_protect (xfree, orig_string);
 167   end_unwind_frame ();
 168
 169   if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
 170     interactive = (flags & SEVAL_NONINT) ? 0 : 1;
 171
 172 #if defined (HISTORY)
 173   if (flags & SEVAL_NOHIST)
 174     bash_history_disable ();
 175 #endif /* HISTORY */
 176 }
 177
 178 /* Parse and execute the commands in STRING.  Returns whatever
 179    execute_command () returns.  This frees STRING.  FLAGS is a
 180    flags word; look in common.h for the possible values.  Actions
 181    are:
 182         (flags & SEVAL_NONINT) -> interactive = 0;
 183         (flags & SEVAL_INTERACT) -> interactive = 1;
 184         (flags & SEVAL_NOHIST) -> call bash_history_disable ()
 185         (flags & SEVAL_NOFREE) -> don't free STRING when finished
 186         (flags & SEVAL_RESETLINE) -> reset line_number to 1
 187 */
 188
 189 int
 190 parse_and_execute (string, from_file, flags)
 191      char *string;
 192      const char *from_file;
 193      int flags;
 194 {
 195   int code, lreset;
 196   volatile int should_jump_to_top_level, last_result;
 197   COMMAND *volatile command;
 198   volatile sigset_t pe_sigmask;
 199
 200   parse_prologue (string, flags, PE_TAG);
 201
 202   parse_and_execute_level++;
 203
 204   lreset = flags & SEVAL_RESETLINE;
 205
 206 #if defined (HAVE_POSIX_SIGNALS)
 207   /* If we longjmp and are going to go on, use this to restore signal mask */
 208   sigemptyset (&pe_sigmask);
 209   sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &pe_sigmask);
 210 #endif
 211
 212   /* Reset the line number if the caller wants us to.  If we don't reset the
 213      line number, we have to subtract one, because we will add one just
 214      before executing the next command (resetting the line number sets it to
 215      0; the first line number is 1). */
 216   push_stream (lreset);
 217   if (parser_expanding_alias ())
 218     /* push current shell_input_line */
 219     parser_save_alias ();
 220
 221   if (lreset == 0)
 222     line_number--;
 223
 224   indirection_level++;
 225
 226   code = should_jump_to_top_level = 0;
 227   last_result = EXECUTION_SUCCESS;
 228
 229   with_input_from_string (string, from_file);
 230   while (*(bash_input.location.string))
 231     {
 232       command = (COMMAND *)NULL;
 233
 234       if (interrupt_state)
 235         {
 236           last_result = EXECUTION_FAILURE;
 237           break;
 238         }
 239
 240       /* Provide a location for functions which `longjmp (top_level)' to
 241          jump to.  This prevents errors in substitution from restarting
 242          the reader loop directly, for example. */
 243       code = setjmp_nosigs (top_level);
 244
 245       if (code)
 246         {
 247           should_jump_to_top_level = 0;
 248           switch (code)
 249             {
 250             case ERREXIT:
 251               /* variable_context -> 0 is what eval.c:reader_loop() does in
 252                  these circumstances.  Don't bother with cleanup here because
 253                  we don't want to run the function execution cleanup stuff
 254                  that will cause pop_context and other functions to run.
 255                  XXX - change that if we want the function context to be
 256                  unwound. */
 257               if (exit_immediately_on_error && variable_context)
 258                 {
 259                   discard_unwind_frame ("pe_dispose");
 260                   variable_context = 0; /* not in a function */
 261                 }
 262               should_jump_to_top_level = 1;
 263               goto out;
 264             case FORCE_EOF:
 265             case EXITPROG:
 266               if (command)
 267                 run_unwind_frame ("pe_dispose");
 268               /* Remember to call longjmp (top_level) after the old
 269                  value for it is restored. */
 270               should_jump_to_top_level = 1;
 271               goto out;
 272
 273             case DISCARD:
 274               if (command)
 275                 run_unwind_frame ("pe_dispose");
 276               last_result = last_command_exit_value = EXECUTION_FAILURE; /* XXX */
 277               if (subshell_environment)
 278                 {
 279                   should_jump_to_top_level = 1;
 280                   goto out;
 281                 }
 282               else
 283                 {
 284 #if 0
 285                   dispose_command (command);    /* pe_dispose does this */
 286 #endif
 287 #if defined (HAVE_POSIX_SIGNALS)
 288                   sigprocmask (SIG_SETMASK, &pe_sigmask, (sigset_t *)NULL);
 289 #endif
 290                   continue;
 291                 }
 292
 293             default:
 294               command_error ("parse_and_execute", CMDERR_BADJUMP, code, 0);
 295               break;
 296             }
 297         }
 298
 299       if (parse_command () == 0)
 300         {
 301           if ((flags & SEVAL_PARSEONLY) || (interactive_shell == 0 && read_but_dont_execute))
 302             {
 303               last_result = EXECUTION_SUCCESS;
 304               dispose_command (global_command);
 305               global_command = (COMMAND *)NULL;
 306             }
 307           else if (command = global_command)
 308             {
 309               struct fd_bitmap *bitmap;
 310
 311               if (flags & SEVAL_FUNCDEF)
 312                 {
 313                   char *x;
 314
 315                   /* If the command parses to something other than a straight
 316                      function definition, or if we have not consumed the entire
 317                      string, or if the parser has transformed the function
 318                      name (as parsing will if it begins or ends with shell
 319                      whitespace, for example), reject the attempt */
 320                   if (command->type != cm_function_def ||
 321                       ((x = parser_remaining_input ()) && *x) ||
 322                       (STREQ (from_file, command->value.Function_def->name->word) == 0))
 323                     {
 324                       internal_warning (_("%s: ignoring function definition attempt"), from_file);
 325                       should_jump_to_top_level = 0;
 326                       last_result = last_command_exit_value = EX_BADUSAGE;
 327                       reset_parser ();
 328                       break;
 329                     }
 330                 }
 331
 332               bitmap = new_fd_bitmap (FD_BITMAP_SIZE);
 333               begin_unwind_frame ("pe_dispose");
 334               add_unwind_protect (dispose_fd_bitmap, bitmap);
 335               add_unwind_protect (dispose_command, command);    /* XXX */
 336
 337               global_command = (COMMAND *)NULL;
 338
 339               if ((subshell_environment & SUBSHELL_COMSUB) && comsub_ignore_return)
 340                 command->flags |= CMD_IGNORE_RETURN;
 341
 342 #if defined (ONESHOT)
 343               /*
 344                * IF
 345                *   we were invoked as `bash -c' (startup_state == 2) AND
 346                *   parse_and_execute has not been called recursively AND
 347                *   we're not running a trap AND
 348                *   we have parsed the full command (string == '\0') AND
 349                *   we're not going to run the exit trap AND
 350                *   we have a simple command without redirections AND
 351                *   the command is not being timed AND
 352                *   the command's return status is not being inverted
 353                * THEN
 354                *   tell the execution code that we don't need to fork
 355                */
 356               if (startup_state == 2 && parse_and_execute_level == 1 &&
 357                   running_trap == 0 &&
 358                   *bash_input.location.string == '\0' &&
 359                   command->type == cm_simple &&
 360                   signal_is_trapped (EXIT_TRAP) == 0 &&
 361                   command->redirects == 0 && command->value.Simple->redirects == 0 &&
 362                   ((command->flags & CMD_TIME_PIPELINE) == 0) &&
 363                   ((command->flags & CMD_INVERT_RETURN) == 0))
 364                 {
 365                   command->flags |= CMD_NO_FORK;
 366                   command->value.Simple->flags |= CMD_NO_FORK;
 367                 }
 368 #endif /* ONESHOT */
 369
 370               /* See if this is a candidate for $( <file ). */
 371               if (startup_state == 2 &&
 372                   (subshell_environment & SUBSHELL_COMSUB) &&
 373                   *bash_input.location.string == '\0' &&
 374                   command->type == cm_simple && !command->redirects &&
 375                   (command->flags & CMD_TIME_PIPELINE) == 0 &&
 376                   command->value.Simple->words == 0 &&
 377                   command->value.Simple->redirects &&
 378                   command->value.Simple->redirects->next == 0 &&
 379                   command->value.Simple->redirects->instruction == r_input_direction &&
 380                   command->value.Simple->redirects->redirector.dest == 0)
 381                 {
 382                   int r;
 383                   r = cat_file (command->value.Simple->redirects);
 384                   last_result = (r < 0) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
 385                 }
 386               else
 387                 last_result = execute_command_internal
 388                                 (command, 0, NO_PIPE, NO_PIPE, bitmap);
 389               dispose_command (command);
 390               dispose_fd_bitmap (bitmap);
 391               discard_unwind_frame ("pe_dispose");
 392
 393               if (flags & SEVAL_ONECMD)
 394                 {
 395                   reset_parser ();
 396                   break;
 397                 }
 398             }
 399         }
 400       else
 401         {
 402           last_result = EXECUTION_FAILURE;
 403
 404           if (interactive_shell == 0 && this_shell_builtin &&
 405               (this_shell_builtin == source_builtin || this_shell_builtin == eval_builtin) &&
 406               last_command_exit_value == EX_BADSYNTAX && posixly_correct)
 407             {
 408               should_jump_to_top_level = 1;
 409               code = ERREXIT;
 410               last_command_exit_value = EX_BADUSAGE;
 411             }
 412
 413           /* Since we are shell compatible, syntax errors in a script
 414              abort the execution of the script.  Right? */
 415           break;
 416         }
 417     }
 418
 419  out:
 420
 421   run_unwind_frame (PE_TAG);
 422
 423   if (interrupt_state && parse_and_execute_level == 0)
 424     {
 425       /* An interrupt during non-interactive execution in an
 426          interactive shell (e.g. via $PROMPT_COMMAND) should
 427          not cause the shell to exit. */
 428       interactive = interactive_shell;
 429       throw_to_top_level ();
 430     }
 431
 432   if (should_jump_to_top_level)
 433     jump_to_top_level (code);
 434
 435   return (last_result);
 436 }
 437
 438 /* Parse a command contained in STRING according to FLAGS and return the
 439    number of characters consumed from the string.  If non-NULL, set *ENDP
 440    to the position in the string where the parse ended.  Used to validate
 441    command substitutions during parsing to obey Posix rules about finding
 442    the end of the command and balancing parens. */
 443 int
 444 parse_string (string, from_file, flags, endp)
 445      char *string;
 446      const char *from_file;
 447      int flags;
 448      char **endp;
 449 {
 450   int code, nc;
 451   volatile int should_jump_to_top_level;
 452   COMMAND *volatile command, *oglobal;
 453   char *ostring;
 454   volatile sigset_t ps_sigmask;
 455
 456   parse_prologue (string, flags, PS_TAG);
 457
 458 #if defined (HAVE_POSIX_SIGNALS)
 459   /* If we longjmp and are going to go on, use this to restore signal mask */
 460   sigemptyset (&ps_sigmask);
 461   sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &ps_sigmask);
 462 #endif
 463
 464 /* itrace("parse_string: `%s'", string); */
 465   /* Reset the line number if the caller wants us to.  If we don't reset the
 466      line number, we have to subtract one, because we will add one just
 467      before executing the next command (resetting the line number sets it to
 468      0; the first line number is 1). */
 469   push_stream (0);
 470   if (parser_expanding_alias ())
 471     /* push current shell_input_line */
 472     parser_save_alias ();
 473
 474   code = should_jump_to_top_level = 0;
 475   oglobal = global_command;
 476   ostring = string;
 477
 478   with_input_from_string (string, from_file);
 479   while (*(bash_input.location.string))
 480     {
 481       command = (COMMAND *)NULL;
 482
 483 #if 0
 484       if (interrupt_state)
 485         break;
 486 #endif
 487
 488       /* Provide a location for functions which `longjmp (top_level)' to
 489          jump to. */
 490       code = setjmp_nosigs (top_level);
 491
 492       if (code)
 493         {
 494 #if defined (DEBUG)
 495 itrace("parse_string: longjmp executed: code = %d", code);
 496 #endif
 497           should_jump_to_top_level = 0;
 498           switch (code)
 499             {
 500             case FORCE_EOF:
 501             case ERREXIT:
 502             case EXITPROG:
 503             case DISCARD:               /* XXX */
 504               if (command)
 505                 dispose_command (command);
 506               /* Remember to call longjmp (top_level) after the old
 507                  value for it is restored. */
 508               should_jump_to_top_level = 1;
 509               goto out;
 510
 511             default:
 512 #if defined (HAVE_POSIX_SIGNALS)
 513               sigprocmask (SIG_SETMASK, &ps_sigmask, (sigset_t *)NULL);
 514 #endif
 515               command_error ("parse_string", CMDERR_BADJUMP, code, 0);
 516               break;
 517             }
 518         }
 519
 520       if (parse_command () == 0)
 521         {
 522           dispose_command (global_command);
 523           global_command = (COMMAND *)NULL;
 524         }
 525       else
 526         {
 527           if ((flags & SEVAL_NOLONGJMP) == 0)
 528             {
 529               should_jump_to_top_level = 1;
 530               code = DISCARD;
 531             }
 532           else
 533             reset_parser ();    /* XXX - sets token_to_read */
 534           break;
 535         }
 536
 537       if (current_token == yacc_EOF || current_token == shell_eof_token)
 538           break;
 539     }
 540
 541  out:
 542
 543   global_command = oglobal;
 544   nc = bash_input.location.string - ostring;
 545   if (endp)
 546     *endp = bash_input.location.string;
 547
 548   run_unwind_frame (PS_TAG);
 549
 550   if (should_jump_to_top_level)
 551     jump_to_top_level (code);
 552
 553   return (nc);
 554 }
 555
 556 /* Handle a $( < file ) command substitution.  This expands the filename,
 557    returning errors as appropriate, then just cats the file to the standard
 558    output. */
 559 static int
 560 cat_file (r)
 561      REDIRECT *r;
 562 {
 563   char *fn;
 564   int fd, rval;
 565
 566   if (r->instruction != r_input_direction)
 567     return -1;
 568
 569   /* Get the filename. */
 570   if (posixly_correct && !interactive_shell)
 571     disallow_filename_globbing++;
 572   fn = redirection_expand (r->redirectee.filename);
 573   if (posixly_correct && !interactive_shell)
 574     disallow_filename_globbing--;
 575
 576   if (fn == 0)
 577     {
 578       redirection_error (r, AMBIGUOUS_REDIRECT);
 579       return -1;
 580     }
 581
 582   fd = open(fn, O_RDONLY);
 583   if (fd < 0)
 584     {
 585       file_error (fn);
 586       free (fn);
 587       return -1;
 588     }
 589
 590   rval = zcatfd (fd, 1, fn);
 591
 592   free (fn);
 593   close (fd);
 594
 595   return (rval);
 596 }
 597
 598 int
 599 evalstring (string, from_file, flags)
 600      char *string;
 601      const char *from_file;
 602      int flags;
 603 {
 604   volatile int r, rflag, rcatch;
 605
 606   rcatch = 0;
 607   rflag = return_catch_flag;
 608   /* If we are in a place where `return' is valid, we have to catch
 609      `eval "... return"' and make sure parse_and_execute cleans up. Then
 610      we can trampoline to the previous saved return_catch location. */
 611   if (rflag)
 612     {
 613       begin_unwind_frame ("evalstring");
 614
 615       unwind_protect_int (return_catch_flag);
 616       unwind_protect_jmp_buf (return_catch);
 617
 618       return_catch_flag++;      /* increment so we have a counter */
 619       rcatch = setjmp_nosigs (return_catch);
 620     }
 621
 622   if (rcatch)
 623     {
 624       parse_and_execute_cleanup ();
 625       r = return_catch_value;
 626     }
 627   else
 628     /* Note that parse_and_execute () frees the string it is passed. */
 629     r = parse_and_execute (string, from_file, flags);
 630
 631   if (rflag)
 632     {
 633       run_unwind_frame ("evalstring");
 634       if (rcatch && return_catch_flag)
 635         {
 636           return_catch_value = r;
 637           longjmp (return_catch, 1);
 638         }
 639     }
 640
 641   return (r);
 642 }