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