1 /* execute_cmd.c -- Execute a COMMAND structure. */
3 /* Copyright (C) 1987-2013 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
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.
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.
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/>.
23 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
25 #endif /* _AIX && RISC6000 && !__GNUC__ */
28 #include "chartypes.h"
29 #include "bashtypes.h"
30 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
31 # include <sys/file.h>
34 #include "posixstat.h"
36 #if defined (HAVE_SYS_PARAM_H)
37 # include <sys/param.h>
40 #if defined (HAVE_UNISTD_H)
44 #include "posixtime.h"
46 #if defined (HAVE_SYS_RESOURCE_H) && !defined (RLIMTYPE)
47 # include <sys/resource.h>
50 #if defined (HAVE_SYS_TIMES_H) && defined (HAVE_TIMES)
51 # include <sys/times.h>
60 #define NEED_FPURGE_DECL
67 #include <y.tab.h> /* use <...> so we pick it up from the build directory */
72 #include "execute_cmd.h"
79 #if defined (COND_COMMAND)
83 #include "builtins/common.h"
84 #include "builtins/builtext.h" /* list of builtins */
86 #include <glob/strmatch.h>
87 #include <tilde/tilde.h>
89 #if defined (BUFFERED_INPUT)
98 # include "bashhist.h"
101 extern int dollar_dollar_pid
;
102 extern int posixly_correct
;
103 extern int expand_aliases
;
105 extern int breaking
, continuing
, loop_level
;
106 extern int parse_and_execute_level
, running_trap
, sourcelevel
;
107 extern int command_string_index
, line_number
;
108 extern int dot_found_in_search
;
109 extern int already_making_children
;
110 extern int tempenv_assign_error
;
111 extern char *the_printed_command
, *shell_name
;
112 extern pid_t last_command_subst_pid
;
113 extern sh_builtin_func_t
*last_shell_builtin
, *this_shell_builtin
;
114 extern char **subshell_argv
, **subshell_envp
;
115 extern int subshell_argc
;
116 extern time_t shell_start_time
;
118 extern char *glob_argv_flags
;
121 extern int job_control
; /* XXX */
123 extern int close
__P((int));
125 /* Static functions defined and used in this file. */
126 static void close_pipes
__P((int, int));
127 static void do_piping
__P((int, int));
128 static void bind_lastarg
__P((char *));
129 static int shell_control_structure
__P((enum command_type
));
130 static void cleanup_redirects
__P((REDIRECT
*));
132 #if defined (JOB_CONTROL)
133 static int restore_signal_mask
__P((sigset_t
*));
136 static void async_redirect_stdin
__P((void));
138 static int builtin_status
__P((int));
140 static int execute_for_command
__P((FOR_COM
*));
141 #if defined (SELECT_COMMAND)
142 static int displen
__P((const char *));
143 static int print_index_and_element
__P((int, int, WORD_LIST
*));
144 static void indent
__P((int, int));
145 static void print_select_list
__P((WORD_LIST
*, int, int, int));
146 static char *select_query
__P((WORD_LIST
*, int, char *, int));
147 static int execute_select_command
__P((SELECT_COM
*));
149 #if defined (DPAREN_ARITHMETIC)
150 static int execute_arith_command
__P((ARITH_COM
*));
152 #if defined (COND_COMMAND)
153 static int execute_cond_node
__P((COND_COM
*));
154 static int execute_cond_command
__P((COND_COM
*));
156 #if defined (COMMAND_TIMING)
157 static int mkfmt
__P((char *, int, int, time_t, int));
158 static void print_formatted_time
__P((FILE *, char *,
159 time_t, int, time_t, int,
161 static int time_command
__P((COMMAND
*, int, int, int, struct fd_bitmap
*));
163 #if defined (ARITH_FOR_COMMAND)
164 static intmax_t eval_arith_for_expr
__P((WORD_LIST
*, int *));
165 static int execute_arith_for_command
__P((ARITH_FOR_COM
*));
167 static int execute_case_command
__P((CASE_COM
*));
168 static int execute_while_command
__P((WHILE_COM
*));
169 static int execute_until_command
__P((WHILE_COM
*));
170 static int execute_while_or_until
__P((WHILE_COM
*, int));
171 static int execute_if_command
__P((IF_COM
*));
172 static int execute_null_command
__P((REDIRECT
*, int, int, int));
173 static void fix_assignment_words
__P((WORD_LIST
*));
174 static int execute_simple_command
__P((SIMPLE_COM
*, int, int, int, struct fd_bitmap
*));
175 static int execute_builtin
__P((sh_builtin_func_t
*, WORD_LIST
*, int, int));
176 static int execute_function
__P((SHELL_VAR
*, WORD_LIST
*, int, struct fd_bitmap
*, int, int));
177 static int execute_builtin_or_function
__P((WORD_LIST
*, sh_builtin_func_t
*,
179 REDIRECT
*, struct fd_bitmap
*, int));
180 static void execute_subshell_builtin_or_function
__P((WORD_LIST
*, REDIRECT
*,
186 static int execute_disk_command
__P((WORD_LIST
*, REDIRECT
*, char *,
187 int, int, int, struct fd_bitmap
*, int));
189 static char *getinterp
__P((char *, int, int *));
190 static void initialize_subshell
__P((void));
191 static int execute_in_subshell
__P((COMMAND
*, int, int, int, struct fd_bitmap
*));
192 #if defined (COPROCESS_SUPPORT)
193 static int execute_coproc
__P((COMMAND
*, int, int, struct fd_bitmap
*));
196 static int execute_pipeline
__P((COMMAND
*, int, int, int, struct fd_bitmap
*));
198 static int execute_connection
__P((COMMAND
*, int, int, int, struct fd_bitmap
*));
200 static int execute_intern_function
__P((WORD_DESC
*, FUNCTION_DEF
*));
202 /* Set to 1 if fd 0 was the subject of redirection to a subshell. Global
203 so that reader_loop can set it to zero before executing a command. */
206 /* The name of the command that is currently being executed.
207 `test' needs this, for example. */
208 char *this_command_name
;
210 /* The printed representation of the currently-executing command (same as
211 the_printed_command), except when a trap is being executed. Useful for
212 a debugger to know where exactly the program is currently executing. */
213 char *the_printed_command_except_trap
;
215 /* For catching RETURN in a function. */
216 int return_catch_flag
;
217 int return_catch_value
;
218 procenv_t return_catch
;
220 /* The value returned by the last synchronous command. */
221 int last_command_exit_value
;
223 /* Whether or not the last command (corresponding to last_command_exit_value)
224 was terminated by a signal, and, if so, which one. */
225 int last_command_exit_signal
;
227 /* Are we currently ignoring the -e option for the duration of a builtin's
229 int builtin_ignoring_errexit
= 0;
231 /* The list of redirections to perform which will undo the redirections
232 that I made in the shell. */
233 REDIRECT
*redirection_undo_list
= (REDIRECT
*)NULL
;
235 /* The list of redirections to perform which will undo the internal
236 redirections performed by the `exec' builtin. These are redirections
237 that must be undone even when exec discards redirection_undo_list. */
238 REDIRECT
*exec_redirection_undo_list
= (REDIRECT
*)NULL
;
240 /* When greater than zero, value is the `level' of builtins we are
241 currently executing (e.g. `eval echo a' would have it set to 2). */
242 int executing_builtin
= 0;
244 /* Non-zero if we are executing a command list (a;b;c, etc.) */
245 int executing_list
= 0;
247 /* Non-zero if failing commands in a command substitution should not exit the
248 shell even if -e is set. Used to pass the CMD_IGNORE_RETURN flag down to
249 commands run in command substitutions by parse_and_execute. */
250 int comsub_ignore_return
= 0;
252 /* Non-zero if we have just forked and are currently running in a subshell
254 int subshell_environment
;
256 /* Count of nested subshells, like SHLVL. Available via $BASH_SUBSHELL */
257 int subshell_level
= 0;
259 /* Currently-executing shell function. */
260 SHELL_VAR
*this_shell_function
;
262 /* If non-zero, matches in case and [[ ... ]] are case-insensitive */
263 int match_ignore_case
= 0;
265 int executing_command_builtin
= 0;
267 struct stat SB
; /* used for debugging */
269 static int special_builtin_failed
;
271 static COMMAND
*currently_executing_command
;
273 /* The line number that the currently executing function starts on. */
274 static int function_line_number
;
276 /* XXX - set to 1 if we're running the DEBUG trap and we want to show the line
277 number containing the function name. Used by executing_line_number to
278 report the correct line number. Kind of a hack. */
279 static int showing_function_line
;
281 /* $LINENO ($BASH_LINENO) for use by an ERR trap. Global so parse_and_execute
282 can save and restore it. */
283 int line_number_for_err_trap
;
285 /* A sort of function nesting level counter */
287 int funcnest_max
= 0; /* bash-4.2 */
289 int lastpipe_opt
= 0;
291 struct fd_bitmap
*current_fds_to_close
= (struct fd_bitmap
*)NULL
;
293 #define FD_BITMAP_DEFAULT_SIZE 32
295 /* Functions to allocate and deallocate the structures used to pass
296 information from the shell to its children about file descriptors
302 struct fd_bitmap
*ret
;
304 ret
= (struct fd_bitmap
*)xmalloc (sizeof (struct fd_bitmap
));
310 ret
->bitmap
= (char *)xmalloc (size
);
311 memset (ret
->bitmap
, '\0', size
);
314 ret
->bitmap
= (char *)NULL
;
319 dispose_fd_bitmap (fdbp
)
320 struct fd_bitmap
*fdbp
;
327 close_fd_bitmap (fdbp
)
328 struct fd_bitmap
*fdbp
;
334 for (i
= 0; i
< fdbp
->size
; i
++)
343 /* Return the line number of the currently executing command. */
345 executing_line_number ()
347 if (executing
&& showing_function_line
== 0 &&
348 (variable_context
== 0 || interactive_shell
== 0) &&
349 currently_executing_command
)
351 #if defined (COND_COMMAND)
352 if (currently_executing_command
->type
== cm_cond
)
353 return currently_executing_command
->value
.Cond
->line
;
355 #if defined (DPAREN_ARITHMETIC)
356 if (currently_executing_command
->type
== cm_arith
)
357 return currently_executing_command
->value
.Arith
->line
;
359 #if defined (ARITH_FOR_COMMAND)
360 if (currently_executing_command
->type
== cm_arith_for
)
361 return currently_executing_command
->value
.ArithFor
->line
;
370 /* Execute the command passed in COMMAND. COMMAND is exactly what
371 read_command () places into GLOBAL_COMMAND. See "command.h" for the
372 details of the command structure.
374 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
375 return values. Executing a command with nothing in it returns
376 EXECUTION_SUCCESS. */
378 execute_command (command
)
381 struct fd_bitmap
*bitmap
;
384 current_fds_to_close
= (struct fd_bitmap
*)NULL
;
385 bitmap
= new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE
);
386 begin_unwind_frame ("execute-command");
387 add_unwind_protect (dispose_fd_bitmap
, (char *)bitmap
);
389 /* Just do the command, but not asynchronously. */
390 result
= execute_command_internal (command
, 0, NO_PIPE
, NO_PIPE
, bitmap
);
392 dispose_fd_bitmap (bitmap
);
393 discard_unwind_frame ("execute-command");
395 #if defined (PROCESS_SUBSTITUTION)
396 /* don't unlink fifos if we're in a shell function; wait until the function
398 if (variable_context
== 0)
400 #endif /* PROCESS_SUBSTITUTION */
406 /* Return 1 if TYPE is a shell control structure type. */
408 shell_control_structure (type
)
409 enum command_type type
;
413 #if defined (ARITH_FOR_COMMAND)
416 #if defined (SELECT_COMMAND)
419 #if defined (DPAREN_ARITHMETIC)
422 #if defined (COND_COMMAND)
431 case cm_function_def
:
439 /* A function to use to unwind_protect the redirection undo list
442 cleanup_redirects (list
)
445 do_redirections (list
, RX_ACTIVE
);
446 dispose_redirects (list
);
450 /* Function to unwind_protect the redirections for functions and builtins. */
452 cleanup_func_redirects (list
)
455 do_redirections (list
, RX_ACTIVE
);
460 dispose_exec_redirects ()
462 if (exec_redirection_undo_list
)
464 dispose_redirects (exec_redirection_undo_list
);
465 exec_redirection_undo_list
= (REDIRECT
*)NULL
;
469 #if defined (JOB_CONTROL)
470 /* A function to restore the signal mask to its proper value when the shell
471 is interrupted or errors occur while creating a pipeline. */
473 restore_signal_mask (set
)
476 return (sigprocmask (SIG_SETMASK
, set
, (sigset_t
*)NULL
));
478 #endif /* JOB_CONTROL */
481 /* A debugging function that can be called from gdb, for instance. */
486 int f
, fd_table_size
;
488 fd_table_size
= getdtablesize ();
490 fprintf (stderr
, "pid %ld open files:", (long)getpid ());
491 for (i
= 3; i
< fd_table_size
; i
++)
493 if ((f
= fcntl (i
, F_GETFD
, 0)) != -1)
494 fprintf (stderr
, " %d (%s)", i
, f
? "close" : "open");
496 fprintf (stderr
, "\n");
501 async_redirect_stdin ()
505 fd
= open ("/dev/null", O_RDONLY
);
512 internal_error (_("cannot redirect standard input from /dev/null: %s"), strerror (errno
));
515 #define DESCRIBE_PID(pid) do { if (interactive) describe_pid (pid); } while (0)
517 /* Execute the command passed in COMMAND, perhaps doing it asynchronously.
518 COMMAND is exactly what read_command () places into GLOBAL_COMMAND.
519 ASYNCHROUNOUS, if non-zero, says to do this command in the background.
520 PIPE_IN and PIPE_OUT are file descriptors saying where input comes
521 from and where it goes. They can have the value of NO_PIPE, which means
523 FDS_TO_CLOSE is a list of file descriptors to close once the child has
524 been forked. This list often contains the unusable sides of pipes, etc.
526 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
527 return values. Executing a command with nothing in it returns
528 EXECUTION_SUCCESS. */
530 execute_command_internal (command
, asynchronous
, pipe_in
, pipe_out
,
534 int pipe_in
, pipe_out
;
535 struct fd_bitmap
*fds_to_close
;
537 int exec_result
, user_subshell
, invert
, ignore_return
, was_error_trap
;
538 REDIRECT
*my_undo_list
, *exec_undo_list
;
540 volatile int last_pid
;
541 volatile int save_line_number
;
542 #if defined (PROCESS_SUBSTITUTION)
543 volatile int ofifo
, nfifo
, osize
, saved_fifo
;
544 volatile char *ofifo_list
;
547 if (breaking
|| continuing
)
548 return (last_command_exit_value
);
549 if (command
== 0 || read_but_dont_execute
)
550 return (EXECUTION_SUCCESS
);
553 run_pending_traps ();
556 if (running_trap
== 0)
558 currently_executing_command
= command
;
560 invert
= (command
->flags
& CMD_INVERT_RETURN
) != 0;
562 /* If we're inverting the return value and `set -e' has been executed,
563 we don't want a failing command to inadvertently cause the shell
565 if (exit_immediately_on_error
&& invert
) /* XXX */
566 command
->flags
|= CMD_IGNORE_RETURN
; /* XXX */
568 exec_result
= EXECUTION_SUCCESS
;
570 /* If a command was being explicitly run in a subshell, or if it is
571 a shell control-structure, and it has a pipe, then we do the command
573 if (command
->type
== cm_subshell
&& (command
->flags
& CMD_NO_FORK
))
574 return (execute_in_subshell (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
));
576 #if defined (COPROCESS_SUPPORT)
577 if (command
->type
== cm_coproc
)
578 return (execute_coproc (command
, pipe_in
, pipe_out
, fds_to_close
));
581 user_subshell
= command
->type
== cm_subshell
|| ((command
->flags
& CMD_WANT_SUBSHELL
) != 0);
583 if (command
->type
== cm_subshell
||
584 (command
->flags
& (CMD_WANT_SUBSHELL
|CMD_FORCE_SUBSHELL
)) ||
585 (shell_control_structure (command
->type
) &&
586 (pipe_out
!= NO_PIPE
|| pipe_in
!= NO_PIPE
|| asynchronous
)))
591 /* Fork a subshell, turn off the subshell bit, turn off job
592 control and call execute_command () on the command again. */
593 line_number_for_err_trap
= line_number
;
594 tcmd
= make_command_string (command
);
595 paren_pid
= make_child (savestring (tcmd
), asynchronous
);
597 if (user_subshell
&& signal_is_trapped (ERROR_TRAP
) &&
598 signal_in_progress (DEBUG_TRAP
) == 0 && running_trap
== 0)
600 FREE (the_printed_command_except_trap
);
601 the_printed_command_except_trap
= savestring (the_printed_command
);
606 /* We want to run the exit trap for forced {} subshells, and we
607 want to note this before execute_in_subshell modifies the
608 COMMAND struct. Need to keep in mind that execute_in_subshell
609 runs the exit trap for () subshells itself. */
610 /* This handles { command; } & */
611 s
= user_subshell
== 0 && command
->type
== cm_group
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
&& asynchronous
;
612 /* run exit trap for : | { ...; } and { ...; } | : */
613 /* run exit trap for : | ( ...; ) and ( ...; ) | : */
614 s
+= user_subshell
== 0 && command
->type
== cm_group
&& (pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
) && asynchronous
== 0;
616 last_command_exit_value
= execute_in_subshell (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
618 subshell_exit (last_command_exit_value
);
620 exit (last_command_exit_value
);
625 close_pipes (pipe_in
, pipe_out
);
627 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
628 if (variable_context
== 0) /* wait until shell function completes */
631 /* If we are part of a pipeline, and not the end of the pipeline,
632 then we should simply return and let the last command in the
633 pipe be waited for. If we are not in a pipeline, or are the
634 last command in the pipeline, then we wait for the subshell
635 and return its exit status as usual. */
636 if (pipe_out
!= NO_PIPE
)
637 return (EXECUTION_SUCCESS
);
639 stop_pipeline (asynchronous
, (COMMAND
*)NULL
);
641 if (asynchronous
== 0)
643 was_error_trap
= signal_is_trapped (ERROR_TRAP
) && signal_is_ignored (ERROR_TRAP
) == 0;
644 invert
= (command
->flags
& CMD_INVERT_RETURN
) != 0;
645 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
647 exec_result
= wait_for (paren_pid
);
649 /* If we have to, invert the return value. */
651 exec_result
= ((exec_result
== EXECUTION_SUCCESS
)
653 : EXECUTION_SUCCESS
);
655 last_command_exit_value
= exec_result
;
656 if (user_subshell
&& was_error_trap
&& ignore_return
== 0 && invert
== 0 && exec_result
!= EXECUTION_SUCCESS
)
658 save_line_number
= line_number
;
659 line_number
= line_number_for_err_trap
;
661 line_number
= save_line_number
;
664 if (user_subshell
&& ignore_return
== 0 && invert
== 0 && exit_immediately_on_error
&& exec_result
!= EXECUTION_SUCCESS
)
666 run_pending_traps ();
667 jump_to_top_level (ERREXIT
);
670 return (last_command_exit_value
);
674 DESCRIBE_PID (paren_pid
);
676 run_pending_traps ();
678 /* Posix 2013 2.9.3.1: "the exit status of an asynchronous list
680 last_command_exit_value
= 0;
681 return (EXECUTION_SUCCESS
);
686 #if defined (COMMAND_TIMING)
687 if (command
->flags
& CMD_TIME_PIPELINE
)
691 command
->flags
|= CMD_FORCE_SUBSHELL
;
692 exec_result
= execute_command_internal (command
, 1, pipe_in
, pipe_out
, fds_to_close
);
696 exec_result
= time_command (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
698 if (running_trap
== 0)
700 currently_executing_command
= (COMMAND
*)NULL
;
702 return (exec_result
);
704 #endif /* COMMAND_TIMING */
706 if (shell_control_structure (command
->type
) && command
->redirects
)
707 stdin_redir
= stdin_redirects (command
->redirects
);
709 #if defined (PROCESS_SUBSTITUTION)
710 if (variable_context
!= 0)
712 ofifo
= num_fifos ();
713 ofifo_list
= copy_fifo_list ((int *)&osize
);
720 /* Handle WHILE FOR CASE etc. with redirections. (Also '&' input
722 if (do_redirections (command
->redirects
, RX_ACTIVE
|RX_UNDOABLE
) != 0)
724 cleanup_redirects (redirection_undo_list
);
725 redirection_undo_list
= (REDIRECT
*)NULL
;
726 dispose_exec_redirects ();
727 #if defined (PROCESS_SUBSTITUTION)
729 free ((void *)ofifo_list
);
731 return (last_command_exit_value
= EXECUTION_FAILURE
);
734 if (redirection_undo_list
)
736 /* XXX - why copy here? */
737 my_undo_list
= (REDIRECT
*)copy_redirects (redirection_undo_list
);
738 dispose_redirects (redirection_undo_list
);
739 redirection_undo_list
= (REDIRECT
*)NULL
;
742 my_undo_list
= (REDIRECT
*)NULL
;
744 if (exec_redirection_undo_list
)
746 /* XXX - why copy here? */
747 exec_undo_list
= (REDIRECT
*)copy_redirects (exec_redirection_undo_list
);
748 dispose_redirects (exec_redirection_undo_list
);
749 exec_redirection_undo_list
= (REDIRECT
*)NULL
;
752 exec_undo_list
= (REDIRECT
*)NULL
;
754 if (my_undo_list
|| exec_undo_list
)
755 begin_unwind_frame ("loop_redirections");
758 add_unwind_protect ((Function
*)cleanup_redirects
, my_undo_list
);
761 add_unwind_protect ((Function
*)dispose_redirects
, exec_undo_list
);
763 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
767 switch (command
->type
)
771 save_line_number
= line_number
;
772 /* We can't rely on variables retaining their values across a
773 call to execute_simple_command if a longjmp occurs as the
774 result of a `return' builtin. This is true for sure with gcc. */
775 #if defined (RECYCLES_PIDS)
776 last_made_pid
= NO_PID
;
778 last_pid
= last_made_pid
;
779 was_error_trap
= signal_is_trapped (ERROR_TRAP
) && signal_is_ignored (ERROR_TRAP
) == 0;
781 if (ignore_return
&& command
->value
.Simple
)
782 command
->value
.Simple
->flags
|= CMD_IGNORE_RETURN
;
783 if (command
->flags
& CMD_STDIN_REDIR
)
784 command
->value
.Simple
->flags
|= CMD_STDIN_REDIR
;
786 line_number_for_err_trap
= line_number
= command
->value
.Simple
->line
;
788 execute_simple_command (command
->value
.Simple
, pipe_in
, pipe_out
,
789 asynchronous
, fds_to_close
);
790 line_number
= save_line_number
;
792 /* The temporary environment should be used for only the simple
793 command immediately following its definition. */
794 dispose_used_env_vars ();
796 #if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
797 /* Reclaim memory allocated with alloca () on machines which
798 may be using the alloca emulation code. */
800 #endif /* (ultrix && mips) || C_ALLOCA */
802 /* If we forked to do the command, then we must wait_for ()
805 /* XXX - this is something to watch out for if there are problems
806 when the shell is compiled without job control. Don't worry about
807 whether or not last_made_pid == last_pid; already_making_children
808 tells us whether or not there are unwaited-for children to wait
810 if (already_making_children
&& pipe_out
== NO_PIPE
)
812 stop_pipeline (asynchronous
, (COMMAND
*)NULL
);
816 DESCRIBE_PID (last_made_pid
);
819 #if !defined (JOB_CONTROL)
820 /* Do not wait for asynchronous processes started from
822 if (last_made_pid
!= last_asynchronous_pid
)
824 /* When executing a shell function that executes other
825 commands, this causes the last simple command in
826 the function to be waited for twice. This also causes
827 subshells forked to execute builtin commands (e.g., in
828 pipelines) to be waited for twice. */
829 exec_result
= wait_for (last_made_pid
);
833 /* 2009/02/13 -- pipeline failure is processed elsewhere. This handles
834 only the failure of a simple command. */
835 if (was_error_trap
&& ignore_return
== 0 && invert
== 0 && pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
&& exec_result
!= EXECUTION_SUCCESS
)
837 last_command_exit_value
= exec_result
;
838 line_number
= line_number_for_err_trap
;
840 line_number
= save_line_number
;
843 if (ignore_return
== 0 && invert
== 0 &&
844 ((posixly_correct
&& interactive
== 0 && special_builtin_failed
) ||
845 (exit_immediately_on_error
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
&& exec_result
!= EXECUTION_SUCCESS
)))
847 last_command_exit_value
= exec_result
;
848 run_pending_traps ();
849 jump_to_top_level (ERREXIT
);
856 command
->value
.For
->flags
|= CMD_IGNORE_RETURN
;
857 exec_result
= execute_for_command (command
->value
.For
);
860 #if defined (ARITH_FOR_COMMAND)
863 command
->value
.ArithFor
->flags
|= CMD_IGNORE_RETURN
;
864 exec_result
= execute_arith_for_command (command
->value
.ArithFor
);
868 #if defined (SELECT_COMMAND)
871 command
->value
.Select
->flags
|= CMD_IGNORE_RETURN
;
872 exec_result
= execute_select_command (command
->value
.Select
);
878 command
->value
.Case
->flags
|= CMD_IGNORE_RETURN
;
879 exec_result
= execute_case_command (command
->value
.Case
);
884 command
->value
.While
->flags
|= CMD_IGNORE_RETURN
;
885 exec_result
= execute_while_command (command
->value
.While
);
890 command
->value
.While
->flags
|= CMD_IGNORE_RETURN
;
891 exec_result
= execute_until_command (command
->value
.While
);
896 command
->value
.If
->flags
|= CMD_IGNORE_RETURN
;
897 exec_result
= execute_if_command (command
->value
.If
);
902 /* This code can be executed from either of two paths: an explicit
903 '{}' command, or via a function call. If we are executed via a
904 function call, we have already taken care of the function being
905 executed in the background (down there in execute_simple_command ()),
906 and this command should *not* be marked as asynchronous. If we
907 are executing a regular '{}' group command, and asynchronous == 1,
908 we must want to execute the whole command in the background, so we
909 need a subshell, and we want the stuff executed in that subshell
910 (this group command) to be executed in the foreground of that
911 subshell (i.e. there will not be *another* subshell forked).
913 What we do is to force a subshell if asynchronous, and then call
914 execute_command_internal again with asynchronous still set to 1,
915 but with the original group command, so the printed command will
918 The code above that handles forking off subshells will note that
919 both subshell and async are on, and turn off async in the child
920 after forking the subshell (but leave async set in the parent, so
921 the normal call to describe_pid is made). This turning off
922 async is *crucial*; if it is not done, this will fall into an
923 infinite loop of executions through this spot in subshell after
924 subshell until the process limit is exhausted. */
928 command
->flags
|= CMD_FORCE_SUBSHELL
;
930 execute_command_internal (command
, 1, pipe_in
, pipe_out
,
935 if (ignore_return
&& command
->value
.Group
->command
)
936 command
->value
.Group
->command
->flags
|= CMD_IGNORE_RETURN
;
938 execute_command_internal (command
->value
.Group
->command
,
939 asynchronous
, pipe_in
, pipe_out
,
945 exec_result
= execute_connection (command
, asynchronous
,
946 pipe_in
, pipe_out
, fds_to_close
);
949 #if defined (DPAREN_ARITHMETIC)
951 was_error_trap
= signal_is_trapped (ERROR_TRAP
) && signal_is_ignored (ERROR_TRAP
) == 0;
953 command
->value
.Arith
->flags
|= CMD_IGNORE_RETURN
;
954 line_number_for_err_trap
= save_line_number
= line_number
;
955 exec_result
= execute_arith_command (command
->value
.Arith
);
956 line_number
= save_line_number
;
958 if (was_error_trap
&& ignore_return
== 0 && invert
== 0 && exec_result
!= EXECUTION_SUCCESS
)
960 last_command_exit_value
= exec_result
;
961 save_line_number
= line_number
;
962 line_number
= line_number_for_err_trap
;
964 line_number
= save_line_number
;
967 if (ignore_return
== 0 && invert
== 0 && exit_immediately_on_error
&& exec_result
!= EXECUTION_SUCCESS
)
969 last_command_exit_value
= exec_result
;
970 run_pending_traps ();
971 jump_to_top_level (ERREXIT
);
977 #if defined (COND_COMMAND)
979 was_error_trap
= signal_is_trapped (ERROR_TRAP
) && signal_is_ignored (ERROR_TRAP
) == 0;
981 command
->value
.Cond
->flags
|= CMD_IGNORE_RETURN
;
983 line_number_for_err_trap
= save_line_number
= line_number
;
984 exec_result
= execute_cond_command (command
->value
.Cond
);
985 line_number
= save_line_number
;
987 if (was_error_trap
&& ignore_return
== 0 && invert
== 0 && exec_result
!= EXECUTION_SUCCESS
)
989 last_command_exit_value
= exec_result
;
990 save_line_number
= line_number
;
991 line_number
= line_number_for_err_trap
;
993 line_number
= save_line_number
;
996 if (ignore_return
== 0 && invert
== 0 && exit_immediately_on_error
&& exec_result
!= EXECUTION_SUCCESS
)
998 last_command_exit_value
= exec_result
;
999 run_pending_traps ();
1000 jump_to_top_level (ERREXIT
);
1006 case cm_function_def
:
1007 exec_result
= execute_intern_function (command
->value
.Function_def
->name
,
1008 command
->value
.Function_def
);
1012 command_error ("execute_command", CMDERR_BADTYPE
, command
->type
, 0);
1017 do_redirections (my_undo_list
, RX_ACTIVE
);
1018 dispose_redirects (my_undo_list
);
1022 dispose_redirects (exec_undo_list
);
1024 if (my_undo_list
|| exec_undo_list
)
1025 discard_unwind_frame ("loop_redirections");
1027 #if defined (PROCESS_SUBSTITUTION)
1030 nfifo
= num_fifos ();
1032 close_new_fifos ((char *)ofifo_list
, osize
);
1033 free ((void *)ofifo_list
);
1037 /* Invert the return value if we have to */
1039 exec_result
= (exec_result
== EXECUTION_SUCCESS
)
1041 : EXECUTION_SUCCESS
;
1043 #if defined (DPAREN_ARITHMETIC) || defined (COND_COMMAND)
1044 /* This is where we set PIPESTATUS from the exit status of the appropriate
1045 compound commands (the ones that look enough like simple commands to
1046 cause confusion). We might be able to optimize by not doing this if
1047 subshell_environment != 0. */
1048 switch (command
->type
)
1050 # if defined (DPAREN_ARITHMETIC)
1053 # if defined (COND_COMMAND)
1056 set_pipestatus_from_exit (exec_result
);
1061 last_command_exit_value
= exec_result
;
1062 run_pending_traps ();
1064 if (running_trap
== 0)
1066 currently_executing_command
= (COMMAND
*)NULL
;
1068 return (last_command_exit_value
);
1071 #if defined (COMMAND_TIMING)
1073 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1074 extern struct timeval
*difftimeval
__P((struct timeval
*, struct timeval
*, struct timeval
*));
1075 extern struct timeval
*addtimeval
__P((struct timeval
*, struct timeval
*, struct timeval
*));
1076 extern int timeval_to_cpu
__P((struct timeval
*, struct timeval
*, struct timeval
*));
1079 #define POSIX_TIMEFORMAT "real %2R\nuser %2U\nsys %2S"
1080 #define BASH_TIMEFORMAT "\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS"
1082 static const int precs
[] = { 0, 100, 10, 1 };
1084 /* Expand one `%'-prefixed escape sequence from a time format string. */
1086 mkfmt (buf
, prec
, lng
, sec
, sec_fraction
)
1093 char abuf
[INT_STRLEN_BOUND(time_t) + 1];
1097 abuf
[sizeof(abuf
) - 1] = '\0';
1099 /* If LNG is non-zero, we want to decompose SEC into minutes and seconds. */
1104 aind
= sizeof(abuf
) - 2;
1106 abuf
[aind
--] = (min
% 10) + '0';
1110 buf
[ind
++] = abuf
[aind
++];
1114 /* Now add the seconds. */
1115 aind
= sizeof (abuf
) - 2;
1117 abuf
[aind
--] = (sec
% 10) + '0';
1121 buf
[ind
++] = abuf
[aind
++];
1123 /* We want to add a decimal point and PREC places after it if PREC is
1124 nonzero. PREC is not greater than 3. SEC_FRACTION is between 0
1129 for (aind
= 1; aind
<= prec
; aind
++)
1131 buf
[ind
++] = (sec_fraction
/ precs
[aind
]) + '0';
1132 sec_fraction
%= precs
[aind
];
1143 /* Interpret the format string FORMAT, interpolating the following escape
1147 where the optional `prec' is a precision, meaning the number of
1148 characters after the decimal point, the optional `l' means to format
1149 using minutes and seconds (MMmNN[.FF]s), like the `times' builtin',
1150 and the last character is one of
1152 R number of seconds of `real' time
1153 U number of seconds of `user' time
1154 S number of seconds of `system' time
1156 An occurrence of `%%' in the format string is translated to a `%'. The
1157 result is printed to FP, a pointer to a FILE. The other variables are
1158 the seconds and thousandths of a second of real, user, and system time,
1161 print_formatted_time (fp
, format
, rs
, rsf
, us
, usf
, ss
, ssf
, cpu
)
1172 char *str
, *s
, ts
[INT_STRLEN_BOUND (time_t) + sizeof ("mSS.FFFF")];
1177 len
= strlen (format
);
1178 ssize
= (len
+ 64) - (len
% 64);
1179 str
= (char *)xmalloc (ssize
);
1182 for (s
= format
; *s
; s
++)
1184 if (*s
!= '%' || s
[1] == '\0')
1186 RESIZE_MALLOCED_BUFFER (str
, sindex
, 1, ssize
, 64);
1189 else if (s
[1] == '%')
1192 RESIZE_MALLOCED_BUFFER (str
, sindex
, 1, ssize
, 64);
1195 else if (s
[1] == 'P')
1199 /* clamp CPU usage at 100% */
1204 sum_frac
= (cpu
% 100) * 10;
1205 len
= mkfmt (ts
, 2, 0, sum
, sum_frac
);
1206 RESIZE_MALLOCED_BUFFER (str
, sindex
, len
, ssize
, 64);
1207 strcpy (str
+ sindex
, ts
);
1212 prec
= 3; /* default is three places past the decimal point. */
1213 lng
= 0; /* default is to not use minutes or append `s' */
1215 if (DIGIT (*s
)) /* `precision' */
1218 if (prec
> 3) prec
= 3;
1220 if (*s
== 'l') /* `length extender' */
1225 if (*s
== 'R' || *s
== 'E')
1226 len
= mkfmt (ts
, prec
, lng
, rs
, rsf
);
1228 len
= mkfmt (ts
, prec
, lng
, us
, usf
);
1230 len
= mkfmt (ts
, prec
, lng
, ss
, ssf
);
1233 internal_error (_("TIMEFORMAT: `%c': invalid format character"), *s
);
1237 RESIZE_MALLOCED_BUFFER (str
, sindex
, len
, ssize
, 64);
1238 strcpy (str
+ sindex
, ts
);
1244 fprintf (fp
, "%s\n", str
);
1251 time_command (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
1253 int asynchronous
, pipe_in
, pipe_out
;
1254 struct fd_bitmap
*fds_to_close
;
1256 int rv
, posix_time
, old_flags
, nullcmd
;
1262 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1263 struct timeval real
, user
, sys
;
1264 struct timeval before
, after
;
1265 # if defined (HAVE_STRUCT_TIMEZONE)
1266 struct timezone dtz
; /* posix doesn't define this */
1268 struct rusage selfb
, selfa
, kidsb
, kidsa
; /* a = after, b = before */
1270 # if defined (HAVE_TIMES)
1271 clock_t tbefore
, tafter
, real
, user
, sys
;
1272 struct tms before
, after
;
1276 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1277 # if defined (HAVE_STRUCT_TIMEZONE)
1278 gettimeofday (&before
, &dtz
);
1280 gettimeofday (&before
, (void *)NULL
);
1281 # endif /* !HAVE_STRUCT_TIMEZONE */
1282 getrusage (RUSAGE_SELF
, &selfb
);
1283 getrusage (RUSAGE_CHILDREN
, &kidsb
);
1285 # if defined (HAVE_TIMES)
1286 tbefore
= times (&before
);
1290 posix_time
= command
&& (command
->flags
& CMD_TIME_POSIX
);
1292 nullcmd
= (command
== 0) || (command
->type
== cm_simple
&& command
->value
.Simple
->words
== 0 && command
->value
.Simple
->redirects
== 0);
1293 if (posixly_correct
&& nullcmd
)
1295 #if defined (HAVE_GETRUSAGE)
1296 selfb
.ru_utime
.tv_sec
= kidsb
.ru_utime
.tv_sec
= selfb
.ru_stime
.tv_sec
= kidsb
.ru_stime
.tv_sec
= 0;
1297 selfb
.ru_utime
.tv_usec
= kidsb
.ru_utime
.tv_usec
= selfb
.ru_stime
.tv_usec
= kidsb
.ru_stime
.tv_usec
= 0;
1298 before
.tv_sec
= shell_start_time
;
1301 before
.tms_utime
= before
.tms_stime
= before
.tms_cutime
= before
.tms_cstime
= 0;
1302 tbefore
= shell_start_time
;
1306 old_flags
= command
->flags
;
1307 command
->flags
&= ~(CMD_TIME_PIPELINE
|CMD_TIME_POSIX
);
1308 rv
= execute_command_internal (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
1309 command
->flags
= old_flags
;
1312 rsf
= usf
= ssf
= cpu
= 0;
1314 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1315 # if defined (HAVE_STRUCT_TIMEZONE)
1316 gettimeofday (&after
, &dtz
);
1318 gettimeofday (&after
, (void *)NULL
);
1319 # endif /* !HAVE_STRUCT_TIMEZONE */
1320 getrusage (RUSAGE_SELF
, &selfa
);
1321 getrusage (RUSAGE_CHILDREN
, &kidsa
);
1323 difftimeval (&real
, &before
, &after
);
1324 timeval_to_secs (&real
, &rs
, &rsf
);
1326 addtimeval (&user
, difftimeval(&after
, &selfb
.ru_utime
, &selfa
.ru_utime
),
1327 difftimeval(&before
, &kidsb
.ru_utime
, &kidsa
.ru_utime
));
1328 timeval_to_secs (&user
, &us
, &usf
);
1330 addtimeval (&sys
, difftimeval(&after
, &selfb
.ru_stime
, &selfa
.ru_stime
),
1331 difftimeval(&before
, &kidsb
.ru_stime
, &kidsa
.ru_stime
));
1332 timeval_to_secs (&sys
, &ss
, &ssf
);
1334 cpu
= timeval_to_cpu (&real
, &user
, &sys
);
1336 # if defined (HAVE_TIMES)
1337 tafter
= times (&after
);
1339 real
= tafter
- tbefore
;
1340 clock_t_to_secs (real
, &rs
, &rsf
);
1342 user
= (after
.tms_utime
- before
.tms_utime
) + (after
.tms_cutime
- before
.tms_cutime
);
1343 clock_t_to_secs (user
, &us
, &usf
);
1345 sys
= (after
.tms_stime
- before
.tms_stime
) + (after
.tms_cstime
- before
.tms_cstime
);
1346 clock_t_to_secs (sys
, &ss
, &ssf
);
1348 cpu
= (real
== 0) ? 0 : ((user
+ sys
) * 10000) / real
;
1352 rsf
= usf
= ssf
= cpu
= 0;
1357 time_format
= POSIX_TIMEFORMAT
;
1358 else if ((time_format
= get_string_value ("TIMEFORMAT")) == 0)
1360 if (posixly_correct
&& nullcmd
)
1361 time_format
= "user\t%2lU\nsys\t%2lS";
1363 time_format
= BASH_TIMEFORMAT
;
1365 if (time_format
&& *time_format
)
1366 print_formatted_time (stderr
, time_format
, rs
, rsf
, us
, usf
, ss
, ssf
, cpu
);
1370 #endif /* COMMAND_TIMING */
1372 /* Execute a command that's supposed to be in a subshell. This must be
1373 called after make_child and we must be running in the child process.
1374 The caller will return or exit() immediately with the value this returns. */
1376 execute_in_subshell (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
1379 int pipe_in
, pipe_out
;
1380 struct fd_bitmap
*fds_to_close
;
1382 int user_subshell
, return_code
, function_value
, should_redir_stdin
, invert
;
1383 int ois
, user_coproc
;
1385 volatile COMMAND
*tcom
;
1387 USE_VAR(user_subshell
);
1388 USE_VAR(user_coproc
);
1391 USE_VAR(asynchronous
);
1394 should_redir_stdin
= (asynchronous
&& (command
->flags
& CMD_STDIN_REDIR
) &&
1395 pipe_in
== NO_PIPE
&&
1396 stdin_redirects (command
->redirects
) == 0);
1398 invert
= (command
->flags
& CMD_INVERT_RETURN
) != 0;
1399 user_subshell
= command
->type
== cm_subshell
|| ((command
->flags
& CMD_WANT_SUBSHELL
) != 0);
1400 user_coproc
= command
->type
== cm_coproc
;
1402 command
->flags
&= ~(CMD_FORCE_SUBSHELL
| CMD_WANT_SUBSHELL
| CMD_INVERT_RETURN
);
1404 /* If a command is asynchronous in a subshell (like ( foo ) & or
1405 the special case of an asynchronous GROUP command where the
1406 the subshell bit is turned on down in case cm_group: below),
1407 turn off `asynchronous', so that two subshells aren't spawned.
1408 XXX - asynchronous used to be set to 0 in this block, but that
1409 means that setup_async_signals was never run. Now it's set to
1410 0 after subshell_environment is set appropriately and setup_async_signals
1413 This seems semantically correct to me. For example,
1414 ( foo ) & seems to say ``do the command `foo' in a subshell
1415 environment, but don't wait for that subshell to finish'',
1416 and "{ foo ; bar ; } &" seems to me to be like functions or
1417 builtins in the background, which executed in a subshell
1418 environment. I just don't see the need to fork two subshells. */
1420 /* Don't fork again, we are already in a subshell. A `doubly
1421 async' shell is not interactive, however. */
1424 #if defined (JOB_CONTROL)
1425 /* If a construct like ( exec xxx yyy ) & is given while job
1426 control is active, we want to prevent exec from putting the
1427 subshell back into the original process group, carefully
1428 undoing all the work we just did in make_child. */
1430 #endif /* JOB_CONTROL */
1431 ois
= interactive_shell
;
1432 interactive_shell
= 0;
1433 /* This test is to prevent alias expansion by interactive shells that
1434 run `(command) &' but to allow scripts that have enabled alias
1435 expansion with `shopt -s expand_alias' to continue to expand
1437 if (ois
!= interactive_shell
)
1441 /* Subshells are neither login nor interactive. */
1442 login_shell
= interactive
= 0;
1445 subshell_environment
= SUBSHELL_PAREN
;
1448 subshell_environment
= 0; /* XXX */
1450 subshell_environment
|= SUBSHELL_ASYNC
;
1451 if (pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
)
1452 subshell_environment
|= SUBSHELL_PIPE
;
1454 subshell_environment
|= SUBSHELL_COPROC
;
1457 reset_terminating_signals (); /* in sig.c */
1458 /* Cancel traps, in trap.c. */
1459 /* Reset the signal handlers in the child, but don't free the
1460 trap strings. Set a flag noting that we have to free the
1461 trap strings if we run trap to change a signal disposition. */
1462 reset_signal_handlers ();
1463 subshell_environment
|= SUBSHELL_RESETTRAP
;
1465 /* Make sure restore_original_signals doesn't undo the work done by
1466 make_child to ensure that asynchronous children are immune to SIGINT
1467 and SIGQUIT. Turn off asynchronous to make sure more subshells are
1471 setup_async_signals ();
1475 #if defined (JOB_CONTROL)
1476 set_sigchld_handler ();
1477 #endif /* JOB_CONTROL */
1479 set_sigint_handler ();
1481 #if defined (JOB_CONTROL)
1482 /* Delete all traces that there were any jobs running. This is
1483 only for subshells. */
1484 without_job_control ();
1485 #endif /* JOB_CONTROL */
1488 close_fd_bitmap (fds_to_close
);
1490 do_piping (pipe_in
, pipe_out
);
1492 #if defined (COPROCESS_SUPPORT)
1496 /* If this is a user subshell, set a flag if stdin was redirected.
1497 This is used later to decide whether to redirect fd 0 to
1498 /dev/null for async commands in the subshell. This adds more
1499 sh compatibility, but I'm not sure it's the right thing to do. */
1502 stdin_redir
= stdin_redirects (command
->redirects
);
1503 restore_default_signal (EXIT_TRAP
);
1506 /* If this is an asynchronous command (command &), we want to
1507 redirect the standard input from /dev/null in the absence of
1508 any specific redirection involving stdin. */
1509 if (should_redir_stdin
&& stdin_redir
== 0)
1510 async_redirect_stdin ();
1512 /* Do redirections, then dispose of them before recursive call. */
1513 if (command
->redirects
)
1515 if (do_redirections (command
->redirects
, RX_ACTIVE
) != 0)
1516 exit (invert
? EXECUTION_SUCCESS
: EXECUTION_FAILURE
);
1518 dispose_redirects (command
->redirects
);
1519 command
->redirects
= (REDIRECT
*)NULL
;
1522 if (command
->type
== cm_subshell
)
1523 tcom
= command
->value
.Subshell
->command
;
1524 else if (user_coproc
)
1525 tcom
= command
->value
.Coproc
->command
;
1529 if (command
->flags
& CMD_TIME_PIPELINE
)
1530 tcom
->flags
|= CMD_TIME_PIPELINE
;
1531 if (command
->flags
& CMD_TIME_POSIX
)
1532 tcom
->flags
|= CMD_TIME_POSIX
;
1534 /* Make sure the subshell inherits any CMD_IGNORE_RETURN flag. */
1535 if ((command
->flags
& CMD_IGNORE_RETURN
) && tcom
!= command
)
1536 tcom
->flags
|= CMD_IGNORE_RETURN
;
1538 /* If this is a simple command, tell execute_disk_command that it
1539 might be able to get away without forking and simply exec.
1540 This means things like ( sleep 10 ) will only cause one fork.
1541 If we're timing the command or inverting its return value, however,
1542 we cannot do this optimization. */
1543 if ((user_subshell
|| user_coproc
) && (tcom
->type
== cm_simple
|| tcom
->type
== cm_subshell
) &&
1544 ((tcom
->flags
& CMD_TIME_PIPELINE
) == 0) &&
1545 ((tcom
->flags
& CMD_INVERT_RETURN
) == 0))
1547 tcom
->flags
|= CMD_NO_FORK
;
1548 if (tcom
->type
== cm_simple
)
1549 tcom
->value
.Simple
->flags
|= CMD_NO_FORK
;
1552 invert
= (tcom
->flags
& CMD_INVERT_RETURN
) != 0;
1553 tcom
->flags
&= ~CMD_INVERT_RETURN
;
1555 result
= setjmp_nosigs (top_level
);
1557 /* If we're inside a function while executing this subshell, we
1558 need to handle a possible `return'. */
1560 if (return_catch_flag
)
1561 function_value
= setjmp_nosigs (return_catch
);
1563 /* If we're going to exit the shell, we don't want to invert the return
1565 if (result
== EXITPROG
)
1566 invert
= 0, return_code
= last_command_exit_value
;
1568 return_code
= EXECUTION_FAILURE
;
1569 else if (function_value
)
1570 return_code
= return_catch_value
;
1572 return_code
= execute_command_internal ((COMMAND
*)tcom
, asynchronous
, NO_PIPE
, NO_PIPE
, fds_to_close
);
1574 /* If we are asked to, invert the return value. */
1576 return_code
= (return_code
== EXECUTION_SUCCESS
) ? EXECUTION_FAILURE
1577 : EXECUTION_SUCCESS
;
1579 /* If we were explicitly placed in a subshell with (), we need
1580 to do the `shell cleanup' things, such as running traps[0]. */
1581 if (user_subshell
&& signal_is_trapped (0))
1583 last_command_exit_value
= return_code
;
1584 return_code
= run_exit_trap ();
1588 return (return_code
);
1592 #if defined (COPROCESS_SUPPORT)
1593 #define COPROC_MAX 16
1595 typedef struct cpelement
1597 struct cpelement
*next
;
1598 struct coproc
*coproc
;
1602 typedef struct cplist
1604 struct cpelement
*head
;
1605 struct cpelement
*tail
;
1611 static struct cpelement
*cpe_alloc
__P((struct coproc
*));
1612 static void cpe_dispose
__P((struct cpelement
*));
1613 static struct cpelement
*cpl_add
__P((struct coproc
*));
1614 static struct cpelement
*cpl_delete
__P((pid_t
));
1615 static void cpl_reap
__P((void));
1616 static void cpl_flush
__P((void));
1617 static void cpl_closeall
__P((void));
1618 static struct cpelement
*cpl_search
__P((pid_t
));
1619 static struct cpelement
*cpl_searchbyname
__P((const char *));
1620 static void cpl_prune
__P((void));
1622 static void coproc_free
__P((struct coproc
*));
1624 /* Will go away when there is fully-implemented support for multiple coprocs. */
1625 Coproc sh_coproc
= { 0, NO_PID
, -1, -1, 0, 0, 0, 0, 0 };
1627 cplist_t coproc_list
= {0, 0, 0};
1629 /* Functions to manage the list of coprocs */
1631 static struct cpelement
*
1635 struct cpelement
*cpe
;
1637 cpe
= (struct cpelement
*)xmalloc (sizeof (struct cpelement
));
1639 cpe
->next
= (struct cpelement
*)0;
1645 struct cpelement
*cpe
;
1650 static struct cpelement
*
1654 struct cpelement
*cpe
;
1656 cpe
= cpe_alloc (cp
);
1658 if (coproc_list
.head
== 0)
1660 coproc_list
.head
= coproc_list
.tail
= cpe
;
1661 coproc_list
.ncoproc
= 0; /* just to make sure */
1665 coproc_list
.tail
->next
= cpe
;
1666 coproc_list
.tail
= cpe
;
1668 coproc_list
.ncoproc
++;
1673 static struct cpelement
*
1677 struct cpelement
*prev
, *p
;
1679 for (prev
= p
= coproc_list
.head
; p
; prev
= p
, p
= p
->next
)
1680 if (p
->coproc
->c_pid
== pid
)
1682 prev
->next
= p
->next
; /* remove from list */
1687 return 0; /* not found */
1690 itrace("cpl_delete: deleting %d", pid
);
1693 /* Housekeeping in the border cases. */
1694 if (p
== coproc_list
.head
)
1695 coproc_list
.head
= coproc_list
.head
->next
;
1696 else if (p
== coproc_list
.tail
)
1697 coproc_list
.tail
= prev
;
1699 coproc_list
.ncoproc
--;
1700 if (coproc_list
.ncoproc
== 0)
1701 coproc_list
.head
= coproc_list
.tail
= 0;
1702 else if (coproc_list
.ncoproc
== 1)
1703 coproc_list
.tail
= coproc_list
.head
; /* just to make sure */
1711 struct cpelement
*p
, *next
, *nh
, *nt
;
1713 /* Build a new list by removing dead coprocs and fix up the coproc_list
1714 pointers when done. */
1715 nh
= nt
= next
= (struct cpelement
*)0;
1716 for (p
= coproc_list
.head
; p
; p
= next
)
1719 if (p
->coproc
->c_flags
& COPROC_DEAD
)
1721 coproc_list
.ncoproc
--; /* keep running count, fix up pointers later */
1724 itrace("cpl_reap: deleting %d", p
->coproc
->c_pid
);
1727 coproc_dispose (p
->coproc
);
1739 if (coproc_list
.ncoproc
== 0)
1740 coproc_list
.head
= coproc_list
.tail
= 0;
1745 coproc_list
.head
= nh
;
1746 coproc_list
.tail
= nt
;
1747 if (coproc_list
.ncoproc
== 1)
1748 coproc_list
.tail
= coproc_list
.head
; /* just to make sure */
1752 /* Clear out the list of saved statuses */
1756 struct cpelement
*cpe
, *p
;
1758 for (cpe
= coproc_list
.head
; cpe
; )
1763 coproc_dispose (p
->coproc
);
1767 coproc_list
.head
= coproc_list
.tail
= 0;
1768 coproc_list
.ncoproc
= 0;
1774 struct cpelement
*cpe
;
1776 for (cpe
= coproc_list
.head
; cpe
; cpe
= cpe
->next
)
1777 coproc_close (cpe
->coproc
);
1784 struct cpelement
*cpe
;
1786 for (cpe
= coproc_list
.head
; cpe
; cpe
= cpe
->next
)
1787 coproc_checkfd (cpe
->coproc
, fd
);
1790 /* Search for PID in the list of coprocs; return the cpelement struct if
1791 found. If not found, return NULL. */
1792 static struct cpelement
*
1796 struct cpelement
*cpe
;
1798 for (cpe
= coproc_list
.head
; cpe
; cpe
= cpe
->next
)
1799 if (cpe
->coproc
->c_pid
== pid
)
1801 return (struct cpelement
*)NULL
;
1804 /* Search for the coproc named NAME in the list of coprocs; return the
1805 cpelement struct if found. If not found, return NULL. */
1806 static struct cpelement
*
1807 cpl_searchbyname (name
)
1810 struct cpelement
*cp
;
1812 for (cp
= coproc_list
.head
; cp
; cp
= cp
->next
)
1813 if (STREQ (cp
->coproc
->c_name
, name
))
1815 return (struct cpelement
*)NULL
;
1822 struct cpelement
*cp
;
1824 while (coproc_list
.head
&& coproc_list
.ncoproc
> COPROC_MAX
)
1826 cp
= coproc_list
.head
;
1827 coproc_list
.head
= coproc_list
.head
->next
;
1828 coproc_dispose (cp
->coproc
);
1830 coproc_list
.ncoproc
--;
1835 /* These currently use a single global "shell coproc" but are written in a
1836 way to not preclude additional coprocs later (using the list management
1840 getcoprocbypid (pid
)
1843 #if MULTIPLE_COPROCS
1844 struct cpelement
*p
;
1846 p
= cpl_search (pid
);
1847 return (p
? p
->coproc
: 0);
1849 return (pid
== sh_coproc
.c_pid
? &sh_coproc
: 0);
1854 getcoprocbyname (name
)
1857 #if MULTIPLE_COPROCS
1858 struct cpelement
*p
;
1860 p
= cpl_searchbyname (name
);
1861 return (p
? p
->coproc
: 0);
1863 return ((sh_coproc
.c_name
&& STREQ (sh_coproc
.c_name
, name
)) ? &sh_coproc
: 0);
1873 cp
->c_rfd
= cp
->c_wfd
= -1;
1874 cp
->c_rsave
= cp
->c_wsave
= -1;
1875 cp
->c_flags
= cp
->c_status
= cp
->c_lock
= 0;
1879 coproc_alloc (name
, pid
)
1885 #if MULTIPLE_COPROCS
1886 cp
= (struct coproc
*)xmalloc (sizeof (struct coproc
));
1894 cp
->c_name
= savestring (name
);
1895 #if MULTIPLE_COPROCS
1918 BLOCK_SIGNAL (SIGCHLD
, set
, oset
);
1920 coproc_unsetvars (cp
);
1923 #if MULTIPLE_COPROCS
1929 UNBLOCK_SIGNAL (oset
);
1932 /* Placeholder for now. Will require changes for multiple coprocs */
1936 #if MULTIPLE_COPROCS
1939 coproc_dispose (&sh_coproc
);
1957 cp
->c_rsave
= cp
->c_wsave
= -1;
1963 #if MULTIPLE_COPROCS
1966 coproc_close (&sh_coproc
); /* XXX - will require changes for multiple coprocs */
1973 #if MULTIPLE_COPROCS
1978 cp
= &sh_coproc
; /* XXX - will require changes for multiple coprocs */
1979 if (cp
&& (cp
->c_flags
& COPROC_DEAD
))
1980 coproc_dispose (cp
);
1985 coproc_rclose (cp
, fd
)
1989 if (cp
->c_rfd
>= 0 && cp
->c_rfd
== fd
)
1997 coproc_wclose (cp
, fd
)
2001 if (cp
->c_wfd
>= 0 && cp
->c_wfd
== fd
)
2009 coproc_checkfd (cp
, fd
)
2016 if (cp
->c_rfd
>= 0 && cp
->c_rfd
== fd
)
2017 update
= cp
->c_rfd
= -1;
2018 if (cp
->c_wfd
>= 0 && cp
->c_wfd
== fd
)
2019 update
= cp
->c_wfd
= -1;
2021 coproc_setvars (cp
);
2028 #if MULTIPLE_COPROCS
2031 coproc_checkfd (&sh_coproc
, fd
);
2036 coproc_fdclose (cp
, fd
)
2040 coproc_rclose (cp
, fd
);
2041 coproc_wclose (cp
, fd
);
2042 coproc_setvars (cp
);
2049 cp
->c_rsave
= cp
->c_rfd
;
2050 cp
->c_wsave
= cp
->c_wfd
;
2054 coproc_fdrestore (cp
)
2057 cp
->c_rfd
= cp
->c_rsave
;
2058 cp
->c_wfd
= cp
->c_wsave
;
2062 coproc_pidchk (pid
, status
)
2067 #if MULTIPLE_COPROCS
2068 struct cpelement
*cpe
;
2070 cpe
= cpl_delete (pid
);
2071 cp
= cpe
? cpe
->coproc
: 0;
2073 cp
= getcoprocbypid (pid
);
2078 cp
->c_status
= status
;
2079 cp
->c_flags
|= COPROC_DEAD
;
2080 cp
->c_flags
&= ~COPROC_RUNNING
;
2081 /* Don't dispose the coproc or unset the COPROC_XXX variables because
2082 this is executed in a signal handler context. Wait until coproc_reap
2083 takes care of it. */
2095 #if defined (ARRAY_VARS)
2099 if (cp
->c_name
== 0)
2102 l
= strlen (cp
->c_name
);
2103 namevar
= xmalloc (l
+ 16);
2105 #if defined (ARRAY_VARS)
2106 v
= find_variable (cp
->c_name
);
2108 v
= make_new_array_variable (cp
->c_name
);
2109 if (array_p (v
) == 0)
2110 v
= convert_var_to_array (v
);
2112 t
= itos (cp
->c_rfd
);
2114 v
= bind_array_variable (cp
->c_name
, ind
, t
, 0);
2117 t
= itos (cp
->c_wfd
);
2119 bind_array_variable (cp
->c_name
, ind
, t
, 0);
2122 sprintf (namevar
, "%s_READ", cp
->c_name
);
2123 t
= itos (cp
->c_rfd
);
2124 bind_variable (namevar
, t
, 0);
2126 sprintf (namevar
, "%s_WRITE", cp
->c_name
);
2127 t
= itos (cp
->c_wfd
);
2128 bind_variable (namevar
, t
, 0);
2132 sprintf (namevar
, "%s_PID", cp
->c_name
);
2133 t
= itos (cp
->c_pid
);
2134 bind_variable (namevar
, t
, 0);
2141 coproc_unsetvars (cp
)
2147 if (cp
->c_name
== 0)
2150 l
= strlen (cp
->c_name
);
2151 namevar
= xmalloc (l
+ 16);
2153 sprintf (namevar
, "%s_PID", cp
->c_name
);
2154 unbind_variable (namevar
);
2156 #if defined (ARRAY_VARS)
2157 unbind_variable (cp
->c_name
);
2159 sprintf (namevar
, "%s_READ", cp
->c_name
);
2160 unbind_variable (namevar
);
2161 sprintf (namevar
, "%s_WRITE", cp
->c_name
);
2162 unbind_variable (namevar
);
2169 execute_coproc (command
, pipe_in
, pipe_out
, fds_to_close
)
2171 int pipe_in
, pipe_out
;
2172 struct fd_bitmap
*fds_to_close
;
2174 int rpipe
[2], wpipe
[2], estat
, invert
;
2180 /* XXX -- can be removed after changes to handle multiple coprocs */
2181 #if !MULTIPLE_COPROCS
2182 if (sh_coproc
.c_pid
!= NO_PID
)
2183 internal_warning ("execute_coproc: coproc [%d:%s] still exists", sh_coproc
.c_pid
, sh_coproc
.c_name
);
2184 coproc_init (&sh_coproc
);
2187 invert
= (command
->flags
& CMD_INVERT_RETURN
) != 0;
2188 command_string_index
= 0;
2189 tcmd
= make_command_string (command
);
2191 sh_openpipe ((int *)&rpipe
); /* 0 = parent read, 1 = child write */
2192 sh_openpipe ((int *)&wpipe
); /* 0 = child read, 1 = parent write */
2194 BLOCK_SIGNAL (SIGCHLD
, set
, oset
);
2196 coproc_pid
= make_child (savestring (tcmd
), 1);
2198 if (coproc_pid
== 0)
2203 UNBLOCK_SIGNAL (oset
);
2204 estat
= execute_in_subshell (command
, 1, wpipe
[0], rpipe
[1], fds_to_close
);
2215 /* XXX - possibly run Coproc->name through word expansion? */
2216 cp
= coproc_alloc (command
->value
.Coproc
->name
, coproc_pid
);
2217 cp
->c_rfd
= rpipe
[0];
2218 cp
->c_wfd
= wpipe
[1];
2220 SET_CLOSE_ON_EXEC (cp
->c_rfd
);
2221 SET_CLOSE_ON_EXEC (cp
->c_wfd
);
2223 coproc_setvars (cp
);
2225 UNBLOCK_SIGNAL (oset
);
2228 itrace ("execute_coproc: [%d] %s", coproc_pid
, the_printed_command
);
2231 close_pipes (pipe_in
, pipe_out
);
2232 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
2233 unlink_fifo_list ();
2235 stop_pipeline (1, (COMMAND
*)NULL
);
2236 DESCRIBE_PID (coproc_pid
);
2237 run_pending_traps ();
2239 return (invert
? EXECUTION_FAILURE
: EXECUTION_SUCCESS
);
2251 /* Catch-all cleanup function for lastpipe code for unwind-protects */
2253 lastpipe_cleanup (s
)
2256 unfreeze_jobs_list ();
2260 execute_pipeline (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
2262 int asynchronous
, pipe_in
, pipe_out
;
2263 struct fd_bitmap
*fds_to_close
;
2265 int prev
, fildes
[2], new_bitmap_size
, dummyfd
, ignore_return
, exec_result
;
2266 int lstdin
, lastpipe_flag
, lastpipe_jid
;
2268 struct fd_bitmap
*fd_bitmap
;
2271 #if defined (JOB_CONTROL)
2273 BLOCK_CHILD (set
, oset
);
2274 #endif /* JOB_CONTROL */
2276 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
2281 while (cmd
&& cmd
->type
== cm_connection
&&
2282 cmd
->value
.Connection
&& cmd
->value
.Connection
->connector
== '|')
2284 /* Make a pipeline between the two commands. */
2285 if (pipe (fildes
) < 0)
2287 sys_error (_("pipe error"));
2288 #if defined (JOB_CONTROL)
2289 terminate_current_pipeline ();
2290 kill_current_pipeline ();
2291 UNBLOCK_CHILD (oset
);
2292 #endif /* JOB_CONTROL */
2293 last_command_exit_value
= EXECUTION_FAILURE
;
2294 /* The unwind-protects installed below will take care
2295 of closing all of the open file descriptors. */
2296 throw_to_top_level ();
2297 return (EXECUTION_FAILURE
); /* XXX */
2300 /* Here is a problem: with the new file close-on-exec
2301 code, the read end of the pipe (fildes[0]) stays open
2302 in the first process, so that process will never get a
2303 SIGPIPE. There is no way to signal the first process
2304 that it should close fildes[0] after forking, so it
2305 remains open. No SIGPIPE is ever sent because there
2306 is still a file descriptor open for reading connected
2307 to the pipe. We take care of that here. This passes
2308 around a bitmap of file descriptors that must be
2309 closed after making a child process in execute_simple_command. */
2311 /* We need fd_bitmap to be at least as big as fildes[0].
2312 If fildes[0] is less than fds_to_close->size, then
2313 use fds_to_close->size. */
2314 new_bitmap_size
= (fildes
[0] < fds_to_close
->size
)
2315 ? fds_to_close
->size
2318 fd_bitmap
= new_fd_bitmap (new_bitmap_size
);
2320 /* Now copy the old information into the new bitmap. */
2321 xbcopy ((char *)fds_to_close
->bitmap
, (char *)fd_bitmap
->bitmap
, fds_to_close
->size
);
2323 /* And mark the pipe file descriptors to be closed. */
2324 fd_bitmap
->bitmap
[fildes
[0]] = 1;
2326 /* In case there are pipe or out-of-processes errors, we
2327 want all these file descriptors to be closed when
2328 unwind-protects are run, and the storage used for the
2329 bitmaps freed up. */
2330 begin_unwind_frame ("pipe-file-descriptors");
2331 add_unwind_protect (dispose_fd_bitmap
, fd_bitmap
);
2332 add_unwind_protect (close_fd_bitmap
, fd_bitmap
);
2334 add_unwind_protect (close
, prev
);
2335 dummyfd
= fildes
[1];
2336 add_unwind_protect (close
, dummyfd
);
2338 #if defined (JOB_CONTROL)
2339 add_unwind_protect (restore_signal_mask
, &oset
);
2340 #endif /* JOB_CONTROL */
2342 if (ignore_return
&& cmd
->value
.Connection
->first
)
2343 cmd
->value
.Connection
->first
->flags
|= CMD_IGNORE_RETURN
;
2344 execute_command_internal (cmd
->value
.Connection
->first
, asynchronous
,
2345 prev
, fildes
[1], fd_bitmap
);
2353 dispose_fd_bitmap (fd_bitmap
);
2354 discard_unwind_frame ("pipe-file-descriptors");
2356 cmd
= cmd
->value
.Connection
->second
;
2359 lastpid
= last_made_pid
;
2361 /* Now execute the rightmost command in the pipeline. */
2362 if (ignore_return
&& cmd
)
2363 cmd
->flags
|= CMD_IGNORE_RETURN
;
2367 begin_unwind_frame ("lastpipe-exec");
2369 /* If the `lastpipe' option is set with shopt, and job control is not
2370 enabled, execute the last element of non-async pipelines in the
2371 current shell environment. */
2372 if (lastpipe_opt
&& job_control
== 0 && asynchronous
== 0 && pipe_out
== NO_PIPE
&& prev
> 0)
2374 lstdin
= move_to_high_fd (0, 1, -1);
2377 do_piping (prev
, pipe_out
);
2379 add_unwind_protect (restore_stdin
, lstdin
);
2381 freeze_jobs_list ();
2382 lastpipe_jid
= stop_pipeline (0, (COMMAND
*)NULL
); /* XXX */
2383 add_unwind_protect (lastpipe_cleanup
, lastpipe_jid
);
2386 cmd
->flags
|= CMD_LASTPIPE
;
2389 add_unwind_protect (close
, prev
);
2391 exec_result
= execute_command_internal (cmd
, asynchronous
, prev
, pipe_out
, fds_to_close
);
2394 restore_stdin (lstdin
);
2399 #if defined (JOB_CONTROL)
2400 UNBLOCK_CHILD (oset
);
2407 #if defined (JOB_CONTROL)
2408 if (INVALID_JOB (lastpipe_jid
) == 0)
2410 append_process (savestring (the_printed_command_except_trap
), dollar_dollar_pid
, exec_result
, lastpipe_jid
);
2411 lstdin
= wait_for (lastpid
);
2414 lstdin
= wait_for_single_pid (lastpid
); /* checks bgpids list */
2416 lstdin
= wait_for (lastpid
);
2419 #if defined (JOB_CONTROL)
2420 /* If wait_for removes the job from the jobs table, use result of last
2421 command as pipeline's exit status as usual. The jobs list can get
2422 frozen and unfrozen at inconvenient times if there are multiple pipelines
2423 running simultaneously. */
2424 if (INVALID_JOB (lastpipe_jid
) == 0)
2425 exec_result
= job_exit_status (lastpipe_jid
);
2426 else if (pipefail_opt
)
2427 exec_result
= exec_result
| lstdin
; /* XXX */
2428 /* otherwise we use exec_result */
2431 unfreeze_jobs_list ();
2434 discard_unwind_frame ("lastpipe-exec");
2436 return (exec_result
);
2440 execute_connection (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
)
2442 int asynchronous
, pipe_in
, pipe_out
;
2443 struct fd_bitmap
*fds_to_close
;
2445 COMMAND
*tc
, *second
;
2446 int ignore_return
, exec_result
, was_error_trap
, invert
;
2447 volatile int save_line_number
;
2449 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
2451 switch (command
->value
.Connection
->connector
)
2453 /* Do the first command asynchronously. */
2455 tc
= command
->value
.Connection
->first
;
2457 return (EXECUTION_SUCCESS
);
2460 tc
->flags
|= CMD_IGNORE_RETURN
;
2461 tc
->flags
|= CMD_AMPERSAND
;
2463 /* If this shell was compiled without job control support,
2464 if we are currently in a subshell via `( xxx )', or if job
2465 control is not active then the standard input for an
2466 asynchronous command is forced to /dev/null. */
2467 #if defined (JOB_CONTROL)
2468 if ((subshell_environment
|| !job_control
) && !stdin_redir
)
2471 #endif /* JOB_CONTROL */
2472 tc
->flags
|= CMD_STDIN_REDIR
;
2474 exec_result
= execute_command_internal (tc
, 1, pipe_in
, pipe_out
, fds_to_close
);
2477 if (tc
->flags
& CMD_STDIN_REDIR
)
2478 tc
->flags
&= ~CMD_STDIN_REDIR
;
2480 second
= command
->value
.Connection
->second
;
2484 second
->flags
|= CMD_IGNORE_RETURN
;
2486 exec_result
= execute_command_internal (second
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
2491 /* Just call execute command on both sides. */
2495 if (command
->value
.Connection
->first
)
2496 command
->value
.Connection
->first
->flags
|= CMD_IGNORE_RETURN
;
2497 if (command
->value
.Connection
->second
)
2498 command
->value
.Connection
->second
->flags
|= CMD_IGNORE_RETURN
;
2502 execute_command (command
->value
.Connection
->first
);
2504 exec_result
= execute_command_internal (command
->value
.Connection
->second
,
2505 asynchronous
, pipe_in
, pipe_out
,
2511 was_error_trap
= signal_is_trapped (ERROR_TRAP
) && signal_is_ignored (ERROR_TRAP
) == 0;
2512 invert
= (command
->flags
& CMD_INVERT_RETURN
) != 0;
2513 ignore_return
= (command
->flags
& CMD_IGNORE_RETURN
) != 0;
2515 line_number_for_err_trap
= line_number
;
2516 exec_result
= execute_pipeline (command
, asynchronous
, pipe_in
, pipe_out
, fds_to_close
);
2518 if (was_error_trap
&& ignore_return
== 0 && invert
== 0 && exec_result
!= EXECUTION_SUCCESS
)
2520 last_command_exit_value
= exec_result
;
2521 save_line_number
= line_number
;
2522 line_number
= line_number_for_err_trap
;
2524 line_number
= save_line_number
;
2527 if (ignore_return
== 0 && invert
== 0 && exit_immediately_on_error
&& exec_result
!= EXECUTION_SUCCESS
)
2529 last_command_exit_value
= exec_result
;
2530 run_pending_traps ();
2531 jump_to_top_level (ERREXIT
);
2540 /* If we have something like `a && b &' or `a || b &', run the
2541 && or || stuff in a subshell. Force a subshell and just call
2542 execute_command_internal again. Leave asynchronous on
2543 so that we get a report from the parent shell about the
2545 command
->flags
|= CMD_FORCE_SUBSHELL
;
2546 exec_result
= execute_command_internal (command
, 1, pipe_in
, pipe_out
, fds_to_close
);
2550 /* Execute the first command. If the result of that is successful
2551 and the connector is AND_AND, or the result is not successful
2552 and the connector is OR_OR, then execute the second command,
2553 otherwise return. */
2556 if (command
->value
.Connection
->first
)
2557 command
->value
.Connection
->first
->flags
|= CMD_IGNORE_RETURN
;
2559 exec_result
= execute_command (command
->value
.Connection
->first
);
2561 if (((command
->value
.Connection
->connector
== AND_AND
) &&
2562 (exec_result
== EXECUTION_SUCCESS
)) ||
2563 ((command
->value
.Connection
->connector
== OR_OR
) &&
2564 (exec_result
!= EXECUTION_SUCCESS
)))
2566 if (ignore_return
&& command
->value
.Connection
->second
)
2567 command
->value
.Connection
->second
->flags
|= CMD_IGNORE_RETURN
;
2569 exec_result
= execute_command (command
->value
.Connection
->second
);
2575 command_error ("execute_connection", CMDERR_BADCONN
, command
->value
.Connection
->connector
, 0);
2576 jump_to_top_level (DISCARD
);
2577 exec_result
= EXECUTION_FAILURE
;
2586 if (!interactive_shell) \
2587 reap_dead_jobs (); \
2591 /* Execute a FOR command. The syntax is: FOR word_desc IN word_list;
2594 execute_for_command (for_command
)
2595 FOR_COM
*for_command
;
2597 register WORD_LIST
*releaser
, *list
;
2600 int retval
, save_line_number
;
2602 SHELL_VAR
*old_value
= (SHELL_VAR
*)NULL
; /* Remember the old value of x. */
2605 save_line_number
= line_number
;
2606 if (check_identifier (for_command
->name
, 1) == 0)
2608 if (posixly_correct
&& interactive_shell
== 0)
2610 last_command_exit_value
= EX_BADUSAGE
;
2611 jump_to_top_level (ERREXIT
);
2613 return (EXECUTION_FAILURE
);
2617 identifier
= for_command
->name
->word
;
2619 line_number
= for_command
->line
; /* for expansion error messages */
2620 list
= releaser
= expand_words_no_vars (for_command
->map_list
);
2622 begin_unwind_frame ("for");
2623 add_unwind_protect (dispose_words
, releaser
);
2626 if (lexical_scoping
)
2628 old_value
= copy_variable (find_variable (identifier
));
2630 add_unwind_protect (dispose_variable
, old_value
);
2634 if (for_command
->flags
& CMD_IGNORE_RETURN
)
2635 for_command
->action
->flags
|= CMD_IGNORE_RETURN
;
2637 for (retval
= EXECUTION_SUCCESS
; list
; list
= list
->next
)
2641 line_number
= for_command
->line
;
2643 /* Remember what this command looks like, for debugger. */
2644 command_string_index
= 0;
2645 print_for_command_head (for_command
);
2647 if (echo_command_at_execute
)
2648 xtrace_print_for_command_head (for_command
);
2650 /* Save this command unless it's a trap command and we're not running
2652 if (signal_in_progress (DEBUG_TRAP
) == 0 && running_trap
== 0)
2654 FREE (the_printed_command_except_trap
);
2655 the_printed_command_except_trap
= savestring (the_printed_command
);
2658 retval
= run_debug_trap ();
2659 #if defined (DEBUGGER)
2660 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
2661 skip the command. */
2662 if (debugging_mode
&& retval
!= EXECUTION_SUCCESS
)
2666 this_command_name
= (char *)NULL
;
2667 /* XXX - special ksh93 for command index variable handling */
2668 v
= find_variable_last_nameref (identifier
);
2669 if (v
&& nameref_p (v
))
2671 v
= bind_variable_value (v
, list
->word
->word
, 0);
2674 v
= bind_variable (identifier
, list
->word
->word
, 0);
2675 if (readonly_p (v
) || noassign_p (v
))
2677 line_number
= save_line_number
;
2678 if (readonly_p (v
) && interactive_shell
== 0 && posixly_correct
)
2680 last_command_exit_value
= EXECUTION_FAILURE
;
2681 jump_to_top_level (FORCE_EOF
);
2685 dispose_words (releaser
);
2686 discard_unwind_frame ("for");
2688 return (EXECUTION_FAILURE
);
2691 retval
= execute_command (for_command
->action
);
2710 line_number
= save_line_number
;
2713 if (lexical_scoping
)
2716 unbind_variable (identifier
);
2719 SHELL_VAR
*new_value
;
2721 new_value
= bind_variable (identifier
, value_cell(old_value
), 0);
2722 new_value
->attributes
= old_value
->attributes
;
2723 dispose_variable (old_value
);
2728 dispose_words (releaser
);
2729 discard_unwind_frame ("for");
2733 #if defined (ARITH_FOR_COMMAND)
2734 /* Execute an arithmetic for command. The syntax is
2736 for (( init ; step ; test ))
2741 The execution should be exactly equivalent to
2744 while eval \(\( test \)\) ; do
2750 eval_arith_for_expr (l
, okp
)
2758 new = expand_words_no_vars (l
);
2761 if (echo_command_at_execute
)
2762 xtrace_print_arith_cmd (new);
2763 this_command_name
= "(("; /* )) for expression error messages */
2765 command_string_index
= 0;
2766 print_arith_command (new);
2767 if (signal_in_progress (DEBUG_TRAP
) == 0)
2769 FREE (the_printed_command_except_trap
);
2770 the_printed_command_except_trap
= savestring (the_printed_command
);
2773 r
= run_debug_trap ();
2774 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
2775 skip the command. */
2776 #if defined (DEBUGGER)
2777 if (debugging_mode
== 0 || r
== EXECUTION_SUCCESS
)
2778 expresult
= evalexp (new->word
->word
, okp
);
2786 expresult
= evalexp (new->word
->word
, okp
);
2788 dispose_words (new);
2800 execute_arith_for_command (arith_for_command
)
2801 ARITH_FOR_COM
*arith_for_command
;
2804 int expok
, body_status
, arith_lineno
, save_lineno
;
2806 body_status
= EXECUTION_SUCCESS
;
2808 save_lineno
= line_number
;
2810 if (arith_for_command
->flags
& CMD_IGNORE_RETURN
)
2811 arith_for_command
->action
->flags
|= CMD_IGNORE_RETURN
;
2813 this_command_name
= "(("; /* )) for expression error messages */
2815 /* save the starting line number of the command so we can reset
2816 line_number before executing each expression -- for $LINENO
2817 and the DEBUG trap. */
2818 line_number
= arith_lineno
= arith_for_command
->line
;
2819 if (variable_context
&& interactive_shell
)
2820 line_number
-= function_line_number
;
2822 /* Evaluate the initialization expression. */
2823 expresult
= eval_arith_for_expr (arith_for_command
->init
, &expok
);
2826 line_number
= save_lineno
;
2827 return (EXECUTION_FAILURE
);
2832 /* Evaluate the test expression. */
2833 line_number
= arith_lineno
;
2834 expresult
= eval_arith_for_expr (arith_for_command
->test
, &expok
);
2835 line_number
= save_lineno
;
2839 body_status
= EXECUTION_FAILURE
;
2846 /* Execute the body of the arithmetic for command. */
2848 body_status
= execute_command (arith_for_command
->action
);
2851 /* Handle any `break' or `continue' commands executed by the body. */
2865 /* Evaluate the step expression. */
2866 line_number
= arith_lineno
;
2867 expresult
= eval_arith_for_expr (arith_for_command
->step
, &expok
);
2868 line_number
= save_lineno
;
2872 body_status
= EXECUTION_FAILURE
;
2878 line_number
= save_lineno
;
2880 return (body_status
);
2884 #if defined (SELECT_COMMAND)
2885 static int LINES
, COLS
, tabsize
;
2887 #define RP_SPACE ") "
2888 #define RP_SPACE_LEN 2
2890 /* XXX - does not handle numbers > 1000000 at all. */
2891 #define NUMBER_LEN(s) \
2895 : ((s < 10000) ? 4 \
2896 : ((s < 100000) ? 5 \
2903 #if defined (HANDLE_MULTIBYTE)
2909 slen
= mbstowcs (wcstr
, s
, 0);
2912 wcstr
= (wchar_t *)xmalloc (sizeof (wchar_t) * (slen
+ 1));
2913 mbstowcs (wcstr
, s
, slen
+ 1);
2914 wclen
= wcswidth (wcstr
, slen
);
2916 return (wclen
< 0 ? STRLEN(s
) : wclen
);
2918 return (STRLEN (s
));
2923 print_index_and_element (len
, ind
, list
)
2927 register WORD_LIST
*l
;
2932 for (i
= ind
, l
= list
; l
&& --i
; l
= l
->next
)
2934 if (l
== 0) /* don't think this can happen */
2936 fprintf (stderr
, "%*d%s%s", len
, ind
, RP_SPACE
, l
->word
->word
);
2937 return (displen (l
->word
->word
));
2946 if ((to
/ tabsize
) > (from
/ tabsize
))
2948 putc ('\t', stderr
);
2949 from
+= tabsize
- from
% tabsize
;
2960 print_select_list (list
, list_len
, max_elem_len
, indices_len
)
2962 int list_len
, max_elem_len
, indices_len
;
2964 int ind
, row
, elem_len
, pos
, cols
, rows
;
2965 int first_column_indices_len
, other_indices_len
;
2969 putc ('\n', stderr
);
2973 cols
= max_elem_len
? COLS
/ max_elem_len
: 1;
2976 rows
= list_len
? list_len
/ cols
+ (list_len
% cols
!= 0) : 1;
2977 cols
= list_len
? list_len
/ rows
+ (list_len
% rows
!= 0) : 1;
2985 first_column_indices_len
= NUMBER_LEN (rows
);
2986 other_indices_len
= indices_len
;
2988 for (row
= 0; row
< rows
; row
++)
2994 indices_len
= (pos
== 0) ? first_column_indices_len
: other_indices_len
;
2995 elem_len
= print_index_and_element (indices_len
, ind
+ 1, list
);
2996 elem_len
+= indices_len
+ RP_SPACE_LEN
;
2998 if (ind
>= list_len
)
3000 indent (pos
+ elem_len
, pos
+ max_elem_len
);
3001 pos
+= max_elem_len
;
3003 putc ('\n', stderr
);
3007 /* Print the elements of LIST, one per line, preceded by an index from 1 to
3008 LIST_LEN. Then display PROMPT and wait for the user to enter a number.
3009 If the number is between 1 and LIST_LEN, return that selection. If EOF
3010 is read, return a null string. If a blank line is entered, or an invalid
3011 number is entered, the loop is executed again. */
3013 select_query (list
, list_len
, prompt
, print_menu
)
3019 int max_elem_len
, indices_len
, len
;
3022 char *repl_string
, *t
;
3025 t
= get_string_value ("LINES");
3026 LINES
= (t
&& *t
) ? atoi (t
) : 24;
3028 t
= get_string_value ("COLUMNS");
3029 COLS
= (t
&& *t
) ? atoi (t
) : 80;
3032 t
= get_string_value ("TABSIZE");
3033 tabsize
= (t
&& *t
) ? atoi (t
) : 8;
3041 for (l
= list
; l
; l
= l
->next
)
3043 len
= displen (l
->word
->word
);
3044 if (len
> max_elem_len
)
3047 indices_len
= NUMBER_LEN (list_len
);
3048 max_elem_len
+= indices_len
+ RP_SPACE_LEN
+ 2;
3053 print_select_list (list
, list_len
, max_elem_len
, indices_len
);
3054 fprintf (stderr
, "%s", prompt
);
3058 if (read_builtin ((WORD_LIST
*)NULL
) != EXECUTION_SUCCESS
)
3061 return ((char *)NULL
);
3063 repl_string
= get_string_value ("REPLY");
3064 if (*repl_string
== 0)
3069 if (legal_number (repl_string
, &reply
) == 0)
3071 if (reply
< 1 || reply
> list_len
)
3074 for (l
= list
; l
&& --reply
; l
= l
->next
)
3076 return (l
->word
->word
); /* XXX - can't be null? */
3080 /* Execute a SELECT command. The syntax is:
3081 SELECT word IN list DO command_list DONE
3082 Only `break' or `return' in command_list will terminate
3085 execute_select_command (select_command
)
3086 SELECT_COM
*select_command
;
3088 WORD_LIST
*releaser
, *list
;
3090 char *identifier
, *ps3_prompt
, *selection
;
3091 int retval
, list_len
, show_menu
, save_line_number
;
3093 if (check_identifier (select_command
->name
, 1) == 0)
3094 return (EXECUTION_FAILURE
);
3096 save_line_number
= line_number
;
3097 line_number
= select_command
->line
;
3099 command_string_index
= 0;
3100 print_select_command_head (select_command
);
3102 if (echo_command_at_execute
)
3103 xtrace_print_select_command_head (select_command
);
3106 if (signal_in_progress (DEBUG_TRAP
) == 0 && (this_command_name
== 0 || (STREQ (this_command_name
, "trap") == 0)))
3108 if (signal_in_progress (DEBUG_TRAP
) == 0 && running_trap
== 0)
3111 FREE (the_printed_command_except_trap
);
3112 the_printed_command_except_trap
= savestring (the_printed_command
);
3115 retval
= run_debug_trap ();
3116 #if defined (DEBUGGER)
3117 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3118 skip the command. */
3119 if (debugging_mode
&& retval
!= EXECUTION_SUCCESS
)
3120 return (EXECUTION_SUCCESS
);
3124 identifier
= select_command
->name
->word
;
3126 /* command and arithmetic substitution, parameter and variable expansion,
3127 word splitting, pathname expansion, and quote removal. */
3128 list
= releaser
= expand_words_no_vars (select_command
->map_list
);
3129 list_len
= list_length (list
);
3130 if (list
== 0 || list_len
== 0)
3133 dispose_words (list
);
3134 line_number
= save_line_number
;
3135 return (EXECUTION_SUCCESS
);
3138 begin_unwind_frame ("select");
3139 add_unwind_protect (dispose_words
, releaser
);
3141 if (select_command
->flags
& CMD_IGNORE_RETURN
)
3142 select_command
->action
->flags
|= CMD_IGNORE_RETURN
;
3144 retval
= EXECUTION_SUCCESS
;
3149 line_number
= select_command
->line
;
3150 ps3_prompt
= get_string_value ("PS3");
3151 if (ps3_prompt
== 0)
3155 selection
= select_query (list
, list_len
, ps3_prompt
, show_menu
);
3159 /* select_query returns EXECUTION_FAILURE if the read builtin
3160 fails, so we want to return failure in this case. */
3161 retval
= EXECUTION_FAILURE
;
3165 v
= bind_variable (identifier
, selection
, 0);
3166 if (readonly_p (v
) || noassign_p (v
))
3168 if (readonly_p (v
) && interactive_shell
== 0 && posixly_correct
)
3170 last_command_exit_value
= EXECUTION_FAILURE
;
3171 jump_to_top_level (FORCE_EOF
);
3175 dispose_words (releaser
);
3176 discard_unwind_frame ("select");
3178 line_number
= save_line_number
;
3179 return (EXECUTION_FAILURE
);
3183 retval
= execute_command (select_command
->action
);
3201 #if defined (KSH_COMPATIBLE_SELECT)
3203 selection
= get_string_value ("REPLY");
3204 if (selection
&& *selection
== '\0')
3210 line_number
= save_line_number
;
3212 dispose_words (releaser
);
3213 discard_unwind_frame ("select");
3216 #endif /* SELECT_COMMAND */
3218 /* Execute a CASE command. The syntax is: CASE word_desc IN pattern_list ESAC.
3219 The pattern_list is a linked list of pattern clauses; each clause contains
3220 some patterns to compare word_desc against, and an associated command to
3223 execute_case_command (case_command
)
3224 CASE_COM
*case_command
;
3226 register WORD_LIST
*list
;
3227 WORD_LIST
*wlist
, *es
;
3228 PATTERN_LIST
*clauses
;
3229 char *word
, *pattern
;
3230 int retval
, match
, ignore_return
, save_line_number
;
3232 save_line_number
= line_number
;
3233 line_number
= case_command
->line
;
3235 command_string_index
= 0;
3236 print_case_command_head (case_command
);
3238 if (echo_command_at_execute
)
3239 xtrace_print_case_command_head (case_command
);
3242 if (signal_in_progress (DEBUG_TRAP
) == 0 && (this_command_name
== 0 || (STREQ (this_command_name
, "trap") == 0)))
3244 if (signal_in_progress (DEBUG_TRAP
) == 0 && running_trap
== 0)
3247 FREE (the_printed_command_except_trap
);
3248 the_printed_command_except_trap
= savestring (the_printed_command
);
3251 retval
= run_debug_trap();
3252 #if defined (DEBUGGER)
3253 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3254 skip the command. */
3255 if (debugging_mode
&& retval
!= EXECUTION_SUCCESS
)
3257 line_number
= save_line_number
;
3258 return (EXECUTION_SUCCESS
);
3262 wlist
= expand_word_unsplit (case_command
->word
, 0);
3263 word
= wlist
? string_list (wlist
) : savestring ("");
3264 dispose_words (wlist
);
3266 retval
= EXECUTION_SUCCESS
;
3267 ignore_return
= case_command
->flags
& CMD_IGNORE_RETURN
;
3269 begin_unwind_frame ("case");
3270 add_unwind_protect ((Function
*)xfree
, word
);
3272 #define EXIT_CASE() goto exit_case_command
3274 for (clauses
= case_command
->clauses
; clauses
; clauses
= clauses
->next
)
3277 for (list
= clauses
->patterns
; list
; list
= list
->next
)
3279 es
= expand_word_leave_quoted (list
->word
, 0);
3281 if (es
&& es
->word
&& es
->word
->word
&& *(es
->word
->word
))
3282 pattern
= quote_string_for_globbing (es
->word
->word
, QGLOB_CVTNULL
);
3285 pattern
= (char *)xmalloc (1);
3289 /* Since the pattern does not undergo quote removal (as per
3290 Posix.2, section 3.9.4.3), the strmatch () call must be able
3291 to recognize backslashes as escape characters. */
3292 match
= strmatch (pattern
, word
, FNMATCH_EXTFLAG
|FNMATCH_IGNCASE
) != FNM_NOMATCH
;
3301 if (clauses
->action
&& ignore_return
)
3302 clauses
->action
->flags
|= CMD_IGNORE_RETURN
;
3303 retval
= execute_command (clauses
->action
);
3305 while ((clauses
->flags
& CASEPAT_FALLTHROUGH
) && (clauses
= clauses
->next
));
3306 if (clauses
== 0 || (clauses
->flags
& CASEPAT_TESTNEXT
) == 0)
3318 discard_unwind_frame ("case");
3319 line_number
= save_line_number
;
3326 /* The WHILE command. Syntax: WHILE test DO action; DONE.
3327 Repeatedly execute action while executing test produces
3328 EXECUTION_SUCCESS. */
3330 execute_while_command (while_command
)
3331 WHILE_COM
*while_command
;
3333 return (execute_while_or_until (while_command
, CMD_WHILE
));
3336 /* UNTIL is just like WHILE except that the test result is negated. */
3338 execute_until_command (while_command
)
3339 WHILE_COM
*while_command
;
3341 return (execute_while_or_until (while_command
, CMD_UNTIL
));
3344 /* The body for both while and until. The only difference between the
3345 two is that the test value is treated differently. TYPE is
3346 CMD_WHILE or CMD_UNTIL. The return value for both commands should
3347 be EXECUTION_SUCCESS if no commands in the body are executed, and
3348 the status of the last command executed in the body otherwise. */
3350 execute_while_or_until (while_command
, type
)
3351 WHILE_COM
*while_command
;
3354 int return_value
, body_status
;
3356 body_status
= EXECUTION_SUCCESS
;
3359 while_command
->test
->flags
|= CMD_IGNORE_RETURN
;
3360 if (while_command
->flags
& CMD_IGNORE_RETURN
)
3361 while_command
->action
->flags
|= CMD_IGNORE_RETURN
;
3365 return_value
= execute_command (while_command
->test
);
3368 /* Need to handle `break' in the test when we would break out of the
3369 loop. The job control code will set `breaking' to loop_level
3370 when a job in a loop is stopped with SIGTSTP. If the stopped job
3371 is in the loop test, `breaking' will not be reset unless we do
3372 this, and the shell will cease to execute commands. */
3373 if (type
== CMD_WHILE
&& return_value
!= EXECUTION_SUCCESS
)
3379 if (type
== CMD_UNTIL
&& return_value
== EXECUTION_SUCCESS
)
3387 body_status
= execute_command (while_command
->action
);
3405 return (body_status
);
3408 /* IF test THEN command [ELSE command].
3409 IF also allows ELIF in the place of ELSE IF, but
3410 the parser makes *that* stupidity transparent. */
3412 execute_if_command (if_command
)
3415 int return_value
, save_line_number
;
3417 save_line_number
= line_number
;
3418 if_command
->test
->flags
|= CMD_IGNORE_RETURN
;
3419 return_value
= execute_command (if_command
->test
);
3420 line_number
= save_line_number
;
3422 if (return_value
== EXECUTION_SUCCESS
)
3426 if (if_command
->true_case
&& (if_command
->flags
& CMD_IGNORE_RETURN
))
3427 if_command
->true_case
->flags
|= CMD_IGNORE_RETURN
;
3429 return (execute_command (if_command
->true_case
));
3435 if (if_command
->false_case
&& (if_command
->flags
& CMD_IGNORE_RETURN
))
3436 if_command
->false_case
->flags
|= CMD_IGNORE_RETURN
;
3438 return (execute_command (if_command
->false_case
));
3442 #if defined (DPAREN_ARITHMETIC)
3444 execute_arith_command (arith_command
)
3445 ARITH_COM
*arith_command
;
3447 int expok
, save_line_number
, retval
;
3454 save_line_number
= line_number
;
3455 this_command_name
= "(("; /* )) */
3456 line_number
= arith_command
->line
;
3457 /* If we're in a function, update the line number information. */
3458 if (variable_context
&& interactive_shell
)
3459 line_number
-= function_line_number
;
3461 command_string_index
= 0;
3462 print_arith_command (arith_command
->exp
);
3464 if (signal_in_progress (DEBUG_TRAP
) == 0)
3466 FREE (the_printed_command_except_trap
);
3467 the_printed_command_except_trap
= savestring (the_printed_command
);
3470 /* Run the debug trap before each arithmetic command, but do it after we
3471 update the line number information and before we expand the various
3472 words in the expression. */
3473 retval
= run_debug_trap ();
3474 #if defined (DEBUGGER)
3475 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3476 skip the command. */
3477 if (debugging_mode
&& retval
!= EXECUTION_SUCCESS
)
3479 line_number
= save_line_number
;
3480 return (EXECUTION_SUCCESS
);
3484 new = expand_words_no_vars (arith_command
->exp
);
3486 /* If we're tracing, make a new word list with `((' at the front and `))'
3487 at the back and print it. */
3488 if (echo_command_at_execute
)
3489 xtrace_print_arith_cmd (new);
3493 exp
= new->next
? string_list (new) : new->word
->word
;
3494 expresult
= evalexp (exp
, &expok
);
3495 line_number
= save_line_number
;
3496 if (exp
!= new->word
->word
)
3498 dispose_words (new);
3507 return (EXECUTION_FAILURE
);
3509 return (expresult
== 0 ? EXECUTION_FAILURE
: EXECUTION_SUCCESS
);
3511 #endif /* DPAREN_ARITHMETIC */
3513 #if defined (COND_COMMAND)
3515 static char * const nullstr
= "";
3517 /* XXX - can COND ever be NULL when this is called? */
3519 execute_cond_node (cond
)
3522 int result
, invert
, patmatch
, rmatch
, mflags
, ignore
;
3528 invert
= (cond
->flags
& CMD_INVERT_RETURN
);
3529 ignore
= (cond
->flags
& CMD_IGNORE_RETURN
);
3533 cond
->left
->flags
|= CMD_IGNORE_RETURN
;
3535 cond
->right
->flags
|= CMD_IGNORE_RETURN
;
3538 if (cond
->type
== COND_EXPR
)
3539 result
= execute_cond_node (cond
->left
);
3540 else if (cond
->type
== COND_OR
)
3542 result
= execute_cond_node (cond
->left
);
3543 if (result
!= EXECUTION_SUCCESS
)
3544 result
= execute_cond_node (cond
->right
);
3546 else if (cond
->type
== COND_AND
)
3548 result
= execute_cond_node (cond
->left
);
3549 if (result
== EXECUTION_SUCCESS
)
3550 result
= execute_cond_node (cond
->right
);
3552 else if (cond
->type
== COND_UNARY
)
3555 comsub_ignore_return
++;
3556 arg1
= cond_expand_word (cond
->left
->op
, 0);
3558 comsub_ignore_return
--;
3561 if (echo_command_at_execute
)
3562 xtrace_print_cond_term (cond
->type
, invert
, cond
->op
, arg1
, (char *)NULL
);
3563 result
= unary_test (cond
->op
->word
, arg1
) ? EXECUTION_SUCCESS
: EXECUTION_FAILURE
;
3564 if (arg1
!= nullstr
)
3567 else if (cond
->type
== COND_BINARY
)
3570 patmatch
= (((cond
->op
->word
[1] == '=') && (cond
->op
->word
[2] == '\0') &&
3571 (cond
->op
->word
[0] == '!' || cond
->op
->word
[0] == '=')) ||
3572 (cond
->op
->word
[0] == '=' && cond
->op
->word
[1] == '\0'));
3573 #if defined (COND_REGEXP)
3574 rmatch
= (cond
->op
->word
[0] == '=' && cond
->op
->word
[1] == '~' &&
3575 cond
->op
->word
[2] == '\0');
3579 comsub_ignore_return
++;
3580 arg1
= cond_expand_word (cond
->left
->op
, 0);
3582 comsub_ignore_return
--;
3586 comsub_ignore_return
++;
3587 arg2
= cond_expand_word (cond
->right
->op
,
3588 (rmatch
&& shell_compatibility_level
> 31) ? 2 : (patmatch
? 1 : 0));
3590 comsub_ignore_return
--;
3594 if (echo_command_at_execute
)
3595 xtrace_print_cond_term (cond
->type
, invert
, cond
->op
, arg1
, arg2
);
3597 #if defined (COND_REGEXP)
3600 mflags
= SHMAT_PWARN
;
3601 #if defined (ARRAY_VARS)
3602 mflags
|= SHMAT_SUBEXP
;
3606 t1
= strescape(arg1
);
3607 t2
= strescape(arg2
);
3608 itrace("execute_cond_node: sh_regmatch on `%s' and `%s'", t1
, t2
);
3613 result
= sh_regmatch (arg1
, arg2
, mflags
);
3616 #endif /* COND_REGEXP */
3621 result
= binary_test (cond
->op
->word
, arg1
, arg2
, TEST_PATMATCH
|TEST_ARITHEXP
|TEST_LOCALE
)
3623 : EXECUTION_FAILURE
;
3626 if (arg1
!= nullstr
)
3628 if (arg2
!= nullstr
)
3633 command_error ("execute_cond_node", CMDERR_BADTYPE
, cond
->type
, 0);
3634 jump_to_top_level (DISCARD
);
3635 result
= EXECUTION_FAILURE
;
3639 result
= (result
== EXECUTION_SUCCESS
) ? EXECUTION_FAILURE
: EXECUTION_SUCCESS
;
3645 execute_cond_command (cond_command
)
3646 COND_COM
*cond_command
;
3648 int retval
, save_line_number
;
3650 retval
= EXECUTION_SUCCESS
;
3651 save_line_number
= line_number
;
3653 this_command_name
= "[[";
3654 line_number
= cond_command
->line
;
3655 /* If we're in a function, update the line number information. */
3656 if (variable_context
&& interactive_shell
)
3657 line_number
-= function_line_number
;
3658 command_string_index
= 0;
3659 print_cond_command (cond_command
);
3661 if (signal_in_progress (DEBUG_TRAP
) == 0)
3663 FREE (the_printed_command_except_trap
);
3664 the_printed_command_except_trap
= savestring (the_printed_command
);
3667 /* Run the debug trap before each conditional command, but do it after we
3668 update the line number information. */
3669 retval
= run_debug_trap ();
3670 #if defined (DEBUGGER)
3671 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3672 skip the command. */
3673 if (debugging_mode
&& retval
!= EXECUTION_SUCCESS
)
3675 line_number
= save_line_number
;
3676 return (EXECUTION_SUCCESS
);
3681 debug_print_cond_command (cond_command
);
3684 last_command_exit_value
= retval
= execute_cond_node (cond_command
);
3685 line_number
= save_line_number
;
3688 #endif /* COND_COMMAND */
3698 var
= bind_variable ("_", arg
, 0);
3699 VUNSETATTR (var
, att_exported
);
3702 /* Execute a null command. Fork a subshell if the command uses pipes or is
3703 to be run asynchronously. This handles all the side effects that are
3704 supposed to take place. */
3706 execute_null_command (redirects
, pipe_in
, pipe_out
, async
)
3707 REDIRECT
*redirects
;
3708 int pipe_in
, pipe_out
, async
;
3714 for (forcefork
= 0, rd
= redirects
; rd
; rd
= rd
->next
)
3715 forcefork
+= rd
->rflags
& REDIR_VARASSIGN
;
3717 if (forcefork
|| pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
|| async
)
3719 /* We have a null command, but we really want a subshell to take
3720 care of it. Just fork, do piping and redirections, and exit. */
3721 if (make_child ((char *)NULL
, async
) == 0)
3723 /* Cancel traps, in trap.c. */
3724 restore_original_signals (); /* XXX */
3726 do_piping (pipe_in
, pipe_out
);
3728 #if defined (COPROCESS_SUPPORT)
3732 subshell_environment
= 0;
3734 subshell_environment
|= SUBSHELL_ASYNC
;
3735 if (pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
)
3736 subshell_environment
|= SUBSHELL_PIPE
;
3738 if (do_redirections (redirects
, RX_ACTIVE
) == 0)
3739 exit (EXECUTION_SUCCESS
);
3741 exit (EXECUTION_FAILURE
);
3745 close_pipes (pipe_in
, pipe_out
);
3746 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
3747 if (pipe_out
== NO_PIPE
)
3748 unlink_fifo_list ();
3750 return (EXECUTION_SUCCESS
);
3755 /* Even if there aren't any command names, pretend to do the
3756 redirections that are specified. The user expects the side
3757 effects to take place. If the redirections fail, then return
3758 failure. Otherwise, if a command substitution took place while
3759 expanding the command or a redirection, return the value of that
3760 substitution. Otherwise, return EXECUTION_SUCCESS. */
3762 r
= do_redirections (redirects
, RX_ACTIVE
|RX_UNDOABLE
);
3763 cleanup_redirects (redirection_undo_list
);
3764 redirection_undo_list
= (REDIRECT
*)NULL
;
3767 return (EXECUTION_FAILURE
);
3768 else if (last_command_subst_pid
!= NO_PID
)
3769 return (last_command_exit_value
);
3771 return (EXECUTION_SUCCESS
);
3775 /* This is a hack to suppress word splitting for assignment statements
3776 given as arguments to builtins with the ASSIGNMENT_BUILTIN flag set. */
3778 fix_assignment_words (words
)
3781 WORD_LIST
*w
, *wcmd
;
3783 int assoc
, global
, array
, integer
;
3789 assoc
= global
= array
= integer
= 0;
3791 /* Skip over assignment statements preceding a command name */
3793 for (wcmd
= words
; wcmd
; wcmd
= wcmd
->next
)
3794 if ((wcmd
->word
->flags
& W_ASSIGNMENT
) == 0)
3797 for (w
= wcmd
; w
; w
= w
->next
)
3798 if (w
->word
->flags
& W_ASSIGNMENT
)
3802 /* Posix (post-2008) says that `command' doesn't change whether
3803 or not the builtin it shadows is a `declaration command', even
3804 though it removes other special builtin properties. In Posix
3805 mode, we skip over one or more instances of `command' and
3806 deal with the next word as the assignment builtin. */
3807 while (posixly_correct
&& wcmd
&& wcmd
->word
&& wcmd
->word
->word
&& STREQ (wcmd
->word
->word
, "command"))
3809 b
= builtin_address_internal (wcmd
->word
->word
, 0);
3810 if (b
== 0 || (b
->flags
& ASSIGNMENT_BUILTIN
) == 0)
3812 else if (b
&& (b
->flags
& ASSIGNMENT_BUILTIN
))
3813 wcmd
->word
->flags
|= W_ASSNBLTIN
;
3815 w
->word
->flags
|= (W_NOSPLIT
|W_NOGLOB
|W_TILDEEXP
|W_ASSIGNARG
);
3816 #if defined (ARRAY_VARS)
3818 w
->word
->flags
|= W_ASSIGNASSOC
;
3820 w
->word
->flags
|= W_ASSIGNARRAY
;
3823 w
->word
->flags
|= W_ASSNGLOBAL
;
3825 w
->word
->flags
|= W_ASSIGNINT
;
3827 #if defined (ARRAY_VARS)
3828 /* Note that we saw an associative array option to a builtin that takes
3829 assignment statements. This is a bit of a kludge. */
3830 else if (w
->word
->word
[0] == '-' && (strchr (w
->word
->word
+1, 'A') || strchr (w
->word
->word
+1, 'a') || strchr (w
->word
->word
+1, 'g')))
3832 else if (w
->word
->word
[0] == '-' && strchr (w
->word
->word
+1, 'g'))
3837 while (posixly_correct
&& wcmd
&& wcmd
->word
&& wcmd
->word
->word
&& STREQ (wcmd
->word
->word
, "command"))
3839 b
= builtin_address_internal (wcmd
->word
->word
, 0);
3840 if (b
== 0 || (b
->flags
& ASSIGNMENT_BUILTIN
) == 0)
3842 else if (b
&& (b
->flags
& ASSIGNMENT_BUILTIN
))
3843 wcmd
->word
->flags
|= W_ASSNBLTIN
;
3845 if ((wcmd
->word
->flags
& W_ASSNBLTIN
) && strchr (w
->word
->word
+1, 'A'))
3847 else if ((wcmd
->word
->flags
& W_ASSNBLTIN
) && strchr (w
->word
->word
+1, 'a'))
3849 if ((wcmd
->word
->flags
& W_ASSNBLTIN
) && strchr (w
->word
->word
+1, 'g'))
3851 if ((wcmd
->word
->flags
& W_ASSNBLTIN
) && strchr (w
->word
->word
+1, 'i'))
3856 /* Return 1 if the file found by searching $PATH for PATHNAME, defaulting
3857 to PATHNAME, is a directory. Used by the autocd code below. */
3859 is_dirname (pathname
)
3865 temp
= search_for_command (pathname
, 0);
3866 ret
= (temp
? file_isdir (temp
) : file_isdir (pathname
));
3871 /* The meaty part of all the executions. We have to start hacking the
3872 real execution of commands here. Fork a process, set things up,
3873 execute the command. */
3875 execute_simple_command (simple_command
, pipe_in
, pipe_out
, async
, fds_to_close
)
3876 SIMPLE_COM
*simple_command
;
3877 int pipe_in
, pipe_out
, async
;
3878 struct fd_bitmap
*fds_to_close
;
3880 WORD_LIST
*words
, *lastword
;
3881 char *command_line
, *lastarg
, *temp
;
3882 int first_word_quoted
, result
, builtin_is_special
, already_forked
, dofork
;
3883 pid_t old_last_async_pid
;
3884 sh_builtin_func_t
*builtin
;
3886 volatile int old_builtin
, old_command_builtin
;
3888 result
= EXECUTION_SUCCESS
;
3889 special_builtin_failed
= builtin_is_special
= 0;
3890 command_line
= (char *)0;
3894 /* If we're in a function, update the line number information. */
3895 if (variable_context
&& interactive_shell
&& sourcelevel
== 0)
3896 line_number
-= function_line_number
;
3898 /* Remember what this command line looks like at invocation. */
3899 command_string_index
= 0;
3900 print_simple_command (simple_command
);
3903 if (signal_in_progress (DEBUG_TRAP
) == 0 && (this_command_name
== 0 || (STREQ (this_command_name
, "trap") == 0)))
3905 if (signal_in_progress (DEBUG_TRAP
) == 0 && running_trap
== 0)
3908 FREE (the_printed_command_except_trap
);
3909 the_printed_command_except_trap
= the_printed_command
? savestring (the_printed_command
) : (char *)0;
3912 /* Run the debug trap before each simple command, but do it after we
3913 update the line number information. */
3914 result
= run_debug_trap ();
3915 #if defined (DEBUGGER)
3916 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3917 skip the command. */
3918 if (debugging_mode
&& result
!= EXECUTION_SUCCESS
)
3919 return (EXECUTION_SUCCESS
);
3923 simple_command
->words
? (simple_command
->words
->word
->flags
& W_QUOTED
) : 0;
3925 last_command_subst_pid
= NO_PID
;
3926 old_last_async_pid
= last_asynchronous_pid
;
3928 already_forked
= dofork
= 0;
3930 /* If we're in a pipeline or run in the background, set DOFORK so we
3931 make the child early, before word expansion. This keeps assignment
3932 statements from affecting the parent shell's environment when they
3934 dofork
= pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
|| async
;
3936 /* Something like `%2 &' should restart job 2 in the background, not cause
3937 the shell to fork here. */
3938 if (dofork
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
&&
3939 simple_command
->words
&& simple_command
->words
->word
&&
3940 simple_command
->words
->word
->word
&&
3941 (simple_command
->words
->word
->word
[0] == '%'))
3946 /* Do this now, because execute_disk_command will do it anyway in the
3947 vast majority of cases. */
3948 maybe_make_export_env ();
3950 /* Don't let a DEBUG trap overwrite the command string to be saved with
3951 the process/job associated with this child. */
3952 if (make_child (savestring (the_printed_command_except_trap
), async
) == 0)
3955 simple_command
->flags
|= CMD_NO_FORK
;
3957 subshell_environment
= SUBSHELL_FORK
;
3958 if (pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
)
3959 subshell_environment
|= SUBSHELL_PIPE
;
3961 subshell_environment
|= SUBSHELL_ASYNC
;
3963 /* We need to do this before piping to handle some really
3964 pathological cases where one of the pipe file descriptors
3967 close_fd_bitmap (fds_to_close
);
3969 do_piping (pipe_in
, pipe_out
);
3970 pipe_in
= pipe_out
= NO_PIPE
;
3971 #if defined (COPROCESS_SUPPORT)
3975 last_asynchronous_pid
= old_last_async_pid
;
3981 /* Don't let simple commands that aren't the last command in a
3982 pipeline change $? for the rest of the pipeline (or at all). */
3983 if (pipe_out
!= NO_PIPE
)
3984 result
= last_command_exit_value
;
3985 close_pipes (pipe_in
, pipe_out
);
3986 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
3987 /* Close /dev/fd file descriptors in the parent after forking the
3988 last child in a (possibly one-element) pipeline. Defer this
3989 until any running shell function completes. */
3990 if (pipe_out
== NO_PIPE
&& variable_context
== 0) /* XXX */
3991 unlink_fifo_list (); /* XXX */
3993 command_line
= (char *)NULL
; /* don't free this. */
3994 bind_lastarg ((char *)NULL
);
3999 /* If we are re-running this as the result of executing the `command'
4000 builtin, do not expand the command words a second time. */
4001 if ((simple_command
->flags
& CMD_INHIBIT_EXPANSION
) == 0)
4003 current_fds_to_close
= fds_to_close
;
4004 fix_assignment_words (simple_command
->words
);
4005 /* Pass the ignore return flag down to command substitutions */
4006 if (simple_command
->flags
& CMD_IGNORE_RETURN
) /* XXX */
4007 comsub_ignore_return
++;
4008 words
= expand_words (simple_command
->words
);
4009 if (simple_command
->flags
& CMD_IGNORE_RETURN
)
4010 comsub_ignore_return
--;
4011 current_fds_to_close
= (struct fd_bitmap
*)NULL
;
4014 words
= copy_word_list (simple_command
->words
);
4016 /* It is possible for WORDS not to have anything left in it.
4017 Perhaps all the words consisted of `$foo', and there was
4018 no variable `$foo'. */
4021 this_command_name
= 0;
4022 result
= execute_null_command (simple_command
->redirects
,
4024 already_forked
? 0 : async
);
4029 bind_lastarg ((char *)NULL
);
4030 set_pipestatus_from_exit (result
);
4035 lastarg
= (char *)NULL
;
4037 begin_unwind_frame ("simple-command");
4039 if (echo_command_at_execute
)
4040 xtrace_print_word_list (words
, 1);
4042 builtin
= (sh_builtin_func_t
*)NULL
;
4043 func
= (SHELL_VAR
*)NULL
;
4044 if ((simple_command
->flags
& CMD_NO_FUNCTIONS
) == 0)
4046 /* Posix.2 says special builtins are found before functions. We
4047 don't set builtin_is_special anywhere other than here, because
4048 this path is followed only when the `command' builtin is *not*
4049 being used, and we don't want to exit the shell if a special
4050 builtin executed with `command builtin' fails. `command' is not
4051 a special builtin. */
4052 if (posixly_correct
)
4054 builtin
= find_special_builtin (words
->word
->word
);
4056 builtin_is_special
= 1;
4059 func
= find_function (words
->word
->word
);
4062 /* In POSIX mode, assignment errors in the temporary environment cause a
4063 non-interactive shell to exit. */
4064 if (posixly_correct
&& builtin_is_special
&& interactive_shell
== 0 && tempenv_assign_error
)
4066 last_command_exit_value
= EXECUTION_FAILURE
;
4067 jump_to_top_level (ERREXIT
);
4069 tempenv_assign_error
= 0; /* don't care about this any more */
4071 add_unwind_protect (dispose_words
, words
);
4074 /* Bind the last word in this command to "$_" after execution. */
4075 for (lastword
= words
; lastword
->next
; lastword
= lastword
->next
)
4077 lastarg
= lastword
->word
->word
;
4079 #if defined (JOB_CONTROL)
4080 /* Is this command a job control related thing? */
4081 if (words
->word
->word
[0] == '%' && already_forked
== 0)
4083 this_command_name
= async
? "bg" : "fg";
4084 last_shell_builtin
= this_shell_builtin
;
4085 this_shell_builtin
= builtin_address (this_command_name
);
4086 result
= (*this_shell_builtin
) (words
);
4090 /* One other possibililty. The user may want to resume an existing job.
4091 If they do, find out whether this word is a candidate for a running
4093 if (job_control
&& already_forked
== 0 && async
== 0 &&
4094 !first_word_quoted
&&
4096 words
->word
->word
[0] &&
4097 !simple_command
->redirects
&&
4098 pipe_in
== NO_PIPE
&&
4099 pipe_out
== NO_PIPE
&&
4100 (temp
= get_string_value ("auto_resume")))
4102 int job
, jflags
, started_status
;
4104 jflags
= JM_STOPPED
|JM_FIRSTMATCH
;
4105 if (STREQ (temp
, "exact"))
4107 else if (STREQ (temp
, "substring"))
4108 jflags
|= JM_SUBSTRING
;
4110 jflags
|= JM_PREFIX
;
4111 job
= get_job_by_name (words
->word
->word
, jflags
);
4114 run_unwind_frame ("simple-command");
4115 this_command_name
= "fg";
4116 last_shell_builtin
= this_shell_builtin
;
4117 this_shell_builtin
= builtin_address ("fg");
4119 started_status
= start_job (job
, 1);
4120 return ((started_status
< 0) ? EXECUTION_FAILURE
: started_status
);
4123 #endif /* JOB_CONTROL */
4126 /* Remember the name of this command globally. */
4127 this_command_name
= words
->word
->word
;
4131 /* This command could be a shell builtin or a user-defined function.
4132 We have already found special builtins by this time, so we do not
4133 set builtin_is_special. If this is a function or builtin, and we
4134 have pipes, then fork a subshell in here. Otherwise, just execute
4135 the command directly. */
4136 if (func
== 0 && builtin
== 0)
4137 builtin
= find_shell_builtin (this_command_name
);
4139 last_shell_builtin
= this_shell_builtin
;
4140 this_shell_builtin
= builtin
;
4142 if (builtin
|| func
)
4146 old_builtin
= executing_builtin
;
4147 old_command_builtin
= executing_command_builtin
;
4148 unwind_protect_int (executing_builtin
); /* modified in execute_builtin */
4149 unwind_protect_int (executing_command_builtin
); /* ditto */
4153 /* reset_terminating_signals (); */ /* XXX */
4154 /* Reset the signal handlers in the child, but don't free the
4155 trap strings. Set a flag noting that we have to free the
4156 trap strings if we run trap to change a signal disposition. */
4157 reset_signal_handlers ();
4158 subshell_environment
|= SUBSHELL_RESETTRAP
;
4162 if ((simple_command
->flags
& CMD_STDIN_REDIR
) &&
4163 pipe_in
== NO_PIPE
&&
4164 (stdin_redirects (simple_command
->redirects
) == 0))
4165 async_redirect_stdin ();
4166 setup_async_signals ();
4170 execute_subshell_builtin_or_function
4171 (words
, simple_command
->redirects
, builtin
, func
,
4172 pipe_in
, pipe_out
, async
, fds_to_close
,
4173 simple_command
->flags
);
4178 result
= execute_builtin_or_function
4179 (words
, builtin
, func
, simple_command
->redirects
, fds_to_close
,
4180 simple_command
->flags
);
4183 if (result
> EX_SHERRBASE
)
4190 /* These errors cause non-interactive posix mode shells to exit */
4191 if (posixly_correct
&& builtin_is_special
&& interactive_shell
== 0)
4193 last_command_exit_value
= EXECUTION_FAILURE
;
4194 jump_to_top_level (ERREXIT
);
4197 result
= builtin_status (result
);
4198 if (builtin_is_special
)
4199 special_builtin_failed
= 1;
4201 /* In POSIX mode, if there are assignment statements preceding
4202 a special builtin, they persist after the builtin
4204 if (posixly_correct
&& builtin_is_special
&& temporary_env
)
4205 merge_temporary_env ();
4209 if (result
== EX_USAGE
)
4210 result
= EX_BADUSAGE
;
4211 else if (result
> EX_SHERRBASE
)
4212 result
= EXECUTION_FAILURE
;
4215 set_pipestatus_from_exit (result
);
4221 if (autocd
&& interactive
&& words
->word
&& is_dirname (words
->word
->word
))
4223 words
= make_word_list (make_word ("cd"), words
);
4224 xtrace_print_word_list (words
, 0);
4228 if (command_line
== 0)
4229 command_line
= savestring (the_printed_command_except_trap
? the_printed_command_except_trap
: "");
4231 #if defined (PROCESS_SUBSTITUTION)
4232 if ((subshell_environment
& SUBSHELL_COMSUB
) && (simple_command
->flags
& CMD_NO_FORK
) && fifos_pending() > 0)
4233 simple_command
->flags
&= ~CMD_NO_FORK
;
4236 result
= execute_disk_command (words
, simple_command
->redirects
, command_line
,
4237 pipe_in
, pipe_out
, async
, fds_to_close
,
4238 simple_command
->flags
);
4241 bind_lastarg (lastarg
);
4242 FREE (command_line
);
4243 dispose_words (words
);
4246 executing_builtin
= old_builtin
;
4247 executing_command_builtin
= old_command_builtin
;
4249 discard_unwind_frame ("simple-command");
4250 this_command_name
= (char *)NULL
; /* points to freed memory now */
4254 /* Translate the special builtin exit statuses. We don't really need a
4255 function for this; it's a placeholder for future work. */
4257 builtin_status (result
)
4271 r
= EXECUTION_FAILURE
;
4274 r
= EXECUTION_SUCCESS
;
4281 execute_builtin (builtin
, words
, flags
, subshell
)
4282 sh_builtin_func_t
*builtin
;
4284 int flags
, subshell
;
4286 int old_e_flag
, result
, eval_unwind
;
4291 old_e_flag
= exit_immediately_on_error
;
4293 /* The eval builtin calls parse_and_execute, which does not know about
4294 the setting of flags, and always calls the execution functions with
4295 flags that will exit the shell on an error if -e is set. If the
4296 eval builtin is being called, and we're supposed to ignore the exit
4297 value of the command, we turn the -e flag off ourselves and disable
4298 the ERR trap, then restore them when the command completes. This is
4299 also a problem (as below) for the command and source/. builtins. */
4300 if (subshell
== 0 && (flags
& CMD_IGNORE_RETURN
) &&
4301 (builtin
== eval_builtin
|| builtin
== command_builtin
|| builtin
== source_builtin
))
4303 begin_unwind_frame ("eval_builtin");
4304 unwind_protect_int (exit_immediately_on_error
);
4305 unwind_protect_int (builtin_ignoring_errexit
);
4306 error_trap
= TRAP_STRING (ERROR_TRAP
);
4309 error_trap
= savestring (error_trap
);
4310 add_unwind_protect (xfree
, error_trap
);
4311 add_unwind_protect (set_error_trap
, error_trap
);
4312 restore_default_signal (ERROR_TRAP
);
4314 exit_immediately_on_error
= 0;
4315 builtin_ignoring_errexit
= 1;
4321 /* The temporary environment for a builtin is supposed to apply to
4322 all commands executed by that builtin. Currently, this is a
4323 problem only with the `unset', `source' and `eval' builtins.
4324 `mapfile' is a special case because it uses evalstring (same as
4325 eval or source) to run its callbacks. */
4326 isbltinenv
= (builtin
== source_builtin
|| builtin
== eval_builtin
|| builtin
== unset_builtin
|| builtin
== mapfile_builtin
);
4331 begin_unwind_frame ("builtin_env");
4335 push_scope (VC_BLTNENV
, temporary_env
);
4337 add_unwind_protect (pop_scope
, (flags
& CMD_COMMAND_BUILTIN
) ? 0 : "1");
4338 temporary_env
= (HASH_TABLE
*)NULL
;
4342 /* `return' does a longjmp() back to a saved environment in execute_function.
4343 If a variable assignment list preceded the command, and the shell is
4344 running in POSIX mode, we need to merge that into the shell_variables
4345 table, since `return' is a POSIX special builtin. */
4346 if (posixly_correct
&& subshell
== 0 && builtin
== return_builtin
&& temporary_env
)
4348 begin_unwind_frame ("return_temp_env");
4349 add_unwind_protect (merge_temporary_env
, (char *)NULL
);
4352 executing_builtin
++;
4353 executing_command_builtin
|= builtin
== command_builtin
;
4354 result
= ((*builtin
) (words
->next
));
4356 /* This shouldn't happen, but in case `return' comes back instead of
4357 longjmp'ing, we need to unwind. */
4358 if (posixly_correct
&& subshell
== 0 && builtin
== return_builtin
&& temporary_env
)
4359 discard_unwind_frame ("return_temp_env");
4361 if (subshell
== 0 && isbltinenv
)
4362 run_unwind_frame ("builtin_env");
4366 exit_immediately_on_error
= errexit_flag
;
4367 builtin_ignoring_errexit
= 0;
4370 set_error_trap (error_trap
);
4373 discard_unwind_frame ("eval_builtin");
4380 execute_function (var
, words
, flags
, fds_to_close
, async
, subshell
)
4384 struct fd_bitmap
*fds_to_close
;
4385 int async
, subshell
;
4387 int return_val
, result
;
4388 COMMAND
*tc
, *fc
, *save_current
;
4389 char *debug_trap
, *error_trap
, *return_trap
;
4390 #if defined (ARRAY_VARS)
4391 SHELL_VAR
*funcname_v
, *nfv
, *bash_source_v
, *bash_lineno_v
;
4393 volatile ARRAY
*bash_source_a
;
4394 volatile ARRAY
*bash_lineno_a
;
4396 FUNCTION_DEF
*shell_fn
;
4401 if (funcnest_max
> 0 && funcnest
>= funcnest_max
)
4403 internal_error (_("%s: maximum function nesting level exceeded (%d)"), var
->name
, funcnest
);
4404 funcnest
= 0; /* XXX - should we reset it somewhere else? */
4405 jump_to_top_level (DISCARD
);
4408 #if defined (ARRAY_VARS)
4409 GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v
, funcname_a
);
4410 GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v
, bash_source_a
);
4411 GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v
, bash_lineno_a
);
4414 tc
= (COMMAND
*)copy_command (function_cell (var
));
4415 if (tc
&& (flags
& CMD_IGNORE_RETURN
))
4416 tc
->flags
|= CMD_IGNORE_RETURN
;
4420 begin_unwind_frame ("function_calling");
4421 push_context (var
->name
, subshell
, temporary_env
);
4422 add_unwind_protect (pop_context
, (char *)NULL
);
4423 unwind_protect_int (line_number
);
4424 unwind_protect_int (return_catch_flag
);
4425 unwind_protect_jmp_buf (return_catch
);
4426 add_unwind_protect (dispose_command
, (char *)tc
);
4427 unwind_protect_pointer (this_shell_function
);
4428 unwind_protect_int (loop_level
);
4429 unwind_protect_int (funcnest
);
4432 push_context (var
->name
, subshell
, temporary_env
); /* don't unwind-protect for subshells */
4434 temporary_env
= (HASH_TABLE
*)NULL
;
4436 this_shell_function
= var
;
4437 make_funcname_visible (1);
4439 debug_trap
= TRAP_STRING(DEBUG_TRAP
);
4440 error_trap
= TRAP_STRING(ERROR_TRAP
);
4441 return_trap
= TRAP_STRING(RETURN_TRAP
);
4443 /* The order of the unwind protects for debug_trap, error_trap and
4444 return_trap is important here! unwind-protect commands are run
4445 in reverse order of registration. If this causes problems, take
4446 out the xfree unwind-protect calls and live with the small memory leak. */
4448 /* function_trace_mode != 0 means that all functions inherit the DEBUG trap.
4449 if the function has the trace attribute set, it inherits the DEBUG trap */
4450 if (debug_trap
&& ((trace_p (var
) == 0) && function_trace_mode
== 0))
4454 debug_trap
= savestring (debug_trap
);
4455 add_unwind_protect (xfree
, debug_trap
);
4456 add_unwind_protect (set_debug_trap
, debug_trap
);
4458 restore_default_signal (DEBUG_TRAP
);
4461 /* error_trace_mode != 0 means that functions inherit the ERR trap. */
4462 if (error_trap
&& error_trace_mode
== 0)
4466 error_trap
= savestring (error_trap
);
4467 add_unwind_protect (xfree
, error_trap
);
4468 add_unwind_protect (set_error_trap
, error_trap
);
4470 restore_default_signal (ERROR_TRAP
);
4473 /* Shell functions inherit the RETURN trap if function tracing is on
4474 globally or on individually for this function. */
4476 if (return_trap
&& ((trace_p (var
) == 0) && function_trace_mode
== 0))
4478 if (return_trap
&& (signal_in_progress (DEBUG_TRAP
) || ((trace_p (var
) == 0) && function_trace_mode
== 0)))
4483 return_trap
= savestring (return_trap
);
4484 add_unwind_protect (xfree
, return_trap
);
4485 add_unwind_protect (set_return_trap
, return_trap
);
4487 restore_default_signal (RETURN_TRAP
);
4491 #if defined (ARRAY_VARS)
4492 /* This is quite similar to the code in shell.c and elsewhere. */
4493 shell_fn
= find_function_def (this_shell_function
->name
);
4494 sfile
= shell_fn
? shell_fn
->source_file
: "";
4495 array_push ((ARRAY
*)funcname_a
, this_shell_function
->name
);
4497 array_push ((ARRAY
*)bash_source_a
, sfile
);
4498 t
= itos (executing_line_number ());
4499 array_push ((ARRAY
*)bash_lineno_a
, t
);
4503 /* The temporary environment for a function is supposed to apply to
4504 all commands executed within the function body. */
4506 remember_args (words
->next
, 1);
4508 /* Update BASH_ARGV and BASH_ARGC */
4510 push_args (words
->next
);
4512 /* Number of the line on which the function body starts. */
4513 line_number
= function_line_number
= tc
->line
;
4515 #if defined (JOB_CONTROL)
4517 stop_pipeline (async
, (COMMAND
*)NULL
);
4522 return_catch_flag
++;
4523 return_val
= setjmp_nosigs (return_catch
);
4527 result
= return_catch_value
;
4528 /* Run the RETURN trap in the function's context. */
4529 save_current
= currently_executing_command
;
4531 currently_executing_command
= save_current
;
4535 /* Run the debug trap here so we can trap at the start of a function's
4536 execution rather than the execution of the body's first command. */
4537 showing_function_line
= 1;
4538 save_current
= currently_executing_command
;
4539 result
= run_debug_trap ();
4540 #if defined (DEBUGGER)
4541 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
4542 skip the command. */
4543 if (debugging_mode
== 0 || result
== EXECUTION_SUCCESS
)
4545 showing_function_line
= 0;
4546 currently_executing_command
= save_current
;
4547 result
= execute_command_internal (fc
, 0, NO_PIPE
, NO_PIPE
, fds_to_close
);
4549 /* Run the RETURN trap in the function's context */
4550 save_current
= currently_executing_command
;
4552 currently_executing_command
= save_current
;
4555 result
= execute_command_internal (fc
, 0, NO_PIPE
, NO_PIPE
, fds_to_close
);
4557 save_current
= currently_executing_command
;
4559 currently_executing_command
= save_current
;
4561 showing_function_line
= 0;
4564 /* Restore BASH_ARGC and BASH_ARGV */
4569 run_unwind_frame ("function_calling");
4571 #if defined (ARRAY_VARS)
4572 /* These two variables cannot be unset, and cannot be affected by the
4574 array_pop ((ARRAY
*)bash_source_a
);
4575 array_pop ((ARRAY
*)bash_lineno_a
);
4577 /* FUNCNAME can be unset, and so can potentially be changed by the
4579 GET_ARRAY_FROM_VAR ("FUNCNAME", nfv
, funcname_a
);
4580 if (nfv
== funcname_v
)
4581 array_pop (funcname_a
);
4584 if (variable_context
== 0 || this_shell_function
== 0)
4586 make_funcname_visible (0);
4587 #if defined (PROCESS_SUBSTITUTION)
4588 unlink_fifo_list ();
4595 /* A convenience routine for use by other parts of the shell to execute
4596 a particular shell function. */
4598 execute_shell_function (var
, words
)
4603 struct fd_bitmap
*bitmap
;
4605 bitmap
= new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE
);
4606 begin_unwind_frame ("execute-shell-function");
4607 add_unwind_protect (dispose_fd_bitmap
, (char *)bitmap
);
4609 ret
= execute_function (var
, words
, 0, bitmap
, 0, 0);
4611 dispose_fd_bitmap (bitmap
);
4612 discard_unwind_frame ("execute-shell-function");
4617 /* Execute a shell builtin or function in a subshell environment. This
4618 routine does not return; it only calls exit(). If BUILTIN is non-null,
4619 it points to a function to call to execute a shell builtin; otherwise
4620 VAR points at the body of a function to execute. WORDS is the arguments
4621 to the command, REDIRECTS specifies redirections to perform before the
4622 command is executed. */
4624 execute_subshell_builtin_or_function (words
, redirects
, builtin
, var
,
4625 pipe_in
, pipe_out
, async
, fds_to_close
,
4628 REDIRECT
*redirects
;
4629 sh_builtin_func_t
*builtin
;
4631 int pipe_in
, pipe_out
, async
;
4632 struct fd_bitmap
*fds_to_close
;
4635 int result
, r
, funcvalue
;
4636 #if defined (JOB_CONTROL)
4639 jobs_hack
= (builtin
== jobs_builtin
) &&
4640 ((subshell_environment
& SUBSHELL_ASYNC
) == 0 || pipe_out
!= NO_PIPE
);
4643 /* A subshell is neither a login shell nor interactive. */
4644 login_shell
= interactive
= 0;
4647 subshell_environment
|= SUBSHELL_ASYNC
;
4648 if (pipe_in
!= NO_PIPE
|| pipe_out
!= NO_PIPE
)
4649 subshell_environment
|= SUBSHELL_PIPE
;
4651 maybe_make_export_env (); /* XXX - is this needed? */
4653 #if defined (JOB_CONTROL)
4654 /* Eradicate all traces of job control after we fork the subshell, so
4655 all jobs begun by this subshell are in the same process group as
4656 the shell itself. */
4658 /* Allow the output of `jobs' to be piped. */
4660 kill_current_pipeline ();
4662 without_job_control ();
4664 set_sigchld_handler ();
4665 #endif /* JOB_CONTROL */
4667 set_sigint_handler ();
4670 close_fd_bitmap (fds_to_close
);
4672 do_piping (pipe_in
, pipe_out
);
4674 if (do_redirections (redirects
, RX_ACTIVE
) != 0)
4675 exit (EXECUTION_FAILURE
);
4679 /* Give builtins a place to jump back to on failure,
4680 so we don't go back up to main(). */
4681 result
= setjmp_nosigs (top_level
);
4683 /* Give the return builtin a place to jump to when executed in a subshell
4686 if (return_catch_flag
&& builtin
== return_builtin
)
4687 funcvalue
= setjmp_nosigs (return_catch
);
4689 if (result
== EXITPROG
)
4690 exit (last_command_exit_value
);
4692 exit (EXECUTION_FAILURE
);
4694 exit (return_catch_value
);
4697 r
= execute_builtin (builtin
, words
, flags
, 1);
4706 r
= execute_function (var
, words
, flags
, fds_to_close
, async
, 1);
4712 /* Execute a builtin or function in the current shell context. If BUILTIN
4713 is non-null, it is the builtin command to execute, otherwise VAR points
4714 to the body of a function. WORDS are the command's arguments, REDIRECTS
4715 are the redirections to perform. FDS_TO_CLOSE is the usual bitmap of
4716 file descriptors to close.
4718 If BUILTIN is exec_builtin, the redirections specified in REDIRECTS are
4719 not undone before this function returns. */
4721 execute_builtin_or_function (words
, builtin
, var
, redirects
,
4722 fds_to_close
, flags
)
4724 sh_builtin_func_t
*builtin
;
4726 REDIRECT
*redirects
;
4727 struct fd_bitmap
*fds_to_close
;
4731 REDIRECT
*saved_undo_list
;
4732 #if defined (PROCESS_SUBSTITUTION)
4733 int ofifo
, nfifo
, osize
;
4738 #if defined (PROCESS_SUBSTITUTION)
4739 ofifo
= num_fifos ();
4740 ofifo_list
= copy_fifo_list (&osize
);
4743 if (do_redirections (redirects
, RX_ACTIVE
|RX_UNDOABLE
) != 0)
4745 cleanup_redirects (redirection_undo_list
);
4746 redirection_undo_list
= (REDIRECT
*)NULL
;
4747 dispose_exec_redirects ();
4748 #if defined (PROCESS_SUBSTITUTION)
4751 return (EX_REDIRFAIL
); /* was EXECUTION_FAILURE */
4754 saved_undo_list
= redirection_undo_list
;
4756 /* Calling the "exec" builtin changes redirections forever. */
4757 if (builtin
== exec_builtin
)
4759 dispose_redirects (saved_undo_list
);
4760 saved_undo_list
= exec_redirection_undo_list
;
4761 exec_redirection_undo_list
= (REDIRECT
*)NULL
;
4764 dispose_exec_redirects ();
4766 if (saved_undo_list
)
4768 begin_unwind_frame ("saved redirects");
4769 add_unwind_protect (cleanup_redirects
, (char *)saved_undo_list
);
4772 redirection_undo_list
= (REDIRECT
*)NULL
;
4775 result
= execute_builtin (builtin
, words
, flags
, 0);
4777 result
= execute_function (var
, words
, flags
, fds_to_close
, 0, 0);
4779 /* We do this before undoing the effects of any redirections. */
4782 if (ferror (stdout
))
4785 /* If we are executing the `command' builtin, but this_shell_builtin is
4786 set to `exec_builtin', we know that we have something like
4787 `command exec [redirection]', since otherwise `exec' would have
4788 overwritten the shell and we wouldn't get here. In this case, we
4789 want to behave as if the `command' builtin had not been specified
4790 and preserve the redirections. */
4791 if (builtin
== command_builtin
&& this_shell_builtin
== exec_builtin
)
4796 if (saved_undo_list
)
4798 dispose_redirects (saved_undo_list
);
4801 redirection_undo_list
= exec_redirection_undo_list
;
4802 saved_undo_list
= exec_redirection_undo_list
= (REDIRECT
*)NULL
;
4804 discard_unwind_frame ("saved redirects");
4807 if (saved_undo_list
)
4809 redirection_undo_list
= saved_undo_list
;
4810 discard_unwind_frame ("saved redirects");
4813 if (redirection_undo_list
)
4815 cleanup_redirects (redirection_undo_list
);
4816 redirection_undo_list
= (REDIRECT
*)NULL
;
4819 #if defined (PROCESS_SUBSTITUTION)
4820 /* Close any FIFOs created by this builtin or function. */
4821 nfifo
= num_fifos ();
4823 close_new_fifos (ofifo_list
, osize
);
4831 setup_async_signals ()
4833 #if defined (__BEOS__)
4834 set_signal_handler (SIGHUP
, SIG_IGN
); /* they want csh-like behavior */
4837 #if defined (JOB_CONTROL)
4838 if (job_control
== 0)
4841 /* Make sure we get the original signal dispositions now so we don't
4842 confuse the trap builtin later if the subshell tries to use it to
4843 reset SIGINT/SIGQUIT. Don't call set_signal_ignored; that sets
4844 the value of original_signals to SIG_IGN. Posix interpretation 751. */
4845 get_original_signal (SIGINT
);
4846 set_signal_handler (SIGINT
, SIG_IGN
);
4848 get_original_signal (SIGQUIT
);
4849 set_signal_handler (SIGQUIT
, SIG_IGN
);
4853 /* Execute a simple command that is hopefully defined in a disk file
4858 3) look up the command
4861 6) If the execve failed, see if the file has executable mode set.
4862 If so, and it isn't a directory, then execute its contents as
4865 Note that the filename hashing stuff has to take place up here,
4866 in the parent. This is probably why the Bourne style shells
4867 don't handle it, since that would require them to go through
4868 this gnarly hair, for no good reason.
4870 NOTE: callers expect this to fork or exit(). */
4872 /* Name of a shell function to call when a command name is not found. */
4873 #ifndef NOTFOUND_HOOK
4874 # define NOTFOUND_HOOK "command_not_found_handle"
4878 execute_disk_command (words
, redirects
, command_line
, pipe_in
, pipe_out
,
4879 async
, fds_to_close
, cmdflags
)
4881 REDIRECT
*redirects
;
4883 int pipe_in
, pipe_out
, async
;
4884 struct fd_bitmap
*fds_to_close
;
4887 char *pathname
, *command
, **args
;
4893 nofork
= (cmdflags
& CMD_NO_FORK
); /* Don't fork, just exec, if no pipes */
4894 pathname
= words
->word
->word
;
4896 result
= EXECUTION_SUCCESS
;
4897 #if defined (RESTRICTED_SHELL)
4898 command
= (char *)NULL
;
4899 if (restricted
&& mbschr (pathname
, '/'))
4901 internal_error (_("%s: restricted: cannot specify `/' in command names"),
4903 result
= last_command_exit_value
= EXECUTION_FAILURE
;
4905 /* If we're not going to fork below, we must already be in a child
4906 process or a context in which it's safe to call exit(2). */
4907 if (nofork
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
)
4908 exit (last_command_exit_value
);
4912 #endif /* RESTRICTED_SHELL */
4914 command
= search_for_command (pathname
, 1);
4918 maybe_make_export_env ();
4919 put_command_name_into_env (command
);
4922 /* We have to make the child before we check for the non-existence
4923 of COMMAND, since we want the error messages to be redirected. */
4924 /* If we can get away without forking and there are no pipes to deal with,
4925 don't bother to fork, just directly exec the command. */
4926 if (nofork
&& pipe_in
== NO_PIPE
&& pipe_out
== NO_PIPE
)
4929 pid
= make_child (savestring (command_line
), async
);
4933 int old_interactive
;
4935 reset_terminating_signals (); /* XXX */
4936 /* Cancel traps, in trap.c. */
4937 restore_original_signals ();
4941 /* restore_original_signals may have undone the work done
4942 by make_child to ensure that SIGINT and SIGQUIT are ignored
4943 in asynchronous children. */
4946 if ((cmdflags
& CMD_STDIN_REDIR
) &&
4947 pipe_in
== NO_PIPE
&&
4948 (stdin_redirects (redirects
) == 0))
4949 async_redirect_stdin ();
4950 setup_async_signals ();
4953 /* This functionality is now provided by close-on-exec of the
4954 file descriptors manipulated by redirection and piping.
4955 Some file descriptors still need to be closed in all children
4956 because of the way bash does pipes; fds_to_close is a
4957 bitmap of all such file descriptors. */
4959 close_fd_bitmap (fds_to_close
);
4961 do_piping (pipe_in
, pipe_out
);
4963 old_interactive
= interactive
;
4967 subshell_environment
= SUBSHELL_FORK
;
4969 if (redirects
&& (do_redirections (redirects
, RX_ACTIVE
) != 0))
4971 #if defined (PROCESS_SUBSTITUTION)
4972 /* Try to remove named pipes that may have been created as the
4973 result of redirections. */
4974 unlink_fifo_list ();
4975 #endif /* PROCESS_SUBSTITUTION */
4976 exit (EXECUTION_FAILURE
);
4980 interactive
= old_interactive
;
4984 hookf
= find_function (NOTFOUND_HOOK
);
4987 /* Make sure filenames are displayed using printable characters */
4988 if (ansic_shouldquote (pathname
))
4989 pathname
= ansic_quote (pathname
, 0, NULL
);
4990 internal_error (_("%s: command not found"), pathname
);
4991 exit (EX_NOTFOUND
); /* Posix.2 says the exit status is 127 */
4994 #if defined (JOB_CONTROL)
4995 /* May need to reinitialize more of the job control state here. */
4996 kill_current_pipeline ();
4999 wl
= make_word_list (make_word (NOTFOUND_HOOK
), words
);
5000 exit (execute_shell_function (hookf
, wl
));
5005 /* Execve expects the command name to be in args[0]. So we
5006 leave it there, in the same format that the user used to
5008 args
= strvec_from_word_list (words
, 0, 0, (int *)NULL
);
5009 exit (shell_execve (command
, args
, export_env
));
5016 /* Make sure that the pipes are closed in the parent. */
5017 close_pipes (pipe_in
, pipe_out
);
5018 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
5019 if (variable_context
== 0)
5020 unlink_fifo_list ();
5027 /* CPP defines to decide whether a particular index into the #! line
5028 corresponds to a valid interpreter name or argument character, or
5029 whitespace. The MSDOS define is to allow \r to be treated the same
5032 #if !defined (MSDOS)
5033 # define STRINGCHAR(ind) \
5034 (ind < sample_len && !whitespace (sample[ind]) && sample[ind] != '\n')
5035 # define WHITECHAR(ind) \
5036 (ind < sample_len && whitespace (sample[ind]))
5038 # define STRINGCHAR(ind) \
5039 (ind < sample_len && !whitespace (sample[ind]) && sample[ind] != '\n' && sample[ind] != '\r')
5040 # define WHITECHAR(ind) \
5041 (ind < sample_len && whitespace (sample[ind]))
5045 getinterp (sample
, sample_len
, endp
)
5047 int sample_len
, *endp
;
5053 /* Find the name of the interpreter to exec. */
5054 for (i
= 2; i
< sample_len
&& whitespace (sample
[i
]); i
++)
5057 for (start
= i
; STRINGCHAR(i
); i
++)
5060 execname
= substring (sample
, start
, i
);
5067 #if !defined (HAVE_HASH_BANG_EXEC)
5068 /* If the operating system on which we're running does not handle
5069 the #! executable format, then help out. SAMPLE is the text read
5070 from the file, SAMPLE_LEN characters. COMMAND is the name of
5071 the script; it and ARGS, the arguments given by the user, will
5072 become arguments to the specified interpreter. ENV is the environment
5073 to pass to the interpreter.
5075 The word immediately following the #! is the interpreter to execute.
5076 A single argument to the interpreter is allowed. */
5079 execute_shell_script (sample
, sample_len
, command
, args
, env
)
5085 char *execname
, *firstarg
;
5086 int i
, start
, size_increment
, larry
;
5088 /* Find the name of the interpreter to exec. */
5089 execname
= getinterp (sample
, sample_len
, &i
);
5092 /* Now the argument, if any. */
5093 for (firstarg
= (char *)NULL
, start
= i
; WHITECHAR(i
); i
++)
5096 /* If there is more text on the line, then it is an argument for the
5101 for (start
= i
; STRINGCHAR(i
); i
++)
5103 firstarg
= substring ((char *)sample
, start
, i
);
5107 larry
= strvec_len (args
) + size_increment
;
5108 args
= strvec_resize (args
, larry
+ 1);
5110 for (i
= larry
- 1; i
; i
--)
5111 args
[i
] = args
[i
- size_increment
];
5122 args
[larry
] = (char *)NULL
;
5124 return (shell_execve (execname
, args
, env
));
5129 #endif /* !HAVE_HASH_BANG_EXEC */
5132 initialize_subshell ()
5135 /* Forget about any aliases that we knew of. We are in a subshell. */
5136 delete_all_aliases ();
5139 #if defined (HISTORY)
5140 /* Forget about the history lines we have read. This is a non-interactive
5142 history_lines_this_session
= 0;
5145 #if defined (JOB_CONTROL)
5146 /* Forget about the way job control was working. We are in a subshell. */
5147 without_job_control ();
5148 set_sigchld_handler ();
5150 #endif /* JOB_CONTROL */
5152 /* Reset the values of the shell flags and options. */
5153 reset_shell_flags ();
5154 reset_shell_options ();
5155 reset_shopt_options ();
5157 /* Zero out builtin_env, since this could be a shell script run from a
5158 sourced file with a temporary environment supplied to the `source/.'
5159 builtin. Such variables are not supposed to be exported (empirical
5160 testing with sh and ksh). Just throw it away; don't worry about a
5162 if (vc_isbltnenv (shell_variables
))
5163 shell_variables
= shell_variables
->down
;
5165 clear_unwind_protect_list (0);
5166 /* XXX -- are there other things we should be resetting here? */
5167 parse_and_execute_level
= 0; /* nothing left to restore it */
5169 /* We're no longer inside a shell function. */
5170 variable_context
= return_catch_flag
= funcnest
= 0;
5172 executing_list
= 0; /* XXX */
5174 /* If we're not interactive, close the file descriptor from which we're
5175 reading the current shell script. */
5176 if (interactive_shell
== 0)
5177 unset_bash_input (0);
5180 #if defined (HAVE_SETOSTYPE) && defined (_POSIX_SOURCE)
5181 # define SETOSTYPE(x) __setostype(x)
5183 # define SETOSTYPE(x)
5186 #define READ_SAMPLE_BUF(file, buf, len) \
5189 fd = open(file, O_RDONLY); \
5192 len = read (fd, buf, 80); \
5200 /* Call execve (), handling interpreting shell scripts, and handling
5203 shell_execve (command
, args
, env
)
5211 SETOSTYPE (0); /* Some systems use for USG/POSIX semantics */
5212 execve (command
, args
, env
);
5213 i
= errno
; /* error from execve() */
5217 /* If we get to this point, then start checking out the file.
5218 Maybe it is something we can hack ourselves. */
5221 if (file_isdir (command
))
5222 #if defined (EISDIR)
5223 internal_error (_("%s: %s"), command
, strerror (EISDIR
));
5225 internal_error (_("%s: is a directory"), command
);
5227 else if (executable_file (command
) == 0)
5230 file_error (command
);
5232 /* errors not involving the path argument to execve. */
5233 else if (i
== E2BIG
|| i
== ENOMEM
)
5236 file_error (command
);
5240 /* The file has the execute bits set, but the kernel refuses to
5241 run it for some reason. See why. */
5242 #if defined (HAVE_HASH_BANG_EXEC)
5243 READ_SAMPLE_BUF (command
, sample
, sample_len
);
5244 sample
[sample_len
- 1] = '\0';
5245 if (sample_len
> 2 && sample
[0] == '#' && sample
[1] == '!')
5250 interp
= getinterp (sample
, sample_len
, (int *)NULL
);
5251 ilen
= strlen (interp
);
5253 if (interp
[ilen
- 1] == '\r')
5255 interp
= xrealloc (interp
, ilen
+ 2);
5256 interp
[ilen
- 1] = '^';
5258 interp
[ilen
+ 1] = '\0';
5260 sys_error (_("%s: %s: bad interpreter"), command
, interp
? interp
: "");
5266 file_error (command
);
5268 return ((i
== ENOENT
) ? EX_NOTFOUND
: EX_NOEXEC
); /* XXX Posix.2 says that exit status is 126 */
5271 /* This file is executable.
5272 If it begins with #!, then help out people with losing operating
5273 systems. Otherwise, check to see if it is a binary file by seeing
5274 if the contents of the first line (or up to 80 characters) are in the
5275 ASCII set. If it's a text file, execute the contents as shell commands,
5276 otherwise return 126 (EX_BINARY_FILE). */
5277 READ_SAMPLE_BUF (command
, sample
, sample_len
);
5279 if (sample_len
== 0)
5280 return (EXECUTION_SUCCESS
);
5282 /* Is this supposed to be an executable script?
5283 If so, the format of the line is "#! interpreter [argument]".
5284 A single argument is allowed. The BSD kernel restricts
5285 the length of the entire line to 32 characters (32 bytes
5286 being the size of the BSD exec header), but we allow 80
5290 #if !defined (HAVE_HASH_BANG_EXEC)
5291 if (sample_len
> 2 && sample
[0] == '#' && sample
[1] == '!')
5292 return (execute_shell_script (sample
, sample_len
, command
, args
, env
));
5295 if (check_binary_file (sample
, sample_len
))
5297 internal_error (_("%s: cannot execute binary file: %s"), command
, strerror (i
));
5298 return (EX_BINARY_FILE
);
5302 /* We have committed to attempting to execute the contents of this file
5303 as shell commands. */
5305 initialize_subshell ();
5307 set_sigint_handler ();
5309 /* Insert the name of this shell into the argument list. */
5310 larray
= strvec_len (args
) + 1;
5311 args
= strvec_resize (args
, larray
+ 1);
5313 for (i
= larray
- 1; i
; i
--)
5314 args
[i
] = args
[i
- 1];
5316 args
[0] = shell_name
;
5318 args
[larray
] = (char *)NULL
;
5320 if (args
[0][0] == '-')
5323 #if defined (RESTRICTED_SHELL)
5325 change_flag ('r', FLAG_OFF
);
5330 /* Can't free subshell_argv[0]; that is shell_name. */
5331 for (i
= 1; i
< subshell_argc
; i
++)
5332 free (subshell_argv
[i
]);
5333 free (subshell_argv
);
5336 dispose_command (currently_executing_command
); /* XXX */
5337 currently_executing_command
= (COMMAND
*)NULL
;
5339 subshell_argc
= larray
;
5340 subshell_argv
= args
;
5341 subshell_envp
= env
;
5343 unbind_args (); /* remove the positional parameters */
5345 longjmp (subshell_top_level
, 1);
5350 execute_intern_function (name
, funcdef
)
5352 FUNCTION_DEF
*funcdef
;
5356 if (check_identifier (name
, posixly_correct
) == 0)
5358 if (posixly_correct
&& interactive_shell
== 0)
5360 last_command_exit_value
= EX_BADUSAGE
;
5361 jump_to_top_level (ERREXIT
);
5363 return (EXECUTION_FAILURE
);
5366 /* Posix interpretation 383 */
5367 if (posixly_correct
&& find_special_builtin (name
->word
))
5369 internal_error (_("`%s': is a special builtin"), name
->word
);
5370 last_command_exit_value
= EX_BADUSAGE
;
5371 jump_to_top_level (ERREXIT
);
5374 var
= find_function (name
->word
);
5375 if (var
&& (readonly_p (var
) || noassign_p (var
)))
5377 if (readonly_p (var
))
5378 internal_error (_("%s: readonly function"), var
->name
);
5379 return (EXECUTION_FAILURE
);
5382 #if defined (DEBUGGER)
5383 bind_function_def (name
->word
, funcdef
);
5386 bind_function (name
->word
, funcdef
->command
);
5387 return (EXECUTION_SUCCESS
);
5390 #if defined (INCLUDE_UNUSED)
5391 #if defined (PROCESS_SUBSTITUTION)
5395 register int i
, fd_table_size
;
5397 fd_table_size
= getdtablesize ();
5398 if (fd_table_size
> 256) /* clamp to a reasonable value */
5399 fd_table_size
= 256;
5401 for (i
= 3; i
< fd_table_size
; i
++)
5404 #endif /* PROCESS_SUBSTITUTION */
5408 close_pipes (in
, out
)
5418 dup_error (oldd
, newd
)
5421 sys_error (_("cannot duplicate fd %d to fd %d"), oldd
, newd
);
5424 /* Redirect input and output to be from and to the specified pipes.
5425 NO_PIPE and REDIRECT_BOTH are handled correctly. */
5427 do_piping (pipe_in
, pipe_out
)
5428 int pipe_in
, pipe_out
;
5430 if (pipe_in
!= NO_PIPE
)
5432 if (dup2 (pipe_in
, 0) < 0)
5433 dup_error (pipe_in
, 0);
5437 /* Let stdio know the fd may have changed from text to binary mode. */
5438 freopen (NULL
, "r", stdin
);
5439 #endif /* __CYGWIN__ */
5441 if (pipe_out
!= NO_PIPE
)
5443 if (pipe_out
!= REDIRECT_BOTH
)
5445 if (dup2 (pipe_out
, 1) < 0)
5446 dup_error (pipe_out
, 1);
5447 if (pipe_out
== 0 || pipe_out
> 1)
5452 if (dup2 (1, 2) < 0)
5456 /* Let stdio know the fd may have changed from text to binary mode, and
5457 make sure to preserve stdout line buffering. */
5458 freopen (NULL
, "w", stdout
);
5459 sh_setlinebuf (stdout
);
5460 #endif /* __CYGWIN__ */