1 /* execute_command.c -- Execute a COMMAND structure. */
3 /* Copyright (C) 1987,1991 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 1, or (at your option)
12 Bash is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash; see the file COPYING. If not, write to the Free
19 Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
24 #endif /* _AIX && RISC6000 && !__GNUC__ */
28 #include "bashtypes.h"
30 # include <sys/file.h>
33 #include "posixstat.h"
36 # include <sys/param.h>
39 #if defined (HAVE_UNISTD_H)
43 #if defined (HAVE_LIMITS_H)
47 /* Some systems require this, mostly for the definition of `struct timezone'.
48 For example, Dynix/ptx has that definition in <time.h> rather than
50 #if defined (TIME_WITH_SYS_TIME)
51 # include <sys/time.h>
54 # if defined (HAVE_SYS_TIME_H)
55 # include <sys/time.h>
61 #if defined (HAVE_SYS_RESOURCE_H) && !defined (RLIMTYPE)
62 # include <sys/resource.h>
65 #if defined (HAVE_SYS_TIMES_H) && defined (HAVE_TIMES)
66 # include <sys/times.h>
79 #include <y.tab.h> /* use <...> so we pick it up from the build directory */
84 #include "execute_cmd.h"
91 #if defined (COND_COMMAND)
95 #include "builtins/common.h"
96 #include "builtins/builtext.h" /* list of builtins */
98 #include <glob/fnmatch.h>
99 #include <tilde/tilde.h>
101 #if defined (BUFFERED_INPUT)
109 #if defined (HISTORY)
110 # include "bashhist.h"
113 extern int posixly_correct;
114 extern int executing, breaking, continuing, loop_level;
115 extern int interactive, interactive_shell, login_shell, expand_aliases;
116 extern int parse_and_execute_level, running_trap, trap_line_number;
117 extern int command_string_index, variable_context, line_number;
118 extern int dot_found_in_search;
119 extern int already_making_children;
120 extern char **temporary_env, **function_env, **builtin_env;
121 extern char *the_printed_command, *shell_name;
122 extern pid_t last_command_subst_pid;
123 extern Function *last_shell_builtin, *this_shell_builtin;
124 extern char **subshell_argv, **subshell_envp;
125 extern int subshell_argc;
126 extern char *glob_argv_flags;
128 extern int getdtablesize ();
131 /* Static functions defined and used in this file. */
132 static void close_pipes (), do_piping (), bind_lastarg ();
133 static void cleanup_redirects ();
135 static int execute_for_command ();
136 #if defined (SELECT_COMMAND)
137 static int execute_select_command ();
139 #if defined (DPAREN_ARITHMETIC)
140 static int execute_arith_command ();
142 #if defined (COND_COMMAND)
143 static int execute_cond_command ();
145 #if defined (COMMAND_TIMING)
146 static int time_command ();
148 static int execute_case_command ();
149 static int execute_while_command (), execute_until_command ();
150 static int execute_while_or_until ();
151 static int execute_if_command ();
152 static int execute_simple_command ();
153 static int execute_builtin (), execute_function ();
154 static int execute_builtin_or_function ();
155 static int builtin_status ();
156 static void execute_subshell_builtin_or_function ();
157 static void execute_disk_command ();
158 static int execute_connection ();
159 static int execute_intern_function ();
161 /* The line number that the currently executing function starts on. */
162 static int function_line_number;
164 /* Set to 1 if fd 0 was the subject of redirection to a subshell. Global
165 so that reader_loop can set it to zero before executing a command. */
168 /* The name of the command that is currently being executed.
169 `test' needs this, for example. */
170 char *this_command_name;
172 static COMMAND *currently_executing_command;
174 struct stat SB; /* used for debugging */
176 static int special_builtin_failed;
178 /* For catching RETURN in a function. */
179 int return_catch_flag;
180 int return_catch_value;
181 procenv_t return_catch;
183 /* The value returned by the last synchronous command. */
184 int last_command_exit_value;
186 /* The list of redirections to perform which will undo the redirections
187 that I made in the shell. */
188 REDIRECT *redirection_undo_list = (REDIRECT *)NULL;
190 /* The list of redirections to perform which will undo the internal
191 redirections performed by the `exec' builtin. These are redirections
192 that must be undone even when exec discards redirection_undo_list. */
193 REDIRECT *exec_redirection_undo_list = (REDIRECT *)NULL;
195 /* Non-zero if we have just forked and are currently running in a subshell
197 int subshell_environment;
199 struct fd_bitmap *current_fds_to_close = (struct fd_bitmap *)NULL;
201 #define FD_BITMAP_DEFAULT_SIZE 32L
203 /* Functions to allocate and deallocate the structures used to pass
204 information from the shell to its children about file descriptors
210 struct fd_bitmap *ret;
212 ret = (struct fd_bitmap *)xmalloc (sizeof (struct fd_bitmap));
218 ret->bitmap = xmalloc (size);
219 bzero (ret->bitmap, size);
222 ret->bitmap = (char *)NULL;
227 dispose_fd_bitmap (fdbp)
228 struct fd_bitmap *fdbp;
235 close_fd_bitmap (fdbp)
236 struct fd_bitmap *fdbp;
242 for (i = 0; i < fdbp->size; i++)
251 /* Return the line number of the currently executing command. */
253 executing_line_number ()
255 if (executing && variable_context == 0 && currently_executing_command &&
256 currently_executing_command->type == cm_simple)
257 return currently_executing_command->value.Simple->line;
258 else if (running_trap)
259 return trap_line_number;
264 /* Execute the command passed in COMMAND. COMMAND is exactly what
265 read_command () places into GLOBAL_COMMAND. See "command.h" for the
266 details of the command structure.
268 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
269 return values. Executing a command with nothing in it returns
270 EXECUTION_SUCCESS. */
272 execute_command (command)
275 struct fd_bitmap *bitmap;
278 current_fds_to_close = (struct fd_bitmap *)NULL;
279 bitmap = new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE);
280 begin_unwind_frame ("execute-command");
281 add_unwind_protect (dispose_fd_bitmap, (char *)bitmap);
283 /* Just do the command, but not asynchronously. */
284 result = execute_command_internal (command, 0, NO_PIPE, NO_PIPE, bitmap);
286 dispose_fd_bitmap (bitmap);
287 discard_unwind_frame ("execute-command");
289 #if defined (PROCESS_SUBSTITUTION)
291 #endif /* PROCESS_SUBSTITUTION */
296 /* Return 1 if TYPE is a shell control structure type. */
298 shell_control_structure (type)
299 enum command_type type;
304 #if defined (SELECT_COMMAND)
307 #if defined (DPAREN_ARITHMETIC)
310 #if defined (COND_COMMAND)
325 /* A function to use to unwind_protect the redirection undo list
328 cleanup_redirects (list)
331 do_redirections (list, 1, 0, 0);
332 dispose_redirects (list);
336 /* Function to unwind_protect the redirections for functions and builtins. */
338 cleanup_func_redirects (list)
341 do_redirections (list, 1, 0, 0);
346 dispose_exec_redirects ()
348 if (exec_redirection_undo_list)
350 dispose_redirects (exec_redirection_undo_list);
351 exec_redirection_undo_list = (REDIRECT *)NULL;
355 #if defined (JOB_CONTROL)
356 /* A function to restore the signal mask to its proper value when the shell
357 is interrupted or errors occur while creating a pipeline. */
359 restore_signal_mask (set)
362 return (sigprocmask (SIG_SETMASK, &set, (sigset_t *)NULL));
364 #endif /* JOB_CONTROL */
366 /* A debugging function that can be called from gdb, for instance. */
371 int f, fd_table_size;
373 fd_table_size = getdtablesize ();
375 fprintf (stderr, "pid %d open files:", (int)getpid ());
376 for (i = 3; i < fd_table_size; i++)
378 if ((f = fcntl (i, F_GETFD, 0)) != -1)
379 fprintf (stderr, " %d (%s)", i, f ? "close" : "open");
381 fprintf (stderr, "\n");
385 async_redirect_stdin ()
389 fd = open ("/dev/null", O_RDONLY);
396 internal_error ("cannot redirect standard input from /dev/null: %s", strerror (errno));
399 #define DESCRIBE_PID(pid) do { if (interactive) describe_pid (pid); } while (0)
401 /* Execute the command passed in COMMAND, perhaps doing it asynchrounously.
402 COMMAND is exactly what read_command () places into GLOBAL_COMMAND.
403 ASYNCHROUNOUS, if non-zero, says to do this command in the background.
404 PIPE_IN and PIPE_OUT are file descriptors saying where input comes
405 from and where it goes. They can have the value of NO_PIPE, which means
407 FDS_TO_CLOSE is a list of file descriptors to close once the child has
408 been forked. This list often contains the unusable sides of pipes, etc.
410 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
411 return values. Executing a command with nothing in it returns
412 EXECUTION_SUCCESS. */
414 execute_command_internal (command, asynchronous, pipe_in, pipe_out,
418 int pipe_in, pipe_out;
419 struct fd_bitmap *fds_to_close;
421 int exec_result, invert, ignore_return, was_debug_trap;
422 REDIRECT *my_undo_list, *exec_undo_list;
423 volatile pid_t last_pid;
425 if (command == 0 || breaking || continuing || read_but_dont_execute)
426 return (EXECUTION_SUCCESS);
428 run_pending_traps ();
430 if (running_trap == 0)
431 currently_executing_command = command;
433 invert = (command->flags & CMD_INVERT_RETURN) != 0;
435 /* If we're inverting the return value and `set -e' has been executed,
436 we don't want a failing command to inadvertently cause the shell
438 if (exit_immediately_on_error && invert) /* XXX */
439 command->flags |= CMD_IGNORE_RETURN; /* XXX */
441 exec_result = EXECUTION_SUCCESS;
443 /* If a command was being explicitly run in a subshell, or if it is
444 a shell control-structure, and it has a pipe, then we do the command
447 if ((command->flags & (CMD_WANT_SUBSHELL|CMD_FORCE_SUBSHELL)) ||
448 (shell_control_structure (command->type) &&
449 (pipe_out != NO_PIPE || pipe_in != NO_PIPE || asynchronous)))
453 /* Fork a subshell, turn off the subshell bit, turn off job
454 control and call execute_command () on the command again. */
455 paren_pid = make_child (savestring (make_command_string (command)),
459 int user_subshell, return_code, function_value, should_redir_stdin;
461 should_redir_stdin = (asynchronous && (command->flags & CMD_STDIN_REDIR) &&
462 pipe_in == NO_PIPE &&
463 stdin_redirects (command->redirects) == 0);
465 user_subshell = (command->flags & CMD_WANT_SUBSHELL) != 0;
466 command->flags &= ~(CMD_FORCE_SUBSHELL | CMD_WANT_SUBSHELL | CMD_INVERT_RETURN);
468 /* If a command is asynchronous in a subshell (like ( foo ) & or
469 the special case of an asynchronous GROUP command where the
470 the subshell bit is turned on down in case cm_group: below),
471 turn off `asynchronous', so that two subshells aren't spawned.
473 This seems semantically correct to me. For example,
474 ( foo ) & seems to say ``do the command `foo' in a subshell
475 environment, but don't wait for that subshell to finish'',
476 and "{ foo ; bar } &" seems to me to be like functions or
477 builtins in the background, which executed in a subshell
478 environment. I just don't see the need to fork two subshells. */
480 /* Don't fork again, we are already in a subshell. A `doubly
481 async' shell is not interactive, however. */
484 #if defined (JOB_CONTROL)
485 /* If a construct like ( exec xxx yyy ) & is given while job
486 control is active, we want to prevent exec from putting the
487 subshell back into the original process group, carefully
488 undoing all the work we just did in make_child. */
490 #endif /* JOB_CONTROL */
491 interactive_shell = 0;
496 /* Subshells are neither login nor interactive. */
497 login_shell = interactive = 0;
499 subshell_environment = user_subshell ? SUBSHELL_PAREN : SUBSHELL_ASYNC;
501 reset_terminating_signals (); /* in shell.c */
502 /* Cancel traps, in trap.c. */
503 restore_original_signals ();
505 setup_async_signals ();
507 #if defined (JOB_CONTROL)
508 set_sigchld_handler ();
509 #endif /* JOB_CONTROL */
511 set_sigint_handler ();
513 #if defined (JOB_CONTROL)
514 /* Delete all traces that there were any jobs running. This is
515 only for subshells. */
516 without_job_control ();
517 #endif /* JOB_CONTROL */
518 do_piping (pipe_in, pipe_out);
520 /* If this is a user subshell, set a flag if stdin was redirected.
521 This is used later to decide whether to redirect fd 0 to
522 /dev/null for async commands in the subshell. This adds more
523 sh compatibility, but I'm not sure it's the right thing to do. */
526 stdin_redir = stdin_redirects (command->redirects);
527 restore_default_signal (0);
531 close_fd_bitmap (fds_to_close);
533 /* If this is an asynchronous command (command &), we want to
534 redirect the standard input from /dev/null in the absence of
535 any specific redirection involving stdin. */
536 if (should_redir_stdin && stdin_redir == 0)
537 async_redirect_stdin ();
539 /* Do redirections, then dispose of them before recursive call. */
540 if (command->redirects)
542 if (do_redirections (command->redirects, 1, 0, 0) != 0)
543 exit (EXECUTION_FAILURE);
545 dispose_redirects (command->redirects);
546 command->redirects = (REDIRECT *)NULL;
549 /* If this is a simple command, tell execute_disk_command that it
550 might be able to get away without forking and simply exec.
551 This means things like ( sleep 10 ) will only cause one fork.
552 If we're timing the command, however, we cannot do this
555 if (user_subshell && command->type == cm_simple)
557 if (user_subshell && command->type == cm_simple && (command->flags & CMD_TIME_PIPELINE) == 0)
560 command->flags |= CMD_NO_FORK;
561 command->value.Simple->flags |= CMD_NO_FORK;
564 /* If we're inside a function while executing this subshell, we
565 need to handle a possible `return'. */
567 if (return_catch_flag)
568 function_value = setjmp (return_catch);
571 return_code = return_catch_value;
573 return_code = execute_command_internal
574 (command, asynchronous, NO_PIPE, NO_PIPE, fds_to_close);
576 /* If we were explicitly placed in a subshell with (), we need
577 to do the `shell cleanup' things, such as running traps[0]. */
578 if (user_subshell && signal_is_trapped (0))
580 last_command_exit_value = return_code;
581 return_code = run_exit_trap ();
588 close_pipes (pipe_in, pipe_out);
590 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
593 /* If we are part of a pipeline, and not the end of the pipeline,
594 then we should simply return and let the last command in the
595 pipe be waited for. If we are not in a pipeline, or are the
596 last command in the pipeline, then we wait for the subshell
597 and return its exit status as usual. */
598 if (pipe_out != NO_PIPE)
599 return (EXECUTION_SUCCESS);
601 stop_pipeline (asynchronous, (COMMAND *)NULL);
603 if (asynchronous == 0)
605 last_command_exit_value = wait_for (paren_pid);
607 /* If we have to, invert the return value. */
609 return ((last_command_exit_value == EXECUTION_SUCCESS)
611 : EXECUTION_SUCCESS);
613 return (last_command_exit_value);
617 DESCRIBE_PID (paren_pid);
619 run_pending_traps ();
621 return (EXECUTION_SUCCESS);
626 #if defined (COMMAND_TIMING)
627 if (command->flags & CMD_TIME_PIPELINE)
631 command->flags |= CMD_FORCE_SUBSHELL;
632 exec_result = execute_command_internal (command, 1, pipe_in, pipe_out, fds_to_close);
636 exec_result = time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close);
637 if (running_trap == 0)
638 currently_executing_command = (COMMAND *)NULL;
640 return (exec_result);
642 #endif /* COMMAND_TIMING */
644 if (shell_control_structure (command->type) && command->redirects)
645 stdin_redir = stdin_redirects (command->redirects);
647 /* Handle WHILE FOR CASE etc. with redirections. (Also '&' input
649 if (do_redirections (command->redirects, 1, 1, 0) != 0)
651 cleanup_redirects (redirection_undo_list);
652 redirection_undo_list = (REDIRECT *)NULL;
653 dispose_exec_redirects ();
654 return (EXECUTION_FAILURE);
657 if (redirection_undo_list)
659 my_undo_list = (REDIRECT *)copy_redirects (redirection_undo_list);
660 dispose_redirects (redirection_undo_list);
661 redirection_undo_list = (REDIRECT *)NULL;
664 my_undo_list = (REDIRECT *)NULL;
666 if (exec_redirection_undo_list)
668 exec_undo_list = (REDIRECT *)copy_redirects (exec_redirection_undo_list);
669 dispose_redirects (exec_redirection_undo_list);
670 exec_redirection_undo_list = (REDIRECT *)NULL;
673 exec_undo_list = (REDIRECT *)NULL;
675 if (my_undo_list || exec_undo_list)
676 begin_unwind_frame ("loop_redirections");
679 add_unwind_protect ((Function *)cleanup_redirects, my_undo_list);
682 add_unwind_protect ((Function *)dispose_redirects, exec_undo_list);
684 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
688 switch (command->type)
692 /* We can't rely on this variable retaining its value across a
693 call to execute_simple_command if a longjmp occurs as the
694 result of a `return' builtin. This is true for sure with gcc. */
695 last_pid = last_made_pid;
696 was_debug_trap = signal_is_trapped (DEBUG_TRAP) && signal_is_ignored (DEBUG_TRAP) == 0;
698 if (ignore_return && command->value.Simple)
699 command->value.Simple->flags |= CMD_IGNORE_RETURN;
700 if (command->flags & CMD_STDIN_REDIR)
701 command->value.Simple->flags |= CMD_STDIN_REDIR;
703 execute_simple_command (command->value.Simple, pipe_in, pipe_out,
704 asynchronous, fds_to_close);
706 /* The temporary environment should be used for only the simple
707 command immediately following its definition. */
708 dispose_used_env_vars ();
710 #if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
711 /* Reclaim memory allocated with alloca () on machines which
712 may be using the alloca emulation code. */
714 #endif /* (ultrix && mips) || C_ALLOCA */
716 /* If we forked to do the command, then we must wait_for ()
719 /* XXX - this is something to watch out for if there are problems
720 when the shell is compiled without job control. */
721 if (already_making_children && pipe_out == NO_PIPE &&
722 last_pid != last_made_pid)
724 stop_pipeline (asynchronous, (COMMAND *)NULL);
728 DESCRIBE_PID (last_made_pid);
731 #if !defined (JOB_CONTROL)
732 /* Do not wait for asynchronous processes started from
734 if (last_made_pid != last_asynchronous_pid)
736 /* When executing a shell function that executes other
737 commands, this causes the last simple command in
738 the function to be waited for twice. */
739 exec_result = wait_for (last_made_pid);
746 if (ignore_return == 0 && invert == 0 &&
747 ((posixly_correct && interactive == 0 && special_builtin_failed) ||
748 (exit_immediately_on_error && (exec_result != EXECUTION_SUCCESS))))
750 last_command_exit_value = exec_result;
751 run_pending_traps ();
752 jump_to_top_level (EXITPROG);
759 command->value.For->flags |= CMD_IGNORE_RETURN;
760 exec_result = execute_for_command (command->value.For);
763 #if defined (SELECT_COMMAND)
766 command->value.Select->flags |= CMD_IGNORE_RETURN;
767 exec_result = execute_select_command (command->value.Select);
773 command->value.Case->flags |= CMD_IGNORE_RETURN;
774 exec_result = execute_case_command (command->value.Case);
779 command->value.While->flags |= CMD_IGNORE_RETURN;
780 exec_result = execute_while_command (command->value.While);
785 command->value.While->flags |= CMD_IGNORE_RETURN;
786 exec_result = execute_until_command (command->value.While);
791 command->value.If->flags |= CMD_IGNORE_RETURN;
792 exec_result = execute_if_command (command->value.If);
797 /* This code can be executed from either of two paths: an explicit
798 '{}' command, or via a function call. If we are executed via a
799 function call, we have already taken care of the function being
800 executed in the background (down there in execute_simple_command ()),
801 and this command should *not* be marked as asynchronous. If we
802 are executing a regular '{}' group command, and asynchronous == 1,
803 we must want to execute the whole command in the background, so we
804 need a subshell, and we want the stuff executed in that subshell
805 (this group command) to be executed in the foreground of that
806 subshell (i.e. there will not be *another* subshell forked).
808 What we do is to force a subshell if asynchronous, and then call
809 execute_command_internal again with asynchronous still set to 1,
810 but with the original group command, so the printed command will
813 The code above that handles forking off subshells will note that
814 both subshell and async are on, and turn off async in the child
815 after forking the subshell (but leave async set in the parent, so
816 the normal call to describe_pid is made). This turning off
817 async is *crucial*; if it is not done, this will fall into an
818 infinite loop of executions through this spot in subshell after
819 subshell until the process limit is exhausted. */
823 command->flags |= CMD_FORCE_SUBSHELL;
825 execute_command_internal (command, 1, pipe_in, pipe_out,
830 if (ignore_return && command->value.Group->command)
831 command->value.Group->command->flags |= CMD_IGNORE_RETURN;
833 execute_command_internal (command->value.Group->command,
834 asynchronous, pipe_in, pipe_out,
840 exec_result = execute_connection (command, asynchronous,
841 pipe_in, pipe_out, fds_to_close);
844 #if defined (DPAREN_ARITHMETIC)
847 command->value.Arith->flags |= CMD_IGNORE_RETURN;
848 exec_result = execute_arith_command (command->value.Arith);
852 #if defined (COND_COMMAND)
855 command->value.Cond->flags |= CMD_IGNORE_RETURN;
856 exec_result = execute_cond_command (command->value.Cond);
860 case cm_function_def:
861 exec_result = execute_intern_function (command->value.Function_def->name,
862 command->value.Function_def->command);
867 ("execute_command: bad command type `%d'", command->type);
872 do_redirections (my_undo_list, 1, 0, 0);
873 dispose_redirects (my_undo_list);
877 dispose_redirects (exec_undo_list);
879 if (my_undo_list || exec_undo_list)
880 discard_unwind_frame ("loop_redirections");
882 /* Invert the return value if we have to */
884 exec_result = (exec_result == EXECUTION_SUCCESS)
888 last_command_exit_value = exec_result;
889 run_pending_traps ();
890 if (running_trap == 0)
891 currently_executing_command = (COMMAND *)NULL;
892 return (last_command_exit_value);
895 #if defined (COMMAND_TIMING)
896 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
897 static struct timeval *
898 difftimeval (d, t1, t2)
899 struct timeval *d, *t1, *t2;
901 d->tv_sec = t2->tv_sec - t1->tv_sec;
902 d->tv_usec = t2->tv_usec - t1->tv_usec;
905 d->tv_usec += 1000000;
907 if (d->tv_sec < 0) /* ??? -- BSD/OS does this */
913 static struct timeval *
914 addtimeval (d, t1, t2)
915 struct timeval *d, *t1, *t2;
917 d->tv_sec = t1->tv_sec + t2->tv_sec;
918 d->tv_usec = t1->tv_usec + t2->tv_usec;
919 if (d->tv_usec > 1000000)
921 d->tv_usec -= 1000000;
927 /* Do "cpu = ((user + sys) * 10000) / real;" with timevals.
928 Barely-tested code from Deven T. Corzine <deven@ties.org>. */
930 timeval_to_cpu (rt, ut, st)
931 struct timeval *rt, *ut, *st; /* real, user, sys */
933 struct timeval t1, t2;
936 addtimeval (&t1, ut, st);
937 t2.tv_sec = rt->tv_sec;
938 t2.tv_usec = rt->tv_usec;
940 for (i = 0; i < 6; i++)
942 if ((t1.tv_sec > 99999999) || (t2.tv_sec > 99999999))
945 t1.tv_sec += t1.tv_usec / 100000;
947 t1.tv_usec %= 1000000;
949 t2.tv_sec += t2.tv_usec / 100000;
951 t2.tv_usec %= 1000000;
953 for (i = 0; i < 4; i++)
955 if (t1.tv_sec < 100000000)
961 return ((t2.tv_sec == 0) ? 0 : t1.tv_sec / t2.tv_sec);
963 #endif /* HAVE_GETRUSAGE && HAVE_GETTIMEOFDAY */
965 #define POSIX_TIMEFORMAT "real %2R\nuser %2U\nsys %2S"
966 #define BASH_TIMEFORMAT "\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS"
968 static int precs[] = { 0, 100, 10, 1 };
970 /* Expand one `%'-prefixed escape sequence from a time format string. */
972 mkfmt (buf, prec, lng, sec, sec_fraction)
985 /* If LNG is non-zero, we want to decompose SEC into minutes and seconds. */
992 abuf[aind--] = (min % 10) + '0';
996 buf[ind++] = abuf[aind++];
1000 /* Now add the seconds. */
1003 abuf[aind--] = (sec % 10) + '0';
1007 buf[ind++] = abuf[aind++];
1009 /* We want to add a decimal point and PREC places after it if PREC is
1010 nonzero. PREC is not greater than 3. SEC_FRACTION is between 0
1015 for (aind = 1; aind <= prec; aind++)
1017 buf[ind++] = (sec_fraction / precs[aind]) + '0';
1018 sec_fraction %= precs[aind];
1029 /* Interpret the format string FORMAT, interpolating the following escape
1033 where the optional `prec' is a precision, meaning the number of
1034 characters after the decimal point, the optional `l' means to format
1035 using minutes and seconds (MMmNN[.FF]s), like the `times' builtin',
1036 and the last character is one of
1038 R number of seconds of `real' time
1039 U number of seconds of `user' time
1040 S number of seconds of `system' time
1042 An occurrence of `%%' in the format string is translated to a `%'. The
1043 result is printed to FP, a pointer to a FILE. The other variables are
1044 the seconds and thousandths of a second of real, user, and system time,
1047 print_formatted_time (fp, format, rs, rsf, us, usf, ss, ssf, cpu)
1051 int rsf, usf, ssf, cpu;
1054 char *str, *s, ts[32];
1059 len = strlen (format);
1060 ssize = (len + 64) - (len % 64);
1061 str = xmalloc (ssize);
1064 for (s = format; *s; s++)
1066 if (*s != '%' || s[1] == '\0')
1068 RESIZE_MALLOCED_BUFFER (str, sindex, 1, ssize, 64);
1071 else if (s[1] == '%')
1074 RESIZE_MALLOCED_BUFFER (str, sindex, 1, ssize, 64);
1077 else if (s[1] == 'P')
1083 sum_frac = (cpu % 100) * 10;
1084 len = mkfmt (ts, 2, 0, sum, sum_frac);
1085 RESIZE_MALLOCED_BUFFER (str, sindex, len, ssize, 64);
1086 strcpy (str + sindex, ts);
1091 prec = 3; /* default is three places past the decimal point. */
1092 lng = 0; /* default is to not use minutes or append `s' */
1094 if (isdigit (*s)) /* `precision' */
1097 if (prec > 3) prec = 3;
1099 if (*s == 'l') /* `length extender' */
1104 if (*s == 'R' || *s == 'E')
1105 len = mkfmt (ts, prec, lng, rs, rsf);
1107 len = mkfmt (ts, prec, lng, us, usf);
1109 len = mkfmt (ts, prec, lng, ss, ssf);
1112 internal_error ("bad format character in time format: %c", *s);
1116 RESIZE_MALLOCED_BUFFER (str, sindex, len, ssize, 64);
1117 strcpy (str + sindex, ts);
1123 fprintf (fp, "%s\n", str);
1130 time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close)
1132 int asynchronous, pipe_in, pipe_out;
1133 struct fd_bitmap *fds_to_close;
1135 int rv, posix_time, old_flags;
1141 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1142 struct timeval real, user, sys;
1143 struct timeval before, after;
1144 struct timezone dtz;
1145 struct rusage selfb, selfa, kidsb, kidsa; /* a = after, b = before */
1147 # if defined (HAVE_TIMES)
1148 clock_t tbefore, tafter, real, user, sys;
1149 struct tms before, after;
1153 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1154 gettimeofday (&before, &dtz);
1155 getrusage (RUSAGE_SELF, &selfb);
1156 getrusage (RUSAGE_CHILDREN, &kidsb);
1158 # if defined (HAVE_TIMES)
1159 tbefore = times (&before);
1163 posix_time = (command->flags & CMD_TIME_POSIX);
1165 old_flags = command->flags;
1166 command->flags &= ~(CMD_TIME_PIPELINE|CMD_TIME_POSIX);
1167 rv = execute_command_internal (command, asynchronous, pipe_in, pipe_out, fds_to_close);
1168 command->flags = old_flags;
1171 rsf = usf = ssf = cpu = 0;
1173 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1174 gettimeofday (&after, &dtz);
1175 getrusage (RUSAGE_SELF, &selfa);
1176 getrusage (RUSAGE_CHILDREN, &kidsa);
1178 difftimeval (&real, &before, &after);
1179 timeval_to_secs (&real, &rs, &rsf);
1181 addtimeval (&user, difftimeval(&after, &selfb.ru_utime, &selfa.ru_utime),
1182 difftimeval(&before, &kidsb.ru_utime, &kidsa.ru_utime));
1183 timeval_to_secs (&user, &us, &usf);
1185 addtimeval (&sys, difftimeval(&after, &selfb.ru_stime, &selfa.ru_stime),
1186 difftimeval(&before, &kidsb.ru_stime, &kidsa.ru_stime));
1187 timeval_to_secs (&sys, &ss, &ssf);
1189 cpu = timeval_to_cpu (&real, &user, &sys);
1191 # if defined (HAVE_TIMES)
1192 tafter = times (&after);
1194 real = tafter - tbefore;
1195 clock_t_to_secs (real, &rs, &rsf);
1197 user = (after.tms_utime - before.tms_utime) + (after.tms_cutime - before.tms_cutime);
1198 clock_t_to_secs (user, &us, &usf);
1200 sys = (after.tms_stime - before.tms_stime) + (after.tms_cstime - before.tms_cstime);
1201 clock_t_to_secs (sys, &ss, &ssf);
1203 cpu = (real == 0) ? 0 : ((user + sys) * 10000) / real;
1207 rsf = usf = ssf = cpu = 0;
1212 time_format = POSIX_TIMEFORMAT;
1213 else if ((time_format = get_string_value ("TIMEFORMAT")) == 0)
1214 time_format = BASH_TIMEFORMAT;
1216 if (time_format && *time_format)
1217 print_formatted_time (stderr, time_format, rs, rsf, us, usf, ss, ssf, cpu);
1221 #endif /* COMMAND_TIMING */
1224 execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close)
1226 int asynchronous, pipe_in, pipe_out;
1227 struct fd_bitmap *fds_to_close;
1229 int prev, fildes[2], new_bitmap_size, dummyfd, ignore_return, exec_result;
1231 struct fd_bitmap *fd_bitmap;
1233 #if defined (JOB_CONTROL)
1235 BLOCK_CHILD (set, oset);
1236 #endif /* JOB_CONTROL */
1238 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
1243 while (cmd && cmd->type == cm_connection &&
1244 cmd->value.Connection && cmd->value.Connection->connector == '|')
1246 /* Make a pipeline between the two commands. */
1247 if (pipe (fildes) < 0)
1249 sys_error ("pipe error");
1250 #if defined (JOB_CONTROL)
1251 terminate_current_pipeline ();
1252 kill_current_pipeline ();
1253 #endif /* JOB_CONTROL */
1254 last_command_exit_value = EXECUTION_FAILURE;
1255 /* The unwind-protects installed below will take care
1256 of closing all of the open file descriptors. */
1257 throw_to_top_level ();
1258 return (EXECUTION_FAILURE); /* XXX */
1261 /* Here is a problem: with the new file close-on-exec
1262 code, the read end of the pipe (fildes[0]) stays open
1263 in the first process, so that process will never get a
1264 SIGPIPE. There is no way to signal the first process
1265 that it should close fildes[0] after forking, so it
1266 remains open. No SIGPIPE is ever sent because there
1267 is still a file descriptor open for reading connected
1268 to the pipe. We take care of that here. This passes
1269 around a bitmap of file descriptors that must be
1270 closed after making a child process in execute_simple_command. */
1272 /* We need fd_bitmap to be at least as big as fildes[0].
1273 If fildes[0] is less than fds_to_close->size, then
1274 use fds_to_close->size. */
1275 new_bitmap_size = (fildes[0] < fds_to_close->size)
1276 ? fds_to_close->size
1279 fd_bitmap = new_fd_bitmap (new_bitmap_size);
1281 /* Now copy the old information into the new bitmap. */
1282 xbcopy ((char *)fds_to_close->bitmap, (char *)fd_bitmap->bitmap, fds_to_close->size);
1284 /* And mark the pipe file descriptors to be closed. */
1285 fd_bitmap->bitmap[fildes[0]] = 1;
1287 /* In case there are pipe or out-of-processes errors, we
1288 want all these file descriptors to be closed when
1289 unwind-protects are run, and the storage used for the
1290 bitmaps freed up. */
1291 begin_unwind_frame ("pipe-file-descriptors");
1292 add_unwind_protect (dispose_fd_bitmap, fd_bitmap);
1293 add_unwind_protect (close_fd_bitmap, fd_bitmap);
1295 add_unwind_protect (close, prev);
1296 dummyfd = fildes[1];
1297 add_unwind_protect (close, dummyfd);
1299 #if defined (JOB_CONTROL)
1300 add_unwind_protect (restore_signal_mask, oset);
1301 #endif /* JOB_CONTROL */
1303 if (ignore_return && cmd->value.Connection->first)
1304 cmd->value.Connection->first->flags |= CMD_IGNORE_RETURN;
1305 execute_command_internal (cmd->value.Connection->first, asynchronous,
1306 prev, fildes[1], fd_bitmap);
1314 dispose_fd_bitmap (fd_bitmap);
1315 discard_unwind_frame ("pipe-file-descriptors");
1317 cmd = cmd->value.Connection->second;
1320 /* Now execute the rightmost command in the pipeline. */
1321 if (ignore_return && cmd)
1322 cmd->flags |= CMD_IGNORE_RETURN;
1323 exec_result = execute_command_internal (cmd, asynchronous, prev, pipe_out, fds_to_close);
1328 #if defined (JOB_CONTROL)
1329 UNBLOCK_CHILD (oset);
1332 return (exec_result);
1336 execute_connection (command, asynchronous, pipe_in, pipe_out, fds_to_close)
1338 int asynchronous, pipe_in, pipe_out;
1339 struct fd_bitmap *fds_to_close;
1345 COMMAND *tc, *second;
1346 int ignore_return, exec_result;
1348 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
1350 switch (command->value.Connection->connector)
1352 /* Do the first command asynchronously. */
1354 tc = command->value.Connection->first;
1356 return (EXECUTION_SUCCESS);
1361 tc->flags |= CMD_IGNORE_RETURN;
1362 tc->flags |= CMD_AMPERSAND;
1364 /* If this shell was compiled without job control support, if
1365 the shell is not running interactively, if we are currently
1366 in a subshell via `( xxx )', or if job control is not active
1367 then the standard input for an asynchronous command is
1368 forced to /dev/null. */
1369 #if defined (JOB_CONTROL)
1370 if ((!interactive_shell || subshell_environment || !job_control) && !stdin_redir)
1373 #endif /* JOB_CONTROL */
1376 rd.filename = make_bare_word ("/dev/null");
1377 tr = make_redirection (0, r_inputa_direction, rd);
1378 tr->next = tc->redirects;
1381 tc->flags |= CMD_STDIN_REDIR;
1384 exec_result = execute_command_internal (tc, 1, pipe_in, pipe_out, fds_to_close);
1386 if (tc->flags & CMD_STDIN_REDIR)
1389 /* Remove the redirection we added above. It matters,
1390 especially for loops, which call execute_command ()
1391 multiple times with the same command. */
1396 tc->redirects = tc->redirects->next;
1398 while (tc->redirects && tc->redirects != rp);
1400 tl->next = (REDIRECT *)NULL;
1401 dispose_redirects (tr);
1403 tc->flags &= ~CMD_STDIN_REDIR;
1406 second = command->value.Connection->second;
1410 second->flags |= CMD_IGNORE_RETURN;
1412 exec_result = execute_command_internal (second, asynchronous, pipe_in, pipe_out, fds_to_close);
1417 /* Just call execute command on both sides. */
1421 if (command->value.Connection->first)
1422 command->value.Connection->first->flags |= CMD_IGNORE_RETURN;
1423 if (command->value.Connection->second)
1424 command->value.Connection->second->flags |= CMD_IGNORE_RETURN;
1427 execute_command (command->value.Connection->first);
1429 exec_result = execute_command_internal (command->value.Connection->second,
1430 asynchronous, pipe_in, pipe_out,
1435 exec_result = execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close);
1442 /* If we have something like `a && b &' or `a || b &', run the
1443 && or || stuff in a subshell. Force a subshell and just call
1444 execute_command_internal again. Leave asynchronous on
1445 so that we get a report from the parent shell about the
1447 command->flags |= CMD_FORCE_SUBSHELL;
1448 exec_result = execute_command_internal (command, 1, pipe_in, pipe_out, fds_to_close);
1452 /* Execute the first command. If the result of that is successful
1453 and the connector is AND_AND, or the result is not successful
1454 and the connector is OR_OR, then execute the second command,
1455 otherwise return. */
1457 if (command->value.Connection->first)
1458 command->value.Connection->first->flags |= CMD_IGNORE_RETURN;
1460 exec_result = execute_command (command->value.Connection->first);
1462 if (((command->value.Connection->connector == AND_AND) &&
1463 (exec_result == EXECUTION_SUCCESS)) ||
1464 ((command->value.Connection->connector == OR_OR) &&
1465 (exec_result != EXECUTION_SUCCESS)))
1467 if (ignore_return && command->value.Connection->second)
1468 command->value.Connection->second->flags |= CMD_IGNORE_RETURN;
1470 exec_result = execute_command (command->value.Connection->second);
1475 programming_error ("execute_connection: bad connector `%d'", command->value.Connection->connector);
1476 jump_to_top_level (DISCARD);
1477 exec_result = EXECUTION_FAILURE;
1483 #if defined (JOB_CONTROL)
1487 if (!interactive_shell) \
1488 reap_dead_jobs (); \
1491 #else /* !JOB_CONTROL */
1495 if (!interactive_shell) \
1496 cleanup_dead_jobs (); \
1499 #endif /* !JOB_CONTROL */
1502 /* Execute a FOR command. The syntax is: FOR word_desc IN word_list;
1505 execute_for_command (for_command)
1506 FOR_COM *for_command;
1508 register WORD_LIST *releaser, *list;
1513 SHELL_VAR *old_value = (SHELL_VAR *)NULL; /* Remember the old value of x. */
1516 if (check_identifier (for_command->name, 1) == 0)
1518 if (posixly_correct && interactive_shell == 0)
1520 last_command_exit_value = EX_USAGE;
1521 jump_to_top_level (EXITPROG);
1523 return (EXECUTION_FAILURE);
1527 identifier = for_command->name->word;
1529 list = releaser = expand_words_no_vars (for_command->map_list);
1531 begin_unwind_frame ("for");
1532 add_unwind_protect (dispose_words, releaser);
1535 if (lexical_scoping)
1537 old_value = copy_variable (find_variable (identifier));
1539 add_unwind_protect (dispose_variable, old_value);
1543 if (for_command->flags & CMD_IGNORE_RETURN)
1544 for_command->action->flags |= CMD_IGNORE_RETURN;
1546 for (retval = EXECUTION_SUCCESS; list; list = list->next)
1549 this_command_name = (char *)NULL;
1550 v = bind_variable (identifier, list->word->word);
1553 if (interactive_shell == 0 && posixly_correct)
1555 last_command_exit_value = EXECUTION_FAILURE;
1556 jump_to_top_level (FORCE_EOF);
1560 run_unwind_frame ("for");
1562 return (EXECUTION_FAILURE);
1565 retval = execute_command (for_command->action);
1586 if (lexical_scoping)
1589 makunbound (identifier, shell_variables);
1592 SHELL_VAR *new_value;
1594 new_value = bind_variable (identifier, value_cell(old_value));
1595 new_value->attributes = old_value->attributes;
1596 dispose_variable (old_value);
1601 dispose_words (releaser);
1602 discard_unwind_frame ("for");
1606 #if defined (SELECT_COMMAND)
1607 static int LINES, COLS, tabsize;
1609 #define RP_SPACE ") "
1610 #define RP_SPACE_LEN 2
1612 /* XXX - does not handle numbers > 1000000 at all. */
1613 #define NUMBER_LEN(s) \
1617 : ((s < 10000) ? 4 \
1618 : ((s < 100000) ? 5 \
1622 print_index_and_element (len, ind, list)
1626 register WORD_LIST *l;
1631 for (i = ind, l = list; l && --i; l = l->next)
1633 fprintf (stderr, "%*d%s%s", len, ind, RP_SPACE, l->word->word);
1634 return (STRLEN (l->word->word));
1643 if ((to / tabsize) > (from / tabsize))
1645 putc ('\t', stderr);
1646 from += tabsize - from % tabsize;
1657 print_select_list (list, list_len, max_elem_len, indices_len)
1659 int list_len, max_elem_len, indices_len;
1661 int ind, row, elem_len, pos, cols, rows;
1662 int first_column_indices_len, other_indices_len;
1666 putc ('\n', stderr);
1670 cols = max_elem_len ? COLS / max_elem_len : 1;
1673 rows = list_len ? list_len / cols + (list_len % cols != 0) : 1;
1674 cols = list_len ? list_len / rows + (list_len % rows != 0) : 1;
1682 first_column_indices_len = NUMBER_LEN (rows);
1683 other_indices_len = indices_len;
1685 for (row = 0; row < rows; row++)
1691 indices_len = (pos == 0) ? first_column_indices_len : other_indices_len;
1692 elem_len = print_index_and_element (indices_len, ind + 1, list);
1693 elem_len += indices_len + RP_SPACE_LEN;
1695 if (ind >= list_len)
1697 indent (pos + elem_len, pos + max_elem_len);
1698 pos += max_elem_len;
1700 putc ('\n', stderr);
1704 /* Print the elements of LIST, one per line, preceded by an index from 1 to
1705 LIST_LEN. Then display PROMPT and wait for the user to enter a number.
1706 If the number is between 1 and LIST_LEN, return that selection. If EOF
1707 is read, return a null string. If a blank line is entered, or an invalid
1708 number is entered, the loop is executed again. */
1710 select_query (list, list_len, prompt)
1715 int max_elem_len, indices_len, len;
1718 char *repl_string, *t;
1720 t = get_string_value ("LINES");
1721 LINES = (t && *t) ? atoi (t) : 24;
1722 t = get_string_value ("COLUMNS");
1723 COLS = (t && *t) ? atoi (t) : 80;
1726 t = get_string_value ("TABSIZE");
1727 tabsize = (t && *t) ? atoi (t) : 8;
1735 for (l = list; l; l = l->next)
1737 len = STRLEN (l->word->word);
1738 if (len > max_elem_len)
1741 indices_len = NUMBER_LEN (list_len);
1742 max_elem_len += indices_len + RP_SPACE_LEN + 2;
1746 print_select_list (list, list_len, max_elem_len, indices_len);
1747 fprintf (stderr, "%s", prompt);
1751 if (read_builtin ((WORD_LIST *)NULL) == EXECUTION_FAILURE)
1754 return ((char *)NULL);
1756 repl_string = get_string_value ("REPLY");
1757 if (*repl_string == 0)
1759 if (legal_number (repl_string, &reply) == 0)
1761 if (reply < 1 || reply > list_len)
1764 for (l = list; l && --reply; l = l->next)
1766 return (l->word->word);
1770 /* Execute a SELECT command. The syntax is:
1771 SELECT word IN list DO command_list DONE
1772 Only `break' or `return' in command_list will terminate
1775 execute_select_command (select_command)
1776 SELECT_COM *select_command;
1778 WORD_LIST *releaser, *list;
1780 char *identifier, *ps3_prompt, *selection;
1781 int retval, list_len, return_val;
1783 if (check_identifier (select_command->name, 1) == 0)
1784 return (EXECUTION_FAILURE);
1787 identifier = select_command->name->word;
1789 /* command and arithmetic substitution, parameter and variable expansion,
1790 word splitting, pathname expansion, and quote removal. */
1791 list = releaser = expand_words_no_vars (select_command->map_list);
1792 list_len = list_length (list);
1793 if (list == 0 || list_len == 0)
1796 dispose_words (list);
1797 return (EXECUTION_SUCCESS);
1800 begin_unwind_frame ("select");
1801 add_unwind_protect (dispose_words, releaser);
1803 if (select_command->flags & CMD_IGNORE_RETURN)
1804 select_command->action->flags |= CMD_IGNORE_RETURN;
1806 retval = EXECUTION_SUCCESS;
1808 unwind_protect_int (return_catch_flag);
1809 unwind_protect_jmp_buf (return_catch);
1810 return_catch_flag++;
1814 ps3_prompt = get_string_value ("PS3");
1815 if (ps3_prompt == 0)
1819 selection = select_query (list, list_len, ps3_prompt);
1824 v = bind_variable (identifier, selection);
1827 if (interactive_shell == 0 && posixly_correct)
1829 last_command_exit_value = EXECUTION_FAILURE;
1830 jump_to_top_level (FORCE_EOF);
1834 run_unwind_frame ("select");
1835 return (EXECUTION_FAILURE);
1839 return_val = setjmp (return_catch);
1843 retval = return_catch_value;
1847 retval = execute_command (select_command->action);
1861 run_unwind_frame ("select");
1864 #endif /* SELECT_COMMAND */
1866 /* Execute a CASE command. The syntax is: CASE word_desc IN pattern_list ESAC.
1867 The pattern_list is a linked list of pattern clauses; each clause contains
1868 some patterns to compare word_desc against, and an associated command to
1871 execute_case_command (case_command)
1872 CASE_COM *case_command;
1874 register WORD_LIST *list;
1875 WORD_LIST *wlist, *es;
1876 PATTERN_LIST *clauses;
1877 char *word, *pattern;
1878 int retval, match, ignore_return;
1880 /* Posix.2 specifies that the WORD is tilde expanded. */
1881 if (member ('~', case_command->word->word))
1883 word = bash_tilde_expand (case_command->word->word);
1884 free (case_command->word->word);
1885 case_command->word->word = word;
1888 wlist = expand_word_no_split (case_command->word, 0);
1889 word = wlist ? string_list (wlist) : savestring ("");
1890 dispose_words (wlist);
1892 retval = EXECUTION_SUCCESS;
1893 ignore_return = case_command->flags & CMD_IGNORE_RETURN;
1895 begin_unwind_frame ("case");
1896 add_unwind_protect ((Function *)xfree, word);
1898 #define EXIT_CASE() goto exit_case_command
1900 for (clauses = case_command->clauses; clauses; clauses = clauses->next)
1903 for (list = clauses->patterns; list; list = list->next)
1905 /* Posix.2 specifies to tilde expand each member of the pattern
1907 if (member ('~', list->word->word))
1909 pattern = bash_tilde_expand (list->word->word);
1910 free (list->word->word);
1911 list->word->word = pattern;
1914 es = expand_word_leave_quoted (list->word, 0);
1916 if (es && es->word && es->word->word && *(es->word->word))
1917 pattern = quote_string_for_globbing (es->word->word, QGLOB_CVTNULL);
1920 pattern = xmalloc (1);
1924 /* Since the pattern does not undergo quote removal (as per
1925 Posix.2, section 3.9.4.3), the fnmatch () call must be able
1926 to recognize backslashes as escape characters. */
1927 match = fnmatch (pattern, word, FNMATCH_EXTFLAG) != FNM_NOMATCH;
1934 if (clauses->action && ignore_return)
1935 clauses->action->flags |= CMD_IGNORE_RETURN;
1936 retval = execute_command (clauses->action);
1946 discard_unwind_frame ("case");
1953 /* The WHILE command. Syntax: WHILE test DO action; DONE.
1954 Repeatedly execute action while executing test produces
1955 EXECUTION_SUCCESS. */
1957 execute_while_command (while_command)
1958 WHILE_COM *while_command;
1960 return (execute_while_or_until (while_command, CMD_WHILE));
1963 /* UNTIL is just like WHILE except that the test result is negated. */
1965 execute_until_command (while_command)
1966 WHILE_COM *while_command;
1968 return (execute_while_or_until (while_command, CMD_UNTIL));
1971 /* The body for both while and until. The only difference between the
1972 two is that the test value is treated differently. TYPE is
1973 CMD_WHILE or CMD_UNTIL. The return value for both commands should
1974 be EXECUTION_SUCCESS if no commands in the body are executed, and
1975 the status of the last command executed in the body otherwise. */
1977 execute_while_or_until (while_command, type)
1978 WHILE_COM *while_command;
1981 int return_value, body_status;
1983 body_status = EXECUTION_SUCCESS;
1986 while_command->test->flags |= CMD_IGNORE_RETURN;
1987 if (while_command->flags & CMD_IGNORE_RETURN)
1988 while_command->action->flags |= CMD_IGNORE_RETURN;
1992 return_value = execute_command (while_command->test);
1995 if (type == CMD_WHILE && return_value != EXECUTION_SUCCESS)
1997 if (type == CMD_UNTIL && return_value == EXECUTION_SUCCESS)
2001 body_status = execute_command (while_command->action);
2019 return (body_status);
2022 /* IF test THEN command [ELSE command].
2023 IF also allows ELIF in the place of ELSE IF, but
2024 the parser makes *that* stupidity transparent. */
2026 execute_if_command (if_command)
2031 if_command->test->flags |= CMD_IGNORE_RETURN;
2032 return_value = execute_command (if_command->test);
2034 if (return_value == EXECUTION_SUCCESS)
2038 if (if_command->true_case && (if_command->flags & CMD_IGNORE_RETURN))
2039 if_command->true_case->flags |= CMD_IGNORE_RETURN;
2041 return (execute_command (if_command->true_case));
2047 if (if_command->false_case && (if_command->flags & CMD_IGNORE_RETURN))
2048 if_command->false_case->flags |= CMD_IGNORE_RETURN;
2050 return (execute_command (if_command->false_case));
2054 #if defined (DPAREN_ARITHMETIC)
2056 execute_arith_command (arith_command)
2057 ARITH_COM *arith_command;
2059 int result, expok, expresult;
2060 WORD_LIST *new, *p, *printit;
2065 this_command_name = "((";
2066 /* If we're in a function, update the line number information. */
2067 if (variable_context)
2068 line_number = arith_command->line - function_line_number;
2070 new = expand_words (arith_command->exp);
2072 /* If we're tracing, make a new word list with `((' at the front and `))'
2073 at the back and print it. */
2074 if (echo_command_at_execute)
2075 xtrace_print_arith_cmd (new);
2077 result = evalexp (new->word->word, &expok);
2078 dispose_words (new);
2081 return (EXECUTION_FAILURE);
2083 return (result == 0 ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
2085 #endif /* DPAREN_ARITHMETIC */
2087 #if defined (COND_COMMAND)
2089 static char *nullstr = "";
2092 execute_cond_node (cond)
2095 int result, invert, patmatch;
2096 char *arg1, *arg2, *print2;
2098 invert = (cond->flags & CMD_INVERT_RETURN);
2100 if (cond->type == COND_EXPR)
2101 result = execute_cond_node (cond->left);
2102 else if (cond->type == COND_OR)
2104 result = execute_cond_node (cond->left);
2105 if (result != EXECUTION_SUCCESS)
2106 result = execute_cond_node (cond->right);
2108 else if (cond->type == COND_AND)
2110 result = execute_cond_node (cond->left);
2111 if (result == EXECUTION_SUCCESS)
2112 result = execute_cond_node (cond->right);
2114 else if (cond->type == COND_UNARY)
2116 arg1 = cond_expand_word (cond->left->op, 0);
2119 if (echo_command_at_execute)
2120 xtrace_print_cond_term (cond->type, invert, cond->op, arg1, (char *)NULL);
2121 result = unary_test (cond->op->word, arg1) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
2122 if (arg1 != nullstr)
2125 else if (cond->type == COND_BINARY)
2127 patmatch = (cond->op->word[1] == '=') && (cond->op->word[2] == '\0') &&
2128 (cond->op->word[0] == '!' || cond->op->word[0] == '=');
2130 arg1 = cond_expand_word (cond->left->op, 0);
2133 arg2 = cond_expand_word (cond->right->op, patmatch);
2137 if (echo_command_at_execute)
2138 xtrace_print_cond_term (cond->type, invert, cond->op, arg1, arg2);
2140 result = binary_test (cond->op->word, arg1, arg2, TEST_PATMATCH|TEST_ARITHEXP)
2142 : EXECUTION_FAILURE;
2143 if (arg1 != nullstr)
2145 if (arg2 != nullstr)
2150 programming_error ("execute_cond_node: %d: unknown conditional command type", cond->type);
2151 jump_to_top_level (DISCARD);
2152 result = EXECUTION_FAILURE;
2156 result = (result == EXECUTION_SUCCESS) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
2162 execute_cond_command (cond_command)
2163 COND_COM *cond_command;
2167 result = EXECUTION_SUCCESS;
2169 this_command_name = "[[";
2170 /* If we're in a function, update the line number information. */
2171 if (variable_context)
2172 line_number = cond_command->line - function_line_number;
2175 debug_print_cond_command (cond_command);
2177 last_command_exit_value = result = execute_cond_node (cond_command);
2180 #endif /* COND_COMMAND */
2190 var = bind_variable ("_", arg);
2191 var->attributes &= ~att_exported;
2194 /* Execute a null command. Fork a subshell if the command uses pipes or is
2195 to be run asynchronously. This handles all the side effects that are
2196 supposed to take place. */
2198 execute_null_command (redirects, pipe_in, pipe_out, async, old_last_command_subst_pid)
2199 REDIRECT *redirects;
2200 int pipe_in, pipe_out, async, old_last_command_subst_pid;
2202 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE || async)
2204 /* We have a null command, but we really want a subshell to take
2205 care of it. Just fork, do piping and redirections, and exit. */
2206 if (make_child ((char *)NULL, async) == 0)
2208 /* Cancel traps, in trap.c. */
2209 restore_original_signals (); /* XXX */
2211 do_piping (pipe_in, pipe_out);
2213 subshell_environment = SUBSHELL_ASYNC;
2215 if (do_redirections (redirects, 1, 0, 0) == 0)
2216 exit (EXECUTION_SUCCESS);
2218 exit (EXECUTION_FAILURE);
2222 close_pipes (pipe_in, pipe_out);
2223 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
2224 unlink_fifo_list ();
2226 return (EXECUTION_SUCCESS);
2231 /* Even if there aren't any command names, pretend to do the
2232 redirections that are specified. The user expects the side
2233 effects to take place. If the redirections fail, then return
2234 failure. Otherwise, if a command substitution took place while
2235 expanding the command or a redirection, return the value of that
2236 substitution. Otherwise, return EXECUTION_SUCCESS. */
2238 if (do_redirections (redirects, 0, 0, 0) != 0)
2239 return (EXECUTION_FAILURE);
2240 else if (old_last_command_subst_pid != last_command_subst_pid)
2241 return (last_command_exit_value);
2243 return (EXECUTION_SUCCESS);
2247 /* This is a hack to suppress word splitting for assignment statements
2248 given as arguments to builtins with the ASSIGNMENT_BUILTIN flag set. */
2250 fix_assignment_words (words)
2259 b = builtin_address_internal (words->word->word, 0);
2260 if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
2263 for (w = words; w; w = w->next)
2264 if (w->word->flags & W_ASSIGNMENT)
2265 w->word->flags |= W_NOSPLIT;
2268 /* The meaty part of all the executions. We have to start hacking the
2269 real execution of commands here. Fork a process, set things up,
2270 execute the command. */
2272 execute_simple_command (simple_command, pipe_in, pipe_out, async, fds_to_close)
2273 SIMPLE_COM *simple_command;
2274 int pipe_in, pipe_out, async;
2275 struct fd_bitmap *fds_to_close;
2277 WORD_LIST *words, *lastword;
2278 char *command_line, *lastarg, *temp;
2279 int first_word_quoted, result, builtin_is_special, already_forked;
2280 pid_t old_last_command_subst_pid;
2284 result = EXECUTION_SUCCESS;
2285 special_builtin_failed = builtin_is_special = 0;
2286 command_line = (char *)0;
2288 /* If we're in a function, update the line number information. */
2289 if (variable_context)
2290 line_number = simple_command->line - function_line_number;
2292 /* Remember what this command line looks like at invocation. */
2293 command_string_index = 0;
2294 print_simple_command (simple_command);
2297 simple_command->words ? (simple_command->words->word->flags & W_QUOTED): 0;
2299 old_last_command_subst_pid = last_command_subst_pid;
2302 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE || async)
2304 /* XXX memory leak if expand_words() error causes a jump_to_top_level */
2305 command_line = savestring (the_printed_command);
2307 if (make_child (command_line, async) == 0)
2310 simple_command->flags |= CMD_NO_FORK;
2312 do_piping (pipe_in, pipe_out);
2313 pipe_in = pipe_out = -1;
2315 subshell_environment = SUBSHELL_ASYNC;
2319 close_pipes (pipe_in, pipe_out);
2320 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
2321 unlink_fifo_list ();
2323 command_line = (char *)NULL; /* don't free this. */
2324 bind_lastarg ((char *)NULL);
2329 /* If we are re-running this as the result of executing the `command'
2330 builtin, do not expand the command words a second time. */
2331 if ((simple_command->flags & CMD_INHIBIT_EXPANSION) == 0)
2333 current_fds_to_close = fds_to_close;
2334 fix_assignment_words (simple_command->words);
2335 words = expand_words (simple_command->words);
2336 current_fds_to_close = (struct fd_bitmap *)NULL;
2339 words = copy_word_list (simple_command->words);
2341 /* It is possible for WORDS not to have anything left in it.
2342 Perhaps all the words consisted of `$foo', and there was
2343 no variable `$foo'. */
2346 result = execute_null_command (simple_command->redirects,
2348 already_forked ? 0 : async,
2349 old_last_command_subst_pid);
2354 bind_lastarg ((char *)NULL);
2355 set_pipestatus_from_exit (result);
2360 lastarg = (char *)NULL;
2362 begin_unwind_frame ("simple-command");
2364 if (echo_command_at_execute)
2365 xtrace_print_word_list (words);
2367 builtin = (Function *)NULL;
2368 func = (SHELL_VAR *)NULL;
2369 if ((simple_command->flags & CMD_NO_FUNCTIONS) == 0)
2371 /* Posix.2 says special builtins are found before functions. We
2372 don't set builtin_is_special anywhere other than here, because
2373 this path is followed only when the `command' builtin is *not*
2374 being used, and we don't want to exit the shell if a special
2375 builtin executed with `command builtin' fails. `command' is not
2376 a special builtin. */
2377 if (posixly_correct)
2379 builtin = find_special_builtin (words->word->word);
2381 builtin_is_special = 1;
2384 func = find_function (words->word->word);
2387 add_unwind_protect (dispose_words, words);
2390 /* Bind the last word in this command to "$_" after execution. */
2391 for (lastword = words; lastword->next; lastword = lastword->next)
2393 lastarg = lastword->word->word;
2395 #if defined (JOB_CONTROL)
2396 /* Is this command a job control related thing? */
2397 if (words->word->word[0] == '%' && already_forked == 0)
2399 this_command_name = async ? "bg" : "fg";
2400 last_shell_builtin = this_shell_builtin;
2401 this_shell_builtin = builtin_address (this_command_name);
2402 result = (*this_shell_builtin) (words);
2406 /* One other possiblilty. The user may want to resume an existing job.
2407 If they do, find out whether this word is a candidate for a running
2409 if (job_control && already_forked == 0 && async == 0 &&
2410 !first_word_quoted &&
2412 words->word->word[0] &&
2413 !simple_command->redirects &&
2414 pipe_in == NO_PIPE &&
2415 pipe_out == NO_PIPE &&
2416 (temp = get_string_value ("auto_resume")))
2420 int wl, cl, exact, substring, match, started_status;
2421 register PROCESS *p;
2423 word = words->word->word;
2424 exact = STREQ (temp, "exact");
2425 substring = STREQ (temp, "substring");
2427 for (i = job_slots - 1; i > -1; i--)
2429 if (jobs[i] == 0 || (JOBSTATE (i) != JSTOPPED))
2437 cl = strlen (p->command);
2438 match = STREQN (p->command, word, cl);
2441 match = strindex (p->command, word) != (char *)0;
2443 match = STREQN (p->command, word, wl);
2451 run_unwind_frame ("simple-command");
2452 this_command_name = "fg";
2453 last_shell_builtin = this_shell_builtin;
2454 this_shell_builtin = builtin_address ("fg");
2456 started_status = start_job (i, 1);
2457 return ((started_status < 0) ? EXECUTION_FAILURE : started_status);
2459 while (p != jobs[i]->pipe);
2462 #endif /* JOB_CONTROL */
2464 /* Remember the name of this command globally. */
2465 this_command_name = words->word->word;
2469 /* This command could be a shell builtin or a user-defined function.
2470 We have already found special builtins by this time, so we do not
2471 set builtin_is_special. If this is a function or builtin, and we
2472 have pipes, then fork a subshell in here. Otherwise, just execute
2473 the command directly. */
2474 if (func == 0 && builtin == 0)
2475 builtin = find_shell_builtin (this_command_name);
2477 last_shell_builtin = this_shell_builtin;
2478 this_shell_builtin = builtin;
2480 if (builtin || func)
2484 /* reset_terminating_signals (); */ /* XXX */
2485 /* Cancel traps, in trap.c. */
2486 restore_original_signals ();
2490 if ((simple_command->flags & CMD_STDIN_REDIR) &&
2491 pipe_in == NO_PIPE &&
2492 (stdin_redirects (simple_command->redirects) == 0))
2493 async_redirect_stdin ();
2494 setup_async_signals ();
2497 execute_subshell_builtin_or_function
2498 (words, simple_command->redirects, builtin, func,
2499 pipe_in, pipe_out, async, fds_to_close,
2500 simple_command->flags);
2504 result = execute_builtin_or_function
2505 (words, builtin, func, simple_command->redirects, fds_to_close,
2506 simple_command->flags);
2509 if (result > EX_SHERRBASE)
2511 result = builtin_status (result);
2512 if (builtin_is_special)
2513 special_builtin_failed = 1;
2515 /* In POSIX mode, if there are assignment statements preceding
2516 a special builtin, they persist after the builtin
2518 if (posixly_correct && builtin_is_special && temporary_env)
2519 merge_temporary_env ();
2523 if (result == EX_USAGE)
2524 result = EX_BADUSAGE;
2525 else if (result > EX_SHERRBASE)
2526 result = EXECUTION_FAILURE;
2529 set_pipestatus_from_exit (result);
2535 if (command_line == 0)
2536 command_line = savestring (the_printed_command);
2538 execute_disk_command (words, simple_command->redirects, command_line,
2539 pipe_in, pipe_out, async, fds_to_close,
2540 simple_command->flags);
2543 bind_lastarg (lastarg);
2544 FREE (command_line);
2545 run_unwind_frame ("simple-command");
2549 /* Translate the special builtin exit statuses. We don't really need a
2550 function for this; it's a placeholder for future work. */
2552 builtin_status (result)
2566 r = EXECUTION_FAILURE;
2569 r = EXECUTION_SUCCESS;
2576 execute_builtin (builtin, words, flags, subshell)
2579 int flags, subshell;
2581 int old_e_flag, result, eval_unwind;
2583 old_e_flag = exit_immediately_on_error;
2584 /* The eval builtin calls parse_and_execute, which does not know about
2585 the setting of flags, and always calls the execution functions with
2586 flags that will exit the shell on an error if -e is set. If the
2587 eval builtin is being called, and we're supposed to ignore the exit
2588 value of the command, we turn the -e flag off ourselves, then
2589 restore it when the command completes. */
2590 if (subshell == 0 && builtin == eval_builtin && (flags & CMD_IGNORE_RETURN))
2592 begin_unwind_frame ("eval_builtin");
2593 unwind_protect_int (exit_immediately_on_error);
2594 exit_immediately_on_error = 0;
2600 /* The temporary environment for a builtin is supposed to apply to
2601 all commands executed by that builtin. Currently, this is a
2602 problem only with the `source' and `eval' builtins. */
2603 if (builtin == source_builtin || builtin == eval_builtin)
2606 begin_unwind_frame ("builtin_env");
2610 builtin_env = copy_array (temporary_env);
2612 add_unwind_protect (dispose_builtin_env, (char *)NULL);
2613 dispose_used_env_vars ();
2617 builtin_env = (char **)NULL;
2621 result = ((*builtin) (words->next));
2623 if (subshell == 0 && (builtin == source_builtin || builtin == eval_builtin))
2625 /* In POSIX mode, if any variable assignments precede the `.' or
2626 `eval' builtin, they persist after the builtin completes, since `.'
2627 and `eval' are special builtins. */
2628 if (posixly_correct && builtin_env)
2629 merge_builtin_env ();
2631 dispose_builtin_env ();
2632 discard_unwind_frame ("builtin_env");
2634 run_unwind_frame ("builtin_env");
2640 exit_immediately_on_error += old_e_flag;
2641 discard_unwind_frame ("eval_builtin");
2648 execute_function (var, words, flags, fds_to_close, async, subshell)
2651 int flags, subshell, async;
2652 struct fd_bitmap *fds_to_close;
2654 int return_val, result;
2658 tc = (COMMAND *)copy_command (function_cell (var));
2659 if (tc && (flags & CMD_IGNORE_RETURN))
2660 tc->flags |= CMD_IGNORE_RETURN;
2664 begin_unwind_frame ("function_calling");
2666 add_unwind_protect (pop_context, (char *)NULL);
2667 unwind_protect_int (line_number);
2668 unwind_protect_int (return_catch_flag);
2669 unwind_protect_jmp_buf (return_catch);
2670 add_unwind_protect (dispose_command, (char *)tc);
2671 unwind_protect_int (loop_level);
2674 debug_trap = (signal_is_trapped (DEBUG_TRAP) && signal_is_ignored (DEBUG_TRAP) == 0)
2675 ? trap_list[DEBUG_TRAP]
2681 debug_trap = savestring (debug_trap);
2682 /* XXX order is important here! unwind-protect commands are run
2683 in reverse order of registering. If this causes problems,
2684 take out the xfree unwind-protect and live with the small
2686 add_unwind_protect (xfree, debug_trap);
2687 add_unwind_protect (set_debug_trap, debug_trap);
2689 restore_default_signal (DEBUG_TRAP);
2692 /* The temporary environment for a function is supposed to apply to
2693 all commands executed within the function body. */
2696 function_env = copy_array (temporary_env);
2698 add_unwind_protect (dispose_function_env, (char *)NULL);
2699 dispose_used_env_vars ();
2703 function_env = (char **)NULL;
2706 remember_args (words->next, 1);
2708 /* Number of the line on which the function body starts. */
2709 line_number = function_line_number = tc->line;
2713 #if defined (JOB_CONTROL)
2714 stop_pipeline (async, (COMMAND *)NULL);
2716 fc = (tc->type == cm_group) ? tc->value.Group->command : tc;
2718 if (fc && (flags & CMD_IGNORE_RETURN))
2719 fc->flags |= CMD_IGNORE_RETURN;
2726 return_catch_flag++;
2727 return_val = setjmp (return_catch);
2730 result = return_catch_value;
2732 result = execute_command_internal (fc, 0, NO_PIPE, NO_PIPE, fds_to_close);
2735 run_unwind_frame ("function_calling");
2740 /* Execute a shell builtin or function in a subshell environment. This
2741 routine does not return; it only calls exit(). If BUILTIN is non-null,
2742 it points to a function to call to execute a shell builtin; otherwise
2743 VAR points at the body of a function to execute. WORDS is the arguments
2744 to the command, REDIRECTS specifies redirections to perform before the
2745 command is executed. */
2747 execute_subshell_builtin_or_function (words, redirects, builtin, var,
2748 pipe_in, pipe_out, async, fds_to_close,
2751 REDIRECT *redirects;
2754 int pipe_in, pipe_out, async;
2755 struct fd_bitmap *fds_to_close;
2760 /* A subshell is neither a login shell nor interactive. */
2761 login_shell = interactive = 0;
2763 subshell_environment = SUBSHELL_ASYNC;
2765 maybe_make_export_env (); /* XXX - is this needed? */
2767 #if defined (JOB_CONTROL)
2768 /* Eradicate all traces of job control after we fork the subshell, so
2769 all jobs begun by this subshell are in the same process group as
2770 the shell itself. */
2772 /* Allow the output of `jobs' to be piped. */
2773 if (builtin == jobs_builtin && !async &&
2774 (pipe_out != NO_PIPE || pipe_in != NO_PIPE))
2775 kill_current_pipeline ();
2777 without_job_control ();
2779 set_sigchld_handler ();
2780 #endif /* JOB_CONTROL */
2782 set_sigint_handler ();
2784 do_piping (pipe_in, pipe_out);
2787 close_fd_bitmap (fds_to_close);
2789 if (do_redirections (redirects, 1, 0, 0) != 0)
2790 exit (EXECUTION_FAILURE);
2794 /* Give builtins a place to jump back to on failure,
2795 so we don't go back up to main(). */
2796 result = setjmp (top_level);
2798 if (result == EXITPROG)
2799 exit (last_command_exit_value);
2801 exit (EXECUTION_FAILURE);
2804 r = execute_builtin (builtin, words, flags, 1);
2811 exit (execute_function (var, words, flags, fds_to_close, async, 1));
2814 /* Execute a builtin or function in the current shell context. If BUILTIN
2815 is non-null, it is the builtin command to execute, otherwise VAR points
2816 to the body of a function. WORDS are the command's arguments, REDIRECTS
2817 are the redirections to perform. FDS_TO_CLOSE is the usual bitmap of
2818 file descriptors to close.
2820 If BUILTIN is exec_builtin, the redirections specified in REDIRECTS are
2821 not undone before this function returns. */
2823 execute_builtin_or_function (words, builtin, var, redirects,
2824 fds_to_close, flags)
2828 REDIRECT *redirects;
2829 struct fd_bitmap *fds_to_close;
2833 REDIRECT *saved_undo_list;
2835 if (do_redirections (redirects, 1, 1, 0) != 0)
2837 cleanup_redirects (redirection_undo_list);
2838 redirection_undo_list = (REDIRECT *)NULL;
2839 dispose_exec_redirects ();
2840 return (EX_REDIRFAIL); /* was EXECUTION_FAILURE */
2843 saved_undo_list = redirection_undo_list;
2845 /* Calling the "exec" builtin changes redirections forever. */
2846 if (builtin == exec_builtin)
2848 dispose_redirects (saved_undo_list);
2849 saved_undo_list = exec_redirection_undo_list;
2850 exec_redirection_undo_list = (REDIRECT *)NULL;
2853 dispose_exec_redirects ();
2855 if (saved_undo_list)
2857 begin_unwind_frame ("saved redirects");
2858 add_unwind_protect (cleanup_redirects, (char *)saved_undo_list);
2861 redirection_undo_list = (REDIRECT *)NULL;
2864 result = execute_builtin (builtin, words, flags, 0);
2866 result = execute_function (var, words, flags, fds_to_close, 0, 0);
2868 if (saved_undo_list)
2870 redirection_undo_list = saved_undo_list;
2871 discard_unwind_frame ("saved redirects");
2874 if (redirection_undo_list)
2876 cleanup_redirects (redirection_undo_list);
2877 redirection_undo_list = (REDIRECT *)NULL;
2884 setup_async_signals ()
2886 #if defined (JOB_CONTROL)
2887 if (job_control == 0)
2890 set_signal_handler (SIGINT, SIG_IGN);
2891 set_signal_ignored (SIGINT);
2892 set_signal_handler (SIGQUIT, SIG_IGN);
2893 set_signal_ignored (SIGQUIT);
2897 /* Execute a simple command that is hopefully defined in a disk file
2902 3) look up the command
2905 6) If the execve failed, see if the file has executable mode set.
2906 If so, and it isn't a directory, then execute its contents as
2909 Note that the filename hashing stuff has to take place up here,
2910 in the parent. This is probably why the Bourne style shells
2911 don't handle it, since that would require them to go through
2912 this gnarly hair, for no good reason. */
2914 execute_disk_command (words, redirects, command_line, pipe_in, pipe_out,
2915 async, fds_to_close, cmdflags)
2917 REDIRECT *redirects;
2919 int pipe_in, pipe_out, async;
2920 struct fd_bitmap *fds_to_close;
2923 char *pathname, *command, **args;
2927 nofork = (cmdflags & CMD_NO_FORK); /* Don't fork, just exec, if no pipes */
2928 pathname = words->word->word;
2930 #if defined (RESTRICTED_SHELL)
2931 if (restricted && strchr (pathname, '/'))
2933 internal_error ("%s: restricted: cannot specify `/' in command names",
2935 last_command_exit_value = EXECUTION_FAILURE;
2938 #endif /* RESTRICTED_SHELL */
2940 command = search_for_command (pathname);
2944 maybe_make_export_env ();
2945 put_command_name_into_env (command);
2948 /* We have to make the child before we check for the non-existance
2949 of COMMAND, since we want the error messages to be redirected. */
2950 /* If we can get away without forking and there are no pipes to deal with,
2951 don't bother to fork, just directly exec the command. */
2952 if (nofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE)
2955 pid = make_child (savestring (command_line), async);
2959 int old_interactive;
2962 /* This has been disabled for the time being. */
2963 #if !defined (ARG_MAX) || ARG_MAX >= 10240
2964 if (posixly_correct == 0)
2965 put_gnu_argv_flags_into_env ((int)getpid (), glob_argv_flags);
2969 /* Cancel traps, in trap.c. */
2970 restore_original_signals ();
2972 /* restore_original_signals may have undone the work done
2973 by make_child to ensure that SIGINT and SIGQUIT are ignored
2974 in asynchronous children. */
2977 if ((cmdflags & CMD_STDIN_REDIR) &&
2978 pipe_in == NO_PIPE &&
2979 (stdin_redirects (redirects) == 0))
2980 async_redirect_stdin ();
2981 setup_async_signals ();
2984 do_piping (pipe_in, pipe_out);
2988 old_interactive = interactive;
2992 subshell_environment = SUBSHELL_FORK;
2994 /* This functionality is now provided by close-on-exec of the
2995 file descriptors manipulated by redirection and piping.
2996 Some file descriptors still need to be closed in all children
2997 because of the way bash does pipes; fds_to_close is a
2998 bitmap of all such file descriptors. */
3000 close_fd_bitmap (fds_to_close);
3002 if (redirects && (do_redirections (redirects, 1, 0, 0) != 0))
3004 #if defined (PROCESS_SUBSTITUTION)
3005 /* Try to remove named pipes that may have been created as the
3006 result of redirections. */
3007 unlink_fifo_list ();
3008 #endif /* PROCESS_SUBSTITUTION */
3009 exit (EXECUTION_FAILURE);
3013 interactive = old_interactive;
3017 internal_error ("%s: command not found", pathname);
3018 exit (EX_NOTFOUND); /* Posix.2 says the exit status is 127 */
3021 /* Execve expects the command name to be in args[0]. So we
3022 leave it there, in the same format that the user used to
3024 args = word_list_to_argv (words, 0, 0, (int *)NULL);
3025 exit (shell_execve (command, args, export_env));
3029 /* Make sure that the pipes are closed in the parent. */
3030 close_pipes (pipe_in, pipe_out);
3031 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
3032 unlink_fifo_list ();
3038 #if !defined (HAVE_HASH_BANG_EXEC)
3039 /* If the operating system on which we're running does not handle
3040 the #! executable format, then help out. SAMPLE is the text read
3041 from the file, SAMPLE_LEN characters. COMMAND is the name of
3042 the script; it and ARGS, the arguments given by the user, will
3043 become arguments to the specified interpreter. ENV is the environment
3044 to pass to the interpreter.
3046 The word immediately following the #! is the interpreter to execute.
3047 A single argument to the interpreter is allowed. */
3049 execute_shell_script (sample, sample_len, command, args, env)
3050 unsigned char *sample;
3056 char *execname, *firstarg;
3057 int start, size_increment, larry;
3059 /* Find the name of the interpreter to exec. */
3060 for (i = 2; whitespace (sample[i]) && i < sample_len; i++)
3064 !whitespace (sample[i]) && sample[i] != '\n' && i < sample_len;
3069 execname = xmalloc (1 + larry);
3070 strncpy (execname, (char *)(sample + start), larry);
3071 execname[larry] = '\0';
3074 /* Now the argument, if any. */
3075 firstarg = (char *)NULL;
3077 whitespace (sample[i]) && sample[i] != '\n' && i < sample_len;
3081 /* If there is more text on the line, then it is an argument for the
3083 if (i < sample_len && sample[i] != '\n' && !whitespace (sample[i]))
3086 !whitespace (sample[i]) && sample[i] != '\n' && i < sample_len;
3090 firstarg = xmalloc (1 + larry);
3091 strncpy (firstarg, (char *)(sample + start), larry);
3092 firstarg[larry] = '\0';
3097 larry = array_len (args) + size_increment;
3099 args = (char **)xrealloc ((char *)args, (1 + larry) * sizeof (char *));
3101 for (i = larry - 1; i; i--)
3102 args[i] = args[i - size_increment];
3113 args[larry] = (char *)NULL;
3115 return (shell_execve (execname, args, env));
3117 #endif /* !HAVE_HASH_BANG_EXEC */
3120 initialize_subshell ()
3123 /* Forget about any aliases that we knew of. We are in a subshell. */
3124 delete_all_aliases ();
3127 #if defined (HISTORY)
3128 /* Forget about the history lines we have read. This is a non-interactive
3130 history_lines_this_session = 0;
3133 #if defined (JOB_CONTROL)
3134 /* Forget about the way job control was working. We are in a subshell. */
3135 without_job_control ();
3136 set_sigchld_handler ();
3137 #endif /* JOB_CONTROL */
3139 /* Reset the values of the shell flags and options. */
3140 reset_shell_flags ();
3141 reset_shell_options ();
3142 reset_shopt_options ();
3144 /* If we're not interactive, close the file descriptor from which we're
3145 reading the current shell script. */
3146 if (interactive_shell == 0)
3147 unset_bash_input (1);
3150 #if defined (HAVE_SETOSTYPE) && defined (_POSIX_SOURCE)
3151 # define SETOSTYPE(x) __setostype(x)
3153 # define SETOSTYPE(x)
3156 /* Call execve (), handling interpreting shell scripts, and handling
3159 shell_execve (command, args, env)
3166 SETOSTYPE (0); /* Some systems use for USG/POSIX semantics */
3167 execve (command, args, env);
3170 /* If we get to this point, then start checking out the file.
3171 Maybe it is something we can hack ourselves. */
3172 if (errno != ENOEXEC)
3175 if ((stat (command, &finfo) == 0) && (S_ISDIR (finfo.st_mode)))
3176 internal_error ("%s: is a directory", command);
3180 file_error (command);
3182 return ((i == ENOENT) ? EX_NOTFOUND : EX_NOEXEC); /* XXX Posix.2 says that exit status is 126 */
3185 /* This file is executable.
3186 If it begins with #!, then help out people with losing operating
3187 systems. Otherwise, check to see if it is a binary file by seeing
3188 if the first line (or up to 80 characters) are in the ASCII set.
3189 Execute the contents as shell commands. */
3190 fd = open (command, O_RDONLY);
3193 unsigned char sample[80];
3196 sample_len = read (fd, (char *)sample, 80);
3199 if (sample_len == 0)
3200 return (EXECUTION_SUCCESS);
3202 /* Is this supposed to be an executable script?
3203 If so, the format of the line is "#! interpreter [argument]".
3204 A single argument is allowed. The BSD kernel restricts
3205 the length of the entire line to 32 characters (32 bytes
3206 being the size of the BSD exec header), but we allow 80
3210 #if !defined (HAVE_HASH_BANG_EXEC)
3211 if (sample[0] == '#' && sample[1] == '!')
3212 return (execute_shell_script (sample, sample_len, command, args, env));
3215 if (check_binary_file (sample, sample_len))
3217 internal_error ("%s: cannot execute binary file", command);
3218 return (EX_BINARY_FILE);
3223 initialize_subshell ();
3225 set_sigint_handler ();
3227 /* Insert the name of this shell into the argument list. */
3228 larray = array_len (args) + 1;
3229 args = (char **)xrealloc ((char *)args, (1 + larray) * sizeof (char *));
3231 for (i = larray - 1; i; i--)
3232 args[i] = args[i - 1];
3234 args[0] = shell_name;
3236 args[larray] = (char *)NULL;
3238 if (args[0][0] == '-')
3241 #if defined (RESTRICTED_SHELL)
3243 change_flag ('r', FLAG_OFF);
3248 /* Can't free subshell_argv[0]; that is shell_name. */
3249 for (i = 1; i < subshell_argc; i++)
3250 free (subshell_argv[i]);
3251 free (subshell_argv);
3254 dispose_command (currently_executing_command); /* XXX */
3255 currently_executing_command = (COMMAND *)NULL;
3257 subshell_argc = larray;
3258 subshell_argv = args;
3259 subshell_envp = env;
3261 unbind_args (); /* remove the positional parameters */
3263 longjmp (subshell_top_level, 1);
3267 execute_intern_function (name, function)
3273 if (check_identifier (name, posixly_correct) == 0)
3275 if (posixly_correct && interactive_shell == 0)
3277 last_command_exit_value = EX_USAGE;
3278 jump_to_top_level (EXITPROG);
3280 return (EXECUTION_FAILURE);
3283 var = find_function (name->word);
3284 if (var && readonly_p (var))
3286 internal_error ("%s: readonly function", var->name);
3287 return (EXECUTION_FAILURE);
3290 bind_function (name->word, function);
3291 return (EXECUTION_SUCCESS);
3294 #if defined (INCLUDE_UNUSED)
3295 #if defined (PROCESS_SUBSTITUTION)
3299 register int i, fd_table_size;
3301 fd_table_size = getdtablesize ();
3302 if (fd_table_size > 256) /* clamp to a reasonable value */
3303 fd_table_size = 256;
3305 for (i = 3; i < fd_table_size; i++)
3308 #endif /* PROCESS_SUBSTITUTION */
3312 close_pipes (in, out)
3321 /* Redirect input and output to be from and to the specified pipes.
3322 NO_PIPE and REDIRECT_BOTH are handled correctly. */
3324 do_piping (pipe_in, pipe_out)
3325 int pipe_in, pipe_out;
3327 if (pipe_in != NO_PIPE)
3329 if (dup2 (pipe_in, 0) < 0)
3330 sys_error ("cannot duplicate fd %d to fd 0", pipe_in);
3334 setmode (0, O_TEXT);
3337 if (pipe_out != NO_PIPE)
3339 if (pipe_out != REDIRECT_BOTH)
3341 if (dup2 (pipe_out, 1) < 0)
3342 sys_error ("cannot duplicate fd %d to fd 1", pipe_out);
3343 if (pipe_out == 0 || pipe_out > 1)
3346 setmode (1, O_TEXT);
3351 if (dup2 (1, 2) < 0)
3352 sys_error ("cannot duplicate fd 1 to fd 2");
3354 setmode (1, O_TEXT);
3355 setmode (2, O_TEXT);