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) 56extern int errno; 57#endif 58 59#define IS_BUILTIN(s) (builtin_address_internal(s, 0) != (struct builtin *)NULL) 60 61extern int indirection_level, subshell_environment; 62extern int line_number; 63extern int current_token, shell_eof_token; 64extern int last_command_exit_value; 65extern int running_trap; 66extern int loop_level; 67extern int executing_list; 68extern int comsub_ignore_return; 69extern int posixly_correct; 70 71int parse_and_execute_level = 0; 72 73static 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) 79static void 80set_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. */ 87void 88parse_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 102static void 103parse_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 166int 167parse_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. */ 357int 358parse_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) 398itrace("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. */ 459static int 460cat_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} 497