src/vlib/unix/cli.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * cli.c: Unix stdin/socket CLI.
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39 /**
  40  * @file
  41  * @brief Unix stdin/socket command line interface.
  42  * Provides a command line interface so humans can interact with VPP.
  43  * This is predominantly a debugging and testing mechanism.
  44  */
  45 /*? %%clicmd:group_label Command line session %% ?*/
  46 /*? %%syscfg:group_label Command line session %% ?*/
  47
  48 #include <vlib/vlib.h>
  49 #include <vlib/unix/unix.h>
  50
  51 #include <ctype.h>
  52 #include <fcntl.h>
  53 #include <sys/stat.h>
  54 #include <termios.h>
  55 #include <signal.h>
  56 #include <unistd.h>
  57 #include <arpa/telnet.h>
  58 #include <sys/ioctl.h>
  59 #include <sys/types.h>
  60 #include <unistd.h>
  61 #include <limits.h>
  62 #include <netinet/tcp.h>
  63 #include <math.h>
  64
  65 /** ANSI escape code. */
  66 #define ESC "\x1b"
  67
  68 /** ANSI Control Sequence Introducer. */
  69 #define CSI ESC "["
  70
  71 /** ANSI clear screen. */
  72 #define ANSI_CLEAR      CSI "2J" CSI "1;1H"
  73 /** ANSI reset color settings. */
  74 #define ANSI_RESET      CSI "0m"
  75 /** ANSI Start bold text. */
  76 #define ANSI_BOLD       CSI "1m"
  77 /** ANSI Stop bold text. */
  78 #define ANSI_DIM        CSI "2m"
  79 /** ANSI Start dark red text. */
  80 #define ANSI_DRED       ANSI_DIM CSI "31m"
  81 /** ANSI Start bright red text. */
  82 #define ANSI_BRED       ANSI_BOLD CSI "31m"
  83 /** ANSI clear line cursor is on. */
  84 #define ANSI_CLEARLINE  CSI "2K"
  85 /** ANSI scroll screen down one line. */
  86 #define ANSI_SCROLLDN   CSI "1T"
  87 /** ANSI save cursor position. */
  88 #define ANSI_SAVECURSOR CSI "s"
  89 /** ANSI restore cursor position if previously saved. */
  90 #define ANSI_RESTCURSOR CSI "u"
  91
  92 /** Maximum depth into a byte stream from which to compile a Telnet
  93  * protocol message. This is a safety measure. */
  94 #define UNIX_CLI_MAX_DEPTH_TELNET 24
  95
  96 /** Maximum terminal width we will accept */
  97 #define UNIX_CLI_MAX_TERMINAL_WIDTH 512
  98 /** Maximum terminal height we will accept */
  99 #define UNIX_CLI_MAX_TERMINAL_HEIGHT 512
 100 /** Default terminal height */
 101 #define UNIX_CLI_DEFAULT_TERMINAL_HEIGHT 24
 102 /** Default terminal width */
 103 #define UNIX_CLI_DEFAULT_TERMINAL_WIDTH 80
 104
 105 /** A CLI banner line. */
 106 typedef struct
 107 {
 108   u8 *line;     /**< The line to print. */
 109   u32 length;   /**< The length of the line without terminating NUL. */
 110 } unix_cli_banner_t;
 111
 112 #define _(a) { .line = (u8 *)(a), .length = sizeof(a) - 1 }
 113 /** Plain welcome banner. */
 114 static unix_cli_banner_t unix_cli_banner[] = {
 115   _("    _______    _        _   _____  ___ \n"),
 116   _(" __/ __/ _ \\  (_)__    | | / / _ \\/ _ \\\n"),
 117   _(" _/ _// // / / / _ \\   | |/ / ___/ ___/\n"),
 118   _(" /_/ /____(_)_/\\___/   |___/_/  /_/    \n"),
 119   _("\n")
 120 };
 121
 122 /** ANSI color welcome banner. */
 123 static unix_cli_banner_t unix_cli_banner_color[] = {
 124   _(ANSI_BRED "    _______    _     " ANSI_RESET "   _   _____  ___ \n"),
 125   _(ANSI_BRED " __/ __/ _ \\  (_)__ " ANSI_RESET "   | | / / _ \\/ _ \\\n"),
 126   _(ANSI_BRED " _/ _// // / / / _ \\" ANSI_RESET "   | |/ / ___/ ___/\n"),
 127   _(ANSI_BRED " /_/ /____(_)_/\\___/" ANSI_RESET "   |___/_/  /_/    \n"),
 128   _("\n")
 129 };
 130
 131 #undef _
 132
 133 /** Pager line index */
 134 typedef struct
 135 {
 136   /** Index into pager_vector */
 137   u32 line;
 138
 139   /** Offset of the string in the line */
 140   u32 offset;
 141
 142   /** Length of the string in the line */
 143   u32 length;
 144 } unix_cli_pager_index_t;
 145
 146
 147 /** Unix CLI session. */
 148 typedef struct
 149 {
 150   /** The file index held by unix.c */
 151   u32 clib_file_index;
 152
 153   /** Vector of output pending write to file descriptor. */
 154   u8 *output_vector;
 155
 156   /** Vector of input saved by Unix input node to be processed by
 157      CLI process. */
 158   u8 *input_vector;
 159
 160   /** This session has command history. */
 161   u8 has_history;
 162   /** Array of vectors of commands in the history. */
 163   u8 **command_history;
 164   /** The command currently pointed at by the history cursor. */
 165   u8 *current_command;
 166   /** How far from the end of the history array the user has browsed. */
 167   i32 excursion;
 168
 169   /** Maximum number of history entries this session will store. */
 170   u32 history_limit;
 171
 172   /** Current command line counter */
 173   u32 command_number;
 174
 175   /** The string being searched for in the history. */
 176   u8 *search_key;
 177   /** If non-zero then the CLI is searching in the history array.
 178    * - @c -1 means search backwards.
 179    * - @c 1 means search forwards.
 180    */
 181   int search_mode;
 182
 183   /** Position of the insert cursor on the current input line */
 184   u32 cursor;
 185
 186   /** Line mode or char mode */
 187   u8 line_mode;
 188
 189   /** Set if the CRLF mode wants CR + LF */
 190   u8 crlf_mode;
 191
 192   /** Can we do ANSI output? */
 193   u8 ansi_capable;
 194
 195   /** Has the session started? */
 196   u8 started;
 197
 198   /** Disable the pager? */
 199   u8 no_pager;
 200
 201   /** Whether the session is interactive or not.
 202    * Controls things like initial banner, the CLI prompt etc.  */
 203   u8 is_interactive;
 204
 205   /** Whether the session is attached to a socket. */
 206   u8 is_socket;
 207
 208   /** If EPIPE has been detected, prevent further write-related
 209    * activity on the descriptor.
 210    */
 211   u8 has_epipe;
 212
 213   /** Pager buffer */
 214   u8 **pager_vector;
 215
 216   /** Index of line fragments in the pager buffer */
 217   unix_cli_pager_index_t *pager_index;
 218
 219   /** Line number of top of page */
 220   u32 pager_start;
 221
 222   /** Terminal width */
 223   u32 width;
 224
 225   /** Terminal height */
 226   u32 height;
 227
 228   /** Process node identifier */
 229   u32 process_node_index;
 230
 231   /** The current direction of cursor travel.
 232    *  This is important since when advancing left-to-right, at the
 233    *  right hand edge of the console the terminal typically defers
 234    *  wrapping the cursor to the next line until a character is
 235    *  actually displayed.
 236    *  This messes up our heuristic for whether to use ANSI to return
 237    *  the cursor to the end of the line and instead we have to
 238    *  nudge the cursor to the next line.
 239    *  A Value of @c 0 means we're advancing left-to-right; @c 1 means
 240    *  the opposite.
 241    */
 242   u8 cursor_direction;
 243
 244 } unix_cli_file_t;
 245
 246 /** Resets the pager buffer and other data.
 247  * @param f The CLI session whose pager needs to be reset.
 248  */
 249 always_inline void
 250 unix_cli_pager_reset (unix_cli_file_t * f)
 251 {
 252   u8 **p;
 253
 254   f->pager_start = 0;
 255
 256   vec_free (f->pager_index);
 257   f->pager_index = 0;
 258
 259   vec_foreach (p, f->pager_vector)
 260   {
 261     vec_free (*p);
 262   }
 263   vec_free (f->pager_vector);
 264   f->pager_vector = 0;
 265 }
 266
 267 /** Release storage used by a CLI session.
 268  * @param f The CLI session whose storage needs to be released.
 269  */
 270 always_inline void
 271 unix_cli_file_free (unix_cli_file_t * f)
 272 {
 273   vec_free (f->output_vector);
 274   vec_free (f->input_vector);
 275   unix_cli_pager_reset (f);
 276 }
 277
 278 /** CLI actions */
 279 typedef enum
 280 {
 281   UNIX_CLI_PARSE_ACTION_NOACTION = 0,   /**< No action */
 282   UNIX_CLI_PARSE_ACTION_CRLF,           /**< Carriage return, newline or enter */
 283   UNIX_CLI_PARSE_ACTION_TAB,            /**< Tab key */
 284   UNIX_CLI_PARSE_ACTION_ERASE,          /**< Erase cursor left */
 285   UNIX_CLI_PARSE_ACTION_ERASERIGHT,     /**< Erase cursor right */
 286   UNIX_CLI_PARSE_ACTION_UP,             /**< Up arrow */
 287   UNIX_CLI_PARSE_ACTION_DOWN,           /**< Down arrow */
 288   UNIX_CLI_PARSE_ACTION_LEFT,           /**< Left arrow */
 289   UNIX_CLI_PARSE_ACTION_RIGHT,          /**< Right arrow */
 290   UNIX_CLI_PARSE_ACTION_HOME,           /**< Home key (jump to start of line) */
 291   UNIX_CLI_PARSE_ACTION_END,            /**< End key (jump to end of line) */
 292   UNIX_CLI_PARSE_ACTION_WORDLEFT,       /**< Jump cursor to start of left word */
 293   UNIX_CLI_PARSE_ACTION_WORDRIGHT,      /**< Jump cursor to start of right word */
 294   UNIX_CLI_PARSE_ACTION_ERASELINELEFT,  /**< Erase line to left of cursor */
 295   UNIX_CLI_PARSE_ACTION_ERASELINERIGHT, /**< Erase line to right & including cursor */
 296   UNIX_CLI_PARSE_ACTION_ERASEWORDLEFT,  /**< Erase word left */
 297   UNIX_CLI_PARSE_ACTION_CLEAR,          /**< Clear the terminal */
 298   UNIX_CLI_PARSE_ACTION_REVSEARCH,      /**< Search backwards in command history */
 299   UNIX_CLI_PARSE_ACTION_FWDSEARCH,      /**< Search forwards in command history */
 300   UNIX_CLI_PARSE_ACTION_YANK,           /**< Undo last erase action */
 301   UNIX_CLI_PARSE_ACTION_TELNETIAC,      /**< Telnet control code */
 302
 303   UNIX_CLI_PARSE_ACTION_PAGER_CRLF,     /**< Enter pressed (CR, CRLF, LF, etc) */
 304   UNIX_CLI_PARSE_ACTION_PAGER_QUIT,     /**< Exit the pager session */
 305   UNIX_CLI_PARSE_ACTION_PAGER_NEXT,     /**< Scroll to next page */
 306   UNIX_CLI_PARSE_ACTION_PAGER_DN,       /**< Scroll to next line */
 307   UNIX_CLI_PARSE_ACTION_PAGER_UP,       /**< Scroll to previous line */
 308   UNIX_CLI_PARSE_ACTION_PAGER_TOP,      /**< Scroll to first line */
 309   UNIX_CLI_PARSE_ACTION_PAGER_BOTTOM,   /**< Scroll to last line */
 310   UNIX_CLI_PARSE_ACTION_PAGER_PGDN,     /**< Scroll to next page */
 311   UNIX_CLI_PARSE_ACTION_PAGER_PGUP,     /**< Scroll to previous page */
 312   UNIX_CLI_PARSE_ACTION_PAGER_REDRAW,   /**< Clear and redraw the page on the terminal */
 313   UNIX_CLI_PARSE_ACTION_PAGER_SEARCH,   /**< Search the pager buffer */
 314
 315   UNIX_CLI_PARSE_ACTION_PARTIALMATCH,   /**< Action parser found a partial match */
 316   UNIX_CLI_PARSE_ACTION_NOMATCH         /**< Action parser did not find any match */
 317 } unix_cli_parse_action_t;
 318
 319 /** @brief Mapping of input buffer strings to action values.
 320  * @note This won't work as a hash since we need to be able to do
 321  *       partial matches on the string.
 322  */
 323 typedef struct
 324 {
 325   u8 *input;                        /**< Input string to match. */
 326   u32 len;                          /**< Length of input without final NUL. */
 327   unix_cli_parse_action_t action;   /**< Action to take when matched. */
 328 } unix_cli_parse_actions_t;
 329
 330 /** @brief Given a capital ASCII letter character return a @c NUL terminated
 331  * string with the control code for that letter.
 332  *
 333  * @param c An ASCII character.
 334  * @return A @c NUL terminated string of type @c u8[].
 335  *
 336  * @par Example
 337  *     @c CTL('A') returns <code>{ 0x01, 0x00 }</code> as a @c u8[].
 338  */
 339 #define CTL(c) (u8[]){ (c) - '@', 0 }
 340
 341 #define _(a,b) { .input = (u8 *)(a), .len = sizeof(a) - 1, .action = (b) }
 342 /**
 343  * Patterns to match on a CLI input stream.
 344  * @showinitializer
 345  */
 346 static unix_cli_parse_actions_t unix_cli_parse_strings[] = {
 347   /* Line handling */
 348   _("\r\n", UNIX_CLI_PARSE_ACTION_CRLF),        /* Must be before '\r' */
 349   _("\n", UNIX_CLI_PARSE_ACTION_CRLF),
 350   _("\r\0", UNIX_CLI_PARSE_ACTION_CRLF),        /* Telnet does this */
 351   _("\r", UNIX_CLI_PARSE_ACTION_CRLF),
 352
 353   /* Unix shell control codes */
 354   _(CTL ('B'), UNIX_CLI_PARSE_ACTION_LEFT),
 355   _(CTL ('F'), UNIX_CLI_PARSE_ACTION_RIGHT),
 356   _(CTL ('P'), UNIX_CLI_PARSE_ACTION_UP),
 357   _(CTL ('N'), UNIX_CLI_PARSE_ACTION_DOWN),
 358   _(CTL ('A'), UNIX_CLI_PARSE_ACTION_HOME),
 359   _(CTL ('E'), UNIX_CLI_PARSE_ACTION_END),
 360   _(CTL ('D'), UNIX_CLI_PARSE_ACTION_ERASERIGHT),
 361   _(CTL ('U'), UNIX_CLI_PARSE_ACTION_ERASELINELEFT),
 362   _(CTL ('K'), UNIX_CLI_PARSE_ACTION_ERASELINERIGHT),
 363   _(CTL ('W'), UNIX_CLI_PARSE_ACTION_ERASEWORDLEFT),
 364   _(CTL ('Y'), UNIX_CLI_PARSE_ACTION_YANK),
 365   _(CTL ('L'), UNIX_CLI_PARSE_ACTION_CLEAR),
 366   _(ESC "b", UNIX_CLI_PARSE_ACTION_WORDLEFT),   /* Alt-B */
 367   _(ESC "f", UNIX_CLI_PARSE_ACTION_WORDRIGHT),  /* Alt-F */
 368   _("\b", UNIX_CLI_PARSE_ACTION_ERASE), /* ^H */
 369   _("\x7f", UNIX_CLI_PARSE_ACTION_ERASE),       /* Backspace */
 370   _("\t", UNIX_CLI_PARSE_ACTION_TAB),   /* ^I */
 371
 372   /* VT100 Normal mode - Broadest support */
 373   _(CSI "A", UNIX_CLI_PARSE_ACTION_UP),
 374   _(CSI "B", UNIX_CLI_PARSE_ACTION_DOWN),
 375   _(CSI "C", UNIX_CLI_PARSE_ACTION_RIGHT),
 376   _(CSI "D", UNIX_CLI_PARSE_ACTION_LEFT),
 377   _(CSI "H", UNIX_CLI_PARSE_ACTION_HOME),
 378   _(CSI "F", UNIX_CLI_PARSE_ACTION_END),
 379   _(CSI "3~", UNIX_CLI_PARSE_ACTION_ERASERIGHT),        /* Delete */
 380   _(CSI "1;5D", UNIX_CLI_PARSE_ACTION_WORDLEFT),        /* C-Left */
 381   _(CSI "1;5C", UNIX_CLI_PARSE_ACTION_WORDRIGHT),       /* C-Right */
 382
 383   /* VT100 Application mode - Some Gnome Terminal functions use these */
 384   _(ESC "OA", UNIX_CLI_PARSE_ACTION_UP),
 385   _(ESC "OB", UNIX_CLI_PARSE_ACTION_DOWN),
 386   _(ESC "OC", UNIX_CLI_PARSE_ACTION_RIGHT),
 387   _(ESC "OD", UNIX_CLI_PARSE_ACTION_LEFT),
 388   _(ESC "OH", UNIX_CLI_PARSE_ACTION_HOME),
 389   _(ESC "OF", UNIX_CLI_PARSE_ACTION_END),
 390
 391   /* ANSI X3.41-1974 - sent by Microsoft Telnet and PuTTY */
 392   _(CSI "1~", UNIX_CLI_PARSE_ACTION_HOME),
 393   _(CSI "4~", UNIX_CLI_PARSE_ACTION_END),
 394
 395   /* Emacs-ish history search */
 396   _(CTL ('S'), UNIX_CLI_PARSE_ACTION_FWDSEARCH),
 397   _(CTL ('R'), UNIX_CLI_PARSE_ACTION_REVSEARCH),
 398
 399   /* Other protocol things */
 400   _("\xff", UNIX_CLI_PARSE_ACTION_TELNETIAC),   /* IAC */
 401   _("\0", UNIX_CLI_PARSE_ACTION_NOACTION),      /* NUL */
 402   _(NULL, UNIX_CLI_PARSE_ACTION_NOMATCH)
 403 };
 404
 405 /**
 406  * Patterns to match when a CLI session is in the pager.
 407  * @showinitializer
 408  */
 409 static unix_cli_parse_actions_t unix_cli_parse_pager[] = {
 410   /* Line handling */
 411   _("\r\n", UNIX_CLI_PARSE_ACTION_PAGER_CRLF),  /* Must be before '\r' */
 412   _("\n", UNIX_CLI_PARSE_ACTION_PAGER_CRLF),
 413   _("\r\0", UNIX_CLI_PARSE_ACTION_PAGER_CRLF),  /* Telnet does this */
 414   _("\r", UNIX_CLI_PARSE_ACTION_PAGER_CRLF),
 415
 416   /* Pager commands */
 417   _(" ", UNIX_CLI_PARSE_ACTION_PAGER_NEXT),
 418   _("q", UNIX_CLI_PARSE_ACTION_PAGER_QUIT),
 419   _(CTL ('L'), UNIX_CLI_PARSE_ACTION_PAGER_REDRAW),
 420   _(CTL ('R'), UNIX_CLI_PARSE_ACTION_PAGER_REDRAW),
 421   _("/", UNIX_CLI_PARSE_ACTION_PAGER_SEARCH),
 422
 423   /* VT100 */
 424   _(CSI "A", UNIX_CLI_PARSE_ACTION_PAGER_UP),
 425   _(CSI "B", UNIX_CLI_PARSE_ACTION_PAGER_DN),
 426   _(CSI "H", UNIX_CLI_PARSE_ACTION_PAGER_TOP),
 427   _(CSI "F", UNIX_CLI_PARSE_ACTION_PAGER_BOTTOM),
 428
 429   /* VT100 Application mode */
 430   _(ESC "OA", UNIX_CLI_PARSE_ACTION_PAGER_UP),
 431   _(ESC "OB", UNIX_CLI_PARSE_ACTION_PAGER_DN),
 432   _(ESC "OH", UNIX_CLI_PARSE_ACTION_PAGER_TOP),
 433   _(ESC "OF", UNIX_CLI_PARSE_ACTION_PAGER_BOTTOM),
 434
 435   /* ANSI X3.41-1974 */
 436   _(CSI "1~", UNIX_CLI_PARSE_ACTION_PAGER_TOP),
 437   _(CSI "4~", UNIX_CLI_PARSE_ACTION_PAGER_BOTTOM),
 438   _(CSI "5~", UNIX_CLI_PARSE_ACTION_PAGER_PGUP),
 439   _(CSI "6~", UNIX_CLI_PARSE_ACTION_PAGER_PGDN),
 440
 441   /* Other protocol things */
 442   _("\xff", UNIX_CLI_PARSE_ACTION_TELNETIAC),   /* IAC */
 443   _("\0", UNIX_CLI_PARSE_ACTION_NOACTION),      /* NUL */
 444   _(NULL, UNIX_CLI_PARSE_ACTION_NOMATCH)
 445 };
 446
 447 #undef _
 448
 449 /** CLI session events. */
 450 typedef enum
 451 {
 452   UNIX_CLI_PROCESS_EVENT_READ_READY,  /**< A file descriptor has data to be read. */
 453   UNIX_CLI_PROCESS_EVENT_QUIT,        /**< A CLI session wants to close. */
 454 } unix_cli_process_event_type_t;
 455
 456 /** CLI session telnet negotiation timer events. */
 457 typedef enum
 458 {
 459   UNIX_CLI_NEW_SESSION_EVENT_ADD, /**< Add a CLI session to the new session list */
 460 } unix_cli_timeout_event_type_t;
 461
 462 /** Each new session is stored on a list with a deadline after which
 463  * a prompt is issued, in case the session TELNET negotiation fails to
 464  * complete. */
 465 typedef struct
 466 {
 467   uword cf_index; /**< Session index of the new session. */
 468   f64 deadline;   /**< Deadline after which the new session must have a prompt. */
 469 } unix_cli_new_session_t;
 470
 471 /** CLI global state. */
 472 typedef struct
 473 {
 474   /** Prompt string for CLI. */
 475   u8 *cli_prompt;
 476
 477   /** Vec pool of CLI sessions. */
 478   unix_cli_file_t *cli_file_pool;
 479
 480   /** Vec pool of unused session indices. */
 481   u32 *unused_cli_process_node_indices;
 482
 483   /** The session index of the stdin cli */
 484   u32 stdin_cli_file_index;
 485
 486   /** File pool index of current input. */
 487   u32 current_input_file_index;
 488
 489   /** New session process node identifier */
 490   u32 new_session_process_node_index;
 491
 492   /** List of new sessions */
 493   unix_cli_new_session_t *new_sessions;
 494 } unix_cli_main_t;
 495
 496 /** CLI global state */
 497 static unix_cli_main_t unix_cli_main;
 498
 499 /**
 500  * @brief Search for a byte sequence in the action list.
 501  *
 502  * Searches the @ref unix_cli_parse_actions_t list in @a a for a match with
 503  * the bytes in @a input of maximum length @a ilen bytes.
 504  * When a match is made @a *matched indicates how many bytes were matched.
 505  * Returns a value from the enum @ref unix_cli_parse_action_t to indicate
 506  * whether no match was found, a partial match was found or a complete
 507  * match was found and what action, if any, should be taken.
 508  *
 509  * @param[in]  a        Actions list to search within.
 510  * @param[in]  input    String fragment to search for.
 511  * @param[in]  ilen     Length of the string in 'input'.
 512  * @param[out] matched  Pointer to an integer that will contain the number
 513  *                      of bytes matched when a complete match is found.
 514  *
 515  * @return Action from @ref unix_cli_parse_action_t that the string fragment
 516  *         matches.
 517  *         @ref UNIX_CLI_PARSE_ACTION_PARTIALMATCH is returned when the
 518  *         whole input string matches the start of at least one action.
 519  *         @ref UNIX_CLI_PARSE_ACTION_NOMATCH is returned when there is no
 520  *         match at all.
 521  */
 522 static unix_cli_parse_action_t
 523 unix_cli_match_action (unix_cli_parse_actions_t * a,
 524                        u8 * input, u32 ilen, i32 * matched)
 525 {
 526   u8 partial = 0;
 527
 528   while (a->input)
 529     {
 530       if (ilen >= a->len)
 531         {
 532           /* see if the start of the input buffer exactly matches the current
 533            * action string. */
 534           if (memcmp (input, a->input, a->len) == 0)
 535             {
 536               *matched = a->len;
 537               return a->action;
 538             }
 539         }
 540       else
 541         {
 542           /* if the first ilen characters match, flag this as a partial -
 543            * meaning keep collecting bytes in case of a future match */
 544           if (memcmp (input, a->input, ilen) == 0)
 545             partial = 1;
 546         }
 547
 548       /* check next action */
 549       a++;
 550     }
 551
 552   return partial ?
 553     UNIX_CLI_PARSE_ACTION_PARTIALMATCH : UNIX_CLI_PARSE_ACTION_NOMATCH;
 554 }
 555
 556
 557 /** Add bytes to the output vector and then flagg the I/O system that bytes
 558  * are available to be sent.
 559  */
 560 static void
 561 unix_cli_add_pending_output (clib_file_t * uf,
 562                              unix_cli_file_t * cf,
 563                              u8 * buffer, uword buffer_bytes)
 564 {
 565   clib_file_main_t *fm = &file_main;
 566
 567   vec_add (cf->output_vector, buffer, buffer_bytes);
 568   if (vec_len (cf->output_vector) > 0)
 569     {
 570       int skip_update = 0 != (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE);
 571       uf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
 572       if (!skip_update)
 573         fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
 574     }
 575 }
 576
 577 /** Delete all bytes from the output vector and flag the I/O system
 578  * that no more bytes are available to be sent.
 579  */
 580 static void
 581 unix_cli_del_pending_output (clib_file_t * uf,
 582                              unix_cli_file_t * cf, uword n_bytes)
 583 {
 584   clib_file_main_t *fm = &file_main;
 585
 586   vec_delete (cf->output_vector, n_bytes, 0);
 587   if (vec_len (cf->output_vector) <= 0)
 588     {
 589       int skip_update = 0 == (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE);
 590       uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE;
 591       if (!skip_update)
 592         fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY);
 593     }
 594 }
 595
 596 /** @brief A bit like strchr with a buffer length limit.
 597  * Search a buffer for the first instance of a character up to the limit of
 598  * the buffer length. If found then return the position of that character.
 599  *
 600  * The key departure from strchr is that if the character is not found then
 601  * return the buffer length.
 602  *
 603  * @param chr The byte value to search for.
 604  * @param str The buffer in which to search for the value.
 605  * @param len The depth into the buffer to search.
 606  *
 607  * @return The index of the first occurrence of \c chr. If \c chr is not
 608  *          found then \c len instead.
 609  */
 610 always_inline word
 611 unix_vlib_findchr (u8 chr, u8 * str, word len)
 612 {
 613   word i = 0;
 614   for (i = 0; i < len; i++, str++)
 615     {
 616       if (*str == chr)
 617         return i;
 618     }
 619   return len;
 620 }
 621
 622 /** @brief Send a buffer to the CLI stream if possible, enqueue it otherwise.
 623  * Attempts to write given buffer to the file descriptor of the given
 624  * Unix CLI session. If that session already has data in the output buffer
 625  * or if the write attempt tells us to try again later then the given buffer
 626  * is appended to the pending output buffer instead.
 627  *
 628  * This is typically called only from \c unix_vlib_cli_output_cooked since
 629  * that is where CRLF handling occurs or from places where we explicitly do
 630  * not want cooked handling.
 631  *
 632  * @param cf Unix CLI session of the desired stream to write to.
 633  * @param uf The Unix file structure of the desired stream to write to.
 634  * @param buffer Pointer to the buffer that needs to be written.
 635  * @param buffer_bytes The number of bytes from \c buffer to write.
 636  */
 637 static void
 638 unix_vlib_cli_output_raw (unix_cli_file_t * cf,
 639                           clib_file_t * uf, u8 * buffer, uword buffer_bytes)
 640 {
 641   int n = 0;
 642
 643   if (cf->has_epipe)            /* don't try writing anything */
 644     return;
 645
 646   if (vec_len (cf->output_vector) == 0)
 647     {
 648       if (cf->is_socket)
 649         /* If it's a socket we use MSG_NOSIGNAL to prevent SIGPIPE */
 650         n = send (uf->file_descriptor, buffer, buffer_bytes, MSG_NOSIGNAL);
 651       else
 652         n = write (uf->file_descriptor, buffer, buffer_bytes);
 653     }
 654
 655   if (n < 0 && errno != EAGAIN)
 656     {
 657       if (errno == EPIPE)
 658         {
 659           /* connection closed on us */
 660           unix_main_t *um = &unix_main;
 661           cf->has_epipe = 1;
 662           vlib_process_signal_event (um->vlib_main, cf->process_node_index,
 663                                      UNIX_CLI_PROCESS_EVENT_QUIT,
 664                                      uf->private_data);
 665         }
 666       else
 667         {
 668           clib_unix_warning ("write");
 669         }
 670     }
 671   else if ((word) n < (word) buffer_bytes)
 672     {
 673       /* We got EAGAIN or we already have stuff in the buffer;
 674        * queue up whatever didn't get sent for later. */
 675       if (n < 0)
 676         n = 0;
 677       unix_cli_add_pending_output (uf, cf, buffer + n, buffer_bytes - n);
 678     }
 679 }
 680
 681 /** @brief Process a buffer for CRLF handling before outputting it to the CLI.
 682  *
 683  * @param cf Unix CLI session of the desired stream to write to.
 684  * @param uf The Unix file structure of the desired stream to write to.
 685  * @param buffer Pointer to the buffer that needs to be written.
 686  * @param buffer_bytes The number of bytes from \c buffer to write.
 687  */
 688 static void
 689 unix_vlib_cli_output_cooked (unix_cli_file_t * cf,
 690                              clib_file_t * uf,
 691                              u8 * buffer, uword buffer_bytes)
 692 {
 693   word end = 0, start = 0;
 694
 695   while (end < buffer_bytes)
 696     {
 697       if (cf->crlf_mode)
 698         {
 699           /* iterate the line on \n's so we can insert a \r before it */
 700           end = unix_vlib_findchr ('\n',
 701                                    buffer + start,
 702                                    buffer_bytes - start) + start;
 703         }
 704       else
 705         {
 706           /* otherwise just send the whole buffer */
 707           end = buffer_bytes;
 708         }
 709
 710       unix_vlib_cli_output_raw (cf, uf, buffer + start, end - start);
 711
 712       if (cf->crlf_mode)
 713         {
 714           if (end < buffer_bytes)
 715             {
 716               unix_vlib_cli_output_raw (cf, uf, (u8 *) "\r\n", 2);
 717               end++;            /* skip the \n that we already sent */
 718             }
 719           start = end;
 720         }
 721     }
 722
 723   /* Use the last character to determine the last direction of the cursor. */
 724   if (buffer_bytes > 0)
 725     cf->cursor_direction = (buffer[buffer_bytes - 1] == (u8) '\b');
 726 }
 727
 728 /** @brief Moves the terminal cursor one character to the left, with
 729  * special handling when it reaches the left edge of the terminal window.
 730  *
 731  * Ordinarily we can simply send a '\b' to move the cursor left, however
 732  * most terminals will not reverse-wrap to the end of the previous line
 733  * if the cursor is in the left-most column. To counter this we must
 734  * check the cursor position + prompt length modulo terminal width and
 735  * if available use some other means, such as ANSI terminal escape
 736  * sequences, to move the cursor.
 737  *
 738  * @param cf Unix CLI session of the desired stream to write to.
 739  * @param uf The Unix file structure of the desired stream to write to.
 740  */
 741 static void
 742 unix_vlib_cli_output_cursor_left (unix_cli_file_t * cf, clib_file_t * uf)
 743 {
 744   unix_cli_main_t *cm = &unix_cli_main;
 745   static u8 *ansi = 0;          /* assumes no reentry */
 746   u32 position;
 747
 748   if (!cf->is_interactive || !cf->ansi_capable || !cf->width)
 749     {
 750       /* No special handling for dumb terminals */
 751       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\b", 1);
 752       return;
 753     }
 754
 755   position = ((u32) vec_len (cm->cli_prompt) + cf->cursor) % cf->width;
 756
 757   if (position != 0)
 758     {
 759       /* No special handling required if we're not at the left edge */
 760       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\b", 1);
 761       return;
 762     }
 763
 764   if (!cf->cursor_direction)
 765     {
 766       /* Special handling for when we are at the left edge but
 767        * the cursor was going left-to-right, but in this situation
 768        * xterm-like terminals actually hide the cursor off the right
 769        * edge. A \b here seems to jump one char too many, so let's
 770        * force the cursor onto the next line instead.
 771        */
 772       if (cf->cursor < vec_len (cf->current_command))
 773         unix_vlib_cli_output_cooked (cf, uf, &cf->current_command[cf->cursor],
 774                                      1);
 775       else
 776         unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
 777       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\r", 1);
 778     }
 779
 780   /* Relocate the cursor at the right hand edge one line above */
 781   ansi = format (ansi, CSI "A" CSI "%dC", cf->width - 1);
 782   unix_vlib_cli_output_cooked (cf, uf, ansi, vec_len (ansi));
 783   vec_reset_length (ansi);      /* keep the vec around for next time */
 784   cf->cursor_direction = 1;     /* going backwards now */
 785 }
 786
 787 /** @brief Output the CLI prompt */
 788 static void
 789 unix_cli_cli_prompt (unix_cli_file_t * cf, clib_file_t * uf)
 790 {
 791   unix_cli_main_t *cm = &unix_cli_main;
 792
 793   if (cf->is_interactive)       /* Only interactive sessions get a prompt */
 794     unix_vlib_cli_output_raw (cf, uf, cm->cli_prompt,
 795                               vec_len (cm->cli_prompt));
 796 }
 797
 798 /** @brief Output a pager prompt and show number of buffered lines */
 799 static void
 800 unix_cli_pager_prompt (unix_cli_file_t * cf, clib_file_t * uf)
 801 {
 802   u8 *prompt;
 803   u32 h;
 804
 805   h = cf->pager_start + (cf->height - 1);
 806   if (h > vec_len (cf->pager_index))
 807     h = vec_len (cf->pager_index);
 808
 809   prompt = format (0, "\r%s-- more -- (%d-%d/%d)%s",
 810                    cf->ansi_capable ? ANSI_BOLD : "",
 811                    cf->pager_start + 1,
 812                    h,
 813                    vec_len (cf->pager_index),
 814                    cf->ansi_capable ? ANSI_RESET : "");
 815
 816   unix_vlib_cli_output_cooked (cf, uf, prompt, vec_len (prompt));
 817
 818   vec_free (prompt);
 819 }
 820
 821 /** @brief Output a pager "skipping" message */
 822 static void
 823 unix_cli_pager_message (unix_cli_file_t * cf, clib_file_t * uf,
 824                         char *message, char *postfix)
 825 {
 826   u8 *prompt;
 827
 828   prompt = format (0, "\r%s-- %s --%s%s",
 829                    cf->ansi_capable ? ANSI_BOLD : "",
 830                    message, cf->ansi_capable ? ANSI_RESET : "", postfix);
 831
 832   unix_vlib_cli_output_cooked (cf, uf, prompt, vec_len (prompt));
 833
 834   vec_free (prompt);
 835 }
 836
 837 /** @brief Erase the printed pager prompt */
 838 static void
 839 unix_cli_pager_prompt_erase (unix_cli_file_t * cf, clib_file_t * uf)
 840 {
 841   if (cf->ansi_capable)
 842     {
 843       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\r", 1);
 844       unix_vlib_cli_output_cooked (cf, uf,
 845                                    (u8 *) ANSI_CLEARLINE,
 846                                    sizeof (ANSI_CLEARLINE) - 1);
 847     }
 848   else
 849     {
 850       int i;
 851
 852       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\r", 1);
 853       for (i = 0; i < cf->width - 1; i++)
 854         unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
 855       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\r", 1);
 856     }
 857 }
 858
 859 /** @brief Uses an ANSI escape sequence to move the cursor */
 860 static void
 861 unix_cli_ansi_cursor (unix_cli_file_t * cf, clib_file_t * uf, u16 x, u16 y)
 862 {
 863   u8 *str;
 864
 865   str = format (0, "%s%d;%dH", CSI, y, x);
 866
 867   unix_vlib_cli_output_cooked (cf, uf, str, vec_len (str));
 868
 869   vec_free (str);
 870 }
 871
 872 /** Redraw the currently displayed page of text.
 873  * @param cf CLI session to redraw the pager buffer of.
 874  * @param uf Unix file of the CLI session.
 875  */
 876 static void
 877 unix_cli_pager_redraw (unix_cli_file_t * cf, clib_file_t * uf)
 878 {
 879   unix_cli_pager_index_t *pi = NULL;
 880   u8 *line = NULL;
 881   word i;
 882
 883   /* No active pager? Do nothing. */
 884   if (!vec_len (cf->pager_index))
 885     return;
 886
 887   if (cf->ansi_capable)
 888     {
 889       /* If we have ANSI, send the clear screen sequence */
 890       unix_vlib_cli_output_cooked (cf, uf,
 891                                    (u8 *) ANSI_CLEAR,
 892                                    sizeof (ANSI_CLEAR) - 1);
 893     }
 894   else
 895     {
 896       /* Otherwise make sure we're on a blank line */
 897       unix_cli_pager_prompt_erase (cf, uf);
 898     }
 899
 900   /* (Re-)send the current page of content */
 901   for (i = 0; i < cf->height - 1 &&
 902        i + cf->pager_start < vec_len (cf->pager_index); i++)
 903     {
 904       pi = &cf->pager_index[cf->pager_start + i];
 905       line = cf->pager_vector[pi->line] + pi->offset;
 906
 907       unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
 908     }
 909   /* if the last line didn't end in newline, add a newline */
 910   if (pi && line[pi->length - 1] != '\n')
 911     unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
 912
 913   unix_cli_pager_prompt (cf, uf);
 914 }
 915
 916 /** @brief Process and add a line to the pager index.
 917  * In normal operation this function will take the given character string
 918  * found in @c line and with length @c len_or_index and iterates the over the
 919  * contents, adding each line of text discovered within it to the
 920  * pager index. Lines are identified by newlines ("<code>\\n</code>") and by
 921  * strings longer than the width of the terminal.
 922  *
 923  * If instead @c line is @c NULL then @c len_or_index is taken to mean the
 924  * index of an existing line in the pager buffer; this simply means that the
 925  * input line does not need to be cloned since we already have it. This is
 926  * typical if we are reindexing the pager buffer.
 927  *
 928  * @param cf           The CLI session whose pager we are adding to.
 929  * @param line         The string of text to be indexed into the pager buffer.
 930  *                     If @c line is @c NULL then the mode of operation
 931  *                     changes slightly; see the description above.
 932  * @param len_or_index If @c line is a pointer to a string then this parameter
 933  *                     indicates the length of that string; Otherwise this
 934  *                     value provides the index in the pager buffer of an
 935  *                     existing string to be indexed.
 936  */
 937 static void
 938 unix_cli_pager_add_line (unix_cli_file_t * cf, u8 * line, word len_or_index)
 939 {
 940   u8 *p = NULL;
 941   word i, j, k;
 942   word line_index, len;
 943   u32 width = cf->width;
 944   unix_cli_pager_index_t *pi;
 945
 946   if (line == NULL)
 947     {
 948       /* Use a line already in the pager buffer */
 949       line_index = len_or_index;
 950       if (cf->pager_vector != NULL)
 951         p = cf->pager_vector[line_index];
 952       len = vec_len (p);
 953     }
 954   else
 955     {
 956       len = len_or_index;
 957       /* Add a copy of the raw string to the pager buffer */
 958       p = vec_new (u8, len);
 959       clib_memcpy (p, line, len);
 960
 961       /* store in pager buffer */
 962       line_index = vec_len (cf->pager_vector);
 963       vec_add1 (cf->pager_vector, p);
 964     }
 965
 966   i = 0;
 967   while (i < len)
 968     {
 969       /* Find the next line, or run to terminal width, or run to EOL */
 970       int l = len - i;
 971       j = unix_vlib_findchr ((u8) '\n', p, l < width ? l : width);
 972
 973       if (j < l && p[j] == '\n')        /* incl \n */
 974         j++;
 975
 976       /* Add the line to the index */
 977       k = vec_len (cf->pager_index);
 978       vec_validate (cf->pager_index, k);
 979       pi = &cf->pager_index[k];
 980
 981       pi->line = line_index;
 982       pi->offset = i;
 983       pi->length = j;
 984
 985       i += j;
 986       p += j;
 987     }
 988 }
 989
 990 /** @brief Reindex entire pager buffer.
 991  * Resets the current pager index and then re-adds the lines in the pager
 992  * buffer to the index.
 993  *
 994  * Additionally this function attempts to retain the current page start
 995  * line offset by searching for the same top-of-screen line in the new index.
 996  *
 997  * @param cf The CLI session whose pager buffer should be reindexed.
 998  */
 999 static void
1000 unix_cli_pager_reindex (unix_cli_file_t * cf)
1001 {
1002   word i, old_line, old_offset;
1003   unix_cli_pager_index_t *pi;
1004
1005   /* If there is nothing in the pager buffer then make sure the index
1006    * is empty and move on.
1007    */
1008   if (cf->pager_vector == 0)
1009     {
1010       vec_reset_length (cf->pager_index);
1011       return;
1012     }
1013
1014   /* Retain a pointer to the current page start line so we can
1015    * find it later
1016    */
1017   pi = &cf->pager_index[cf->pager_start];
1018   old_line = pi->line;
1019   old_offset = pi->offset;
1020
1021   /* Re-add the buffered lines to the index */
1022   vec_reset_length (cf->pager_index);
1023   vec_foreach_index (i, cf->pager_vector)
1024   {
1025     unix_cli_pager_add_line (cf, NULL, i);
1026   }
1027
1028   /* Attempt to re-locate the previously stored page start line */
1029   vec_foreach_index (i, cf->pager_index)
1030   {
1031     pi = &cf->pager_index[i];
1032
1033     if (pi->line == old_line &&
1034         (pi->offset <= old_offset || pi->offset + pi->length > old_offset))
1035       {
1036         /* Found it! */
1037         cf->pager_start = i;
1038         break;
1039       }
1040   }
1041
1042   /* In case the start line was not found (rare), ensure the pager start
1043    * index is within bounds
1044    */
1045   if (cf->pager_start >= vec_len (cf->pager_index))
1046     {
1047       if (!cf->height || vec_len (cf->pager_index) < (cf->height - 1))
1048         cf->pager_start = 0;
1049       else
1050         cf->pager_start = vec_len (cf->pager_index) - (cf->height - 1);
1051     }
1052 }
1053
1054 /** VLIB CLI output function.
1055  *
1056  * If the terminal has a pager configured then this function takes care
1057  * of collating output into the pager buffer; ensuring only the first page
1058  * is displayed and any lines in excess of the first page are buffered.
1059  *
1060  * If the maximum number of index lines in the buffer is exceeded then the
1061  * pager is cancelled and the contents of the current buffer are sent to the
1062  * terminal.
1063  *
1064  * If there is no pager configured then the output is sent directly to the
1065  * terminal.
1066  *
1067  * @param cli_file_index Index of the CLI session where this output is
1068  *                       directed.
1069  * @param buffer         String of printabe bytes to be output.
1070  * @param buffer_bytes   The number of bytes in @c buffer to be output.
1071  */
1072 static void
1073 unix_vlib_cli_output (uword cli_file_index, u8 * buffer, uword buffer_bytes)
1074 {
1075   unix_main_t *um = &unix_main;
1076   clib_file_main_t *fm = &file_main;
1077   unix_cli_main_t *cm = &unix_cli_main;
1078   unix_cli_file_t *cf;
1079   clib_file_t *uf;
1080
1081   cf = pool_elt_at_index (cm->cli_file_pool, cli_file_index);
1082   uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
1083
1084   if (cf->no_pager || um->cli_pager_buffer_limit == 0 || cf->height == 0)
1085     {
1086       unix_vlib_cli_output_cooked (cf, uf, buffer, buffer_bytes);
1087     }
1088   else
1089     {
1090       word row = vec_len (cf->pager_index);
1091       u8 *line;
1092       unix_cli_pager_index_t *pi;
1093
1094       /* Index and add the output lines to the pager buffer. */
1095       unix_cli_pager_add_line (cf, buffer, buffer_bytes);
1096
1097       /* Now iterate what was added to display the lines.
1098        * If we reach the bottom of the page, display a prompt.
1099        */
1100       while (row < vec_len (cf->pager_index))
1101         {
1102           if (row < cf->height - 1)
1103             {
1104               /* output this line */
1105               pi = &cf->pager_index[row];
1106               line = cf->pager_vector[pi->line] + pi->offset;
1107               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
1108
1109               /* if the last line didn't end in newline, and we're at the
1110                * bottom of the page, add a newline */
1111               if (line[pi->length - 1] != '\n' && row == cf->height - 2)
1112                 unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
1113             }
1114           else
1115             {
1116               /* Display the pager prompt every 10 lines */
1117               if (!(row % 10))
1118                 unix_cli_pager_prompt (cf, uf);
1119             }
1120           row++;
1121         }
1122
1123       /* Check if we went over the pager buffer limit */
1124       if (vec_len (cf->pager_index) > um->cli_pager_buffer_limit)
1125         {
1126           /* Stop using the pager for the remainder of this CLI command */
1127           cf->no_pager = 2;
1128
1129           /* If we likely printed the prompt, erase it */
1130           if (vec_len (cf->pager_index) > cf->height - 1)
1131             unix_cli_pager_prompt_erase (cf, uf);
1132
1133           /* Dump out the contents of the buffer */
1134           for (row = cf->pager_start + (cf->height - 1);
1135                row < vec_len (cf->pager_index); row++)
1136             {
1137               pi = &cf->pager_index[row];
1138               line = cf->pager_vector[pi->line] + pi->offset;
1139               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
1140             }
1141
1142           unix_cli_pager_reset (cf);
1143         }
1144     }
1145 }
1146
1147 /** Identify whether a terminal type is ANSI capable.
1148  *
1149  * Compares the string given in @c term with a list of terminal types known
1150  * to support ANSI escape sequences.
1151  *
1152  * This list contains, for example, @c xterm, @c screen and @c ansi.
1153  *
1154  * @param term A string with a terminal type in it.
1155  * @param len The length of the string in @c term.
1156  *
1157  * @return @c 1 if the terminal type is recognized as supporting ANSI
1158  *         terminal sequences; @c 0 otherwise.
1159  */
1160 static u8
1161 unix_cli_terminal_type_ansi (u8 * term, uword len)
1162 {
1163   /* This may later be better done as a hash of some sort. */
1164 #define _(a) do { \
1165     if (strncasecmp(a, (char *)term, (size_t)len) == 0) return 1; \
1166   } while(0)
1167
1168   _("xterm");
1169   _("xterm-color");
1170   _("xterm-256color");          /* iTerm on Mac */
1171   _("screen");
1172   _("screen-256color");         /* Screen and tmux */
1173   _("ansi");                    /* Microsoft Telnet */
1174 #undef _
1175
1176   return 0;
1177 }
1178
1179 /** Identify whether a terminal type is non-interactive.
1180  *
1181  * Compares the string given in @c term with a list of terminal types known
1182  * to be non-interactive, as send by tools such as @c vppctl .
1183  *
1184  * This list contains, for example, @c vppctl.
1185  *
1186  * @param term A string with a terminal type in it.
1187  * @param len The length of the string in @c term.
1188  *
1189  * @return @c 1 if the terminal type is recognized as being non-interactive;
1190  *         @c 0 otherwise.
1191  */
1192 static u8
1193 unix_cli_terminal_type_noninteractive (u8 * term, uword len)
1194 {
1195   /* This may later be better done as a hash of some sort. */
1196 #define _(a) do { \
1197     if (strncasecmp(a, (char *)term, (size_t)len) == 0) return 1; \
1198   } while(0)
1199
1200   _("vppctl");
1201 #undef _
1202
1203   return 0;
1204 }
1205
1206 /** Set a session to be non-interactive. */
1207 static void
1208 unix_cli_set_session_noninteractive (unix_cli_file_t * cf)
1209 {
1210   /* Non-interactive sessions don't get these */
1211   cf->is_interactive = 0;
1212   cf->no_pager = 1;
1213   cf->history_limit = 0;
1214   cf->has_history = 0;
1215   cf->line_mode = 1;
1216 }
1217
1218 /** @brief Emit initial welcome banner and prompt on a connection. */
1219 static void
1220 unix_cli_file_welcome (unix_cli_main_t * cm, unix_cli_file_t * cf)
1221 {
1222   unix_main_t *um = &unix_main;
1223   clib_file_main_t *fm = &file_main;
1224   clib_file_t *uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
1225   unix_cli_banner_t *banner;
1226   int i, len;
1227
1228   /* Mark the session as started if we get here */
1229   cf->started = 1;
1230
1231   if (!(cf->is_interactive))    /* No banner for non-interactive sessions */
1232     return;
1233
1234   /*
1235    * Put the first bytes directly into the buffer so that further output is
1236    * queued until everything is ready. (oterwise initial prompt can appear
1237    * mid way through VPP initialization)
1238    */
1239   unix_cli_add_pending_output (uf, cf, (u8 *) "\r", 1);
1240
1241   if (!um->cli_no_banner)
1242     {
1243       if (cf->ansi_capable)
1244         {
1245           banner = unix_cli_banner_color;
1246           len = ARRAY_LEN (unix_cli_banner_color);
1247         }
1248       else
1249         {
1250           banner = unix_cli_banner;
1251           len = ARRAY_LEN (unix_cli_banner);
1252         }
1253
1254       for (i = 0; i < len; i++)
1255         {
1256           unix_vlib_cli_output_cooked (cf, uf,
1257                                        banner[i].line, banner[i].length);
1258         }
1259     }
1260
1261   /* Prompt. */
1262   unix_cli_cli_prompt (cf, uf);
1263
1264 }
1265
1266 /**
1267  * @brief A failsafe manager that ensures CLI sessions issue an initial
1268  * prompt if TELNET negotiation fails.
1269  */
1270 static uword
1271 unix_cli_new_session_process (vlib_main_t * vm, vlib_node_runtime_t * rt,
1272                               vlib_frame_t * f)
1273 {
1274   unix_cli_main_t *cm = &unix_cli_main;
1275   uword event_type, *event_data = 0;
1276   f64 wait = 10.0;
1277
1278   while (1)
1279     {
1280       if (vec_len (cm->new_sessions) > 0)
1281         wait = vlib_process_wait_for_event_or_clock (vm, wait);
1282       else
1283         vlib_process_wait_for_event (vm);
1284
1285       event_type = vlib_process_get_events (vm, &event_data);
1286
1287       switch (event_type)
1288         {
1289         case ~0:                /* no events => timeout */
1290           break;
1291
1292         case UNIX_CLI_NEW_SESSION_EVENT_ADD:
1293           {
1294             /* Add an identifier to the new session list */
1295             unix_cli_new_session_t ns;
1296
1297             ns.cf_index = event_data[0];
1298             ns.deadline = vlib_time_now (vm) + 1.0;
1299
1300             vec_add1 (cm->new_sessions, ns);
1301
1302             if (wait > 0.1)
1303               wait = 0.1;       /* force a re-evaluation soon, but not too soon */
1304           }
1305           break;
1306
1307         default:
1308           clib_warning ("BUG: unknown event type 0x%wx", event_type);
1309           break;
1310         }
1311
1312       vec_reset_length (event_data);
1313
1314       if (vlib_process_suspend_time_is_zero (wait))
1315         {
1316           /* Scan the list looking for expired deadlines.
1317            * Emit needed prompts and remove from the list.
1318            * While scanning, look for the nearest new deadline
1319            * for the next iteration.
1320            * Since the list is ordered with newest sessions first
1321            * we can make assumptions about expired sessions being
1322            * contiguous at the beginning and the next deadline is the
1323            * next entry on the list, if any.
1324            */
1325           f64 now = vlib_time_now (vm);
1326           unix_cli_new_session_t *nsp;
1327           word index = 0;
1328
1329           wait = INFINITY;
1330
1331           vec_foreach (nsp, cm->new_sessions)
1332           {
1333             if (vlib_process_suspend_time_is_zero (nsp->deadline - now))
1334               {
1335                 /* Deadline reached */
1336                 unix_cli_file_t *cf;
1337
1338                 /* Mark the highwater */
1339                 index++;
1340
1341                 /* Check the connection didn't close already */
1342                 if (pool_is_free_index (cm->cli_file_pool, nsp->cf_index))
1343                   continue;
1344
1345                 cf = pool_elt_at_index (cm->cli_file_pool, nsp->cf_index);
1346
1347                 if (!cf->started)
1348                   unix_cli_file_welcome (cm, cf);
1349               }
1350             else
1351               {
1352                 wait = nsp->deadline - now;
1353                 break;
1354               }
1355           }
1356
1357           if (index)
1358             {
1359               /* We have sessions to remove */
1360               vec_delete (cm->new_sessions, index, 0);
1361             }
1362         }
1363     }
1364
1365   return 0;
1366 }
1367
1368
1369 /** @brief A mostly no-op Telnet state machine.
1370  * Process Telnet command bytes in a way that ensures we're mostly
1371  * transparent to the Telnet protocol. That is, it's mostly a no-op.
1372  *
1373  * @return -1 if we need more bytes, otherwise a positive integer number of
1374  *          bytes to consume from the input_vector, not including the initial
1375  *          IAC byte.
1376  */
1377 static i32
1378 unix_cli_process_telnet (unix_main_t * um,
1379                          unix_cli_file_t * cf,
1380                          clib_file_t * uf, u8 * input_vector, uword len)
1381 {
1382   /* Input_vector starts at IAC byte.
1383    * See if we have a complete message; if not, return -1 so we wait for more.
1384    * if we have a complete message, consume those bytes from the vector.
1385    */
1386   i32 consume = 0;
1387
1388   if (len == 1)
1389     return -1;                  /* want more bytes */
1390
1391   switch (input_vector[1])
1392     {
1393     case IAC:
1394       /* two IAC's in a row means to pass through 0xff.
1395        * since that makes no sense here, just consume it.
1396        */
1397       consume = 1;
1398       break;
1399
1400     case WILL:
1401     case WONT:
1402     case DO:
1403     case DONT:
1404       /* Expect 3 bytes */
1405       if (len < 3)
1406         return -1;              /* want more bytes */
1407
1408       consume = 2;
1409       break;
1410
1411     case SB:
1412       {
1413         /* Sub option - search ahead for IAC SE to end it */
1414         i32 i;
1415         for (i = 3; i < len && i < UNIX_CLI_MAX_DEPTH_TELNET; i++)
1416           {
1417             if (input_vector[i - 1] == IAC && input_vector[i] == SE)
1418               {
1419                 /* We have a complete message; see if we care about it */
1420                 switch (input_vector[2])
1421                   {
1422                   case TELOPT_TTYPE:
1423                     if (input_vector[3] != 0)
1424                       break;
1425                     {
1426                       /* See if the the terminal type is recognized */
1427                       u8 *term = input_vector + 4;
1428                       uword len = i - 5;
1429
1430                       /* See if the terminal type is ANSI capable */
1431                       cf->ansi_capable =
1432                         unix_cli_terminal_type_ansi (term, len);
1433
1434                       /* See if the terminal type indicates non-interactive */
1435                       if (unix_cli_terminal_type_noninteractive (term, len))
1436                         unix_cli_set_session_noninteractive (cf);
1437                     }
1438
1439                     /* If session not started, we can release the pause */
1440                     if (!cf->started)
1441                       /* Send the welcome banner and initial prompt */
1442                       unix_cli_file_welcome (&unix_cli_main, cf);
1443                     break;
1444
1445                   case TELOPT_NAWS:
1446                     /* Window size */
1447                     if (i != 8) /* check message is correct size */
1448                       break;
1449
1450                     cf->width =
1451                       clib_net_to_host_u16 (*((u16 *) (input_vector + 3)));
1452                     if (cf->width > UNIX_CLI_MAX_TERMINAL_WIDTH)
1453                       cf->width = UNIX_CLI_MAX_TERMINAL_WIDTH;
1454                     if (cf->width == 0)
1455                       cf->width = UNIX_CLI_DEFAULT_TERMINAL_WIDTH;
1456
1457                     cf->height =
1458                       clib_net_to_host_u16 (*((u16 *) (input_vector + 5)));
1459                     if (cf->height > UNIX_CLI_MAX_TERMINAL_HEIGHT)
1460                       cf->height = UNIX_CLI_MAX_TERMINAL_HEIGHT;
1461                     if (cf->height == 0)
1462                       cf->height = UNIX_CLI_DEFAULT_TERMINAL_HEIGHT;
1463
1464                     /* reindex pager buffer */
1465                     unix_cli_pager_reindex (cf);
1466                     /* redraw page */
1467                     unix_cli_pager_redraw (cf, uf);
1468                     break;
1469
1470                   default:
1471                     break;
1472                   }
1473                 /* Consume it all */
1474                 consume = i;
1475                 break;
1476               }
1477           }
1478
1479         if (i == UNIX_CLI_MAX_DEPTH_TELNET)
1480           consume = 1;          /* hit max search depth, advance one byte */
1481
1482         if (consume == 0)
1483           return -1;            /* want more bytes */
1484
1485         break;
1486       }
1487
1488     case GA:
1489     case EL:
1490     case EC:
1491     case AO:
1492     case IP:
1493     case BREAK:
1494     case DM:
1495     case NOP:
1496     case SE:
1497     case EOR:
1498     case ABORT:
1499     case SUSP:
1500     case xEOF:
1501       /* Simple one-byte messages */
1502       consume = 1;
1503       break;
1504
1505     case AYT:
1506       /* Are You There - trigger a visible response */
1507       consume = 1;
1508       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "fd.io VPP\n", 10);
1509       break;
1510
1511     default:
1512       /* Unknown command! Eat the IAC byte */
1513       break;
1514     }
1515
1516   return consume;
1517 }
1518
1519 /** @brief Process actionable input.
1520  * Based on the \c action process the input; this typically involves
1521  * searching the command history or editing the current command line.
1522  */
1523 static int
1524 unix_cli_line_process_one (unix_cli_main_t * cm,
1525                            unix_main_t * um,
1526                            unix_cli_file_t * cf,
1527                            clib_file_t * uf,
1528                            u8 input, unix_cli_parse_action_t action)
1529 {
1530   u8 *prev;
1531   u8 *save = 0;
1532   u8 **possible_commands;
1533   int j, delta;
1534
1535   switch (action)
1536     {
1537     case UNIX_CLI_PARSE_ACTION_NOACTION:
1538       break;
1539
1540     case UNIX_CLI_PARSE_ACTION_REVSEARCH:
1541     case UNIX_CLI_PARSE_ACTION_FWDSEARCH:
1542       if (!cf->has_history || !cf->history_limit)
1543         break;
1544       if (cf->search_mode == 0)
1545         {
1546           /* Erase the current command (if any) */
1547           for (; cf->cursor > 0; cf->cursor--)
1548             {
1549               unix_vlib_cli_output_cursor_left (cf, uf);
1550               unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1551               unix_vlib_cli_output_cursor_left (cf, uf);
1552             }
1553
1554           vec_reset_length (cf->search_key);
1555           vec_reset_length (cf->current_command);
1556
1557           if (action == UNIX_CLI_PARSE_ACTION_REVSEARCH)
1558             cf->search_mode = -1;
1559           else
1560             cf->search_mode = 1;
1561         }
1562       else
1563         {
1564           if (action == UNIX_CLI_PARSE_ACTION_REVSEARCH)
1565             cf->search_mode = -1;
1566           else
1567             cf->search_mode = 1;
1568
1569           cf->excursion += cf->search_mode;
1570           goto search_again;
1571         }
1572       break;
1573
1574     case UNIX_CLI_PARSE_ACTION_ERASELINELEFT:
1575       /* Erase the command from the cursor to the start */
1576
1577       j = cf->cursor;
1578       /* Shimmy backwards to the new end of line position */
1579       delta = vec_len (cf->current_command) - cf->cursor;
1580       for (; cf->cursor > delta; cf->cursor--)
1581         unix_vlib_cli_output_cursor_left (cf, uf);
1582       /* Zap from here to the end of what is currently displayed */
1583       for (; cf->cursor < vec_len (cf->current_command); cf->cursor++)
1584         unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1585       /* Get back to the start of the line */
1586       for (; cf->cursor > 0; cf->cursor--)
1587         unix_vlib_cli_output_cursor_left (cf, uf);
1588
1589       /* Delete the desired text from the command */
1590       memmove (cf->current_command, cf->current_command + j, delta);
1591       _vec_len (cf->current_command) = delta;
1592
1593       /* Print the new contents */
1594       unix_vlib_cli_output_cooked (cf, uf, cf->current_command, delta);
1595       cf->cursor = delta;       /* for backspace tracking */
1596
1597       /* Shimmy back to the start */
1598       for (; cf->cursor > 0; cf->cursor--)
1599         unix_vlib_cli_output_cursor_left (cf, uf);
1600
1601       cf->search_mode = 0;
1602       break;
1603
1604     case UNIX_CLI_PARSE_ACTION_ERASELINERIGHT:
1605       /* Erase the command from the cursor to the end */
1606
1607       j = cf->cursor;
1608       /* Zap from cursor to end of what is currently displayed */
1609       for (; cf->cursor < (vec_len (cf->current_command)); cf->cursor++)
1610         unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1611       /* Get back to where we were */
1612       for (; cf->cursor > j; cf->cursor--)
1613         unix_vlib_cli_output_cursor_left (cf, uf);
1614
1615       /* Truncate the line at the cursor */
1616       _vec_len (cf->current_command) = cf->cursor;
1617
1618       cf->search_mode = 0;
1619       break;
1620
1621     case UNIX_CLI_PARSE_ACTION_ERASEWORDLEFT:
1622       /* calculate num of caracter to be erased */
1623       delta = 0;
1624       while (cf->cursor > delta
1625              && cf->current_command[cf->cursor - delta - 1] == ' ')
1626         delta++;
1627       while (cf->cursor > delta
1628              && cf->current_command[cf->cursor - delta - 1] != ' ')
1629         delta++;
1630
1631       if (vec_len (cf->current_command))
1632         {
1633           if (cf->cursor > 0)
1634             {
1635               /* move cursor left delta times */
1636               for (j = delta; j > 0; j--, cf->cursor--)
1637                 unix_vlib_cli_output_cursor_left (cf, uf);
1638               save = cf->current_command + cf->cursor;
1639
1640               /* redraw remainder of line */
1641               memmove (cf->current_command + cf->cursor,
1642                        cf->current_command + cf->cursor + delta,
1643                        _vec_len (cf->current_command) - cf->cursor - delta);
1644               unix_vlib_cli_output_cooked (cf, uf,
1645                                            cf->current_command + cf->cursor,
1646                                            _vec_len (cf->current_command) -
1647                                            cf->cursor);
1648               cf->cursor += _vec_len (cf->current_command) - cf->cursor;
1649
1650               /* print delta amount of blank spaces,
1651                * then finally fix the cursor position */
1652               for (j = delta; j > 0; j--, cf->cursor--)
1653                 unix_vlib_cli_output_cursor_left (cf, uf);
1654               for (j = delta; j > 0; j--, cf->cursor++)
1655                 unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1656               for (; (cf->current_command + cf->cursor) > save; cf->cursor--)
1657                 unix_vlib_cli_output_cursor_left (cf, uf);
1658               _vec_len (cf->current_command) -= delta;
1659             }
1660         }
1661       cf->search_mode = 0;
1662       cf->excursion = 0;
1663       vec_reset_length (cf->search_key);
1664       break;
1665
1666     case UNIX_CLI_PARSE_ACTION_LEFT:
1667       if (cf->cursor > 0)
1668         {
1669           unix_vlib_cli_output_cursor_left (cf, uf);
1670           cf->cursor--;
1671         }
1672
1673       cf->search_mode = 0;
1674       break;
1675
1676     case UNIX_CLI_PARSE_ACTION_RIGHT:
1677       if (cf->cursor < vec_len (cf->current_command))
1678         {
1679           /* have to emit the character under the cursor */
1680           unix_vlib_cli_output_cooked (cf, uf,
1681                                        cf->current_command + cf->cursor, 1);
1682           cf->cursor++;
1683         }
1684
1685       cf->search_mode = 0;
1686       break;
1687
1688     case UNIX_CLI_PARSE_ACTION_UP:
1689     case UNIX_CLI_PARSE_ACTION_DOWN:
1690       if (!cf->has_history || !cf->history_limit)
1691         break;
1692       cf->search_mode = 0;
1693       /* Erase the command */
1694       for (; cf->cursor < vec_len (cf->current_command); cf->cursor++)
1695         unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1696       for (; cf->cursor > 0; cf->cursor--)
1697         {
1698           unix_vlib_cli_output_cursor_left (cf, uf);
1699           unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1700           unix_vlib_cli_output_cursor_left (cf, uf);
1701         }
1702       vec_reset_length (cf->current_command);
1703       if (vec_len (cf->command_history))
1704         {
1705           if (action == UNIX_CLI_PARSE_ACTION_UP)
1706             delta = -1;
1707           else
1708             delta = 1;
1709
1710           cf->excursion += delta;
1711
1712           if (cf->excursion == vec_len (cf->command_history))
1713             {
1714               /* down-arrowed to last entry - want a blank line */
1715               _vec_len (cf->current_command) = 0;
1716             }
1717           else if (cf->excursion < 0)
1718             {
1719               /* up-arrowed over the start to the end, want a blank line */
1720               cf->excursion = vec_len (cf->command_history);
1721               _vec_len (cf->current_command) = 0;
1722             }
1723           else
1724             {
1725               if (cf->excursion > (i32) vec_len (cf->command_history) - 1)
1726                 /* down-arrowed past end - wrap to start */
1727                 cf->excursion = 0;
1728
1729               /* Print the command at the current position */
1730               prev = cf->command_history[cf->excursion];
1731               vec_validate (cf->current_command, vec_len (prev) - 1);
1732
1733               clib_memcpy (cf->current_command, prev, vec_len (prev));
1734               _vec_len (cf->current_command) = vec_len (prev);
1735               unix_vlib_cli_output_cooked (cf, uf, cf->current_command,
1736                                            vec_len (cf->current_command));
1737             }
1738         }
1739       cf->cursor = vec_len (cf->current_command);
1740       break;
1741
1742     case UNIX_CLI_PARSE_ACTION_HOME:
1743       if (vec_len (cf->current_command) && cf->cursor > 0)
1744         {
1745           for (; cf->cursor > 0; cf->cursor--)
1746             unix_vlib_cli_output_cursor_left (cf, uf);
1747         }
1748
1749       cf->search_mode = 0;
1750       break;
1751
1752     case UNIX_CLI_PARSE_ACTION_END:
1753       if (vec_len (cf->current_command) &&
1754           cf->cursor < vec_len (cf->current_command))
1755         {
1756           unix_vlib_cli_output_cooked (cf, uf,
1757                                        cf->current_command + cf->cursor,
1758                                        vec_len (cf->current_command) -
1759                                        cf->cursor);
1760           cf->cursor = vec_len (cf->current_command);
1761         }
1762
1763       cf->search_mode = 0;
1764       break;
1765
1766     case UNIX_CLI_PARSE_ACTION_WORDLEFT:
1767       if (vec_len (cf->current_command) && cf->cursor > 0)
1768         {
1769           unix_vlib_cli_output_cursor_left (cf, uf);
1770           cf->cursor--;
1771
1772           while (cf->cursor && isspace (cf->current_command[cf->cursor]))
1773             {
1774               unix_vlib_cli_output_cursor_left (cf, uf);
1775               cf->cursor--;
1776             }
1777           while (cf->cursor && !isspace (cf->current_command[cf->cursor]))
1778             {
1779               if (isspace (cf->current_command[cf->cursor - 1]))
1780                 break;
1781               unix_vlib_cli_output_cursor_left (cf, uf);
1782               cf->cursor--;
1783             }
1784
1785         }
1786
1787       cf->search_mode = 0;
1788       break;
1789
1790     case UNIX_CLI_PARSE_ACTION_WORDRIGHT:
1791       if (vec_len (cf->current_command) &&
1792           cf->cursor < vec_len (cf->current_command))
1793         {
1794           int e = vec_len (cf->current_command);
1795           j = cf->cursor;
1796           while (j < e && !isspace (cf->current_command[j]))
1797             j++;
1798           while (j < e && isspace (cf->current_command[j]))
1799             j++;
1800           unix_vlib_cli_output_cooked (cf, uf,
1801                                        cf->current_command + cf->cursor,
1802                                        j - cf->cursor);
1803           cf->cursor = j;
1804         }
1805
1806       cf->search_mode = 0;
1807       break;
1808
1809
1810     case UNIX_CLI_PARSE_ACTION_ERASE:
1811       if (vec_len (cf->current_command))
1812         {
1813           if (cf->cursor == vec_len (cf->current_command))
1814             {
1815               unix_vlib_cli_output_cursor_left (cf, uf);
1816               cf->cursor--;
1817               unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1818               cf->cursor++;
1819               unix_vlib_cli_output_cursor_left (cf, uf);
1820               cf->cursor--;
1821               _vec_len (cf->current_command)--;
1822             }
1823           else if (cf->cursor > 0)
1824             {
1825               /* shift everything at & to the right of the cursor left by 1 */
1826               j = vec_len (cf->current_command) - cf->cursor;
1827               memmove (cf->current_command + cf->cursor - 1,
1828                        cf->current_command + cf->cursor, j);
1829               _vec_len (cf->current_command)--;
1830
1831               /* redraw the rest of the line */
1832               unix_vlib_cli_output_cursor_left (cf, uf);
1833               cf->cursor--;
1834               unix_vlib_cli_output_cooked (cf, uf,
1835                                            cf->current_command + cf->cursor,
1836                                            j);
1837               cf->cursor += j;
1838               /* erase last char */
1839               unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1840               cf->cursor++;
1841
1842               /* and shift the terminal cursor back where it should be */
1843               j += 2;           /* account for old string length and offset position */
1844               while (--j)
1845                 {
1846                   unix_vlib_cli_output_cursor_left (cf, uf);
1847                   cf->cursor--;
1848                 }
1849             }
1850         }
1851       cf->search_mode = 0;
1852       cf->excursion = 0;
1853       vec_reset_length (cf->search_key);
1854       break;
1855
1856     case UNIX_CLI_PARSE_ACTION_ERASERIGHT:
1857       if (vec_len (cf->current_command))
1858         {
1859           if (cf->cursor < vec_len (cf->current_command))
1860             {
1861               /* shift everything to the right of the cursor left by 1 */
1862               j = vec_len (cf->current_command) - cf->cursor - 1;
1863               memmove (cf->current_command + cf->cursor,
1864                        cf->current_command + cf->cursor + 1, j);
1865               _vec_len (cf->current_command)--;
1866               /* redraw the rest of the line */
1867               unix_vlib_cli_output_cooked (cf, uf,
1868                                            cf->current_command + cf->cursor,
1869                                            j);
1870               cf->cursor += j;
1871               unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1872               cf->cursor++;
1873               unix_vlib_cli_output_cursor_left (cf, uf);
1874               cf->cursor--;
1875               /* and shift the terminal cursor back where it should be */
1876               if (j)
1877                 {
1878                   unix_vlib_cli_output_cursor_left (cf, uf);
1879                   cf->cursor--;
1880                   while (--j)
1881                     {
1882                       unix_vlib_cli_output_cursor_left (cf, uf);
1883                       cf->cursor--;
1884                     }
1885                 }
1886             }
1887         }
1888       else if (input == 'D' - '@')
1889         {
1890           /* ^D with no command entered = quit */
1891           unix_vlib_cli_output_cooked (cf, uf, (u8 *) "quit\n", 5);
1892           vlib_process_signal_event (um->vlib_main,
1893                                      vlib_current_process (um->vlib_main),
1894                                      UNIX_CLI_PROCESS_EVENT_QUIT,
1895                                      cf - cm->cli_file_pool);
1896         }
1897       cf->search_mode = 0;
1898       cf->excursion = 0;
1899       vec_reset_length (cf->search_key);
1900       break;
1901
1902     case UNIX_CLI_PARSE_ACTION_CLEAR:
1903       /* If we're in ANSI mode, clear the screen.
1904        * Then redraw the prompt and any existing command input, then put
1905        * the cursor back where it was in that line.
1906        */
1907       if (cf->ansi_capable)
1908         unix_vlib_cli_output_cooked (cf, uf,
1909                                      (u8 *) ANSI_CLEAR,
1910                                      sizeof (ANSI_CLEAR) - 1);
1911       else
1912         unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
1913
1914       unix_vlib_cli_output_raw (cf, uf,
1915                                 cm->cli_prompt, vec_len (cm->cli_prompt));
1916       unix_vlib_cli_output_cooked (cf, uf,
1917                                    cf->current_command,
1918                                    vec_len (cf->current_command));
1919       j = cf->cursor;
1920       cf->cursor = vec_len (cf->current_command);
1921       for (; cf->cursor > j; cf->cursor--)
1922         unix_vlib_cli_output_cursor_left (cf, uf);
1923
1924       break;
1925
1926     case UNIX_CLI_PARSE_ACTION_TAB:
1927       if (cf->cursor < vec_len (cf->current_command))
1928         {
1929           /* if we are in the middle of a line, complete only if
1930            * the cursor points to whitespace */
1931           if (isspace (cf->current_command[cf->cursor]))
1932             {
1933               /* save and clear any input that is after the cursor */
1934               vec_resize (save, vec_len (cf->current_command) - cf->cursor);
1935               clib_memcpy (save, cf->current_command + cf->cursor,
1936                            vec_len (cf->current_command) - cf->cursor);
1937               _vec_len (cf->current_command) = cf->cursor;
1938             }
1939           else
1940             {
1941               unix_vlib_cli_output_raw (cf, uf, (u8 *) "\a", 1);
1942               break;
1943             }
1944         }
1945       possible_commands =
1946         vlib_cli_get_possible_completions (cf->current_command);
1947       if (vec_len (possible_commands) == 1)
1948         {
1949           u8 *completed = possible_commands[0];
1950           j = cf->cursor;
1951
1952           /* find the last word of current_command */
1953           while (j >= 1 && !isspace (cf->current_command[j - 1]))
1954             {
1955               unix_vlib_cli_output_cursor_left (cf, uf);
1956               cf->cursor--;
1957               j--;
1958             }
1959           _vec_len (cf->current_command) = j;
1960
1961           /* replace it with the newly expanded command */
1962           vec_append (cf->current_command, completed);
1963
1964           /* echo to the terminal */
1965           unix_vlib_cli_output_cooked (cf, uf, completed,
1966                                        vec_len (completed));
1967
1968           /* add one trailing space if needed */
1969           if (vec_len (save) == 0)
1970             {
1971               vec_add1 (cf->current_command, ' ');
1972               unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
1973             }
1974
1975           cf->cursor = vec_len (cf->current_command);
1976
1977         }
1978       else if (vec_len (possible_commands) >= 2)
1979         {
1980           u8 **possible_command;
1981           uword max_command_len = 0, min_command_len = ~0;
1982           u32 i;
1983
1984           vec_foreach (possible_command, possible_commands)
1985           {
1986             if (vec_len (*possible_command) > max_command_len)
1987               max_command_len = vec_len (*possible_command);
1988             if (vec_len (*possible_command) < min_command_len)
1989               min_command_len = vec_len (*possible_command);
1990           }
1991
1992           unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
1993
1994           i = 0;
1995           vec_foreach (possible_command, possible_commands)
1996           {
1997             if (i + max_command_len >= cf->width)
1998               {
1999                 unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2000                 i = 0;
2001               }
2002             unix_vlib_cli_output_cooked (cf, uf, *possible_command,
2003                                          vec_len (*possible_command));
2004             for (j = vec_len (*possible_command); j < max_command_len + 2;
2005                  j++)
2006               {
2007                 unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
2008               }
2009             i += max_command_len + 2;
2010           }
2011
2012           unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2013
2014           /* rewrite prompt */
2015           unix_cli_cli_prompt (cf, uf);
2016           unix_vlib_cli_output_cooked (cf, uf, cf->current_command,
2017                                        vec_len (cf->current_command));
2018
2019           /* count length of last word */
2020           j = cf->cursor;
2021           i = 0;
2022           while (j >= 1 && !isspace (cf->current_command[j - 1]))
2023             {
2024               j--;
2025               i++;
2026             }
2027
2028           /* determine smallest common command */
2029           for (; i < min_command_len; i++)
2030             {
2031               u8 common = '\0';
2032               int stop = 0;
2033
2034               vec_foreach (possible_command, possible_commands)
2035               {
2036                 if (common == '\0')
2037                   {
2038                     common = (*possible_command)[i];
2039                   }
2040                 else if (common != (*possible_command)[i])
2041                   {
2042                     stop = 1;
2043                     break;
2044                   }
2045               }
2046
2047               if (!stop)
2048                 {
2049                   vec_add1 (cf->current_command, common);
2050                   cf->cursor++;
2051                   unix_vlib_cli_output_cooked (cf, uf, (u8 *) & common, 1);
2052                 }
2053               else
2054                 {
2055                   break;
2056                 }
2057             }
2058         }
2059       else
2060         {
2061           unix_vlib_cli_output_raw (cf, uf, (u8 *) "\a", 1);
2062         }
2063
2064       if (vec_len (save) > 0)
2065         {
2066           /* restore remaining input if tab was hit in the middle of a line */
2067           unix_vlib_cli_output_cooked (cf, uf, save, vec_len (save));
2068           cf->cursor += vec_len (save);
2069           for (j = 0; j < vec_len (save); j++, cf->cursor--)
2070             unix_vlib_cli_output_cursor_left (cf, uf);
2071           vec_append (cf->current_command, save);
2072           vec_free (save);
2073         }
2074       vec_free (possible_commands);
2075
2076       break;
2077     case UNIX_CLI_PARSE_ACTION_YANK:
2078       /* TODO */
2079       break;
2080
2081
2082     case UNIX_CLI_PARSE_ACTION_PAGER_QUIT:
2083     pager_quit:
2084       unix_cli_pager_prompt_erase (cf, uf);
2085       unix_cli_pager_reset (cf);
2086       unix_cli_cli_prompt (cf, uf);
2087       break;
2088
2089     case UNIX_CLI_PARSE_ACTION_PAGER_NEXT:
2090     case UNIX_CLI_PARSE_ACTION_PAGER_PGDN:
2091       /* show next page of the buffer */
2092       if (cf->height + cf->pager_start <= vec_len (cf->pager_index))
2093         {
2094           u8 *line = NULL;
2095           unix_cli_pager_index_t *pi = NULL;
2096
2097           int m = cf->pager_start + (cf->height - 1);
2098           unix_cli_pager_prompt_erase (cf, uf);
2099           for (j = m;
2100                j < vec_len (cf->pager_index) && cf->pager_start < m;
2101                j++, cf->pager_start++)
2102             {
2103               pi = &cf->pager_index[j];
2104               line = cf->pager_vector[pi->line] + pi->offset;
2105               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2106             }
2107           /* if the last line didn't end in newline, add a newline */
2108           if (pi && line[pi->length - 1] != '\n')
2109             unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2110           unix_cli_pager_prompt (cf, uf);
2111         }
2112       else
2113         {
2114           if (action == UNIX_CLI_PARSE_ACTION_PAGER_NEXT)
2115             /* no more in buffer, exit, but only if it was <space> */
2116             goto pager_quit;
2117         }
2118       break;
2119
2120     case UNIX_CLI_PARSE_ACTION_PAGER_DN:
2121     case UNIX_CLI_PARSE_ACTION_PAGER_CRLF:
2122       /* display the next line of the buffer */
2123       if (cf->height + cf->pager_start <= vec_len (cf->pager_index))
2124         {
2125           u8 *line;
2126           unix_cli_pager_index_t *pi;
2127
2128           unix_cli_pager_prompt_erase (cf, uf);
2129           pi = &cf->pager_index[cf->pager_start + (cf->height - 1)];
2130           line = cf->pager_vector[pi->line] + pi->offset;
2131           unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2132           cf->pager_start++;
2133           /* if the last line didn't end in newline, add a newline */
2134           if (line[pi->length - 1] != '\n')
2135             unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2136           unix_cli_pager_prompt (cf, uf);
2137         }
2138       else
2139         {
2140           if (action == UNIX_CLI_PARSE_ACTION_PAGER_CRLF)
2141             /* no more in buffer, exit, but only if it was <enter> */
2142             goto pager_quit;
2143         }
2144
2145       break;
2146
2147     case UNIX_CLI_PARSE_ACTION_PAGER_UP:
2148       /* scroll the page back one line */
2149       if (cf->pager_start > 0)
2150         {
2151           u8 *line = NULL;
2152           unix_cli_pager_index_t *pi = NULL;
2153
2154           cf->pager_start--;
2155           if (cf->ansi_capable)
2156             {
2157               pi = &cf->pager_index[cf->pager_start];
2158               line = cf->pager_vector[pi->line] + pi->offset;
2159               unix_cli_pager_prompt_erase (cf, uf);
2160               unix_vlib_cli_output_cooked (cf, uf, (u8 *) ANSI_SCROLLDN,
2161                                            sizeof (ANSI_SCROLLDN) - 1);
2162               unix_vlib_cli_output_cooked (cf, uf, (u8 *) ANSI_SAVECURSOR,
2163                                            sizeof (ANSI_SAVECURSOR) - 1);
2164               unix_cli_ansi_cursor (cf, uf, 1, 1);
2165               unix_vlib_cli_output_cooked (cf, uf, (u8 *) ANSI_CLEARLINE,
2166                                            sizeof (ANSI_CLEARLINE) - 1);
2167               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2168               unix_vlib_cli_output_cooked (cf, uf, (u8 *) ANSI_RESTCURSOR,
2169                                            sizeof (ANSI_RESTCURSOR) - 1);
2170               unix_cli_pager_prompt_erase (cf, uf);
2171               unix_cli_pager_prompt (cf, uf);
2172             }
2173           else
2174             {
2175               int m = cf->pager_start + (cf->height - 1);
2176               unix_cli_pager_prompt_erase (cf, uf);
2177               for (j = cf->pager_start;
2178                    j < vec_len (cf->pager_index) && j < m; j++)
2179                 {
2180                   pi = &cf->pager_index[j];
2181                   line = cf->pager_vector[pi->line] + pi->offset;
2182                   unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2183                 }
2184               /* if the last line didn't end in newline, add a newline */
2185               if (pi && line[pi->length - 1] != '\n')
2186                 unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2187               unix_cli_pager_prompt (cf, uf);
2188             }
2189         }
2190       break;
2191
2192     case UNIX_CLI_PARSE_ACTION_PAGER_TOP:
2193       /* back to the first page of the buffer */
2194       if (cf->pager_start > 0)
2195         {
2196           u8 *line = NULL;
2197           unix_cli_pager_index_t *pi = NULL;
2198
2199           cf->pager_start = 0;
2200           int m = cf->pager_start + (cf->height - 1);
2201           unix_cli_pager_prompt_erase (cf, uf);
2202           for (j = cf->pager_start; j < vec_len (cf->pager_index) && j < m;
2203                j++)
2204             {
2205               pi = &cf->pager_index[j];
2206               line = cf->pager_vector[pi->line] + pi->offset;
2207               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2208             }
2209           /* if the last line didn't end in newline, add a newline */
2210           if (pi && line[pi->length - 1] != '\n')
2211             unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2212           unix_cli_pager_prompt (cf, uf);
2213         }
2214       break;
2215
2216     case UNIX_CLI_PARSE_ACTION_PAGER_BOTTOM:
2217       /* skip to the last page of the buffer */
2218       if (cf->pager_start < vec_len (cf->pager_index) - (cf->height - 1))
2219         {
2220           u8 *line = NULL;
2221           unix_cli_pager_index_t *pi = NULL;
2222
2223           cf->pager_start = vec_len (cf->pager_index) - (cf->height - 1);
2224           unix_cli_pager_prompt_erase (cf, uf);
2225           unix_cli_pager_message (cf, uf, "skipping", "\n");
2226           for (j = cf->pager_start; j < vec_len (cf->pager_index); j++)
2227             {
2228               pi = &cf->pager_index[j];
2229               line = cf->pager_vector[pi->line] + pi->offset;
2230               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2231             }
2232           /* if the last line didn't end in newline, add a newline */
2233           if (pi && line[pi->length - 1] != '\n')
2234             unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2235           unix_cli_pager_prompt (cf, uf);
2236         }
2237       break;
2238
2239     case UNIX_CLI_PARSE_ACTION_PAGER_PGUP:
2240       /* wander back one page in the buffer */
2241       if (cf->pager_start > 0)
2242         {
2243           u8 *line = NULL;
2244           unix_cli_pager_index_t *pi = NULL;
2245           int m;
2246
2247           if (cf->pager_start >= cf->height)
2248             cf->pager_start -= cf->height - 1;
2249           else
2250             cf->pager_start = 0;
2251           m = cf->pager_start + cf->height - 1;
2252           unix_cli_pager_prompt_erase (cf, uf);
2253           for (j = cf->pager_start; j < vec_len (cf->pager_index) && j < m;
2254                j++)
2255             {
2256               pi = &cf->pager_index[j];
2257               line = cf->pager_vector[pi->line] + pi->offset;
2258               unix_vlib_cli_output_cooked (cf, uf, line, pi->length);
2259             }
2260           /* if the last line didn't end in newline, add a newline */
2261           if (pi && line[pi->length - 1] != '\n')
2262             unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2263           unix_cli_pager_prompt (cf, uf);
2264         }
2265       break;
2266
2267     case UNIX_CLI_PARSE_ACTION_PAGER_REDRAW:
2268       /* Redraw the current pager screen */
2269       unix_cli_pager_redraw (cf, uf);
2270       break;
2271
2272     case UNIX_CLI_PARSE_ACTION_PAGER_SEARCH:
2273       /* search forwards in the buffer */
2274       break;
2275
2276
2277     case UNIX_CLI_PARSE_ACTION_CRLF:
2278     crlf:
2279       unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\n", 1);
2280
2281       if (cf->has_history && cf->history_limit)
2282         {
2283           if (cf->command_history
2284               && vec_len (cf->command_history) >= cf->history_limit)
2285             {
2286               vec_free (cf->command_history[0]);
2287               vec_delete (cf->command_history, 1, 0);
2288             }
2289           /* Don't add blank lines to the cmd history */
2290           if (vec_len (cf->current_command))
2291             {
2292               /* Don't duplicate the previous command */
2293               j = vec_len (cf->command_history);
2294               if (j == 0 ||
2295                   (vec_len (cf->current_command) !=
2296                    vec_len (cf->command_history[j - 1])
2297                    || memcmp (cf->current_command, cf->command_history[j - 1],
2298                               vec_len (cf->current_command)) != 0))
2299                 {
2300                   /* copy the command to the history */
2301                   u8 *c = 0;
2302                   vec_append (c, cf->current_command);
2303                   vec_add1 (cf->command_history, c);
2304                   cf->command_number++;
2305                 }
2306             }
2307           cf->excursion = vec_len (cf->command_history);
2308         }
2309
2310       cf->search_mode = 0;
2311       vec_reset_length (cf->search_key);
2312       cf->cursor = 0;
2313
2314       return 0;
2315
2316     case UNIX_CLI_PARSE_ACTION_PARTIALMATCH:
2317     case UNIX_CLI_PARSE_ACTION_NOMATCH:
2318       if (vec_len (cf->pager_index))
2319         {
2320           /* no-op for now */
2321         }
2322       else if (cf->has_history && cf->search_mode != 0 && isprint (input))
2323         {
2324           int k, limit, offset;
2325           u8 *item;
2326
2327           vec_add1 (cf->search_key, input);
2328
2329         search_again:
2330           for (j = 0; j < vec_len (cf->command_history); j++)
2331             {
2332               if (cf->excursion > (i32) vec_len (cf->command_history) - 1)
2333                 cf->excursion = 0;
2334               else if (cf->excursion < 0)
2335                 cf->excursion = vec_len (cf->command_history) - 1;
2336
2337               item = cf->command_history[cf->excursion];
2338
2339               limit = (vec_len (cf->search_key) > vec_len (item)) ?
2340                 vec_len (item) : vec_len (cf->search_key);
2341
2342               for (offset = 0; offset <= vec_len (item) - limit; offset++)
2343                 {
2344                   for (k = 0; k < limit; k++)
2345                     {
2346                       if (item[k + offset] != cf->search_key[k])
2347                         goto next_offset;
2348                     }
2349                   goto found_at_offset;
2350
2351                 next_offset:
2352                   ;
2353                 }
2354               goto next;
2355
2356             found_at_offset:
2357               for (; cf->cursor > 0; cf->cursor--)
2358                 {
2359                   unix_vlib_cli_output_cursor_left (cf, uf);
2360                   unix_vlib_cli_output_cooked (cf, uf, (u8 *) " ", 1);
2361                   unix_vlib_cli_output_cursor_left (cf, uf);
2362                 }
2363
2364               vec_validate (cf->current_command, vec_len (item) - 1);
2365               clib_memcpy (cf->current_command, item, vec_len (item));
2366               _vec_len (cf->current_command) = vec_len (item);
2367
2368               unix_vlib_cli_output_cooked (cf, uf, cf->current_command,
2369                                            vec_len (cf->current_command));
2370               cf->cursor = vec_len (cf->current_command);
2371               goto found;
2372
2373             next:
2374               cf->excursion += cf->search_mode;
2375             }
2376
2377           unix_vlib_cli_output_cooked (cf, uf, (u8 *) "\nNo match...", 12);
2378           vec_reset_length (cf->search_key);
2379           vec_reset_length (cf->current_command);
2380           cf->search_mode = 0;
2381           cf->cursor = 0;
2382           goto crlf;
2383         }
2384       else if (isprint (input)) /* skip any errant control codes */
2385         {
2386           if (cf->cursor == vec_len (cf->current_command))
2387             {
2388               /* Append to end */
2389               vec_add1 (cf->current_command, input);
2390               cf->cursor++;
2391
2392               /* Echo the character back to the client */
2393               unix_vlib_cli_output_cooked (cf, uf, &input, 1);
2394             }
2395           else
2396             {
2397               /* Insert at cursor: resize +1 byte, move everything over */
2398               j = vec_len (cf->current_command) - cf->cursor;
2399               vec_add1 (cf->current_command, (u8) 'A');
2400               memmove (cf->current_command + cf->cursor + 1,
2401                        cf->current_command + cf->cursor, j);
2402               cf->current_command[cf->cursor] = input;
2403               /* Redraw the line */
2404               j++;
2405               unix_vlib_cli_output_cooked (cf, uf,
2406                                            cf->current_command + cf->cursor,
2407                                            j);
2408               cf->cursor += j;
2409               j--;
2410               /* Put terminal cursor back */
2411               for (; j > 0; j--, cf->cursor--)
2412                 unix_vlib_cli_output_cursor_left (cf, uf);
2413             }
2414         }
2415       else
2416         {
2417           /* no-op - not printable or otherwise not actionable */
2418         }
2419
2420     found:
2421
2422       break;
2423
2424     case UNIX_CLI_PARSE_ACTION_TELNETIAC:
2425       break;
2426     }
2427   return 1;
2428 }
2429
2430 /** @brief Process input bytes on a stream to provide line editing and
2431  * command history in the CLI. */
2432 static int
2433 unix_cli_line_edit (unix_cli_main_t * cm, unix_main_t * um,
2434                     clib_file_main_t * fm, unix_cli_file_t * cf)
2435 {
2436   clib_file_t *uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
2437   int i;
2438
2439   for (i = 0; i < vec_len (cf->input_vector); i++)
2440     {
2441       unix_cli_parse_action_t action;
2442       i32 matched = 0;
2443       unix_cli_parse_actions_t *a;
2444
2445       /* If we're in the pager mode, search the pager actions */
2446       a =
2447         vec_len (cf->pager_index) ? unix_cli_parse_pager :
2448         unix_cli_parse_strings;
2449
2450       /* See if the input buffer is some sort of control code */
2451       action = unix_cli_match_action (a, &cf->input_vector[i],
2452                                       vec_len (cf->input_vector) - i,
2453                                       &matched);
2454
2455       switch (action)
2456         {
2457         case UNIX_CLI_PARSE_ACTION_PARTIALMATCH:
2458           if (i)
2459             {
2460               /* There was a partial match which means we need more bytes
2461                * than the input buffer currently has.
2462                * Since the bytes before here have been processed, shift
2463                * the remaining contents to the start of the input buffer.
2464                */
2465               vec_delete (cf->input_vector, i, 0);
2466             }
2467           return 1;             /* wait for more */
2468
2469         case UNIX_CLI_PARSE_ACTION_TELNETIAC:
2470           /* process telnet options */
2471           matched = unix_cli_process_telnet (um, cf, uf,
2472                                              cf->input_vector + i,
2473                                              vec_len (cf->input_vector) - i);
2474           if (matched < 0)
2475             {
2476               /* There was a partial match which means we need more bytes
2477                * than the input buffer currently has.
2478                */
2479               if (i)
2480                 {
2481                   /*
2482                    * Since the bytes before here have been processed, shift
2483                    * the remaining contents to the start of the input buffer.
2484                    */
2485                   vec_delete (cf->input_vector, i, 0);
2486                 }
2487               return 1;         /* wait for more */
2488             }
2489           break;
2490
2491         default:
2492           /* If telnet option processing switched us to line mode, get us
2493            * out of here!
2494            */
2495           if (cf->line_mode)
2496             {
2497               vec_delete (cf->input_vector, i, 0);
2498               cf->current_command = cf->input_vector;
2499               return 0;
2500             }
2501
2502           /* process the action */
2503           if (!unix_cli_line_process_one (cm, um, cf, uf,
2504                                           cf->input_vector[i], action))
2505             {
2506               /* CRLF found. Consume the bytes from the input_vector */
2507               vec_delete (cf->input_vector, i + matched, 0);
2508               /* And tell our caller to execute cf->input_command */
2509               return 0;
2510             }
2511         }
2512
2513       i += matched;
2514     }
2515
2516   vec_reset_length (cf->input_vector);
2517   return 1;
2518 }
2519
2520 /** @brief Process input to a CLI session. */
2521 static void
2522 unix_cli_process_input (unix_cli_main_t * cm, uword cli_file_index)
2523 {
2524   unix_main_t *um = &unix_main;
2525   clib_file_main_t *fm = &file_main;
2526   clib_file_t *uf;
2527   unix_cli_file_t *cf = pool_elt_at_index (cm->cli_file_pool, cli_file_index);
2528   unformat_input_t input;
2529   int vlib_parse_eval (u8 *);
2530
2531   cm->current_input_file_index = cli_file_index;
2532
2533 more:
2534   /* Try vlibplex first.  Someday... */
2535   if (0 && vlib_parse_eval (cf->input_vector) == 0)
2536     goto done;
2537
2538
2539   if (cf->line_mode)
2540     {
2541       /* just treat whatever we got as a complete line of input */
2542       cf->current_command = cf->input_vector;
2543     }
2544   else
2545     {
2546       /* Line edit, echo, etc. */
2547       if (unix_cli_line_edit (cm, um, fm, cf))
2548         /* want more input */
2549         return;
2550     }
2551
2552   if (um->log_fd)
2553     {
2554       static u8 *lv;
2555       vec_reset_length (lv);
2556       lv = format (lv, "%U[%d]: %v",
2557                    format_timeval, 0 /* current bat-time */ ,
2558                    0 /* current bat-format */ ,
2559                    cli_file_index, cf->current_command);
2560       int rv __attribute__ ((unused)) = write (um->log_fd, lv, vec_len (lv));
2561     }
2562
2563   /* Build an unformat structure around our command */
2564   unformat_init_vector (&input, cf->current_command);
2565
2566   /* Remove leading white space from input. */
2567   (void) unformat (&input, "");
2568
2569   cf->pager_start = 0;          /* start a new pager session */
2570
2571   if (unformat_check_input (&input) != UNFORMAT_END_OF_INPUT)
2572     vlib_cli_input (um->vlib_main, &input, unix_vlib_cli_output,
2573                     cli_file_index);
2574
2575   /* Zero buffer since otherwise unformat_free will call vec_free on it. */
2576   input.buffer = 0;
2577
2578   unformat_free (&input);
2579
2580   /* Re-fetch pointer since pool may have moved. */
2581   cf = pool_elt_at_index (cm->cli_file_pool, cli_file_index);
2582   uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
2583
2584 done:
2585   /* reset vector; we'll re-use it later  */
2586   if (cf->line_mode)
2587     {
2588       vec_reset_length (cf->input_vector);
2589       cf->current_command = 0;
2590     }
2591   else
2592     {
2593       vec_reset_length (cf->current_command);
2594     }
2595
2596   if (cf->no_pager == 2)
2597     {
2598       /* Pager was programmatically disabled */
2599       unix_cli_pager_message (cf, uf, "pager buffer overflowed", "\n");
2600       cf->no_pager = um->cli_no_pager;
2601     }
2602
2603   if (vec_len (cf->pager_index) == 0
2604       || vec_len (cf->pager_index) < cf->height)
2605     {
2606       /* There was no need for the pager */
2607       unix_cli_pager_reset (cf);
2608
2609       /* Prompt. */
2610       unix_cli_cli_prompt (cf, uf);
2611     }
2612   else
2613     {
2614       /* Display the pager prompt */
2615       unix_cli_pager_prompt (cf, uf);
2616     }
2617
2618   /* Any residual data in the input vector? */
2619   if (vec_len (cf->input_vector))
2620     goto more;
2621
2622   /* For non-interactive sessions send a NUL byte.
2623    * Specifically this is because vppctl needs to see some traffic in
2624    * order to move on to closing the session. Commands with no output
2625    * would thus cause vppctl to hang indefinitely in non-interactive mode
2626    * since there is also no prompt sent after the command completes.
2627    */
2628   if (!cf->is_interactive)
2629     unix_vlib_cli_output_raw (cf, uf, (u8 *) "\0", 1);
2630 }
2631
2632 /** Destroy a CLI session.
2633  * @note If we destroy the @c stdin session this additionally signals
2634  *       the shutdown of VPP.
2635  */
2636 static void
2637 unix_cli_kill (unix_cli_main_t * cm, uword cli_file_index)
2638 {
2639   unix_main_t *um = &unix_main;
2640   clib_file_main_t *fm = &file_main;
2641   unix_cli_file_t *cf;
2642   clib_file_t *uf;
2643   int i;
2644
2645   /* Validate cli_file_index */
2646   if (pool_is_free_index (cm->cli_file_pool, cli_file_index))
2647     return;
2648
2649   cf = pool_elt_at_index (cm->cli_file_pool, cli_file_index);
2650   uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
2651
2652   /* Quit/EOF on stdin means quit program. */
2653   if (uf->file_descriptor == STDIN_FILENO)
2654     clib_longjmp (&um->vlib_main->main_loop_exit, VLIB_MAIN_LOOP_EXIT_CLI);
2655
2656   vec_free (cf->current_command);
2657   vec_free (cf->search_key);
2658
2659   for (i = 0; i < vec_len (cf->command_history); i++)
2660     vec_free (cf->command_history[i]);
2661
2662   vec_free (cf->command_history);
2663
2664   clib_file_del (fm, uf);
2665
2666   unix_cli_file_free (cf);
2667   pool_put (cm->cli_file_pool, cf);
2668 }
2669
2670 /** Handle system events. */
2671 static uword
2672 unix_cli_process (vlib_main_t * vm,
2673                   vlib_node_runtime_t * rt, vlib_frame_t * f)
2674 {
2675   unix_cli_main_t *cm = &unix_cli_main;
2676   uword i, *data = 0;
2677
2678   while (1)
2679     {
2680       unix_cli_process_event_type_t event_type;
2681       vlib_process_wait_for_event (vm);
2682       event_type = vlib_process_get_events (vm, &data);
2683
2684       switch (event_type)
2685         {
2686         case UNIX_CLI_PROCESS_EVENT_READ_READY:
2687           for (i = 0; i < vec_len (data); i++)
2688             unix_cli_process_input (cm, data[i]);
2689           break;
2690
2691         case UNIX_CLI_PROCESS_EVENT_QUIT:
2692           /* Kill this process. */
2693           for (i = 0; i < vec_len (data); i++)
2694             unix_cli_kill (cm, data[i]);
2695           goto done;
2696         }
2697
2698       if (data)
2699         _vec_len (data) = 0;
2700     }
2701
2702 done:
2703   vec_free (data);
2704
2705   vlib_node_set_state (vm, rt->node_index, VLIB_NODE_STATE_DISABLED);
2706
2707   /* Add node index so we can re-use this process later. */
2708   vec_add1 (cm->unused_cli_process_node_indices, rt->node_index);
2709
2710   return 0;
2711 }
2712
2713 /** Called when a CLI session file descriptor can be written to without
2714  * blocking. */
2715 static clib_error_t *
2716 unix_cli_write_ready (clib_file_t * uf)
2717 {
2718   unix_cli_main_t *cm = &unix_cli_main;
2719   unix_cli_file_t *cf;
2720   int n;
2721
2722   cf = pool_elt_at_index (cm->cli_file_pool, uf->private_data);
2723
2724   /* Flush output vector. */
2725   if (cf->is_socket)
2726     /* If it's a socket we use MSG_NOSIGNAL to prevent SIGPIPE */
2727     n = send (uf->file_descriptor,
2728               cf->output_vector, vec_len (cf->output_vector), MSG_NOSIGNAL);
2729   else
2730     n = write (uf->file_descriptor,
2731                cf->output_vector, vec_len (cf->output_vector));
2732
2733   if (n < 0 && errno != EAGAIN)
2734     {
2735       if (errno == EPIPE)
2736         {
2737           /* connection closed on us */
2738           unix_main_t *um = &unix_main;
2739           cf->has_epipe = 1;
2740           vlib_process_signal_event (um->vlib_main, cf->process_node_index,
2741                                      UNIX_CLI_PROCESS_EVENT_QUIT,
2742                                      uf->private_data);
2743         }
2744       else
2745         {
2746           return clib_error_return_unix (0, "write");
2747         }
2748     }
2749
2750   else if (n > 0)
2751     unix_cli_del_pending_output (uf, cf, n);
2752
2753   return /* no error */ 0;
2754 }
2755
2756 /** Called when a CLI session file descriptor has data to be read. */
2757 static clib_error_t *
2758 unix_cli_read_ready (clib_file_t * uf)
2759 {
2760   unix_main_t *um = &unix_main;
2761   unix_cli_main_t *cm = &unix_cli_main;
2762   unix_cli_file_t *cf;
2763   uword l;
2764   int n, n_read, n_try;
2765
2766   cf = pool_elt_at_index (cm->cli_file_pool, uf->private_data);
2767
2768   n = n_try = 4096;
2769   while (n == n_try)
2770     {
2771       l = vec_len (cf->input_vector);
2772       vec_resize (cf->input_vector, l + n_try);
2773
2774       n = read (uf->file_descriptor, cf->input_vector + l, n_try);
2775
2776       /* Error? */
2777       if (n < 0 && errno != EAGAIN)
2778         return clib_error_return_unix (0, "read");
2779
2780       n_read = n < 0 ? 0 : n;
2781       _vec_len (cf->input_vector) = l + n_read;
2782     }
2783
2784   if (!(n < 0))
2785     vlib_process_signal_event (um->vlib_main,
2786                                cf->process_node_index,
2787                                (n_read == 0
2788                                 ? UNIX_CLI_PROCESS_EVENT_QUIT
2789                                 : UNIX_CLI_PROCESS_EVENT_READ_READY),
2790                                /* event data */ uf->private_data);
2791
2792   return /* no error */ 0;
2793 }
2794
2795 /** Called when a CLI session file descriptor has an error condition. */
2796 static clib_error_t *
2797 unix_cli_error_detected (clib_file_t * uf)
2798 {
2799   unix_main_t *um = &unix_main;
2800   unix_cli_main_t *cm = &unix_cli_main;
2801   unix_cli_file_t *cf;
2802
2803   cf = pool_elt_at_index (cm->cli_file_pool, uf->private_data);
2804   cf->has_epipe = 1;            /* prevent writes while the close is pending */
2805   vlib_process_signal_event (um->vlib_main,
2806                              cf->process_node_index,
2807                              UNIX_CLI_PROCESS_EVENT_QUIT,
2808                              /* event data */ uf->private_data);
2809
2810   return /* no error */ 0;
2811 }
2812
2813 /** Store a new CLI session.
2814  * @param name The name of the session.
2815  * @param fd   The file descriptor for the session I/O.
2816  * @return The session ID.
2817  */
2818 static u32
2819 unix_cli_file_add (unix_cli_main_t * cm, char *name, int fd)
2820 {
2821   unix_main_t *um = &unix_main;
2822   clib_file_main_t *fm = &file_main;
2823   unix_cli_file_t *cf;
2824   clib_file_t template = { 0 };
2825   vlib_main_t *vm = um->vlib_main;
2826   vlib_node_t *n = 0;
2827   u8 *file_desc = 0;
2828
2829   file_desc = format (0, "%s", name);
2830
2831   name = (char *) format (0, "unix-cli-%s", name);
2832
2833   if (vec_len (cm->unused_cli_process_node_indices) > 0)
2834     {
2835       uword l = vec_len (cm->unused_cli_process_node_indices);
2836       int i;
2837       vlib_main_t *this_vlib_main;
2838       u8 *old_name = 0;
2839
2840       /*
2841        * Nodes are bulk-copied, so node name pointers are shared.
2842        * Find the cli node in all graph replicas, and give all of them
2843        * the same new name.
2844        * Then, throw away the old shared name-vector.
2845        */
2846       for (i = 0; i < vec_len (vlib_mains); i++)
2847         {
2848           this_vlib_main = vlib_mains[i];
2849           if (this_vlib_main == 0)
2850             continue;
2851           n = vlib_get_node (this_vlib_main,
2852                              cm->unused_cli_process_node_indices[l - 1]);
2853           old_name = n->name;
2854           n->name = (u8 *) name;
2855         }
2856       vec_free (old_name);
2857
2858       vlib_node_set_state (vm, n->index, VLIB_NODE_STATE_POLLING);
2859
2860       _vec_len (cm->unused_cli_process_node_indices) = l - 1;
2861     }
2862   else
2863     {
2864       static vlib_node_registration_t r = {
2865         .function = unix_cli_process,
2866         .type = VLIB_NODE_TYPE_PROCESS,
2867         .process_log2_n_stack_bytes = 18,
2868       };
2869
2870       r.name = name;
2871
2872       vlib_worker_thread_barrier_sync (vm);
2873
2874       vlib_register_node (vm, &r);
2875       vec_free (name);
2876
2877       n = vlib_get_node (vm, r.index);
2878       vlib_worker_thread_node_runtime_update ();
2879       vlib_worker_thread_barrier_release (vm);
2880     }
2881
2882   pool_get (cm->cli_file_pool, cf);
2883   clib_memset (cf, 0, sizeof (*cf));
2884
2885   template.read_function = unix_cli_read_ready;
2886   template.write_function = unix_cli_write_ready;
2887   template.error_function = unix_cli_error_detected;
2888   template.file_descriptor = fd;
2889   template.private_data = cf - cm->cli_file_pool;
2890   template.description = file_desc;
2891
2892   cf->process_node_index = n->index;
2893   cf->clib_file_index = clib_file_add (fm, &template);
2894   cf->output_vector = 0;
2895   cf->input_vector = 0;
2896
2897   vlib_start_process (vm, n->runtime_index);
2898
2899   vlib_process_t *p = vlib_get_process_from_node (vm, n);
2900   p->output_function = unix_vlib_cli_output;
2901   p->output_function_arg = cf - cm->cli_file_pool;
2902
2903   return cf - cm->cli_file_pool;
2904 }
2905
2906 /** Telnet listening socket has a new connection. */
2907 static clib_error_t *
2908 unix_cli_listen_read_ready (clib_file_t * uf)
2909 {
2910   unix_main_t *um = &unix_main;
2911   clib_file_main_t *fm = &file_main;
2912   unix_cli_main_t *cm = &unix_cli_main;
2913   clib_socket_t *s = &um->cli_listen_socket;
2914   clib_socket_t client;
2915   char *client_name;
2916   clib_error_t *error;
2917   unix_cli_file_t *cf;
2918   u32 cf_index;
2919   int one;
2920
2921   error = clib_socket_accept (s, &client);
2922   if (error)
2923     return error;
2924
2925   /* Disable Nagle, ignore any errors doing so eg on PF_LOCAL socket */
2926   one = 1;
2927   (void) setsockopt (client.fd, IPPROTO_TCP, TCP_NODELAY,
2928                      (void *) &one, sizeof (one));
2929
2930   client_name = (char *) format (0, "%U%c", format_sockaddr, &client.peer, 0);
2931
2932   cf_index = unix_cli_file_add (cm, client_name, client.fd);
2933   cf = pool_elt_at_index (cm->cli_file_pool, cf_index);
2934   cf->is_socket = 1;
2935
2936   /* No longer need CLIB version of socket. */
2937   clib_socket_free (&client);
2938   vec_free (client_name);
2939
2940   /* if we're supposed to run telnet session in character mode (default) */
2941   if (um->cli_line_mode == 0)
2942     {
2943       /*
2944        * Set telnet client character mode, echo on, suppress "go-ahead".
2945        * Technically these should be negotiated, but this works.
2946        */
2947       u8 charmode_option[] = {
2948         IAC, WONT, TELOPT_LINEMODE,     /* server will do char-by-char */
2949         IAC, DONT, TELOPT_LINEMODE,     /* client should do char-by-char */
2950         IAC, WILL, TELOPT_SGA,  /* server willl supress GA */
2951         IAC, DO, TELOPT_SGA,    /* client should supress Go Ahead */
2952         IAC, WILL, TELOPT_ECHO, /* server will do echo */
2953         IAC, DONT, TELOPT_ECHO, /* client should not echo */
2954         IAC, DO, TELOPT_TTYPE,  /* client should tell us its term type */
2955         IAC, SB, TELOPT_TTYPE, 1, IAC, SE,      /* now tell me ttype */
2956         IAC, DO, TELOPT_NAWS,   /* client should tell us its window sz */
2957         IAC, SB, TELOPT_NAWS, 1, IAC, SE,       /* now tell me window size */
2958       };
2959
2960       /* Enable history on this CLI */
2961       cf->history_limit = um->cli_history_limit;
2962       cf->has_history = cf->history_limit != 0;
2963
2964       /* This is an interactive session until we decide otherwise */
2965       cf->is_interactive = 1;
2966
2967       /* Make sure this session is in line mode */
2968       cf->line_mode = 0;
2969
2970       /* We need CRLF */
2971       cf->crlf_mode = 1;
2972
2973       /* Setup the pager */
2974       cf->no_pager = um->cli_no_pager;
2975
2976       /* Default terminal dimensions, should the terminal
2977        * fail to provide any.
2978        */
2979       cf->width = UNIX_CLI_DEFAULT_TERMINAL_WIDTH;
2980       cf->height = UNIX_CLI_DEFAULT_TERMINAL_HEIGHT;
2981
2982       /* Send the telnet options */
2983       uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
2984       unix_vlib_cli_output_raw (cf, uf, charmode_option,
2985                                 ARRAY_LEN (charmode_option));
2986
2987       if (cm->new_session_process_node_index == ~0)
2988         {
2989           /* Create thw new session deadline process */
2990           cm->new_session_process_node_index =
2991             vlib_process_create (um->vlib_main, "unix-cli-new-session",
2992                                  unix_cli_new_session_process,
2993                                  16 /* log2_n_stack_bytes */ );
2994         }
2995
2996       /* In case the client doesn't negotiate terminal type, register
2997        * our session with a process that will emit the prompt if
2998        * a deadline passes */
2999       vlib_process_signal_event (um->vlib_main,
3000                                  cm->new_session_process_node_index,
3001                                  UNIX_CLI_NEW_SESSION_EVENT_ADD, cf_index);
3002
3003     }
3004
3005   return error;
3006 }
3007
3008 /** The system terminal has informed us that the window size
3009  * has changed.
3010  */
3011 static void
3012 unix_cli_resize_interrupt (int signum)
3013 {
3014   clib_file_main_t *fm = &file_main;
3015   unix_cli_main_t *cm = &unix_cli_main;
3016   unix_cli_file_t *cf = pool_elt_at_index (cm->cli_file_pool,
3017                                            cm->stdin_cli_file_index);
3018   clib_file_t *uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
3019   struct winsize ws;
3020   (void) signum;
3021
3022   /* Terminal resized, fetch the new size */
3023   if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) < 0)
3024     {
3025       /* "Should never happen..." */
3026       clib_unix_warning ("TIOCGWINSZ");
3027       /* We can't trust ws.XXX... */
3028       return;
3029     }
3030
3031   cf->width = ws.ws_col;
3032   if (cf->width > UNIX_CLI_MAX_TERMINAL_WIDTH)
3033     cf->width = UNIX_CLI_MAX_TERMINAL_WIDTH;
3034   if (cf->width == 0)
3035     cf->width = UNIX_CLI_DEFAULT_TERMINAL_WIDTH;
3036
3037   cf->height = ws.ws_row;
3038   if (cf->height > UNIX_CLI_MAX_TERMINAL_HEIGHT)
3039     cf->height = UNIX_CLI_MAX_TERMINAL_HEIGHT;
3040   if (cf->height == 0)
3041     cf->height = UNIX_CLI_DEFAULT_TERMINAL_HEIGHT;
3042
3043   /* Reindex the pager buffer */
3044   unix_cli_pager_reindex (cf);
3045
3046   /* Redraw the page */
3047   unix_cli_pager_redraw (cf, uf);
3048 }
3049
3050 /** Handle configuration directives in the @em unix section. */
3051 static clib_error_t *
3052 unix_cli_config (vlib_main_t * vm, unformat_input_t * input)
3053 {
3054   unix_main_t *um = &unix_main;
3055   clib_file_main_t *fm = &file_main;
3056   unix_cli_main_t *cm = &unix_cli_main;
3057   int flags;
3058   clib_error_t *error = 0;
3059   unix_cli_file_t *cf;
3060   u32 cf_index;
3061   struct termios tio;
3062   struct sigaction sa;
3063   struct winsize ws;
3064   u8 *term;
3065
3066   /* We depend on unix flags being set. */
3067   if ((error = vlib_call_config_function (vm, unix_config)))
3068     return error;
3069
3070   if (um->flags & UNIX_FLAG_INTERACTIVE)
3071     {
3072       /* Set stdin to be non-blocking. */
3073       if ((flags = fcntl (STDIN_FILENO, F_GETFL, 0)) < 0)
3074         flags = 0;
3075       (void) fcntl (STDIN_FILENO, F_SETFL, flags | O_NONBLOCK);
3076
3077       cf_index = unix_cli_file_add (cm, "stdin", STDIN_FILENO);
3078       cf = pool_elt_at_index (cm->cli_file_pool, cf_index);
3079       cm->stdin_cli_file_index = cf_index;
3080
3081       /* If stdin is a tty and we are using chacracter mode, enable
3082        * history on the CLI and set the tty line discipline accordingly. */
3083       if (isatty (STDIN_FILENO) && um->cli_line_mode == 0)
3084         {
3085           /* Capture terminal resize events */
3086           clib_memset (&sa, 0, sizeof (sa));
3087           sa.sa_handler = unix_cli_resize_interrupt;
3088           if (sigaction (SIGWINCH, &sa, 0) < 0)
3089             clib_panic ("sigaction");
3090
3091           /* Retrieve the current terminal size */
3092           if (ioctl (STDIN_FILENO, TIOCGWINSZ, &ws) == 0)
3093             {
3094               cf->width = ws.ws_col;
3095               cf->height = ws.ws_row;
3096             }
3097
3098           if (cf->width == 0 || cf->height == 0)
3099             {
3100               /*
3101                * We have a tty, but no size. Use defaults.
3102                * vpp "unix interactive" inside emacs + gdb ends up here.
3103                */
3104               cf->width = UNIX_CLI_DEFAULT_TERMINAL_WIDTH;
3105               cf->height = UNIX_CLI_DEFAULT_TERMINAL_HEIGHT;
3106             }
3107
3108           /* Setup the history */
3109           cf->history_limit = um->cli_history_limit;
3110           cf->has_history = cf->history_limit != 0;
3111
3112           /* Setup the pager */
3113           cf->no_pager = um->cli_no_pager;
3114
3115           /* This is an interactive session until we decide otherwise */
3116           cf->is_interactive = 1;
3117
3118           /* We're going to be in char by char mode */
3119           cf->line_mode = 0;
3120
3121           /* Save the original tty state so we can restore it later */
3122           tcgetattr (STDIN_FILENO, &um->tio_stdin);
3123           um->tio_isset = 1;
3124
3125           /* Tweak the tty settings */
3126           tio = um->tio_stdin;
3127           /* echo off, canonical mode off, ext'd input processing off */
3128           tio.c_lflag &= ~(ECHO | ICANON | IEXTEN);
3129           /* disable XON/XOFF, so ^S invokes the history search */
3130           tio.c_iflag &= ~(IXON | IXOFF);
3131           tio.c_cc[VMIN] = 1;   /* 1 byte at a time */
3132           tio.c_cc[VTIME] = 0;  /* no timer */
3133           tio.c_cc[VSTOP] = _POSIX_VDISABLE;    /* not ^S */
3134           tio.c_cc[VSTART] = _POSIX_VDISABLE;   /* not ^Q */
3135           tcsetattr (STDIN_FILENO, TCSAFLUSH, &tio);
3136
3137           /* See if we can do ANSI/VT100 output */
3138           term = (u8 *) getenv ("TERM");
3139           if (term != NULL)
3140             {
3141               int len = strlen ((char *) term);
3142               cf->ansi_capable = unix_cli_terminal_type_ansi (term, len);
3143               if (unix_cli_terminal_type_noninteractive (term, len))
3144                 unix_cli_set_session_noninteractive (cf);
3145             }
3146         }
3147       else
3148         {
3149           /* No tty, so make sure the session doesn't have tty-like features */
3150           unix_cli_set_session_noninteractive (cf);
3151         }
3152
3153       /* Send banner and initial prompt */
3154       unix_cli_file_welcome (cm, cf);
3155     }
3156
3157   /* If we have socket config, LISTEN, otherwise, don't */
3158   clib_socket_t *s = &um->cli_listen_socket;
3159   if (s->config && s->config[0] != 0)
3160     {
3161       /* CLI listen. */
3162       clib_file_t template = { 0 };
3163
3164       /* mkdir of file socketu, only under /run  */
3165       if (strncmp (s->config, "/run", 4) == 0)
3166         {
3167           u8 *tmp = format (0, "%s", s->config);
3168           int i = vec_len (tmp);
3169           while (i && tmp[--i] != '/')
3170             ;
3171
3172           tmp[i] = '\0';
3173
3174           if (i)
3175             vlib_unix_recursive_mkdir ((char *) tmp);
3176           vec_free (tmp);
3177         }
3178
3179       s->flags = CLIB_SOCKET_F_IS_SERVER |      /* listen, don't connect */
3180         CLIB_SOCKET_F_ALLOW_GROUP_WRITE;        /* PF_LOCAL socket only */
3181       error = clib_socket_init (s);
3182
3183       if (error)
3184         return error;
3185
3186       template.read_function = unix_cli_listen_read_ready;
3187       template.file_descriptor = s->fd;
3188       template.description = format (0, "cli listener %s", s->config);
3189
3190       clib_file_add (fm, &template);
3191     }
3192
3193   /* Set CLI prompt. */
3194   if (!cm->cli_prompt)
3195     cm->cli_prompt = format (0, "VLIB: ");
3196
3197   return 0;
3198 }
3199
3200 /*?
3201  * This module has no configurable parameters.
3202 ?*/
3203 VLIB_CONFIG_FUNCTION (unix_cli_config, "unix-cli");
3204
3205 /** Called when VPP is shutting down, this restores the system
3206  * terminal state if previously saved.
3207  */
3208 static clib_error_t *
3209 unix_cli_exit (vlib_main_t * vm)
3210 {
3211   unix_main_t *um = &unix_main;
3212
3213   /* If stdin is a tty and we saved the tty state, reset the tty state */
3214   if (isatty (STDIN_FILENO) && um->tio_isset)
3215     tcsetattr (STDIN_FILENO, TCSAFLUSH, &um->tio_stdin);
3216
3217   return 0;
3218 }
3219
3220 VLIB_MAIN_LOOP_EXIT_FUNCTION (unix_cli_exit);
3221
3222 /** Set the CLI prompt.
3223  * @param prompt The C string to set the prompt to.
3224  * @note This setting is global; it impacts all current
3225  *       and future CLI sessions.
3226  */
3227 void
3228 vlib_unix_cli_set_prompt (char *prompt)
3229 {
3230   char *fmt = (prompt[strlen (prompt) - 1] == ' ') ? "%s" : "%s ";
3231   unix_cli_main_t *cm = &unix_cli_main;
3232   if (cm->cli_prompt)
3233     vec_free (cm->cli_prompt);
3234   cm->cli_prompt = format (0, fmt, prompt);
3235 }
3236
3237 /** CLI command to quit the terminal session.
3238  * @note If this is a stdin session then this will
3239  *       shutdown VPP also.
3240  */
3241 static clib_error_t *
3242 unix_cli_quit (vlib_main_t * vm,
3243                unformat_input_t * input, vlib_cli_command_t * cmd)
3244 {
3245   unix_cli_main_t *cm = &unix_cli_main;
3246   unix_cli_file_t *cf = pool_elt_at_index (cm->cli_file_pool,
3247                                            cm->current_input_file_index);
3248
3249   /* Cosmetic: suppress the final prompt from appearing before we die */
3250   cf->is_interactive = 0;
3251   cf->started = 1;
3252
3253   vlib_process_signal_event (vm,
3254                              vlib_current_process (vm),
3255                              UNIX_CLI_PROCESS_EVENT_QUIT,
3256                              cm->current_input_file_index);
3257   return 0;
3258 }
3259
3260 /*?
3261  * Terminates the current CLI session.
3262  *
3263  * If VPP is running in @em interactive mode and this is the console session
3264  * (that is, the session on @c stdin) then this will also terminate VPP.
3265 ?*/
3266 /* *INDENT-OFF* */
3267 VLIB_CLI_COMMAND (unix_cli_quit_command, static) = {
3268   .path = "quit",
3269   .short_help = "Exit CLI",
3270   .function = unix_cli_quit,
3271 };
3272 /* *INDENT-ON* */
3273
3274 /* *INDENT-OFF* */
3275 VLIB_CLI_COMMAND (unix_cli_q_command, static) = {
3276   .path = "q",
3277   .short_help = "Exit CLI",
3278   .function = unix_cli_quit,
3279 };
3280 /* *INDENT-ON* */
3281
3282 /** CLI command to execute a VPP command script. */
3283 static clib_error_t *
3284 unix_cli_exec (vlib_main_t * vm,
3285                unformat_input_t * input, vlib_cli_command_t * cmd)
3286 {
3287   char *file_name;
3288   int fd;
3289   unformat_input_t sub_input;
3290   clib_error_t *error;
3291
3292   file_name = 0;
3293   fd = -1;
3294   error = 0;
3295
3296   if (!unformat (input, "%s", &file_name))
3297     {
3298       error = clib_error_return (0, "expecting file name, got `%U'",
3299                                  format_unformat_error, input);
3300       goto done;
3301     }
3302
3303   fd = open (file_name, O_RDONLY);
3304   if (fd < 0)
3305     {
3306       error = clib_error_return_unix (0, "failed to open `%s'", file_name);
3307       goto done;
3308     }
3309
3310   /* Make sure its a regular file. */
3311   {
3312     struct stat s;
3313
3314     if (fstat (fd, &s) < 0)
3315       {
3316         error = clib_error_return_unix (0, "failed to stat `%s'", file_name);
3317         goto done;
3318       }
3319
3320     if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
3321       {
3322         error = clib_error_return (0, "not a regular file `%s'", file_name);
3323         goto done;
3324       }
3325   }
3326
3327   unformat_init_clib_file (&sub_input, fd);
3328
3329   vlib_cli_input (vm, &sub_input, 0, 0);
3330   unformat_free (&sub_input);
3331
3332 done:
3333   if (fd >= 0)
3334     close (fd);
3335   vec_free (file_name);
3336
3337   return error;
3338 }
3339
3340 /*?
3341  * Executes a sequence of CLI commands which are read from a file. If
3342  * a command is unrecognised or otherwise invalid then the usual CLI
3343  * feedback will be generated, however execution of subsequent commands
3344  * from the file will continue.
3345  *
3346  * The VPP code is indifferent to the file location. However, if SELinux
3347  * is enabled, then the file needs to have an SELinux label the VPP
3348  * process is allowed to access. For example, if a file is created in
3349  * '<em>/usr/share/vpp/</em>', it will be allowed. However, files manually
3350  * created in '/tmp/' or '/home/<user>/' will not be accessible by the VPP
3351  * process when SELinux is enabled.
3352  *
3353  * @cliexpar
3354  * Sample file:
3355  * @clistart
3356  * <b><em>$ cat /usr/share/vpp/scripts/gigup.txt</em></b>
3357  * set interface state GigabitEthernet0/8/0 up
3358  * set interface state GigabitEthernet0/9/0 up
3359  * @cliend
3360  * Example of how to execute a set of CLI commands from a file:
3361  * @cliexcmd{exec /usr/share/vpp/scripts/gigup.txt}
3362 ?*/
3363 /* *INDENT-OFF* */
3364 VLIB_CLI_COMMAND (cli_exec, static) = {
3365   .path = "exec",
3366   .short_help = "exec <filename>",
3367   .function = unix_cli_exec,
3368   .is_mp_safe = 1,
3369 };
3370 /* *INDENT-ON* */
3371
3372 /** CLI command to show various unix error statistics. */
3373 static clib_error_t *
3374 unix_show_errors (vlib_main_t * vm,
3375                   unformat_input_t * input, vlib_cli_command_t * cmd)
3376 {
3377   unix_main_t *um = &unix_main;
3378   clib_error_t *error = 0;
3379   int i, n_errors_to_show;
3380   unix_error_history_t *unix_errors = 0;
3381
3382   n_errors_to_show = 1 << 30;
3383
3384   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3385     {
3386       if (!unformat (input, "%d", &n_errors_to_show))
3387         {
3388           error =
3389             clib_error_return (0,
3390                                "expecting integer number of errors to show, got `%U'",
3391                                format_unformat_error, input);
3392           goto done;
3393         }
3394     }
3395
3396   n_errors_to_show =
3397     clib_min (ARRAY_LEN (um->error_history), n_errors_to_show);
3398
3399   i =
3400     um->error_history_index >
3401     0 ? um->error_history_index - 1 : ARRAY_LEN (um->error_history) - 1;
3402
3403   while (n_errors_to_show > 0)
3404     {
3405       unix_error_history_t *eh = um->error_history + i;
3406
3407       if (!eh->error)
3408         break;
3409
3410       vec_add1 (unix_errors, eh[0]);
3411       n_errors_to_show -= 1;
3412       if (i == 0)
3413         i = ARRAY_LEN (um->error_history) - 1;
3414       else
3415         i--;
3416     }
3417
3418   if (vec_len (unix_errors) == 0)
3419     vlib_cli_output (vm, "no Unix errors so far");
3420   else
3421     {
3422       vlib_cli_output (vm, "%Ld total errors seen", um->n_total_errors);
3423       for (i = vec_len (unix_errors) - 1; i >= 0; i--)
3424         {
3425           unix_error_history_t *eh = vec_elt_at_index (unix_errors, i);
3426           vlib_cli_output (vm, "%U: %U",
3427                            format_time_interval, "h:m:s:u", eh->time,
3428                            format_clib_error, eh->error);
3429         }
3430       vlib_cli_output (vm, "%U: time now",
3431                        format_time_interval, "h:m:s:u", vlib_time_now (vm));
3432     }
3433
3434 done:
3435   vec_free (unix_errors);
3436   return error;
3437 }
3438
3439 /* *INDENT-OFF* */
3440 VLIB_CLI_COMMAND (cli_unix_show_errors, static) = {
3441   .path = "show unix errors",
3442   .short_help = "Show Unix system call error history",
3443   .function = unix_show_errors,
3444 };
3445 /* *INDENT-ON* */
3446
3447 /** CLI command to show various unix error statistics. */
3448 static clib_error_t *
3449 unix_show_files (vlib_main_t * vm,
3450                  unformat_input_t * input, vlib_cli_command_t * cmd)
3451 {
3452   clib_error_t *error = 0;
3453   clib_file_main_t *fm = &file_main;
3454   clib_file_t *f;
3455   char path[PATH_MAX];
3456   u8 *s = 0;
3457
3458   vlib_cli_output (vm, "%3s %6s %12s %12s %12s %-32s %s", "FD", "Thread",
3459                    "Read", "Write", "Error", "File Name", "Description");
3460
3461   /* *INDENT-OFF* */
3462   pool_foreach (f, fm->file_pool,(
3463    {
3464       int rv;
3465       s = format (s, "/proc/self/fd/%d%c", f->file_descriptor, 0);
3466       rv = readlink((char *) s, path, PATH_MAX - 1);
3467
3468       path[rv < 0 ? 0 : rv] = 0;
3469
3470       vlib_cli_output (vm, "%3d %6d %12d %12d %12d %-32s %v",
3471                        f->file_descriptor, f->polling_thread_index,
3472                        f->read_events, f->write_events, f->error_events,
3473                        path, f->description);
3474       vec_reset_length (s);
3475     }));
3476   /* *INDENT-ON* */
3477   vec_free (s);
3478
3479   return error;
3480 }
3481
3482 /* *INDENT-OFF* */
3483 VLIB_CLI_COMMAND (cli_unix_show_files, static) = {
3484   .path = "show unix files",
3485   .short_help = "Show Unix files in use",
3486   .function = unix_show_files,
3487 };
3488 /* *INDENT-ON* */
3489
3490 /** CLI command to show session command history. */
3491 static clib_error_t *
3492 unix_cli_show_history (vlib_main_t * vm,
3493                        unformat_input_t * input, vlib_cli_command_t * cmd)
3494 {
3495   unix_cli_main_t *cm = &unix_cli_main;
3496   unix_cli_file_t *cf;
3497   int i, j;
3498
3499   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3500
3501   if (!cf->is_interactive)
3502     return clib_error_return (0, "invalid for non-interactive sessions");
3503
3504   if (cf->has_history && cf->history_limit)
3505     {
3506       i = 1 + cf->command_number - vec_len (cf->command_history);
3507       for (j = 0; j < vec_len (cf->command_history); j++)
3508         vlib_cli_output (vm, "%d  %v\n", i + j, cf->command_history[j]);
3509     }
3510   else
3511     {
3512       vlib_cli_output (vm, "History not enabled.\n");
3513     }
3514
3515   return 0;
3516 }
3517
3518 /*?
3519  * Displays the command history for the current session, if any.
3520 ?*/
3521 /* *INDENT-OFF* */
3522 VLIB_CLI_COMMAND (cli_unix_cli_show_history, static) = {
3523   .path = "history",
3524   .short_help = "Show current session command history",
3525   .function = unix_cli_show_history,
3526 };
3527 /* *INDENT-ON* */
3528
3529 /** CLI command to show terminal status. */
3530 static clib_error_t *
3531 unix_cli_show_terminal (vlib_main_t * vm,
3532                         unformat_input_t * input, vlib_cli_command_t * cmd)
3533 {
3534   unix_main_t *um = &unix_main;
3535   unix_cli_main_t *cm = &unix_cli_main;
3536   unix_cli_file_t *cf;
3537   vlib_node_t *n;
3538
3539   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3540   n = vlib_get_node (vm, cf->process_node_index);
3541
3542   vlib_cli_output (vm, "Terminal name:   %v\n", n->name);
3543   vlib_cli_output (vm, "Terminal mode:   %s\n", cf->line_mode ?
3544                    "line-by-line" : "char-by-char");
3545   vlib_cli_output (vm, "Terminal width:  %d\n", cf->width);
3546   vlib_cli_output (vm, "Terminal height: %d\n", cf->height);
3547   vlib_cli_output (vm, "ANSI capable:    %s\n",
3548                    cf->ansi_capable ? "yes" : "no");
3549   vlib_cli_output (vm, "Interactive:     %s\n",
3550                    cf->is_interactive ? "yes" : "no");
3551   vlib_cli_output (vm, "History enabled: %s%s\n",
3552                    cf->has_history ? "yes" : "no", !cf->has_history
3553                    || cf->history_limit ? "" :
3554                    " (disabled by history limit)");
3555   if (cf->has_history)
3556     vlib_cli_output (vm, "History limit:   %d\n", cf->history_limit);
3557   vlib_cli_output (vm, "Pager enabled:   %s%s%s\n",
3558                    cf->no_pager ? "no" : "yes",
3559                    cf->no_pager
3560                    || cf->height ? "" : " (disabled by terminal height)",
3561                    cf->no_pager
3562                    || um->cli_pager_buffer_limit ? "" :
3563                    " (disabled by buffer limit)");
3564   if (!cf->no_pager)
3565     vlib_cli_output (vm, "Pager limit:     %d\n", um->cli_pager_buffer_limit);
3566   vlib_cli_output (vm, "CRLF mode:       %s\n",
3567                    cf->crlf_mode ? "CR+LF" : "LF");
3568
3569   return 0;
3570 }
3571
3572 /*?
3573  * Displays various information about the state of the current terminal
3574  * session.
3575  *
3576  * @cliexpar
3577  * @cliexstart{show terminal}
3578  * Terminal name:   unix-cli-stdin
3579  * Terminal mode:   char-by-char
3580  * Terminal width:  123
3581  * Terminal height: 48
3582  * ANSI capable:    yes
3583  * Interactive:     yes
3584  * History enabled: yes
3585  * History limit:   50
3586  * Pager enabled:   yes
3587  * Pager limit:     100000
3588  * CRLF mode:       LF
3589  * @cliexend
3590 ?*/
3591 /* *INDENT-OFF* */
3592 VLIB_CLI_COMMAND (cli_unix_cli_show_terminal, static) = {
3593   .path = "show terminal",
3594   .short_help = "Show current session terminal settings",
3595   .function = unix_cli_show_terminal,
3596 };
3597 /* *INDENT-ON* */
3598
3599 /** CLI command to display a list of CLI sessions. */
3600 static clib_error_t *
3601 unix_cli_show_cli_sessions (vlib_main_t * vm,
3602                             unformat_input_t * input,
3603                             vlib_cli_command_t * cmd)
3604 {
3605   unix_cli_main_t *cm = &unix_cli_main;
3606   clib_file_main_t *fm = &file_main;
3607   unix_cli_file_t *cf;
3608   clib_file_t *uf;
3609   vlib_node_t *n;
3610
3611   vlib_cli_output (vm, "%-5s %-5s %-20s %s", "PNI", "FD", "Name", "Flags");
3612
3613 #define fl(x, y) ( (x) ? toupper((y)) : tolower((y)) )
3614   /* *INDENT-OFF* */
3615   pool_foreach (cf, cm->cli_file_pool, ({
3616     uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
3617     n = vlib_get_node (vm, cf->process_node_index);
3618     vlib_cli_output (vm,
3619                      "%-5d %-5d %-20v %c%c%c%c%c\n",
3620                      cf->process_node_index,
3621                      uf->file_descriptor,
3622                      n->name,
3623                      fl (cf->is_interactive, 'i'),
3624                      fl (cf->is_socket, 's'),
3625                      fl (cf->line_mode, 'l'),
3626                      fl (cf->has_epipe, 'p'),
3627                      fl (cf->ansi_capable, 'a'));
3628   }));
3629   /* *INDENT-ON* */
3630 #undef fl
3631
3632   return 0;
3633 }
3634
3635 /*?
3636  * Displays a summary of all the current CLI sessions.
3637  *
3638  * Typically used to diagnose connection issues with the CLI
3639  * socket.
3640  *
3641  * @cliexpar
3642  * @cliexstart{show cli-sessions}
3643  * PNI   FD    Name                 Flags
3644  * 343   0     unix-cli-stdin       IslpA
3645  * 344   7     unix-cli-local:20    ISlpA
3646  * 346   8     unix-cli-local:21    iSLpa
3647  * @cliexend
3648
3649  * In this example we have the debug console of the running process
3650  * on stdin/out, we have an interactive socket session and we also
3651  * have a non-interactive socket session.
3652  *
3653  * Fields:
3654  *
3655  * - @em PNI: Process node index.
3656  * - @em FD: Unix file descriptor.
3657  * - @em Name: Name of the session.
3658  * - @em Flags: Various flags that describe the state of the session.
3659  *
3660  * @em Flags have the following meanings; lower-case typically negates
3661  * upper-case:
3662  *
3663  * - @em I Interactive session.
3664  * - @em S Connected by socket.
3665  * - @em s Not a socket, likely stdin.
3666  * - @em L Line-by-line mode.
3667  * - @em l Char-by-char mode.
3668  * - @em P EPIPE detected on connection; it will close soon.
3669  * - @em A ANSI-capable terminal.
3670 ?*/
3671 /* *INDENT-OFF* */
3672 VLIB_CLI_COMMAND (cli_unix_cli_show_cli_sessions, static) = {
3673   .path = "show cli-sessions",
3674   .short_help = "Show current CLI sessions",
3675   .function = unix_cli_show_cli_sessions,
3676 };
3677 /* *INDENT-ON* */
3678
3679 /** CLI command to set terminal pager settings. */
3680 static clib_error_t *
3681 unix_cli_set_terminal_pager (vlib_main_t * vm,
3682                              unformat_input_t * input,
3683                              vlib_cli_command_t * cmd)
3684 {
3685   unix_main_t *um = &unix_main;
3686   unix_cli_main_t *cm = &unix_cli_main;
3687   unix_cli_file_t *cf;
3688   unformat_input_t _line_input, *line_input = &_line_input;
3689   clib_error_t *error = 0;
3690
3691   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3692
3693   if (!cf->is_interactive)
3694     return clib_error_return (0, "invalid for non-interactive sessions");
3695
3696   if (!unformat_user (input, unformat_line_input, line_input))
3697     return 0;
3698
3699   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
3700     {
3701       if (unformat (line_input, "on"))
3702         cf->no_pager = 0;
3703       else if (unformat (line_input, "off"))
3704         cf->no_pager = 1;
3705       else if (unformat (line_input, "limit %u", &um->cli_pager_buffer_limit))
3706         vlib_cli_output (vm,
3707                          "Pager limit set to %u lines; note, this is global.\n",
3708                          um->cli_pager_buffer_limit);
3709       else
3710         {
3711           error = clib_error_return (0, "unknown parameter: `%U`",
3712                                      format_unformat_error, line_input);
3713           goto done;
3714         }
3715     }
3716
3717 done:
3718   unformat_free (line_input);
3719
3720   return error;
3721 }
3722
3723 /*?
3724  * Enables or disables the terminal pager for this session. Generally
3725  * this defaults to enabled.
3726  *
3727  * Additionally allows the pager buffer size to be set; though note that
3728  * this value is set globally and not per session.
3729 ?*/
3730 /* *INDENT-OFF* */
3731 VLIB_CLI_COMMAND (cli_unix_cli_set_terminal_pager, static) = {
3732   .path = "set terminal pager",
3733   .short_help = "set terminal pager [on|off] [limit <lines>]",
3734   .function = unix_cli_set_terminal_pager,
3735 };
3736 /* *INDENT-ON* */
3737
3738 /** CLI command to set terminal history settings. */
3739 static clib_error_t *
3740 unix_cli_set_terminal_history (vlib_main_t * vm,
3741                                unformat_input_t * input,
3742                                vlib_cli_command_t * cmd)
3743 {
3744   unix_cli_main_t *cm = &unix_cli_main;
3745   unix_cli_file_t *cf;
3746   unformat_input_t _line_input, *line_input = &_line_input;
3747   u32 limit;
3748   clib_error_t *error = 0;
3749
3750   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3751
3752   if (!cf->is_interactive)
3753     return clib_error_return (0, "invalid for non-interactive sessions");
3754
3755   if (!unformat_user (input, unformat_line_input, line_input))
3756     return 0;
3757
3758   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
3759     {
3760       if (unformat (line_input, "on"))
3761         cf->has_history = 1;
3762       else if (unformat (line_input, "off"))
3763         cf->has_history = 0;
3764       else if (unformat (line_input, "limit %u", &cf->history_limit))
3765         ;
3766       else
3767         {
3768           error = clib_error_return (0, "unknown parameter: `%U`",
3769                                      format_unformat_error, line_input);
3770           goto done;
3771         }
3772
3773     }
3774
3775   /* If we reduced history size, or turned it off, purge the history */
3776   limit = cf->has_history ? cf->history_limit : 0;
3777   if (limit < vec_len (cf->command_history))
3778     {
3779       u32 i;
3780
3781       /* How many items to remove from the start of history */
3782       limit = vec_len (cf->command_history) - limit;
3783
3784       for (i = 0; i < limit; i++)
3785         vec_free (cf->command_history[i]);
3786
3787       vec_delete (cf->command_history, limit, 0);
3788     }
3789
3790 done:
3791   unformat_free (line_input);
3792
3793   return error;
3794 }
3795
3796 /*?
3797  * Enables or disables the command history function of the current
3798  * terminal. Generally this defaults to enabled.
3799  *
3800  * This command also allows the maximum size of the history buffer for
3801  * this session to be altered.
3802 ?*/
3803 /* *INDENT-OFF* */
3804 VLIB_CLI_COMMAND (cli_unix_cli_set_terminal_history, static) = {
3805   .path = "set terminal history",
3806   .short_help = "set terminal history [on|off] [limit <lines>]",
3807   .function = unix_cli_set_terminal_history,
3808 };
3809 /* *INDENT-ON* */
3810
3811 /** CLI command to set terminal ANSI settings. */
3812 static clib_error_t *
3813 unix_cli_set_terminal_ansi (vlib_main_t * vm,
3814                             unformat_input_t * input,
3815                             vlib_cli_command_t * cmd)
3816 {
3817   unix_cli_main_t *cm = &unix_cli_main;
3818   unix_cli_file_t *cf;
3819
3820   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3821
3822   if (!cf->is_interactive)
3823     return clib_error_return (0, "invalid for non-interactive sessions");
3824
3825   if (unformat (input, "on"))
3826     cf->ansi_capable = 1;
3827   else if (unformat (input, "off"))
3828     cf->ansi_capable = 0;
3829   else
3830     return clib_error_return (0, "unknown parameter: `%U`",
3831                               format_unformat_error, input);
3832
3833   return 0;
3834 }
3835
3836 /*?
3837  * Enables or disables the use of ANSI control sequences by this terminal.
3838  * The default will vary based on terminal detection at the start of the
3839  * session.
3840  *
3841  * ANSI control sequences are used in a small number of places to provide,
3842  * for example, color text output and to control the cursor in the pager.
3843 ?*/
3844 /* *INDENT-OFF* */
3845 VLIB_CLI_COMMAND (cli_unix_cli_set_terminal_ansi, static) = {
3846   .path = "set terminal ansi",
3847   .short_help = "set terminal ansi [on|off]",
3848   .function = unix_cli_set_terminal_ansi,
3849 };
3850 /* *INDENT-ON* */
3851
3852
3853 #define MAX_CLI_WAIT 86400
3854 /** CLI command to wait <sec> seconds. Useful for exec script. */
3855 static clib_error_t *
3856 unix_wait_cmd (vlib_main_t * vm,
3857                unformat_input_t * input, vlib_cli_command_t * cmd)
3858 {
3859   unformat_input_t _line_input, *line_input = &_line_input;
3860   f64 sec = 1.0;
3861
3862   if (!unformat_user (input, unformat_line_input, line_input))
3863     return 0;
3864
3865   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
3866     {
3867       if (unformat (line_input, "%f", &sec))
3868         ;
3869       else
3870         return clib_error_return (0, "unknown parameter: `%U`",
3871                                   format_unformat_error, input);
3872     }
3873
3874   if (sec <= 0 || sec > MAX_CLI_WAIT || floor (sec * 1000) / 1000 != sec)
3875     return clib_error_return (0,
3876                               "<sec> must be a positive value and less than 86400 (one day) with no more than msec precision.");
3877
3878   vlib_process_wait_for_event_or_clock (vm, sec);
3879   vlib_cli_output (vm, "waited %.3f sec.", sec);
3880
3881   unformat_free (line_input);
3882   return 0;
3883 }
3884 /* *INDENT-OFF* */
3885 VLIB_CLI_COMMAND (cli_unix_wait_cmd, static) = {
3886   .path = "wait",
3887   .short_help = "wait <sec>",
3888   .function = unix_wait_cmd,
3889 };
3890 /* *INDENT-ON* */
3891
3892 static clib_error_t *
3893 unix_cli_init (vlib_main_t * vm)
3894 {
3895   unix_cli_main_t *cm = &unix_cli_main;
3896
3897   /* Breadcrumb to indicate the new session process
3898    * has not been started */
3899   cm->new_session_process_node_index = ~0;
3900
3901   return 0;
3902 }
3903
3904 VLIB_INIT_FUNCTION (unix_cli_init);
3905
3906 /*
3907  * fd.io coding-style-patch-verification: ON
3908  *
3909  * Local Variables:
3910  * eval: (c-set-style "gnu")
3911  * End:
3912  */