# include <sys/file.h>
#endif
#include "posixstat.h"
+#include "posixtime.h"
#include "bashansi.h"
#include <stdio.h>
#include <signal.h>
# include <unistd.h>
#endif
+#define NEED_SH_SETLINEBUF_DECL /* used in externs.h */
+
#include "shell.h"
#include "flags.h"
#include "trap.h"
#endif
#include <tilde/tilde.h>
-#include <glob/fnmatch.h>
+#include <glob/strmatch.h>
#if defined (__OPENNT)
# include <opennt/opennt.h>
/* Information about the current user. */
struct user_info current_user =
{
- -1, -1, -1, -1, (char *)NULL, (char *)NULL, (char *)NULL
+ (uid_t)-1, (uid_t)-1, (gid_t)-1, (gid_t)-1,
+ (char *)NULL, (char *)NULL, (char *)NULL
};
/* The current host's name. */
{ "dump-po-strings", Int, &dump_po_strings, (char **)0x0 },
{ "dump-strings", Int, &dump_translatable_strings, (char **)0x0 },
{ "help", Int, &want_initial_help, (char **)0x0 },
+ { "init-file", Charp, (int *)0x0, &bashrc_file },
{ "login", Int, &make_login_shell, (char **)0x0 },
{ "noediting", Int, &no_line_editing, (char **)0x0 },
{ "noprofile", Int, &no_profile, (char **)0x0 },
int read_from_stdin; /* -s flag supplied */
int want_pending_command; /* -c flag supplied */
+static int shell_reinitialized = 0;
static char *local_pending_command;
static FILE *default_input;
-static int parse_long_options ();
-static int parse_shell_options ();
-static void run_startup_files ();
-static int bind_args ();
-static int open_shell_script ();
-static void set_bash_input ();
-static int run_one_command ();
-static int run_wordexp ();
+static STRING_INT_ALIST *shopt_alist;
+static int shopt_ind = 0, shopt_len = 0;
+
+static int parse_long_options __P((char **, int, int));
+static int parse_shell_options __P((char **, int, int));
+static int bind_args __P((char **, int, int, int));
+
+static void add_shopt_to_alist __P((char *, int));
+static void run_shopt_alist __P((void));
+
+static void execute_env_file __P((char *));
+static void run_startup_files __P((void));
+static int open_shell_script __P((char *));
+static void set_bash_input __P((void));
+static int run_one_command __P((char *));
+static int run_wordexp __P((char *));
+
+static int uidget __P((void));
+static int isnetconn __P((int));
-static int uidget ();
-static int isnetconn ();
+static void init_interactive __P((void));
+static void init_noninteractive __P((void));
-static void init_interactive (), init_noninteractive ();
-static void set_shell_name ();
-static void shell_initialize ();
-static void shell_reinitialize ();
+static void set_shell_name __P((char *));
+static void shell_initialize __P((void));
+static void shell_reinitialize __P((void));
-static void show_shell_usage ();
+static void show_shell_usage __P((FILE *, int));
-#ifdef __CYGWIN32__
+#ifdef __CYGWIN__
static void
_cygwin32_check_tmp ()
{
internal_warning ("/tmp must be a valid directory name");
}
}
-#endif /* __CYGWIN32__ */
+#endif /* __CYGWIN__ */
#if defined (NO_MAIN_ENV_ARG)
/* systems without third argument to main() */
#endif /* !NO_MAIN_ENV_ARG */
{
register int i;
- int code, saverst, old_errexit_flag;
+ int code, old_errexit_flag;
+#if defined (RESTRICTED_SHELL)
+ int saverst;
+#endif
volatile int locally_skip_execution;
volatile int arg_index, top_level_arg_index;
#ifdef __OPENNT
env = environ;
#endif /* __OPENNT */
+ USE_VAR(argc);
+ USE_VAR(argv);
+ USE_VAR(env);
+ USE_VAR(code);
+ USE_VAR(old_errexit_flag);
+#if defined (RESTRICTED_SHELL)
+ USE_VAR(saverst);
+#endif
+
/* Catch early SIGINTs. */
code = setjmp (top_level);
if (code)
exit (2);
+#if defined (USING_BASH_MALLOC) && defined (DEBUG)
+# if 0 /* memory tracing */
+ malloc_set_trace(1);
+# endif
+
+# if 0
+ malloc_set_register (1);
+# endif
+#endif
+
check_dev_tty ();
-#ifdef __CYGWIN32__
+#ifdef __CYGWIN__
_cygwin32_check_tmp ();
-#endif
+#endif /* __CYGWIN__ */
/* Wait forever if we are debugging a login shell. */
while (debugging_login_shell);
running_setuid = uidget ();
- posixly_correct = (getenv ("POSIXLY_CORRECT") != (char *)NULL) ||
- (getenv ("POSIX_PEDANTIC") != (char *)NULL);
+ if (getenv ("POSIXLY_CORRECT") || getenv ("POSIX_PEDANTIC"))
+ posixly_correct = 1;
#if defined (USE_GNU_MALLOC_LIBRARY)
mcheck (programming_error, (void (*) ())0);
sourced_env = 0;
}
+ shell_reinitialized = 0;
+
/* Initialize `local' variables for all `invocations' of main (). */
arg_index = 1;
local_pending_command = (char *)NULL;
login_shell = -login_shell;
}
+ set_login_shell (login_shell != 0);
+
/* All done with full word options; do standard shell option parsing.*/
this_command_name = shell_name; /* for error reporting */
arg_index = parse_shell_options (argv, arg_index, argc);
other Posix.2 things. */
if (posixly_correct)
{
- posix_initialize (posixly_correct);
-#if defined (READLINE)
- if (interactive_shell)
- posix_readline_initialize (posixly_correct);
-#endif
+ bind_variable ("POSIXLY_CORRECT", "y");
+ sv_strict_posix ("POSIXLY_CORRECT");
}
+ /* Now we run the shopt_alist and process the options. */
+ if (shopt_alist)
+ run_shopt_alist ();
+
/* From here on in, the shell must be a normal functioning shell.
Variables from the environment are expected to be set, etc. */
shell_initialize ();
term = getenv ("TERM");
no_line_editing |= term && (STREQ (term, "emacs"));
term = getenv ("EMACS");
- running_under_emacs = term ? ((fnmatch ("*term*", term, 0) == 0) ? 2 : 1)
+ running_under_emacs = term ? ((strmatch ("*term*", term, 0) == 0) ? 2 : 1)
: 0;
}
{
makunbound ("PS1", shell_variables);
makunbound ("PS2", shell_variables);
- interactive = expand_aliases = 0;
+ interactive = 0;
+ expand_aliases = posixly_correct;
}
else
{
exit_immediately_on_error = 0;
run_startup_files ();
-
exit_immediately_on_error += old_errexit_flag;
}
/* If we are invoked as `sh', turn on Posix mode. */
if (act_like_sh)
{
- posix_initialize (posixly_correct = 1);
-#if defined (READLINE)
- if (interactive_shell)
- posix_readline_initialize (posixly_correct);
-#endif
+ bind_variable ("POSIXLY_CORRECT", "y");
+ sv_strict_posix ("POSIXLY_CORRECT");
}
#if defined (RESTRICTED_SHELL)
means that `bash -r' or `set -r' invoked from a startup file will
turn on the restrictions after the startup files are executed. */
restricted = saverst || restricted;
- maybe_make_restricted (shell_name);
+ if (shell_reinitialized == 0)
+ maybe_make_restricted (shell_name);
#endif /* RESTRICTED_SHELL */
if (wordexp_only)
if (local_pending_command)
{
arg_index = bind_args (argv, arg_index, argc, 0);
-
startup_state = 2;
#if defined (ONESHOT)
+ executing = 1;
run_one_command (local_pending_command);
exit_shell (last_command_exit_value);
#else /* ONESHOT */
/* Bind remaining args to $1 ... $n */
arg_index = bind_args (argv, arg_index, argc, 1);
-
/* Do the things that should be done only for interactive shells. */
if (interactive_shell)
{
next_arg++;
break;
+ case 'O':
+ /* Since some of these can be overridden by the normal
+ interactive/non-interactive shell initialization or
+ initializing posix mode, we save the options and process
+ them after initialization. */
+ o_option = argv[next_arg];
+ if (o_option == 0)
+ {
+ shopt_listopt (o_option, (on_or_off == '-') ? 0 : 1);
+ break;
+ }
+ add_shopt_to_alist (o_option, on_or_off);
+ next_arg++;
+ break;
+
case 'D':
dump_translatable_strings = 1;
break;
hangup_all_jobs ();
/* If this shell is interactive, terminate all stopped jobs and
- restore the original terminal process group. */
- end_job_control ();
+ restore the original terminal process group. Don't do this if we're
+ in a subshell and calling exit_shell after, for example, a failed
+ word expansion. */
+ if (subshell_environment == 0)
+ end_job_control ();
#endif /* JOB_CONTROL */
/* Always return the exit status of the last command to our parent. */
exit (s);
}
+#ifdef INCLUDE_UNUSED
/* A wrapper for exit that (optionally) can do other things, like malloc
statistics tracing. */
void
{
exit (s);
}
+#endif
/* Source the bash startup files. If POSIXLY_CORRECT is non-zero, we obey
the Posix.2 startup file rules: $ENV is expanded, and if the file it
then:
- COMMAND EXECUTE BASHRC
- --------------------------------
- bash -c foo NO
- bash foo NO
- foo NO
- rsh machine ls YES (for rsh, which calls `bash -c')
- rsh machine foo YES (for shell started by rsh) NO (for foo!)
- echo ls | bash NO
- login NO
- bash YES
+ COMMAND EXECUTE BASHRC
+ --------------------------------
+ bash -c foo NO
+ bash foo NO
+ foo NO
+ rsh machine ls YES (for rsh, which calls `bash -c')
+ rsh machine foo YES (for shell started by rsh) NO (for foo!)
+ echo ls | bash NO
+ login NO
+ bash YES
*/
static void
char *env_file;
{
char *fn;
- WORD_LIST *list;
if (env_file && *env_file)
{
- list = expand_string_unsplit (env_file, Q_DOUBLE_QUOTES);
- if (list)
- {
- fn = string_list (list);
- dispose_words (list);
-
- if (fn && *fn)
- maybe_execute_file (fn, 1);
- FREE (fn);
- }
+ fn = expand_string_unsplit_to_string (env_file, Q_DOUBLE_QUOTES);
+ if (fn && *fn)
+ maybe_execute_file (fn, 1);
+ FREE (fn);
}
}
if (interactive_shell == 0 && no_rc == 0 && login_shell == 0 &&
act_like_sh == 0 && local_pending_command)
{
- run_by_ssh = find_variable ("SSH_CLIENT") != (SHELL_VAR *)0;
- run_by_ssh |= find_variable ("SSH2_CLIENT") != (SHELL_VAR *)0;
+#ifdef SSH_SOURCE_BASHRC
+ run_by_ssh = (find_variable ("SSH_CLIENT") != (SHELL_VAR *)0) ||
+ (find_variable ("SSH2_CLIENT") != (SHELL_VAR *)0);
+#else
+ run_by_ssh = 0;
+#endif
/* If we were run by sshd or we think we were run by rshd, execute
~/.bashrc if we are a top-level shell. */
maybe_execute_file (SYS_BASHRC, 1);
# endif
#endif
- maybe_execute_file (bashrc_file, 1);
+ maybe_execute_file (bashrc_file, 1);
}
/* sh */
else if (act_like_sh && privileged_mode == 0 && sourced_env++ == 0)
- execute_env_file (get_string_value ("ENV"));
+ execute_env_file (get_string_value ("ENV"));
}
else /* bash --posix, sh --posix */
{
/* bash and sh */
if (interactive_shell && privileged_mode == 0 && sourced_env++ == 0)
- execute_env_file (get_string_value ("ENV"));
+ execute_env_file (get_string_value ("ENV"));
}
#if defined (JOB_CONTROL)
set_var_read_only ("SHELL");
set_var_read_only ("ENV");
set_var_read_only ("BASH_ENV");
- restricted++;
+ restricted = 1;
}
return (restricted);
}
char *words;
{
int code, nw, nb;
- WORD_DESC *w;
WORD_LIST *wl, *result;
code = setjmp (top_level);
{
with_input_from_string (words, "--wordexp");
if (parse_command () != 0)
- return (126);
+ return (126);
if (global_command == 0)
{
printf ("0\n0\n");
return (0);
}
if (global_command->type != cm_simple)
- return (126);
+ return (126);
wl = global_command->value.Simple->words;
result = wl ? expand_words_no_vars (wl) : (WORD_LIST *)0;
}
remember_args (args->next, 1);
}
else /* bind to $1...$n for shell script */
- remember_args (args, 1);
+ remember_args (args, 1);
dispose_words (args);
}
open_shell_script (script_name)
char *script_name;
{
- int fd, e;
+ int fd, e, fd_is_tty;
char *filename, *path_filename;
- unsigned char sample[80];
+ char sample[80];
int sample_len;
struct stat sb;
exit ((e == ENOENT) ? EX_NOTFOUND : EX_NOINPUT);
}
- /* Only do this with file descriptors we can seek on. */
- if (lseek (fd, 0L, 1) != -1)
+#ifdef HAVE_DEV_FD
+ fd_is_tty = isatty (fd);
+#else
+ fd_is_tty = 0;
+#endif
+
+ /* Only do this with non-tty file descriptors we can seek on. */
+ if (fd_is_tty == 0 && (lseek (fd, 0L, 1) != -1))
{
/* Check to see if the `file' in `bash file' is a binary file
according to the same tests done by execute_simple_command (),
e = errno;
if ((fstat (fd, &sb) == 0) && S_ISDIR (sb.st_mode))
internal_error ("%s: is a directory", filename);
- else
+ else
{
errno = e;
file_error (filename);
not match with ours. */
fd = move_to_high_fd (fd, 0, -1);
+#if defined (__CYGWIN__) && defined (O_TEXT)
+ setmode (fd, O_TEXT);
+#endif
+
#if defined (BUFFERED_INPUT)
default_buffered_input = fd;
-# if 0
- /* This is never executed. */
- if (default_buffered_input == -1)
- {
- file_error (filename);
- exit (EX_NOTFOUND);
- }
-# endif
SET_CLOSE_ON_EXEC (default_buffered_input);
#else /* !BUFFERED_INPUT */
default_input = fdopen (fd, "r");
SET_CLOSE_ON_EXEC (fileno (default_input));
#endif /* !BUFFERED_INPUT */
- if (interactive_shell == 0 || isatty (fd) == 0)
- /* XXX - does this really need to be called again here? */
- init_noninteractive ();
- else
+ /* Just about the only way for this code to be executed is if something
+ like `bash -i /dev/stdin' is executed. */
+ if (interactive_shell && fd_is_tty)
{
- /* I don't believe that this code is ever executed, even in
- the presence of /dev/fd. */
dup2 (fd, 0);
close (fd);
fd = 0;
default_input = stdin;
#endif
}
+ else if (forced_interactive && fd_is_tty == 0)
+ /* But if a script is called with something like `bash -i scriptname',
+ we need to do a non-interactive setup here, since we didn't do it
+ before. */
+ init_noninteractive ();
+
free (filename);
return (fd);
}
no-delay mode. */
#if defined (BUFFERED_INPUT)
if (interactive == 0)
- unset_nodelay_mode (default_buffered_input);
+ sh_unset_nodelay_mode (default_buffered_input);
else
#endif /* !BUFFERED_INPUT */
- unset_nodelay_mode (fileno (stdin));
+ sh_unset_nodelay_mode (fileno (stdin));
/* with_input_from_stdin really means `with_input_from_readline' */
if (interactive && no_line_editing == 0)
delete_all_variables (shell_variables);
delete_all_variables (shell_functions);
-#if 0
- /* Pretend the PATH variable has changed. */
- flush_hashed_filenames ();
-#endif
+ shell_reinitialized = 1;
}
static void
fprintf (fp, "\t--%s\n", long_args[i].name);
fputs ("Shell options:\n", fp);
- fputs ("\t-irsD or -c command\t\t(invocation only)\n", fp);
+ fputs ("\t-irsD or -c command or -O shopt_option\t\t(invocation only)\n", fp);
for (i = 0, set_opts = 0; shell_builtins[i].name; i++)
if (STREQ (shell_builtins[i].name, "set"))
}
}
+static void
+add_shopt_to_alist (opt, on_or_off)
+ char *opt;
+ int on_or_off;
+{
+ if (shopt_ind >= shopt_len)
+ {
+ shopt_len += 8;
+ shopt_alist = (STRING_INT_ALIST *)xrealloc (shopt_alist, shopt_len * sizeof (shopt_alist[0]));
+ }
+ shopt_alist[shopt_ind].word = opt;
+ shopt_alist[shopt_ind].token = on_or_off;
+ shopt_ind++;
+}
+
+static void
+run_shopt_alist ()
+{
+ register int i;
+
+ for (i = 0; i < shopt_ind; i++)
+ if (shopt_setopt (shopt_alist[i].word, (shopt_alist[i].token == '-')) != EXECUTION_SUCCESS)
+ exit (EX_USAGE);
+ free (shopt_alist);
+ shopt_alist = 0;
+ shopt_ind = shopt_len = 0;
+}
+
/* The second and subsequent conditions must match those used to decide
whether or not to call getpeername() in isnetconn(). */
#if defined (HAVE_SYS_SOCKET_H) && defined (HAVE_GETPEERNAME) && !defined (SVR4_2)
int fd;
{
#if defined (HAVE_GETPEERNAME) && !defined (SVR4_2) && !defined (__BEOS__)
- int rv, l;
+ int rv;
+ socklen_t l;
struct sockaddr sa;
l = sizeof(sa);
projects / platform / upstream / bash.git / blobdiff