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 "bashline.h"
79
#include <tilde/tilde.h>
80
#include <glob/strmatch.h>
82
#if defined (__OPENNT)
83
# include <opennt/opennt.h>
86
#if !defined (HAVE_GETPW_DECLS)
87
extern struct passwd *getpwuid ();
88
#endif /* !HAVE_GETPW_DECLS */
94
#if defined (NO_MAIN_ENV_ARG)
95
extern char **environ; /* used if no third argument to main() */
98
extern char *dist_version, *release_status;
99
extern int patch_level, build_version;
100
extern int shell_level;
101
extern int subshell_environment;
102
extern int last_command_exit_value;
103
extern int line_number;
104
extern int expand_aliases;
105
extern int array_needs_making;
106
extern int gnu_error_format;
107
extern char *primary_prompt, *secondary_prompt;
108
extern char *this_command_name;
110
/* Non-zero means that this shell has already been run; i.e. you should
111
call shell_reinitialize () if you need to start afresh. */
112
int shell_initialized = 0;
114
COMMAND *global_command = (COMMAND *)NULL;
116
/* Information about the current user. */
117
struct user_info current_user =
119
(uid_t)-1, (uid_t)-1, (gid_t)-1, (gid_t)-1,
120
(char *)NULL, (char *)NULL, (char *)NULL
123
/* The current host's name. */
124
char *current_host_name = (char *)NULL;
126
/* Non-zero means that this shell is a login shell.
129
1 = login shell from getty (or equivalent fake out)
130
-1 = login shell from "--login" (or -l) flag.
131
-2 = both from getty, and from flag.
135
/* Non-zero means that at this moment, the shell is interactive. In
136
general, this means that the shell is at this moment reading input
137
from the keyboard. */
140
/* Non-zero means that the shell was started as an interactive shell. */
141
int interactive_shell = 0;
143
/* Non-zero means to send a SIGHUP to all jobs when an interactive login
147
/* Non-zero means to list status of running and stopped jobs at shell exit */
148
int check_jobs_at_exit = 0;
150
/* Non-zero means to change to a directory name supplied as a command name */
153
/* Tells what state the shell was in when it started:
154
0 = non-interactive shell script
157
3 = wordexp evaluation
158
This is a superset of the information provided by interactive_shell.
160
int startup_state = 0;
162
/* Special debugging helper. */
163
int debugging_login_shell = 0;
165
/* The environment that the shell passes to other commands. */
166
char **shell_environment;
168
/* Non-zero when we are executing a top-level command. */
171
/* The number of commands executed so far. */
172
int current_command_number = 1;
174
/* Non-zero is the recursion depth for commands. */
175
int indirection_level = 0;
177
/* The name of this shell, as taken from argv[0]. */
178
char *shell_name = (char *)NULL;
180
/* time in seconds when the shell was started */
181
time_t shell_start_time;
183
/* Are we running in an emacs shell window? */
184
int running_under_emacs;
186
/* Do we have /dev/fd? */
188
int have_devfd = HAVE_DEV_FD;
193
/* The name of the .(shell)rc file. */
194
static char *bashrc_file = "~/.bashrc";
196
/* Non-zero means to act more like the Bourne shell on startup. */
197
static int act_like_sh;
199
/* Non-zero if this shell is being run by `su'. */
202
/* Non-zero if we have already expanded and sourced $ENV. */
203
static int sourced_env;
205
/* Is this shell running setuid? */
206
static int running_setuid;
208
/* Values for the long-winded argument names. */
209
static int debugging; /* Do debugging things. */
210
static int no_rc; /* Don't execute ~/.bashrc */
211
static int no_profile; /* Don't execute .profile */
212
static int do_version; /* Display interesting version info. */
213
static int make_login_shell; /* Make this shell be a `-bash' shell. */
214
static int want_initial_help; /* --help option */
216
int debugging_mode = 0; /* In debugging mode with --debugger */
217
#if defined (READLINE)
218
int no_line_editing = 0; /* non-zero -> don't do fancy line editing. */
220
int no_line_editing = 1; /* can't have line editing without readline */
222
int dump_translatable_strings; /* Dump strings in $"...", don't execute. */
223
int dump_po_strings; /* Dump strings in $"..." in po format */
224
int wordexp_only = 0; /* Do word expansion only */
225
int protected_mode = 0; /* No command substitution with --wordexp */
227
#if defined (STRICT_POSIX)
228
int posixly_correct = 1; /* Non-zero means posix.2 superset. */
230
int posixly_correct = 0; /* Non-zero means posix.2 superset. */
233
/* Some long-winded argument names. These are obviously new. */
236
static const struct {
242
{ "debug", Int, &debugging, (char **)0x0 },
243
#if defined (DEBUGGER)
244
{ "debugger", Int, &debugging_mode, (char **)0x0 },
246
{ "dump-po-strings", Int, &dump_po_strings, (char **)0x0 },
247
{ "dump-strings", Int, &dump_translatable_strings, (char **)0x0 },
248
{ "help", Int, &want_initial_help, (char **)0x0 },
249
{ "init-file", Charp, (int *)0x0, &bashrc_file },
250
{ "login", Int, &make_login_shell, (char **)0x0 },
251
{ "noediting", Int, &no_line_editing, (char **)0x0 },
252
{ "noprofile", Int, &no_profile, (char **)0x0 },
253
{ "norc", Int, &no_rc, (char **)0x0 },
254
{ "posix", Int, &posixly_correct, (char **)0x0 },
255
#if defined (WORDEXP_OPTION)
256
{ "protected", Int, &protected_mode, (char **)0x0 },
258
{ "rcfile", Charp, (int *)0x0, &bashrc_file },
259
#if defined (RESTRICTED_SHELL)
260
{ "restricted", Int, &restricted, (char **)0x0 },
262
{ "verbose", Int, &echo_input_at_read, (char **)0x0 },
263
{ "version", Int, &do_version, (char **)0x0 },
264
#if defined (WORDEXP_OPTION)
265
{ "wordexp", Int, &wordexp_only, (char **)0x0 },
267
{ (char *)0x0, Int, (int *)0x0, (char **)0x0 }
270
/* These are extern so execute_simple_command can set them, and then
271
longjmp back to main to execute a shell script, instead of calling
272
main () again and resulting in indefinite, possibly fatal, stack
274
procenv_t subshell_top_level;
276
char **subshell_argv;
277
char **subshell_envp;
281
#if defined (BUFFERED_INPUT)
282
/* The file descriptor from which the shell is reading input. */
283
int default_buffered_input = -1;
286
/* The following two variables are not static so they can show up in $-. */
287
int read_from_stdin; /* -s flag supplied */
288
int want_pending_command; /* -c flag supplied */
290
/* This variable is not static so it can be bound to $BASH_EXECUTION_STRING */
291
char *command_execution_string; /* argument to -c option */
293
int malloc_trace_at_exit = 0;
295
static int shell_reinitialized = 0;
297
static FILE *default_input;
299
static STRING_INT_ALIST *shopt_alist;
300
static int shopt_ind = 0, shopt_len = 0;
302
static int parse_long_options __P((char **, int, int));
303
static int parse_shell_options __P((char **, int, int));
304
static int bind_args __P((char **, int, int, int));
306
static void start_debugger __P((void));
308
static void add_shopt_to_alist __P((char *, int));
309
static void run_shopt_alist __P((void));
311
static void execute_env_file __P((char *));
312
static void run_startup_files __P((void));
313
static int open_shell_script __P((char *));
314
static void set_bash_input __P((void));
315
static int run_one_command __P((char *));
316
#if defined (WORDEXP_OPTION)
317
static int run_wordexp __P((char *));
320
static int uidget __P((void));
322
static void init_interactive __P((void));
323
static void init_noninteractive __P((void));
324
static void init_interactive_script __P((void));
326
static void set_shell_name __P((char *));
327
static void shell_initialize __P((void));
328
static void shell_reinitialize __P((void));
330
static void show_shell_usage __P((FILE *, int));
334
_cygwin32_check_tmp ()
338
if (stat ("/tmp", &sb) < 0)
339
internal_warning (_("could not find /tmp, please create!"));
342
if (S_ISDIR (sb.st_mode) == 0)
343
internal_warning (_("/tmp must be a valid directory name"));
346
#endif /* __CYGWIN__ */
348
#if defined (NO_MAIN_ENV_ARG)
349
/* systems without third argument to main() */
354
#else /* !NO_MAIN_ENV_ARG */
356
main (argc, argv, env)
359
#endif /* !NO_MAIN_ENV_ARG */
362
int code, old_errexit_flag;
363
#if defined (RESTRICTED_SHELL)
366
volatile int locally_skip_execution;
367
volatile int arg_index, top_level_arg_index;
372
#endif /* __OPENNT */
378
USE_VAR(old_errexit_flag);
379
#if defined (RESTRICTED_SHELL)
383
/* Catch early SIGINTs. */
384
code = setjmp_nosigs (top_level);
390
#if defined (USING_BASH_MALLOC) && defined (DEBUG) && !defined (DISABLE_MALLOC_WRAPPERS)
392
malloc_set_register (1);
399
_cygwin32_check_tmp ();
400
#endif /* __CYGWIN__ */
402
/* Wait forever if we are debugging a login shell. */
403
while (debugging_login_shell) sleep (3);
405
set_default_locale ();
407
running_setuid = uidget ();
409
if (getenv ("POSIXLY_CORRECT") || getenv ("POSIX_PEDANTIC"))
412
#if defined (USE_GNU_MALLOC_LIBRARY)
413
mcheck (programming_error, (void (*) ())0);
414
#endif /* USE_GNU_MALLOC_LIBRARY */
416
if (setjmp (subshell_top_level))
418
argc = subshell_argc;
419
argv = subshell_argv;
424
shell_reinitialized = 0;
426
/* Initialize `local' variables for all `invocations' of main (). */
428
if (arg_index > argc)
430
command_execution_string = (char *)NULL;
431
want_pending_command = locally_skip_execution = read_from_stdin = 0;
432
default_input = stdin;
433
#if defined (BUFFERED_INPUT)
434
default_buffered_input = -1;
437
/* Fix for the `infinite process creation' bug when running shell scripts
438
from startup files on System V. */
439
login_shell = make_login_shell = 0;
441
/* If this shell has already been run, then reinitialize it to a
443
if (shell_initialized || shell_name)
445
/* Make sure that we do not infinitely recurse as a login shell. */
446
if (*shell_name == '-')
449
shell_reinitialize ();
450
if (setjmp_nosigs (top_level))
454
shell_environment = env;
455
set_shell_name (argv[0]);
456
shell_start_time = NOW; /* NOW now defined in general.h */
458
/* Parse argument flags from the input line. */
460
/* Find full word arguments first. */
461
arg_index = parse_long_options (argv, arg_index, argc);
463
if (want_initial_help)
465
show_shell_usage (stdout, 1);
466
exit (EXECUTION_SUCCESS);
471
show_shell_version (1);
472
exit (EXECUTION_SUCCESS);
475
/* All done with full word options; do standard shell option parsing.*/
476
this_command_name = shell_name; /* for error reporting */
477
arg_index = parse_shell_options (argv, arg_index, argc);
479
/* If user supplied the "--login" (or -l) flag, then set and invert
481
if (make_login_shell)
484
login_shell = -login_shell;
487
set_login_shell ("login_shell", login_shell != 0);
490
dump_translatable_strings = 1;
492
if (dump_translatable_strings)
493
read_but_dont_execute = 1;
495
if (running_setuid && privileged_mode == 0)
496
disable_priv_mode ();
498
/* Need to get the argument to a -c option processed in the
499
above loop. The next arg is a command to execute, and the
500
following args are $0...$n respectively. */
501
if (want_pending_command)
503
command_execution_string = argv[arg_index];
504
if (command_execution_string == 0)
506
report_error (_("%s: option requires an argument"), "-c");
511
this_command_name = (char *)NULL;
513
cmd_init(); /* initialize the command object caches */
515
/* First, let the outside world know about our interactive status.
516
A shell is interactive if the `-i' flag was given, or if all of
517
the following conditions are met:
519
no arguments remaining or the -s flag given
520
standard input is a terminal
521
standard error is a terminal
522
Refer to Posix.2, the description of the `sh' utility. */
524
if (forced_interactive || /* -i flag */
525
(!command_execution_string && /* No -c command and ... */
526
wordexp_only == 0 && /* No --wordexp and ... */
527
((arg_index == argc) || /* no remaining args or... */
528
read_from_stdin) && /* -s flag with args, and */
529
isatty (fileno (stdin)) && /* Input is a terminal and */
530
isatty (fileno (stderr)))) /* error output is a terminal. */
533
init_noninteractive ();
536
* Some systems have the bad habit of starting login shells with lots of open
537
* file descriptors. For instance, most systems that have picked up the
538
* pre-4.0 Sun YP code leave a file descriptor open each time you call one
539
* of the getpw* functions, and it's set to be open across execs. That
540
* means one for login, one for xterm, one for shelltool, etc. There are
541
* also systems that open persistent FDs to other agents or files as part
542
* of process startup; these need to be set to be close-on-exec.
544
if (login_shell && interactive_shell)
546
for (i = 3; i < 20; i++)
547
SET_CLOSE_ON_EXEC (i);
550
/* If we're in a strict Posix.2 mode, turn on interactive comments,
551
alias expansion in non-interactive shells, and other Posix.2 things. */
554
bind_variable ("POSIXLY_CORRECT", "y", 0);
555
sv_strict_posix ("POSIXLY_CORRECT");
558
/* Now we run the shopt_alist and process the options. */
562
/* From here on in, the shell must be a normal functioning shell.
563
Variables from the environment are expected to be set, etc. */
567
set_default_locale_vars ();
570
* M-x term -> TERM=eterm EMACS=22.1 (term:0.96) (eterm)
571
* M-x shell -> TERM=dumb EMACS=t (no line editing)
572
* M-x terminal -> TERM=emacs-em7955 EMACS= (line editing)
574
if (interactive_shell)
578
term = get_string_value ("TERM");
579
emacs = get_string_value ("EMACS");
581
/* Not sure any emacs terminal emulator sets TERM=emacs any more */
582
no_line_editing |= term && (STREQ (term, "emacs"));
583
no_line_editing |= emacs && emacs[0] == 't' && emacs[1] == '\0' && STREQ (term, "dumb");
585
/* running_under_emacs == 2 for `eterm' */
586
running_under_emacs = (emacs != 0) || (term && STREQN (term, "emacs", 5));
587
running_under_emacs += term && STREQN (term, "eterm", 5) && emacs && strstr (emacs, "term");
589
if (running_under_emacs)
590
gnu_error_format = 1;
593
top_level_arg_index = arg_index;
594
old_errexit_flag = exit_immediately_on_error;
596
/* Give this shell a place to longjmp to before executing the
597
startup files. This allows users to press C-c to abort the
599
code = setjmp (top_level);
602
if (code == EXITPROG || code == ERREXIT)
603
exit_shell (last_command_exit_value);
606
#if defined (JOB_CONTROL)
607
/* Reset job control, since run_startup_files turned it off. */
608
set_job_control (interactive_shell);
610
/* Reset value of `set -e', since it's turned off before running
611
the startup files. */
612
exit_immediately_on_error += old_errexit_flag;
613
locally_skip_execution++;
617
arg_index = top_level_arg_index;
619
/* Execute the start-up scripts. */
621
if (interactive_shell == 0)
623
unbind_variable ("PS1");
624
unbind_variable ("PS2");
627
/* This has already been done by init_noninteractive */
628
expand_aliases = posixly_correct;
633
change_flag ('i', FLAG_ON);
637
#if defined (RESTRICTED_SHELL)
638
/* Set restricted_shell based on whether the basename of $0 indicates that
639
the shell should be restricted or if the `-r' option was supplied at
641
restricted_shell = shell_is_restricted (shell_name);
643
/* If the `-r' option is supplied at invocation, make sure that the shell
644
is not in restricted mode when running the startup files. */
645
saverst = restricted;
649
/* The startup files are run with `set -e' temporarily disabled. */
650
if (locally_skip_execution == 0 && running_setuid == 0)
652
old_errexit_flag = exit_immediately_on_error;
653
exit_immediately_on_error = 0;
655
run_startup_files ();
656
exit_immediately_on_error += old_errexit_flag;
659
/* If we are invoked as `sh', turn on Posix mode. */
662
bind_variable ("POSIXLY_CORRECT", "y", 0);
663
sv_strict_posix ("POSIXLY_CORRECT");
666
#if defined (RESTRICTED_SHELL)
667
/* Turn on the restrictions after executing the startup files. This
668
means that `bash -r' or `set -r' invoked from a startup file will
669
turn on the restrictions after the startup files are executed. */
670
restricted = saverst || restricted;
671
if (shell_reinitialized == 0)
672
maybe_make_restricted (shell_name);
673
#endif /* RESTRICTED_SHELL */
675
#if defined (WORDEXP_OPTION)
679
last_command_exit_value = run_wordexp (argv[arg_index]);
680
exit_shell (last_command_exit_value);
684
if (command_execution_string)
686
arg_index = bind_args (argv, arg_index, argc, 0);
692
#if defined (ONESHOT)
694
run_one_command (command_execution_string);
695
exit_shell (last_command_exit_value);
697
with_input_from_string (command_execution_string, "-c");
698
goto read_and_execute;
699
#endif /* !ONESHOT */
702
/* Get possible input filename and set up default_buffered_input or
703
default_input as appropriate. */
704
if (arg_index != argc && read_from_stdin == 0)
706
open_shell_script (argv[arg_index]);
709
else if (interactive == 0)
710
/* In this mode, bash is reading a script from stdin, which is a
711
pipe or redirected file. */
712
#if defined (BUFFERED_INPUT)
713
default_buffered_input = fileno (stdin); /* == 0 */
715
setbuf (default_input, (char *)NULL);
716
#endif /* !BUFFERED_INPUT */
720
/* Bind remaining args to $1 ... $n */
721
arg_index = bind_args (argv, arg_index, argc, 1);
723
if (debugging_mode && locally_skip_execution == 0 && running_setuid == 0 && dollar_vars[1])
726
/* Do the things that should be done only for interactive shells. */
727
if (interactive_shell)
729
/* Set up for checking for presence of mail. */
733
#if defined (HISTORY)
734
/* Initialize the interactive history stuff. */
735
bash_initialize_history ();
736
/* Don't load the history from the history file if we've already
737
saved some lines in this session (e.g., by putting `history -s xx'
738
into one of the startup files). */
739
if (shell_initialized == 0 && history_lines_this_session == 0)
743
/* Initialize terminal state for interactive shells after the
744
.bash_profile and .bashrc are interpreted. */
748
#if !defined (ONESHOT)
750
#endif /* !ONESHOT */
752
shell_initialized = 1;
754
/* Read commands until exit condition. */
756
exit_shell (last_command_exit_value);
760
parse_long_options (argv, arg_start, arg_end)
762
int arg_start, arg_end;
764
int arg_index, longarg, i;
767
arg_index = arg_start;
768
while ((arg_index != arg_end) && (arg_string = argv[arg_index]) &&
769
(*arg_string == '-'))
773
/* Make --login equivalent to -login. */
774
if (arg_string[1] == '-' && arg_string[2])
780
for (i = 0; long_args[i].name; i++)
782
if (STREQ (arg_string + 1, long_args[i].name))
784
if (long_args[i].type == Int)
785
*long_args[i].int_value = 1;
786
else if (argv[++arg_index] == 0)
788
report_error (_("%s: option requires an argument"), long_args[i].name);
792
*long_args[i].char_value = argv[arg_index];
797
if (long_args[i].name == 0)
801
report_error (_("%s: invalid option"), argv[arg_index]);
802
show_shell_usage (stderr, 0);
805
break; /* No such argument. Maybe flag arg. */
815
parse_shell_options (argv, arg_start, arg_end)
817
int arg_start, arg_end;
820
int arg_character, on_or_off, next_arg, i;
821
char *o_option, *arg_string;
823
arg_index = arg_start;
824
while (arg_index != arg_end && (arg_string = argv[arg_index]) &&
825
(*arg_string == '-' || *arg_string == '+'))
827
/* There are flag arguments, so parse them. */
828
next_arg = arg_index + 1;
830
/* A single `-' signals the end of options. From the 4.3 BSD sh.
831
An option `--' means the same thing; this is the standard
832
getopt(3) meaning. */
833
if (arg_string[0] == '-' &&
834
(arg_string[1] == '\0' ||
835
(arg_string[1] == '-' && arg_string[2] == '\0')))
839
on_or_off = arg_string[0];
840
while (arg_character = arg_string[i++])
842
switch (arg_character)
845
want_pending_command = 1;
849
make_login_shell = 1;
857
o_option = argv[next_arg];
860
list_minus_o_opts (-1, (on_or_off == '-') ? 0 : 1);
863
if (set_minus_o_option (on_or_off, o_option) != EXECUTION_SUCCESS)
869
/* Since some of these can be overridden by the normal
870
interactive/non-interactive shell initialization or
871
initializing posix mode, we save the options and process
872
them after initialization. */
873
o_option = argv[next_arg];
876
shopt_listopt (o_option, (on_or_off == '-') ? 0 : 1);
879
add_shopt_to_alist (o_option, on_or_off);
884
dump_translatable_strings = 1;
888
if (change_flag (arg_character, on_or_off) == FLAG_ERROR)
890
report_error (_("%c%c: invalid option"), on_or_off, arg_character);
891
show_shell_usage (stderr, 0);
896
/* Can't do just a simple increment anymore -- what about
897
"bash -abouo emacs ignoreeof -hP"? */
898
arg_index = next_arg;
904
/* Exit the shell with status S. */
909
fflush (stdout); /* XXX */
912
/* Do trap[0] if defined. Allow it to override the exit status
914
if (signal_is_trapped (0))
915
s = run_exit_trap ();
917
#if defined (PROCESS_SUBSTITUTION)
919
#endif /* PROCESS_SUBSTITUTION */
921
#if defined (HISTORY)
922
if (remember_on_history)
923
maybe_save_shell_history ();
926
#if defined (COPROCESS_SUPPORT)
930
#if defined (JOB_CONTROL)
931
/* If the user has run `shopt -s huponexit', hangup all jobs when we exit
932
an interactive login shell. ksh does this unconditionally. */
933
if (interactive_shell && login_shell && hup_on_exit)
936
/* If this shell is interactive, terminate all stopped jobs and
937
restore the original terminal process group. Don't do this if we're
938
in a subshell and calling exit_shell after, for example, a failed
940
if (subshell_environment == 0)
942
#endif /* JOB_CONTROL */
944
/* Always return the exit status of the last command to our parent. */
948
/* A wrapper for exit that (optionally) can do other things, like malloc
949
statistics tracing. */
954
#if defined (MALLOC_DEBUG) && defined (USING_BASH_MALLOC)
955
if (malloc_trace_at_exit)
956
trace_malloc_stats (get_name_for_error (), (char *)NULL);
962
/* Exit a subshell, which includes calling the exit trap. We don't want to
963
do any more cleanup, since a subshell is created as an exact copy of its
972
/* Do trap[0] if defined. Allow it to override the exit status
974
if (signal_is_trapped (0))
975
s = run_exit_trap ();
980
/* Source the bash startup files. If POSIXLY_CORRECT is non-zero, we obey
981
the Posix.2 startup file rules: $ENV is expanded, and if the file it
982
names exists, that file is sourced. The Posix.2 rules are in effect
983
for interactive shells only. (section 4.56.5.3) */
985
/* Execute ~/.bashrc for most shells. Never execute it if
986
ACT_LIKE_SH is set, or if NO_RC is set.
988
If the executable file "/usr/gnu/src/bash/foo" contains:
995
COMMAND EXECUTE BASHRC
996
--------------------------------
1000
rsh machine ls YES (for rsh, which calls `bash -c')
1001
rsh machine foo YES (for shell started by rsh) NO (for foo!)
1008
execute_env_file (env_file)
1013
if (env_file && *env_file)
1015
fn = expand_string_unsplit_to_string (env_file, Q_DOUBLE_QUOTES);
1017
maybe_execute_file (fn, 1);
1023
run_startup_files ()
1025
#if defined (JOB_CONTROL)
1026
int old_job_control;
1028
int sourced_login, run_by_ssh;
1030
/* get the rshd/sshd case out of the way first. */
1031
if (interactive_shell == 0 && no_rc == 0 && login_shell == 0 &&
1032
act_like_sh == 0 && command_execution_string)
1034
#ifdef SSH_SOURCE_BASHRC
1035
run_by_ssh = (find_variable ("SSH_CLIENT") != (SHELL_VAR *)0) ||
1036
(find_variable ("SSH2_CLIENT") != (SHELL_VAR *)0);
1041
/* If we were run by sshd or we think we were run by rshd, execute
1042
~/.bashrc if we are a top-level shell. */
1043
if ((run_by_ssh || isnetconn (fileno (stdin))) && shell_level < 2)
1046
# if defined (__OPENNT)
1047
maybe_execute_file (_prefixInstallPath(SYS_BASHRC, NULL, 0), 1);
1049
maybe_execute_file (SYS_BASHRC, 1);
1052
maybe_execute_file (bashrc_file, 1);
1057
#if defined (JOB_CONTROL)
1058
/* Startup files should be run without job control enabled. */
1059
old_job_control = interactive_shell ? set_job_control (0) : 0;
1064
/* A shell begun with the --login (or -l) flag that is not in posix mode
1065
runs the login shell startup files, no matter whether or not it is
1066
interactive. If NON_INTERACTIVE_LOGIN_SHELLS is defined, run the
1067
startup files if argv[0][0] == '-' as well. */
1068
#if defined (NON_INTERACTIVE_LOGIN_SHELLS)
1069
if (login_shell && posixly_correct == 0)
1071
if (login_shell < 0 && posixly_correct == 0)
1074
/* We don't execute .bashrc for login shells. */
1077
/* Execute /etc/profile and one of the personal login shell
1078
initialization files. */
1079
if (no_profile == 0)
1081
maybe_execute_file (SYS_PROFILE, 1);
1083
if (act_like_sh) /* sh */
1084
maybe_execute_file ("~/.profile", 1);
1085
else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
1086
(maybe_execute_file ("~/.bash_login", 1) == 0)) /* bash */
1087
maybe_execute_file ("~/.profile", 1);
1093
/* A non-interactive shell not named `sh' and not in posix mode reads and
1094
executes commands from $BASH_ENV. If `su' starts a shell with `-c cmd'
1095
and `-su' as the name of the shell, we want to read the startup files.
1096
No other non-interactive shells read any startup files. */
1097
if (interactive_shell == 0 && !(su_shell && login_shell))
1099
if (posixly_correct == 0 && act_like_sh == 0 && privileged_mode == 0 &&
1101
execute_env_file (get_string_value ("BASH_ENV"));
1105
/* Interactive shell or `-su' shell. */
1106
if (posixly_correct == 0) /* bash, sh */
1108
if (login_shell && sourced_login++ == 0)
1110
/* We don't execute .bashrc for login shells. */
1113
/* Execute /etc/profile and one of the personal login shell
1114
initialization files. */
1115
if (no_profile == 0)
1117
maybe_execute_file (SYS_PROFILE, 1);
1119
if (act_like_sh) /* sh */
1120
maybe_execute_file ("~/.profile", 1);
1121
else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
1122
(maybe_execute_file ("~/.bash_login", 1) == 0)) /* bash */
1123
maybe_execute_file ("~/.profile", 1);
1128
if (act_like_sh == 0 && no_rc == 0)
1131
# if defined (__OPENNT)
1132
maybe_execute_file (_prefixInstallPath(SYS_BASHRC, NULL, 0), 1);
1134
maybe_execute_file (SYS_BASHRC, 1);
1137
maybe_execute_file (bashrc_file, 1);
1140
else if (act_like_sh && privileged_mode == 0 && sourced_env++ == 0)
1141
execute_env_file (get_string_value ("ENV"));
1143
else /* bash --posix, sh --posix */
1146
if (interactive_shell && privileged_mode == 0 && sourced_env++ == 0)
1147
execute_env_file (get_string_value ("ENV"));
1150
#if defined (JOB_CONTROL)
1151
set_job_control (old_job_control);
1155
#if defined (RESTRICTED_SHELL)
1156
/* Return 1 if the shell should be a restricted one based on NAME or the
1157
value of `restricted'. Don't actually do anything, just return a
1160
shell_is_restricted (name)
1167
temp = base_pathname (name);
1170
return (STREQ (temp, RESTRICTED_SHELL_NAME));
1173
/* Perhaps make this shell a `restricted' one, based on NAME. If the
1174
basename of NAME is "rbash", then this shell is restricted. The
1175
name of the restricted shell is a configurable option, see config.h.
1176
In a restricted shell, PATH, SHELL, ENV, and BASH_ENV are read-only
1178
Do this also if `restricted' is already set to 1; maybe the shell was
1181
maybe_make_restricted (name)
1186
temp = base_pathname (name);
1189
if (restricted || (STREQ (temp, RESTRICTED_SHELL_NAME)))
1191
set_var_read_only ("PATH");
1192
set_var_read_only ("SHELL");
1193
set_var_read_only ("ENV");
1194
set_var_read_only ("BASH_ENV");
1197
return (restricted);
1199
#endif /* RESTRICTED_SHELL */
1201
/* Fetch the current set of uids and gids and return 1 if we're running
1202
setuid or setgid. */
1209
if (current_user.uid != u)
1211
FREE (current_user.user_name);
1212
FREE (current_user.shell);
1213
FREE (current_user.home_dir);
1214
current_user.user_name = current_user.shell = current_user.home_dir = (char *)NULL;
1216
current_user.uid = u;
1217
current_user.gid = getgid ();
1218
current_user.euid = geteuid ();
1219
current_user.egid = getegid ();
1221
/* See whether or not we are running setuid or setgid. */
1222
return (current_user.uid != current_user.euid) ||
1223
(current_user.gid != current_user.egid);
1227
disable_priv_mode ()
1229
setuid (current_user.uid);
1230
setgid (current_user.gid);
1231
current_user.euid = current_user.uid;
1232
current_user.egid = current_user.gid;
1235
#if defined (WORDEXP_OPTION)
1241
WORD_LIST *wl, *tl, *result;
1243
code = setjmp_nosigs (top_level);
1245
if (code != NOT_JUMPED)
1249
/* Some kind of throw to top_level has occurred. */
1251
return last_command_exit_value = 127;
1254
return last_command_exit_value;
1256
return last_command_exit_value = 1;
1258
command_error ("run_wordexp", CMDERR_BADJUMP, code, 0);
1262
/* Run it through the parser to get a list of words and expand them */
1263
if (words && *words)
1265
with_input_from_string (words, "--wordexp");
1266
if (parse_command () != 0)
1268
if (global_command == 0)
1273
if (global_command->type != cm_simple)
1275
wl = global_command->value.Simple->words;
1277
for (tl = wl; tl; tl = tl->next)
1278
tl->word->flags |= W_NOCOMSUB|W_NOPROCSUB;
1279
result = wl ? expand_words_no_vars (wl) : (WORD_LIST *)0;
1282
result = (WORD_LIST *)0;
1284
last_command_exit_value = 0;
1292
/* Count up the number of words and bytes, and print them. Don't count
1293
the trailing NUL byte. */
1294
for (nw = nb = 0, wl = result; wl; wl = wl->next)
1297
nb += strlen (wl->word->word);
1299
printf ("%u\n%u\n", nw, nb);
1300
/* Print each word on a separate line. This will have to be changed when
1301
the interface to glibc is completed. */
1302
for (wl = result; wl; wl = wl->next)
1303
printf ("%s\n", wl->word->word);
1309
#if defined (ONESHOT)
1310
/* Run one command, given as the argument to the -c option. Tell
1311
parse_and_execute not to fork for a simple command. */
1313
run_one_command (command)
1318
code = setjmp_nosigs (top_level);
1320
if (code != NOT_JUMPED)
1322
#if defined (PROCESS_SUBSTITUTION)
1323
unlink_fifo_list ();
1324
#endif /* PROCESS_SUBSTITUTION */
1327
/* Some kind of throw to top_level has occurred. */
1329
return last_command_exit_value = 127;
1332
return last_command_exit_value;
1334
return last_command_exit_value = 1;
1336
command_error ("run_one_command", CMDERR_BADJUMP, code, 0);
1339
return (parse_and_execute (savestring (command), "-c", SEVAL_NOHIST));
1341
#endif /* ONESHOT */
1344
bind_args (argv, arg_start, arg_end, start_index)
1346
int arg_start, arg_end, start_index;
1351
for (i = arg_start, args = (WORD_LIST *)NULL; i < arg_end; i++)
1352
args = make_word_list (make_word (argv[i]), args);
1355
args = REVERSE_LIST (args, WORD_LIST *);
1356
if (start_index == 0) /* bind to $0...$n for sh -c command */
1358
/* Posix.2 4.56.3 says that the first argument after sh -c command
1359
becomes $0, and the rest of the arguments become $1...$n */
1360
shell_name = savestring (args->word->word);
1361
FREE (dollar_vars[0]);
1362
dollar_vars[0] = savestring (args->word->word);
1363
remember_args (args->next, 1);
1364
push_args (args->next); /* BASH_ARGV and BASH_ARGC */
1366
else /* bind to $1...$n for shell script */
1368
remember_args (args, 1);
1369
push_args (args); /* BASH_ARGV and BASH_ARGC */
1372
dispose_words (args);
1381
remember_args ((WORD_LIST *)NULL, 1);
1382
pop_args (); /* Reset BASH_ARGV and BASH_ARGC */
1388
#if defined (DEBUGGER) && defined (DEBUGGER_START_FILE)
1391
old_errexit = exit_immediately_on_error;
1392
exit_immediately_on_error = 0;
1394
maybe_execute_file (DEBUGGER_START_FILE, 1);
1395
function_trace_mode = 1;
1397
exit_immediately_on_error += old_errexit;
1402
open_shell_script (script_name)
1405
int fd, e, fd_is_tty;
1406
char *filename, *path_filename, *t;
1410
#if defined (ARRAY_VARS)
1411
SHELL_VAR *funcname_v, *bash_source_v, *bash_lineno_v;
1412
ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;
1415
filename = savestring (script_name);
1417
fd = open (filename, O_RDONLY);
1418
if ((fd < 0) && (errno == ENOENT) && (absolute_program (filename) == 0))
1421
/* If it's not in the current directory, try looking through PATH
1423
path_filename = find_path_file (script_name);
1427
filename = path_filename;
1428
fd = open (filename, O_RDONLY);
1437
file_error (filename);
1438
exit ((e == ENOENT) ? EX_NOTFOUND : EX_NOINPUT);
1441
free (dollar_vars[0]);
1442
dollar_vars[0] = exec_argv0 ? savestring (exec_argv0) : savestring (script_name);
1446
exec_argv0 = (char *)NULL;
1449
#if defined (ARRAY_VARS)
1450
GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
1451
GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
1452
GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v, bash_lineno_a);
1454
array_push (bash_source_a, filename);
1457
t = itos (executing_line_number ());
1458
array_push (bash_lineno_a, t);
1461
array_push (funcname_a, "main");
1465
fd_is_tty = isatty (fd);
1470
/* Only do this with non-tty file descriptors we can seek on. */
1471
if (fd_is_tty == 0 && (lseek (fd, 0L, 1) != -1))
1473
/* Check to see if the `file' in `bash file' is a binary file
1474
according to the same tests done by execute_simple_command (),
1475
and report an error and exit if it is. */
1476
sample_len = read (fd, sample, sizeof (sample));
1480
if ((fstat (fd, &sb) == 0) && S_ISDIR (sb.st_mode))
1481
internal_error (_("%s: is a directory"), filename);
1485
file_error (filename);
1489
else if (sample_len > 0 && (check_binary_file (sample, sample_len)))
1491
internal_error (_("%s: cannot execute binary file"), filename);
1492
exit (EX_BINARY_FILE);
1494
/* Now rewind the file back to the beginning. */
1498
/* Open the script. But try to move the file descriptor to a randomly
1499
large one, in the hopes that any descriptors used by the script will
1500
not match with ours. */
1501
fd = move_to_high_fd (fd, 1, -1);
1503
#if defined (BUFFERED_INPUT)
1504
default_buffered_input = fd;
1505
SET_CLOSE_ON_EXEC (default_buffered_input);
1506
#else /* !BUFFERED_INPUT */
1507
default_input = fdopen (fd, "r");
1509
if (default_input == 0)
1511
file_error (filename);
1515
SET_CLOSE_ON_EXEC (fd);
1516
if (fileno (default_input) != fd)
1517
SET_CLOSE_ON_EXEC (fileno (default_input));
1518
#endif /* !BUFFERED_INPUT */
1520
/* Just about the only way for this code to be executed is if something
1521
like `bash -i /dev/stdin' is executed. */
1522
if (interactive_shell && fd_is_tty)
1527
#if defined (BUFFERED_INPUT)
1528
default_buffered_input = 0;
1530
fclose (default_input);
1531
default_input = stdin;
1534
else if (forced_interactive && fd_is_tty == 0)
1535
/* But if a script is called with something like `bash -i scriptname',
1536
we need to do a non-interactive setup here, since we didn't do it
1538
init_interactive_script ();
1544
/* Initialize the input routines for the parser. */
1548
/* Make sure the fd from which we are reading input is not in
1550
#if defined (BUFFERED_INPUT)
1551
if (interactive == 0)
1552
sh_unset_nodelay_mode (default_buffered_input);
1554
#endif /* !BUFFERED_INPUT */
1555
sh_unset_nodelay_mode (fileno (stdin));
1557
/* with_input_from_stdin really means `with_input_from_readline' */
1558
if (interactive && no_line_editing == 0)
1559
with_input_from_stdin ();
1560
#if defined (BUFFERED_INPUT)
1561
else if (interactive == 0)
1562
with_input_from_buffered_stream (default_buffered_input, dollar_vars[0]);
1563
#endif /* BUFFERED_INPUT */
1565
with_input_from_stream (default_input, dollar_vars[0]);
1568
/* Close the current shell script input source and forget about it. This is
1569
extern so execute_cmd.c:initialize_subshell() can call it. If CHECK_ZERO
1570
is non-zero, we close default_buffered_input even if it's the standard
1573
unset_bash_input (check_zero)
1576
#if defined (BUFFERED_INPUT)
1577
if ((check_zero && default_buffered_input >= 0) ||
1578
(check_zero == 0 && default_buffered_input > 0))
1580
close_buffered_fd (default_buffered_input);
1581
default_buffered_input = bash_input.location.buffered_fd = -1;
1582
bash_input.type = st_none; /* XXX */
1584
#else /* !BUFFERED_INPUT */
1587
fclose (default_input);
1588
default_input = (FILE *)NULL;
1590
#endif /* !BUFFERED_INPUT */
1594
#if !defined (PROGRAM)
1595
# define PROGRAM "bash"
1599
set_shell_name (argv0)
1602
/* Here's a hack. If the name of this shell is "sh", then don't do
1603
any startup files; just try to be more like /bin/sh. */
1604
shell_name = argv0 ? base_pathname (argv0) : PROGRAM;
1606
if (argv0 && *argv0 == '-')
1608
if (*shell_name == '-')
1613
if (shell_name[0] == 's' && shell_name[1] == 'h' && shell_name[2] == '\0')
1615
if (shell_name[0] == 's' && shell_name[1] == 'u' && shell_name[2] == '\0')
1618
shell_name = argv0 ? argv0 : PROGRAM;
1619
FREE (dollar_vars[0]);
1620
dollar_vars[0] = savestring (shell_name);
1622
/* A program may start an interactive shell with
1623
"execl ("/bin/bash", "-", NULL)".
1624
If so, default the name of this shell to our name. */
1625
if (!shell_name || !*shell_name || (shell_name[0] == '-' && !shell_name[1]))
1626
shell_name = PROGRAM;
1632
expand_aliases = interactive_shell = startup_state = 1;
1637
init_noninteractive ()
1639
#if defined (HISTORY)
1640
bash_history_reinit (0);
1641
#endif /* HISTORY */
1642
interactive_shell = startup_state = interactive = 0;
1643
expand_aliases = posixly_correct; /* XXX - was 0 not posixly_correct */
1644
no_line_editing = 1;
1645
#if defined (JOB_CONTROL)
1646
/* Even if the shell is not interactive, enable job control if the -i or
1647
-m option is supplied at startup. */
1648
set_job_control (forced_interactive||jobs_m_flag);
1649
#endif /* JOB_CONTROL */
1653
init_interactive_script ()
1655
init_noninteractive ();
1656
expand_aliases = interactive_shell = startup_state = 1;
1660
get_current_user_info ()
1662
struct passwd *entry;
1664
/* Don't fetch this more than once. */
1665
if (current_user.user_name == 0)
1667
#if defined (__TANDEM)
1668
entry = getpwnam (getlogin ());
1670
entry = getpwuid (current_user.uid);
1674
current_user.user_name = savestring (entry->pw_name);
1675
current_user.shell = (entry->pw_shell && entry->pw_shell[0])
1676
? savestring (entry->pw_shell)
1677
: savestring ("/bin/sh");
1678
current_user.home_dir = savestring (entry->pw_dir);
1682
current_user.user_name = _("I have no name!");
1683
current_user.user_name = savestring (current_user.user_name);
1684
current_user.shell = savestring ("/bin/sh");
1685
current_user.home_dir = savestring ("/");
1691
/* Do whatever is necessary to initialize the shell.
1692
Put new initializations in here. */
1698
/* Line buffer output for stderr and stdout. */
1699
if (shell_initialized == 0)
1701
sh_setlinebuf (stderr);
1702
sh_setlinebuf (stdout);
1705
/* Sort the array of shell builtins so that the binary search in
1706
find_shell_builtin () works correctly. */
1707
initialize_shell_builtins ();
1709
/* Initialize the trap signal handlers before installing our own
1710
signal handlers. traps.c:restore_original_signals () is responsible
1711
for restoring the original default signal handlers. That function
1712
is called when we make a new child. */
1713
initialize_traps ();
1714
initialize_signals (0);
1716
/* It's highly unlikely that this will change. */
1717
if (current_host_name == 0)
1719
/* Initialize current_host_name. */
1720
if (gethostname (hostname, 255) < 0)
1721
current_host_name = "??host??";
1723
current_host_name = savestring (hostname);
1726
/* Initialize the stuff in current_user that comes from the password
1727
file. We don't need to do this right away if the shell is not
1729
if (interactive_shell)
1730
get_current_user_info ();
1732
/* Initialize our interface to the tilde expander. */
1733
tilde_initialize ();
1735
/* Initialize internal and environment variables. Don't import shell
1736
functions from the environment if we are running in privileged or
1737
restricted mode or if the shell is running setuid. */
1738
#if defined (RESTRICTED_SHELL)
1739
initialize_shell_variables (shell_environment, privileged_mode||restricted||running_setuid);
1741
initialize_shell_variables (shell_environment, privileged_mode||running_setuid);
1744
/* Initialize the data structures for storing and running jobs. */
1745
initialize_job_control (jobs_m_flag);
1747
/* Initialize input streams to null. */
1748
initialize_bash_input ();
1750
initialize_flags ();
1752
/* Initialize the shell options. Don't import the shell options
1753
from the environment variables $SHELLOPTS or $BASHOPTS if we are
1754
running in privileged or restricted mode or if the shell is running
1756
#if defined (RESTRICTED_SHELL)
1757
initialize_shell_options (privileged_mode||restricted||running_setuid);
1758
initialize_bashopts (privileged_mode||restricted||running_setuid);
1760
initialize_shell_options (privileged_mode||running_setuid);
1761
initialize_bashopts (privileged_mode||running_setuid);
1765
/* Function called by main () when it appears that the shell has already
1766
had some initialization performed. This is supposed to reset the world
1767
back to a pristine state, as if we had been exec'ed. */
1769
shell_reinitialize ()
1771
/* The default shell prompts. */
1772
primary_prompt = PPROMPT;
1773
secondary_prompt = SPROMPT;
1775
/* Things that get 1. */
1776
current_command_number = 1;
1778
/* We have decided that the ~/.bashrc file should not be executed
1779
for the invocation of each shell script. If the variable $ENV
1780
(or $BASH_ENV) is set, its value is used as the name of a file
1782
no_rc = no_profile = 1;
1784
/* Things that get 0. */
1785
login_shell = make_login_shell = interactive = executing = 0;
1786
debugging = do_version = line_number = last_command_exit_value = 0;
1787
forced_interactive = interactive_shell = subshell_environment = 0;
1790
/* XXX - should we set jobs_m_flag to 0 here? */
1792
#if defined (HISTORY)
1793
bash_history_reinit (0);
1794
#endif /* HISTORY */
1796
#if defined (RESTRICTED_SHELL)
1798
#endif /* RESTRICTED_SHELL */
1800
/* Ensure that the default startup file is used. (Except that we don't
1801
execute this file for reinitialized shells). */
1802
bashrc_file = "~/.bashrc";
1804
/* Delete all variables and functions. They will be reinitialized when
1805
the environment is parsed. */
1806
delete_all_contexts (shell_variables);
1807
delete_all_variables (shell_functions);
1809
reinit_special_variables ();
1811
#if defined (READLINE)
1812
bashline_reinitialize ();
1815
shell_reinitialized = 1;
1819
show_shell_usage (fp, extra)
1824
char *set_opts, *s, *t;
1827
fprintf (fp, _("GNU bash, version %s-(%s)\n"), shell_version_string (), MACHTYPE);
1828
fprintf (fp, _("Usage:\t%s [GNU long option] [option] ...\n\t%s [GNU long option] [option] script-file ...\n"),
1829
shell_name, shell_name);
1830
fputs (_("GNU long options:\n"), fp);
1831
for (i = 0; long_args[i].name; i++)
1832
fprintf (fp, "\t--%s\n", long_args[i].name);
1834
fputs (_("Shell options:\n"), fp);
1835
fputs (_("\t-ilrsD or -c command or -O shopt_option\t\t(invocation only)\n"), fp);
1837
for (i = 0, set_opts = 0; shell_builtins[i].name; i++)
1838
if (STREQ (shell_builtins[i].name, "set"))
1839
set_opts = savestring (shell_builtins[i].short_doc);
1842
s = strchr (set_opts, '[');
1847
t = strchr (s, ']');
1850
fprintf (fp, _("\t-%s or -o option\n"), s);
1856
fprintf (fp, _("Type `%s -c \"help set\"' for more information about shell options.\n"), shell_name);
1857
fprintf (fp, _("Type `%s -c help' for more information about shell builtin commands.\n"), shell_name);
1858
fprintf (fp, _("Use the `bashbug' command to report bugs.\n"));
1863
add_shopt_to_alist (opt, on_or_off)
1867
if (shopt_ind >= shopt_len)
1870
shopt_alist = (STRING_INT_ALIST *)xrealloc (shopt_alist, shopt_len * sizeof (shopt_alist[0]));
1872
shopt_alist[shopt_ind].word = opt;
1873
shopt_alist[shopt_ind].token = on_or_off;
1882
for (i = 0; i < shopt_ind; i++)
1883
if (shopt_setopt (shopt_alist[i].word, (shopt_alist[i].token == '-')) != EXECUTION_SUCCESS)
1887
shopt_ind = shopt_len = 0;
added
removed
.pc/privmode.diff/shell.c
