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