1 /* execute_command.c -- Execute a COMMAND structure. */
3 /* Copyright (C) 1987,1991 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 1, or (at your option)
12 Bash is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash; see the file COPYING. If not, write to the Free
19 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
24 #endif /* _AIX && RISC6000 && !__GNUC__ */
28 #include "bashtypes.h"
30 # include <sys/file.h>
33 #include "posixstat.h"
36 # include <sys/param.h>
39 #if defined (HAVE_UNISTD_H)
43 #if defined (HAVE_LIMITS_H)
47 /* Some systems require this, mostly for the definition of `struct timezone'.
48 For example, Dynix/ptx has that definition in <time.h> rather than
50 #if defined (TIME_WITH_SYS_TIME)
51 # include <sys/time.h>
54 # if defined (HAVE_SYS_TIME_H)
55 # include <sys/time.h>
61 #if defined (HAVE_SYS_RESOURCE_H) && !defined (RLIMTYPE)
62 # include <sys/resource.h>
65 #if defined (HAVE_SYS_TIMES_H) && defined (HAVE_TIMES)
66 # include <sys/times.h>
79 #include <y.tab.h> /* use <...> so we pick it up from the build directory */
84 #include "execute_cmd.h"
91 #if defined (COND_COMMAND)
95 #include "builtins/common.h"
96 #include "builtins/builtext.h" /* list of builtins */
98 #include <glob/fnmatch.h>
99 #include <tilde/tilde.h>
101 #if defined (BUFFERED_INPUT)
109 #if defined (HISTORY)
110 # include "bashhist.h"
113 extern int posixly_correct
;
114 extern int executing
, breaking
, continuing
, loop_level
;
115 extern int interactive
, interactive_shell
, login_shell
, expand_aliases
;
116 extern int parse_and_execute_level
, running_trap
, trap_line_number
;
117 extern int command_string_index
, variable_context
, line_number
;
118 extern int dot_found_in_search
;
119 extern int already_making_children
;
120 extern char **temporary_env
, **function_env
, **builtin_env
;
121 extern char *the_printed_command
, *shell_name
;
122 extern pid_t last_command_subst_pid
;
123 extern Function
*last_shell_builtin
, *this_shell_builtin
;
124 extern char **subshell_argv
, **subshell_envp
;
125 extern int subshell_argc
;
126 extern char *glob_argv_flags
;
128 extern int getdtablesize ();
131 /* Static functions defined and used in this file. */
132 static void close_pipes (), do_piping (), bind_lastarg ();
133 static void cleanup_redirects ();
135 static int execute_for_command ();
136 #if defined (SELECT_COMMAND)
137 static int execute_select_command ();
139 #if defined (DPAREN_ARITHMETIC)
140 static int execute_arith_command ();
142 #if defined (COND_COMMAND)
143 static int execute_cond_command ();
145 #if defined (COMMAND_TIMING)
146 static int time_command ();
148 static int execute_case_command ();
149 static int execute_while_command (), execute_until_command ();
150 static int execute_while_or_until ();
151 static int execute_if_command ();
152 static int execute_simple_command ();
153 static int execute_builtin (), execute_function ();
154 static int execute_builtin_or_function ();
155 static int builtin_status ();
156 static void execute_subshell_builtin_or_function ();
157 static void execute_disk_command ();
158 static int execute_connection ();
159 static int execute_intern_function ();
161 /* The line number that the currently executing function starts on. */
162 static int function_line_number
;
164 /* Set to 1 if fd 0 was the subject of redirection to a subshell. Global
165 so that reader_loop can set it to zero before executing a command. */
168 /* The name of the command that is currently being executed.
169 `test' needs this, for example. */
170 char *this_command_name
;
172 static COMMAND
*currently_executing_command
;
174 struct stat SB
; /* used for debugging */
176 static int special_builtin_failed
;
178 /* For catching RETURN in a function. */
179 int return_catch_flag
;
180 int return_catch_value
;
181 procenv_t return_catch
;
183 /* The value returned by the last synchronous command. */
184 int last_command_exit_value
;
186 /* The list of redirections to perform which will undo the redirections
187 that I made in the shell. */
188 REDIRECT
*redirection_undo_list
= (REDIRECT
*)NULL
;
190 /* The list of redirections to perform which will undo the internal
191 redirections performed by the `exec' builtin. These are redirections
192 that must be undone even when exec discards redirection_undo_list. */
193 REDIRECT
*exec_redirection_undo_list
= (REDIRECT
*)NULL
;
195 /* Non-zero if we have just forked and are currently running in a subshell
197 int subshell_environment
;
199 struct fd_bitmap
*current_fds_to_close
= (struct fd_bitmap
*)NULL
;
201 #define FD_BITMAP_DEFAULT_SIZE 32L
203 /* Functions to allocate and deallocate the structures used to pass
204 information from the shell to its children about file descriptors
210 struct fd_bitmap
*ret
;
212 ret
= (struct fd_bitmap
*)xmalloc (sizeof (struct fd_bitmap
));
218 ret
->bitmap
= xmalloc (size
);
219 bzero (ret
->bitmap
, size
);
222 ret
->bitmap
= (char *)NULL
;
227 dispose_fd_bitmap (fdbp
)
228 struct fd_bitmap
*fdbp
;
235 close_fd_bitmap (fdbp
)
236 struct fd_bitmap
*fdbp
;
242 for (i
= 0; i
< fdbp
->size
; i
++)
251 /* Return the line number of the currently executing command. */
253 executing_line_number ()
255 if (executing
&& variable_context
== 0 && currently_executing_command
&&
256 currently_executing_command
->type
== cm_simple
)
257 return currently_executing_command
->value
.Simple
->line
;
258 else if (running_trap
)
259 return trap_line_number
;
264 /* Execute the command passed in COMMAND. COMMAND is exactly what
265 read_command () places into GLOBAL_COMMAND. See "command.h" for the
266 details of the command structure.
268 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
269 return values. Executing a command with nothing in it returns
270 EXECUTION_SUCCESS. */
272 execute_command (command
)
275 struct fd_bitmap
*bitmap
;
278 current_fds_to_close
= (struct fd_bitmap
*)NULL
;
279 bitmap
= new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE
);
280 begin_unwind_frame ("execute-command");
281 add_unwind_protect (dispose_fd_bitmap
, (char *)bitmap
);
283 /* Just do the command, but not asynchronously. */
284 result
= execute_command_internal (command
, 0, NO_PIPE
, NO_PIPE
, bitmap
);
286 dispose_fd_bitmap (bitmap
);
287 discard_unwind_frame ("execute-command");
289 #if defined (PROCESS_SUBSTITUTION)
291 #endif /* PROCESS_SUBSTITUTION */
296 /* Return 1 if TYPE is a shell control structure type. */
298 shell_control_structure (type
)
299 enum command_type type
;
304 #if defined (SELECT_COMMAND)
307 #if defined (DPAREN_ARITHMETIC)
310 #if defined (COND_COMMAND)
325 /* A function to use to unwind_protect the redirection undo list
328 cleanup_redirects (list
)
331 do_redirections (list
, 1, 0, 0);
332 dispose_redirects (list
);
336 /* Function to unwind_protect the redirections for functions and builtins. */
338 cleanup_func_redirects (list
)
341 do_redirections (list
, 1, 0, 0);
346 dispose_exec_redirects ()
348 if (exec_redirection_undo_list
)
350 dispose_redirects (exec_redirection_undo_list
);
351 exec_redirection_undo_list
= (REDIRECT
*)NULL
;
355 #if defined (JOB_CONTROL)
356 /* A function to restore the signal mask to its proper value when the shell
357 is interrupted or errors occur while creating a pipeline. */
359 restore_signal_mask (set
)
362 return (sigprocmask (SIG_SETMASK
, &set
, (sigset_t
*)NULL
));
364 #endif /* JOB_CONTROL */
366 /* A debugging function that can be called from gdb, for instance. */
371 int f
, fd_table_size
;
373 fd_table_size
= getdtablesize ();
375 fprintf (stderr
, "pid %d open files:", (int)getpid ());
376 for (i
= 3; i
< fd_table_size
; i
++)
378 if ((f
= fcntl (i
, F_GETFD
, 0)) != -1)
379 fprintf (stderr
, " %d (%s)", i
, f
? "close" : "open");
381 fprintf (stderr
, "\n");
385 async_redirect_stdin ()
389 fd
= open ("/dev/null", O_RDONLY
);
396 internal_error ("cannot redirect standard input from /dev/null: %s", strerror (errno
));
399 #define DESCRIBE_PID(pid) do { if (interactive) describe_pid (pid); } while (0)
401 /* Execute the command passed in COMMAND, perhaps doing it asynchrounously.
402 COMMAND is exactly what read_command () places into GLOBAL_COMMAND.
403 ASYNCHROUNOUS, if non-zero, says to do this command in the background.
404 PIPE_IN and PIPE_OUT are file descriptors saying where input comes
405 from and where it goes. They can have the value of NO_PIPE, which means
407 FDS_TO_CLOSE is a list of file descriptors to close once the child has
408 been forked. This list often contains the unusable sides of pipes, etc.
410 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
411 return values. Executing a command with nothing in it returns
412 EXECUTION_SUCCESS. */
414 execute_command_internal (command
, asynchronous
, pipe_in
, pipe_out
,
418 int pipe_in
, pipe_out
;
419 struct fd_bitmap
*fds_to_close
;
421 int exec_result
, invert
, ignore_return
, was_debug_trap
;
422 REDIRECT
*my_undo_list
, *exec_undo_list
;
423 volatile pid_t last_pid
;
425 if (command
== 0 || breaking
|| continuing
|| read_but_dont_execute
)
426 return (EXECUTION_SUCCESS
);
428 run_pending_traps ();
430 if (running_trap
== 0)
431 currently_executing_command
= command
;
433 invert
= (command
->flags
& CMD_INVERT_RETURN
) != 0;
435 /* If we're inverting the return value and `set -e' has been executed,
436 we don't want a failing command to inadvertently cause the shell
438 if (exit_immediately_on_error
&& invert
) /* XXX */
439 command
->flags
|= CMD_IGNORE_RETURN
; /* XXX */
441 exec_result
= EXECUTION_SUCCESS
;
443 /* If a command was being explicitly run in a subshell, or if it is
444 a shell control-structure, and it has a pipe, then we do the command
447 if ((command
->flags
& (CMD_WANT_SUBSHELL
|CMD_FORCE_SUBSHELL
)) ||
448 (shell_control_structure (command
->type
) &&
449 (pipe_out
!= NO_PIPE
|| pipe_in
!= NO_PIPE
|| asynchronous
)))
453 /* Fork a subshell, turn off the subshell bit, turn off job
454 control and call execute_command () on the command again. */
455 paren_pid
= make_child (savestring (make_command_string (command
)),
459 int user_subshell
, return_code
, function_value
, should_redir_stdin
;
461 should_redir_stdin
= (asynchronous
&& (command
->flags
& CMD_STDIN_REDIR
) &&
462 pipe_in
== NO_PIPE
&&
463 stdin_redirects (command
->redirects
) == 0);
465 user_subshell
= (command
->flags
& CMD_WANT_SUBSHELL
) != 0;
466 command
->flags
&= ~(CMD_FORCE_SUBSHELL
| CMD_WANT_SUBSHELL
| CMD_INVERT_RETURN
);
468 /* If a command is asynchronous in a subshell (like ( foo ) & or
469 the special case of an asynchronous GROUP command where the
470 the subshell bit is turned on down in case cm_group: below),
471 turn off `asynchronous', so that two subshells aren't spawned.
473 This seems semantically correct to me. For example,
474 ( foo ) & seems to say ``do the command `foo' in a subshell
475 environment, but don't wait for that subshell to finish'',
476 and "{ foo ; bar } &" seems to me to be like functions or
477 builtins in the background, which executed in a subshell
478 environment. I just don't see the need to fork two subshells. */
480 /* Don't fork again, we are already in a subshell. A `doubly
481 async' shell is not interactive, however. */
484 #if defined (JOB_CONTROL)
485 /* If a construct like ( exec xxx yyy ) & is given while job
486 control is active, we want to prevent exec from putting the
487 subshell back into the original process group, carefully
488 undoing all the work we just did in make_child. */
490 #endif /* JOB_CONTROL */
491 interactive_shell
= 0;
496 /* Subshells are neither login nor interactive. */
497 login_shell
= interactive
= 0;
499 subshell_environment
= user_subshell
? SUBSHELL_PAREN
: SUBSHELL_ASYNC
;
501 reset_terminating_signals (); /* in shell.c */
502 /* Cancel traps, in trap.c. */
503 restore_original_signals ();
505 setup_async_signals ();
507 #if defined (JOB_CONTROL)
508 set_sigchld_handler ();
509 #endif /* JOB_CONTROL */
511 set_sigint_handler ();
513 #if defined (JOB_CONTROL)
514 /* Delete all traces that there were any jobs running. This is
515 only for subshells. */
516 without_job_control ();
517 #endif /* JOB_CONTROL */
518 do_piping (pipe_in
, pipe_out
);
520 /* If this is a user subshell, set a flag if stdin was redirected.
521 This is used later to decide whether to redirect fd 0 to
522 /dev/null for async commands in the subshell. This adds more
523 sh compatibility, but I'm not sure it's the right thing to do. */
526 stdin_redir
= stdin_redirects (command
->redirects
);
527 restore_default_signal (0);
531 close_fd_bitmap (fds_to_close
);
533 /* If this is an asynchronous command (command &), we want to
534 redirect the standard input from /dev/null in the absence of
535 any specific redirection involving stdin. */
536 if (should_redir_stdin
&& stdin_redir
== 0)
537 async_redirect_stdin ();
539 /* Do redirections, then dispose of them before recursive call. */
540 if (command
->redirects
)
542 if (do_redirections (command
->redirects
, 1, 0, 0) != 0)
543 exit (EXECUTION_FAILURE
);
545 dispose_redirects (command
->redirects
);
546 command
->redirects
= (REDIRECT
*)NULL
;
549 /* If this is a simple command, tell execute_disk_command that it
550 might be able to get away without forking and simply exec.
551 This means things like ( sleep 10 ) will only cause one fork.
552 If we're timing the command, however, we cannot do this
555 if (user_subshell
&& command
->type
== cm_simple
)
557 if (user_subshell
&& command
->type
== cm_simple
&& (command
->flags
& CMD_TIME_PIPELINE
) == 0)
560 command
->flags
|= CMD_NO_FORK
;
561 command
->value
.Simple
->flags
|= CMD_NO_FORK
;
564 /* If we're inside a function while executing this subshell, we
565 need to handle a possible `return'. */
567 if (return_catch_flag
)
568 function_value
= setjmp (return_catch
);
571 return_code
= return_catch_value
;
573 return_code
= execute_command_internal
574 (command
, asynchronous
, NO_PIPE
, NO_PIPE
, fds_to_close
);
576 /* If we were explicitly placed in a subshell with (), we need
577 to do the `shell cleanup' things, such as running traps[0]. */
578 if (user_subshell
&& signal_is_trapped (0))
580 last_command_exit_value
= return_code
;
581 return_code
= run_exit_trap ();
588 close_pipes (pipe_in
, pipe_out
);
590 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
593 /* If we are part of a pipeline, and not the end of the pipeline,
594 then we should simply return and let the last command in the
595 pipe be waited for. If we are not in a pipeline, or are the
596 last command in the pipeline, then we wait for the subshell
597 and return its exit status as usual. */
598 if (pipe_out
!= NO_PIPE
)
599 return (EXECUTION_SUCCESS
);
601 stop_pipeline (asynchronous
, (COMMAND
*)NULL
);
603 if (asynchronous
== 0)
605 last_command_exit_value
= wait_for (paren_pid
);
607 /* If we have to, invert the return value. */
609 return ((last_command_exit_value
== EXECUTION_SUCCESS
)
611 : EXECUTION_SUCCESS
);
613 return (last_command_exit_value
);
617 DESCRIBE_PID (paren_pid
);
619 run_pending_traps ();
621 return (EXECUTION_SUCCESS
);
626 #if defined (COMMAND_TIMING)
627 if (command
->flags
& CMD_TIME_PIPELINE
)
631 command
->flags
|= CMD_FORCE_SUBSHELL
;
632 exec_result
= execute_command_internal (command
, 1, pipe_in
, pipe_out
, fds_to_close
);
636 exec_result
= time_command (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
637 if (running_trap
== 0)
638 currently_executing_command
= (COMMAND
*)NULL
;
640 return (exec_result
);
642 #endif /* COMMAND_TIMING */
644 if (shell_control_structure (command
->type
) && command
->redirects
)
645 stdin_redir
= stdin_redirects (command
->redirects
);
647 /* Handle WHILE FOR CASE etc. with redirections. (Also '&' input
649 if (do_redirections (command
->redirects
, 1, 1, 0) != 0)
651 cleanup_redirects (redirection_undo_list
);
652 redirection_undo_list
= (REDIRECT
*)NULL
;
653 dispose_exec_redirects ();
654 return (EXECUTION_FAILURE
);
657 if (redirection_undo_list
)
659 my_undo_list
= (REDIRECT
*)copy_redirects (redirection_undo_list
);
660 dispose_redirects (redirection_undo_list
);
661 redirection_undo_list
= (REDIRECT
*)NULL
;
664 my_undo_list
= (REDIRECT
*)NULL
;
666 if (exec_redirection_undo_list
)
668 exec_undo_list
= (REDIRECT
*)copy_redirects (exec_redirection_undo_list
);
669 dispose_redirects (exec_redirection_undo_list
);
670 exec_redirection_undo_list
= (REDIRECT
*)NULL
;
673 exec_undo_list
= (REDIRECT
*)NULL
;
675 if (my_undo_list
|| exec_undo_list
)
676 begin_unwind_frame ("loop_redirections");
679 add_unwind_protect ((Function
*)cleanup_redirects
, my_undo_list
);
682 add_unwind_protect ((Function
*)dispose_redirects
, exec_undo_list
);
684 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
688 switch (command
->type
)
692 /* We can't rely on this variable retaining its value across a
693 call to execute_simple_command if a longjmp occurs as the
694 result of a `return' builtin. This is true for sure with gcc. */
695 last_pid
= last_made_pid
;
696 was_debug_trap
= signal_is_trapped (DEBUG_TRAP
) && signal_is_ignored (DEBUG_TRAP
) == 0;
698 if (ignore_return
&& command
->value
.Simple
)
699 command
->value
.Simple
->flags
|= CMD_IGNORE_RETURN
;
700 if (command
->flags
& CMD_STDIN_REDIR
)
701 command
->value
.Simple
->flags
|= CMD_STDIN_REDIR
;
703 execute_simple_command (command
->value
.Simple
, pipe_in
, pipe_out
,
704 asynchronous
, fds_to_close
);
706 /* The temporary environment should be used for only the simple
707 command immediately following its definition. */
708 dispose_used_env_vars ();
710 #if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
711 /* Reclaim memory allocated with alloca () on machines which
712 may be using the alloca emulation code. */
714 #endif /* (ultrix && mips) || C_ALLOCA */
716 /* If we forked to do the command, then we must wait_for ()
719 /* XXX - this is something to watch out for if there are problems
720 when the shell is compiled without job control. */
721 if (already_making_children
&& pipe_out
== NO_PIPE
&&
722 last_pid
!= last_made_pid
)
724 stop_pipeline (asynchronous
, (COMMAND
*)NULL
);
728 DESCRIBE_PID (last_made_pid
);
731 #if !defined (JOB_CONTROL)
732 /* Do not wait for asynchronous processes started from
734 if (last_made_pid
!= last_asynchronous_pid
)
736 /* When executing a shell function that executes other
737 commands, this causes the last simple command in
738 the function to be waited for twice. */
739 exec_result
= wait_for (last_made_pid
);
740 #if defined (RECYCLES_PIDS)
741 /* LynxOS, for one, recycles pids very quickly -- so quickly
742 that a new process may have the same pid as the last one
743 created. This has been reported to fix the problem. */
744 if (exec_result
== 0)
745 last_made_pid
= NO_PID
;
753 if (ignore_return
== 0 && invert
== 0 &&
754 ((posixly_correct
&& interactive
== 0 && special_builtin_failed
) ||
755 (exit_immediately_on_error
&& (exec_result
!= EXECUTION_SUCCESS
))))
757 last_command_exit_value
= exec_result
;
758 run_pending_traps ();
759 jump_to_top_level (EXITPROG
);
766 command
->value
.For
->flags
|= CMD_IGNORE_RETURN
;
767 exec_result
= execute_for_command (command
->value
.For
);
770 #if defined (SELECT_COMMAND)
773 command
->value
.Select
->flags
|= CMD_IGNORE_RETURN
;
774 exec_result
= execute_select_command (command
->value
.Select
);
780 command
->value
.Case
->flags
|= CMD_IGNORE_RETURN
;
781 exec_result
= execute_case_command (command
->value
.Case
);
786 command
->value
.While
->flags
|= CMD_IGNORE_RETURN
;
787 exec_result
= execute_while_command (command
->value
.While
);
792 command
->value
.While
->flags
|= CMD_IGNORE_RETURN
;
793 exec_result
= execute_until_command (command
->value
.While
);
798 command
->value
.If
->flags
|= CMD_IGNORE_RETURN
;
799 exec_result
= execute_if_command (command
->value
.If
);
804 /* This code can be executed from either of two paths: an explicit
805 '{}' command, or via a function call. If we are executed via a
806 function call, we have already taken care of the function being
807 executed in the background (down there in execute_simple_command ()),
808 and this command should *not* be marked as asynchronous. If we
809 are executing a regular '{}' group command, and asynchronous == 1,
810 we must want to execute the whole command in the background, so we
811 need a subshell, and we want the stuff executed in that subshell
812 (this group command) to be executed in the foreground of that
813 subshell (i.e. there will not be *another* subshell forked).
815 What we do is to force a subshell if asynchronous, and then call
816 execute_command_internal again with asynchronous still set to 1,
817 but with the original group command, so the printed command will
820 The code above that handles forking off subshells will note that
821 both subshell and async are on, and turn off async in the child
822 after forking the subshell (but leave async set in the parent, so
823 the normal call to describe_pid is made). This turning off
824 async is *crucial*; if it is not done, this will fall into an
825 infinite loop of executions through this spot in subshell after
826 subshell until the process limit is exhausted. */
830 command
->flags
|= CMD_FORCE_SUBSHELL
;
832 execute_command_internal (command
, 1, pipe_in
, pipe_out
,
837 if (ignore_return
&& command
->value
.Group
->command
)
838 command
->value
.Group
->command
->flags
|= CMD_IGNORE_RETURN
;
840 execute_command_internal (command
->value
.Group
->command
,
841 asynchronous
, pipe_in
, pipe_out
,
847 exec_result
= execute_connection (command
, asynchronous
,
848 pipe_in
, pipe_out
, fds_to_close
);
851 #if defined (DPAREN_ARITHMETIC)
854 command
->value
.Arith
->flags
|= CMD_IGNORE_RETURN
;
855 exec_result
= execute_arith_command (command
->value
.Arith
);
859 #if defined (COND_COMMAND)
862 command
->value
.Cond
->flags
|= CMD_IGNORE_RETURN
;
863 exec_result
= execute_cond_command (command
->value
.Cond
);
867 case cm_function_def
:
868 exec_result
= execute_intern_function (command
->value
.Function_def
->name
,
869 command
->value
.Function_def
->command
);
873 command_error ("execute_command", CMDERR_BADTYPE
, command
->type
, 0);
878 do_redirections (my_undo_list
, 1, 0, 0);
879 dispose_redirects (my_undo_list
);
883 dispose_redirects (exec_undo_list
);
885 if (my_undo_list
|| exec_undo_list
)
886 discard_unwind_frame ("loop_redirections");
888 /* Invert the return value if we have to */
890 exec_result
= (exec_result
== EXECUTION_SUCCESS
)
894 last_command_exit_value
= exec_result
;
895 run_pending_traps ();
896 if (running_trap
== 0)
897 currently_executing_command
= (COMMAND
*)NULL
;
898 return (last_command_exit_value
);
901 #if defined (COMMAND_TIMING)
902 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
903 static struct timeval
*
904 difftimeval (d
, t1
, t2
)
905 struct timeval
*d
, *t1
, *t2
;
907 d
->tv_sec
= t2
->tv_sec
- t1
->tv_sec
;
908 d
->tv_usec
= t2
->tv_usec
- t1
->tv_usec
;
911 d
->tv_usec
+= 1000000;
913 if (d
->tv_sec
< 0) /* ??? -- BSD/OS does this */
922 static struct timeval
*
923 addtimeval (d
, t1
, t2
)
924 struct timeval
*d
, *t1
, *t2
;
926 d
->tv_sec
= t1
->tv_sec
+ t2
->tv_sec
;
927 d
->tv_usec
= t1
->tv_usec
+ t2
->tv_usec
;
928 if (d
->tv_usec
>= 1000000)
930 d
->tv_usec
-= 1000000;
936 /* Do "cpu = ((user + sys) * 10000) / real;" with timevals.
937 Barely-tested code from Deven T. Corzine <deven@ties.org>. */
939 timeval_to_cpu (rt
, ut
, st
)
940 struct timeval
*rt
, *ut
, *st
; /* real, user, sys */
942 struct timeval t1
, t2
;
945 addtimeval (&t1
, ut
, st
);
946 t2
.tv_sec
= rt
->tv_sec
;
947 t2
.tv_usec
= rt
->tv_usec
;
949 for (i
= 0; i
< 6; i
++)
951 if ((t1
.tv_sec
> 99999999) || (t2
.tv_sec
> 99999999))
954 t1
.tv_sec
+= t1
.tv_usec
/ 100000;
956 t1
.tv_usec
%= 1000000;
958 t2
.tv_sec
+= t2
.tv_usec
/ 100000;
960 t2
.tv_usec
%= 1000000;
962 for (i
= 0; i
< 4; i
++)
964 if (t1
.tv_sec
< 100000000)
970 return ((t2
.tv_sec
== 0) ? 0 : t1
.tv_sec
/ t2
.tv_sec
);
972 #endif /* HAVE_GETRUSAGE && HAVE_GETTIMEOFDAY */
974 #define POSIX_TIMEFORMAT "real %2R\nuser %2U\nsys %2S"
975 #define BASH_TIMEFORMAT "\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS"
977 static int precs
[] = { 0, 100, 10, 1 };
979 /* Expand one `%'-prefixed escape sequence from a time format string. */
981 mkfmt (buf
, prec
, lng
, sec
, sec_fraction
)
994 /* If LNG is non-zero, we want to decompose SEC into minutes and seconds. */
1001 abuf
[aind
--] = (min
% 10) + '0';
1005 buf
[ind
++] = abuf
[aind
++];
1009 /* Now add the seconds. */
1012 abuf
[aind
--] = (sec
% 10) + '0';
1016 buf
[ind
++] = abuf
[aind
++];
1018 /* We want to add a decimal point and PREC places after it if PREC is
1019 nonzero. PREC is not greater than 3. SEC_FRACTION is between 0
1024 for (aind
= 1; aind
<= prec
; aind
++)
1026 buf
[ind
++] = (sec_fraction
/ precs
[aind
]) + '0';
1027 sec_fraction
%= precs
[aind
];
1038 /* Interpret the format string FORMAT, interpolating the following escape
1042 where the optional `prec' is a precision, meaning the number of
1043 characters after the decimal point, the optional `l' means to format
1044 using minutes and seconds (MMmNN[.FF]s), like the `times' builtin',
1045 and the last character is one of
1047 R number of seconds of `real' time
1048 U number of seconds of `user' time
1049 S number of seconds of `system' time
1051 An occurrence of `%%' in the format string is translated to a `%'. The
1052 result is printed to FP, a pointer to a FILE. The other variables are
1053 the seconds and thousandths of a second of real, user, and system time,
1056 print_formatted_time (fp
, format
, rs
, rsf
, us
, usf
, ss
, ssf
, cpu
)
1060 int rsf
, usf
, ssf
, cpu
;
1063 char *str
, *s
, ts
[32];
1068 len
= strlen (format
);
1069 ssize
= (len
+ 64) - (len
% 64);
1070 str
= xmalloc (ssize
);
1073 for (s
= format
; *s
; s
++)
1075 if (*s
!= '%' || s
[1] == '\0')
1077 RESIZE_MALLOCED_BUFFER (str
, sindex
, 1, ssize
, 64);
1080 else if (s
[1] == '%')
1083 RESIZE_MALLOCED_BUFFER (str
, sindex
, 1, ssize
, 64);
1086 else if (s
[1] == 'P')
1092 sum_frac
= (cpu
% 100) * 10;
1093 len
= mkfmt (ts
, 2, 0, sum
, sum_frac
);
1094 RESIZE_MALLOCED_BUFFER (str
, sindex
, len
, ssize
, 64);
1095 strcpy (str
+ sindex
, ts
);
1100 prec
= 3; /* default is three places past the decimal point. */
1101 lng
= 0; /* default is to not use minutes or append `s' */
1103 if (isdigit (*s
)) /* `precision' */
1106 if (prec
> 3) prec
= 3;
1108 if (*s
== 'l') /* `length extender' */
1113 if (*s
== 'R' || *s
== 'E')
1114 len
= mkfmt (ts
, prec
, lng
, rs
, rsf
);
1116 len
= mkfmt (ts
, prec
, lng
, us
, usf
);
1118 len
= mkfmt (ts
, prec
, lng
, ss
, ssf
);
1121 internal_error ("bad format character in time format: %c", *s
);
1125 RESIZE_MALLOCED_BUFFER (str
, sindex
, len
, ssize
, 64);
1126 strcpy (str
+ sindex
, ts
);
1132 fprintf (fp
, "%s\n", str
);
1139 time_command (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
1141 int asynchronous
, pipe_in
, pipe_out
;
1142 struct fd_bitmap
*fds_to_close
;
1144 int rv
, posix_time
, old_flags
;
1150 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1151 struct timeval real
, user
, sys
;
1152 struct timeval before
, after
;
1153 struct timezone dtz
;
1154 struct rusage selfb
, selfa
, kidsb
, kidsa
; /* a = after, b = before */
1156 # if defined (HAVE_TIMES)
1157 clock_t tbefore
, tafter
, real
, user
, sys
;
1158 struct tms before
, after
;
1162 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1163 gettimeofday (&before
, &dtz
);
1164 getrusage (RUSAGE_SELF
, &selfb
);
1165 getrusage (RUSAGE_CHILDREN
, &kidsb
);
1167 # if defined (HAVE_TIMES)
1168 tbefore
= times (&before
);
1172 posix_time
= (command
->flags
& CMD_TIME_POSIX
);
1174 old_flags
= command
->flags
;
1175 command
->flags
&= ~(CMD_TIME_PIPELINE
|CMD_TIME_POSIX
);
1176 rv
= execute_command_internal (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
1177 command
->flags
= old_flags
;
1180 rsf
= usf
= ssf
= cpu
= 0;
1182 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1183 gettimeofday (&after
, &dtz
);
1184 getrusage (RUSAGE_SELF
, &selfa
);
1185 getrusage (RUSAGE_CHILDREN
, &kidsa
);
1187 difftimeval (&real
, &before
, &after
);
1188 timeval_to_secs (&real
, &rs
, &rsf
);
1190 addtimeval (&user
, difftimeval(&after
, &selfb
.ru_utime
, &selfa
.ru_utime
),
1191 difftimeval(&before
, &kidsb
.ru_utime
, &kidsa
.ru_utime
));
1192 timeval_to_secs (&user
, &us
, &usf
);
1194 addtimeval (&sys
, difftimeval(&after
, &selfb
.ru_stime
, &selfa
.ru_stime
),
1195 difftimeval(&before
, &kidsb
.ru_stime
, &kidsa
.ru_stime
));
1196 timeval_to_secs (&sys
, &ss
, &ssf
);
1198 cpu
= timeval_to_cpu (&real
, &user
, &sys
);
1200 # if defined (HAVE_TIMES)
1201 tafter
= times (&after
);
1203 real
= tafter
- tbefore
;
1204 clock_t_to_secs (real
, &rs
, &rsf
);
1206 user
= (after
.tms_utime
- before
.tms_utime
) + (after
.tms_cutime
- before
.tms_cutime
);
1207 clock_t_to_secs (user
, &us
, &usf
);
1209 sys
= (after
.tms_stime
- before
.tms_stime
) + (after
.tms_cstime
- before
.tms_cstime
);
1210 clock_t_to_secs (sys
, &ss
, &ssf
);
1212 cpu
= (real
== 0) ? 0 : ((user
+ sys
) * 10000) / real
;
1216 rsf
= usf
= ssf
= cpu
= 0;
1221 time_format
= POSIX_TIMEFORMAT
;
1222 else if ((time_format
= get_string_value ("TIMEFORMAT")) == 0)
1223 time_format
= BASH_TIMEFORMAT
;
1225 if (time_format
&& *time_format
)
1226 print_formatted_time (stderr
, time_format
, rs
, rsf
, us
, usf
, ss
, ssf
, cpu
);
1230 #endif /* COMMAND_TIMING */
1233 execute_pipeline (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
1235 int asynchronous
, pipe_in
, pipe_out
;
1236 struct fd_bitmap
*fds_to_close
;
1238 int prev
, fildes
[2], new_bitmap_size
, dummyfd
, ignore_return
, exec_result
;
1240 struct fd_bitmap
*fd_bitmap
;
1242 #if defined (JOB_CONTROL)
1244 BLOCK_CHILD (set
, oset
);
1245 #endif /* JOB_CONTROL */
1247 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
1252 while (cmd
&& cmd
->type
== cm_connection
&&
1253 cmd
->value
.Connection
&& cmd
->value
.Connection
->connector
== '|')
1255 /* Make a pipeline between the two commands. */
1256 if (pipe (fildes
) < 0)
1258 sys_error ("pipe error");
1259 #if defined (JOB_CONTROL)
1260 terminate_current_pipeline ();
1261 kill_current_pipeline ();
1262 #endif /* JOB_CONTROL */
1263 last_command_exit_value
= EXECUTION_FAILURE
;
1264 /* The unwind-protects installed below will take care
1265 of closing all of the open file descriptors. */
1266 throw_to_top_level ();
1267 return (EXECUTION_FAILURE
); /* XXX */
1270 /* Here is a problem: with the new file close-on-exec
1271 code, the read end of the pipe (fildes[0]) stays open
1272 in the first process, so that process will never get a
1273 SIGPIPE. There is no way to signal the first process
1274 that it should close fildes[0] after forking, so it
1275 remains open. No SIGPIPE is ever sent because there
1276 is still a file descriptor open for reading connected
1277 to the pipe. We take care of that here. This passes
1278 around a bitmap of file descriptors that must be
1279 closed after making a child process in execute_simple_command. */
1281 /* We need fd_bitmap to be at least as big as fildes[0].
1282 If fildes[0] is less than fds_to_close->size, then
1283 use fds_to_close->size. */
1284 new_bitmap_size
= (fildes
[0] < fds_to_close
->size
)
1285 ? fds_to_close
->size
1288 fd_bitmap
= new_fd_bitmap (new_bitmap_size
);
1290 /* Now copy the old information into the new bitmap. */
1291 xbcopy ((char *)fds_to_close
->bitmap
, (char *)fd_bitmap
->bitmap
, fds_to_close
->size
);
1293 /* And mark the pipe file descriptors to be closed. */
1294 fd_bitmap
->bitmap
[fildes
[0]] = 1;
1296 /* In case there are pipe or out-of-processes errors, we
1297 want all these file descriptors to be closed when
1298 unwind-protects are run, and the storage used for the
1299 bitmaps freed up. */
1300 begin_unwind_frame ("pipe-file-descriptors");
1301 add_unwind_protect (dispose_fd_bitmap
, fd_bitmap
);
1302 add_unwind_protect (close_fd_bitmap
, fd_bitmap
);
1304 add_unwind_protect (close
, prev
);
1305 dummyfd
= fildes
[1];
1306 add_unwind_protect (close
, dummyfd
);
1308 #if defined (JOB_CONTROL)
1309 add_unwind_protect (restore_signal_mask
, oset
);
1310 #endif /* JOB_CONTROL */
1312 if (ignore_return
&& cmd
->value
.Connection
->first
)
1313 cmd
->value
.Connection
->first
->flags
|= CMD_IGNORE_RETURN
;
1314 execute_command_internal (cmd
->value
.Connection
->first
, asynchronous
,
1315 prev
, fildes
[1], fd_bitmap
);
1323 dispose_fd_bitmap (fd_bitmap
);
1324 discard_unwind_frame ("pipe-file-descriptors");
1326 cmd
= cmd
->value
.Connection
->second
;
1329 /* Now execute the rightmost command in the pipeline. */
1330 if (ignore_return
&& cmd
)
1331 cmd
->flags
|= CMD_IGNORE_RETURN
;
1332 exec_result
= execute_command_internal (cmd
, asynchronous
, prev
, pipe_out
, fds_to_close
);
1337 #if defined (JOB_CONTROL)
1338 UNBLOCK_CHILD (oset
);
1341 return (exec_result
);
1345 execute_connection (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
1347 int asynchronous
, pipe_in
, pipe_out
;
1348 struct fd_bitmap
*fds_to_close
;
1354 COMMAND
*tc
, *second
;
1355 int ignore_return
, exec_result
;
1357 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
1359 switch (command
->value
.Connection
->connector
)
1361 /* Do the first command asynchronously. */
1363 tc
= command
->value
.Connection
->first
;
1365 return (EXECUTION_SUCCESS
);
1370 tc
->flags
|= CMD_IGNORE_RETURN
;
1371 tc
->flags
|= CMD_AMPERSAND
;
1373 /* If this shell was compiled without job control support, if
1374 the shell is not running interactively, if we are currently
1375 in a subshell via `( xxx )', or if job control is not active
1376 then the standard input for an asynchronous command is
1377 forced to /dev/null. */
1378 #if defined (JOB_CONTROL)
1379 if ((!interactive_shell
|| subshell_environment
|| !job_control
) && !stdin_redir
)
1382 #endif /* JOB_CONTROL */
1385 rd
.filename
= make_bare_word ("/dev/null");
1386 tr
= make_redirection (0, r_inputa_direction
, rd
);
1387 tr
->next
= tc
->redirects
;
1390 tc
->flags
|= CMD_STDIN_REDIR
;
1393 exec_result
= execute_command_internal (tc
, 1, pipe_in
, pipe_out
, fds_to_close
);
1395 if (tc
->flags
& CMD_STDIN_REDIR
)
1398 /* Remove the redirection we added above. It matters,
1399 especially for loops, which call execute_command ()
1400 multiple times with the same command. */
1405 tc
->redirects
= tc
->redirects
->next
;
1407 while (tc
->redirects
&& tc
->redirects
!= rp
);
1409 tl
->next
= (REDIRECT
*)NULL
;
1410 dispose_redirects (tr
);
1412 tc
->flags
&= ~CMD_STDIN_REDIR
;
1415 second
= command
->value
.Connection
->second
;
1419 second
->flags
|= CMD_IGNORE_RETURN
;
1421 exec_result
= execute_command_internal (second
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
1426 /* Just call execute command on both sides. */
1430 if (command
->value
.Connection
->first
)
1431 command
->value
.Connection
->first
->flags
|= CMD_IGNORE_RETURN
;
1432 if (command
->value
.Connection
->second
)
1433 command
->value
.Connection
->second
->flags
|= CMD_IGNORE_RETURN
;
1436 execute_command (command
->value
.Connection
->first
);
1438 exec_result
= execute_command_internal (command
->value
.Connection
->second
,
1439 asynchronous
, pipe_in
, pipe_out
,
1444 exec_result
= execute_pipeline (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
1451 /* If we have something like `a && b &' or `a || b &', run the
1452 && or || stuff in a subshell. Force a subshell and just call
1453 execute_command_internal again. Leave asynchronous on
1454 so that we get a report from the parent shell about the
1456 command
->flags
|= CMD_FORCE_SUBSHELL
;
1457 exec_result
= execute_command_internal (command
, 1, pipe_in
, pipe_out
, fds_to_close
);
1461 /* Execute the first command. If the result of that is successful
1462 and the connector is AND_AND, or the result is not successful
1463 and the connector is OR_OR, then execute the second command,
1464 otherwise return. */
1466 if (command
->value
.Connection
->first
)
1467 command
->value
.Connection
->first
->flags
|= CMD_IGNORE_RETURN
;
1469 exec_result
= execute_command (command
->value
.Connection
->first
);
1471 if (((command
->value
.Connection
->connector
== AND_AND
) &&
1472 (exec_result
== EXECUTION_SUCCESS
)) ||
1473 ((command
->value
.Connection
->connector
== OR_OR
) &&
1474 (exec_result
!= EXECUTION_SUCCESS
)))
1476 if (ignore_return
&& command
->value
.Connection
->second
)
1477 command
->value
.Connection
->second
->flags
|= CMD_IGNORE_RETURN
;
1479 exec_result
= execute_command (command
->value
.Connection
->second
);
1484 command_error ("execute_connection", CMDERR_BADCONN
, command
->value
.Connection
->connector
, 0);
1485 jump_to_top_level (DISCARD
);
1486 exec_result
= EXECUTION_FAILURE
;
1492 #if defined (JOB_CONTROL)
1496 if (!interactive_shell) \
1497 reap_dead_jobs (); \
1500 #else /* !JOB_CONTROL */
1504 if (!interactive_shell) \
1505 cleanup_dead_jobs (); \
1508 #endif /* !JOB_CONTROL */
1511 /* Execute a FOR command. The syntax is: FOR word_desc IN word_list;
1514 execute_for_command (for_command
)
1515 FOR_COM
*for_command
;
1517 register WORD_LIST
*releaser
, *list
;
1522 SHELL_VAR
*old_value
= (SHELL_VAR
*)NULL
; /* Remember the old value of x. */
1525 if (check_identifier (for_command
->name
, 1) == 0)
1527 if (posixly_correct
&& interactive_shell
== 0)
1529 last_command_exit_value
= EX_USAGE
;
1530 jump_to_top_level (EXITPROG
);
1532 return (EXECUTION_FAILURE
);
1536 identifier
= for_command
->name
->word
;
1538 list
= releaser
= expand_words_no_vars (for_command
->map_list
);
1540 begin_unwind_frame ("for");
1541 add_unwind_protect (dispose_words
, releaser
);
1544 if (lexical_scoping
)
1546 old_value
= copy_variable (find_variable (identifier
));
1548 add_unwind_protect (dispose_variable
, old_value
);
1552 if (for_command
->flags
& CMD_IGNORE_RETURN
)
1553 for_command
->action
->flags
|= CMD_IGNORE_RETURN
;
1555 for (retval
= EXECUTION_SUCCESS
; list
; list
= list
->next
)
1558 this_command_name
= (char *)NULL
;
1559 v
= bind_variable (identifier
, list
->word
->word
);
1562 if (interactive_shell
== 0 && posixly_correct
)
1564 last_command_exit_value
= EXECUTION_FAILURE
;
1565 jump_to_top_level (FORCE_EOF
);
1569 run_unwind_frame ("for");
1571 return (EXECUTION_FAILURE
);
1574 retval
= execute_command (for_command
->action
);
1595 if (lexical_scoping
)
1598 makunbound (identifier
, shell_variables
);
1601 SHELL_VAR
*new_value
;
1603 new_value
= bind_variable (identifier
, value_cell(old_value
));
1604 new_value
->attributes
= old_value
->attributes
;
1605 dispose_variable (old_value
);
1610 dispose_words (releaser
);
1611 discard_unwind_frame ("for");
1615 #if defined (SELECT_COMMAND)
1616 static int LINES
, COLS
, tabsize
;
1618 #define RP_SPACE ") "
1619 #define RP_SPACE_LEN 2
1621 /* XXX - does not handle numbers > 1000000 at all. */
1622 #define NUMBER_LEN(s) \
1626 : ((s < 10000) ? 4 \
1627 : ((s < 100000) ? 5 \
1631 print_index_and_element (len
, ind
, list
)
1635 register WORD_LIST
*l
;
1640 for (i
= ind
, l
= list
; l
&& --i
; l
= l
->next
)
1642 fprintf (stderr
, "%*d%s%s", len
, ind
, RP_SPACE
, l
->word
->word
);
1643 return (STRLEN (l
->word
->word
));
1652 if ((to
/ tabsize
) > (from
/ tabsize
))
1654 putc ('\t', stderr
);
1655 from
+= tabsize
- from
% tabsize
;
1666 print_select_list (list
, list_len
, max_elem_len
, indices_len
)
1668 int list_len
, max_elem_len
, indices_len
;
1670 int ind
, row
, elem_len
, pos
, cols
, rows
;
1671 int first_column_indices_len
, other_indices_len
;
1675 putc ('\n', stderr
);
1679 cols
= max_elem_len
? COLS
/ max_elem_len
: 1;
1682 rows
= list_len
? list_len
/ cols
+ (list_len
% cols
!= 0) : 1;
1683 cols
= list_len
? list_len
/ rows
+ (list_len
% rows
!= 0) : 1;
1691 first_column_indices_len
= NUMBER_LEN (rows
);
1692 other_indices_len
= indices_len
;
1694 for (row
= 0; row
< rows
; row
++)
1700 indices_len
= (pos
== 0) ? first_column_indices_len
: other_indices_len
;
1701 elem_len
= print_index_and_element (indices_len
, ind
+ 1, list
);
1702 elem_len
+= indices_len
+ RP_SPACE_LEN
;
1704 if (ind
>= list_len
)
1706 indent (pos
+ elem_len
, pos
+ max_elem_len
);
1707 pos
+= max_elem_len
;
1709 putc ('\n', stderr
);
1713 /* Print the elements of LIST, one per line, preceded by an index from 1 to
1714 LIST_LEN. Then display PROMPT and wait for the user to enter a number.
1715 If the number is between 1 and LIST_LEN, return that selection. If EOF
1716 is read, return a null string. If a blank line is entered, or an invalid
1717 number is entered, the loop is executed again. */
1719 select_query (list
, list_len
, prompt
)
1724 int max_elem_len
, indices_len
, len
;
1727 char *repl_string
, *t
;
1729 t
= get_string_value ("LINES");
1730 LINES
= (t
&& *t
) ? atoi (t
) : 24;
1731 t
= get_string_value ("COLUMNS");
1732 COLS
= (t
&& *t
) ? atoi (t
) : 80;
1735 t
= get_string_value ("TABSIZE");
1736 tabsize
= (t
&& *t
) ? atoi (t
) : 8;
1744 for (l
= list
; l
; l
= l
->next
)
1746 len
= STRLEN (l
->word
->word
);
1747 if (len
> max_elem_len
)
1750 indices_len
= NUMBER_LEN (list_len
);
1751 max_elem_len
+= indices_len
+ RP_SPACE_LEN
+ 2;
1755 print_select_list (list
, list_len
, max_elem_len
, indices_len
);
1756 fprintf (stderr
, "%s", prompt
);
1760 if (read_builtin ((WORD_LIST
*)NULL
) == EXECUTION_FAILURE
)
1763 return ((char *)NULL
);
1765 repl_string
= get_string_value ("REPLY");
1766 if (*repl_string
== 0)
1768 if (legal_number (repl_string
, &reply
) == 0)
1770 if (reply
< 1 || reply
> list_len
)
1773 for (l
= list
; l
&& --reply
; l
= l
->next
)
1775 return (l
->word
->word
);
1779 /* Execute a SELECT command. The syntax is:
1780 SELECT word IN list DO command_list DONE
1781 Only `break' or `return' in command_list will terminate
1784 execute_select_command (select_command
)
1785 SELECT_COM
*select_command
;
1787 WORD_LIST
*releaser
, *list
;
1789 char *identifier
, *ps3_prompt
, *selection
;
1790 int retval
, list_len
, return_val
;
1792 if (check_identifier (select_command
->name
, 1) == 0)
1793 return (EXECUTION_FAILURE
);
1796 identifier
= select_command
->name
->word
;
1798 /* command and arithmetic substitution, parameter and variable expansion,
1799 word splitting, pathname expansion, and quote removal. */
1800 list
= releaser
= expand_words_no_vars (select_command
->map_list
);
1801 list_len
= list_length (list
);
1802 if (list
== 0 || list_len
== 0)
1805 dispose_words (list
);
1806 return (EXECUTION_SUCCESS
);
1809 begin_unwind_frame ("select");
1810 add_unwind_protect (dispose_words
, releaser
);
1812 if (select_command
->flags
& CMD_IGNORE_RETURN
)
1813 select_command
->action
->flags
|= CMD_IGNORE_RETURN
;
1815 retval
= EXECUTION_SUCCESS
;
1817 unwind_protect_int (return_catch_flag
);
1818 unwind_protect_jmp_buf (return_catch
);
1819 return_catch_flag
++;
1823 ps3_prompt
= get_string_value ("PS3");
1824 if (ps3_prompt
== 0)
1828 selection
= select_query (list
, list_len
, ps3_prompt
);
1833 v
= bind_variable (identifier
, selection
);
1836 if (interactive_shell
== 0 && posixly_correct
)
1838 last_command_exit_value
= EXECUTION_FAILURE
;
1839 jump_to_top_level (FORCE_EOF
);
1843 run_unwind_frame ("select");
1844 return (EXECUTION_FAILURE
);
1848 return_val
= setjmp (return_catch
);
1852 retval
= return_catch_value
;
1856 retval
= execute_command (select_command
->action
);
1870 run_unwind_frame ("select");
1873 #endif /* SELECT_COMMAND */
1875 /* Execute a CASE command. The syntax is: CASE word_desc IN pattern_list ESAC.
1876 The pattern_list is a linked list of pattern clauses; each clause contains
1877 some patterns to compare word_desc against, and an associated command to
1880 execute_case_command (case_command
)
1881 CASE_COM
*case_command
;
1883 register WORD_LIST
*list
;
1884 WORD_LIST
*wlist
, *es
;
1885 PATTERN_LIST
*clauses
;
1886 char *word
, *pattern
;
1887 int retval
, match
, ignore_return
;
1889 /* Posix.2 specifies that the WORD is tilde expanded. */
1890 if (member ('~', case_command
->word
->word
))
1892 word
= bash_tilde_expand (case_command
->word
->word
);
1893 free (case_command
->word
->word
);
1894 case_command
->word
->word
= word
;
1897 wlist
= expand_word_no_split (case_command
->word
, 0);
1898 word
= wlist
? string_list (wlist
) : savestring ("");
1899 dispose_words (wlist
);
1901 retval
= EXECUTION_SUCCESS
;
1902 ignore_return
= case_command
->flags
& CMD_IGNORE_RETURN
;
1904 begin_unwind_frame ("case");
1905 add_unwind_protect ((Function
*)xfree
, word
);
1907 #define EXIT_CASE() goto exit_case_command
1909 for (clauses
= case_command
->clauses
; clauses
; clauses
= clauses
->next
)
1912 for (list
= clauses
->patterns
; list
; list
= list
->next
)
1914 /* Posix.2 specifies to tilde expand each member of the pattern
1916 if (member ('~', list
->word
->word
))
1918 pattern
= bash_tilde_expand (list
->word
->word
);
1919 free (list
->word
->word
);
1920 list
->word
->word
= pattern
;
1923 es
= expand_word_leave_quoted (list
->word
, 0);
1925 if (es
&& es
->word
&& es
->word
->word
&& *(es
->word
->word
))
1926 pattern
= quote_string_for_globbing (es
->word
->word
, QGLOB_CVTNULL
);
1929 pattern
= xmalloc (1);
1933 /* Since the pattern does not undergo quote removal (as per
1934 Posix.2, section 3.9.4.3), the fnmatch () call must be able
1935 to recognize backslashes as escape characters. */
1936 match
= fnmatch (pattern
, word
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
;
1943 if (clauses
->action
&& ignore_return
)
1944 clauses
->action
->flags
|= CMD_IGNORE_RETURN
;
1945 retval
= execute_command (clauses
->action
);
1955 discard_unwind_frame ("case");
1962 /* The WHILE command. Syntax: WHILE test DO action; DONE.
1963 Repeatedly execute action while executing test produces
1964 EXECUTION_SUCCESS. */
1966 execute_while_command (while_command
)
1967 WHILE_COM
*while_command
;
1969 return (execute_while_or_until (while_command
, CMD_WHILE
));
1972 /* UNTIL is just like WHILE except that the test result is negated. */
1974 execute_until_command (while_command
)
1975 WHILE_COM
*while_command
;
1977 return (execute_while_or_until (while_command
, CMD_UNTIL
));
1980 /* The body for both while and until. The only difference between the
1981 two is that the test value is treated differently. TYPE is
1982 CMD_WHILE or CMD_UNTIL. The return value for both commands should
1983 be EXECUTION_SUCCESS if no commands in the body are executed, and
1984 the status of the last command executed in the body otherwise. */
1986 execute_while_or_until (while_command
, type
)
1987 WHILE_COM
*while_command
;
1990 int return_value
, body_status
;
1992 body_status
= EXECUTION_SUCCESS
;
1995 while_command
->test
->flags
|= CMD_IGNORE_RETURN
;
1996 if (while_command
->flags
& CMD_IGNORE_RETURN
)
1997 while_command
->action
->flags
|= CMD_IGNORE_RETURN
;
2001 return_value
= execute_command (while_command
->test
);
2004 if (type
== CMD_WHILE
&& return_value
!= EXECUTION_SUCCESS
)
2006 if (type
== CMD_UNTIL
&& return_value
== EXECUTION_SUCCESS
)
2010 body_status
= execute_command (while_command
->action
);
2028 return (body_status
);
2031 /* IF test THEN command [ELSE command].
2032 IF also allows ELIF in the place of ELSE IF, but
2033 the parser makes *that* stupidity transparent. */
2035 execute_if_command (if_command
)
2040 if_command
->test
->flags
|= CMD_IGNORE_RETURN
;
2041 return_value
= execute_command (if_command
->test
);
2043 if (return_value
== EXECUTION_SUCCESS
)
2047 if (if_command
->true_case
&& (if_command
->flags
& CMD_IGNORE_RETURN
))
2048 if_command
->true_case
->flags
|= CMD_IGNORE_RETURN
;
2050 return (execute_command (if_command
->true_case
));
2056 if (if_command
->false_case
&& (if_command
->flags
& CMD_IGNORE_RETURN
))
2057 if_command
->false_case
->flags
|= CMD_IGNORE_RETURN
;
2059 return (execute_command (if_command
->false_case
));
2063 #if defined (DPAREN_ARITHMETIC)
2065 execute_arith_command (arith_command
)
2066 ARITH_COM
*arith_command
;
2068 int result
, expok
, expresult
;
2069 WORD_LIST
*new, *p
, *printit
;
2074 this_command_name
= "(("; /* )) */
2075 /* If we're in a function, update the line number information. */
2076 if (variable_context
)
2077 line_number
= arith_command
->line
- function_line_number
;
2079 new = expand_words (arith_command
->exp
);
2081 /* If we're tracing, make a new word list with `((' at the front and `))'
2082 at the back and print it. */
2083 if (echo_command_at_execute
)
2084 xtrace_print_arith_cmd (new);
2086 result
= evalexp (new->word
->word
, &expok
);
2087 dispose_words (new);
2090 return (EXECUTION_FAILURE
);
2092 return (result
== 0 ? EXECUTION_FAILURE
: EXECUTION_SUCCESS
);
2094 #endif /* DPAREN_ARITHMETIC */
2096 #if defined (COND_COMMAND)
2098 static char *nullstr
= "";
2101 execute_cond_node (cond
)
2104 int result
, invert
, patmatch
, flags
;
2105 char *arg1
, *arg2
, *print2
;
2107 invert
= (cond
->flags
& CMD_INVERT_RETURN
);
2109 if (cond
->type
== COND_EXPR
)
2110 result
= execute_cond_node (cond
->left
);
2111 else if (cond
->type
== COND_OR
)
2113 result
= execute_cond_node (cond
->left
);
2114 if (result
!= EXECUTION_SUCCESS
)
2115 result
= execute_cond_node (cond
->right
);
2117 else if (cond
->type
== COND_AND
)
2119 result
= execute_cond_node (cond
->left
);
2120 if (result
== EXECUTION_SUCCESS
)
2121 result
= execute_cond_node (cond
->right
);
2123 else if (cond
->type
== COND_UNARY
)
2125 arg1
= cond_expand_word (cond
->left
->op
, 0);
2128 if (echo_command_at_execute
)
2129 xtrace_print_cond_term (cond
->type
, invert
, cond
->op
, arg1
, (char *)NULL
);
2130 result
= unary_test (cond
->op
->word
, arg1
) ? EXECUTION_SUCCESS
: EXECUTION_FAILURE
;
2131 if (arg1
!= nullstr
)
2134 else if (cond
->type
== COND_BINARY
)
2136 patmatch
= ((cond
->op
->word
[1] == '=') && (cond
->op
->word
[2] == '\0') &&
2137 (cond
->op
->word
[0] == '!' || cond
->op
->word
[0] == '=') ||
2138 (cond
->op
->word
[0] == '=' && cond
->op
->word
[1] == '\0'));
2140 arg1
= cond_expand_word (cond
->left
->op
, 0);
2143 arg2
= cond_expand_word (cond
->right
->op
, patmatch
);
2147 if (echo_command_at_execute
)
2148 xtrace_print_cond_term (cond
->type
, invert
, cond
->op
, arg1
, arg2
);
2150 result
= binary_test (cond
->op
->word
, arg1
, arg2
, TEST_PATMATCH
|TEST_ARITHEXP
)
2152 : EXECUTION_FAILURE
;
2153 if (arg1
!= nullstr
)
2155 if (arg2
!= nullstr
)
2160 command_error ("execute_cond_node", CMDERR_BADTYPE
, cond
->type
, 0);
2161 jump_to_top_level (DISCARD
);
2162 result
= EXECUTION_FAILURE
;
2166 result
= (result
== EXECUTION_SUCCESS
) ? EXECUTION_FAILURE
: EXECUTION_SUCCESS
;
2172 execute_cond_command (cond_command
)
2173 COND_COM
*cond_command
;
2177 result
= EXECUTION_SUCCESS
;
2179 this_command_name
= "[[";
2180 /* If we're in a function, update the line number information. */
2181 if (variable_context
)
2182 line_number
= cond_command
->line
- function_line_number
;
2185 debug_print_cond_command (cond_command
);
2187 last_command_exit_value
= result
= execute_cond_node (cond_command
);
2190 #endif /* COND_COMMAND */
2200 var
= bind_variable ("_", arg
);
2201 var
->attributes
&= ~att_exported
;
2204 /* Execute a null command. Fork a subshell if the command uses pipes or is
2205 to be run asynchronously. This handles all the side effects that are
2206 supposed to take place. */
2208 execute_null_command (redirects
, pipe_in
, pipe_out
, async
, old_last_command_subst_pid
)
2209 REDIRECT
*redirects
;
2210 int pipe_in
, pipe_out
, async
, old_last_command_subst_pid
;
2212 if (pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
|| async
)
2214 /* We have a null command, but we really want a subshell to take
2215 care of it. Just fork, do piping and redirections, and exit. */
2216 if (make_child ((char *)NULL
, async
) == 0)
2218 /* Cancel traps, in trap.c. */
2219 restore_original_signals (); /* XXX */
2221 do_piping (pipe_in
, pipe_out
);
2223 subshell_environment
= SUBSHELL_ASYNC
;
2225 if (do_redirections (redirects
, 1, 0, 0) == 0)
2226 exit (EXECUTION_SUCCESS
);
2228 exit (EXECUTION_FAILURE
);
2232 close_pipes (pipe_in
, pipe_out
);
2233 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
2234 unlink_fifo_list ();
2236 return (EXECUTION_SUCCESS
);
2241 /* Even if there aren't any command names, pretend to do the
2242 redirections that are specified. The user expects the side
2243 effects to take place. If the redirections fail, then return
2244 failure. Otherwise, if a command substitution took place while
2245 expanding the command or a redirection, return the value of that
2246 substitution. Otherwise, return EXECUTION_SUCCESS. */
2248 if (do_redirections (redirects
, 0, 0, 0) != 0)
2249 return (EXECUTION_FAILURE
);
2250 else if (old_last_command_subst_pid
!= last_command_subst_pid
)
2251 return (last_command_exit_value
);
2253 return (EXECUTION_SUCCESS
);
2257 /* This is a hack to suppress word splitting for assignment statements
2258 given as arguments to builtins with the ASSIGNMENT_BUILTIN flag set. */
2260 fix_assignment_words (words
)
2269 b
= builtin_address_internal (words
->word
->word
, 0);
2270 if (b
== 0 || (b
->flags
& ASSIGNMENT_BUILTIN
) == 0)
2273 for (w
= words
; w
; w
= w
->next
)
2274 if (w
->word
->flags
& W_ASSIGNMENT
)
2275 w
->word
->flags
|= (W_NOSPLIT
|W_NOGLOB
);
2278 /* The meaty part of all the executions. We have to start hacking the
2279 real execution of commands here. Fork a process, set things up,
2280 execute the command. */
2282 execute_simple_command (simple_command
, pipe_in
, pipe_out
, async
, fds_to_close
)
2283 SIMPLE_COM
*simple_command
;
2284 int pipe_in
, pipe_out
, async
;
2285 struct fd_bitmap
*fds_to_close
;
2287 WORD_LIST
*words
, *lastword
;
2288 char *command_line
, *lastarg
, *temp
;
2289 int first_word_quoted
, result
, builtin_is_special
, already_forked
, dofork
;
2290 pid_t old_last_command_subst_pid
, old_last_async_pid
;
2294 result
= EXECUTION_SUCCESS
;
2295 special_builtin_failed
= builtin_is_special
= 0;
2296 command_line
= (char *)0;
2298 /* If we're in a function, update the line number information. */
2299 if (variable_context
)
2300 line_number
= simple_command
->line
- function_line_number
;
2302 /* Remember what this command line looks like at invocation. */
2303 command_string_index
= 0;
2304 print_simple_command (simple_command
);
2307 simple_command
->words
? (simple_command
->words
->word
->flags
& W_QUOTED
): 0;
2309 old_last_command_subst_pid
= last_command_subst_pid
;
2310 old_last_async_pid
= last_asynchronous_pid
;
2312 already_forked
= dofork
= 0;
2314 /* If we're in a pipeline or run in the background, set DOFORK so we
2315 make the child early, before word expansion. This keeps assignment
2316 statements from affecting the parent shell's environment when they
2318 dofork
= pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
|| async
;
2320 /* Something like `%2 &' should restart job 2 in the background, not cause
2321 the shell to fork here. */
2322 if (dofork
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
&&
2323 simple_command
->words
&& simple_command
->words
->word
&&
2324 simple_command
->words
->word
->word
&&
2325 (simple_command
->words
->word
->word
[0] == '%'))
2330 /* XXX memory leak if expand_words() error causes a jump_to_top_level */
2331 command_line
= savestring (the_printed_command
);
2333 if (make_child (command_line
, async
) == 0)
2336 simple_command
->flags
|= CMD_NO_FORK
;
2338 do_piping (pipe_in
, pipe_out
);
2339 pipe_in
= pipe_out
= -1;
2341 last_asynchronous_pid
= old_last_async_pid
;
2342 subshell_environment
= async
? SUBSHELL_ASYNC
: SUBSHELL_FORK
;
2346 close_pipes (pipe_in
, pipe_out
);
2347 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
2348 unlink_fifo_list ();
2350 command_line
= (char *)NULL
; /* don't free this. */
2351 bind_lastarg ((char *)NULL
);
2356 /* If we are re-running this as the result of executing the `command'
2357 builtin, do not expand the command words a second time. */
2358 if ((simple_command
->flags
& CMD_INHIBIT_EXPANSION
) == 0)
2360 current_fds_to_close
= fds_to_close
;
2361 fix_assignment_words (simple_command
->words
);
2362 words
= expand_words (simple_command
->words
);
2363 current_fds_to_close
= (struct fd_bitmap
*)NULL
;
2366 words
= copy_word_list (simple_command
->words
);
2368 /* It is possible for WORDS not to have anything left in it.
2369 Perhaps all the words consisted of `$foo', and there was
2370 no variable `$foo'. */
2373 result
= execute_null_command (simple_command
->redirects
,
2375 already_forked
? 0 : async
,
2376 old_last_command_subst_pid
);
2381 bind_lastarg ((char *)NULL
);
2382 set_pipestatus_from_exit (result
);
2387 lastarg
= (char *)NULL
;
2389 begin_unwind_frame ("simple-command");
2391 if (echo_command_at_execute
)
2392 xtrace_print_word_list (words
);
2394 builtin
= (Function
*)NULL
;
2395 func
= (SHELL_VAR
*)NULL
;
2396 if ((simple_command
->flags
& CMD_NO_FUNCTIONS
) == 0)
2398 /* Posix.2 says special builtins are found before functions. We
2399 don't set builtin_is_special anywhere other than here, because
2400 this path is followed only when the `command' builtin is *not*
2401 being used, and we don't want to exit the shell if a special
2402 builtin executed with `command builtin' fails. `command' is not
2403 a special builtin. */
2404 if (posixly_correct
)
2406 builtin
= find_special_builtin (words
->word
->word
);
2408 builtin_is_special
= 1;
2411 func
= find_function (words
->word
->word
);
2414 add_unwind_protect (dispose_words
, words
);
2417 /* Bind the last word in this command to "$_" after execution. */
2418 for (lastword
= words
; lastword
->next
; lastword
= lastword
->next
)
2420 lastarg
= lastword
->word
->word
;
2422 #if defined (JOB_CONTROL)
2423 /* Is this command a job control related thing? */
2424 if (words
->word
->word
[0] == '%' && already_forked
== 0)
2426 this_command_name
= async
? "bg" : "fg";
2427 last_shell_builtin
= this_shell_builtin
;
2428 this_shell_builtin
= builtin_address (this_command_name
);
2429 result
= (*this_shell_builtin
) (words
);
2433 /* One other possiblilty. The user may want to resume an existing job.
2434 If they do, find out whether this word is a candidate for a running
2436 if (job_control
&& already_forked
== 0 && async
== 0 &&
2437 !first_word_quoted
&&
2439 words
->word
->word
[0] &&
2440 !simple_command
->redirects
&&
2441 pipe_in
== NO_PIPE
&&
2442 pipe_out
== NO_PIPE
&&
2443 (temp
= get_string_value ("auto_resume")))
2447 int wl
, cl
, exact
, substring
, match
, started_status
;
2448 register PROCESS
*p
;
2450 word
= words
->word
->word
;
2451 exact
= STREQ (temp
, "exact");
2452 substring
= STREQ (temp
, "substring");
2454 for (i
= job_slots
- 1; i
> -1; i
--)
2456 if (jobs
[i
] == 0 || (JOBSTATE (i
) != JSTOPPED
))
2464 cl
= strlen (p
->command
);
2465 match
= STREQN (p
->command
, word
, cl
);
2468 match
= strindex (p
->command
, word
) != (char *)0;
2470 match
= STREQN (p
->command
, word
, wl
);
2478 run_unwind_frame ("simple-command");
2479 this_command_name
= "fg";
2480 last_shell_builtin
= this_shell_builtin
;
2481 this_shell_builtin
= builtin_address ("fg");
2483 started_status
= start_job (i
, 1);
2484 return ((started_status
< 0) ? EXECUTION_FAILURE
: started_status
);
2486 while (p
!= jobs
[i
]->pipe
);
2489 #endif /* JOB_CONTROL */
2491 /* Remember the name of this command globally. */
2492 this_command_name
= words
->word
->word
;
2496 /* This command could be a shell builtin or a user-defined function.
2497 We have already found special builtins by this time, so we do not
2498 set builtin_is_special. If this is a function or builtin, and we
2499 have pipes, then fork a subshell in here. Otherwise, just execute
2500 the command directly. */
2501 if (func
== 0 && builtin
== 0)
2502 builtin
= find_shell_builtin (this_command_name
);
2504 last_shell_builtin
= this_shell_builtin
;
2505 this_shell_builtin
= builtin
;
2507 if (builtin
|| func
)
2511 /* reset_terminating_signals (); */ /* XXX */
2512 /* Cancel traps, in trap.c. */
2513 restore_original_signals ();
2517 if ((simple_command
->flags
& CMD_STDIN_REDIR
) &&
2518 pipe_in
== NO_PIPE
&&
2519 (stdin_redirects (simple_command
->redirects
) == 0))
2520 async_redirect_stdin ();
2521 setup_async_signals ();
2524 execute_subshell_builtin_or_function
2525 (words
, simple_command
->redirects
, builtin
, func
,
2526 pipe_in
, pipe_out
, async
, fds_to_close
,
2527 simple_command
->flags
);
2531 result
= execute_builtin_or_function
2532 (words
, builtin
, func
, simple_command
->redirects
, fds_to_close
,
2533 simple_command
->flags
);
2536 if (result
> EX_SHERRBASE
)
2538 result
= builtin_status (result
);
2539 if (builtin_is_special
)
2540 special_builtin_failed
= 1;
2542 /* In POSIX mode, if there are assignment statements preceding
2543 a special builtin, they persist after the builtin
2545 if (posixly_correct
&& builtin_is_special
&& temporary_env
)
2546 merge_temporary_env ();
2550 if (result
== EX_USAGE
)
2551 result
= EX_BADUSAGE
;
2552 else if (result
> EX_SHERRBASE
)
2553 result
= EXECUTION_FAILURE
;
2556 set_pipestatus_from_exit (result
);
2562 if (command_line
== 0)
2563 command_line
= savestring (the_printed_command
);
2565 execute_disk_command (words
, simple_command
->redirects
, command_line
,
2566 pipe_in
, pipe_out
, async
, fds_to_close
,
2567 simple_command
->flags
);
2570 bind_lastarg (lastarg
);
2571 FREE (command_line
);
2572 run_unwind_frame ("simple-command");
2576 /* Translate the special builtin exit statuses. We don't really need a
2577 function for this; it's a placeholder for future work. */
2579 builtin_status (result
)
2593 r
= EXECUTION_FAILURE
;
2596 r
= EXECUTION_SUCCESS
;
2603 execute_builtin (builtin
, words
, flags
, subshell
)
2606 int flags
, subshell
;
2608 int old_e_flag
, result
, eval_unwind
;
2610 old_e_flag
= exit_immediately_on_error
;
2611 /* The eval builtin calls parse_and_execute, which does not know about
2612 the setting of flags, and always calls the execution functions with
2613 flags that will exit the shell on an error if -e is set. If the
2614 eval builtin is being called, and we're supposed to ignore the exit
2615 value of the command, we turn the -e flag off ourselves, then
2616 restore it when the command completes. */
2617 if (subshell
== 0 && builtin
== eval_builtin
&& (flags
& CMD_IGNORE_RETURN
))
2619 begin_unwind_frame ("eval_builtin");
2620 unwind_protect_int (exit_immediately_on_error
);
2621 exit_immediately_on_error
= 0;
2627 /* The temporary environment for a builtin is supposed to apply to
2628 all commands executed by that builtin. Currently, this is a
2629 problem only with the `source' and `eval' builtins. */
2630 if (builtin
== source_builtin
|| builtin
== eval_builtin
)
2633 begin_unwind_frame ("builtin_env");
2637 builtin_env
= copy_array (temporary_env
);
2639 add_unwind_protect (dispose_builtin_env
, (char *)NULL
);
2640 dispose_used_env_vars ();
2644 builtin_env
= (char **)NULL
;
2648 result
= ((*builtin
) (words
->next
));
2650 if (subshell
== 0 && (builtin
== source_builtin
|| builtin
== eval_builtin
))
2652 /* In POSIX mode, if any variable assignments precede the `.' or
2653 `eval' builtin, they persist after the builtin completes, since `.'
2654 and `eval' are special builtins. */
2655 if (posixly_correct
&& builtin_env
)
2656 merge_builtin_env ();
2658 dispose_builtin_env ();
2659 discard_unwind_frame ("builtin_env");
2661 run_unwind_frame ("builtin_env");
2667 exit_immediately_on_error
+= old_e_flag
;
2668 discard_unwind_frame ("eval_builtin");
2675 execute_function (var
, words
, flags
, fds_to_close
, async
, subshell
)
2678 int flags
, subshell
, async
;
2679 struct fd_bitmap
*fds_to_close
;
2681 int return_val
, result
;
2685 tc
= (COMMAND
*)copy_command (function_cell (var
));
2686 if (tc
&& (flags
& CMD_IGNORE_RETURN
))
2687 tc
->flags
|= CMD_IGNORE_RETURN
;
2691 begin_unwind_frame ("function_calling");
2693 add_unwind_protect (pop_context
, (char *)NULL
);
2694 unwind_protect_int (line_number
);
2695 unwind_protect_int (return_catch_flag
);
2696 unwind_protect_jmp_buf (return_catch
);
2697 add_unwind_protect (dispose_command
, (char *)tc
);
2698 unwind_protect_int (loop_level
);
2701 debug_trap
= (signal_is_trapped (DEBUG_TRAP
) && signal_is_ignored (DEBUG_TRAP
) == 0)
2702 ? trap_list
[DEBUG_TRAP
]
2708 debug_trap
= savestring (debug_trap
);
2709 /* XXX order is important here! unwind-protect commands are run
2710 in reverse order of registering. If this causes problems,
2711 take out the xfree unwind-protect and live with the small
2713 add_unwind_protect (xfree
, debug_trap
);
2714 add_unwind_protect (set_debug_trap
, debug_trap
);
2716 restore_default_signal (DEBUG_TRAP
);
2719 /* The temporary environment for a function is supposed to apply to
2720 all commands executed within the function body. */
2723 function_env
= copy_array (temporary_env
);
2725 add_unwind_protect (dispose_function_env
, (char *)NULL
);
2726 dispose_used_env_vars ();
2730 function_env
= (char **)NULL
;
2733 remember_args (words
->next
, 1);
2735 /* Number of the line on which the function body starts. */
2736 line_number
= function_line_number
= tc
->line
;
2740 #if defined (JOB_CONTROL)
2741 stop_pipeline (async
, (COMMAND
*)NULL
);
2743 fc
= (tc
->type
== cm_group
) ? tc
->value
.Group
->command
: tc
;
2745 if (fc
&& (flags
& CMD_IGNORE_RETURN
))
2746 fc
->flags
|= CMD_IGNORE_RETURN
;
2753 return_catch_flag
++;
2754 return_val
= setjmp (return_catch
);
2757 result
= return_catch_value
;
2759 result
= execute_command_internal (fc
, 0, NO_PIPE
, NO_PIPE
, fds_to_close
);
2762 run_unwind_frame ("function_calling");
2767 /* Execute a shell builtin or function in a subshell environment. This
2768 routine does not return; it only calls exit(). If BUILTIN is non-null,
2769 it points to a function to call to execute a shell builtin; otherwise
2770 VAR points at the body of a function to execute. WORDS is the arguments
2771 to the command, REDIRECTS specifies redirections to perform before the
2772 command is executed. */
2774 execute_subshell_builtin_or_function (words
, redirects
, builtin
, var
,
2775 pipe_in
, pipe_out
, async
, fds_to_close
,
2778 REDIRECT
*redirects
;
2781 int pipe_in
, pipe_out
, async
;
2782 struct fd_bitmap
*fds_to_close
;
2785 int result
, r
, jobs_hack
;
2787 /* A subshell is neither a login shell nor interactive. */
2788 login_shell
= interactive
= 0;
2790 jobs_hack
= (builtin
== jobs_builtin
) &&
2791 ((subshell_environment
& SUBSHELL_ASYNC
) == 0 || pipe_out
!= NO_PIPE
);
2793 subshell_environment
= SUBSHELL_ASYNC
;
2795 maybe_make_export_env (); /* XXX - is this needed? */
2797 #if defined (JOB_CONTROL)
2798 /* Eradicate all traces of job control after we fork the subshell, so
2799 all jobs begun by this subshell are in the same process group as
2800 the shell itself. */
2802 /* Allow the output of `jobs' to be piped. */
2804 kill_current_pipeline ();
2806 without_job_control ();
2808 set_sigchld_handler ();
2809 #endif /* JOB_CONTROL */
2811 set_sigint_handler ();
2813 do_piping (pipe_in
, pipe_out
);
2816 close_fd_bitmap (fds_to_close
);
2818 if (do_redirections (redirects
, 1, 0, 0) != 0)
2819 exit (EXECUTION_FAILURE
);
2823 /* Give builtins a place to jump back to on failure,
2824 so we don't go back up to main(). */
2825 result
= setjmp (top_level
);
2827 if (result
== EXITPROG
)
2828 exit (last_command_exit_value
);
2830 exit (EXECUTION_FAILURE
);
2833 r
= execute_builtin (builtin
, words
, flags
, 1);
2840 exit (execute_function (var
, words
, flags
, fds_to_close
, async
, 1));
2843 /* Execute a builtin or function in the current shell context. If BUILTIN
2844 is non-null, it is the builtin command to execute, otherwise VAR points
2845 to the body of a function. WORDS are the command's arguments, REDIRECTS
2846 are the redirections to perform. FDS_TO_CLOSE is the usual bitmap of
2847 file descriptors to close.
2849 If BUILTIN is exec_builtin, the redirections specified in REDIRECTS are
2850 not undone before this function returns. */
2852 execute_builtin_or_function (words
, builtin
, var
, redirects
,
2853 fds_to_close
, flags
)
2857 REDIRECT
*redirects
;
2858 struct fd_bitmap
*fds_to_close
;
2862 REDIRECT
*saved_undo_list
;
2864 if (do_redirections (redirects
, 1, 1, 0) != 0)
2866 cleanup_redirects (redirection_undo_list
);
2867 redirection_undo_list
= (REDIRECT
*)NULL
;
2868 dispose_exec_redirects ();
2869 return (EX_REDIRFAIL
); /* was EXECUTION_FAILURE */
2872 saved_undo_list
= redirection_undo_list
;
2874 /* Calling the "exec" builtin changes redirections forever. */
2875 if (builtin
== exec_builtin
)
2877 dispose_redirects (saved_undo_list
);
2878 saved_undo_list
= exec_redirection_undo_list
;
2879 exec_redirection_undo_list
= (REDIRECT
*)NULL
;
2882 dispose_exec_redirects ();
2884 if (saved_undo_list
)
2886 begin_unwind_frame ("saved redirects");
2887 add_unwind_protect (cleanup_redirects
, (char *)saved_undo_list
);
2890 redirection_undo_list
= (REDIRECT
*)NULL
;
2893 result
= execute_builtin (builtin
, words
, flags
, 0);
2895 result
= execute_function (var
, words
, flags
, fds_to_close
, 0, 0);
2897 if (saved_undo_list
)
2899 redirection_undo_list
= saved_undo_list
;
2900 discard_unwind_frame ("saved redirects");
2903 if (redirection_undo_list
)
2905 cleanup_redirects (redirection_undo_list
);
2906 redirection_undo_list
= (REDIRECT
*)NULL
;
2913 setup_async_signals ()
2915 #if defined (__BEOS__)
2916 set_signal_handler (SIGHUP
, SIG_IGN
); /* they want csh-like behavior */
2919 #if defined (JOB_CONTROL)
2920 if (job_control
== 0)
2923 set_signal_handler (SIGINT
, SIG_IGN
);
2924 set_signal_ignored (SIGINT
);
2925 set_signal_handler (SIGQUIT
, SIG_IGN
);
2926 set_signal_ignored (SIGQUIT
);
2930 /* Execute a simple command that is hopefully defined in a disk file
2935 3) look up the command
2938 6) If the execve failed, see if the file has executable mode set.
2939 If so, and it isn't a directory, then execute its contents as
2942 Note that the filename hashing stuff has to take place up here,
2943 in the parent. This is probably why the Bourne style shells
2944 don't handle it, since that would require them to go through
2945 this gnarly hair, for no good reason. */
2947 execute_disk_command (words
, redirects
, command_line
, pipe_in
, pipe_out
,
2948 async
, fds_to_close
, cmdflags
)
2950 REDIRECT
*redirects
;
2952 int pipe_in
, pipe_out
, async
;
2953 struct fd_bitmap
*fds_to_close
;
2956 char *pathname
, *command
, **args
;
2960 nofork
= (cmdflags
& CMD_NO_FORK
); /* Don't fork, just exec, if no pipes */
2961 pathname
= words
->word
->word
;
2963 #if defined (RESTRICTED_SHELL)
2964 if (restricted
&& strchr (pathname
, '/'))
2966 internal_error ("%s: restricted: cannot specify `/' in command names",
2968 last_command_exit_value
= EXECUTION_FAILURE
;
2971 #endif /* RESTRICTED_SHELL */
2973 command
= search_for_command (pathname
);
2977 maybe_make_export_env ();
2978 put_command_name_into_env (command
);
2981 /* We have to make the child before we check for the non-existance
2982 of COMMAND, since we want the error messages to be redirected. */
2983 /* If we can get away without forking and there are no pipes to deal with,
2984 don't bother to fork, just directly exec the command. */
2985 if (nofork
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
)
2988 pid
= make_child (savestring (command_line
), async
);
2992 int old_interactive
;
2995 /* This has been disabled for the time being. */
2996 #if !defined (ARG_MAX) || ARG_MAX >= 10240
2997 if (posixly_correct
== 0)
2998 put_gnu_argv_flags_into_env ((int)getpid (), glob_argv_flags
);
3002 /* Cancel traps, in trap.c. */
3003 restore_original_signals ();
3005 /* restore_original_signals may have undone the work done
3006 by make_child to ensure that SIGINT and SIGQUIT are ignored
3007 in asynchronous children. */
3010 if ((cmdflags
& CMD_STDIN_REDIR
) &&
3011 pipe_in
== NO_PIPE
&&
3012 (stdin_redirects (redirects
) == 0))
3013 async_redirect_stdin ();
3014 setup_async_signals ();
3017 do_piping (pipe_in
, pipe_out
);
3021 old_interactive
= interactive
;
3025 subshell_environment
= SUBSHELL_FORK
;
3027 /* This functionality is now provided by close-on-exec of the
3028 file descriptors manipulated by redirection and piping.
3029 Some file descriptors still need to be closed in all children
3030 because of the way bash does pipes; fds_to_close is a
3031 bitmap of all such file descriptors. */
3033 close_fd_bitmap (fds_to_close
);
3035 if (redirects
&& (do_redirections (redirects
, 1, 0, 0) != 0))
3037 #if defined (PROCESS_SUBSTITUTION)
3038 /* Try to remove named pipes that may have been created as the
3039 result of redirections. */
3040 unlink_fifo_list ();
3041 #endif /* PROCESS_SUBSTITUTION */
3042 exit (EXECUTION_FAILURE
);
3046 interactive
= old_interactive
;
3050 internal_error ("%s: command not found", pathname
);
3051 exit (EX_NOTFOUND
); /* Posix.2 says the exit status is 127 */
3054 /* Execve expects the command name to be in args[0]. So we
3055 leave it there, in the same format that the user used to
3057 args
= word_list_to_argv (words
, 0, 0, (int *)NULL
);
3058 exit (shell_execve (command
, args
, export_env
));
3062 /* Make sure that the pipes are closed in the parent. */
3063 close_pipes (pipe_in
, pipe_out
);
3064 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
3065 unlink_fifo_list ();
3071 #if !defined (HAVE_HASH_BANG_EXEC)
3072 /* If the operating system on which we're running does not handle
3073 the #! executable format, then help out. SAMPLE is the text read
3074 from the file, SAMPLE_LEN characters. COMMAND is the name of
3075 the script; it and ARGS, the arguments given by the user, will
3076 become arguments to the specified interpreter. ENV is the environment
3077 to pass to the interpreter.
3079 The word immediately following the #! is the interpreter to execute.
3080 A single argument to the interpreter is allowed. */
3082 execute_shell_script (sample
, sample_len
, command
, args
, env
)
3083 unsigned char *sample
;
3089 char *execname
, *firstarg
;
3090 int start
, size_increment
, larry
;
3092 /* Find the name of the interpreter to exec. */
3093 for (i
= 2; whitespace (sample
[i
]) && i
< sample_len
; i
++)
3097 !whitespace (sample
[i
]) && sample
[i
] != '\n' && i
< sample_len
;
3102 execname
= xmalloc (1 + larry
);
3103 strncpy (execname
, (char *)(sample
+ start
), larry
);
3104 execname
[larry
] = '\0';
3107 /* Now the argument, if any. */
3108 firstarg
= (char *)NULL
;
3110 whitespace (sample
[i
]) && sample
[i
] != '\n' && i
< sample_len
;
3114 /* If there is more text on the line, then it is an argument for the
3116 if (i
< sample_len
&& sample
[i
] != '\n' && !whitespace (sample
[i
]))
3119 !whitespace (sample
[i
]) && sample
[i
] != '\n' && i
< sample_len
;
3123 firstarg
= xmalloc (1 + larry
);
3124 strncpy (firstarg
, (char *)(sample
+ start
), larry
);
3125 firstarg
[larry
] = '\0';
3130 larry
= array_len (args
) + size_increment
;
3132 args
= (char **)xrealloc ((char *)args
, (1 + larry
) * sizeof (char *));
3134 for (i
= larry
- 1; i
; i
--)
3135 args
[i
] = args
[i
- size_increment
];
3146 args
[larry
] = (char *)NULL
;
3148 return (shell_execve (execname
, args
, env
));
3150 #endif /* !HAVE_HASH_BANG_EXEC */
3153 initialize_subshell ()
3156 /* Forget about any aliases that we knew of. We are in a subshell. */
3157 delete_all_aliases ();
3160 #if defined (HISTORY)
3161 /* Forget about the history lines we have read. This is a non-interactive
3163 history_lines_this_session
= 0;
3166 #if defined (JOB_CONTROL)
3167 /* Forget about the way job control was working. We are in a subshell. */
3168 without_job_control ();
3169 set_sigchld_handler ();
3170 #endif /* JOB_CONTROL */
3172 /* Reset the values of the shell flags and options. */
3173 reset_shell_flags ();
3174 reset_shell_options ();
3175 reset_shopt_options ();
3177 /* If we're not interactive, close the file descriptor from which we're
3178 reading the current shell script. */
3179 if (interactive_shell
== 0)
3180 unset_bash_input (1);
3183 #if defined (HAVE_SETOSTYPE) && defined (_POSIX_SOURCE)
3184 # define SETOSTYPE(x) __setostype(x)
3186 # define SETOSTYPE(x)
3189 /* Call execve (), handling interpreting shell scripts, and handling
3192 shell_execve (command
, args
, env
)
3199 SETOSTYPE (0); /* Some systems use for USG/POSIX semantics */
3200 execve (command
, args
, env
);
3203 /* If we get to this point, then start checking out the file.
3204 Maybe it is something we can hack ourselves. */
3205 if (errno
!= ENOEXEC
)
3208 if ((stat (command
, &finfo
) == 0) && (S_ISDIR (finfo
.st_mode
)))
3209 internal_error ("%s: is a directory", command
);
3213 file_error (command
);
3215 return ((i
== ENOENT
) ? EX_NOTFOUND
: EX_NOEXEC
); /* XXX Posix.2 says that exit status is 126 */
3218 /* This file is executable.
3219 If it begins with #!, then help out people with losing operating
3220 systems. Otherwise, check to see if it is a binary file by seeing
3221 if the first line (or up to 80 characters) are in the ASCII set.
3222 Execute the contents as shell commands. */
3223 fd
= open (command
, O_RDONLY
);
3226 unsigned char sample
[80];
3229 sample_len
= read (fd
, (char *)sample
, 80);
3232 if (sample_len
== 0)
3233 return (EXECUTION_SUCCESS
);
3235 /* Is this supposed to be an executable script?
3236 If so, the format of the line is "#! interpreter [argument]".
3237 A single argument is allowed. The BSD kernel restricts
3238 the length of the entire line to 32 characters (32 bytes
3239 being the size of the BSD exec header), but we allow 80
3243 #if !defined (HAVE_HASH_BANG_EXEC)
3244 if (sample
[0] == '#' && sample
[1] == '!')
3245 return (execute_shell_script (sample
, sample_len
, command
, args
, env
));
3248 if (check_binary_file (sample
, sample_len
))
3250 internal_error ("%s: cannot execute binary file", command
);
3251 return (EX_BINARY_FILE
);
3256 initialize_subshell ();
3258 set_sigint_handler ();
3260 /* Insert the name of this shell into the argument list. */
3261 larray
= array_len (args
) + 1;
3262 args
= (char **)xrealloc ((char *)args
, (1 + larray
) * sizeof (char *));
3264 for (i
= larray
- 1; i
; i
--)
3265 args
[i
] = args
[i
- 1];
3267 args
[0] = shell_name
;
3269 args
[larray
] = (char *)NULL
;
3271 if (args
[0][0] == '-')
3274 #if defined (RESTRICTED_SHELL)
3276 change_flag ('r', FLAG_OFF
);
3281 /* Can't free subshell_argv[0]; that is shell_name. */
3282 for (i
= 1; i
< subshell_argc
; i
++)
3283 free (subshell_argv
[i
]);
3284 free (subshell_argv
);
3287 dispose_command (currently_executing_command
); /* XXX */
3288 currently_executing_command
= (COMMAND
*)NULL
;
3290 subshell_argc
= larray
;
3291 subshell_argv
= args
;
3292 subshell_envp
= env
;
3294 unbind_args (); /* remove the positional parameters */
3296 longjmp (subshell_top_level
, 1);
3300 execute_intern_function (name
, function
)
3306 if (check_identifier (name
, posixly_correct
) == 0)
3308 if (posixly_correct
&& interactive_shell
== 0)
3310 last_command_exit_value
= EX_USAGE
;
3311 jump_to_top_level (EXITPROG
);
3313 return (EXECUTION_FAILURE
);
3316 var
= find_function (name
->word
);
3317 if (var
&& readonly_p (var
))
3319 internal_error ("%s: readonly function", var
->name
);
3320 return (EXECUTION_FAILURE
);
3323 bind_function (name
->word
, function
);
3324 return (EXECUTION_SUCCESS
);
3327 #if defined (INCLUDE_UNUSED)
3328 #if defined (PROCESS_SUBSTITUTION)
3332 register int i
, fd_table_size
;
3334 fd_table_size
= getdtablesize ();
3335 if (fd_table_size
> 256) /* clamp to a reasonable value */
3336 fd_table_size
= 256;
3338 for (i
= 3; i
< fd_table_size
; i
++)
3341 #endif /* PROCESS_SUBSTITUTION */
3345 close_pipes (in
, out
)
3354 /* Redirect input and output to be from and to the specified pipes.
3355 NO_PIPE and REDIRECT_BOTH are handled correctly. */
3357 do_piping (pipe_in
, pipe_out
)
3358 int pipe_in
, pipe_out
;
3360 if (pipe_in
!= NO_PIPE
)
3362 if (dup2 (pipe_in
, 0) < 0)
3363 sys_error ("cannot duplicate fd %d to fd 0", pipe_in
);
3367 setmode (0, O_TEXT
);
3370 if (pipe_out
!= NO_PIPE
)
3372 if (pipe_out
!= REDIRECT_BOTH
)
3374 if (dup2 (pipe_out
, 1) < 0)
3375 sys_error ("cannot duplicate fd %d to fd 1", pipe_out
);
3376 if (pipe_out
== 0 || pipe_out
> 1)
3379 setmode (1, O_TEXT
);
3384 if (dup2 (1, 2) < 0)
3385 sys_error ("cannot duplicate fd 1 to fd 2");
3387 setmode (1, O_TEXT
);
3388 setmode (2, O_TEXT
);