1 /* shell.c -- GNU's idea of the POSIX shell specification. */
3 /* Copyright (C) 1987-2012 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 Sunday, January 10th, 1988.
24 Initial author: Brian Fox
26 #define INSTALL_DEBUG_MODE
30 #include "bashtypes.h"
31 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
32 # include <sys/file.h>
34 #include "posixstat.h"
35 #include "posixtime.h"
43 #if defined (HAVE_UNISTD_H)
49 #define NEED_SH_SETLINEBUF_DECL /* used in externs.h */
54 #include "mailcheck.h"
56 #include "builtins/common.h"
58 #if defined (JOB_CONTROL)
60 #endif /* JOB_CONTROL */
63 #include "execute_cmd.h"
66 #if defined (USING_BASH_MALLOC) && defined (DEBUG) && !defined (DISABLE_MALLOC_WRAPPERS)
67 # include <malloc/shmalloc.h>
71 # include "bashhist.h"
72 # include <readline/history.h>
75 #if defined (READLINE)
76 # include <readline/readline.h>
77 # include "bashline.h"
80 #include <tilde/tilde.h>
81 #include <glob/strmatch.h>
83 #if defined (__OPENNT)
84 # include <opennt/opennt.h>
87 #if !defined (HAVE_GETPW_DECLS)
88 extern struct passwd
*getpwuid ();
89 #endif /* !HAVE_GETPW_DECLS */
95 #if defined (NO_MAIN_ENV_ARG)
96 extern char **environ
; /* used if no third argument to main() */
99 extern char *dist_version
, *release_status
;
100 extern int patch_level
, build_version
;
101 extern int shell_level
;
102 extern int subshell_environment
;
103 extern int running_in_background
;
104 extern int last_command_exit_value
;
105 extern int line_number
;
106 extern int expand_aliases
;
107 extern int array_needs_making
;
108 extern int gnu_error_format
;
109 extern char *primary_prompt
, *secondary_prompt
;
110 extern char *this_command_name
;
112 /* Non-zero means that this shell has already been run; i.e. you should
113 call shell_reinitialize () if you need to start afresh. */
114 int shell_initialized
= 0;
116 COMMAND
*global_command
= (COMMAND
*)NULL
;
118 /* Information about the current user. */
119 struct user_info current_user
=
121 (uid_t
)-1, (uid_t
)-1, (gid_t
)-1, (gid_t
)-1,
122 (char *)NULL
, (char *)NULL
, (char *)NULL
125 /* The current host's name. */
126 char *current_host_name
= (char *)NULL
;
128 /* Non-zero means that this shell is a login shell.
131 1 = login shell from getty (or equivalent fake out)
132 -1 = login shell from "--login" (or -l) flag.
133 -2 = both from getty, and from flag.
137 /* Non-zero means that at this moment, the shell is interactive. In
138 general, this means that the shell is at this moment reading input
139 from the keyboard. */
142 /* Non-zero means that the shell was started as an interactive shell. */
143 int interactive_shell
= 0;
145 /* Non-zero means to send a SIGHUP to all jobs when an interactive login
149 /* Non-zero means to list status of running and stopped jobs at shell exit */
150 int check_jobs_at_exit
= 0;
152 /* Non-zero means to change to a directory name supplied as a command name */
155 /* Tells what state the shell was in when it started:
156 0 = non-interactive shell script
159 3 = wordexp evaluation
160 This is a superset of the information provided by interactive_shell.
162 int startup_state
= 0;
164 /* Special debugging helper. */
165 int debugging_login_shell
= 0;
167 /* The environment that the shell passes to other commands. */
168 char **shell_environment
;
170 /* Non-zero when we are executing a top-level command. */
173 /* The number of commands executed so far. */
174 int current_command_number
= 1;
176 /* Non-zero is the recursion depth for commands. */
177 int indirection_level
= 0;
179 /* The name of this shell, as taken from argv[0]. */
180 char *shell_name
= (char *)NULL
;
182 /* time in seconds when the shell was started */
183 time_t shell_start_time
;
185 /* Are we running in an emacs shell window? */
186 int running_under_emacs
;
188 /* Do we have /dev/fd? */
190 int have_devfd
= HAVE_DEV_FD
;
195 /* The name of the .(shell)rc file. */
196 static char *bashrc_file
= DEFAULT_BASHRC
;
198 /* Non-zero means to act more like the Bourne shell on startup. */
199 static int act_like_sh
;
201 /* Non-zero if this shell is being run by `su'. */
204 /* Non-zero if we have already expanded and sourced $ENV. */
205 static int sourced_env
;
207 /* Is this shell running setuid? */
208 static int running_setuid
;
210 /* Values for the long-winded argument names. */
211 static int debugging
; /* Do debugging things. */
212 static int no_rc
; /* Don't execute ~/.bashrc */
213 static int no_profile
; /* Don't execute .profile */
214 static int do_version
; /* Display interesting version info. */
215 static int make_login_shell
; /* Make this shell be a `-bash' shell. */
216 static int want_initial_help
; /* --help option */
218 int debugging_mode
= 0; /* In debugging mode with --debugger */
219 #if defined (READLINE)
220 int no_line_editing
= 0; /* non-zero -> don't do fancy line editing. */
222 int no_line_editing
= 1; /* can't have line editing without readline */
224 int dump_translatable_strings
; /* Dump strings in $"...", don't execute. */
225 int dump_po_strings
; /* Dump strings in $"..." in po format */
226 int wordexp_only
= 0; /* Do word expansion only */
227 int protected_mode
= 0; /* No command substitution with --wordexp */
229 #if defined (STRICT_POSIX)
230 int posixly_correct
= 1; /* Non-zero means posix.2 superset. */
232 int posixly_correct
= 0; /* Non-zero means posix.2 superset. */
235 /* Some long-winded argument names. These are obviously new. */
238 static const struct {
244 { "debug", Int
, &debugging
, (char **)0x0 },
245 #if defined (DEBUGGER)
246 { "debugger", Int
, &debugging_mode
, (char **)0x0 },
248 { "dump-po-strings", Int
, &dump_po_strings
, (char **)0x0 },
249 { "dump-strings", Int
, &dump_translatable_strings
, (char **)0x0 },
250 { "help", Int
, &want_initial_help
, (char **)0x0 },
251 { "init-file", Charp
, (int *)0x0, &bashrc_file
},
252 { "login", Int
, &make_login_shell
, (char **)0x0 },
253 { "noediting", Int
, &no_line_editing
, (char **)0x0 },
254 { "noprofile", Int
, &no_profile
, (char **)0x0 },
255 { "norc", Int
, &no_rc
, (char **)0x0 },
256 { "posix", Int
, &posixly_correct
, (char **)0x0 },
257 #if defined (WORDEXP_OPTION)
258 { "protected", Int
, &protected_mode
, (char **)0x0 },
260 { "rcfile", Charp
, (int *)0x0, &bashrc_file
},
261 #if defined (RESTRICTED_SHELL)
262 { "restricted", Int
, &restricted
, (char **)0x0 },
264 { "verbose", Int
, &echo_input_at_read
, (char **)0x0 },
265 { "version", Int
, &do_version
, (char **)0x0 },
266 #if defined (WORDEXP_OPTION)
267 { "wordexp", Int
, &wordexp_only
, (char **)0x0 },
269 { (char *)0x0, Int
, (int *)0x0, (char **)0x0 }
272 /* These are extern so execute_simple_command can set them, and then
273 longjmp back to main to execute a shell script, instead of calling
274 main () again and resulting in indefinite, possibly fatal, stack
276 procenv_t subshell_top_level
;
278 char **subshell_argv
;
279 char **subshell_envp
;
283 #if defined (BUFFERED_INPUT)
284 /* The file descriptor from which the shell is reading input. */
285 int default_buffered_input
= -1;
288 /* The following two variables are not static so they can show up in $-. */
289 int read_from_stdin
; /* -s flag supplied */
290 int want_pending_command
; /* -c flag supplied */
292 /* This variable is not static so it can be bound to $BASH_EXECUTION_STRING */
293 char *command_execution_string
; /* argument to -c option */
295 int malloc_trace_at_exit
= 0;
297 static int shell_reinitialized
= 0;
299 static FILE *default_input
;
301 static STRING_INT_ALIST
*shopt_alist
;
302 static int shopt_ind
= 0, shopt_len
= 0;
304 static int parse_long_options
__P((char **, int, int));
305 static int parse_shell_options
__P((char **, int, int));
306 static int bind_args
__P((char **, int, int, int));
308 static void start_debugger
__P((void));
310 static void add_shopt_to_alist
__P((char *, int));
311 static void run_shopt_alist
__P((void));
313 static void execute_env_file
__P((char *));
314 static void run_startup_files
__P((void));
315 static int open_shell_script
__P((char *));
316 static void set_bash_input
__P((void));
317 static int run_one_command
__P((char *));
318 #if defined (WORDEXP_OPTION)
319 static int run_wordexp
__P((char *));
322 static int uidget
__P((void));
324 static void init_interactive
__P((void));
325 static void init_noninteractive
__P((void));
326 static void init_interactive_script
__P((void));
328 static void set_shell_name
__P((char *));
329 static void shell_initialize
__P((void));
330 static void shell_reinitialize
__P((void));
332 static void show_shell_usage
__P((FILE *, int));
336 _cygwin32_check_tmp ()
340 if (stat ("/tmp", &sb
) < 0)
341 internal_warning (_("could not find /tmp, please create!"));
344 if (S_ISDIR (sb
.st_mode
) == 0)
345 internal_warning (_("/tmp must be a valid directory name"));
348 #endif /* __CYGWIN__ */
350 #if defined (NO_MAIN_ENV_ARG)
351 /* systems without third argument to main() */
356 #else /* !NO_MAIN_ENV_ARG */
358 main (argc
, argv
, env
)
361 #endif /* !NO_MAIN_ENV_ARG */
364 int code
, old_errexit_flag
;
365 #if defined (RESTRICTED_SHELL)
368 volatile int locally_skip_execution
;
369 volatile int arg_index
, top_level_arg_index
;
374 #endif /* __OPENNT */
380 USE_VAR(old_errexit_flag
);
381 #if defined (RESTRICTED_SHELL)
385 /* Catch early SIGINTs. */
386 code
= setjmp_nosigs (top_level
);
392 #if defined (USING_BASH_MALLOC) && defined (DEBUG) && !defined (DISABLE_MALLOC_WRAPPERS)
394 malloc_set_register (1);
401 _cygwin32_check_tmp ();
402 #endif /* __CYGWIN__ */
404 /* Wait forever if we are debugging a login shell. */
405 while (debugging_login_shell
) sleep (3);
407 set_default_locale ();
409 running_setuid
= uidget ();
411 if (getenv ("POSIXLY_CORRECT") || getenv ("POSIX_PEDANTIC"))
414 #if defined (USE_GNU_MALLOC_LIBRARY)
415 mcheck (programming_error
, (void (*) ())0);
416 #endif /* USE_GNU_MALLOC_LIBRARY */
418 if (setjmp (subshell_top_level
))
420 argc
= subshell_argc
;
421 argv
= subshell_argv
;
426 shell_reinitialized
= 0;
428 /* Initialize `local' variables for all `invocations' of main (). */
430 if (arg_index
> argc
)
432 command_execution_string
= (char *)NULL
;
433 want_pending_command
= locally_skip_execution
= read_from_stdin
= 0;
434 default_input
= stdin
;
435 #if defined (BUFFERED_INPUT)
436 default_buffered_input
= -1;
439 /* Fix for the `infinite process creation' bug when running shell scripts
440 from startup files on System V. */
441 login_shell
= make_login_shell
= 0;
443 /* If this shell has already been run, then reinitialize it to a
445 if (shell_initialized
|| shell_name
)
447 /* Make sure that we do not infinitely recurse as a login shell. */
448 if (*shell_name
== '-')
451 shell_reinitialize ();
452 if (setjmp_nosigs (top_level
))
456 shell_environment
= env
;
457 set_shell_name (argv
[0]);
458 shell_start_time
= NOW
; /* NOW now defined in general.h */
460 /* Parse argument flags from the input line. */
462 /* Find full word arguments first. */
463 arg_index
= parse_long_options (argv
, arg_index
, argc
);
465 if (want_initial_help
)
467 show_shell_usage (stdout
, 1);
468 exit (EXECUTION_SUCCESS
);
473 show_shell_version (1);
474 exit (EXECUTION_SUCCESS
);
477 /* All done with full word options; do standard shell option parsing.*/
478 this_command_name
= shell_name
; /* for error reporting */
479 arg_index
= parse_shell_options (argv
, arg_index
, argc
);
481 /* If user supplied the "--login" (or -l) flag, then set and invert
483 if (make_login_shell
)
486 login_shell
= -login_shell
;
489 set_login_shell ("login_shell", login_shell
!= 0);
492 dump_translatable_strings
= 1;
494 if (dump_translatable_strings
)
495 read_but_dont_execute
= 1;
497 if (running_setuid
&& privileged_mode
== 0)
498 disable_priv_mode ();
500 /* Need to get the argument to a -c option processed in the
501 above loop. The next arg is a command to execute, and the
502 following args are $0...$n respectively. */
503 if (want_pending_command
)
505 command_execution_string
= argv
[arg_index
];
506 if (command_execution_string
== 0)
508 report_error (_("%s: option requires an argument"), "-c");
513 this_command_name
= (char *)NULL
;
515 cmd_init(); /* initialize the command object caches */
517 /* First, let the outside world know about our interactive status.
518 A shell is interactive if the `-i' flag was given, or if all of
519 the following conditions are met:
521 no arguments remaining or the -s flag given
522 standard input is a terminal
523 standard error is a terminal
524 Refer to Posix.2, the description of the `sh' utility. */
526 if (forced_interactive
|| /* -i flag */
527 (!command_execution_string
&& /* No -c command and ... */
528 wordexp_only
== 0 && /* No --wordexp and ... */
529 ((arg_index
== argc
) || /* no remaining args or... */
530 read_from_stdin
) && /* -s flag with args, and */
531 isatty (fileno (stdin
)) && /* Input is a terminal and */
532 isatty (fileno (stderr
)))) /* error output is a terminal. */
535 init_noninteractive ();
538 * Some systems have the bad habit of starting login shells with lots of open
539 * file descriptors. For instance, most systems that have picked up the
540 * pre-4.0 Sun YP code leave a file descriptor open each time you call one
541 * of the getpw* functions, and it's set to be open across execs. That
542 * means one for login, one for xterm, one for shelltool, etc. There are
543 * also systems that open persistent FDs to other agents or files as part
544 * of process startup; these need to be set to be close-on-exec.
546 if (login_shell
&& interactive_shell
)
548 for (i
= 3; i
< 20; i
++)
549 SET_CLOSE_ON_EXEC (i
);
552 /* If we're in a strict Posix.2 mode, turn on interactive comments,
553 alias expansion in non-interactive shells, and other Posix.2 things. */
556 bind_variable ("POSIXLY_CORRECT", "y", 0);
557 sv_strict_posix ("POSIXLY_CORRECT");
560 /* Now we run the shopt_alist and process the options. */
564 /* From here on in, the shell must be a normal functioning shell.
565 Variables from the environment are expected to be set, etc. */
569 set_default_locale_vars ();
572 * M-x term -> TERM=eterm EMACS=22.1 (term:0.96) (eterm)
573 * M-x shell -> TERM=dumb EMACS=t (no line editing)
574 * M-x terminal -> TERM=emacs-em7955 EMACS= (line editing)
576 if (interactive_shell
)
580 term
= get_string_value ("TERM");
581 emacs
= get_string_value ("EMACS");
583 /* Not sure any emacs terminal emulator sets TERM=emacs any more */
584 no_line_editing
|= term
&& (STREQ (term
, "emacs"));
585 no_line_editing
|= emacs
&& emacs
[0] == 't' && emacs
[1] == '\0' && STREQ (term
, "dumb");
587 /* running_under_emacs == 2 for `eterm' */
588 running_under_emacs
= (emacs
!= 0) || (term
&& STREQN (term
, "emacs", 5));
589 running_under_emacs
+= term
&& STREQN (term
, "eterm", 5) && emacs
&& strstr (emacs
, "term");
591 if (running_under_emacs
)
592 gnu_error_format
= 1;
595 top_level_arg_index
= arg_index
;
596 old_errexit_flag
= exit_immediately_on_error
;
598 /* Give this shell a place to longjmp to before executing the
599 startup files. This allows users to press C-c to abort the
601 code
= setjmp (top_level
);
604 if (code
== EXITPROG
|| code
== ERREXIT
)
605 exit_shell (last_command_exit_value
);
608 #if defined (JOB_CONTROL)
609 /* Reset job control, since run_startup_files turned it off. */
610 set_job_control (interactive_shell
);
612 /* Reset value of `set -e', since it's turned off before running
613 the startup files. */
614 exit_immediately_on_error
+= old_errexit_flag
;
615 locally_skip_execution
++;
619 arg_index
= top_level_arg_index
;
621 /* Execute the start-up scripts. */
623 if (interactive_shell
== 0)
625 unbind_variable ("PS1");
626 unbind_variable ("PS2");
629 /* This has already been done by init_noninteractive */
630 expand_aliases
= posixly_correct
;
635 change_flag ('i', FLAG_ON
);
639 #if defined (RESTRICTED_SHELL)
640 /* Set restricted_shell based on whether the basename of $0 indicates that
641 the shell should be restricted or if the `-r' option was supplied at
643 restricted_shell
= shell_is_restricted (shell_name
);
645 /* If the `-r' option is supplied at invocation, make sure that the shell
646 is not in restricted mode when running the startup files. */
647 saverst
= restricted
;
651 /* The startup files are run with `set -e' temporarily disabled. */
652 if (locally_skip_execution
== 0 && running_setuid
== 0)
654 old_errexit_flag
= exit_immediately_on_error
;
655 exit_immediately_on_error
= 0;
657 run_startup_files ();
658 exit_immediately_on_error
+= old_errexit_flag
;
661 /* If we are invoked as `sh', turn on Posix mode. */
664 bind_variable ("POSIXLY_CORRECT", "y", 0);
665 sv_strict_posix ("POSIXLY_CORRECT");
668 #if defined (RESTRICTED_SHELL)
669 /* Turn on the restrictions after executing the startup files. This
670 means that `bash -r' or `set -r' invoked from a startup file will
671 turn on the restrictions after the startup files are executed. */
672 restricted
= saverst
|| restricted
;
673 if (shell_reinitialized
== 0)
674 maybe_make_restricted (shell_name
);
675 #endif /* RESTRICTED_SHELL */
677 #if defined (WORDEXP_OPTION)
681 last_command_exit_value
= run_wordexp (argv
[arg_index
]);
682 exit_shell (last_command_exit_value
);
686 if (command_execution_string
)
688 arg_index
= bind_args (argv
, arg_index
, argc
, 0);
694 #if defined (ONESHOT)
696 run_one_command (command_execution_string
);
697 exit_shell (last_command_exit_value
);
699 with_input_from_string (command_execution_string
, "-c");
700 goto read_and_execute
;
701 #endif /* !ONESHOT */
704 /* Get possible input filename and set up default_buffered_input or
705 default_input as appropriate. */
706 if (arg_index
!= argc
&& read_from_stdin
== 0)
708 open_shell_script (argv
[arg_index
]);
711 else if (interactive
== 0)
712 /* In this mode, bash is reading a script from stdin, which is a
713 pipe or redirected file. */
714 #if defined (BUFFERED_INPUT)
715 default_buffered_input
= fileno (stdin
); /* == 0 */
717 setbuf (default_input
, (char *)NULL
);
718 #endif /* !BUFFERED_INPUT */
722 /* Bind remaining args to $1 ... $n */
723 arg_index
= bind_args (argv
, arg_index
, argc
, 1);
725 if (debugging_mode
&& locally_skip_execution
== 0 && running_setuid
== 0 && dollar_vars
[1])
728 /* Do the things that should be done only for interactive shells. */
729 if (interactive_shell
)
731 /* Set up for checking for presence of mail. */
735 #if defined (HISTORY)
736 /* Initialize the interactive history stuff. */
737 bash_initialize_history ();
738 /* Don't load the history from the history file if we've already
739 saved some lines in this session (e.g., by putting `history -s xx'
740 into one of the startup files). */
741 if (shell_initialized
== 0 && history_lines_this_session
== 0)
745 /* Initialize terminal state for interactive shells after the
746 .bash_profile and .bashrc are interpreted. */
750 #if !defined (ONESHOT)
752 #endif /* !ONESHOT */
754 shell_initialized
= 1;
756 /* Read commands until exit condition. */
758 exit_shell (last_command_exit_value
);
762 parse_long_options (argv
, arg_start
, arg_end
)
764 int arg_start
, arg_end
;
766 int arg_index
, longarg
, i
;
769 arg_index
= arg_start
;
770 while ((arg_index
!= arg_end
) && (arg_string
= argv
[arg_index
]) &&
771 (*arg_string
== '-'))
775 /* Make --login equivalent to -login. */
776 if (arg_string
[1] == '-' && arg_string
[2])
782 for (i
= 0; long_args
[i
].name
; i
++)
784 if (STREQ (arg_string
+ 1, long_args
[i
].name
))
786 if (long_args
[i
].type
== Int
)
787 *long_args
[i
].int_value
= 1;
788 else if (argv
[++arg_index
] == 0)
790 report_error (_("%s: option requires an argument"), long_args
[i
].name
);
794 *long_args
[i
].char_value
= argv
[arg_index
];
799 if (long_args
[i
].name
== 0)
803 report_error (_("%s: invalid option"), argv
[arg_index
]);
804 show_shell_usage (stderr
, 0);
807 break; /* No such argument. Maybe flag arg. */
817 parse_shell_options (argv
, arg_start
, arg_end
)
819 int arg_start
, arg_end
;
822 int arg_character
, on_or_off
, next_arg
, i
;
823 char *o_option
, *arg_string
;
825 arg_index
= arg_start
;
826 while (arg_index
!= arg_end
&& (arg_string
= argv
[arg_index
]) &&
827 (*arg_string
== '-' || *arg_string
== '+'))
829 /* There are flag arguments, so parse them. */
830 next_arg
= arg_index
+ 1;
832 /* A single `-' signals the end of options. From the 4.3 BSD sh.
833 An option `--' means the same thing; this is the standard
834 getopt(3) meaning. */
835 if (arg_string
[0] == '-' &&
836 (arg_string
[1] == '\0' ||
837 (arg_string
[1] == '-' && arg_string
[2] == '\0')))
841 on_or_off
= arg_string
[0];
842 while (arg_character
= arg_string
[i
++])
844 switch (arg_character
)
847 want_pending_command
= 1;
851 make_login_shell
= 1;
859 o_option
= argv
[next_arg
];
862 list_minus_o_opts (-1, (on_or_off
== '-') ? 0 : 1);
865 if (set_minus_o_option (on_or_off
, o_option
) != EXECUTION_SUCCESS
)
871 /* Since some of these can be overridden by the normal
872 interactive/non-interactive shell initialization or
873 initializing posix mode, we save the options and process
874 them after initialization. */
875 o_option
= argv
[next_arg
];
878 shopt_listopt (o_option
, (on_or_off
== '-') ? 0 : 1);
881 add_shopt_to_alist (o_option
, on_or_off
);
886 dump_translatable_strings
= 1;
890 if (change_flag (arg_character
, on_or_off
) == FLAG_ERROR
)
892 report_error (_("%c%c: invalid option"), on_or_off
, arg_character
);
893 show_shell_usage (stderr
, 0);
898 /* Can't do just a simple increment anymore -- what about
899 "bash -abouo emacs ignoreeof -hP"? */
900 arg_index
= next_arg
;
906 /* Exit the shell with status S. */
911 fflush (stdout
); /* XXX */
914 #if defined (READLINE)
915 if (RL_ISSTATE (RL_STATE_TERMPREPPED
) && rl_deprep_term_function
)
916 (*rl_deprep_term_function
) ();
919 /* Do trap[0] if defined. Allow it to override the exit status
921 if (signal_is_trapped (0))
922 s
= run_exit_trap ();
924 #if defined (PROCESS_SUBSTITUTION)
926 #endif /* PROCESS_SUBSTITUTION */
928 #if defined (HISTORY)
929 if (remember_on_history
)
930 maybe_save_shell_history ();
933 #if defined (COPROCESS_SUPPORT)
937 #if defined (JOB_CONTROL)
938 /* If the user has run `shopt -s huponexit', hangup all jobs when we exit
939 an interactive login shell. ksh does this unconditionally. */
940 if (interactive_shell
&& login_shell
&& hup_on_exit
)
943 /* If this shell is interactive, or job control is active, terminate all
944 stopped jobs and restore the original terminal process group. Don't do
945 this if we're in a subshell and calling exit_shell after, for example,
946 a failed word expansion. We want to do this even if the shell is not
947 interactive because we set the terminal's process group when job control
948 is enabled regardless of the interactive status. */
949 if (subshell_environment
== 0)
951 #endif /* JOB_CONTROL */
953 /* Always return the exit status of the last command to our parent. */
957 /* A wrapper for exit that (optionally) can do other things, like malloc
958 statistics tracing. */
963 #if defined (MALLOC_DEBUG) && defined (USING_BASH_MALLOC)
964 if (malloc_trace_at_exit
)
965 trace_malloc_stats (get_name_for_error (), (char *)NULL
);
971 /* Exit a subshell, which includes calling the exit trap. We don't want to
972 do any more cleanup, since a subshell is created as an exact copy of its
981 /* Do trap[0] if defined. Allow it to override the exit status
983 if (signal_is_trapped (0))
984 s
= run_exit_trap ();
989 /* Source the bash startup files. If POSIXLY_CORRECT is non-zero, we obey
990 the Posix.2 startup file rules: $ENV is expanded, and if the file it
991 names exists, that file is sourced. The Posix.2 rules are in effect
992 for interactive shells only. (section 4.56.5.3) */
994 /* Execute ~/.bashrc for most shells. Never execute it if
995 ACT_LIKE_SH is set, or if NO_RC is set.
997 If the executable file "/usr/gnu/src/bash/foo" contains:
1004 COMMAND EXECUTE BASHRC
1005 --------------------------------
1009 rsh machine ls YES (for rsh, which calls `bash -c')
1010 rsh machine foo YES (for shell started by rsh) NO (for foo!)
1017 execute_env_file (env_file
)
1022 if (env_file
&& *env_file
)
1024 fn
= expand_string_unsplit_to_string (env_file
, Q_DOUBLE_QUOTES
);
1026 maybe_execute_file (fn
, 1);
1032 run_startup_files ()
1034 #if defined (JOB_CONTROL)
1035 int old_job_control
;
1037 int sourced_login
, run_by_ssh
;
1039 /* get the rshd/sshd case out of the way first. */
1040 if (interactive_shell
== 0 && no_rc
== 0 && login_shell
== 0 &&
1041 act_like_sh
== 0 && command_execution_string
)
1043 #ifdef SSH_SOURCE_BASHRC
1044 run_by_ssh
= (find_variable ("SSH_CLIENT") != (SHELL_VAR
*)0) ||
1045 (find_variable ("SSH2_CLIENT") != (SHELL_VAR
*)0);
1050 /* If we were run by sshd or we think we were run by rshd, execute
1051 ~/.bashrc if we are a top-level shell. */
1052 if ((run_by_ssh
|| isnetconn (fileno (stdin
))) && shell_level
< 2)
1055 # if defined (__OPENNT)
1056 maybe_execute_file (_prefixInstallPath(SYS_BASHRC
, NULL
, 0), 1);
1058 maybe_execute_file (SYS_BASHRC
, 1);
1061 maybe_execute_file (bashrc_file
, 1);
1066 #if defined (JOB_CONTROL)
1067 /* Startup files should be run without job control enabled. */
1068 old_job_control
= interactive_shell
? set_job_control (0) : 0;
1073 /* A shell begun with the --login (or -l) flag that is not in posix mode
1074 runs the login shell startup files, no matter whether or not it is
1075 interactive. If NON_INTERACTIVE_LOGIN_SHELLS is defined, run the
1076 startup files if argv[0][0] == '-' as well. */
1077 #if defined (NON_INTERACTIVE_LOGIN_SHELLS)
1078 if (login_shell
&& posixly_correct
== 0)
1080 if (login_shell
< 0 && posixly_correct
== 0)
1083 /* We don't execute .bashrc for login shells. */
1086 /* Execute /etc/profile and one of the personal login shell
1087 initialization files. */
1088 if (no_profile
== 0)
1090 maybe_execute_file (SYS_PROFILE
, 1);
1092 if (act_like_sh
) /* sh */
1093 maybe_execute_file ("~/.profile", 1);
1094 else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
1095 (maybe_execute_file ("~/.bash_login", 1) == 0)) /* bash */
1096 maybe_execute_file ("~/.profile", 1);
1102 /* A non-interactive shell not named `sh' and not in posix mode reads and
1103 executes commands from $BASH_ENV. If `su' starts a shell with `-c cmd'
1104 and `-su' as the name of the shell, we want to read the startup files.
1105 No other non-interactive shells read any startup files. */
1106 if (interactive_shell
== 0 && !(su_shell
&& login_shell
))
1108 if (posixly_correct
== 0 && act_like_sh
== 0 && privileged_mode
== 0 &&
1110 execute_env_file (get_string_value ("BASH_ENV"));
1114 /* Interactive shell or `-su' shell. */
1115 if (posixly_correct
== 0) /* bash, sh */
1117 if (login_shell
&& sourced_login
++ == 0)
1119 /* We don't execute .bashrc for login shells. */
1122 /* Execute /etc/profile and one of the personal login shell
1123 initialization files. */
1124 if (no_profile
== 0)
1126 maybe_execute_file (SYS_PROFILE
, 1);
1128 if (act_like_sh
) /* sh */
1129 maybe_execute_file ("~/.profile", 1);
1130 else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
1131 (maybe_execute_file ("~/.bash_login", 1) == 0)) /* bash */
1132 maybe_execute_file ("~/.profile", 1);
1137 if (act_like_sh
== 0 && no_rc
== 0)
1140 # if defined (__OPENNT)
1141 maybe_execute_file (_prefixInstallPath(SYS_BASHRC
, NULL
, 0), 1);
1143 maybe_execute_file (SYS_BASHRC
, 1);
1146 maybe_execute_file (bashrc_file
, 1);
1149 else if (act_like_sh
&& privileged_mode
== 0 && sourced_env
++ == 0)
1150 execute_env_file (get_string_value ("ENV"));
1152 else /* bash --posix, sh --posix */
1155 if (interactive_shell
&& privileged_mode
== 0 && sourced_env
++ == 0)
1156 execute_env_file (get_string_value ("ENV"));
1159 #if defined (JOB_CONTROL)
1160 set_job_control (old_job_control
);
1164 #if defined (RESTRICTED_SHELL)
1165 /* Return 1 if the shell should be a restricted one based on NAME or the
1166 value of `restricted'. Don't actually do anything, just return a
1169 shell_is_restricted (name
)
1176 temp
= base_pathname (name
);
1179 return (STREQ (temp
, RESTRICTED_SHELL_NAME
));
1182 /* Perhaps make this shell a `restricted' one, based on NAME. If the
1183 basename of NAME is "rbash", then this shell is restricted. The
1184 name of the restricted shell is a configurable option, see config.h.
1185 In a restricted shell, PATH, SHELL, ENV, and BASH_ENV are read-only
1187 Do this also if `restricted' is already set to 1; maybe the shell was
1190 maybe_make_restricted (name
)
1195 temp
= base_pathname (name
);
1198 if (restricted
|| (STREQ (temp
, RESTRICTED_SHELL_NAME
)))
1200 set_var_read_only ("PATH");
1201 set_var_read_only ("SHELL");
1202 set_var_read_only ("ENV");
1203 set_var_read_only ("BASH_ENV");
1206 return (restricted
);
1208 #endif /* RESTRICTED_SHELL */
1210 /* Fetch the current set of uids and gids and return 1 if we're running
1211 setuid or setgid. */
1218 if (current_user
.uid
!= u
)
1220 FREE (current_user
.user_name
);
1221 FREE (current_user
.shell
);
1222 FREE (current_user
.home_dir
);
1223 current_user
.user_name
= current_user
.shell
= current_user
.home_dir
= (char *)NULL
;
1225 current_user
.uid
= u
;
1226 current_user
.gid
= getgid ();
1227 current_user
.euid
= geteuid ();
1228 current_user
.egid
= getegid ();
1230 /* See whether or not we are running setuid or setgid. */
1231 return (current_user
.uid
!= current_user
.euid
) ||
1232 (current_user
.gid
!= current_user
.egid
);
1236 disable_priv_mode ()
1240 if (setuid (current_user
.uid
) < 0)
1243 sys_error (_("cannot set uid to %d: effective uid %d"), current_user
.uid
, current_user
.euid
);
1244 #if defined (EXIT_ON_SETUID_FAILURE)
1249 if (setgid (current_user
.gid
) < 0)
1250 sys_error (_("cannot set gid to %d: effective gid %d"), current_user
.gid
, current_user
.egid
);
1252 current_user
.euid
= current_user
.uid
;
1253 current_user
.egid
= current_user
.gid
;
1256 #if defined (WORDEXP_OPTION)
1262 WORD_LIST
*wl
, *tl
, *result
;
1264 code
= setjmp_nosigs (top_level
);
1266 if (code
!= NOT_JUMPED
)
1270 /* Some kind of throw to top_level has occurred. */
1272 return last_command_exit_value
= 127;
1275 return last_command_exit_value
;
1277 return last_command_exit_value
= 1;
1279 command_error ("run_wordexp", CMDERR_BADJUMP
, code
, 0);
1283 /* Run it through the parser to get a list of words and expand them */
1284 if (words
&& *words
)
1286 with_input_from_string (words
, "--wordexp");
1287 if (parse_command () != 0)
1289 if (global_command
== 0)
1294 if (global_command
->type
!= cm_simple
)
1296 wl
= global_command
->value
.Simple
->words
;
1298 for (tl
= wl
; tl
; tl
= tl
->next
)
1299 tl
->word
->flags
|= W_NOCOMSUB
|W_NOPROCSUB
;
1300 result
= wl
? expand_words_no_vars (wl
) : (WORD_LIST
*)0;
1303 result
= (WORD_LIST
*)0;
1305 last_command_exit_value
= 0;
1313 /* Count up the number of words and bytes, and print them. Don't count
1314 the trailing NUL byte. */
1315 for (nw
= nb
= 0, wl
= result
; wl
; wl
= wl
->next
)
1318 nb
+= strlen (wl
->word
->word
);
1320 printf ("%u\n%u\n", nw
, nb
);
1321 /* Print each word on a separate line. This will have to be changed when
1322 the interface to glibc is completed. */
1323 for (wl
= result
; wl
; wl
= wl
->next
)
1324 printf ("%s\n", wl
->word
->word
);
1330 #if defined (ONESHOT)
1331 /* Run one command, given as the argument to the -c option. Tell
1332 parse_and_execute not to fork for a simple command. */
1334 run_one_command (command
)
1339 code
= setjmp_nosigs (top_level
);
1341 if (code
!= NOT_JUMPED
)
1343 #if defined (PROCESS_SUBSTITUTION)
1344 unlink_fifo_list ();
1345 #endif /* PROCESS_SUBSTITUTION */
1348 /* Some kind of throw to top_level has occurred. */
1350 return last_command_exit_value
= 127;
1353 return last_command_exit_value
;
1355 return last_command_exit_value
= 1;
1357 command_error ("run_one_command", CMDERR_BADJUMP
, code
, 0);
1360 return (parse_and_execute (savestring (command
), "-c", SEVAL_NOHIST
));
1362 #endif /* ONESHOT */
1365 bind_args (argv
, arg_start
, arg_end
, start_index
)
1367 int arg_start
, arg_end
, start_index
;
1372 for (i
= arg_start
, args
= (WORD_LIST
*)NULL
; i
< arg_end
; i
++)
1373 args
= make_word_list (make_word (argv
[i
]), args
);
1376 args
= REVERSE_LIST (args
, WORD_LIST
*);
1377 if (start_index
== 0) /* bind to $0...$n for sh -c command */
1379 /* Posix.2 4.56.3 says that the first argument after sh -c command
1380 becomes $0, and the rest of the arguments become $1...$n */
1381 shell_name
= savestring (args
->word
->word
);
1382 FREE (dollar_vars
[0]);
1383 dollar_vars
[0] = savestring (args
->word
->word
);
1384 remember_args (args
->next
, 1);
1385 push_args (args
->next
); /* BASH_ARGV and BASH_ARGC */
1387 else /* bind to $1...$n for shell script */
1389 remember_args (args
, 1);
1390 push_args (args
); /* BASH_ARGV and BASH_ARGC */
1393 dispose_words (args
);
1402 remember_args ((WORD_LIST
*)NULL
, 1);
1403 pop_args (); /* Reset BASH_ARGV and BASH_ARGC */
1409 #if defined (DEBUGGER) && defined (DEBUGGER_START_FILE)
1412 old_errexit
= exit_immediately_on_error
;
1413 exit_immediately_on_error
= 0;
1415 maybe_execute_file (DEBUGGER_START_FILE
, 1);
1416 function_trace_mode
= 1;
1418 exit_immediately_on_error
+= old_errexit
;
1423 open_shell_script (script_name
)
1426 int fd
, e
, fd_is_tty
;
1427 char *filename
, *path_filename
, *t
;
1431 #if defined (ARRAY_VARS)
1432 SHELL_VAR
*funcname_v
, *bash_source_v
, *bash_lineno_v
;
1433 ARRAY
*funcname_a
, *bash_source_a
, *bash_lineno_a
;
1436 filename
= savestring (script_name
);
1438 fd
= open (filename
, O_RDONLY
);
1439 if ((fd
< 0) && (errno
== ENOENT
) && (absolute_program (filename
) == 0))
1442 /* If it's not in the current directory, try looking through PATH
1444 path_filename
= find_path_file (script_name
);
1448 filename
= path_filename
;
1449 fd
= open (filename
, O_RDONLY
);
1458 file_error (filename
);
1459 exit ((e
== ENOENT
) ? EX_NOTFOUND
: EX_NOINPUT
);
1462 free (dollar_vars
[0]);
1463 dollar_vars
[0] = exec_argv0
? savestring (exec_argv0
) : savestring (script_name
);
1467 exec_argv0
= (char *)NULL
;
1470 #if defined (ARRAY_VARS)
1471 GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v
, funcname_a
);
1472 GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v
, bash_source_a
);
1473 GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v
, bash_lineno_a
);
1475 array_push (bash_source_a
, filename
);
1478 t
= itos (executing_line_number ());
1479 array_push (bash_lineno_a
, t
);
1482 array_push (funcname_a
, "main");
1486 fd_is_tty
= isatty (fd
);
1491 /* Only do this with non-tty file descriptors we can seek on. */
1492 if (fd_is_tty
== 0 && (lseek (fd
, 0L, 1) != -1))
1494 /* Check to see if the `file' in `bash file' is a binary file
1495 according to the same tests done by execute_simple_command (),
1496 and report an error and exit if it is. */
1497 sample_len
= read (fd
, sample
, sizeof (sample
));
1501 if ((fstat (fd
, &sb
) == 0) && S_ISDIR (sb
.st_mode
))
1502 internal_error (_("%s: is a directory"), filename
);
1506 file_error (filename
);
1510 else if (sample_len
> 0 && (check_binary_file (sample
, sample_len
)))
1512 internal_error (_("%s: cannot execute binary file"), filename
);
1513 exit (EX_BINARY_FILE
);
1515 /* Now rewind the file back to the beginning. */
1519 /* Open the script. But try to move the file descriptor to a randomly
1520 large one, in the hopes that any descriptors used by the script will
1521 not match with ours. */
1522 fd
= move_to_high_fd (fd
, 1, -1);
1524 #if defined (BUFFERED_INPUT)
1525 default_buffered_input
= fd
;
1526 SET_CLOSE_ON_EXEC (default_buffered_input
);
1527 #else /* !BUFFERED_INPUT */
1528 default_input
= fdopen (fd
, "r");
1530 if (default_input
== 0)
1532 file_error (filename
);
1536 SET_CLOSE_ON_EXEC (fd
);
1537 if (fileno (default_input
) != fd
)
1538 SET_CLOSE_ON_EXEC (fileno (default_input
));
1539 #endif /* !BUFFERED_INPUT */
1541 /* Just about the only way for this code to be executed is if something
1542 like `bash -i /dev/stdin' is executed. */
1543 if (interactive_shell
&& fd_is_tty
)
1548 #if defined (BUFFERED_INPUT)
1549 default_buffered_input
= 0;
1551 fclose (default_input
);
1552 default_input
= stdin
;
1555 else if (forced_interactive
&& fd_is_tty
== 0)
1556 /* But if a script is called with something like `bash -i scriptname',
1557 we need to do a non-interactive setup here, since we didn't do it
1559 init_interactive_script ();
1565 /* Initialize the input routines for the parser. */
1569 /* Make sure the fd from which we are reading input is not in
1571 #if defined (BUFFERED_INPUT)
1572 if (interactive
== 0)
1573 sh_unset_nodelay_mode (default_buffered_input
);
1575 #endif /* !BUFFERED_INPUT */
1576 sh_unset_nodelay_mode (fileno (stdin
));
1578 /* with_input_from_stdin really means `with_input_from_readline' */
1579 if (interactive
&& no_line_editing
== 0)
1580 with_input_from_stdin ();
1581 #if defined (BUFFERED_INPUT)
1582 else if (interactive
== 0)
1583 with_input_from_buffered_stream (default_buffered_input
, dollar_vars
[0]);
1584 #endif /* BUFFERED_INPUT */
1586 with_input_from_stream (default_input
, dollar_vars
[0]);
1589 /* Close the current shell script input source and forget about it. This is
1590 extern so execute_cmd.c:initialize_subshell() can call it. If CHECK_ZERO
1591 is non-zero, we close default_buffered_input even if it's the standard
1594 unset_bash_input (check_zero
)
1597 #if defined (BUFFERED_INPUT)
1598 if ((check_zero
&& default_buffered_input
>= 0) ||
1599 (check_zero
== 0 && default_buffered_input
> 0))
1601 close_buffered_fd (default_buffered_input
);
1602 default_buffered_input
= bash_input
.location
.buffered_fd
= -1;
1603 bash_input
.type
= st_none
; /* XXX */
1605 #else /* !BUFFERED_INPUT */
1608 fclose (default_input
);
1609 default_input
= (FILE *)NULL
;
1611 #endif /* !BUFFERED_INPUT */
1615 #if !defined (PROGRAM)
1616 # define PROGRAM "bash"
1620 set_shell_name (argv0
)
1623 /* Here's a hack. If the name of this shell is "sh", then don't do
1624 any startup files; just try to be more like /bin/sh. */
1625 shell_name
= argv0
? base_pathname (argv0
) : PROGRAM
;
1627 if (argv0
&& *argv0
== '-')
1629 if (*shell_name
== '-')
1634 if (shell_name
[0] == 's' && shell_name
[1] == 'h' && shell_name
[2] == '\0')
1636 if (shell_name
[0] == 's' && shell_name
[1] == 'u' && shell_name
[2] == '\0')
1639 shell_name
= argv0
? argv0
: PROGRAM
;
1640 FREE (dollar_vars
[0]);
1641 dollar_vars
[0] = savestring (shell_name
);
1643 /* A program may start an interactive shell with
1644 "execl ("/bin/bash", "-", NULL)".
1645 If so, default the name of this shell to our name. */
1646 if (!shell_name
|| !*shell_name
|| (shell_name
[0] == '-' && !shell_name
[1]))
1647 shell_name
= PROGRAM
;
1653 expand_aliases
= interactive_shell
= startup_state
= 1;
1658 init_noninteractive ()
1660 #if defined (HISTORY)
1661 bash_history_reinit (0);
1662 #endif /* HISTORY */
1663 interactive_shell
= startup_state
= interactive
= 0;
1664 expand_aliases
= posixly_correct
; /* XXX - was 0 not posixly_correct */
1665 no_line_editing
= 1;
1666 #if defined (JOB_CONTROL)
1667 /* Even if the shell is not interactive, enable job control if the -i or
1668 -m option is supplied at startup. */
1669 set_job_control (forced_interactive
||jobs_m_flag
);
1670 #endif /* JOB_CONTROL */
1674 init_interactive_script ()
1676 init_noninteractive ();
1677 expand_aliases
= interactive_shell
= startup_state
= 1;
1681 get_current_user_info ()
1683 struct passwd
*entry
;
1685 /* Don't fetch this more than once. */
1686 if (current_user
.user_name
== 0)
1688 #if defined (__TANDEM)
1689 entry
= getpwnam (getlogin ());
1691 entry
= getpwuid (current_user
.uid
);
1695 current_user
.user_name
= savestring (entry
->pw_name
);
1696 current_user
.shell
= (entry
->pw_shell
&& entry
->pw_shell
[0])
1697 ? savestring (entry
->pw_shell
)
1698 : savestring ("/bin/sh");
1699 current_user
.home_dir
= savestring (entry
->pw_dir
);
1703 current_user
.user_name
= _("I have no name!");
1704 current_user
.user_name
= savestring (current_user
.user_name
);
1705 current_user
.shell
= savestring ("/bin/sh");
1706 current_user
.home_dir
= savestring ("/");
1712 /* Do whatever is necessary to initialize the shell.
1713 Put new initializations in here. */
1719 /* Line buffer output for stderr and stdout. */
1720 if (shell_initialized
== 0)
1722 sh_setlinebuf (stderr
);
1723 sh_setlinebuf (stdout
);
1726 /* Sort the array of shell builtins so that the binary search in
1727 find_shell_builtin () works correctly. */
1728 initialize_shell_builtins ();
1730 /* Initialize the trap signal handlers before installing our own
1731 signal handlers. traps.c:restore_original_signals () is responsible
1732 for restoring the original default signal handlers. That function
1733 is called when we make a new child. */
1734 initialize_traps ();
1735 initialize_signals (0);
1737 /* It's highly unlikely that this will change. */
1738 if (current_host_name
== 0)
1740 /* Initialize current_host_name. */
1741 if (gethostname (hostname
, 255) < 0)
1742 current_host_name
= "??host??";
1744 current_host_name
= savestring (hostname
);
1747 /* Initialize the stuff in current_user that comes from the password
1748 file. We don't need to do this right away if the shell is not
1750 if (interactive_shell
)
1751 get_current_user_info ();
1753 /* Initialize our interface to the tilde expander. */
1754 tilde_initialize ();
1756 /* Initialize internal and environment variables. Don't import shell
1757 functions from the environment if we are running in privileged or
1758 restricted mode or if the shell is running setuid. */
1759 #if defined (RESTRICTED_SHELL)
1760 initialize_shell_variables (shell_environment
, privileged_mode
||restricted
||running_setuid
);
1762 initialize_shell_variables (shell_environment
, privileged_mode
||running_setuid
);
1765 /* Initialize the data structures for storing and running jobs. */
1766 initialize_job_control (jobs_m_flag
);
1768 /* Initialize input streams to null. */
1769 initialize_bash_input ();
1771 initialize_flags ();
1773 /* Initialize the shell options. Don't import the shell options
1774 from the environment variables $SHELLOPTS or $BASHOPTS if we are
1775 running in privileged or restricted mode or if the shell is running
1777 #if defined (RESTRICTED_SHELL)
1778 initialize_shell_options (privileged_mode
||restricted
||running_setuid
);
1779 initialize_bashopts (privileged_mode
||restricted
||running_setuid
);
1781 initialize_shell_options (privileged_mode
||running_setuid
);
1782 initialize_bashopts (privileged_mode
||running_setuid
);
1786 /* Function called by main () when it appears that the shell has already
1787 had some initialization performed. This is supposed to reset the world
1788 back to a pristine state, as if we had been exec'ed. */
1790 shell_reinitialize ()
1792 /* The default shell prompts. */
1793 primary_prompt
= PPROMPT
;
1794 secondary_prompt
= SPROMPT
;
1796 /* Things that get 1. */
1797 current_command_number
= 1;
1799 /* We have decided that the ~/.bashrc file should not be executed
1800 for the invocation of each shell script. If the variable $ENV
1801 (or $BASH_ENV) is set, its value is used as the name of a file
1803 no_rc
= no_profile
= 1;
1805 /* Things that get 0. */
1806 login_shell
= make_login_shell
= interactive
= executing
= 0;
1807 debugging
= do_version
= line_number
= last_command_exit_value
= 0;
1808 forced_interactive
= interactive_shell
= 0;
1809 subshell_environment
= running_in_background
= 0;
1812 /* XXX - should we set jobs_m_flag to 0 here? */
1814 #if defined (HISTORY)
1815 bash_history_reinit (0);
1816 #endif /* HISTORY */
1818 #if defined (RESTRICTED_SHELL)
1820 #endif /* RESTRICTED_SHELL */
1822 /* Ensure that the default startup file is used. (Except that we don't
1823 execute this file for reinitialized shells). */
1824 bashrc_file
= DEFAULT_BASHRC
;
1826 /* Delete all variables and functions. They will be reinitialized when
1827 the environment is parsed. */
1828 delete_all_contexts (shell_variables
);
1829 delete_all_variables (shell_functions
);
1831 reinit_special_variables ();
1833 #if defined (READLINE)
1834 bashline_reinitialize ();
1837 shell_reinitialized
= 1;
1841 show_shell_usage (fp
, extra
)
1846 char *set_opts
, *s
, *t
;
1849 fprintf (fp
, _("GNU bash, version %s-(%s)\n"), shell_version_string (), MACHTYPE
);
1850 fprintf (fp
, _("Usage:\t%s [GNU long option] [option] ...\n\t%s [GNU long option] [option] script-file ...\n"),
1851 shell_name
, shell_name
);
1852 fputs (_("GNU long options:\n"), fp
);
1853 for (i
= 0; long_args
[i
].name
; i
++)
1854 fprintf (fp
, "\t--%s\n", long_args
[i
].name
);
1856 fputs (_("Shell options:\n"), fp
);
1857 fputs (_("\t-ilrsD or -c command or -O shopt_option\t\t(invocation only)\n"), fp
);
1859 for (i
= 0, set_opts
= 0; shell_builtins
[i
].name
; i
++)
1860 if (STREQ (shell_builtins
[i
].name
, "set"))
1861 set_opts
= savestring (shell_builtins
[i
].short_doc
);
1864 s
= strchr (set_opts
, '[');
1869 t
= strchr (s
, ']');
1872 fprintf (fp
, _("\t-%s or -o option\n"), s
);
1878 fprintf (fp
, _("Type `%s -c \"help set\"' for more information about shell options.\n"), shell_name
);
1879 fprintf (fp
, _("Type `%s -c help' for more information about shell builtin commands.\n"), shell_name
);
1880 fprintf (fp
, _("Use the `bashbug' command to report bugs.\n"));
1885 add_shopt_to_alist (opt
, on_or_off
)
1889 if (shopt_ind
>= shopt_len
)
1892 shopt_alist
= (STRING_INT_ALIST
*)xrealloc (shopt_alist
, shopt_len
* sizeof (shopt_alist
[0]));
1894 shopt_alist
[shopt_ind
].word
= opt
;
1895 shopt_alist
[shopt_ind
].token
= on_or_off
;
1904 for (i
= 0; i
< shopt_ind
; i
++)
1905 if (shopt_setopt (shopt_alist
[i
].word
, (shopt_alist
[i
].token
== '-')) != EXECUTION_SUCCESS
)
1909 shopt_ind
= shopt_len
= 0;