path: root/lib/vty_cli.c

/* VTY Command Line Handler
 * Copyright (C) 1997, 98 Kunihiro Ishiguro
 *
 * Revisions: Copyright (C) 2010 Chris Hall (GMCH), Highwayman
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra 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 2, or (at your option) any
 * later version.
 *
 * GNU Zebra 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 GNU Zebra; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#include <zebra.h>

#include "keystroke.h"
#include "vty.h"
#include "uty.h"
#include "vty_io.h"
#include "vty_cli.h"

#include "command.h"

#include "memory.h"

/*==============================================================================
 * Host name handling
 *
 * The host name is used in the command line prompt.  The name used is either
 * the name set by "hostname" command, or the current machine host name.
 *
 * Static variables -- under the VTY_LOCK !
 */

static char* vty_host_name = NULL ;
int vty_host_name_set      = 0 ;

static void uty_new_host_name(const char* name) ;

/*------------------------------------------------------------------------------
 * Update vty_host_name as per "hostname" or "no hostname" command
 */
extern void
uty_set_host_name(const char* name)
{
  VTY_ASSERT_LOCKED() ;

  vty_host_name_set = (name != NULL) ;

  if (vty_host_name_set)
    uty_new_host_name(name) ;
  else
    uty_check_host_name() ;
} ;

/*------------------------------------------------------------------------------
 * If vty_host_name is set, free it.
 */
extern void
uty_free_host_name(void)
{
  if (vty_host_name != NULL)
    XFREE (MTYPE_HOST, vty_host_name) ; /* sets vty_host_name = NULL */
} ;

/*------------------------------------------------------------------------------
 * If the host name is not set by command, see if the actual host name has
 * changed, and if so change it.
 *
 * This is done periodically in case the actual host name changes !
 */
extern void
uty_check_host_name(void)
{
  struct utsname names ;

  VTY_ASSERT_LOCKED() ;

  if (vty_host_name_set)
    return ;                    /* nothing to do if set by command      */

  uname (&names) ;

  if ((vty_host_name == NULL) || (strcmp(vty_host_name, names.nodename) != 0))
    uty_new_host_name(names.nodename) ;
} ;

/*------------------------------------------------------------------------------
 * Set new vty_host_name and run along list of VTYs to mark the change.
 */
static void
uty_new_host_name(const char* name)
{
  vty_io vio ;

  VTY_ASSERT_LOCKED() ;

  uty_free_host_name() ;
  vty_host_name = XSTRDUP(MTYPE_HOST, name) ;

  vio = vio_list_base ;
  while (vio != NULL)
    {
      vio->cli_prompt_set = 0 ;
      vio = sdl_next(vio, vio_list) ;
    } ;
} ;

/*==============================================================================
 * General mechanism for command execution.
 *
 * Command execution is driven by select/pselect -- which means that the
 * processing of commands is multiplexed with all other activity.  In the
 * following:
 *
 *   -- read_ready and write_ready are events signalled by select/pselect
 *
 *   -- setting read or write on, means enabling the file for select/pselect to
 *      consider it for read_ready or write_ready, respectively.
 *
 * State of the CLI:
 *
 *   cli_blocked      -- a command has been dispatched, and CLI is now waiting
 *                       for it and/or its output to complete.
 *
 *   cmd_in_progress  -- a command has been dispatched (and may have been
 *                       queued).
 *
 *                       If not blocked: can continue in the CLI until another
 *                       command is ready to be executed.
 *
 * There are two output FIFOs:
 *
 *   1. for the CLI itself               -- uty_cli_out and friends
 *
 *   2. for output generated by commands -- vty_out and friends.
 *
 * The CLI FIFO is emptied whenever possible, in preference to the command
 * FIFO.  The command FIFO is only emptied when !cmd_in_progress -- this means
 * that all the output from a given command is collected together before being
 * sent to the file.
 *
 * The CLI starts with cli_blocked and !cmd_in_progress, with the socket set
 * write on.  The CLI progresses as follows:
 *
 *   * on read_ready, if cli_blocked: do nothing.
 *
 *   * on write_ready:
 *
 *       - empty out the CLI buffer
 *
 *       - if ! cmd_in_progress:
 *
 *          * empty out the command buffer
 *
 *          * if the command buffer is empty, clear cli_blocked (if was set)
 *
 *       - generate a read_ready event unless write() would block.
 *
 *         So the CLI is kicked once all available output completes.
 *
 *   * on read_ready, if !cli_blocked:
 *
 *       - process keystrokes into command line under construction.
 *
 *       - when required, dispatch the command:
 *
 *           * set cmd_in_progress
 *
 *           * execute the command -- which may generate output
 *
 *           * clear cmd_in_progress
 *
 *           * set cli_blocked
 *
 *       - set write on (or read on) as required.
 *
 * Note that only sets read on when the keystroke stream is empty and has not
 * yet hit eof.  The CLI process is driven mostly by write_ready -- which
 * invokes read_ready.
 *
 * Note also that after each command dispatch the CLI processor exits, to be
 * re-entered again on write_ready/read_ready -- so does one command line at
 * a time, yielding the processor after each one.
 *
 * Note that select/pselect treat a socket which is at "EOF", or has seen an
 * error, or has been half closed, etc. as readable and writable.  This means
 * that the CLI will continue to move forward even after the socket is no
 * longer delivering any data.
 *
 *------------------------------------------------------------------------------
 * The "--more--" handling.
 *
 * This is largely buried in the output handling.
 *
 * While cmd_in_progress is true, all output to the command output FIFO is held
 * there -- no actual write() is performed.
 *
 * When the command completes:
 *
 *  * cmd_in_progress is cleared
 *
 *  * cli_blocked will be set
 *
 *  * the line_control structure is reset
 *
 *  * the output process is kicked off by setting write on
 *
 * The output process used the line_control structure to manage the output, and
 * occasionally enter the trivial "--more--" CLI.  This is invisible to the
 * main CLI.  (See the cmd_wait_more flag and its handling.)
 *
 * When all the output has completed, cli_blocked is cleared and the CLI will
 * be kicked.
 *
 * It is expected that the output will end with a newline -- so that when the
 * CLI is kicked, the cursor will be at the start of an empty line.
 *
 * This mechanism means that the command output FIFO only ever contains the
 * output from the last command executed.
 *
 * If the user decides to abandon output at the "--more--" prompt, then the
 * contents of the command output FIFO are discarded.
 *
 *------------------------------------------------------------------------------
 * The qpthreads/qpnexus extension.
 *
 * When running in qnexus mode, many commands are not executed directly in the
 * CLI, but are queued for execution by the main "routeing" nexus.
 *
 * The parsing of commands is context sensitive.  The context depends may
 * change during the execution of a command.  So... it is not possible to
 * dispatch a command until the previous one has completed.
 *
 * In qnexus mode, when a command is queued, the CLI does not go cli_blocked,
 * even if some output has already been generated.  This allows a further
 * command to be entered while the previous one is executed.  However, if the
 * command is dispatched before the previous one completes, then the cli will
 * block.
 *
 * While the previous command is executing, the current command line has a
 * minimal prompt -- to show that the context is not known.  When the previous
 * command completes, the command line is redrawn in the new context.
 *
 *------------------------------------------------------------------------------
 * Command line drawn state.
 *
 * When the cli_drawn flag is set, the current console line contains the
 * current prompt and the user input to date.  The cursor is positioned where
 * the user last placed it.
 *
 * The command line can be "wiped" -- see uty_cli_wipe() -- which removes all
 * output and prompt, and leaves the console at the start of an empty line
 * where the command line used to be.
 *
 * On entry to the CLI, it will draw the command line again if it has been
 * wiped.
 *
 * This mechanism is used to support the partial command line that may be
 * entered while a queued command executes.
 *
 * It is also used for the command help/completion system.
 *
 * It is also used to support the "monitor" output.
 */

/*==============================================================================
 * Command Line Interface
 *
 * State of the CLI:
 *
 *   cli_blocked        -- a command has been dispatched, and now waiting
 *                         for it and/or its output to complete.
 *
 *   cmd_in_progress    -- a command has been dispatched (and may have been
 *                         queued).
 *
 *                         Can continue in the CLI until another command is
 *                         ready to be executed.
 */

static void uty_cli_draw(vty_io vio, enum node_type node) ;
static enum cli_do uty_cli_process(vty_io vio, enum node_type node) ;
static void uty_cli_response(vty_io vio, enum cli_do cli_do) ;
static int uty_cli_dispatch(vty_io vio) ;

/*------------------------------------------------------------------------------
 * Run the CLI until:
 *
 *   * becomes blocked
 *   * runs out of keystrokes
 *   * executes a command
 *
 * When exits will (in general):
 *
 *   * set write on if there is anything to be written or have something
 *     in the keystroke stream to be processed.
 *
 *   * set read on if does not set write on, if not yet hit EOF on the
 *     keystroke stream.
 *
 * Note that this executes at most one command each time it is called.  This
 * is to allow for a modicum of sharing of the system.  For real keyboard input
 * this will make no difference at all !
 */
extern void
uty_cli(vty_io vio)
{
  bool won ;

  VTY_ASSERT_LOCKED() ;

  /* cli_blocked is set when is waiting for a command, or its output to
   * complete.
   *
   * There is no good reason to arrive here in that state, and nothing to be
   * done if that happens.
   */
  if (vio->cli_blocked)
    return ;

  /* If there is something to do, that is because a previous command has
   * now completed, which may have wiped the pending command.
   *
   * If there is nothing pending, then can run the CLI until there is
   * something to do, or runs out of input.
   */
  if (vio->cli_do != cli_do_nothing)
    uty_cli_draw(vio, vio->vty->node) ;
  else
    vio->cli_do = uty_cli_process(vio, vio->vty->node) ;

  /* If have something to do, do it.                                */
  if (vio->cli_do != cli_do_nothing)
    {
      /* Reflect immediate response                                 */
      uty_cli_response(vio, vio->cli_do) ;

      /* If command not already in progress, dispatch this one, which may
       * set the CLI blocked.
       *
       * Otherwise is now blocked until queued command completes.
       */
      if (!vio->cmd_in_progress)
        vio->cli_blocked = uty_cli_dispatch(vio) ;
      else
        vio->cli_blocked = 1 ;
    } ;

  /* If there is anything in the CLI output FIFO, must set write on to clear
   * it.
   *
   * If there is anything in the command output FIFO *and* is !cmd_in_progress,
   * must set write on to clear it.
   *
   * Otherwise: if cmd_in_progress, then the command buffer is not to be
   * output yet, and the command completion will kick things into action -- so
   * nothing further is required here.
   *
   * Otherwise: if there is anything in the command output buffer, must set
   * write on to clear it.
   *
   * Otherwise: if there is something in the keystroke stream, then must set
   * write on... the write_ready acts as a proxy for keystroke stream is ready.
   *
   * Otherwise: set read on -- so if further input arrives, will get on it.
   */
  do
    {
      won = 1 ;                 /* generally the case           */

      /* If have some CLI output -- do that                             */
      if (!vio_fifo_empty(&vio->cli_obuf))
        break ;

      /* If is blocked with command in progress -- do nothing.
       *
       * This state <=> that there is a queued command, and the CLI is now
       * blocked until the command completes.  When it does, things will
       * progress.
       */
      if (vio->cli_blocked && vio->cmd_in_progress)
        {
          won = 0 ;
          break ;
        } ;

      /* If have some command output which is not held because there is
       * a command in progress -- do that.
       */
      if (!vio_fifo_empty(&vio->cmd_obuf) && !vio->cmd_in_progress)
        break ;

      /* If the keystroke buffer is not empty then write_ready is used as a
       * proxy for keystroke ready.
       */
      if (!keystroke_stream_empty(vio->key_stream))
        break ;

      /* Finally... if not at keystroke EOF, set read on                */
      won = 0 ;

      if (!keystroke_stream_eof(vio->key_stream))
        uty_file_set_read(&vio->file, on) ;

    } while (0) ;

  if (won)
    uty_file_set_write(&vio->file, on) ;
} ;

/* TODO: dealing with EOF and timeout and closing and such
 *
 * uty_cout (vty, "%sVty connection is timed out.%s", VTY_NEWLINE, VTY_NEWLINE);
 *
 */
/*------------------------------------------------------------------------------
 * Dispatch the current vio->cli_do -- queueing it if necessary.
 *
 * Requires that are NOT blocked and NO command is queued.
 *
 * Expects to be on new blank line, and when returns will be on new, blank
 * line.
 *
 * Returns: true <=> output is pending and command completed
 *         false  => no output pending or command was queued
 *
 * Generally sets vio->cl_do = cli_do_nothing and clears vio->cl to empty.
 *
 * Can set vio->cl_do = and vio->cl to be a follow-on command.
 */
static int
uty_cli_dispatch(vty_io vio)
{
  qstring_t tmp ;
  enum cli_do cli_do ;
  int queued ;

  struct vty* vty = vio->vty ;

  VTY_ASSERT_LOCKED() ;
  assert(!vio->cli_blocked && !vio->cmd_in_progress) ;

  /* Set vio->clx to the command about to execute.
   *
   * Clear vio->cl  and vio->cl_do.
   */
  vio->cmd_in_progress = 1 ;            /* => vty->buf is valid         */

  tmp      = vio->clx ;                 /* swap clx and cl              */
  vio->clx = vio->cl ;
  vio->cl  = tmp ;

  qs_term(&vio->clx) ;                  /* ensure string is terminated  */
  vty->buf = qs_chars(&vio->clx) ;      /* terminated command line      */
  cli_do = vio->cli_do ;                /* current operation            */

  vio->cli_do = cli_do_nothing ;        /* clear                        */
  qs_set_empty(&vio->cl) ;              /* set cl empty (with '\0')     */

  /* Reset the command output FIFO and line_control                     */

  assert(vio_fifo_empty(&vio->cmd_obuf)) ;
  /* TODO: reset line_control                                           */

  /* Dispatch command                                                       */
  if ((vty->node == AUTH_NODE) || (vty->node == AUTH_ENABLE_NODE))
    {
      /* AUTH_NODE and AUTH_ENABLE_NODE are unique                          */
      queued = uty_auth(vty, vty->buf, cli_do) ;
    }
  else
    {
      /* All other nodes...                                                 */
      switch (cli_do)
      {
        case cli_do_nothing:
          break ;

        case cli_do_command:
          queued = uty_command(vty, vty->buf) ;
          break ;

        case cli_do_ctrl_c:
          queued = uty_stop_input(vty) ;
          break ;

        case cli_do_ctrl_d:
          queued = uty_down_level(vty) ;
          break ;

        case cli_do_ctrl_z:
          queued = uty_command(vty, vty->buf) ;
          if (queued)
            vio->cli_do = cli_do_ctrl_z ;
          else
            queued = uty_end_config(vty) ;
          break ;

        default:
          zabort("unknown cli_do_xxx value") ;
      } ;
    } ;

  if (!queued)
    {
      vio->cmd_in_progress = 0 ;        /* command complete             */
      vty->buf = NULL ;                 /* finished with command line   */
    } ;

  return ! (vio->cmd_in_progress || vio_fifo_empty(&vio->cmd_obuf)) ;
} ;

/*------------------------------------------------------------------------------
 * Queued command has completed.
 *
 * Note that sets write on whether there is anything in the output buffer
 * or not... write_ready will kick read_ready.
 */
extern void
vty_queued_result(struct vty *vty, int result, int action)
{
  vty_io vio ;

  VTY_LOCK() ;

  vio = vty->vio ;

  vio->cmd_in_progress = 0 ;    /* command complete                     */
  vty->buf = NULL ;             /* finished with command line           */

  vio->cli_blocked = !vio_fifo_empty(&vio->cmd_obuf) ;
                                /* blocked if output is now pending     */

  uty_cli_wipe(vio) ;           /* wipe any partly constructed line     */

  uty_file_set_write(&vty->vio->file, on) ;
                                /* flush any output -- which will do a
                                 * read_ready when all finished         */
  VTY_UNLOCK() ;
}

/*==============================================================================
 * CLI VTY output
 *
 * This is buffered separately from the general (command) VTY output above.
 *
 * Has a dedicated buffer in the struct vty, which is flushed regularly during
 * command processing.
 *
 * It is expected that can flush straight to the file, since this is running at
 * CLI speed.  However, if the CLI is being driven by something other than a
 * keyboard, or "monitor" output has filled the buffers, then may need to
 * have intermediate buffering.
 *
 * No actual I/O takes place here-- all "output" is to vio->cli_obuf
 *                                              and/or vio->cli_ex_obuf
 *
 * The "cli_echo" functions discard the output if vio->cli_echo_suppress != 0.
 * This is used while passwords are entered and to allow command line changes
 * to be made while the line is not visible.
 */

enum { cli_rep_count = 32 } ;

typedef const char cli_rep_char[cli_rep_count] ;

static const char telnet_backspaces[] =
                          { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
                            0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
                            0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
                            0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08
                          } ;
CONFIRM(sizeof(telnet_backspaces) == sizeof(cli_rep_char)) ;

static const char telnet_spaces[] =
                          {  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',
                             ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',
                             ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',
                             ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' ',  ' '
                          } ;
CONFIRM(sizeof(telnet_spaces)     == sizeof(cli_rep_char)) ;

static const char* telnet_newline = "\r\n" ;

static void uty_cli_write(vty_io vio, const char *this, int len) ;
static void uty_cli_write_n(vty_io vio, cli_rep_char chars, int n) ;

/*------------------------------------------------------------------------------
 * CLI VTY output -- cf fprintf()
 */
static void
uty_cli_out (vty_io vio, const char *format, ...)
{
  VTY_ASSERT_LOCKED() ;

  if (vio->file.write_open)
    {
      va_list args;
      int len ;

      va_start (args, format);
      len = qs_vprintf(&vio->cli_vbuf, format, args) ;
      va_end(args);

      if (len > 0)
        uty_cli_write(vio, qs_chars(&vio->cli_vbuf), len) ;
    } ;
} ;

/*------------------------------------------------------------------------------
 * CLI VTY output -- echo user input
 *
 * Do nothing if echo suppressed (eg in AUTH_NODE) or not write_open
 */
static void
uty_cli_echo (vty_io vio, const char *this, size_t len)
{
  VTY_ASSERT_LOCKED() ;

  if (vio->cli_echo_suppress || !vio->file.write_open)
    return ;

  uty_cli_write(vio, this, len) ;
}

/*------------------------------------------------------------------------------
 * CLI VTY output -- echo 'n' characters using a cli_rep_char string
 *
 * Do nothing if echo suppressed (eg in AUTH_NODE)
 */
static void
uty_cli_echo_n(vty_io vio, cli_rep_char chars, int n)
{
  VTY_ASSERT_LOCKED() ;

  if (vio->cli_echo_suppress || !vio->file.write_open)
    return ;

  uty_cli_write_n(vio, chars, n) ;
}

/*------------------------------------------------------------------------------
 * CLI VTY output -- cf write()
 */
inline static void
uty_cli_write(vty_io vio, const char *this, int len)
{
  VTY_ASSERT_LOCKED() ;

  if (vio->file.write_open)
    vio_fifo_put(&vio->cli_obuf, this, len) ;
} ;

/*------------------------------------------------------------------------------
 * CLI VTY output -- write 'n' characters using a cli_rep_char string
 */
static void
uty_cli_write_n(vty_io vio, cli_rep_char chars, int n)
{
  int len ;

  len = sizeof(cli_rep_char) ;
  while (n > 0)
    {
      if (n < len)
        len = n ;
      uty_cli_write(vio, chars, len) ;
      n -= len ;
    } ;
} ;

/*------------------------------------------------------------------------------
 * CLI VTY output -- write given string
 *
 * Returns length of string.
 */
static int
uty_cli_write_s(vty_io vio, const char *str)
{
  int len ;

  len = strlen(str) ;
  if (len != 0)
    uty_cli_write(vio, str, len) ;

  return len ;
} ;

/*==============================================================================
 * Standard Messages
 */

/*------------------------------------------------------------------------------
 * Send newline to the console.
 *
 * Clears the cli_drawn flag.
 */
static void
uty_cli_out_newline(vty_io vio)
{
  uty_cli_write(vio, telnet_newline, 2) ;
  vio->cli_drawn = 0 ;
} ;

/*------------------------------------------------------------------------------
 * Wipe 'n' characters.
 *
 * If 'n' < 0, wipes characters backwards and moves cursor back.
 *    'n' > 0, wipes characters forwards, leaving cursor where it is
 */
static void
uty_cli_out_wipe_n(vty_io vio, int n)
{
  if (n < 0)
    {
      n = abs(n) ;
      uty_cli_write_n(vio, telnet_backspaces, n);
    } ;

  if (n > 0)
    {
      uty_cli_write_n(vio, telnet_spaces,     n) ;
      uty_cli_write_n(vio, telnet_backspaces, n) ;
    } ;
} ;

/*------------------------------------------------------------------------------
 * Send response to the given cli_do
 *
 * If no command is in progress, then will send newline to signal that the
 * command is about to be dispatched.
 *
 * If command is in progress, then leaves cursor on '^' to signal that is now
 * waiting for previous command to complete.
 */
static const char* cli_response [2][cli_do_count] =
{
  { /* when not waiting for previous command to complete        */
    [cli_do_command]        = "",
    [cli_do_ctrl_c]         = "^C",
    [cli_do_ctrl_d]         = "^D",
    [cli_do_ctrl_z]         = "^Z",
  },
  { /* when waiting for a previous command to complete          */
    [cli_do_command]        = "^",
    [cli_do_ctrl_c]         = "^C",
    [cli_do_ctrl_d]         = "^D",
    [cli_do_ctrl_z]         = "^Z",
  }
} ;

static void
uty_cli_response(vty_io vio, enum cli_do cli_do)
{
  const char* str ;
  int len ;

  if (cli_do == cli_do_nothing)
    return ;

  str = (cli_do < cli_do_count)
          ? cli_response[vio->cmd_in_progress ? 1 : 0][cli_do]  : NULL ;
  assert(str != NULL) ;

  len = uty_cli_write_s(vio, str) ;

  if (vio->cmd_in_progress)
    {
      vio->cli_extra_len = len ;
      uty_cli_write_n(vio, telnet_backspaces, len) ;
    }
  else
    {
      uty_cli_out_newline(vio) ;
    } ;
} ;

/*------------------------------------------------------------------------------
 * Send various messages with trailing newline.
 */

static void
uty_cli_out_CMD_ERR_AMBIGUOUS(vty_io vio)
{
  uty_cli_write_s(vio, "% " MSG_CMD_ERR_AMBIGUOUS ".") ;
  uty_cli_out_newline(vio) ;
} ;

static void
uty_cli_out_CMD_ERR_NO_MATCH(vty_io vio)
{
  uty_cli_write_s(vio, "% " MSG_CMD_ERR_NO_MATCH ".") ;
  uty_cli_out_newline(vio) ;
} ;

/*==============================================================================
 * Command line draw and wipe
 */

/*------------------------------------------------------------------------------
 * Wipe the current console line -- if any.
 */
extern void
uty_cli_wipe(vty_io vio)
{
  int a ;
  int b ;

  if (!vio->cli_drawn == 0)
    return ;                    /* quit if already wiped        */

  assert(vio->cl.cp <= vio->cl.len) ;

  /* deal with echo suppression first                           */
  if (vio->cli_echo_suppress)
    {
      b = 0 ;
      a = 0 ;
    }
  else
    {
      b = vio->cl.cp ;          /* behind cursor        */
      a = vio->cl.len - b ;     /* ahead of cursor      */
    }

  /* Stuff ahead of the current position                        */
  uty_cli_out_wipe_n(vio, a + vio->cli_extra_len) ;

  /* Stuff behind the current position                          */
  uty_cli_out_wipe_n(vio, vio->cli_prompt_len + b) ;

  vio->cli_drawn = 0 ;
} ;

/*------------------------------------------------------------------------------
 * Draw prompt and entire command line, leaving current position where it
 * should be.
 *
 * If command line is currently drawn, this wipes and redraws.
 *
 * Otherwise, assumes is positioned at start of an empty line.
 *
 * If there is a command queued, uses a dummy prompt -- because by the time
 * the command is executed, the node may have changed, so the current prompt
 * may be invalid.
 *
 * Sets: cli_drawn         = true
 *       cli_prompt_len    = length of prompt used
 *       cli_extra_len     = 0
 *       cli_echo_suppress = (AUTH_NODE or AUTH_ENABLE_NODE)
 */
static void
uty_cli_draw(vty_io vio, enum node_type node)
{
  const char* prompt ;

  if (vio->cli_drawn)
    uty_cli_wipe(vio) ;

  vio->cli_drawn     = 1 ;
  vio->cli_extra_len = 0 ;
  vio->cli_echo_suppress = (node == AUTH_NODE || node == AUTH_ENABLE_NODE) ;

  /* Sort out what the prompt is.                                       */

  if (vio->cmd_in_progress)
    {
      /* If there is a queued command, the prompt is a minimal affair.  */
      prompt = "~ " ;
      vio->cli_prompt_len = strlen(prompt) ;
    }
  else
    {
      /* The prompt depends on the node, and is expected to include the
       * host name.
       *
       * Caches the prompt so doesn't re-evaluate it every time.
       *
       * If the host name changes, the cli_prompt_set flag is cleared.
       */
      if (!vio->cli_prompt_set || (node != vio->cli_prompt_node))
        {
          const char* prompt ;

          if (vty_host_name == NULL)
            uty_check_host_name() ;         /* should never be required  */

          prompt = cmd_prompt(node) ;
          if (prompt == NULL)
            {
              zlog_err("vty %s has node %d", uty_get_name(vio), node) ;
              prompt = "%s ???: " ;
            } ;

          qs_printf(&vio->cli_prompt_for_node, prompt, vty_host_name);

          vio->cli_prompt_node = node ;
          vio->cli_prompt_set  = 1 ;
        } ;

      prompt              = qs_chars(&vio->cli_prompt_for_node) ;
      vio->cli_prompt_len = vio->cli_prompt_for_node.len ;
    } ;

  uty_cli_write(vio, prompt, vio->cli_prompt_len) ;

  if ((vio->cl.len != 0) && !vio->cli_echo_suppress)
    {
      uty_cli_write(vio, qs_chars(&vio->cl), vio->cl.len) ;
      if (vio->cl.cp < vio->cl.len)
        uty_cli_write_n(vio, telnet_backspaces, vio->cl.len - vio->cl.cp) ;
    } ;
} ;

/*==============================================================================
 * Command line processing loop
 */

#define CONTROL(X)  ((X) - '@')

static void uty_telnet_command(vty_io vio, keystroke stroke) ;
static int uty_cli_insert (vty_io vio, const char* chars, int n) ;
static int uty_cli_overwrite (vty_io vio, char* chars, int n) ;
static int uty_cli_word_overwrite (vty_io vio, char *str) ;
static int uty_cli_forwards(vty_io vio, int n) ;
static int uty_cli_backwards(vty_io vio, int n) ;
static int uty_cli_del_forwards(vty_io vio, int n) ;
static int uty_cli_del_backwards(vty_io vio, int n) ;
static int uty_cli_bol (vty_io vio) ;
static int uty_cli_eol (vty_io vio) ;
static int uty_cli_word_forwards_delta(vty_io vio) ;
static int uty_cli_word_forwards(vty_io vio) ;
static int uty_cli_word_backwards_delta(vty_io vio, int eat_spaces) ;
static int uty_cli_word_backwards_pure (vty_io vio) ;
static int uty_cli_word_backwards (vty_io vio) ;
static int uty_cli_del_word_forwards(vty_io vio) ;
static int uty_cli_del_word_backwards(vty_io vio) ;
static int uty_cli_del_to_eol (vty_io vio) ;
static int uty_cli_clear_line(vty_io vio) ;
static int uty_cli_transpose_chars(vty_io vio) ;
static void uty_cli_history_use(vty_io vio, int step) ;
static void uty_cli_next_line(vty_io vio) ;
static void uty_cli_previous_line (vty_io vio) ;
static void uty_cli_complete_command (vty_io vio, enum node_type node) ;
static void uty_cli_describe_command (vty_io vio, enum node_type node) ;

/*------------------------------------------------------------------------------
 * Fetch next keystroke, reading from the file if required.
 */
static inline bool
uty_cli_get_keystroke(vty_io vio, keystroke stroke)
{
  if (keystroke_get(vio->key_stream, stroke))
    return 1 ;

  uty_read(vio, NULL) ;         /* not stealing */

  return keystroke_get(vio->key_stream, stroke) ;
} ;

/*------------------------------------------------------------------------------
 * Process keystrokes until run out of input, or get something to cli_do.
 *
 * If required, draw the prompt and command line.
 *
 * Process keystrokes until run out of stuff to do, or have a "command line"
 * that must now be executed.
 *
 * Processes the contents of the keystroke stream.  If exhausts that, will set
 * ready to read and return.  (To give some "sharing".)
 *
 * Returns: cli_do_xxxx
 *
 * When returns the cl is '\0' terminated.
 */
static enum cli_do
uty_cli_process(vty_io vio, enum node_type node)
{
  struct keystroke stroke ;
  uint8_t u ;
  int auth ;
  enum cli_do ret ;

  auth = (node == AUTH_NODE || node == AUTH_ENABLE_NODE) ;

  /* Now process as much as possible of what there is                   */
  ret = cli_do_nothing ;
  while (1)
    {
      if (!vio->cli_drawn)
        uty_cli_draw(vio, node) ;

      if (!uty_cli_get_keystroke(vio, &stroke))
        break ;

      if (stroke.flags != 0)
        {
          /* TODO: deal with broken keystrokes                          */
          continue ;
        } ;

      switch (stroke.type)
      {
        /* Straightforward character -----------------------------------*/
        /* Note: only interested in 8-bit characters !                  */
        case ks_char:
          u = (uint8_t)stroke.value ;

          switch (stroke.value)
          {
            case CONTROL('A'):
              uty_cli_bol (vio);
              break;

            case CONTROL('B'):
              uty_cli_backwards(vio, 1);
              break;

            case CONTROL('C'):
              ret = cli_do_ctrl_c ;     /* Exit on ^C ..................*/
              break ;

            case CONTROL('D'):
              if (vio->cl.len == 0)     /* if at start of empty line    */
                ret = cli_do_ctrl_d ;   /* Exit on ^D ..................*/
              else
                uty_cli_del_forwards(vio, 1);
              break;

            case CONTROL('E'):
              uty_cli_eol (vio);
              break;

            case CONTROL('F'):
              uty_cli_forwards(vio, 1);
              break;

            case CONTROL('H'):
            case 0x7f:
              uty_cli_del_backwards(vio, 1);
              break;

            case CONTROL('K'):
              uty_cli_del_to_eol (vio);
              break;

            case CONTROL('N'):
              uty_cli_next_line (vio);
              break;

            case CONTROL('P'):
              uty_cli_previous_line (vio);
              break;

            case CONTROL('T'):
              uty_cli_transpose_chars (vio);
              break;

            case CONTROL('U'):
              uty_cli_clear_line(vio);
              break;

            case CONTROL('W'):
              uty_cli_del_word_backwards (vio);
              break;

            case CONTROL('Z'):
              ret = cli_do_ctrl_z ;     /* Exit on ^Z ..................*/
              break;

            case '\n':
            case '\r':
              ret = cli_do_command ;    /* Exit on CR or LF.............*/
              break ;

            case '\t':
              if (auth)
                break ;
              else
                uty_cli_complete_command (vio, node);
              break;

            case '?':
              if (auth)
                uty_cli_insert (vio, (char*)&u, 1);
              else
                uty_cli_describe_command (vio, node);
              break;

            default:
              if ((stroke.value >= 0x20) && (stroke.value < 0x7F))
                uty_cli_insert (vio, (char*)&u, 1) ;
              break;
            }
          break ;

        /* ESC X -------------------------------------------------------------*/
        case ks_esc:
          switch (stroke.value)
          {
            case 'b':
              uty_cli_word_backwards (vio);
              break;

            case 'f':
              uty_cli_word_forwards (vio);
              break;

            case 'd':
              uty_cli_del_word_forwards (vio);
              break;

            case CONTROL('H'):
            case 0x7f:
              uty_cli_del_word_backwards (vio);
              break;

            default:
              break;
          } ;
          break ;

        /* ESC [ X -----------------------------------------------------------*/
        case ks_csi:
          if (stroke.len != 0)
            break ;             /* only recognise 3 byte sequences      */

          switch (stroke.value)
          {
            case ('A'):
              uty_cli_previous_line (vio);
              break;

            case ('B'):
              uty_cli_next_line (vio);
              break;

            case ('C'):
              uty_cli_forwards(vio, 1);
              break;

            case ('D'):
              uty_cli_backwards(vio, 1);
              break;
            default:
              break ;
          } ;
          break ;

        /* Telnet Command ----------------------------------------------------*/
        case ks_iac:
          uty_telnet_command(vio, &stroke) ;
          break ;

        /* Single byte escape ------------------------------------------------*/
        default:
          zabort("unknown keystroke type") ;
      } ;

      /* After each keystroke.....                                      */

      if (ret != cli_do_nothing)
        {
          uty_cli_eol (vio) ;   /* go to the end of the line    */
          break ;               /* stop processing              */
        } ;
    } ;

  /* Tidy up and return where got to.                                   */

  qs_term(&vio->cl) ;           /* add '\0'                     */

  return ret ;
} ;

/*==============================================================================
 * Support for the "--More--" handling
 */

#define MSG_MORE_PROMPT "--more--"

/*------------------------------------------------------------------------------
 * Output the "--more--" prompt and enter waiting for more state.
 *
 * As enters the waiting state, empties all the available input into the
 * keystroke FIFO...  so doesn't treat anything that arrived before the
 * prompt was issued as a response to the prompt !
 *
 * Enables read  -- now waiting for response to --more--
 *
 * NB: it is the caller's responsibility to clear the "--more--" prompt from
 *     the CLI buffer.
 */
extern void
uty_cli_want_more(vty_io vio)
{
  int  get ;

  /* Empty the input buffers into the keystroke FIFO                    */
  do
    {
      get = uty_read(vio, NULL) ;
    } while (get > 0) ;

  /* Output the prompt and update the state                             */
  uty_cli_write_s(vio, MSG_MORE_PROMPT) ;

  vio->cmd_wait_more    = 1 ;

  uty_file_set_read(&vio->file, on) ;
} ;

/*------------------------------------------------------------------------------
 * Waiting for response to "--more--" prompt.
 *
 * Steal the next available keystroke and process it.  Error and EOF appear as
 * a null keystroke.
 *
 * Wipes the prompt and exits cli_wait_more state when has stolen keystroke.
 *
 * Enables write -- need to clear the prompt from the cli buffers and may
 *                  now continue command output, or signal it's done.
 */
extern void
uty_cli_wait_more(vty_io vio)
{
  struct keystroke steal ;

  /* The read fetches a reasonable lump from the I/O -- so if there is a
   * complete keystroke available, expect to get it.
   *
   * If no complete keystroke available to steal, returns ks_null.
   *
   * If has hit EOF (or error etc), returns knull_eof.
   */
  uty_read(vio, &steal) ;

  if ((steal.type == ks_null) || (steal.value != knull_eof))
    return ;

  /* Stolen a keystroke -- a (very) few terminate all output            */
  if (steal.type == ks_char)
    {
      switch (steal.value)
      {
        case CONTROL('C'):
        case 'q':
        case 'Q':
          uty_out_discard(vio) ;
          break;

        default:                /* evrything else, thrown away  */
          break ;
      } ;
    } ;

  /* Wipe out the prompt and update state.                              */
  uty_cli_out_wipe_n(vio, - (int)strlen(MSG_MORE_PROMPT)) ;

  vio->cmd_wait_more    = 0 ;

  uty_file_set_write(&vio->file, on) ;
} ;

/*==============================================================================
 * Command line operations
 */

/*------------------------------------------------------------------------------
 * Insert 'n' characters at current position in the command line
 *
 * Returns number of characters inserted -- ie 'n'
 */
static int
uty_cli_insert (vty_io vio, const char* chars, int n)
{
  int after ;

  VTY_ASSERT_LOCKED() ;

  assert((vio->cl.cp <= vio->cl.len)&& (n >= 0)) ;

  if (n <= 0)
    return n ;          /* avoid trouble        */

  after = qs_insert(&vio->cl, chars, n) ;

  uty_cli_echo(vio, qs_cp_char(&vio->cl), after + n) ;

  if (after != 0)
    uty_cli_echo_n(vio, telnet_backspaces, after) ;

  vio->cl.cp  += n ;

  return n ;
} ;

/*------------------------------------------------------------------------------
 * Overstrike 'n' characters at current position in the command line
 *
 * Move current position forwards.
 *
 * Returns number of characters inserted -- ie 'n'
 */
static int
uty_cli_overwrite (vty_io vio, char* chars, int n)
{
  VTY_ASSERT_LOCKED() ;

  assert((vio->cl.cp <= vio->cl.len) && (n >= 0)) ;

  if (n > 0)
    {
      qs_replace(&vio->cl, chars, n) ;
      uty_cli_echo(vio, chars, n) ;

      vio->cl.cp += n ;
    } ;

  return n ;
}

/*------------------------------------------------------------------------------
 * Insert a word into vty interface with overwrite mode.
 *
 * NB: Assumes result will then be the end of the line.
 *
 * Returns number of characters inserted -- ie length of string
 */
static int
uty_cli_word_overwrite (vty_io vio, char *str)
{
  int n ;
  VTY_ASSERT_LOCKED() ;

  n = uty_cli_overwrite(vio, str, strlen(str)) ;

  vio->cl.len = vio->cl.cp ;

  return n ;
}

/*------------------------------------------------------------------------------
 * Forward 'n' characters -- stop at end of line.
 *
 * Returns number of characters actually moved
 */
static int
uty_cli_forwards(vty_io vio, int n)
{
  int c ;
  VTY_ASSERT_LOCKED() ;

  c = vio->cl.len - vio->cl.cp ;
  if (n > c)
    n = c ;

  assert(n >= 0) ;

  if (n > 0)
    {
      uty_cli_echo(vio, qs_cp_char(&vio->cl), n) ;
      vio->cl.cp += n ;
    } ;

  return n ;
}

/*------------------------------------------------------------------------------
 * Backwards 'n' characters -- stop at start of line.
 *
 * Returns number of characters actually moved
 */
static int
uty_cli_backwards(vty_io vio, int n)
{
  int c ;
  VTY_ASSERT_LOCKED() ;

  c = vio->cl.len - vio->cl.cp ;
  if (n > c)
    n = c ;

  assert(n >= 0) ;

  uty_cli_echo_n(vio, telnet_backspaces, n) ;
  vio->cl.cp -= n ;

  return n ;
}

/*------------------------------------------------------------------------------
 * Delete 'n' characters -- forwards -- stop at end of line.
 *
 * Returns number of characters actually deleted.
 */
static int
uty_cli_del_forwards(vty_io vio, int n)
{
  int after ;

  VTY_ASSERT_LOCKED() ;

  assert((vio->cl.len - vio->cl.cp) && (n >= 0)) ;

  if (n <= 0)
    return 0 ;

  after = qs_delete(&vio->cl, n) ;

  if (after > 0)
    uty_cli_echo(vio, qs_cp_char(&vio->cl), after) ;

  uty_cli_echo_n(vio, telnet_spaces,     n) ;
  uty_cli_echo_n(vio, telnet_backspaces, after + n) ;

  vio->cl.len -= n ;

  return n ;
}

/*------------------------------------------------------------------------------
 * Delete 'n' characters before the point.
 *
 * Returns number of characters actually deleted.
 */
static int
uty_cli_del_backwards(vty_io vio, int n)
{
  return uty_cli_del_forwards(vio, uty_cli_backwards(vio, n)) ;
}

/*------------------------------------------------------------------------------
 * Move to the beginning of the line.
 *
 * Returns number of characters moved over.
 */
static int
uty_cli_bol (vty_io vio)
{
  return uty_cli_backwards(vio, vio->cl.cp) ;
} ;

/*------------------------------------------------------------------------------
 * Move to the end of the line.
 *
 * Returns number of characters moved over
 */
static int
uty_cli_eol (vty_io vio)
{
  return uty_cli_forwards(vio, vio->cl.len - vio->cl.cp) ;
} ;

/*------------------------------------------------------------------------------
 * Forward word delta -- distance to start of next word.
 *
 * Return number of characters to step over to reach next word.
 *
 * Steps over non-space characters and then any spaces.
 */
static int
uty_cli_word_forwards_delta(vty_io vio)
{
  char* cp ;
  char* tp ;
  char* ep ;

  VTY_ASSERT_LOCKED() ; ;

  assert(vio->cl.cp <= vio->cl.len) ;

  cp = qs_cp_char(&vio->cl) ;
  ep = qs_ep_char(&vio->cl) ;

  tp = cp ;

  while ((tp < ep) && (*tp != ' '))
    ++tp ;

  while ((tp < ep) && (*tp == ' '))
    ++tp ;

  return tp - cp ;
} ;

/*------------------------------------------------------------------------------
 * Forward word -- move to start of next word.
 *
 * Moves past any non-spaces, then past any spaces.
 */
static int
uty_cli_word_forwards(vty_io vio)
{
  return uty_cli_forwards(vio, uty_cli_word_forwards_delta(vio)) ;
} ;

/*------------------------------------------------------------------------------
 * Backward word delta -- distance to start of next word, back.
 *
 * Return number of characters to step over to reach next word.
 *
 * If "eat_spaces", starts by stepping over spaces.
 * Steps back until next (backwards) character is space, or hits start of line.
 */
static int
uty_cli_word_backwards_delta(vty_io vio, int eat_spaces)
{
  char* cp ;
  char* tp ;
  char* sp ;

  VTY_ASSERT_LOCKED() ; ;

  assert(vio->cl.cp <= vio->cl.len) ;

  cp = qs_cp_char(&vio->cl) ;
  sp = qs_chars(&vio->cl) ;

  tp = cp ;

  if (eat_spaces)
    while ((tp > sp) && (*(tp - 1) == ' '))
      --tp ;

  while ((tp > sp) && (*(tp - 1) != ' '))
    --tp ;

  return cp - tp ;
} ;

/*------------------------------------------------------------------------------
 * Backward word, but not trailing spaces.
 *
 * Move back until next (backwards) character is space or start of line.
 *
 * Returns number of characters stepped over.
 */
static int
uty_cli_word_backwards_pure (vty_io vio)
{
  return uty_cli_backwards(vio, uty_cli_word_backwards_delta(vio, 0)) ;
} ;

/*------------------------------------------------------------------------------
 * Backward word -- move to start of previous word.
 *
 * Moves past any spaces, then move back until next (backwards) character is
 * space or start of line.
 *
 * Returns number of characters stepped over.
 */
static int
uty_cli_word_backwards (vty_io vio)
{
  return uty_cli_backwards(vio, uty_cli_word_backwards_delta(vio, 1)) ;
} ;

/*------------------------------------------------------------------------------
 * Delete to end of word -- forwards.
 *
 * Deletes any leading spaces, then deletes upto next space or end of line.
 *
 * Returns number of characters deleted.
 */
static int
uty_cli_del_word_forwards(vty_io vio)
{
  return uty_cli_del_forwards(vio, uty_cli_word_forwards_delta(vio)) ;
}

/*------------------------------------------------------------------------------
 * Delete to start of word -- backwards.
 *
 * Deletes any trailing spaces, then deletes upto next space or start of line.
 *
 * Returns number of characters deleted.
 */
static int
uty_cli_del_word_backwards(vty_io vio)
{
  return uty_cli_del_backwards(vio, uty_cli_word_backwards_delta(vio, 1)) ;
} ;

/*------------------------------------------------------------------------------
 * Kill rest of line from current point.
 *
 * Returns number of characters deleted.
 */
static int
uty_cli_del_to_eol (vty_io vio)
{
  return uty_cli_del_forwards(vio, vio->cl.len - vio->cl.cp) ;
} ;

/*------------------------------------------------------------------------------
 * Kill line from the beginning.
 *
 * Returns number of characters deleted.
 */
static int
uty_cli_clear_line(vty_io vio)
{
  uty_cli_bol(vio) ;
  return uty_cli_del_to_eol(vio) ;
} ;

/*------------------------------------------------------------------------------
 * Transpose chars before or at the point.
 *
 * Return number of characters affected.
 */
static int
uty_cli_transpose_chars(vty_io vio)
{
  char  chars[2] ;
  char* cp ;

  VTY_ASSERT_LOCKED() ;

  /* Give up if < 2 characters or at start of line.                     */
  if ((vio->cl.len < 2) || (vio->cl.cp < 1))
    return 0 ;

  /* Move back to first of characters to exchange                       */
  if (vio->cl.cp == vio->cl.len)
    uty_cli_backwards(vio, 2) ;
  else
    uty_cli_backwards(vio, 1) ;

  /* Pick up in the new order                                           */
  cp = qs_cp_char(&vio->cl) ;
  chars[1] = *cp++ ;
  chars[0] = *cp ;

  /* And overwrite                                                      */
  return uty_cli_overwrite(vio, chars, 2) ;
} ;

/*==============================================================================
 * Command line history handling
 */

/*------------------------------------------------------------------------------
 * Add given command line to the history buffer.
 *
 * This is inserting the vty->buf line into the history.
 */
extern void
uty_cli_hist_add (vty_io vio, const char* cmd_line)
{
  char* prev_line ;
  char* line ;
  char* e ;
  int   prev_index ;

  VTY_ASSERT_LOCKED() ;

  /* make sure have a suitable history vector                           */
  vector_set_min_length(&vio->hist, VTY_MAXHIST) ;

  /* trim leading and trailing spaces before considering for history    */

  while (*cmd_line == ' ')
    ++cmd_line ;                /* hack off leading spaces              */

  if (*cmd_line == '\0')
    return ;                    /* ignore empty lines                   */

  line = XSTRDUP(MTYPE_VTY_HIST, cmd_line) ;

  e = line + strlen(line) ;
  while (*(e - 1) == ' ')
    --e ;
  *e = '\0' ;                   /* hack off any trailing spaces         */

  /* find the previous command line in the history                      */
  prev_index = vio->hindex - 1 ;
  if (prev_index < 0)
    prev_index = VTY_MAXHIST - 1 ;

  prev_line = vector_get_item(&vio->hist, prev_index) ;

  /* Insert unless same as previous line                                */
  if ((prev_line == NULL) || (strcmp(line, prev_line) != 0))
    {
      /* Insert history entry.                          */
      if (prev_line != NULL)
        XFREE (MTYPE_VTY_HIST, prev_line) ;

      vector_set_item(&vio->hist, vio->hindex, line) ;

      /* History index rotation.                        */
      vio->hindex++;
      if (vio->hindex == VTY_MAXHIST)
        vio->hindex = 0;
    }
  else
    {
      XFREE(MTYPE_VTY_HIST, line) ;
    } ;

  vio->hp = vio->hindex;
} ;

/*------------------------------------------------------------------------------
 * Replace command line by current history.
 *
 * This function is called from vty_next_line and vty_previous_line.
 */
static void
uty_cli_history_use(vty_io vio, int step)
{
  int       index ;
  unsigned  new_len ;
  unsigned  old_len ;
  char*     hist ;

  VTY_ASSERT_LOCKED() ;

  /* See if have anything usable                                        */
  index = vio->hp ;

  if ((step > 0) && (index == vio->hindex))
    return ;    /* cannot step forward past the insertion point         */

  index += step ;
  if      (index < 0)
    index = VTY_MAXHIST - 1 ;
  else if (index >= VTY_MAXHIST) ;
    index = 0 ;

  if ((step < 0) && (index == vio->hindex))
    return ;    /* cannot step back to the insertion point              */

  hist = vector_get_item(&vio->hist, index) ;
  if (hist == NULL)
    return ;    /* cannot step to unused entry                          */

  vio->hp = index;

  /* Move back to the start of the current line                         */
  uty_cli_bol(vio) ;

  /* Get previous line from history buffer and echo that                */
  old_len = vio->cl.len ;
  new_len = qs_set(&vio->cl, hist) ;
  vio->cl.cp = new_len ;

  uty_cli_echo(vio, hist, new_len) ;

  if (old_len < new_len)
    uty_cli_del_to_eol(vio) ;

  return ;
} ;

/*------------------------------------------------------------------------------
 * Use next history line, if any.
 */
static void
uty_cli_next_line(vty_io vio)
{
  uty_cli_history_use(vio, +1) ;
}

/*------------------------------------------------------------------------------
 * Use previous history line, if any.
 */
static void
uty_cli_previous_line (vty_io vio)
{
  uty_cli_history_use(vio, -1) ;
}

/*==============================================================================
 * Command Completion and Command Description
 *
 */
static void uty_cli_describe_show(vty_io vio, vector describe) ;
static void uty_cli_describe_fold (vty_io vio, int cmd_width,
                                   unsigned int desc_width, struct desc *desc) ;
static void uty_cli_describe_line(vty_io vio, int cmd_width, const char* cmd,
                                                             const char* str) ;

static vector uty_cli_cmd_prepare(vty_io vio, int help) ;

/*------------------------------------------------------------------------------
 * Command completion
 */
static void
uty_cli_complete_command (vty_io vio, enum node_type node)
{
  unsigned i ;
  int ret ;
  vector matched ;
  vector vline ;

  VTY_ASSERT_LOCKED() ;

  /* Try and match the tokenised command line                           */
  vline = uty_cli_cmd_prepare(vio, 1) ;
  matched = cmd_complete_command (vline, node, &ret);
  cmd_free_strvec (vline);

  /* Show the result.                                                   */
  switch (ret)
    {
      case CMD_ERR_AMBIGUOUS:
        uty_cli_out_newline(vio) ;              /* clears cli_drawn     */
        uty_cli_out_CMD_ERR_AMBIGUOUS(vio) ;
        break ;

      case CMD_ERR_NO_MATCH:
        uty_cli_out_newline(vio) ;              /* clears cli_drawn     */
        uty_cli_out_CMD_ERR_NO_MATCH(vio) ;
        break ;

      case CMD_COMPLETE_FULL_MATCH:
        uty_cli_eol (vio) ;
        uty_cli_word_backwards_pure (vio);
        uty_cli_word_overwrite (vio, vector_get_item(matched, 0));
        uty_cli_insert(vio, " ", 1);
        break ;

      case CMD_COMPLETE_MATCH:
        uty_cli_eol (vio) ;
        uty_cli_word_backwards_pure (vio);
        uty_cli_word_overwrite (vio, vector_get_item(matched, 0));
        break ;

      case CMD_COMPLETE_LIST_MATCH:
        for (i = 0; i < vector_end(matched); i++)
          {
            if ((i % 6) == 0)
              uty_cli_out_newline(vio) ;        /* clears cli_drawn     */
            uty_cli_out (vio, "%-10s ", (char*)vector_get_item(matched, i));
          }

        break;

      case CMD_ERR_NOTHING_TODO:
      default:
        break;
    } ;

  cmd_free_strvec(matched);
} ;

/*------------------------------------------------------------------------------
 * Command Description
 */
static void
uty_cli_describe_command (vty_io vio, enum node_type node)
{
  int ret;
  vector vline;
  vector describe;

  VTY_ASSERT_LOCKED() ;

  /* Try and match the tokenised command line                           */
  vline = uty_cli_cmd_prepare(vio, 1) ;
  describe = cmd_describe_command (vline, node, &ret);
  cmd_free_strvec (vline);

  uty_cli_out_newline(vio);     /* clears cli_drawn     */

  /* Deal with result.                                                  */
  switch (ret)
    {
    case CMD_ERR_AMBIGUOUS:
      uty_cli_out_CMD_ERR_AMBIGUOUS(vio) ;
      break ;

    case CMD_ERR_NO_MATCH:
      uty_cli_out_CMD_ERR_NO_MATCH(vio) ;
      break ;

    default:
      uty_cli_describe_show(vio, describe) ;
      break ;
    } ;

  if (describe != NULL)
    vector_free (describe);
}

/*------------------------------------------------------------------------------
 * Show the command description.
 *
 * Generates lines of the form:
 *
 *   word     description text
 *
 * Where the word field is adjusted to suit the longest word, and the
 * description text is wrapped if required (if the width of the console is
 * known) so that get:
 *
 *   word     description ..................................
 *            .............text
 *
 * If one of the options is '<cr>', that is always shown last.
 */
static void
uty_cli_describe_show(vty_io vio, vector describe)
{
  unsigned int i, cmd_width, desc_width;
  struct desc *desc, *desc_cr ;

  /* Get width of the longest "word"                                    */
  cmd_width = 0;
  for (i = 0; i < vector_active (describe); i++)
    if ((desc = vector_slot (describe, i)) != NULL)
      {
        unsigned int len;

        if (desc->cmd[0] == '\0')
          continue;

        len = strlen (desc->cmd);
        if (desc->cmd[0] == '.')
          len--;

        if (cmd_width < len)
          cmd_width = len;
      }

  /* Set width of description string.                                   */
  desc_width = vio->width - (cmd_width + 6);

  /* Print out description.                                             */
  desc_cr = NULL ;      /* put <cr> last if it appears  */

  for (i = 0; i < vector_active (describe); i++)
    if ((desc = vector_slot (describe, i)) != NULL)
      {
        if (desc->cmd[0] == '\0')
          continue;

        if (strcmp (desc->cmd, command_cr) == 0)
          {
            desc_cr = desc;
            continue;
          }

        uty_cli_describe_fold (vio, cmd_width, desc_width, desc);
      }

  if (desc_cr != NULL)
    uty_cli_describe_fold (vio, cmd_width, desc_width, desc_cr);
} ;

/*------------------------------------------------------------------------------
 * Show one word and the description, folding the description as required.
 */
static void
uty_cli_describe_fold (vty_io vio, int cmd_width,
                       unsigned int desc_width, struct desc *desc)
{
  char *buf;
  const char *cmd, *p;
  int pos;

  VTY_ASSERT_LOCKED() ;

  cmd = desc->cmd[0] == '.' ? desc->cmd + 1 : desc->cmd;
  p = desc->str ;

  /* If have a sensible description width                       */
  if (desc_width > 20)
    {
      buf = XCALLOC (MTYPE_TMP, strlen (desc->str) + 1);

      while (strlen (p) > desc_width)
        {
          /* move back to first space                   */
          for (pos = desc_width; pos > 0; pos--)
            if (*(p + pos) == ' ')
              break;

          /* if did not find a space, break at width    */
          if (pos == 0)
            pos = desc_width ;

          strncpy (buf, p, pos);
          buf[pos] = '\0';
          uty_cli_describe_line(vio, cmd_width, cmd, buf) ;

          cmd = "";             /* for 2nd and subsequent lines */

          p += pos ;            /* step past what just wrote    */
          while (*p == ' ')
            ++p ;               /* skip spaces                  */
        } ;

      XFREE (MTYPE_TMP, buf);
    } ;

  uty_cli_describe_line(vio, cmd_width, cmd, p) ;
} ;

/*------------------------------------------------------------------------------
 * Show one description line.
 */
static void
uty_cli_describe_line(vty_io vio, int cmd_width, const char* cmd,
                                                      const char* str)
{
  if (str != NULL)
    uty_cli_out (vio, "  %-*s  %s", cmd_width, cmd, str) ;
  else
    uty_cli_out (vio, "  %-s", cmd) ;
  uty_cli_out_newline(vio) ;
} ;

/*------------------------------------------------------------------------------
 * Prepare "vline" token array for command handler.
 *
 * For "help" (command completion/description), if the command line is empty,
 * or ends in ' ', adds an empty token to the end of the token array.
 */
static vector
uty_cli_cmd_prepare(vty_io vio, int help)
{
  vector vline ;

  vline = cmd_make_strvec(qs_term(&vio->cl)) ;

  /* Note that if there is a vector of tokens, then there is at least one
   * token, so can guarantee that vio->cl.len >= 1 !
   */
  if (help)
    if ((vline == NULL) || isspace(*qs_chars_at(&vio->cl, vio->cl.len - 1)))
      vline = cmd_add_to_strvec(vline, "") ;

  return vline ;
} ;

/*==============================================================================
 * VTY telnet stuff
 */

#define TELNET_OPTION_DEBUG 1           /* 0 to turn off        */

static const char* telnet_commands[256] =
{
  [tn_IAC  ] = "IAC",
  [tn_DONT ] = "DONT",
  [tn_DO   ] = "DO",
  [tn_WONT ] = "WONT",
  [tn_WILL ] = "WILL",
  [tn_SB   ] = "SB",
  [tn_GA   ] = "GA",
  [tn_EL   ] = "EL",
  [tn_EC   ] = "EC",
  [tn_AYT  ] = "AYT",
  [tn_AO   ] = "AO",
  [tn_IP   ] = "IP",
  [tn_BREAK] = "BREAK",
  [tn_DM   ] = "DM",
  [tn_NOP  ] = "NOP",
  [tn_SE   ] = "SE",
  [tn_EOR  ] = "EOR",
  [tn_ABORT] = "ABORT",
  [tn_SUSP ] = "SUSP",
  [tn_EOF  ] = "EOF",
} ;

static const char* telnet_options[256] =
{
  [to_BINARY]       = "BINARY",      /* 8-bit data path                  */
  [to_ECHO]         = "ECHO",        /* echo                             */
  [to_RCP]          = "RCP",         /* prepare to reconnect             */
  [to_SGA]          = "SGA",         /* suppress go ahead                */
  [to_NAMS]         = "NAMS",        /* approximate message size         */
  [to_STATUS]       = "STATUS",      /* give status                      */
  [to_TM]           = "TM",          /* timing mark                      */
  [to_RCTE]         = "RCTE",        /* remote controlled tx and echo    */
  [to_NAOL]         = "NAOL",        /* neg. about output line width     */
  [to_NAOP]         = "NAOP",        /* neg. about output page size      */
  [to_NAOCRD]       = "NAOCRD",      /* neg. about CR disposition        */
  [to_NAOHTS]       = "NAOHTS",      /* neg. about horizontal tabstops   */
  [to_NAOHTD]       = "NAOHTD",      /* neg. about horizontal tab disp.  */
  [to_NAOFFD]       = "NAOFFD",      /* neg. about formfeed disposition  */
  [to_NAOVTS]       = "NAOVTS",      /* neg. about vertical tab stops    */
  [to_NAOVTD]       = "NAOVTD",      /* neg. about vertical tab disp.    */
  [to_NAOLFD]       = "NAOLFD",      /* neg. about output LF disposition */
  [to_XASCII]       = "XASCII",      /* extended ascii character set     */
  [to_LOGOUT]       = "LOGOUT",      /* force logout                     */
  [to_BM]           = "BM",          /* byte macro                       */
  [to_DET]          = "DET",         /* data entry terminal              */
  [to_SUPDUP]       = "SUPDUP",      /* supdup protocol                  */
  [to_SUPDUPOUTPUT] = "SUPDUPOUTPUT",/* supdup output                    */
  [to_SNDLOC]       = "SNDLOC",      /* send location                    */
  [to_TTYPE]        = "TTYPE",       /* terminal type                    */
  [to_EOR]          = "EOR",         /* end or record                    */
  [to_TUID]         = "TUID",        /* TACACS user identification       */
  [to_OUTMRK]       = "OUTMRK",      /* output marking                   */
  [to_TTYLOC]       = "TTYLOC",      /* terminal location number         */
  [to_3270REGIME]   = "3270REGIME",  /* 3270 regime                      */
  [to_X3PAD]        = "X3PAD",       /* X.3 PAD                          */
  [to_NAWS]         = "NAWS",        /* window size                      */
  [to_TSPEED]       = "TSPEED",      /* terminal speed                   */
  [to_LFLOW]        = "LFLOW",       /* remote flow control              */
  [to_LINEMODE]     = "LINEMODE",    /* Linemode option                  */
  [to_XDISPLOC]     = "XDISPLOC",    /* X Display Location               */
  [to_OLD_ENVIRON]  = "OLD_ENVIRON", /* Old - Environment variables      */
  [to_AUTHENTICATION] = "AUTHENTICATION",  /* Authenticate               */
  [to_ENCRYPT]      = "ENCRYPT",     /* Encryption option                */
  [to_NEW_ENVIRON]  = "NEW_ENVIRON", /* New - Environment variables      */
  [to_EXOPL]        = "EXOPL",       /* extended-options-list            */
} ;

/*------------------------------------------------------------------------------
 * For debug.  Put string or value as decimal.
 */
static void
uty_cli_out_dec(vty_io vio, const char* str, unsigned char u)
{
  if (str != NULL)
    uty_cli_out(vio, "%s ", str) ;
  else
    uty_cli_out(vio, "%d ", (int)u) ;
} ;

/*------------------------------------------------------------------------------
 * For debug.  Put string or value as hex.
 */
static void
uty_cli_out_hex(vty_io vio, const char* str, unsigned char u)
{
  if (str != NULL)
    uty_cli_out(vio, "%s ", str) ;
  else
    uty_cli_out(vio, "0x%02x ", (unsigned)u) ;
} ;

/*------------------------------------------------------------------------------
 * Send telnet: "WILL TELOPT_ECHO"
 */
extern void
uty_will_echo (vty_io vio)
{
  unsigned char cmd[] = { tn_IAC, tn_WILL, to_ECHO };
  VTY_ASSERT_LOCKED() ;
  uty_cli_write (vio, (char*)cmd, (int)sizeof(cmd));
}

/*------------------------------------------------------------------------------
 * Send telnet: "suppress Go-Ahead"
 */
extern void
uty_will_suppress_go_ahead (vty_io vio)
{
  unsigned char cmd[] = { tn_IAC, tn_WILL, to_SGA };
  VTY_ASSERT_LOCKED() ;
  uty_cli_write (vio, (char*)cmd, (int)sizeof(cmd));
}

/*------------------------------------------------------------------------------
 * Send telnet: "don't use linemode"
 */
extern void
uty_dont_linemode (vty_io vio)
{
  unsigned char cmd[] = { tn_IAC, tn_DONT, to_LINEMODE };
  VTY_ASSERT_LOCKED() ;
  uty_cli_write (vio, (char*)cmd, (int)sizeof(cmd));
}

/*------------------------------------------------------------------------------
 * Send telnet: "Use window size"
 */
extern void
uty_do_window_size (vty_io vio)
{
  unsigned char cmd[] = { tn_IAC, tn_DO, to_NAWS };
  VTY_ASSERT_LOCKED() ;
  uty_cli_write (vio, (char*)cmd, (int)sizeof(cmd));
}

/*------------------------------------------------------------------------------
 * Send telnet: "don't use lflow"       -- not currently used
 */
extern void
uty_dont_lflow_ahead (vty_io vio)
{
  unsigned char cmd[] = { tn_IAC, tn_DONT, to_LFLOW };
  VTY_ASSERT_LOCKED() ;
  uty_cli_write (vio, (char*)cmd, (int)sizeof(cmd));
}

/*------------------------------------------------------------------------------
 * Process incoming Telnet Option(s)
 *
 * In particular: get telnet window size.
 */
static void
uty_telnet_command(vty_io vio, keystroke stroke)
{
  uint8_t* p ;
  uint8_t  o ;
  int left ;

  /* Echo to the other end if required                                  */
  if (TELNET_OPTION_DEBUG)
    {
      p    = stroke->buf ;
      left = stroke->len ;

      uty_cli_out_hex(vio, telnet_commands[tn_IAC], tn_IAC) ;

      if (left-- > 0)
        uty_cli_out_dec(vio, telnet_commands[*p], *p) ;
      ++p ;

      if (left-- > 0)
        uty_cli_out_dec(vio, telnet_options[*p], *p) ;
      ++p ;

      if (left > 0)
        {
          while(left-- > 0)
            uty_cli_out_hex(vio, NULL, *p++) ;

          if (stroke->flags & kf_truncated)
            uty_cli_out(vio, "... ") ;

          if (!(stroke->flags & kf_broken))
            {
              uty_cli_out_hex(vio, telnet_commands[tn_IAC], tn_IAC) ;
              uty_cli_out_hex(vio, telnet_commands[tn_SE], tn_SE) ;
            }
        } ;

      if (!(stroke->flags & kf_broken))
        uty_cli_out (vio, "BROKEN") ;

      uty_cli_out (vio, "\r\n") ;

    } ;

  /* Process the telnet command                                         */
  if (stroke->flags != 0)
    return ;                    /* go no further if broken              */

  p    = stroke->buf ;
  left = stroke->len ;

  passert(left >= 1) ;            /* must be if not broken !            */
  passert(stroke->value == *p) ;  /* or something is wrong              */

  ++p ;         /* step past X of IAC X */
  --left ;

  /* Decode the one command that is interesting -- "NAWS"               */
  switch (stroke->value)
  {
    case tn_SB:
      passert(left > 0) ;       /* or parser failed     */

      o = *p++ ;                /* the option byte      */
      --left ;
      switch(o)
      {
        case to_NAWS:
          if (left != 4)
            {
              uzlog(NULL, LOG_WARNING,
                        "RFC 1073 violation detected: telnet NAWS option "
                        "should send %d characters, but we received %d",
                        (3 + 4 + 2), (3 + left + 2)) ;
            }
          else
            {
              vio->width   = *p++ << 8 ;
              vio->width  += *p++ ;
              vio->height  = *p++ << 8 ;
              vio->height += *p ;

              if (TELNET_OPTION_DEBUG)
                uty_cli_out(vio, "TELNET NAWS window size received: "
                                 "width %d, height %d%s",
                                  vio->width, vio->height, telnet_newline) ;
            } ;
          break ;

        default:        /* no other IAC SB <option>     */
          break ;
      } ;
      break ;

    default:            /* no other IAC X               */
      break ;
  } ;
} ;