~ubuntu-branches/ubuntu/trusty/bash/trusty-security

/* bashline.c -- Bash's interface to the readline library. */

/* Copyright (C) 1987-2013 Free Software Foundation, Inc.

   This file is part of GNU Bash, the Bourne Again SHell.

   Bash is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation, either version 3 of the License, or

   (at your option) any later version.

   Bash is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with Bash.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "config.h"

#if defined (READLINE)

#include "bashtypes.h"

#include "posixstat.h"

#if defined (HAVE_UNISTD_H)

#  include <unistd.h>

#endif

#if defined (HAVE_GRP_H)

#  include <grp.h>

#endif

#if defined (HAVE_NETDB_H)

#  include <netdb.h>

#endif

#include <signal.h>

#include <stdio.h>

#include "chartypes.h"

#include "bashansi.h"

#include "bashintl.h"

#include "shell.h"

#include "input.h"

#include "builtins.h"

#include "bashhist.h"

#include "bashline.h"

#include "execute_cmd.h"

#include "findcmd.h"

#include "pathexp.h"

#include "shmbutil.h"

#include "trap.h"

#include "builtins/common.h"

#include <readline/rlconf.h>

#include <readline/readline.h>

#include <readline/history.h>

#include <glob/glob.h>

#if defined (ALIAS)

#  include "alias.h"

#endif

#if defined (PROGRAMMABLE_COMPLETION)

#  include "pcomplete.h"

#endif

/* These should agree with the defines for emacs_mode and vi_mode in

   rldefs.h, even though that's not a public readline header file. */

#ifndef EMACS_EDITING_MODE

#  define NO_EDITING_MODE	-1

#  define EMACS_EDITING_MODE	 1

#  define VI_EDITING_MODE	 0

#endif

#define RL_BOOLEAN_VARIABLE_VALUE(s)	((s)[0] == 'o' && (s)[1] == 'n' && (s)[2] == '\0')

#if defined (BRACE_COMPLETION)

extern int bash_brace_completion __P((int, int));

#endif /* BRACE_COMPLETION */

/* To avoid including curses.h/term.h/termcap.h and that whole mess. */

#ifdef _MINIX

extern int tputs __P((const char *string, int nlines, void (*outx)(int)));

#else

extern int tputs __P((const char *string, int nlines, int (*outx)(int)));

#endif

/* Forward declarations */

/* Functions bound to keys in Readline for Bash users. */

static int shell_expand_line __P((int, int));

static int display_shell_version __P((int, int));

static int operate_and_get_next __P((int, int));

static int bash_ignore_filenames __P((char **));

static int bash_ignore_everything __P((char **));

#if defined (BANG_HISTORY)

static char *history_expand_line_internal __P((char *));

static int history_expand_line __P((int, int));

static int tcsh_magic_space __P((int, int));

#endif /* BANG_HISTORY */

#ifdef ALIAS

static int alias_expand_line __P((int, int));

#endif

#if defined (BANG_HISTORY) && defined (ALIAS)

static int history_and_alias_expand_line __P((int, int));

#endif

static int bash_forward_shellword __P((int, int));

static int bash_backward_shellword __P((int, int));

static int bash_kill_shellword __P((int, int));

static int bash_backward_kill_shellword __P((int, int));

/* Helper functions for Readline. */

static char *restore_tilde __P((char *, char *));

static char *maybe_restore_tilde __P((char *, char *));

static char *bash_filename_rewrite_hook __P((char *, int));

static void bash_directory_expansion __P((char **));

static int bash_filename_stat_hook __P((char **));

static int bash_command_name_stat_hook __P((char **));

static int bash_directory_completion_hook __P((char **));

static int filename_completion_ignore __P((char **));

static int bash_push_line __P((void));

static int executable_completion __P((const char *, int));

static rl_icppfunc_t *save_directory_hook __P((void));

static void restore_directory_hook __P((rl_icppfunc_t));

static void cleanup_expansion_error __P((void));

static void maybe_make_readline_line __P((char *));

static void set_up_new_line __P((char *));

static int check_redir __P((int));

static char **attempt_shell_completion __P((const char *, int, int));

static char *variable_completion_function __P((const char *, int));

static char *hostname_completion_function __P((const char *, int));

static char *command_subst_completion_function __P((const char *, int));

static void build_history_completion_array __P((void));

static char *history_completion_generator __P((const char *, int));

static int dynamic_complete_history __P((int, int));

static int bash_dabbrev_expand __P((int, int));

static void initialize_hostname_list __P((void));

static void add_host_name __P((char *));

static void snarf_hosts_from_file __P((char *));

static char **hostnames_matching __P((char *));

static void _ignore_completion_names __P((char **, sh_ignore_func_t *));

static int name_is_acceptable __P((const char *));

static int test_for_directory __P((const char *));

static int return_zero __P((const char *));

static char *bash_dequote_filename __P((char *, int));

static char *quote_word_break_chars __P((char *));

static void set_filename_bstab __P((const char *));

static char *bash_quote_filename __P((char *, int, char *));

#ifdef _MINIX

static void putx __P((int));

#else

static int putx __P((int));

#endif

static int bash_execute_unix_command __P((int, int));

static void init_unix_command_map __P((void));

static int isolate_sequence __P((char *, int, int, int *));

static int set_saved_history __P((void));

#if defined (ALIAS)

static int posix_edit_macros __P((int, int));

#endif

static int bash_event_hook __P((void));

#if defined (PROGRAMMABLE_COMPLETION)

static int find_cmd_start __P((int));

static int find_cmd_end __P((int));

static char *find_cmd_name __P((int, int *, int *));

static char *prog_complete_return __P((const char *, int));

static char **prog_complete_matches;

#endif

/* Variables used here but defined in other files. */

#if defined (BANG_HISTORY)

extern int hist_verify;

#endif

extern int current_command_line_count, saved_command_line_count;

extern int last_command_exit_value;

extern int array_needs_making;

extern int posixly_correct, no_symbolic_links;

extern char *current_prompt_string, *ps1_prompt;

extern STRING_INT_ALIST word_token_alist[];

extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;

/* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual

   completion functions which indicate what type of completion should be

   done (at or before point) that can be bound to key sequences with

   the readline library. */

#define SPECIFIC_COMPLETION_FUNCTIONS

#if defined (SPECIFIC_COMPLETION_FUNCTIONS)

static int bash_specific_completion __P((int, rl_compentry_func_t *));

static int bash_complete_filename_internal __P((int));

static int bash_complete_username_internal __P((int));

static int bash_complete_hostname_internal __P((int));

static int bash_complete_variable_internal __P((int));

static int bash_complete_command_internal __P((int));

static int bash_complete_filename __P((int, int));

static int bash_possible_filename_completions __P((int, int));

static int bash_complete_username __P((int, int));

static int bash_possible_username_completions __P((int, int));

static int bash_complete_hostname __P((int, int));

static int bash_possible_hostname_completions __P((int, int));

static int bash_complete_variable __P((int, int));

static int bash_possible_variable_completions __P((int, int));

static int bash_complete_command __P((int, int));

static int bash_possible_command_completions __P((int, int));

static char *glob_complete_word __P((const char *, int));

static int bash_glob_completion_internal __P((int));

static int bash_glob_complete_word __P((int, int));

static int bash_glob_expand_word __P((int, int));

static int bash_glob_list_expansions __P((int, int));

#endif /* SPECIFIC_COMPLETION_FUNCTIONS */

static int edit_and_execute_command __P((int, int, int, char *));

#if defined (VI_MODE)

static int vi_edit_and_execute_command __P((int, int));

static int bash_vi_complete __P((int, int));

#endif

static int emacs_edit_and_execute_command __P((int, int));

/* Non-zero once initalize_readline () has been called. */

int bash_readline_initialized = 0;

/* If non-zero, we do hostname completion, breaking words at `@' and

   trying to complete the stuff after the `@' from our own internal

   host list. */

int perform_hostname_completion = 1;

/* If non-zero, we don't do command completion on an empty line. */

int no_empty_command_completion;

/* Set FORCE_FIGNORE if you want to honor FIGNORE even if it ignores the

   only possible matches.  Set to 0 if you want to match filenames if they

   are the only possible matches, even if FIGNORE says to. */

int force_fignore = 1;

/* Perform spelling correction on directory names during word completion */

int dircomplete_spelling = 0;

/* Expand directory names during word/filename completion. */

#if DIRCOMPLETE_EXPAND_DEFAULT

int dircomplete_expand = 1;

int dircomplete_expand_relpath = 1;

#else

int dircomplete_expand = 0;

int dircomplete_expand_relpath = 0;

#endif

/* When non-zero, perform `normal' shell quoting on completed filenames

   even when the completed name contains a directory name with a shell

   variable referene, so dollar signs in a filename get quoted appropriately.

   Set to zero to remove dollar sign (and braces or parens as needed) from

   the set of characters that will be quoted. */

int complete_fullquote = 1;

static char *bash_completer_word_break_characters = " \t\n\"'@><=;|&(:";

static char *bash_nohostname_word_break_characters = " \t\n\"'><=;|&(:";

/* )) */

static const char *default_filename_quote_characters = " \t\n\\\"'@<>=;|&()#$`?*[!:{~";	/*}*/

static char *custom_filename_quote_characters = 0;

static char filename_bstab[256];

static rl_hook_func_t *old_rl_startup_hook = (rl_hook_func_t *)NULL;

static int dot_in_path = 0;

/* Set to non-zero when dabbrev-expand is running */

static int dabbrev_expand_active = 0;

/* What kind of quoting is performed by bash_quote_filename:

	COMPLETE_DQUOTE = double-quoting the filename

	COMPLETE_SQUOTE = single_quoting the filename

	COMPLETE_BSQUOTE = backslash-quoting special chars in the filename

*/

#define COMPLETE_DQUOTE  1

#define COMPLETE_SQUOTE  2

#define COMPLETE_BSQUOTE 3

static int completion_quoting_style = COMPLETE_BSQUOTE;

/* Flag values for the final argument to bash_default_completion */

#define DEFCOMP_CMDPOS		1

/* Change the readline VI-mode keymaps into or out of Posix.2 compliance.

   Called when the shell is put into or out of `posix' mode. */

void

posix_readline_initialize (on_or_off)

     int on_or_off;

{

  if (on_or_off)

    rl_variable_bind ("comment-begin", "#");

#if defined (VI_MODE)

  rl_bind_key_in_map (CTRL ('I'), on_or_off ? rl_insert : rl_complete, vi_insertion_keymap);

#endif

}

void

reset_completer_word_break_chars ()

{

  rl_completer_word_break_characters = perform_hostname_completion ? savestring (bash_completer_word_break_characters) : savestring (bash_nohostname_word_break_characters);

}

/* When this function returns, rl_completer_word_break_characters points to

   dynamically allocated memory. */

int

enable_hostname_completion (on_or_off)

     int on_or_off;

{

  int old_value;

  char *at, *nv, *nval;

  old_value = perform_hostname_completion;

  if (on_or_off)

    {

      perform_hostname_completion = 1;

      rl_special_prefixes = "$@";

    }

  else

    {

      perform_hostname_completion = 0;

      rl_special_prefixes = "$";

    }

  /* Now we need to figure out how to appropriately modify and assign

     rl_completer_word_break_characters depending on whether we want

     hostname completion on or off. */

  /* If this is the first time this has been called

     (bash_readline_initialized == 0), use the sames values as before, but

     allocate new memory for rl_completer_word_break_characters. */

  if (bash_readline_initialized == 0 &&

      (rl_completer_word_break_characters == 0 || 

       rl_completer_word_break_characters == rl_basic_word_break_characters))

    {

      if (on_or_off)

	rl_completer_word_break_characters = savestring (bash_completer_word_break_characters);

      else

	rl_completer_word_break_characters = savestring (bash_nohostname_word_break_characters);

    }

  else

    {

      /* See if we have anything to do. */

      at = strchr (rl_completer_word_break_characters, '@');

      if ((at == 0 && on_or_off == 0) || (at != 0 && on_or_off != 0))

        return old_value;

      /* We have something to do.  Do it. */

      nval = (char *)xmalloc (strlen (rl_completer_word_break_characters) + 1 + on_or_off);

      if (on_or_off == 0)

	{

	  /* Turn it off -- just remove `@' from word break chars.  We want

	     to remove all occurrences of `@' from the char list, so we loop

	     rather than just copy the rest of the list over AT. */

	  for (nv = nval, at = rl_completer_word_break_characters; *at; )

	    if (*at != '@')

	      *nv++ = *at++;

	    else

	      at++;

	  *nv = '\0';

	}

      else

	{

	  nval[0] = '@';

	  strcpy (nval + 1, rl_completer_word_break_characters);

        }

      free (rl_completer_word_break_characters);

      rl_completer_word_break_characters = nval;

    }

  return (old_value);

}

/* Called once from parse.y if we are going to use readline. */

void

initialize_readline ()

{

  rl_command_func_t *func;

  char kseq[2];

  if (bash_readline_initialized)

    return;

  rl_terminal_name = get_string_value ("TERM");

  rl_instream = stdin;

  rl_outstream = stderr;

  /* Allow conditional parsing of the ~/.inputrc file. */

  rl_readline_name = "Bash";

  /* Add bindable names before calling rl_initialize so they may be

     referenced in the various inputrc files. */

  rl_add_defun ("shell-expand-line", shell_expand_line, -1);

#ifdef BANG_HISTORY

  rl_add_defun ("history-expand-line", history_expand_line, -1);

  rl_add_defun ("magic-space", tcsh_magic_space, -1);

#endif

  rl_add_defun ("shell-forward-word", bash_forward_shellword, -1);

  rl_add_defun ("shell-backward-word", bash_backward_shellword, -1);

  rl_add_defun ("shell-kill-word", bash_kill_shellword, -1);

  rl_add_defun ("shell-backward-kill-word", bash_backward_kill_shellword, -1);

#ifdef ALIAS

  rl_add_defun ("alias-expand-line", alias_expand_line, -1);

#  ifdef BANG_HISTORY

  rl_add_defun ("history-and-alias-expand-line", history_and_alias_expand_line, -1);

#  endif

#endif

  /* Backwards compatibility. */

  rl_add_defun ("insert-last-argument", rl_yank_last_arg, -1);

  rl_add_defun ("operate-and-get-next", operate_and_get_next, -1);

  rl_add_defun ("display-shell-version", display_shell_version, -1);

  rl_add_defun ("edit-and-execute-command", emacs_edit_and_execute_command, -1);

#if defined (BRACE_COMPLETION)

  rl_add_defun ("complete-into-braces", bash_brace_completion, -1);

#endif

#if defined (SPECIFIC_COMPLETION_FUNCTIONS)

  rl_add_defun ("complete-filename", bash_complete_filename, -1);

  rl_add_defun ("possible-filename-completions", bash_possible_filename_completions, -1);

  rl_add_defun ("complete-username", bash_complete_username, -1);

  rl_add_defun ("possible-username-completions", bash_possible_username_completions, -1);

  rl_add_defun ("complete-hostname", bash_complete_hostname, -1);

  rl_add_defun ("possible-hostname-completions", bash_possible_hostname_completions, -1);

  rl_add_defun ("complete-variable", bash_complete_variable, -1);

  rl_add_defun ("possible-variable-completions", bash_possible_variable_completions, -1);

  rl_add_defun ("complete-command", bash_complete_command, -1);

  rl_add_defun ("possible-command-completions", bash_possible_command_completions, -1);

  rl_add_defun ("glob-complete-word", bash_glob_complete_word, -1);

  rl_add_defun ("glob-expand-word", bash_glob_expand_word, -1);

  rl_add_defun ("glob-list-expansions", bash_glob_list_expansions, -1);

#endif

  rl_add_defun ("dynamic-complete-history", dynamic_complete_history, -1);

  rl_add_defun ("dabbrev-expand", bash_dabbrev_expand, -1);

  /* Bind defaults before binding our custom shell keybindings. */

  if (RL_ISSTATE(RL_STATE_INITIALIZED) == 0)

    rl_initialize ();

  /* Bind up our special shell functions. */

  rl_bind_key_if_unbound_in_map (CTRL('E'), shell_expand_line, emacs_meta_keymap);

#ifdef BANG_HISTORY

  rl_bind_key_if_unbound_in_map ('^', history_expand_line, emacs_meta_keymap);

#endif

  rl_bind_key_if_unbound_in_map (CTRL ('O'), operate_and_get_next, emacs_standard_keymap);

  rl_bind_key_if_unbound_in_map (CTRL ('V'), display_shell_version, emacs_ctlx_keymap);

  /* In Bash, the user can switch editing modes with "set -o [vi emacs]",

     so it is not necessary to allow C-M-j for context switching.  Turn

     off this occasionally confusing behaviour. */

  kseq[0] = CTRL('J');

  kseq[1] = '\0';

  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);

  if (func == rl_vi_editing_mode)

    rl_unbind_key_in_map (CTRL('J'), emacs_meta_keymap);

  kseq[0] = CTRL('M');

  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);

  if (func == rl_vi_editing_mode)

    rl_unbind_key_in_map (CTRL('M'), emacs_meta_keymap);

#if defined (VI_MODE)

  rl_unbind_key_in_map (CTRL('E'), vi_movement_keymap);

#endif

#if defined (BRACE_COMPLETION)

  rl_bind_key_if_unbound_in_map ('{', bash_brace_completion, emacs_meta_keymap); /*}*/

#endif /* BRACE_COMPLETION */

#if defined (SPECIFIC_COMPLETION_FUNCTIONS)

  rl_bind_key_if_unbound_in_map ('/', bash_complete_filename, emacs_meta_keymap);

  rl_bind_key_if_unbound_in_map ('/', bash_possible_filename_completions, emacs_ctlx_keymap);

  /* Have to jump through hoops here because there is a default binding for

     M-~ (rl_tilde_expand) */

  kseq[0] = '~';

  kseq[1] = '\0';

  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);

  if (func == 0 || func == rl_tilde_expand)

    rl_bind_keyseq_in_map (kseq, bash_complete_username, emacs_meta_keymap);

  rl_bind_key_if_unbound_in_map ('~', bash_possible_username_completions, emacs_ctlx_keymap);

  rl_bind_key_if_unbound_in_map ('@', bash_complete_hostname, emacs_meta_keymap);

  rl_bind_key_if_unbound_in_map ('@', bash_possible_hostname_completions, emacs_ctlx_keymap);

  rl_bind_key_if_unbound_in_map ('$', bash_complete_variable, emacs_meta_keymap);

  rl_bind_key_if_unbound_in_map ('$', bash_possible_variable_completions, emacs_ctlx_keymap);

  rl_bind_key_if_unbound_in_map ('!', bash_complete_command, emacs_meta_keymap);

  rl_bind_key_if_unbound_in_map ('!', bash_possible_command_completions, emacs_ctlx_keymap);

  rl_bind_key_if_unbound_in_map ('g', bash_glob_complete_word, emacs_meta_keymap);

  rl_bind_key_if_unbound_in_map ('*', bash_glob_expand_word, emacs_ctlx_keymap);

  rl_bind_key_if_unbound_in_map ('g', bash_glob_list_expansions, emacs_ctlx_keymap);

#endif /* SPECIFIC_COMPLETION_FUNCTIONS */

  kseq[0] = TAB;

  kseq[1] = '\0';

  func = rl_function_of_keyseq (kseq, emacs_meta_keymap, (int *)NULL);

  if (func == 0 || func == rl_tab_insert)

    rl_bind_key_in_map (TAB, dynamic_complete_history, emacs_meta_keymap);

  /* Tell the completer that we want a crack first. */

  rl_attempted_completion_function = attempt_shell_completion;

  /* Tell the completer that we might want to follow symbolic links or

     do other expansion on directory names. */

  set_directory_hook ();

  rl_filename_rewrite_hook = bash_filename_rewrite_hook;

  rl_filename_stat_hook = bash_filename_stat_hook;

  /* Tell the filename completer we want a chance to ignore some names. */

  rl_ignore_some_completions_function = filename_completion_ignore;

  /* Bind C-xC-e to invoke emacs and run result as commands. */

  rl_bind_key_if_unbound_in_map (CTRL ('E'), emacs_edit_and_execute_command, emacs_ctlx_keymap);

#if defined (VI_MODE)

  rl_bind_key_if_unbound_in_map ('v', vi_edit_and_execute_command, vi_movement_keymap);

#  if defined (ALIAS)

  rl_bind_key_if_unbound_in_map ('@', posix_edit_macros, vi_movement_keymap);

#  endif

  rl_bind_key_in_map ('\\', bash_vi_complete, vi_movement_keymap);

  rl_bind_key_in_map ('*', bash_vi_complete, vi_movement_keymap);

  rl_bind_key_in_map ('=', bash_vi_complete, vi_movement_keymap);

#endif

  rl_completer_quote_characters = "'\"";

  /* This sets rl_completer_word_break_characters and rl_special_prefixes

     to the appropriate values, depending on whether or not hostname

     completion is enabled. */

  enable_hostname_completion (perform_hostname_completion);

  /* characters that need to be quoted when appearing in filenames. */

  rl_filename_quote_characters = default_filename_quote_characters;

  set_filename_bstab (rl_filename_quote_characters);

  rl_filename_quoting_function = bash_quote_filename;

  rl_filename_dequoting_function = bash_dequote_filename;

  rl_char_is_quoted_p = char_is_quoted;

#if 0

  /* This is superfluous and makes it impossible to use tab completion in

     vi mode even when explicitly binding it in ~/.inputrc.  sv_strict_posix()

     should already have called posix_readline_initialize() when

     posixly_correct was set. */

  if (posixly_correct)

    posix_readline_initialize (1);

#endif

  bash_readline_initialized = 1;

}

void

bashline_reinitialize ()

{

  bash_readline_initialized = 0;

}

void

bashline_set_event_hook ()

{

  rl_signal_event_hook = bash_event_hook;

}

void

bashline_reset_event_hook ()

{

  rl_signal_event_hook = 0;

}

/* On Sun systems at least, rl_attempted_completion_function can end up

   getting set to NULL, and rl_completion_entry_function set to do command

   word completion if Bash is interrupted while trying to complete a command

   word.  This just resets all the completion functions to the right thing.

   It's called from throw_to_top_level(). */

void

bashline_reset ()

{

  tilde_initialize ();

  rl_attempted_completion_function = attempt_shell_completion;

  rl_completion_entry_function = NULL;

  rl_ignore_some_completions_function = filename_completion_ignore;

  rl_filename_quote_characters = default_filename_quote_characters;

  set_filename_bstab (rl_filename_quote_characters);

  set_directory_hook ();

  rl_filename_stat_hook = bash_filename_stat_hook;

  bashline_reset_event_hook ();

}

/* Contains the line to push into readline. */

static char *push_to_readline = (char *)NULL;

/* Push the contents of push_to_readline into the

   readline buffer. */

static int

bash_push_line ()

{

  if (push_to_readline)

    {

      rl_insert_text (push_to_readline);

      free (push_to_readline);

      push_to_readline = (char *)NULL;

      rl_startup_hook = old_rl_startup_hook;

    }

  return 0;

}

/* Call this to set the initial text for the next line to read

   from readline. */

int

bash_re_edit (line)

     char *line;

{

  FREE (push_to_readline);

  push_to_readline = savestring (line);

  old_rl_startup_hook = rl_startup_hook;

  rl_startup_hook = bash_push_line;

  return (0);

}

static int

display_shell_version (count, c)

     int count, c;

{

  rl_crlf ();

  show_shell_version (0);

  putc ('\r', rl_outstream);

  fflush (rl_outstream);

  rl_on_new_line ();

  rl_redisplay ();

  return 0;

}

/* **************************************************************** */

/*								    */

/*			     Readline Stuff			    */

/*								    */

/* **************************************************************** */

/* If the user requests hostname completion, then simply build a list

   of hosts, and complete from that forever more, or at least until

   HOSTFILE is unset. */

/* THIS SHOULD BE A STRINGLIST. */

/* The kept list of hostnames. */

static char **hostname_list = (char **)NULL;

/* The physical size of the above list. */

static int hostname_list_size;

/* The number of hostnames in the above list. */

static int hostname_list_length;

/* Whether or not HOSTNAME_LIST has been initialized. */

int hostname_list_initialized = 0;

/* Initialize the hostname completion table. */

static void

initialize_hostname_list ()

{

  char *temp;

  temp = get_string_value ("HOSTFILE");

  if (temp == 0)

    temp = get_string_value ("hostname_completion_file");

  if (temp == 0)

    temp = DEFAULT_HOSTS_FILE;

  snarf_hosts_from_file (temp);

  if (hostname_list)

    hostname_list_initialized++;

}

/* Add NAME to the list of hosts. */

static void

add_host_name (name)

     char *name;

{

  if (hostname_list_length + 2 > hostname_list_size)

    {

      hostname_list_size = (hostname_list_size + 32) - (hostname_list_size % 32);

      hostname_list = strvec_resize (hostname_list, hostname_list_size);

    }

  hostname_list[hostname_list_length++] = savestring (name);

  hostname_list[hostname_list_length] = (char *)NULL;

}

#define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))

static void

snarf_hosts_from_file (filename)

     char *filename;

{

  FILE *file;

  char *temp, buffer[256], name[256];

  register int i, start;

  file = fopen (filename, "r");

  if (file == 0)

    return;

  while (temp = fgets (buffer, 255, file))

    {

      /* Skip to first character. */

      for (i = 0; buffer[i] && cr_whitespace (buffer[i]); i++)

	;

      /* If comment or blank line, ignore. */

      if (buffer[i] == '\0' || buffer[i] == '#')

	continue;

      /* If `preprocessor' directive, do the include. */

      if (strncmp (buffer + i, "$include ", 9) == 0)

	{

	  char *incfile, *t;

	  /* Find start of filename. */

	  for (incfile = buffer + i + 9; *incfile && whitespace (*incfile); incfile++)

	    ;

	  /* Find end of filename. */

	  for (t = incfile; *t && cr_whitespace (*t) == 0; t++)

	    ;

	  *t = '\0';

	  snarf_hosts_from_file (incfile);

	  continue;

	}

      /* Skip internet address if present. */

      if (DIGIT (buffer[i]))

	for (; buffer[i] && cr_whitespace (buffer[i]) == 0; i++);

      /* Gobble up names.  Each name is separated with whitespace. */

      while (buffer[i])

	{

	  for (; cr_whitespace (buffer[i]); i++)

	    ;

	  if (buffer[i] == '\0' || buffer[i] ==  '#')

	    break;

	  /* Isolate the current word. */

	  for (start = i; buffer[i] && cr_whitespace (buffer[i]) == 0; i++)

	    ;

	  if (i == start)

	    continue;

	  strncpy (name, buffer + start, i - start);

	  name[i - start] = '\0';

	  add_host_name (name);

	}

    }

  fclose (file);

}

/* Return the hostname list. */

char **

get_hostname_list ()

{

  if (hostname_list_initialized == 0)

    initialize_hostname_list ();

  return (hostname_list);

}

void

clear_hostname_list ()

{

  register int i;

  if (hostname_list_initialized == 0)

    return;

  for (i = 0; i < hostname_list_length; i++)

    free (hostname_list[i]);

  hostname_list_length = hostname_list_initialized = 0;

}

/* Return a NULL terminated list of hostnames which begin with TEXT.

   Initialize the hostname list the first time if necessary.

   The array is malloc ()'ed, but not the individual strings. */

static char **

hostnames_matching (text)

     char *text;

{

  register int i, len, nmatch, rsize;