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           ioctl (STDIN_FILENO, TIOCGWINSZ, &ws);
3093           cf->width = ws.ws_col;
3094           cf->height = ws.ws_row;
3095
3096           if (cf->width == 0 || cf->height == 0)
3097             {
3098               /*
3099                * We have a tty, but no size. Use defaults.
3100                * vpp "unix interactive" inside emacs + gdb ends up here.
3101                */
3102               cf->width = UNIX_CLI_DEFAULT_TERMINAL_WIDTH;
3103               cf->height = UNIX_CLI_DEFAULT_TERMINAL_HEIGHT;
3104             }
3105
3106           /* Setup the history */
3107           cf->history_limit = um->cli_history_limit;
3108           cf->has_history = cf->history_limit != 0;
3109
3110           /* Setup the pager */
3111           cf->no_pager = um->cli_no_pager;
3112
3113           /* This is an interactive session until we decide otherwise */
3114           cf->is_interactive = 1;
3115
3116           /* We're going to be in char by char mode */
3117           cf->line_mode = 0;
3118
3119           /* Save the original tty state so we can restore it later */
3120           tcgetattr (STDIN_FILENO, &um->tio_stdin);
3121           um->tio_isset = 1;
3122
3123           /* Tweak the tty settings */
3124           tio = um->tio_stdin;
3125           /* echo off, canonical mode off, ext'd input processing off */
3126           tio.c_lflag &= ~(ECHO | ICANON | IEXTEN);
3127           /* disable XON/XOFF, so ^S invokes the history search */
3128           tio.c_iflag &= ~(IXON | IXOFF);
3129           tio.c_cc[VMIN] = 1;   /* 1 byte at a time */
3130           tio.c_cc[VTIME] = 0;  /* no timer */
3131           tio.c_cc[VSTOP] = _POSIX_VDISABLE;    /* not ^S */
3132           tio.c_cc[VSTART] = _POSIX_VDISABLE;   /* not ^Q */
3133           tcsetattr (STDIN_FILENO, TCSAFLUSH, &tio);
3134
3135           /* See if we can do ANSI/VT100 output */
3136           term = (u8 *) getenv ("TERM");
3137           if (term != NULL)
3138             {
3139               int len = strlen ((char *) term);
3140               cf->ansi_capable = unix_cli_terminal_type_ansi (term, len);
3141               if (unix_cli_terminal_type_noninteractive (term, len))
3142                 unix_cli_set_session_noninteractive (cf);
3143             }
3144         }
3145       else
3146         {
3147           /* No tty, so make sure the session doesn't have tty-like features */
3148           unix_cli_set_session_noninteractive (cf);
3149         }
3150
3151       /* Send banner and initial prompt */
3152       unix_cli_file_welcome (cm, cf);
3153     }
3154
3155   /* If we have socket config, LISTEN, otherwise, don't */
3156   clib_socket_t *s = &um->cli_listen_socket;
3157   if (s->config && s->config[0] != 0)
3158     {
3159       /* CLI listen. */
3160       clib_file_t template = { 0 };
3161
3162       /* mkdir of file socketu, only under /run  */
3163       if (strncmp (s->config, "/run", 4) == 0)
3164         {
3165           u8 *tmp = format (0, "%s", s->config);
3166           int i = vec_len (tmp);
3167           while (i && tmp[--i] != '/')
3168             ;
3169
3170           tmp[i] = '\0';
3171
3172           if (i)
3173             vlib_unix_recursive_mkdir ((char *) tmp);
3174           vec_free (tmp);
3175         }
3176
3177       s->flags = CLIB_SOCKET_F_IS_SERVER |      /* listen, don't connect */
3178         CLIB_SOCKET_F_ALLOW_GROUP_WRITE;        /* PF_LOCAL socket only */
3179       error = clib_socket_init (s);
3180
3181       if (error)
3182         return error;
3183
3184       template.read_function = unix_cli_listen_read_ready;
3185       template.file_descriptor = s->fd;
3186       template.description = format (0, "cli listener %s", s->config);
3187
3188       clib_file_add (fm, &template);
3189     }
3190
3191   /* Set CLI prompt. */
3192   if (!cm->cli_prompt)
3193     cm->cli_prompt = format (0, "VLIB: ");
3194
3195   return 0;
3196 }
3197
3198 /*?
3199  * This module has no configurable parameters.
3200 ?*/
3201 VLIB_CONFIG_FUNCTION (unix_cli_config, "unix-cli");
3202
3203 /** Called when VPP is shutting down, this restores the system
3204  * terminal state if previously saved.
3205  */
3206 static clib_error_t *
3207 unix_cli_exit (vlib_main_t * vm)
3208 {
3209   unix_main_t *um = &unix_main;
3210
3211   /* If stdin is a tty and we saved the tty state, reset the tty state */
3212   if (isatty (STDIN_FILENO) && um->tio_isset)
3213     tcsetattr (STDIN_FILENO, TCSAFLUSH, &um->tio_stdin);
3214
3215   return 0;
3216 }
3217
3218 VLIB_MAIN_LOOP_EXIT_FUNCTION (unix_cli_exit);
3219
3220 /** Set the CLI prompt.
3221  * @param prompt The C string to set the prompt to.
3222  * @note This setting is global; it impacts all current
3223  *       and future CLI sessions.
3224  */
3225 void
3226 vlib_unix_cli_set_prompt (char *prompt)
3227 {
3228   char *fmt = (prompt[strlen (prompt) - 1] == ' ') ? "%s" : "%s ";
3229   unix_cli_main_t *cm = &unix_cli_main;
3230   if (cm->cli_prompt)
3231     vec_free (cm->cli_prompt);
3232   cm->cli_prompt = format (0, fmt, prompt);
3233 }
3234
3235 /** CLI command to quit the terminal session.
3236  * @note If this is a stdin session then this will
3237  *       shutdown VPP also.
3238  */
3239 static clib_error_t *
3240 unix_cli_quit (vlib_main_t * vm,
3241                unformat_input_t * input, vlib_cli_command_t * cmd)
3242 {
3243   unix_cli_main_t *cm = &unix_cli_main;
3244   unix_cli_file_t *cf = pool_elt_at_index (cm->cli_file_pool,
3245                                            cm->current_input_file_index);
3246
3247   /* Cosmetic: suppress the final prompt from appearing before we die */
3248   cf->is_interactive = 0;
3249   cf->started = 1;
3250
3251   vlib_process_signal_event (vm,
3252                              vlib_current_process (vm),
3253                              UNIX_CLI_PROCESS_EVENT_QUIT,
3254                              cm->current_input_file_index);
3255   return 0;
3256 }
3257
3258 /*?
3259  * Terminates the current CLI session.
3260  *
3261  * If VPP is running in @em interactive mode and this is the console session
3262  * (that is, the session on @c stdin) then this will also terminate VPP.
3263 ?*/
3264 /* *INDENT-OFF* */
3265 VLIB_CLI_COMMAND (unix_cli_quit_command, static) = {
3266   .path = "quit",
3267   .short_help = "Exit CLI",
3268   .function = unix_cli_quit,
3269 };
3270 /* *INDENT-ON* */
3271
3272 /* *INDENT-OFF* */
3273 VLIB_CLI_COMMAND (unix_cli_q_command, static) = {
3274   .path = "q",
3275   .short_help = "Exit CLI",
3276   .function = unix_cli_quit,
3277 };
3278 /* *INDENT-ON* */
3279
3280 /** CLI command to execute a VPP command script. */
3281 static clib_error_t *
3282 unix_cli_exec (vlib_main_t * vm,
3283                unformat_input_t * input, vlib_cli_command_t * cmd)
3284 {
3285   char *file_name;
3286   int fd;
3287   unformat_input_t sub_input;
3288   clib_error_t *error;
3289
3290   file_name = 0;
3291   fd = -1;
3292   error = 0;
3293
3294   if (!unformat (input, "%s", &file_name))
3295     {
3296       error = clib_error_return (0, "expecting file name, got `%U'",
3297                                  format_unformat_error, input);
3298       goto done;
3299     }
3300
3301   fd = open (file_name, O_RDONLY);
3302   if (fd < 0)
3303     {
3304       error = clib_error_return_unix (0, "failed to open `%s'", file_name);
3305       goto done;
3306     }
3307
3308   /* Make sure its a regular file. */
3309   {
3310     struct stat s;
3311
3312     if (fstat (fd, &s) < 0)
3313       {
3314         error = clib_error_return_unix (0, "failed to stat `%s'", file_name);
3315         goto done;
3316       }
3317
3318     if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
3319       {
3320         error = clib_error_return (0, "not a regular file `%s'", file_name);
3321         goto done;
3322       }
3323   }
3324
3325   unformat_init_clib_file (&sub_input, fd);
3326
3327   vlib_cli_input (vm, &sub_input, 0, 0);
3328   unformat_free (&sub_input);
3329
3330 done:
3331   if (fd > 0)
3332     close (fd);
3333   vec_free (file_name);
3334
3335   return error;
3336 }
3337
3338 /*?
3339  * Executes a sequence of CLI commands which are read from a file. If
3340  * a command is unrecognised or otherwise invalid then the usual CLI
3341  * feedback will be generated, however execution of subsequent commands
3342  * from the file will continue.
3343  *
3344  * The VPP code is indifferent to the file location. However, if SELinux
3345  * is enabled, then the file needs to have an SELinux label the VPP
3346  * process is allowed to access. For example, if a file is created in
3347  * '<em>/usr/share/vpp/</em>', it will be allowed. However, files manually
3348  * created in '/tmp/' or '/home/<user>/' will not be accessible by the VPP
3349  * process when SELinux is enabled.
3350  *
3351  * @cliexpar
3352  * Sample file:
3353  * @clistart
3354  * <b><em>$ cat /usr/share/vpp/scripts/gigup.txt</em></b>
3355  * set interface state GigabitEthernet0/8/0 up
3356  * set interface state GigabitEthernet0/9/0 up
3357  * @cliend
3358  * Example of how to execute a set of CLI commands from a file:
3359  * @cliexcmd{exec /usr/share/vpp/scripts/gigup.txt}
3360 ?*/
3361 /* *INDENT-OFF* */
3362 VLIB_CLI_COMMAND (cli_exec, static) = {
3363   .path = "exec",
3364   .short_help = "exec <filename>",
3365   .function = unix_cli_exec,
3366   .is_mp_safe = 1,
3367 };
3368 /* *INDENT-ON* */
3369
3370 /** CLI command to show various unix error statistics. */
3371 static clib_error_t *
3372 unix_show_errors (vlib_main_t * vm,
3373                   unformat_input_t * input, vlib_cli_command_t * cmd)
3374 {
3375   unix_main_t *um = &unix_main;
3376   clib_error_t *error = 0;
3377   int i, n_errors_to_show;
3378   unix_error_history_t *unix_errors = 0;
3379
3380   n_errors_to_show = 1 << 30;
3381
3382   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3383     {
3384       if (!unformat (input, "%d", &n_errors_to_show))
3385         {
3386           error =
3387             clib_error_return (0,
3388                                "expecting integer number of errors to show, got `%U'",
3389                                format_unformat_error, input);
3390           goto done;
3391         }
3392     }
3393
3394   n_errors_to_show =
3395     clib_min (ARRAY_LEN (um->error_history), n_errors_to_show);
3396
3397   i =
3398     um->error_history_index >
3399     0 ? um->error_history_index - 1 : ARRAY_LEN (um->error_history) - 1;
3400
3401   while (n_errors_to_show > 0)
3402     {
3403       unix_error_history_t *eh = um->error_history + i;
3404
3405       if (!eh->error)
3406         break;
3407
3408       vec_add1 (unix_errors, eh[0]);
3409       n_errors_to_show -= 1;
3410       if (i == 0)
3411         i = ARRAY_LEN (um->error_history) - 1;
3412       else
3413         i--;
3414     }
3415
3416   if (vec_len (unix_errors) == 0)
3417     vlib_cli_output (vm, "no Unix errors so far");
3418   else
3419     {
3420       vlib_cli_output (vm, "%Ld total errors seen", um->n_total_errors);
3421       for (i = vec_len (unix_errors) - 1; i >= 0; i--)
3422         {
3423           unix_error_history_t *eh = vec_elt_at_index (unix_errors, i);
3424           vlib_cli_output (vm, "%U: %U",
3425                            format_time_interval, "h:m:s:u", eh->time,
3426                            format_clib_error, eh->error);
3427         }
3428       vlib_cli_output (vm, "%U: time now",
3429                        format_time_interval, "h:m:s:u", vlib_time_now (vm));
3430     }
3431
3432 done:
3433   vec_free (unix_errors);
3434   return error;
3435 }
3436
3437 /* *INDENT-OFF* */
3438 VLIB_CLI_COMMAND (cli_unix_show_errors, static) = {
3439   .path = "show unix errors",
3440   .short_help = "Show Unix system call error history",
3441   .function = unix_show_errors,
3442 };
3443 /* *INDENT-ON* */
3444
3445 /** CLI command to show various unix error statistics. */
3446 static clib_error_t *
3447 unix_show_files (vlib_main_t * vm,
3448                  unformat_input_t * input, vlib_cli_command_t * cmd)
3449 {
3450   clib_error_t *error = 0;
3451   clib_file_main_t *fm = &file_main;
3452   clib_file_t *f;
3453   char path[PATH_MAX];
3454   u8 *s = 0;
3455
3456   vlib_cli_output (vm, "%3s %6s %12s %12s %12s %-32s %s", "FD", "Thread",
3457                    "Read", "Write", "Error", "File Name", "Description");
3458
3459   /* *INDENT-OFF* */
3460   pool_foreach (f, fm->file_pool,(
3461    {
3462       int rv;
3463       s = format (s, "/proc/self/fd/%d%c", f->file_descriptor, 0);
3464       rv = readlink((char *) s, path, PATH_MAX - 1);
3465
3466       path[rv < 0 ? 0 : rv] = 0;
3467
3468       vlib_cli_output (vm, "%3d %6d %12d %12d %12d %-32s %v",
3469                        f->file_descriptor, f->polling_thread_index,
3470                        f->read_events, f->write_events, f->error_events,
3471                        path, f->description);
3472       vec_reset_length (s);
3473     }));
3474   /* *INDENT-ON* */
3475   vec_free (s);
3476
3477   return error;
3478 }
3479
3480 /* *INDENT-OFF* */
3481 VLIB_CLI_COMMAND (cli_unix_show_files, static) = {
3482   .path = "show unix files",
3483   .short_help = "Show Unix files in use",
3484   .function = unix_show_files,
3485 };
3486 /* *INDENT-ON* */
3487
3488 /** CLI command to show session command history. */
3489 static clib_error_t *
3490 unix_cli_show_history (vlib_main_t * vm,
3491                        unformat_input_t * input, vlib_cli_command_t * cmd)
3492 {
3493   unix_cli_main_t *cm = &unix_cli_main;
3494   unix_cli_file_t *cf;
3495   int i, j;
3496
3497   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3498
3499   if (!cf->is_interactive)
3500     return clib_error_return (0, "invalid for non-interactive sessions");
3501
3502   if (cf->has_history && cf->history_limit)
3503     {
3504       i = 1 + cf->command_number - vec_len (cf->command_history);
3505       for (j = 0; j < vec_len (cf->command_history); j++)
3506         vlib_cli_output (vm, "%d  %v\n", i + j, cf->command_history[j]);
3507     }
3508   else
3509     {
3510       vlib_cli_output (vm, "History not enabled.\n");
3511     }
3512
3513   return 0;
3514 }
3515
3516 /*?
3517  * Displays the command history for the current session, if any.
3518 ?*/
3519 /* *INDENT-OFF* */
3520 VLIB_CLI_COMMAND (cli_unix_cli_show_history, static) = {
3521   .path = "history",
3522   .short_help = "Show current session command history",
3523   .function = unix_cli_show_history,
3524 };
3525 /* *INDENT-ON* */
3526
3527 /** CLI command to show terminal status. */
3528 static clib_error_t *
3529 unix_cli_show_terminal (vlib_main_t * vm,
3530                         unformat_input_t * input, vlib_cli_command_t * cmd)
3531 {
3532   unix_main_t *um = &unix_main;
3533   unix_cli_main_t *cm = &unix_cli_main;
3534   unix_cli_file_t *cf;
3535   vlib_node_t *n;
3536
3537   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3538   n = vlib_get_node (vm, cf->process_node_index);
3539
3540   vlib_cli_output (vm, "Terminal name:   %v\n", n->name);
3541   vlib_cli_output (vm, "Terminal mode:   %s\n", cf->line_mode ?
3542                    "line-by-line" : "char-by-char");
3543   vlib_cli_output (vm, "Terminal width:  %d\n", cf->width);
3544   vlib_cli_output (vm, "Terminal height: %d\n", cf->height);
3545   vlib_cli_output (vm, "ANSI capable:    %s\n",
3546                    cf->ansi_capable ? "yes" : "no");
3547   vlib_cli_output (vm, "Interactive:     %s\n",
3548                    cf->is_interactive ? "yes" : "no");
3549   vlib_cli_output (vm, "History enabled: %s%s\n",
3550                    cf->has_history ? "yes" : "no", !cf->has_history
3551                    || cf->history_limit ? "" :
3552                    " (disabled by history limit)");
3553   if (cf->has_history)
3554     vlib_cli_output (vm, "History limit:   %d\n", cf->history_limit);
3555   vlib_cli_output (vm, "Pager enabled:   %s%s%s\n",
3556                    cf->no_pager ? "no" : "yes",
3557                    cf->no_pager
3558                    || cf->height ? "" : " (disabled by terminal height)",
3559                    cf->no_pager
3560                    || um->cli_pager_buffer_limit ? "" :
3561                    " (disabled by buffer limit)");
3562   if (!cf->no_pager)
3563     vlib_cli_output (vm, "Pager limit:     %d\n", um->cli_pager_buffer_limit);
3564   vlib_cli_output (vm, "CRLF mode:       %s\n",
3565                    cf->crlf_mode ? "CR+LF" : "LF");
3566
3567   return 0;
3568 }
3569
3570 /*?
3571  * Displays various information about the state of the current terminal
3572  * session.
3573  *
3574  * @cliexpar
3575  * @cliexstart{show terminal}
3576  * Terminal name:   unix-cli-stdin
3577  * Terminal mode:   char-by-char
3578  * Terminal width:  123
3579  * Terminal height: 48
3580  * ANSI capable:    yes
3581  * Interactive:     yes
3582  * History enabled: yes
3583  * History limit:   50
3584  * Pager enabled:   yes
3585  * Pager limit:     100000
3586  * CRLF mode:       LF
3587  * @cliexend
3588 ?*/
3589 /* *INDENT-OFF* */
3590 VLIB_CLI_COMMAND (cli_unix_cli_show_terminal, static) = {
3591   .path = "show terminal",
3592   .short_help = "Show current session terminal settings",
3593   .function = unix_cli_show_terminal,
3594 };
3595 /* *INDENT-ON* */
3596
3597 /** CLI command to display a list of CLI sessions. */
3598 static clib_error_t *
3599 unix_cli_show_cli_sessions (vlib_main_t * vm,
3600                             unformat_input_t * input,
3601                             vlib_cli_command_t * cmd)
3602 {
3603   unix_cli_main_t *cm = &unix_cli_main;
3604   clib_file_main_t *fm = &file_main;
3605   unix_cli_file_t *cf;
3606   clib_file_t *uf;
3607   vlib_node_t *n;
3608
3609   vlib_cli_output (vm, "%-5s %-5s %-20s %s", "PNI", "FD", "Name", "Flags");
3610
3611 #define fl(x, y) ( (x) ? toupper((y)) : tolower((y)) )
3612   /* *INDENT-OFF* */
3613   pool_foreach (cf, cm->cli_file_pool, ({
3614     uf = pool_elt_at_index (fm->file_pool, cf->clib_file_index);
3615     n = vlib_get_node (vm, cf->process_node_index);
3616     vlib_cli_output (vm,
3617                      "%-5d %-5d %-20v %c%c%c%c%c\n",
3618                      cf->process_node_index,
3619                      uf->file_descriptor,
3620                      n->name,
3621                      fl (cf->is_interactive, 'i'),
3622                      fl (cf->is_socket, 's'),
3623                      fl (cf->line_mode, 'l'),
3624                      fl (cf->has_epipe, 'p'),
3625                      fl (cf->ansi_capable, 'a'));
3626   }));
3627   /* *INDENT-ON* */
3628 #undef fl
3629
3630   return 0;
3631 }
3632
3633 /*?
3634  * Displays a summary of all the current CLI sessions.
3635  *
3636  * Typically used to diagnose connection issues with the CLI
3637  * socket.
3638  *
3639  * @cliexpar
3640  * @cliexstart{show cli-sessions}
3641  * PNI   FD    Name                 Flags
3642  * 343   0     unix-cli-stdin       IslpA
3643  * 344   7     unix-cli-local:20    ISlpA
3644  * 346   8     unix-cli-local:21    iSLpa
3645  * @cliexend
3646
3647  * In this example we have the debug console of the running process
3648  * on stdin/out, we have an interactive socket session and we also
3649  * have a non-interactive socket session.
3650  *
3651  * Fields:
3652  *
3653  * - @em PNI: Process node index.
3654  * - @em FD: Unix file descriptor.
3655  * - @em Name: Name of the session.
3656  * - @em Flags: Various flags that describe the state of the session.
3657  *
3658  * @em Flags have the following meanings; lower-case typically negates
3659  * upper-case:
3660  *
3661  * - @em I Interactive session.
3662  * - @em S Connected by socket.
3663  * - @em s Not a socket, likely stdin.
3664  * - @em L Line-by-line mode.
3665  * - @em l Char-by-char mode.
3666  * - @em P EPIPE detected on connection; it will close soon.
3667  * - @em A ANSI-capable terminal.
3668 ?*/
3669 /* *INDENT-OFF* */
3670 VLIB_CLI_COMMAND (cli_unix_cli_show_cli_sessions, static) = {
3671   .path = "show cli-sessions",
3672   .short_help = "Show current CLI sessions",
3673   .function = unix_cli_show_cli_sessions,
3674 };
3675 /* *INDENT-ON* */
3676
3677 /** CLI command to set terminal pager settings. */
3678 static clib_error_t *
3679 unix_cli_set_terminal_pager (vlib_main_t * vm,
3680                              unformat_input_t * input,
3681                              vlib_cli_command_t * cmd)
3682 {
3683   unix_main_t *um = &unix_main;
3684   unix_cli_main_t *cm = &unix_cli_main;
3685   unix_cli_file_t *cf;
3686   unformat_input_t _line_input, *line_input = &_line_input;
3687   clib_error_t *error = 0;
3688
3689   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3690
3691   if (!cf->is_interactive)
3692     return clib_error_return (0, "invalid for non-interactive sessions");
3693
3694   if (!unformat_user (input, unformat_line_input, line_input))
3695     return 0;
3696
3697   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
3698     {
3699       if (unformat (line_input, "on"))
3700         cf->no_pager = 0;
3701       else if (unformat (line_input, "off"))
3702         cf->no_pager = 1;
3703       else if (unformat (line_input, "limit %u", &um->cli_pager_buffer_limit))
3704         vlib_cli_output (vm,
3705                          "Pager limit set to %u lines; note, this is global.\n",
3706                          um->cli_pager_buffer_limit);
3707       else
3708         {
3709           error = clib_error_return (0, "unknown parameter: `%U`",
3710                                      format_unformat_error, line_input);
3711           goto done;
3712         }
3713     }
3714
3715 done:
3716   unformat_free (line_input);
3717
3718   return error;
3719 }
3720
3721 /*?
3722  * Enables or disables the terminal pager for this session. Generally
3723  * this defaults to enabled.
3724  *
3725  * Additionally allows the pager buffer size to be set; though note that
3726  * this value is set globally and not per session.
3727 ?*/
3728 /* *INDENT-OFF* */
3729 VLIB_CLI_COMMAND (cli_unix_cli_set_terminal_pager, static) = {
3730   .path = "set terminal pager",
3731   .short_help = "set terminal pager [on|off] [limit <lines>]",
3732   .function = unix_cli_set_terminal_pager,
3733 };
3734 /* *INDENT-ON* */
3735
3736 /** CLI command to set terminal history settings. */
3737 static clib_error_t *
3738 unix_cli_set_terminal_history (vlib_main_t * vm,
3739                                unformat_input_t * input,
3740                                vlib_cli_command_t * cmd)
3741 {
3742   unix_cli_main_t *cm = &unix_cli_main;
3743   unix_cli_file_t *cf;
3744   unformat_input_t _line_input, *line_input = &_line_input;
3745   u32 limit;
3746   clib_error_t *error = 0;
3747
3748   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3749
3750   if (!cf->is_interactive)
3751     return clib_error_return (0, "invalid for non-interactive sessions");
3752
3753   if (!unformat_user (input, unformat_line_input, line_input))
3754     return 0;
3755
3756   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
3757     {
3758       if (unformat (line_input, "on"))
3759         cf->has_history = 1;
3760       else if (unformat (line_input, "off"))
3761         cf->has_history = 0;
3762       else if (unformat (line_input, "limit %u", &cf->history_limit))
3763         ;
3764       else
3765         {
3766           error = clib_error_return (0, "unknown parameter: `%U`",
3767                                      format_unformat_error, line_input);
3768           goto done;
3769         }
3770
3771     }
3772
3773   /* If we reduced history size, or turned it off, purge the history */
3774   limit = cf->has_history ? cf->history_limit : 0;
3775   if (limit < vec_len (cf->command_history))
3776     {
3777       u32 i;
3778
3779       /* How many items to remove from the start of history */
3780       limit = vec_len (cf->command_history) - limit;
3781
3782       for (i = 0; i < limit; i++)
3783         vec_free (cf->command_history[i]);
3784
3785       vec_delete (cf->command_history, limit, 0);
3786     }
3787
3788 done:
3789   unformat_free (line_input);
3790
3791   return error;
3792 }
3793
3794 /*?
3795  * Enables or disables the command history function of the current
3796  * terminal. Generally this defaults to enabled.
3797  *
3798  * This command also allows the maximum size of the history buffer for
3799  * this session to be altered.
3800 ?*/
3801 /* *INDENT-OFF* */
3802 VLIB_CLI_COMMAND (cli_unix_cli_set_terminal_history, static) = {
3803   .path = "set terminal history",
3804   .short_help = "set terminal history [on|off] [limit <lines>]",
3805   .function = unix_cli_set_terminal_history,
3806 };
3807 /* *INDENT-ON* */
3808
3809 /** CLI command to set terminal ANSI settings. */
3810 static clib_error_t *
3811 unix_cli_set_terminal_ansi (vlib_main_t * vm,
3812                             unformat_input_t * input,
3813                             vlib_cli_command_t * cmd)
3814 {
3815   unix_cli_main_t *cm = &unix_cli_main;
3816   unix_cli_file_t *cf;
3817
3818   cf = pool_elt_at_index (cm->cli_file_pool, cm->current_input_file_index);
3819
3820   if (!cf->is_interactive)
3821     return clib_error_return (0, "invalid for non-interactive sessions");
3822
3823   if (unformat (input, "on"))
3824     cf->ansi_capable = 1;
3825   else if (unformat (input, "off"))
3826     cf->ansi_capable = 0;
3827   else
3828     return clib_error_return (0, "unknown parameter: `%U`",
3829                               format_unformat_error, input);
3830
3831   return 0;
3832 }
3833
3834 /*?
3835  * Enables or disables the use of ANSI control sequences by this terminal.
3836  * The default will vary based on terminal detection at the start of the
3837  * session.
3838  *
3839  * ANSI control sequences are used in a small number of places to provide,
3840  * for example, color text output and to control the cursor in the pager.
3841 ?*/
3842 /* *INDENT-OFF* */
3843 VLIB_CLI_COMMAND (cli_unix_cli_set_terminal_ansi, static) = {
3844   .path = "set terminal ansi",
3845   .short_help = "set terminal ansi [on|off]",
3846   .function = unix_cli_set_terminal_ansi,
3847 };
3848 /* *INDENT-ON* */
3849
3850
3851 #define MAX_CLI_WAIT 86400
3852 /** CLI command to wait <sec> seconds. Useful for exec script. */
3853 static clib_error_t *
3854 unix_wait_cmd (vlib_main_t * vm,
3855                unformat_input_t * input, vlib_cli_command_t * cmd)
3856 {
3857   unformat_input_t _line_input, *line_input = &_line_input;
3858   f64 sec = 1.0;
3859
3860   if (!unformat_user (input, unformat_line_input, line_input))
3861     return 0;
3862
3863   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
3864     {
3865       if (unformat (line_input, "%f", &sec))
3866         ;
3867       else
3868         return clib_error_return (0, "unknown parameter: `%U`",
3869                                   format_unformat_error, input);
3870     }
3871
3872   if (sec <= 0 || sec > MAX_CLI_WAIT || floor (sec * 1000) / 1000 != sec)
3873     return clib_error_return (0,
3874                               "<sec> must be a positive value and less than 86400 (one day) with no more than msec precision.");
3875
3876   vlib_process_wait_for_event_or_clock (vm, sec);
3877   vlib_cli_output (vm, "waited %.3f sec.", sec);
3878
3879   unformat_free (line_input);
3880   return 0;
3881 }
3882 /* *INDENT-OFF* */
3883 VLIB_CLI_COMMAND (cli_unix_wait_cmd, static) = {
3884   .path = "wait",
3885   .short_help = "wait <sec>",
3886   .function = unix_wait_cmd,
3887 };
3888 /* *INDENT-ON* */
3889
3890 static clib_error_t *
3891 unix_cli_init (vlib_main_t * vm)
3892 {
3893   unix_cli_main_t *cm = &unix_cli_main;
3894
3895   /* Breadcrumb to indicate the new session process
3896    * has not been started */
3897   cm->new_session_process_node_index = ~0;
3898
3899   return 0;
3900 }
3901
3902 VLIB_INIT_FUNCTION (unix_cli_init);
3903
3904 /*
3905  * fd.io coding-style-patch-verification: ON
3906  *
3907  * Local Variables:
3908  * eval: (c-set-style "gnu")
3909  * End:
3910  */