First beta release

Various bug fixes and improvements.

Running with a fair amount of debug/assert code, which must be
removed at some date.

1 files changed, 1163 insertions, 622 deletions

diff --git a/lib/vty_io.c b/lib/vty_io.c
index 15f90219..7137fbdc 100644
--- a/lib/vty_io.c
+++ b/lib/vty_io.c
@@ -46,21 +46,12 @@
 /*==============================================================================
  * VTY Command Output -- base functions
  *
- * ALL vty command output ends up here.
- *
- *   vty == NULL    => vprintf(stdout, ...)
- *   VTY_SHELL      => vprintf(stdout, ...)
- *   VTY_STDOUT     => vprintf(stdout, ...)
- *
- *   VTY_FILE       => write(fd, ....)
- *
- *   VTY_TERM       => command FIFO
- *   VTY_SHELL_SERV => command FIFO
- *
  * During command processing the output sent here is held until the command
  * completes.
  */
 
+static int uty_config_write(vty_io vio, bool all) ;
+
 /*------------------------------------------------------------------------------
  * VTY output function -- cf fprintf
  *
@@ -84,71 +75,111 @@ uty_out (struct vty *vty, const char *format, ...)
  *
  * Returns: >= 0 => OK
  *          <  0 => failed (see errno)
+ *
+ * NB: for VTY_TERM and for VTY_SHELL_SERV -- this is command output:
+ *
+ *     * MAY NOT do any command output if !cmd_enabled
+ *
+ *        * first, the life of a vty is not guaranteed unless cmd_in_progress,
+ *          so should not attempt to use a vty anywhere other than command
+ *          execution.
+ *
+ *        * second, cmd_out_enabled is false most of the time, and is only
+ *          set true when a command completes, and it is time to write away
+ *          the results.
+ *
+ *     * all output is placed in the vio->cmd_obuf.  When the command completes,
+ *       the contents of the cmd_obuf will be written away -- subject to line
+ *       control.
+ *
+ *     * output is discarded if the vty is no longer write_open
  */
 extern int
 uty_vout(struct vty *vty, const char *format, va_list args)
 {
-  enum vty_type type ;
   vty_io vio ;
-  int    len ;
+  int    ret ;
 
   VTY_ASSERT_LOCKED() ;
 
-  /* Establish type of vty -- if any                                    */
-  if (vty != NULL)
-    {
-      vio = vty->vio ;
-      if (!vio->file.write_open)
-        return 0 ;                   /* discard output if not open !    */
-
-      type = vio->type ;
-    }
-  else
-    {
-      vio = NULL ;
-      type = VTY_STDOUT ;
-    } ;
+  vio = vty->vio ;
 
-  /* Output -- process depends on type                                  */
-  switch (type)
+  switch (vio->type)
   {
     case VTY_STDOUT:
     case VTY_SHELL:
-      len = vprintf (format, args);
+      ret = vprintf (format, args) ;
+      break ;
+
+    case VTY_STDERR:
+      ret = vfprintf (stderr, format, args) ;
+      break ;
+
+    case VTY_CONFIG_WRITE:
+      ret = vio_fifo_vprintf(&vio->cmd_obuf, format, args) ;
+      if ((ret > 0) && vio_fifo_full_lump(&vio->cmd_obuf))
+        ret = uty_config_write(vio, false) ;
       break ;
 
-    case VTY_FILE:
     case VTY_TERM:
     case VTY_SHELL_SERV:
+      assert(vio->cmd_in_progress) ;
 
-      len = qs_vprintf(&vio->cmd_vbuf, format, args) ;
-      if (len > 0)
-        {
-          if (type == VTY_FILE)
-            len = write(vio->file.fd, vio->cmd_vbuf.body, len) ;
-          else
-            vio_fifo_put(&vio->cmd_obuf, vio->cmd_vbuf.body, len) ;
-        } ;
+      if (!vio->sock.write_open)
+        return 0 ;                      /* discard output if not open ! */
+
+      /* fall through....       */
+
+    case VTY_CONFIG_READ:
+      ret = vio_fifo_vprintf(&vio->cmd_obuf, format, args) ;
       break ;
 
     default:
       zabort("impossible VTY type") ;
   } ;
 
-  return len;
+  return ret ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Discard the current contents of the command FIFO
+ * Clear the contents of the command output FIFO etc.
  *
- * TODO: worry about line control ??
+ * NB: does not change any of the cli_blocked/cmd_in_progress/cli_wait_more/etc
+ *     flags -- competent parties must deal with those
  */
 extern void
-uty_out_discard(vty_io vio)
+uty_out_clear(vty_io vio)
 {
   VTY_ASSERT_LOCKED() ;
 
-  vio_fifo_set_empty(&vio->cmd_obuf) ;
+  vio_fifo_clear(&vio->cmd_obuf) ;
+
+  if (vio->cmd_lc != NULL)
+    vio_lc_clear(vio->cmd_lc) ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * Flush the contents of the command output FIFO to the given file.
+ *
+ * Takes no notice of any errors !
+ */
+extern void
+uty_out_fflush(vty_io vio, FILE* file)
+{
+  char*   src ;
+  size_t  have ;
+
+  VTY_ASSERT_LOCKED() ;
+
+  fflush(file) ;
+
+  while ((src = vio_fifo_get_lump(&vio->cmd_obuf, &have)) != NULL)
+    {
+      fwrite(src, 1, have, file) ;
+      vio_fifo_got_upto(&vio->cmd_obuf, src + have) ;
+    } ;
+
+  fflush(file) ;
 } ;
 
 /*==============================================================================
@@ -167,30 +198,13 @@ enum { vty_watch_dog_interval = 5 } ;
 static void vty_watch_dog_qnexus(qtimer qtr, void* timer_info, qtime_t when) ;
 static int vty_watch_dog_thread(struct thread *thread) ;
 
+static void uty_watch_dog_bark(void) ;
+static bool uty_death_watch_scan(void) ;
+
 /*------------------------------------------------------------------------------
- * Watch dog action
+ * Start watch dog -- the first time a VTY is created.
  */
-static void
-uty_watch_dog_bark(void)
-{
-  uty_check_host_name() ;       /* check for host name change           */
-
-  /* TODO: death watch scan                                             */
-
-  /* Set timer to go off again later                                    */
-  if (vty_cli_nexus)
-    qtimer_set(vty_watch_dog.qnexus, qt_add_monotonic(vty_watch_dog_interval),
-                                                         vty_watch_dog_qnexus) ;
-  else
-    {
-      if (vty_watch_dog.thread != NULL)
-        thread_cancel (vty_watch_dog.thread);
-      vty_watch_dog.thread = thread_add_timer (vty_master,
-                           vty_watch_dog_thread, NULL, vty_watch_dog_interval) ;
-    } ;
-} ;
-
-static void
+extern void
 uty_watch_dog_start()
 {
   if (vty_cli_nexus)
@@ -200,6 +214,12 @@ uty_watch_dog_start()
   uty_watch_dog_bark() ;        /* start up by barking the first time   */
 }
 
+/*------------------------------------------------------------------------------
+ * Stop watch dog timer -- at close down.
+ *
+ * Final run along the death-watch
+ *
+ */
 extern void
 uty_watch_dog_stop(void)
 {
@@ -210,6 +230,8 @@ uty_watch_dog_stop(void)
       else
         thread_cancel(vty_watch_dog.thread) ;
     } ;
+
+  uty_death_watch_scan() ;      /* scan the death-watch list            */
 }
 
 /*------------------------------------------------------------------------------
@@ -219,7 +241,9 @@ static void
 vty_watch_dog_qnexus(qtimer qtr, void* timer_info, qtime_t when)
 {
   VTY_LOCK() ;
+
   uty_watch_dog_bark() ;
+
   VTY_UNLOCK() ;
 } ;
 
@@ -230,17 +254,77 @@ static int
 vty_watch_dog_thread(struct thread *thread)
 {
   VTY_LOCK() ;
+
+  vty_watch_dog.thread = NULL ;
   uty_watch_dog_bark() ;
+
   VTY_UNLOCK() ;
   return 0 ;
 } ;
 
+/*------------------------------------------------------------------------------
+ * Watch dog action
+ */
+static void
+uty_watch_dog_bark(void)
+{
+  uty_check_host_name() ;       /* check for host name change           */
+
+  uty_death_watch_scan() ;      /* scan the death-watch list            */
+
+  /* Set timer to go off again later                                    */
+  if (vty_cli_nexus)
+    qtimer_set(vty_watch_dog.qnexus,
+                               qt_add_monotonic(QTIME(vty_watch_dog_interval)),
+                                                         vty_watch_dog_qnexus) ;
+  else
+    {
+      if (vty_watch_dog.thread != NULL)
+        thread_cancel (vty_watch_dog.thread);
+      vty_watch_dog.thread = thread_add_timer (vty_master,
+                           vty_watch_dog_thread, NULL, vty_watch_dog_interval) ;
+    } ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * Scan the death watch list.
+ *
+ * A vty may finally be freed if it is closed and there is no command in
+ * progress.
+ */
+static bool
+uty_death_watch_scan(void)
+{
+  vty_io  vio ;
+  vty_io  next ;
+
+  next = vio_death_watch ;
+  while (next != NULL)
+    {
+      vio  = next ;
+      next = sdl_next(vio, vio_list) ;
+
+      if (vio->closed && !vio->cmd_in_progress)
+        {
+          uty_close(vio) ;      /* closes again to ensure that all buffers
+                                   are released.                            */
+
+          sdl_del(vio_death_watch, vio, vio_list) ;
+
+          XFREE(MTYPE_VTY, vio->vty) ;
+          XFREE(MTYPE_VTY, vio) ;
+        } ;
+    } ;
+
+  return (vio_death_watch == NULL) ;
+} ;
+
 /*==============================================================================
  * Prototypes.
  */
-static void uty_file_init_new(vio_file file, int fd, void* info) ;
-static void uty_file_half_close(vio_file file) ;
-static void uty_file_close(vio_file file) ;
+static void uty_sock_init_new(vio_sock sock, int fd, void* info) ;
+static void uty_sock_half_close(vio_sock sock) ;
+static void uty_sock_close(vio_sock sock) ;
 
 static void vty_read_qnexus (qps_file qf, void* file_info) ;
 static void vty_write_qnexus (qps_file qf, void* file_info) ;
@@ -253,6 +337,8 @@ static int vty_timer_thread (struct thread *thread) ;
 static void vtysh_read_qnexus (qps_file qf, void* file_info) ;
 static int vtysh_read_thread (struct thread *thread) ;
 
+static enum vty_readiness uty_write(vty_io vio) ;
+
 /*==============================================================================
  * Creation and destruction of VTY objects
  */
@@ -260,109 +346,151 @@ static int vtysh_read_thread (struct thread *thread) ;
 /*------------------------------------------------------------------------------
  * Allocate new vty struct
  *
- * Allocates and initialises vty_io structure, complete with:
+ * Allocates and initialises basic vty and vty_io structures, setting the
+ * given type.
  *
- *   Output buffer
- *   Input buffer
- *   qpselect file -- added to CLI nexus  ) if running CLI nexus
- *   qtimer                               )
+ * Note that where is not setting up a vty_sock, this *may* be called from
+ * any thread.
  *
- * Adds to the known vty's -- which locks/unlocks momentarily.
+ * NB: may not create a VTY_CONFIG_WRITE type vty directly
+ *
+ *     see: vty_open_config_write() and vty_close_config_write()
+ *
+ * NB: the sock_fd *must* be valid for VTY_TERM and VTY_SHELL_SERV.
+ *     (So MUST be in the CLI thread to set those up !)
+ *
+ *     the sock_fd is ignored for everything else.
  *
  * Returns: new vty
  */
 extern struct vty *
-uty_new (int fd, enum vty_type type)
+uty_new(enum vty_type type, int sock_fd)
 {
   struct vty *vty ;
   struct vty_io* vio ;
 
   VTY_ASSERT_LOCKED() ;
 
-  if (vty_watch_dog.anon == NULL)
-    uty_watch_dog_start() ;
+  /* If this is a VTY_TERM or a VTY_SHELL, place     */
+  switch (type)
+  {
+    case VTY_TERM:              /* Require fd -- Telnet session         */
+    case VTY_SHELL_SERV:        /* Require fd -- Unix socket            */
+      assert(sock_fd >= 0) ;
+      break ;
+
+    case VTY_CONFIG_WRITE:
+      zabort("may not make a new VTY_CONFIG_WRITE VTY") ;
+      break ;
 
+    case VTY_CONFIG_READ:
+    case VTY_STDOUT:
+    case VTY_STDERR:
+    case VTY_SHELL:
+      sock_fd = -1 ;            /* No fd -- output to stdout/stderr     */
+      break ;
+
+    default:
+      zabort("unknown VTY type") ;
+  } ;
+
+  /* Basic allocation                                                   */
   vty = XCALLOC (MTYPE_VTY, sizeof (struct vty));
   vio = XCALLOC (MTYPE_VTY, sizeof (struct vty_io)) ;
 
   vty->vio = vio ;
   vio->vty = vty ;
 
-  /* Zeroising the vty structure has set:
-   *
-   *   node      = 0  TODO: something better for node value ????
-   *   buf       = NULL -- no command line, yet
-   *   index     = NULL -- nothing, yet
-   *   index_sub = NULL -- nothing, yet
-   */
-  confirm(AUTH_NODE == 0) ;     /* default node type    */
-
-  if (type == VTY_TERM)
-    vty->newline = "\r\n" ;
-  else
-    vty->newline = "\n" ;
-
   /* Zeroising the vty_io structure has set:
    *
+   *   name                = NULL -- no name, yet
+   *
    *   vio_list      both pointers NULL
+   *   mon_list      both pointers NULL
    *
-   *   half_closed         = 0 -- NOT half closed (important !)
-   *   timed_out           = 0 -- NOT timed out
+   *   half_closed         = 0    -- NOT half closed (important !)
+   *   closed              = 0    -- NOT closed      (important !)
+   *   close_reason        = NULL -- no reason, yet
    *
-   *   mon_list      both pointers NULL
+   *   real_type           = 0    -- not material
+   *   file_fd             = 0    -- not material
+   *   file_error          = 0    -- not material
    *
-   *   name                = NULL -- no name, yet
+   *   key_stream          = NULL -- no key stream (always empty, at EOF)
    *
-   *   cli_drawn           = 0 -- not drawn
+   *   cli_drawn           = 0    -- not drawn
+   *   cli_dirty           = 0    -- not dirty
    *   cli_prompt_len      = 0 )
-   *   cli_extra_len       = 0 ) not material
+   *   cli_extra_len       = 0 )     not material
    *   cli_echo_suppress   = 0 )
    *
-   *   cli_prompt_node     = 0 -- not material
-   *   cli_prompt_set      = 0 -- so prompt needs to be constructed
+   *   cli_prompt_node     = 0    -- not material
+   *   cli_prompt_set      = 0    -- so prompt needs to be constructed
+   *
+   *   cli_blocked         = 0    -- not blocked
+   *   cmd_in_progress     = 0    -- no command in progress
+   *   cmd_out_enabled     = 0    -- command output is disabled
+   *   cli_wait_more       = 0    -- not waiting for response to "--more--"
+   *
+   *   cli_more_enabled    = 0    -- not enabled for "--more--"
    *
-   *   cli_blocked         = 0 -- not blocked
-   *   cmd_in_progress     = 0 -- no command in progress
+   *   cmd_out_done        = 0    -- not material
    *
-   *   cli_do              = 0 = cli_do_nothing
+   *   cli_do              = 0    == cli_do_nothing
    *
-   *   cmd_wait_more       = 0 -- not waiting for response to "--more--"
+   *   cmd_lc              = NULL -- no line control
    *
-   *   fail                = 0 -- no login failures yet
+   *   fail                = 0    -- no login failures yet
    *
    *   hist                = empty vector
-   *   hp                  = 0 -- at the beginning
-   *   hindex              = 0 -- the beginning
+   *   hp                  = 0    -- at the beginning
+   *   hindex              = 0    -- the beginning
    *
-   *   width               = 0 -- unknown console width
-   *   height              = 0 -- unknown console height
+   *   width               = 0    -- unknown console width
+   *   height              = 0    -- unknown console height
    *
-   *   lines               = 0 -- unset
+   *   lines               = 0    -- no limit
+   *   lines_set           = 0    -- no explicit setting
    *
-   *   monitor             = 0 -- not a monitor
+   *   monitor             = 0    -- not a monitor
+   *   monitor_busy        = 0    -- not a busy monitor
    *
-   *   config              = 0 -- not holder of "config" mode
+   *   config              = 0    -- not holder of "config" mode
    */
   confirm(cli_do_nothing == 0) ;
+  confirm(AUTH_NODE == 0) ;     /* default node type    */
 
   vio->type   = type ;
 
-  uty_file_init_new(&vio->file, fd, vio) ;
-
-  vio->key_stream = keystroke_stream_new('\0') ;  /* TODO: CSI ??       */
+  /* Zeroising the vty structure has set:
+   *
+   *   node      = 0  TODO: something better for node value ????
+   *   buf       = NULL -- no command line, yet
+   *   parsed    = NULL -- no parsed command, yet
+   *   lineno    = 0    -- nothing read, yet
+   *   index     = NULL -- nothing, yet
+   *   index_sub = NULL -- nothing, yet
+   */
+  if (type == VTY_TERM)
+    vty->newline = "\n" ;       /* line control looks after "\r\n"      */
+  else
+    vty->newline = "\n" ;
 
-  qs_init_new(&vio->ibuf, 0) ;
+  /* Initialise the vio_sock,                                           */
+  uty_sock_init_new(&vio->sock, sock_fd, vio) ;
 
+  /* Make sure all buffers etc. are initialised clean and empty.
+   *
+   * Note that no buffers are actually allocated at this stage.
+   */
   qs_init_new(&vio->cli_prompt_for_node, 0) ;
 
   qs_init_new(&vio->cl,  0) ;
   qs_init_new(&vio->clx, 0) ;
 
-  qs_init_new(&vio->cli_vbuf, 0) ;
-  vio_fifo_init_new(&vio->cli_obuf, 4 * 1024) ; /* allocate in 4K lumps */
+  vio_fifo_init_new(&vio->cli_obuf, 2 * 1024) ; /* allocate in 2K lumps */
 
-  qs_init_new(&vio->cmd_vbuf, 0) ;
-  vio_fifo_init_new(&vio->cmd_obuf, 16 * 1024) ;
+  vio_fifo_init_new(&vio->cmd_obuf, 8 * 1024) ;
 
   /* Place on list of known vio/vty                                     */
   sdl_push(vio_list_base, vio, vio_list) ;
@@ -376,29 +504,34 @@ uty_new (int fd, enum vty_type type)
  * Returns: new vty
  */
 static struct vty *
-uty_new_term(int vty_sock, union sockunion *su)
+uty_new_term(int sock_fd, union sockunion *su)
 {
   struct vty *vty ;
   vty_io vio ;
+  enum vty_readiness ready ;
 
   VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
 
   /* Allocate new vty structure and set up default values.              */
-  vty = uty_new (vty_sock, VTY_TERM) ;
+  vty = uty_new (VTY_TERM, sock_fd) ;
   vio = vty->vio ;
 
-  /* Set the action functions                                           */
+  /* Allocate and initialise a keystroke stream     TODO: CSI ??        */
+  vio->key_stream = keystroke_stream_new('\0', uty_cli_iac_callback, vio) ;
+
+  /* Set the socket action functions                                    */
   if (vty_cli_nexus)
     {
-      vio->file.action.read.qnexus  = vty_read_qnexus ;
-      vio->file.action.write.qnexus = vty_write_qnexus ;
-      vio->file.action.timer.qnexus = vty_timer_qnexus ;
+      vio->sock.action.read.qnexus  = vty_read_qnexus ;
+      vio->sock.action.write.qnexus = vty_write_qnexus ;
+      vio->sock.action.timer.qnexus = vty_timer_qnexus ;
     }
   else
     {
-      vio->file.action.read.thread  = vty_read_thread ;
-      vio->file.action.write.thread = vty_write_thread ;
-      vio->file.action.timer.thread = vty_timer_thread ;
+      vio->sock.action.read.thread  = vty_read_thread ;
+      vio->sock.action.write.thread = vty_write_thread ;
+      vio->sock.action.timer.thread = vty_timer_thread ;
     } ;
 
   /* The text form of the address identifies the VTY                    */
@@ -418,41 +551,38 @@ uty_new_term(int vty_sock, union sockunion *su)
     vty->node = AUTH_NODE;
 
   /* Pick up current timeout setting                                    */
-  vio->file.v_timeout = vty_timeout_val;
+  vio->sock.v_timeout = vty_timeout_val;
 
-  /* Use global 'lines' setting, otherwise is unset                     */
-  if (host.lines >= 0)
-    vio->lines = host.lines;
-  else
-    vio->lines = -1;
+  /* Use global 'lines' setting, as default.  May be -1 => unset        */
+  vio->lines = host.lines ;
 
-  /* Setting up terminal.                                               */
-  uty_will_echo (vio);
-  uty_will_suppress_go_ahead (vio);
-  uty_dont_linemode (vio);
-  uty_do_window_size (vio);
-  if (0)
-    uty_dont_lflow_ahead (vio) ;
+  /* For VTY_TERM use vio_line_control for '\n' and "--more--"          */
+  vio->cmd_lc = vio_lc_init_new(NULL, 0, 0) ;
+  uty_set_height(vio) ;         /* set initial state    */
 
-  /* Set CLI into state waiting for output to complete.                 */
-  vio->cli_blocked      = 1 ;
-  uty_file_set_write(&vio->file, on) ;
+  /* Initialise the CLI, ready for start-up messages etc.               */
+  uty_cli_init(vio) ;
 
   /* Reject connection if password isn't set, and not "no password"     */
   if ((host.password == NULL) && (host.password_encrypt == NULL)
                                                         && ! no_password_check)
     {
-      uty_out (vty, "Vty password is not set.%s", VTY_NEWLINE);
-      uty_half_close (vio);
-      return NULL;
+      uty_half_close (vio, "Vty password is not set.");
+      vty = NULL;
     }
+  else
+    {
+      /* Say hello to the world. */
+      vty_hello (vty);
 
-  /* Say hello to the world. */
-  vty_hello (vty);
-
-  if (! no_password_check)
-    uty_out (vty, "%sUser Access Verification%s%s", VTY_NEWLINE,
+      if (! no_password_check)
+        uty_out (vty, "%sUser Access Verification%s%s", VTY_NEWLINE,
                                                      VTY_NEWLINE, VTY_NEWLINE);
+    } ;
+
+  /* Now start the CLI and set a suitable state of readiness            */
+  ready = uty_cli_start(vio) ;
+  uty_sock_set_readiness(&vio->sock, ready) ;
 
   return vty;
 } ;
@@ -463,7 +593,7 @@ uty_new_term(int vty_sock, union sockunion *su)
  * Returns: new vty
  */
 static struct vty *
-uty_new_shell_serv(int vty_sock)
+uty_new_shell_serv(int sock_fd)
 {
   struct vty *vty ;
   vty_io vio ;
@@ -471,30 +601,27 @@ uty_new_shell_serv(int vty_sock)
   VTY_ASSERT_LOCKED() ;
 
   /* Allocate new vty structure and set up default values.              */
-  vty = uty_new (vty_sock, VTY_SHELL_SERV) ;
+  vty = uty_new (VTY_SHELL_SERV, sock_fd) ;
   vio = vty->vio ;
 
   /* Set the action functions                                           */
   if (vty_cli_nexus)
     {
-      vio->file.action.read.qnexus  = vtysh_read_qnexus ;
-      vio->file.action.write.qnexus = vty_write_qnexus ;
-      vio->file.action.timer.qnexus = NULL ;
+      vio->sock.action.read.qnexus  = vtysh_read_qnexus ;
+      vio->sock.action.write.qnexus = vty_write_qnexus ;
+      vio->sock.action.timer.qnexus = NULL ;
     }
   else
     {
-      vio->file.action.read.thread  = vtysh_read_thread ;
-      vio->file.action.write.thread = vty_write_thread ;
-      vio->file.action.timer.thread = NULL ;
+      vio->sock.action.read.thread  = vtysh_read_thread ;
+      vio->sock.action.write.thread = vty_write_thread ;
+      vio->sock.action.timer.thread = NULL ;
     } ;
 
   vty->node = VIEW_NODE;
 
-  /* Enable the command output to clear the output to date, and set cli
-   * state to blocked waiting for that output to complete.
-   */
-  vio->cli_blocked        = 1 ;
-  uty_file_set_write(&vio->file, on) ;
+  /* Kick start the CLI etc.                                            */
+    uty_sock_set_readiness(&vio->sock, write_ready) ;
 
   return vty;
 } ;
@@ -512,7 +639,7 @@ uty_set_monitor(vty_io vio, bool on)
 
   if      (on && !vio->monitor)
     {
-      if ((vio->type == VTY_TERM) && vio->file.write_open)
+      if ((vio->type == VTY_TERM) && vio->sock.write_open)
         {
           vio->monitor = 1 ;
           sdl_push(vio_monitors_base, vio, mon_list) ;
@@ -539,50 +666,83 @@ uty_get_name(vty_io vio)
 /*------------------------------------------------------------------------------
  * Closing down VTY for reading.
  *
- * Shuts the read side and discards any buffered input.
+ * For VTY_TERM  (must be in CLI thread):
+ *
+ *   * shut the socket for reading
+ *   * discard all buffered input, setting it to "EOF"
+ *   * turns off any monitor status !
+ *   * drop down to RESTRICTED_NODE
+ *
+ * For VTY_SHELL_SERV  (must be in CLI thread):
+ *
+ *   * shut the socket for reading
+ *   * discard all buffered input
+ *   * drop down to RESTRICTED_NODE
  *
- * Leaves the output running, but places the VTY on "death watch".  When
- * all output completes and there is no queued command or anything else
- * active, the VTY is finally put to sleep.
+ * In all cases:
+ *
+ *   * place on death watch
+ *   * set the vty half_closed
+ *   * sets the reason for closing (if any given)
+ *
+ * For VTY_TERM and VTY_SHELL_SERV, when the output side has emptied out all
+ * the buffers, the VTY is closed.
+ *
+ * May already have set the vio->close_reason, or can set it now.  (Passing a
+ * NULL reason has no effect on any existing posted reason.)
  */
 extern void
-uty_half_close (vty_io vio)
+uty_half_close (vty_io vio, const char* reason)
 {
-  char* line ;
-
   VTY_ASSERT_LOCKED() ;
 
   if (vio->half_closed)
-    return ;                    /* cannot do it again   */
-
-  vio->half_closed = 1 ;
+    return ;
 
-  uzlog (NULL, LOG_INFO, "Vty connection (fd %d) close", vio->file.fd) ;
+  if (reason != NULL)
+    vio->close_reason = reason ;
 
-  uty_file_half_close(&vio->file) ;
+  /* Do the file side of things
+   *
+   * Note that half closing the file sets a new timeout, sets read off
+   * and write on.
+   */
+  uty_sock_half_close(&vio->sock) ;
   uty_set_monitor(vio, 0) ;
 
-  keystroke_stream_free(vio->key_stream) ;
-  qs_free_body(&vio->ibuf) ;
+  /* Discard everything in the keystroke stream and force it to EOF     */
+  if (vio->key_stream != NULL)
+    keystroke_stream_set_eof(vio->key_stream) ;
 
-  uty_cli_wipe(vio) ;
-
-  while ((line = vector_ream_keep(&vio->hist)) != NULL)
-    XFREE(MTYPE_VTY_HIST, line) ;
+  /* Turn off "--more--" so that all output clears without interruption.
+   *
+   * Note that if is waiting for "--more--", then shutting the read side
+   * causes it to be readable, but EOF -- so that will flush through.
+   */
+  vio->cli_more_enabled = 0 ;
 
-  /* Hit the width, height and lines so that all output clears without
-   * interruption.
+  /* If a command is not in progress, enable output, which will clear
+   * the output buffer if there is anything there, plus any close reason,
+   * and then close.
+   *
+   * If command is in progress, then this process will start when it
+   * completes.
    */
-  vio->width   = 0 ;
-  vio->height  = 0 ;
-  vio->lines   = 0 ;
+  if (!vio->cmd_in_progress)
+    vio->cmd_out_enabled = 1 ;
 
   /* Make sure no longer holding the config symbol of power             */
-  uty_config_unlock(vio->vty, AUTH_NODE) ;
+  uty_config_unlock(vio->vty, RESTRICTED_NODE) ;
+
+  /* Log closing of VTY_TERM                                            */
+  if (vio->type == VTY_TERM)
+    uzlog (NULL, LOG_INFO, "Vty connection (fd %d) close", vio->sock.fd) ;
 
   /* Move to the death watch list                                       */
   sdl_del(vio_list_base, vio, vio_list) ;
   sdl_push(vio_death_watch, vio, vio_list) ;
+
+  vio->half_closed = 1 ;
 } ;
 
 /*------------------------------------------------------------------------------
@@ -590,118 +750,185 @@ uty_half_close (vty_io vio)
  *
  * Shuts down everything and discards all buffers etc. etc.
  *
- * If not already on it, places the VTY on "death watch".  When there is no
- * queued command or anything else active, the VTY is finally put to sleep.
+ * If cmd_in_progress, cannot complete the process -- but sets the closed
+ * flag.
+ *
+ * Can call vty_close() any number of times.
+ *
+ * The vty structure is placed on death watch, which will finally free the
+ * structure once no longer cmd_in_progress.
  */
 extern void
 uty_close (vty_io vio)
 {
   VTY_ASSERT_LOCKED() ;
 
-  uty_file_close(&vio->file) ;  /* bring the file to a complete stop    */
+  /* Empty all the output buffers                                       */
+  vio_fifo_reset_keep(&vio->cli_obuf) ;
+  vio_fifo_reset_keep(&vio->cmd_obuf) ;
+  vio->cmd_lc = vio_lc_reset_free(vio->cmd_lc) ;
+
+  /* If not already closed, close.                                      */
+  if (!vio->closed)
+    {
+      uty_half_close(vio, NULL) ;   /* place on death watch -- if not
+                                       already done                     */
+      uty_cli_close(vio) ;          /* tell the CLI to stop             */
+
+      vio->closed = 1 ;             /* now closed (stop uty_write()
+                                       from recursing)                  */
+
+      if (vio->sock.write_open)
+        uty_write(vio) ;            /* last gasp attempt                */
 
-  uty_half_close(vio) ;         /* deal with the input side, and place on
-                                   death watch -- if not already done   */
+      uty_sock_close(&vio->sock) ;
+
+    } ;
+
+  /* Nothing more should happen, so can now release almost everything,
+   * the exceptions being the things that are related to a cmd_in_progress.
+   *
+   * All writing to buffers is suppressed, and as the sock has been closed,
+   * there will be no more read_ready or write_ready events.
+   */
+  if (vio->name != NULL)
+    XFREE(MTYPE_VTY_NAME, vio->name) ;
+
+  vio->key_stream = keystroke_stream_free(vio->key_stream) ;
 
   qs_free_body(&vio->cli_prompt_for_node) ;
   qs_free_body(&vio->cl) ;
-  qs_free_body(&vio->clx) ;
-  qs_free_body(&vio->cli_vbuf) ;
-  qs_free_body(&vio->cmd_vbuf) ;
 
-  vio_fifo_reset_keep(&vio->cli_obuf) ;
-  vio_fifo_reset_keep(&vio->cmd_obuf) ;
+  {
+    qstring line ;
+    while ((line = vector_ream_keep(&vio->hist)) != NULL)
+      qs_reset_free(line) ;
+  } ;
 
-  vio->vty->buf = NULL ;
+  /* The final stage cannot be completed if cmd_in_progress.
+   *
+   * The clx is pointed at by vty->buf -- containing the current command.
+   *
+   * Once everything is released, can take the vty off death watch, and
+   * release the vio and the vty.
+   */
+  if (!vio->cmd_in_progress)
+    {
+      qs_free_body(&vio->clx) ;
+      vio->vty->buf = NULL ;
+    } ;
 } ;
 
+/*==============================================================================
+ * For writing configuration file by command, temporarily redirect output to
+ * an actual file.
+ */
+
 /*------------------------------------------------------------------------------
- * Closing down VTY completely.
- *
- * Shuts down everything and discards all buffers etc. etc.
- *
- * If not already on it, places the VTY on "death watch".  When there is no
- * queued command or anything else active, the VTY is finally put to sleep.
+ * Set the given fd as the VTY_FILE output.
  */
 extern void
-uty_full_close (vty_io vio)
+vty_open_config_write(struct vty* vty, int fd)
 {
-  VTY_ASSERT_LOCKED() ;
+  vty_io vio ;
 
-  uty_file_close(&vio->file) ;  /* bring the file to a complete stop    */
+  VTY_LOCK() ;
 
-  uty_half_close(vio) ;         /* deal with the input side, and place on
-                                   death watch -- if not already done   */
+  vio = vty->vio ;
 
-  qs_free_body(&vio->cli_prompt_for_node) ;
-  qs_free_body(&vio->cl) ;
-  qs_free_body(&vio->clx) ;
-  qs_free_body(&vio->cli_vbuf) ;
-  qs_free_body(&vio->cmd_vbuf) ;
+  assert((vio->type != VTY_CONFIG_WRITE) && (vio->type != VTY_NONE)) ;
 
-  vio_fifo_reset_keep(&vio->cli_obuf) ;
-  vio_fifo_reset_keep(&vio->cmd_obuf) ;
+  vio->real_type  = vio->type ;
+
+  vio->type       = VTY_CONFIG_WRITE ;
+  vio->file_fd    = fd ;
+  vio->file_error = 0 ;
 
-  vio->vty->buf = NULL ;
+  VTY_UNLOCK() ;
 } ;
 
-/*==============================================================================
- * Dealing with am I/O error on VTY
- *
- * If this is the first error for this VTY, produce suitable log message.
+/*------------------------------------------------------------------------------
+ * Write away configuration file stuff -- all or just the full lump(s).
  *
- * If is a "monitor", turn that off, *before* issuing log message.
+ * Returns: > 0 => blocked
+ *            0 => all gone (up to last lump if !all)
+ *          < 0 => failed -- see vio->file_error
  */
 static int
-uty_io_error(vty_io vio, const char* what)
+uty_config_write(vty_io vio, bool all)
 {
-  /* can no longer be a monitor !                                       */
-  uty_set_monitor(vio, 0) ;
+  int ret ;
 
-  /* if this is the first error, log it                                 */
-  if (vio->file.error_seen == 0)
+  VTY_ASSERT_LOCKED() ;
+
+  if (vio->file_error == 0)
     {
-      const char* type ;
-      switch (vio->type)
-      {
-        case VTY_TERM:
-          type = "VTY Terminal" ;
-          break ;
-        case VTY_SHELL_SERV:
-          type = "VTY Shell Server" ;
-          break ;
-        default:
-          zabort("unknown VTY type for uty_io_error()") ;
-      } ;
+      ret = vio_fifo_write_nb(&vio->cmd_obuf, vio->file_fd, all) ;
 
-      vio->file.error_seen = errno ;
-      uzlog(NULL, LOG_WARNING, "%s: %s failed on fd %d: %s",
-                type, what, vio->file.fd, safe_strerror(vio->file.error_seen)) ;
-    } ;
+      if (ret < 0)
+        vio->file_error = errno ;
+    }
+  else
+    ret = -1 ;
 
-  return -1 ;
+  return ret ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * Write away any pending stuff, and return the VTY to normal.
+ */
+extern int
+vty_close_config_write(struct vty* vty)
+{
+  vty_io vio ;
+  int err ;
+
+  VTY_LOCK() ;
+
+  vio = vty->vio ;
+
+  assert((vio->type == VTY_CONFIG_WRITE) && (vio->real_type != VTY_NONE)) ;
+
+  uty_config_write(vio, true) ; /* write all that is left       */
+
+  err = vio->file_error ;
+
+  vio->type       = vio->real_type ;
+  vio->file_fd    = -1 ;
+  vio->file_error = 0 ;
+
+  VTY_UNLOCK() ;
+
+  return err ;
 } ;
 
 /*==============================================================================
- * vio_file level operations
+ * vio_sock level operations
  */
 
 /*------------------------------------------------------------------------------
- * Initialise a new vio_file structure.
+ * Initialise a new vio_sock structure.
  *
- * Requires that: the vio_file structure is not currently in use.
+ * Requires that: the vio_sock structure is not currently in use.
  *
- *                if fd >= 0 then: file is open and ready read and write
- *                      otherwise: file is not open
+ *                if fd >= 0 then: sock is open and ready read and write
+ *                      otherwise: sock is not open
  *
  *                there are no errors, yet.
  *
  * Sets timeout to no timeout at all -- timeout is optional.
+ *
+ * NB: MUST be in the CLI thread if the fd is >= 0 !
  */
 static void
-uty_file_init_new(vio_file file, int fd, void* info)
+uty_sock_init_new(vio_sock sock, int fd, void* info)
 {
-  memset(file, 0, sizeof(struct vio_file)) ;
+  VTY_ASSERT_LOCKED() ;
+
+  if (fd >= 0)
+    VTY_ASSERT_CLI_THREAD() ;
+
+  memset(sock, 0, sizeof(struct vio_sock)) ;
 
   /* Zeroising the structure has set:
    *
@@ -718,17 +945,16 @@ uty_file_init_new(vio_file file, int fd, void* info)
    *   t_timer       = NULL -- no timer thread, yet
    *   qtr           = NULL -- no qtimer, yet
    */
-  file->fd          = fd ;
-  file->info        = info ;
+  sock->fd          = fd ;
+  sock->info        = info ;
 
-  file->read_open   = (fd >= 0) ;
-  file->write_open  = (fd >= 0) ;
+  sock->read_open   = (fd >= 0) ;
+  sock->write_open  = (fd >= 0) ;
 
-  if (vty_cli_nexus)
+  if ((fd >= 0) && vty_cli_nexus)
     {
-      file->qf = qps_file_init_new(NULL, NULL);
-      if (fd >= 0)
-        qps_add_file(vty_cli_nexus->selection, file->qf, file->fd, file->info);
+      sock->qf = qps_file_init_new(NULL, NULL);
+      qps_add_file(vty_cli_nexus->selection, sock->qf, sock->fd, sock->info);
     } ;
 } ;
 
@@ -740,250 +966,368 @@ uty_file_init_new(vio_file file, int fd, void* info)
  * If no timeout time is set, and the timer is running, unset it.
  */
 static void
-uty_file_restart_timer(vio_file file)
+uty_sock_restart_timer(vio_sock sock)
 {
-  if (file->v_timeout != 0)
+  VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
+
+  if (sock->v_timeout != 0)
     {
-      assert(file->action.timer.anon != NULL) ;
+      assert(sock->action.timer.anon != NULL) ;
 
       if (vty_cli_nexus)
         {
-          if (file->qtr == NULL)    /* allocate qtr if required     */
-            file->qtr = qtimer_init_new(NULL, vty_cli_nexus->pile,
-                                                             NULL, file->info) ;
-          qtimer_set(file->qtr, qt_add_monotonic(QTIME(file->v_timeout)),
-                                                    file->action.timer.qnexus) ;
+          if (sock->qtr == NULL)    /* allocate qtr if required     */
+            sock->qtr = qtimer_init_new(NULL, vty_cli_nexus->pile,
+                                                             NULL, sock->info) ;
+          qtimer_set(sock->qtr, qt_add_monotonic(QTIME(sock->v_timeout)),
+                                                    sock->action.timer.qnexus) ;
         }
       else
         {
-          if (file->t_timer != NULL)
-            thread_cancel (file->t_timer);
-          file->t_timer = thread_add_timer (vty_master,
-                       file->action.timer.thread, file->info, file->v_timeout) ;
+          if (sock->t_timer != NULL)
+            thread_cancel (sock->t_timer);
+          sock->t_timer = thread_add_timer (vty_master,
+                       sock->action.timer.thread, sock->info, sock->v_timeout) ;
         } ;
 
-      file->timer_running = 1 ;
+      sock->timer_running = 1 ;
     }
-  else if (file->timer_running)
+  else if (sock->timer_running)
     {
       if (vty_cli_nexus)
         {
-          if (file->qtr != NULL)
-            qtimer_unset(file->qtr) ;
+          if (sock->qtr != NULL)
+            qtimer_unset(sock->qtr) ;
         }
       else
         {
-          if (file->t_timer != NULL)
-            thread_cancel (file->t_timer) ;
+          if (sock->t_timer != NULL)
+            thread_cancel (sock->t_timer) ;
         } ;
 
-      file->timer_running = 0 ;
+      sock->timer_running = 0 ;
     } ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Set a new timer value.
+ * Set read on/off
+ *
+ * Returns: the on/off state set
  */
-extern void
-uty_file_set_timer(vio_file file, unsigned long timeout)
+static bool
+uty_sock_set_read(vio_sock sock, bool on)
 {
-  file->v_timeout = timeout ;
-  if (file->timer_running)
-    uty_file_restart_timer(file) ;
-} ;
+  VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
 
-/*------------------------------------------------------------------------------
- * Set read on/off -- restart timer.
- */
-extern void
-uty_file_set_read(vio_file file, bool on)
-{
-  if (file->fd < 0)
-    return ;
+  if (sock->fd < 0)
+    return 0 ;
 
   if (on)
     {
-      assert(file->action.read.anon != NULL) ;
+      assert(sock->action.read.anon != NULL) ;
 
       if (vty_cli_nexus)
-        {
-          qps_enable_mode(file->qf, qps_read_mnum, file->action.read.qnexus) ;
-        }
+          qps_enable_mode(sock->qf, qps_read_mnum, sock->action.read.qnexus) ;
       else
         {
-          if (file->t_read != NULL)
-            thread_cancel(file->t_read) ;
+          if (sock->t_read != NULL)
+            thread_cancel(sock->t_read) ;
 
-          file->t_read = thread_add_read(vty_master,
-                               file->action.read.thread, file->info, file->fd) ;
+          sock->t_read = thread_add_read(vty_master,
+                               sock->action.read.thread, sock->info, sock->fd) ;
         } ;
     }
   else
     {
       if (vty_cli_nexus)
-        {
-          qps_disable_modes(file->qf, qps_read_mbit) ;
-        }
+        qps_disable_modes(sock->qf, qps_read_mbit) ;
       else
         {
-          if (file->t_read != NULL)
-            thread_cancel (file->t_read) ;
+          if (sock->t_read != NULL)
+            thread_cancel (sock->t_read) ;
         } ;
     } ;
 
-    uty_file_restart_timer(file) ;
+  return on ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Set write on/off -- restart timer.
+ * Set write on/off
+ *
+ * Returns: the on/off state set
  */
-extern void
-uty_file_set_write(vio_file file, bool on)
+static bool
+uty_sock_set_write(vio_sock sock, bool on)
 {
-  if (file->fd < 0)
-    return ;
+  VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
+
+  if (sock->fd < 0)
+    return 0 ;
 
   if (on)
     {
-      assert(file->action.write.anon != NULL) ;
+      assert(sock->action.write.anon != NULL) ;
 
       if (vty_cli_nexus)
-        {
-          qps_enable_mode(file->qf, qps_write_mnum, file->action.write.qnexus) ;
-        }
+        qps_enable_mode(sock->qf, qps_write_mnum, sock->action.write.qnexus) ;
       else
         {
-          if (file->t_write != NULL)
-            thread_cancel(file->t_write) ;
+          if (sock->t_write != NULL)
+            thread_cancel(sock->t_write) ;
 
-          file->t_write = thread_add_write(vty_master,
-                              file->action.write.thread, file->info, file->fd) ;
+          sock->t_write = thread_add_write(vty_master,
+                              sock->action.write.thread, sock->info, sock->fd) ;
         } ;
     }
   else
     {
       if (vty_cli_nexus)
-        {
-          qps_disable_modes(file->qf, qps_write_mbit) ;
-        }
+        qps_disable_modes(sock->qf, qps_write_mbit) ;
       else
         {
-          if (file->t_write != NULL)
-            thread_cancel (file->t_write) ;
+          if (sock->t_write != NULL)
+            thread_cancel (sock->t_write) ;
         } ;
     } ;
 
-  uty_file_restart_timer(file) ;
+  return on ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * Set read/write readiness -- for VTY_TERM
+ *
+ * Note that for VTY_TERM, set only one of read or write, and sets write for
+ * preference.
+ */
+extern void
+uty_sock_set_readiness(vio_sock sock, enum vty_readiness ready)
+{
+  VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
+
+  uty_sock_set_read(sock, (ready == read_ready)) ;
+  uty_sock_set_write(sock, (ready >= write_ready)) ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Close given vty file for reading.
+ * Set a new timer value.
+ */
+extern void
+uty_sock_set_timer(vio_sock sock, unsigned long timeout)
+{
+  VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
+
+  sock->v_timeout = timeout ;
+  if (sock->timer_running)
+    uty_sock_restart_timer(sock) ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * Close given vty sock for reading.
  *
  * Sets timer to timeout for clearing any pending output.
+ *
+ * NB: if there is a socket, MUST be in the CLI thread
  */
 static void
-uty_file_half_close(vio_file file)
+uty_sock_half_close(vio_sock sock)
 {
   VTY_ASSERT_LOCKED() ;
 
-  if (file->fd >= 0)
-    {
-      shutdown(file->fd, SHUT_RD) ;     /* actual half close    */
+  sock->read_open = 0 ;         /* make sure                    */
 
-      file->v_timeout = 30 ;            /* for output to clear  */
-      uty_file_set_read(file, off) ;
-    } ;
+  if (sock->fd < 0)
+    return ;                    /* nothing more if no socket    */
+
+  VTY_ASSERT_CLI_THREAD() ;
 
-  file->read_open = 0 ;
+  shutdown(sock->fd, SHUT_RD) ; /* actual half close            */
+
+  uty_sock_set_read(sock, off) ;
+  uty_sock_set_write(sock, on) ;
+  sock->v_timeout = 30 ;        /* for output to clear          */
+  uty_sock_restart_timer(sock) ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Close given vio_file, completely -- shut down any timer.
+ * Close given vio_sock, completely -- shut down any timer.
  *
  * Structure is cleared of everything except the last error !
+ *
+ * NB: if there is a socket, MUST be in the CLI thread
  */
 static void
-uty_file_close(vio_file file)
+uty_sock_close(vio_sock sock)
 {
   VTY_ASSERT_LOCKED() ;
 
-  if (file->fd >= 0)
-    close(file->fd) ;
+  sock->read_open   = 0 ;       /* make sure                    */
+  sock->write_open  = 0 ;
 
-  if (vty_cli_nexus && (file->fd >= 0))
-    qps_remove_file(file->qf) ;
+  if (sock->fd < 0)
+    {
+      assert( (sock->qf      == NULL)
+           && (sock->qtr     == NULL)
+           && (sock->t_read  == NULL)
+           && (sock->t_write == NULL)
+           && (sock->t_timer == NULL) ) ;
+      return ;                  /* no more to be done here      */
+    } ;
 
-  if (file->qf != NULL)
-    qps_file_free(file->qf) ;
+  VTY_ASSERT_CLI_THREAD() ;
+  close(sock->fd) ;
 
-  if (file->t_read != NULL)
-    thread_cancel(file->t_write) ;
-  if (file->t_write != NULL)
-    thread_cancel(file->t_write) ;
+  if (vty_cli_nexus)
+    {
+      assert((sock->qf != NULL) && (sock->fd == qps_file_fd(sock->qf))) ;
+      qps_remove_file(sock->qf) ;
+      qps_file_free(sock->qf) ;
+      sock->qf = NULL ;
+    } ;
 
-  file->fd      = -1 ;
-  file->qf      = NULL ;
-  file->t_read  = NULL ;
-  file->t_write = NULL ;
+  sock->fd      = -1 ;
 
-  file->info              = NULL ;
-  file->action.read.anon  = NULL ;
-  file->action.write.anon = NULL ;
-  file->action.timer.anon = NULL ;
+  if (sock->t_read != NULL)
+    thread_cancel(sock->t_write) ;
+  if (sock->t_write != NULL)
+    thread_cancel(sock->t_write) ;
 
-  file->read_open   = 0 ;
-  file->write_open  = 0 ;
+  sock->t_read  = NULL ;
+  sock->t_write = NULL ;
 
-  if (file->qtr != NULL)
-    qtimer_free(file->qtr) ;
-  if (file->t_timer != NULL)
-    thread_cancel(file->t_timer) ;
+  sock->info              = NULL ;
+  sock->action.read.anon  = NULL ;
+  sock->action.write.anon = NULL ;
+  sock->action.timer.anon = NULL ;
 
-  file->v_timeout = 0 ;
-  file->qtr       = NULL ;
-  file->t_timer   = NULL ;
+  if (sock->qtr != NULL)
+    qtimer_free(sock->qtr) ;
+  if (sock->t_timer != NULL)
+    thread_cancel(sock->t_timer) ;
+
+  sock->v_timeout = 0 ;
+  sock->qtr       = NULL ;
+  sock->t_timer   = NULL ;
 } ;
 
-/*==============================================================================
- * Reading from the VTY_TERM type file.
+/*------------------------------------------------------------------------------
+ * Dealing with an I/O error on VTY socket
  *
- * The select/pselect call-back ends up in uty_read_ready().
+ * If this is the first error for this VTY, produce suitable log message.
  *
- * Note that uty_write_ready() also calls uty_read_ready, in order to kick the
- * current CLI.
+ * If is a "monitor", turn that off, *before* issuing log message.
  */
+static int
+uty_sock_error(vty_io vio, const char* what)
+{
+  VTY_ASSERT_LOCKED() ;
+  VTY_ASSERT_CLI_THREAD() ;
 
-/*------------------------------------------------------------------------------
- * Ready to read -> kicking CLI
+  /* can no longer be a monitor !  *before* any logging !               */
+  uty_set_monitor(vio, 0) ;
+
+  /* if this is the first error, log it                                 */
+  if (vio->sock.error_seen == 0)
+    {
+      const char* type ;
+      switch (vio->type)
+      {
+        case VTY_TERM:
+          type = "VTY Terminal" ;
+          break ;
+        case VTY_SHELL_SERV:
+          type = "VTY Shell Server" ;
+          break ;
+        default:
+          zabort("unknown VTY type for uty_sock_error()") ;
+      } ;
+
+      vio->sock.error_seen = errno ;
+      uzlog(NULL, LOG_WARNING, "%s: %s failed on fd %d: %s",
+                type, what, vio->sock.fd, safe_strerror(vio->sock.error_seen)) ;
+    } ;
+
+  return -1 ;
+} ;
+
+/*==============================================================================
+ * Readiness and the VTY_TERM type VTY.
  *
- * Have two CLI: one (trivial one) when waiting on "--more--",
- *               and the standard one.
+ * For VTY_TERM the driving force is write ready.  This is used to prompt the
+ * VTY_TERM when there is outstanding output (obviously), but also if there
+ * is buffered input in the keystroke stream.
  *
- * End up here when there is something ready to be read.
+ * The VTY_TERM uses read ready only when it doesn't set write ready.  Does
+ * not set both at once.
  *
- * Also ends up here when was write_ready and did not block in uty_write.
+ * So there is only one, common, uty_ready function, which:
  *
- * Will also end up here if an error has occurred, the other end has closed,
- * this end has half closed, etc.  This fact is used to kick the CLI even when
- * there is no data to be read.
+ *   1. attempts to clear any output it can.
  *
- * Note that nothing is actually read here -- reading is done in the CLI itself,
- * if required.
+ *      The state of the output affects the CLI, so must always do this before
+ *      before invoking the CLI.
  *
- * The CLI decides whether to re-enable read, or enable write, or both.
+ *      If this write enters the "--more--" state, then will have tried to
+ *      write away the prompt.
+ *
+ *   2. invokes the CLI
+ *
+ *      Which will do either the standard CLI stuff or the special "--more--"
+ *      stuff.
+ *
+ *   3. attempts to write any output there now is.
+ *
+ *      If the CLI generated new output, as much as possible is written away
+ *      now.
+ *
+ *      If this write enters the "--more--" state, then it returns now_ready,
+ *      if the prompt was written away, which loops back to the CLI.
+ *
+ * Note that this is arranging:
+ *
+ *   a. to write away the "--more--" prompt as soon as the tranche of output to
+ *      which it refers, completes
+ *
+ *   b. to enter the cli_more_wait CLI for the first time immediately after the
+ *      "--more--" prompt is written away.
+ *
+ * The loop limits itself to one trache of command output each time.
+ *
+ * Resets the timer because something happened.
  */
 static void
-uty_read_ready(vty_io vio)
+uty_ready(vty_io vio)
 {
-  uty_file_set_read(&vio->file, off) ;  /* restarts timer       */
+  enum vty_readiness ready ;
 
-  /* Execute the required command processor                     */
-  if (vio->cmd_wait_more)
-    uty_cli_wait_more(vio) ;    /* run "--more--" CLI           */
-  else
-    uty_cli(vio) ;              /* run standard CLI             */
+  VTY_ASSERT_LOCKED() ;
+
+  vio->cmd_out_done = 0 ;         /* not done any command output yet    */
+
+  uty_write(vio) ;                /* try to clear outstanding stuff     */
+  do
+    {
+      ready  = uty_cli(vio) ;     /* do any CLI work...                 */
+      ready |= uty_write(vio) ;   /* ...and any output that generates   */
+    } while (ready >= now_ready) ;
+
+  uty_sock_set_readiness(&vio->sock, ready) ;
+  uty_sock_restart_timer(&vio->sock) ;
 } ;
 
+/*==============================================================================
+ * Reading from VTY_TERM.
+ *
+ * The select/pselect call-back ends up in uty_read_ready().
+ *
+ * Note that uty_write_ready() also calls uty_read_ready, in order to kick the
+ * current CLI.
+ */
+
 /*------------------------------------------------------------------------------
  * Callback -- qnexus: ready to read -> kicking CLI
  */
@@ -994,9 +1338,9 @@ vty_read_qnexus(qps_file qf, void* file_info)
 
   VTY_LOCK() ;
 
-  assert((vio->file.fd == qf->fd) && (vio == vio->file.info)) ;
+  assert((vio->sock.fd == qf->fd) && (vio == vio->sock.info)) ;
 
-  uty_read_ready(vio) ;
+  uty_ready(vio) ;
 
   VTY_UNLOCK() ;
 }
@@ -1011,10 +1355,10 @@ vty_read_thread(struct thread *thread)
 
   VTY_LOCK() ;
 
-  assert(vio->file.fd == THREAD_FD (thread) && (vio == vio->file.info)) ;
+  assert(vio->sock.fd == THREAD_FD (thread) && (vio == vio->sock.info)) ;
 
-  vio->file.t_read = NULL ;     /* implicitly   */
-  uty_read_ready(vio);
+  vio->sock.t_read = NULL ;     /* implicitly   */
+  uty_ready(vio);
 
   VTY_UNLOCK() ;
   return 0 ;
@@ -1035,18 +1379,18 @@ uty_read (vty_io vio, keystroke steal)
   unsigned char buf[500] ;
   int get ;
 
-  if (!vio->file.read_open)
+  if (!vio->sock.read_open)
     return -1 ;                 /* at EOF if not open           */
 
-  get = read_nb(vio->file.fd, buf, sizeof(buf)) ;
-  if      (get > 0)
+  get = read_nb(vio->sock.fd, buf, sizeof(buf)) ;
+  if      (get >= 0)
     keystroke_input(vio->key_stream, buf, get, steal) ;
   else if (get < 0)
     {
       if (get == -1)
-        uty_io_error(vio, "read") ;
+        uty_sock_error(vio, "read") ;
 
-      vio->file.read_open = 0 ;
+      vio->sock.read_open = 0 ;
       keystroke_input(vio->key_stream, NULL, 0, steal) ;
 
       get = -1 ;
@@ -1056,14 +1400,14 @@ uty_read (vty_io vio, keystroke steal)
 } ;
 
 /*==============================================================================
- * The write file action for VTY_TERM type VTY
+ * The write sock action for VTY_TERM type VTY
  *
  * There are two sets of buffering:
  *
  *   cli -- command line   -- which reflects the status of the command line
  *
- *   cmd -- command output -- which is not written to the file while
- *                            cmd_in_progress.
+ *   cmd -- command output -- which is written to the file only while
+ *                            cmd_out_enabled.
  *
  * The cli output takes precedence.
  *
@@ -1071,41 +1415,8 @@ uty_read (vty_io vio, keystroke steal)
  * "--more--" mechanism.
  */
 
-static bool uty_write(vty_io vio) ;
-static int uty_flush_fifo(vty_io vio, vio_fifo vf,
-                                        struct vty_line_control* line_control) ;
-static void uty_empty_out_fifos(vty_io vio) ;
-
-/*------------------------------------------------------------------------------
- * Flush as much as possible of what there is.
- *
- * May end up with:
- *
- *   * something in the buffers waiting to go, but output is currently
- *     threatening to block.
- *
- *     in this case will have set write on, and things will progress when next
- *     write_ready.
- *
- *   * otherwise:
- *
- *     will be set write off, so does a read_ready in order t kick the CLI,
- *     which may wish to set either read or write on.
- */
-static void
-uty_write_ready(vty_io vio)
-{
-  bool blocked ;
-
-  VTY_ASSERT_LOCKED() ;
-
-  uty_file_set_write(&vio->file, off) ; /* restarts timer, too          */
-
-  blocked = uty_write(vio) ;
-
-  if (!blocked)
-    uty_read_ready(vio) ;
-} ;
+static int uty_write_lc(vty_io vio, vio_fifo vf, vio_line_control lc) ;
+static int uty_write_fifo_lc(vty_io vio, vio_fifo vf, vio_line_control lc) ;
 
 /*------------------------------------------------------------------------------
  * Callback -- qnexus: ready to write -> try to empty buffers
@@ -1117,9 +1428,9 @@ vty_write_qnexus(qps_file qf, void* file_info)
 
   VTY_LOCK() ;
 
-  assert((vio->file.fd == qf->fd) && (vio == vio->file.info)) ;
+  assert((vio->sock.fd == qf->fd) && (vio == vio->sock.info)) ;
 
-  uty_write_ready(vio) ;
+  uty_ready(vio) ;
 
   VTY_UNLOCK() ;
 }
@@ -1134,10 +1445,10 @@ vty_write_thread(struct thread *thread)
 
   VTY_LOCK() ;
 
-  assert(vio->file.fd == THREAD_FD (thread) && (vio == vio->file.info)) ;
+  assert(vio->sock.fd == THREAD_FD (thread) && (vio == vio->sock.info)) ;
 
-  vio->file.t_write = NULL;     /* implicitly   */
-  uty_write_ready(vio) ;
+  vio->sock.t_write = NULL;     /* implicitly   */
+  uty_ready(vio) ;
 
   VTY_UNLOCK() ;
   return 0 ;
@@ -1152,154 +1463,337 @@ vty_write_thread(struct thread *thread)
  * Note that if !write_open, or becomes !write_open, then the FIFOs are empty
  * and all output instantly successful.
  *
- * Sets write on if prevented from outputting everything available for output
+ * Sets write on if prevented from writing everything available for output
  * by write() threatening to block.
  *
- * Sets read on if enters cmd_wait_more state.
- *
- * Returns: true <=> blocked by I/O
- *
- * Note that this means that returns true iff sets write on.
+ * Returns: write_ready  if should now set write on
+ *          now_ready    if should loop back and try again
+ *          not_ready    otherwise
  */
-static bool
+static enum vty_readiness
 uty_write(vty_io vio)
 {
   int ret ;
 
   VTY_ASSERT_LOCKED() ;
 
-  /* empty the CLI FIFO
-   *
-   * NB: if the file is !write_open, or if it fails during output here
-   *     and becomes !write_open, then ret == 0 -- as if everything
-   *     has been written.
-   */
-  ret = uty_flush_fifo(vio, &vio->cli_obuf, NULL) ;
-  if (ret != 0)
-    return 1 ;          /* blocked by I/O       */
+  ret = -1 ;
+  while (vio->sock.write_open)
+    {
+      /* Any outstanding line control output takes precedence           */
+      if (vio->cmd_lc != NULL)
+        {
+          ret = uty_write_lc(vio, &vio->cmd_obuf, vio->cmd_lc) ;
+          if (ret != 0)
+            break ;
+        }
 
-  if ((vio->cmd_in_progress) || (vio->cmd_wait_more))
-    return 0 ;          /* not blocked by I/O   */
+      /* Next: empty out the cli output                                 */
+      ret = vio_fifo_write_nb(&vio->cli_obuf, vio->sock.fd, true) ;
+      if (ret != 0)
+        break ;
 
-  /* write from the command FIFO
-   *
-   *  NB: if the file is !write_open, or if it fails during output here
-   *     and becomes !write_open, then ret == 0 -- as if everything
-   *     has been written.
-   */
-  ret = uty_flush_fifo(vio, &vio->cmd_obuf, &vio->line_control) ;
-  if (ret == 1)
-    return 1 ;          /* blocked by I/O       */
+      /* Finished now if not allowed to progress the command stuff      */
+      if (!vio->cmd_out_enabled)
+        return not_ready ;      /* done all can do      */
 
-  if (ret == 2)
-    {
-      /* Want now to wait for "--more--"
+      /* Last: if there is something in the command buffer, do that     */
+      if (!vio_fifo_empty(&vio->cmd_obuf))
+        {
+          if (vio->cmd_out_done)
+            break ;                     /* ...but not if done once      */
+
+          vio->cmd_out_done = 1 ;       /* done this once               */
+
+          assert(!vio->cli_more_wait) ;
+
+          if (vio->cmd_lc != NULL)
+            ret = uty_write_fifo_lc(vio, &vio->cmd_obuf, vio->cmd_lc) ;
+          else
+            ret = vio_fifo_write_nb(&vio->cmd_obuf, vio->sock.fd, true) ;
+
+          /* If moved into "--more--" state@
+           *
+           *   * the "--more--" prompt is ready to be written, so do that now
+           *
+           *   * if that completes, then want to run the CLI *now* to perform the
+           *     first stage of the "--more--" process.
+           */
+          if (vio->cli_more_wait)
+            {
+              ret = vio_fifo_write_nb(&vio->cli_obuf, vio->sock.fd, true) ;
+              if (ret == 0)
+                return now_ready ;
+            } ;
+
+          if (ret != 0)
+            break ;
+        }
+
+      /* Exciting stuff: there is nothing left to output...
        *
-       * Note that this produces CLI output, which must deal with here.
+       * ... watch out for half closed state.
        */
-      uty_cli_want_more(vio) ; /* NB: sets cmd_wait_more                */
+      if (vio->half_closed)
+        {
+          if (vio->close_reason != NULL)
+            {
+              vio->cmd_in_progress = 1 ;    /* TODO: not use vty_out ?  */
+
+              struct vty* vty = vio->vty ;
+              if (vio->cli_drawn || vio->cli_dirty)
+                vty_out(vty, VTY_NEWLINE) ;
+              vty_out(vty, "%% %s%s", vio->close_reason, VTY_NEWLINE) ;
 
-      ret = uty_flush_fifo(vio, &vio->cli_obuf, NULL) ;
-      if (ret == 1)
-        return 1 ;      /* blocked by I/O       */
+              vio->cmd_in_progress = 0 ;
+
+              vio->close_reason = NULL ;    /* MUST discard now...      */
+              continue ;                    /* ... and write away       */
+            } ;
+
+          if (!vio->closed)                 /* avoid recursion          */
+            uty_close(vio) ;
+
+          return not_ready ;                /* it's all over            */
+        } ;
 
-      if (vio->file.write_open)
-        return 0 ;      /* not blocked by I/O   */
+      /* For VTY_TERM: if the command line is not drawn, now is a good
+       * time to do that.
+       */
+      if (vio->type == VTY_TERM)
+        if (uty_cli_draw_if_required(vio))
+          continue ;                    /* do that now.                 */
+
+      /* There really is nothing left to output                         */
+      return not_ready ;
     } ;
 
-  /* Reach here iff both CLI and command FIFOs are empty and is not
-   * cmd_in_progress
+  /* Arrives here if there is more to do, or failed (or was !write_open)    */
+
+  if (ret >= 0)
+    return write_ready ;
+
+  /* If is write_open, then report the error
+   *
+   * If still read_open, let the reader pick up and report the error, when it
+   * has finished anything it has buffered.
    */
-  vio->cli_blocked = 0 ;
+  if (vio->sock.write_open)
+    {
+      if (!vio->sock.read_open)
+        uty_sock_error(vio, "write") ;
 
-  return 0 ;
+      vio->sock.write_open = 0 ;        /* crash close write    */
+    } ;
+
+  /* For whatever reason, is no longer write_open -- clear all buffers.
+   */
+  vio_fifo_clear(&vio->cli_obuf) ;      /* throw away cli stuff */
+  uty_out_clear(vio) ;                  /* throw away cmd stuff */
+
+  vio->close_reason = NULL ;            /* too late for this    */
+
+  return not_ready ;                   /* NB: NOT blocked by I/O       */
+} ;
+
+/*------------------------------------------------------------------------------
+ * Write as much as possible -- for "monitor" output.
+ *
+ * Outputs only:
+ *
+ *   a. outstanding line control stuff.
+ *
+ *   b. contents of CLI buffer
+ *
+ * And:
+ *
+ *   a. does not report any errors.
+ *
+ *   b. does not change anything except the state of the buffers.
+ *
+ *      In particular, for the qpthreaded world, does not attempt to change
+ *      the state of the qfile or any other "thread private" structures.
+ *
+ * Returns: > 0 => blocked
+ *            0 => all gone
+ *          < 0 => failed (or !write_open)
+ */
+static int
+uty_write_monitor(vty_io vio)
+{
+  VTY_ASSERT_LOCKED() ;
+
+  if (!vio->sock.write_open)
+    return -1 ;
+
+  if (vio->cmd_lc != NULL)
+    {
+      int ret ;
+      ret = uty_write_lc(vio, &vio->cmd_obuf, vio->cmd_lc) ;
+
+      if (ret != 0)
+        return ret ;
+    } ;
+
+  return  vio_fifo_write_nb(&vio->cli_obuf, vio->sock.fd, true) ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Flush the given FIFO to output -- subject to possible line control.
+ * Write the given FIFO to output -- subject to possible line control.
+ *
+ * Note that even if no "--more--" is set, will have set some height, so
+ * that does not attempt to empty the FIFO completely all in one go.
+ *
+ * If the line control becomes "paused", it is time to enter "--more--" state
+ * -- unless the FIFO is empty (or "--more--" is not enabled).
  *
- * If ends up needing to write more, sets write on.
+ * NB: expects that the sock is write_open
  *
- * Returns: 0 => written everything there is -- or not (now) write_open
- *          1 => written everything that could -- needs to write more
- *          2 => written everything that could -- needs a "--more--"
+ * Returns: > 0 => blocked   or completed one tranche
+ *            0 => all gone
+ *          < 0 => failed
  */
 static int
-uty_flush_fifo(vty_io vio, vio_fifo vf, struct vty_line_control* line_control)
+uty_write_fifo_lc(vty_io vio, vio_fifo vf, vio_line_control lc)
 {
+  int     ret ;
   char*   src ;
   size_t  have ;
-  int     done ;
-  bool    wait_more ;
 
-  if (!vio->file.write_open)
+  /* Collect another line_control height's worth of output.
+   *
+   * Expect the line control to be empty at this point, but it does not have
+   * to be.
+   */
+  vio_lc_set_pause(lc) ;        /* clears lc->paused                    */
+
+  src = vio_fifo_get_rdr(vf, &have) ;
+
+  while ((src != NULL) && (!lc->paused))
     {
-      uty_empty_out_fifos(vio) ;
-      return 0 ;
+      size_t  take ;
+      take = vio_lc_append(lc, src, have) ;
+      src  = vio_fifo_step_rdr(vf, &have, take) ;
     } ;
 
-  wait_more = 0 ;
+  vio->cli_dirty = (lc->col != 0) ;
 
-  while ((src = vio_fifo_get_lump(vf, &have)) != NULL)
-    {
-      if (line_control != NULL) /* TODO: line control           */
-        {
-          /* Account for what happens if output have bytes from src...
-           * ... and if necessary reduce "have".
-           *
-           * set wait_more if now need to wait
-           */
-        } ;
+  /* Write the contents of the line control                             */
+  ret = uty_write_lc(vio, vf, lc) ;
 
-      done = write_nb(vio->file.fd, src, have) ;
+  if (ret < 0)
+    return ret ;                /* give up now if failed.               */
 
-      if (done < 0)
-        {
-          uty_io_error(vio, "write") ;
+  if ((ret == 0) && vio_fifo_empty(vf))
+    return 0 ;                  /* FIFO and line control empty          */
 
-          vio->file.write_open = 0 ;
-          uty_empty_out_fifos(vio) ;
-          return 0 ;            /* no longer open               */
-        }
+  /* If should now do "--more--", now is the time to prepare for that.
+   *
+   * Entering more state issues a new prompt in the CLI buffer, which can
+   * be written once line control write completes.
+   *
+   * The "--more--" cli will not do anything until the CLI buffer has
+   * cleared.
+   */
+  if (lc->paused && vio->cli_more_enabled)
+    uty_cli_go_more_wait(vio) ;
 
-      vio_fifo_got_upto(vf, src + done) ;
+  return 1 ;                    /* FIFO or line control, not empty      */
+} ;
 
-      if (done < (int)have)
-        {
-          if (line_control != NULL)
-            {
-              /* "put back" have - done bytes for next time     */
-            } ;
+/*------------------------------------------------------------------------------
+ * Write contents of line control (if any).
+ *
+ * NB: expects that the sock is write_open
+ *
+ * NB: does nothing other than write() and buffer management.
+ *
+ * Returns: > 0 => blocked
+ *            0 => all gone
+ *          < 0 => failed
+ */
+static int
+uty_write_lc(vty_io vio, vio_fifo vf, vio_line_control lc)
+{
+  int ret ;
 
-          uty_file_set_write(&vio->file, on) ;
-          return 1 ;            /* output is full               */
-        } ;
+  ret = vio_lc_write_nb(vio->sock.fd, lc) ;
 
-      /* If now wants to wait for a "--more--", then exit
-       *
-       * Note that the line_control cannot tell if the place it wants to
-       * stop is, in fact, the end of the FIFO -- can only tell that
-       * now...
-       */
-      if (wait_more)
-        return vio_fifo_empty(vf) ? 0 : 2 ;
-    } ;
+  if (ret <= 0)
+    vio_fifo_sync_rdr(vf) ;     /* finished with FIFO contents  */
 
-  return 0 ;                    /* all gone                     */
+  return ret ;
 } ;
 
 /*------------------------------------------------------------------------------
- * Empty the output FIFOs
+ * Start command output -- clears down the line control.
  *
- * This is for use when the output has failed or is closed.
+ * Requires that that current line is empty -- restarts the line control
+ * on the basis that is at column 0.
  */
-static void
-uty_empty_out_fifos(vty_io vio)
+extern void
+uty_cmd_output_start(vty_io vio)
 {
-  vio_fifo_set_empty(&vio->cli_obuf) ;
-  vio_fifo_set_empty(&vio->cmd_obuf) ;
+  if (vio->cmd_lc != NULL)
+    vio_lc_clear(vio->cmd_lc) ;
+} ;
+
+/*------------------------------------------------------------------------------
+ * Set the effective height for line control (if any)
+ *
+ * If using line_control, may enable the "--more--" output handling.
+ *
+ * If not, want some limit on the amount of stuff output at a time.
+ *
+ * Sets the line control window width and height.
+ * Sets cli_more_enabled if "--more--" is enabled.
+ */
+extern void
+uty_set_height(vty_io vio)
+{
+  bool on ;
+
+  on = 0 ;              /* default state        */
+
+  if ((vio->cmd_lc != NULL) && !vio->half_closed)
+    {
+      int height ;
+
+      height = 0 ;      /* default state        */
 
-  vio->cmd_wait_more = 0 ;
+      if ((vio->width) != 0)
+        {
+          /* If window size is known, use lines or given height         */
+          if (vio->lines >= 0)
+            height = vio->lines ;
+          else
+            {
+              /* Window height, leaving one line from previous "page"
+               * and one line for the "--more--" -- if at all possible
+               */
+              height = vio->height - 2 ;
+              if (height < 1)
+                height = 1 ;
+            } ;
+        }
+      else
+        {
+          /* If window size not known, use lines if that has been set
+           * explicitly for this terminal.
+           */
+          if (vio->lines_set)
+            height = vio->lines ;
+        } ;
+
+      if (height > 0)
+        on = 1 ;        /* have a defined height        */
+      else
+        height = 200 ;  /* but no "--more--"            */
+
+      vio_lc_set_window(vio->cmd_lc, vio->width, height) ;
+    } ;
+
+  vio->cli_more_enabled = on ;
 } ;
 
 /*==============================================================================
@@ -1321,10 +1815,8 @@ uty_timer_expired (vty_io vio)
   if (vio->half_closed)
     return uty_close(vio) ;             /* curtains                     */
 
-  uty_half_close(vio) ;                 /* bring input side to a halt   */
-
-  vio->timed_out = 1 ;                  /* why stopped                  */
-} ;
+  uty_half_close(vio, "Timed out") ;    /* bring input side to a halt   */
+ } ;
 
 /*------------------------------------------------------------------------------
  * Callback -- qnexus: deal with timer timeout.
@@ -1351,7 +1843,7 @@ vty_timer_thread (struct thread *thread)
 
   VTY_LOCK() ;
 
-  vio->file.t_timer = NULL ;    /* implicitly   */
+  vio->sock.t_timer = NULL ;    /* implicitly   */
 
   uty_timer_expired(vio) ;
 
@@ -1373,7 +1865,7 @@ struct vty_listener
 
   enum vty_type   type ;
 
-  struct vio_file file ;
+  struct vio_sock sock ;
 };
 
 /* List of listeners so can tidy up.                                    */
@@ -1450,7 +1942,7 @@ uty_close_listeners(void)
 
   while ((listener = ssl_pop(&listener, vty_listeners_list, next)) != NULL)
     {
-      uty_file_close(&listener->file) ; /* no ceremony, no flowers      */
+      uty_sock_close(&listener->sock) ; /* no ceremony, no flowers      */
       XFREE(MTYPE_VTY, listener) ;
     } ;
 } ;
@@ -1537,6 +2029,8 @@ uty_serv_sock(const char* addr, unsigned short port)
 
   VTY_ASSERT_LOCKED() ;
 
+  n = 0 ;       /* nothing opened yet   */
+
   /* If have an address, see what kind and whether valid                */
   sa = NULL ;
 
@@ -1620,6 +2114,19 @@ uty_serv_sock_open(sa_family_t family, int type, int protocol,
   if (ret >= 0)
     ret = set_nonblocking(sock);
 
+#if defined(HAVE_IPV6) && defined(IPV6_V6ONLY)
+  /* Want only IPV6 on ipv6 socket (not mapped addresses)
+   *
+   * This distinguishes 0.0.0.0 from :: -- without this, bind() will reject the
+   * attempt to bind to :: after binding to 0.0.0.0.
+   */
+  if ((ret >= 0) && (sa->sa_family == AF_INET6))
+  {
+    int on = 1;
+    ret = setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&on, sizeof(on));
+  }
+#endif
+
   if (ret >= 0)
     ret = sockunion_bind (sock, &su, port, sa) ;
 
@@ -1673,7 +2180,6 @@ uty_serv_vtysh(const char *path)
     {
       uzlog(NULL, LOG_ERR, "Cannot create unix stream socket: %s",
                                                          safe_strerror(errno));
-      umask (old_mask);
       return -1 ;
     }
 
@@ -1711,10 +2217,8 @@ uty_serv_vtysh(const char *path)
     {
       /* set group of socket */
       if ( chown (path, -1, ids.gid_vty) )
-        {
-          uzlog (NULL, LOG_ERR, "uty_serv_vtysh: could chown socket, %s",
+        uzlog (NULL, LOG_ERR, "uty_serv_vtysh: could chown socket, %s",
                                                         safe_strerror (errno) );
-        }
     }
 
   umask (old_mask);
@@ -1745,16 +2249,16 @@ uty_serv_start_listener(int fd, enum vty_type type)
   listener = XCALLOC(MTYPE_VTY, sizeof (struct vty_listener));
 
   ssl_push(vty_listeners_list, listener, next) ;
-  uty_file_init_new(&listener->file, fd, listener) ;
+  uty_sock_init_new(&listener->sock, fd, listener) ;
 
   listener->type = type ;
 
   if (vty_cli_nexus)
-    listener->file.action.read.qnexus = vty_accept_qnexus ;
+    listener->sock.action.read.qnexus = vty_accept_qnexus ;
   else
-    listener->file.action.read.thread = vty_accept_thread ;
+    listener->sock.action.read.thread = vty_accept_thread ;
 
-  uty_file_set_read(&listener->file, on) ;
+  uty_sock_set_read(&listener->sock, on) ;
 } ;
 
 /*------------------------------------------------------------------------------
@@ -1770,7 +2274,7 @@ vty_accept_thread(struct thread *thread)
 
   result = uty_accept(listener, THREAD_FD(thread));
 
-  uty_file_set_read(&listener->file, on) ;
+  uty_sock_set_read(&listener->sock, on) ;
 
   VTY_UNLOCK() ;
   return result ;
@@ -1797,7 +2301,7 @@ uty_accept(vty_listener listener, int listen_sock)
 {
   VTY_ASSERT_LOCKED() ;
 
-  assert(listener->file.fd == listen_sock) ;
+  assert(listener->sock.fd == listen_sock) ;
 
   switch (listener->type)
   {
@@ -1828,9 +2332,9 @@ uty_accept_term(vty_listener listener)
   VTY_ASSERT_LOCKED() ;
 
   /* We can handle IPv4 or IPv6 socket.                                 */
-  sockunion_init_new(&su, 0) ;
+  sockunion_init_new(&su, AF_UNSPEC) ;
 
-  sock = sockunion_accept (listener->file.fd, &su);
+  sock = sockunion_accept (listener->sock.fd, &su);
 
   if (sock < 0)
     {
@@ -1918,7 +2422,7 @@ uty_accept_shell_serv (vty_listener listener)
   client_len = sizeof(client);
   memset (&client, 0, client_len);
 
-  sock = accept(listener->file.fd, (struct sockaddr *) &client,
+  sock = accept(listener->sock.fd, (struct sockaddr *) &client,
                                          (socklen_t *) &client_len) ;
 
   if (sock < 0)
@@ -1948,7 +2452,7 @@ uty_accept_shell_serv (vty_listener listener)
 }
 
 /*==============================================================================
- * Reading from the VTY_SHELL_SERV type file.
+ * Reading from the VTY_SHELL_SERV type sock.
  *
  * The select/pselect call-back ends up in utysh_read_ready().
  */
@@ -1970,7 +2474,7 @@ uty_accept_shell_serv (vty_listener listener)
 static void
 utysh_read_ready(vty_io vio)
 {
-  uty_file_set_read(&vio->file, off) ;
+  uty_sock_set_read(&vio->sock, off) ;
 
   /* TODO: need minimal "CLI" for VTY_SHELL_SERV
    *       NB: when output from command is flushed out, must append the
@@ -1989,7 +2493,7 @@ vtysh_read_qnexus(qps_file qf, void* file_info)
 
   VTY_LOCK() ;
 
-  assert((vio->file.fd == qf->fd) && (vio == vio->file.info)) ;
+  assert((vio->sock.fd == qf->fd) && (vio == vio->sock.info)) ;
 
   utysh_read_ready(vio) ;
 
@@ -2006,9 +2510,9 @@ vtysh_read_thread(struct thread *thread)
 
   VTY_LOCK() ;
 
-  assert(vio->file.fd == THREAD_FD (thread) && (vio == vio->file.info)) ;
+  assert(vio->sock.fd == THREAD_FD (thread) && (vio == vio->sock.info)) ;
 
-  vio->file.t_read = NULL ;     /* implicitly   */
+  vio->sock.t_read = NULL ;     /* implicitly   */
   utysh_read_ready(vio);
 
   VTY_UNLOCK() ;
@@ -2025,7 +2529,7 @@ vtysh_read_thread(struct thread *thread)
  * Moves stuff from the "buf" qstring and appends to "cl" qstring, stopping
  * when get '\0' or empties the "buf".
  *
- * When empties "buf", reads a lump from the file.
+ * When empties "buf", reads a lump from the sock.
  *
  * Returns:  0 => command line is incomplete
  *           1 => have a complete command line
@@ -2070,13 +2574,13 @@ utysh_read (vty_io vio, qstring cl, qstring buf)
       /* buffer is empty -- try and get some more stuff                 */
       assert(buf->len == buf->cp) ;
 
-      if (!vio->file.read_open)
+      if (!vio->sock.read_open)
         return -1 ;             /* at EOF if not open     <<<<<<<<<<<<< */
 
       qs_need(buf, 500) ;       /* need a reasonable lump               */
-      qs_set_empty(buf) ;       /* set cp = len = 0                     */
+      qs_clear(buf) ;           /* set cp = len = 0                     */
 
-      get = read_nb(vio->file.fd, buf->body, buf->size) ;
+      get = read_nb(vio->sock.fd, buf->body, buf->size) ;
       if      (get > 0)
         buf->len = get ;
       else if (get == 0)
@@ -2084,9 +2588,9 @@ utysh_read (vty_io vio, qstring cl, qstring buf)
       else
         {
           if (get == -1)
-            uty_io_error(vio, "read") ;
+            uty_sock_error(vio, "read") ;
 
-          vio->file.read_open = 0 ;
+          vio->sock.read_open = 0 ;
 
           return -1 ;           /* at EOF or failed       <<<<<<<<<<<<< */
         } ;
@@ -2096,13 +2600,65 @@ utysh_read (vty_io vio, qstring cl, qstring buf)
 /*==============================================================================
  * Output to vty which are set to "monitor".
  *
- * If there is something in the command FIFO and command is not in progress,
- * then throw logging away -- console is busy dealing with the output from
- * some command.
+ * This is VERY TRICKY.
+ *
+ * If not running qpthreaded, then the objective is to get the message away
+ * immediately -- do not wish it to be delayed in any way by the thread
+ * system.
+ *
+ * So proceed as follows:
+ *
+ *   a. wipe command line        -- which adds output to the CLI buffer
+ *
+ *   b. write the CLI buffer to the sock and any outstanding line control.
+ *
+ *   c. write the monitor output.
+ *
+ *      If that does not complete, put the tail end to the CLI buffer.
+ *
+ *   d. restore any command line -- which adds output to the CLI buffer
+ *
+ *   e. write the CLI buffer to the sock
+ *
+ * If that all succeeds, nothing has changed as far as the VTY stuff is
+ * concerned -- except that possibly some CLI output was sent before it got
+ * round to it.
+ *
+ * Note that step (b) will deal with any output hanging around from an
+ * earlier step (e).  If cannot complete that, then does not add fuel to the
+ * fire -- but the message will be discarded.
+ *
+ * If that fails, or does not complete, then can set write on, to signal that
+ * there is some output in the CLI buffer that needs to be sent, or some
+ * error to be dealt with.
+ *
+ * The output should be tidy.
+ *
+ * To cut down the clutter, step (d) is performed only if the command line
+ * is not empty (or if in cli_more_wait).  Once a the user has started to enter
+ * a command, the prompt and the command will remain visible.
  *
- * Wipes the command line and flushes the output.  If the CLI FIFO is now
- * empty, add the logging line to it and flush.  Enable read, so that the
- * CLI will be reentered, and the command line restored in due course.
+ * When logging an I/O error for a vty that happens to be a monitor, the
+ * monitor-ness has already been turned off.  The monitor output code does not
+ * attempt to log any errors, sets write on so that the error will be picked
+ * up that way.
+ *
+ * However, in the event of an assertion failure, it is possible that an
+ * assertion will fail inside the monitor output.  The monitor_busy flag
+ * prevents disaster.  It is also left set if I/O fails in monitor output, so
+ * will not try to use the monitor again.
+ *
+ * Note that an assertion which is false for all vty monitors will recurse
+ * through all the monitors, setting each one busy, in turn !
+ *
+
+
+ * TODO: sort out write on in the qpthreads world ??
+ *
+ * The problem is that the qpselect structure is designed to be accessed ONLY
+ * within the thread to which it belongs.  This makes it impossible for the
+ * monitor output to set/clear read/write on the vty sock... so some way
+ * around this is required.
  */
 
 /*------------------------------------------------------------------------------
@@ -2113,67 +2669,52 @@ uty_log(struct logline* ll, struct zlog *zl, int priority,
                                                  const char *format, va_list va)
 {
   vty_io  vio ;
-  vty_io  next ;
 
   VTY_ASSERT_LOCKED() ;
 
-  next = sdl_head(vio_monitors_base) ;
+  vio = sdl_head(vio_monitors_base) ;
 
-  if (next == NULL)
+  if (vio == NULL)
     return ;                    /* go no further if no "monitor" vtys   */
 
   /* Prepare line for output.                                           */
-  uvzlog_line(ll, zl, priority, format, va, 1) ;  /* with crlf          */
+  uvzlog_line(ll, zl, priority, format, va, llt_crlf) ; /* with crlf    */
 
   /* write to all known "monitor" vty
    *
-   * While writing to a given "monitor" the monitor flag is cleared.  This
-   * means that if the write fails, and logs a message, then will recurse
-   * through here -- but won't log to the monitor that has failed.
-   *
-   * If one of the other monitors fails during this process, will recurse
-   * again, now with two monitors with their monitor flags cleared.
-   *
-   * Once the output (and any recursed output) has completed, then the
-   * monitor flag is restored -- but only if the vty is still write_open.
-   *
-   * A monitor that is not write_open at the end of this, is removed from the
-   * monitors list.  The current vio *cannot* be the current vio at a higher
-   * level in any recursion stack, because... if anything higher up the stack
-   * will have their monitor flag cleared, and therefore have been stepped
-   * over at the current level.
    */
-  while (next != NULL)
+  while (vio != NULL)
     {
-      vio = next ;
-
-      if ( vio->monitor          /* may be temporarily not a monitor     */
-          && (vio->cmd_in_progress || vio_fifo_empty(&vio->cmd_obuf)) )
+      if (!vio->monitor_busy)
         {
-          vio->monitor = 0 ;    /* avoid recursion                      */
+          int ret ;
 
-          uty_cli_wipe(vio) ;
-          uty_write(vio) ;
+          vio->monitor_busy = 1 ;       /* close the door               */
 
-          if (vio_fifo_empty(&vio->cli_obuf) && vio->file.write_open)
+          uty_cli_pre_monitor(vio, ll->len - 2) ;  /* claim the console */
+
+          ret = uty_write_monitor(vio) ;
+          if (ret == 0)
             {
-              vio_fifo_put(&vio->cli_obuf, ll->line, ll->len) ;
-              uty_write(vio) ;
+              ret = write_nb(vio->sock.fd, ll->line, ll->len) ;
+
+              if (ret >= 0)
+                {
+                  ret = uty_cli_post_monitor(vio, ll->line + ret,
+                                                  ll->len  - ret) ;
+                  if (ret > 0)
+                    ret = uty_write_monitor(vio) ;
+                } ;
             } ;
 
-          uty_file_set_read(&vio->file, on) ;
+          if (ret != 0)
+            /* need to prod   */ ;
 
-          /* It is possible that something failed, so that is no longer
-           * write_open, and should no longer be a monitor.
-           */
-          vio->monitor = vio->file.write_open ;
+          if (ret >= 0)
+            vio->monitor_busy = 0 ;
         } ;
 
-      next = sdl_next(vio, mon_list) ;
-
-      /* take self off list if no onger a monitor               */
-      if (!vio->monitor)
-        sdl_del(vio_monitors_base, vio, mon_list) ;
+      vio = sdl_next(vio, mon_list) ;
     } ;
 } ;
 
@@ -2194,8 +2735,8 @@ vty_log_fixed (const char *buf, size_t len)
   vio = sdl_head(vio_monitors_base) ;
   while (vio != NULL)
     {
-      write(vio->file.fd, buf, len) ;
-      write(vio->file.fd, "\r\n", 2) ;
+      write(vio->sock.fd, buf, len) ;
+      write(vio->sock.fd, "\r\n", 2) ;
 
       vio = sdl_next(vio, mon_list) ;
     } ;