VNFs/DPPD-PROX/input_curses.c

   1 /*
   2 // Copyright (c) 2010-2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include <string.h>
  18 #include <errno.h>
  19 #include <stdlib.h>
  20 #include <fcntl.h>
  21 #include <unistd.h>
  22
  23 #include "log.h"
  24 #include "input.h"
  25 #include "display.h"
  26 #include "run.h"
  27 #include "cmd_parser.h"
  28 #include "input_curses.h"
  29 #include "histedit.h"
  30
  31 #ifdef COMPILED_WITH_MAKE
  32 #include "libedit_autoconf.h"
  33 #endif
  34
  35 static EditLine *el;
  36 static History *hist;
  37
  38 static struct input input_curses;
  39 static int tabbed;
  40
  41 static void show_history(struct input *input)
  42 {
  43         HistEvent event;
  44
  45         history(hist, &event, H_LAST);
  46
  47         do {
  48                 plog_info("%s", event.str); /* event.str contains newline */
  49         } while (history(hist, &event, H_PREV) != -1);
  50 }
  51
  52 static int complete(__attribute__((unused)) int ch)
  53 {
  54         const LineInfo *li;
  55         size_t len;
  56         size_t n_match = 0;
  57         char complete_cmd[128] = {0};
  58         int complete_cmd_partial = 0;
  59
  60         li = el_line(el);
  61         for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
  62                 len = li->lastchar - li->buffer;
  63                 if (strncmp(cmd_parser_cmd(i), li->buffer, len) == 0) {
  64                         if (n_match) {
  65                                 size_t cur_len = strlen(complete_cmd);
  66                                 for (size_t j = 0; j < cur_len; ++j) {
  67                                         if (complete_cmd[j] != cmd_parser_cmd(i)[j]) {
  68                                                 complete_cmd[j] = 0;
  69                                                 complete_cmd_partial = 1;
  70                                                 break;
  71                                         }
  72                                 }
  73                         }
  74                         else {
  75                                 strcpy(complete_cmd, cmd_parser_cmd(i));
  76                         }
  77
  78                         n_match++;
  79                 }
  80         }
  81
  82         /* Complete only if there are more characters known than
  83            currently entered. */
  84         if (n_match && len < strlen(complete_cmd)) {
  85                 el_deletestr(el, li->cursor - li->buffer);
  86                 el_insertstr(el, complete_cmd);
  87                 if (!complete_cmd_partial)
  88                         el_insertstr(el, " ");
  89
  90                 return CC_REDISPLAY;
  91         }
  92         else if (tabbed) {
  93                 int printed = 0;
  94                 for (size_t i = 0; i < cmd_parser_n_cmd(); ++i) {
  95                         len = li->lastchar - li->buffer;
  96                         if (strncmp(cmd_parser_cmd(i), li->buffer, len) == 0) {
  97                                 plog_info("%-23s", cmd_parser_cmd(i));
  98                                 printed++;
  99                         }
 100                         if (printed == 4) {
 101                                 printed = 0;
 102                                 plog_info("\n");
 103                         }
 104                 }
 105                 if (printed)
 106                         plog_info("\n");
 107         }
 108         else {
 109                 tabbed = 1;
 110         }
 111
 112         return CC_REDISPLAY;
 113 }
 114
 115 /* Returns non-zero if stdin is readable */
 116 static int peek_stdin(void)
 117 {
 118         int tmp;
 119         fd_set in_fd;
 120         struct timeval tv;
 121
 122         tv.tv_sec = 0;
 123         tv.tv_usec = 10000;
 124
 125         FD_ZERO(&in_fd);
 126         FD_SET(fileno(stdin), &in_fd);
 127         tmp = select(fileno(stdin) + 1, &in_fd, NULL, NULL, &tv);
 128         return FD_ISSET(fileno(stdin), &in_fd);
 129 }
 130
 131 #ifdef HAVE_LIBEDIT_EL_RFUNC_T
 132 static int do_get_char(EditLine *e, wchar_t *c)
 133 #else
 134 static int get_char(EditLine *e, char *c)
 135 #endif
 136 {
 137         *c = display_getch();
 138
 139         /* If no characters have been entered, number keys switch the
 140            screen and '0' resets stats. This is provided as a
 141            fall-back in case F-keys do not function. The keys are
 142            intercepted before returning control to libedit. */
 143         if (*c >= '0' && *c <= '9') {
 144                 const LineInfo *li;
 145
 146                 li = el_line(e);
 147                 if (li->lastchar == li->buffer) {
 148                         if (*c >= '1') {
 149                                 display_screen(*c - '0' - 1);
 150                                 return 0;
 151                         }
 152                         else {
 153                                 cmd_parser_parse("reset stats", &input_curses);
 154                                 return 0;
 155                         }
 156                 }
 157         }
 158         if (*c == '=') {
 159                 toggle_display_screen();
 160                 return 0;
 161         }
 162
 163         /* Escape by itself is the first character used for more
 164            complex escape sequences like F-keys. libedit can't be used
 165            to detect both ESC as a unitary key and more complex
 166            sequences starting ESC at the same time. */
 167         if (*c == 27 && !peek_stdin()) {
 168                 quit();
 169                 return 0;
 170         }
 171         else if (*c != 9) {
 172                 tabbed = 0;
 173         }
 174
 175         return 1;
 176 }
 177
 178 #ifdef HAVE_LIBEDIT_EL_RFUNC_T
 179 static el_rfunc_t get_char = &do_get_char;
 180 #endif
 181
 182 static void proc_keyboard(struct input *input)
 183 {
 184         const char *line;
 185         const LineInfo *li;
 186         HistEvent hist_event;
 187         int len;
 188
 189         line = el_gets(el, &len);
 190         li = el_line(el);
 191
 192         if (len == 0 || line == NULL) {
 193                 display_cmd("", 0, 0);
 194                 return;
 195         } else if (len > 0) {
 196                 if (len == 1 && line[0] == '\n') {
 197                         display_print_page();
 198                         el_set(el, EL_UNBUFFERED, 0);
 199                         el_set(el, EL_UNBUFFERED, 1);
 200                         return;
 201                 }
 202                 if (line[len-1] == '\n') {
 203                         if (hist) {
 204                                 history(hist, &hist_event, H_ENTER, line);
 205                         }
 206
 207                         char *line2 = strndup(line, len);
 208                         line2[len - 1] = 0; /* replace \n */
 209                         cmd_parser_parse(line2, input);
 210                         free(line2);
 211
 212                         el_set(el, EL_UNBUFFERED, 0);
 213                         el_set(el, EL_UNBUFFERED, 1);
 214                         display_cmd("", 0, 0);
 215                         return;
 216                 }
 217                 if (line[len-1] == 4) {
 218                         return; /* should quit*/
 219                 }
 220         }
 221         else {
 222                 if (errno) {
 223                        return;
 224                 }
 225                 display_cmd("", 0, 0);
 226                 return;
 227         }
 228         display_cmd(line, len, li->cursor - li->buffer);
 229 }
 230
 231 static int key_f1(__attribute__((unused)) int ch) {display_screen(0); return CC_REDISPLAY;}
 232 static int key_f2(__attribute__((unused)) int ch) {display_screen(1); return CC_REDISPLAY;}
 233 static int key_f3(__attribute__((unused)) int ch) {display_screen(2); return CC_REDISPLAY;}
 234 static int key_f4(__attribute__((unused)) int ch) {display_screen(3); return CC_REDISPLAY;}
 235 static int key_f5(__attribute__((unused)) int ch) {display_screen(4); return CC_REDISPLAY;}
 236 static int key_f6(__attribute__((unused)) int ch) {display_screen(5); return CC_REDISPLAY;}
 237 static int key_f7(__attribute__((unused)) int ch) {display_screen(6); return CC_REDISPLAY;}
 238 static int key_f8(__attribute__((unused)) int ch) {display_screen(7); return CC_REDISPLAY;}
 239 static int key_f9(__attribute__((unused)) int ch) {display_screen(8); return CC_REDISPLAY;}
 240 static int key_f10(__attribute__((unused)) int ch) {display_screen(9); return CC_REDISPLAY;}
 241 static int key_f11(__attribute__((unused)) int ch) {display_screen(10); return CC_REDISPLAY;}
 242 static int key_f12(__attribute__((unused)) int ch) {display_screen(11); return CC_REDISPLAY;}
 243
 244 static int key_page_up(__attribute__((unused)) int ch) {display_page_up(); return CC_REDISPLAY;}
 245 static int key_page_down(__attribute__((unused)) int ch) {display_page_down(); return CC_REDISPLAY;}
 246
 247 static void setup_el(void)
 248 {
 249         int pty;
 250         FILE *dev_pty;
 251         HistEvent hist_event;
 252
 253         /* Open a pseudo-terminal for use in libedit. This is required
 254            since the library checks if it is using a tty. If the file
 255            descriptor does not represent a tty, the library disables
 256            editing. */
 257
 258         pty = posix_openpt(O_RDWR);
 259         /* TODO: On error (posix_openpt() < 0), fall-back to
 260            non-libedit implementation. */
 261         grantpt(pty);
 262         unlockpt(pty);
 263         dev_pty = fdopen(pty, "wr");
 264
 265         el = el_init("", dev_pty, dev_pty, dev_pty);
 266
 267         el_set(el, EL_EDITOR, "emacs");
 268
 269         el_set(el, EL_ADDFN, "complete", "Command completion", complete);
 270
 271         el_set(el, EL_ADDFN, "key_f1", "Switch to screen 1", key_f1);
 272         el_set(el, EL_ADDFN, "key_f2", "Switch to screen 2", key_f2);
 273         el_set(el, EL_ADDFN, "key_f3", "Switch to screen 3", key_f3);
 274         el_set(el, EL_ADDFN, "key_f4", "Switch to screen 4", key_f4);
 275         el_set(el, EL_ADDFN, "key_f5", "Switch to screen 5", key_f5);
 276         el_set(el, EL_ADDFN, "key_f6", "Switch to screen 6", key_f6);
 277         el_set(el, EL_ADDFN, "key_f7", "Switch to screen 7", key_f7);
 278         el_set(el, EL_ADDFN, "key_f8", "Switch to screen 8", key_f8);
 279         el_set(el, EL_ADDFN, "key_f9", "Switch to screen 9", key_f5);
 280         el_set(el, EL_ADDFN, "key_f10", "Switch to screen 10", key_f6);
 281         el_set(el, EL_ADDFN, "key_f11", "Switch to screen 11", key_f7);
 282         el_set(el, EL_ADDFN, "key_f12", "Switch to screen 12", key_f8);
 283
 284         el_set(el, EL_ADDFN, "key_page_up", "Page up", key_page_up);
 285         el_set(el, EL_ADDFN, "key_page_down", "Page down", key_page_down);
 286
 287         el_set(el, EL_BIND, "^I", "complete", NULL);
 288         el_set(el, EL_BIND, "^r", "em-inc-search-prev", NULL);
 289
 290         el_set(el, EL_BIND, "^[[11~", "key_f1", NULL);
 291         el_set(el, EL_BIND, "^[[12~", "key_f2", NULL);
 292         el_set(el, EL_BIND, "^[[13~", "key_f3", NULL);
 293         el_set(el, EL_BIND, "^[[14~", "key_f4", NULL);
 294         el_set(el, EL_BIND, "^[[15~", "key_f5", NULL);
 295         el_set(el, EL_BIND, "^[[17~", "key_f6", NULL);
 296         el_set(el, EL_BIND, "^[[18~", "key_f7", NULL);
 297         el_set(el, EL_BIND, "^[[19~", "key_f8", NULL);
 298         el_set(el, EL_BIND, "^[[20~", "key_f9", NULL);
 299         el_set(el, EL_BIND, "^[[21~", "key_f10", NULL);
 300         el_set(el, EL_BIND, "^[[23~", "key_f11", NULL);
 301         el_set(el, EL_BIND, "^[[24~", "key_f12", NULL);
 302
 303         el_set(el, EL_BIND, "^[OP", "key_f1", NULL);
 304         el_set(el, EL_BIND, "^[OQ", "key_f2", NULL);
 305         el_set(el, EL_BIND, "^[OR", "key_f3", NULL);
 306         el_set(el, EL_BIND, "^[OS", "key_f4", NULL);
 307
 308         el_set(el, EL_BIND, "^[[5~", "key_page_up", NULL);
 309         el_set(el, EL_BIND, "^[[6~", "key_page_down", NULL);
 310
 311         hist = history_init();
 312         if (hist) {
 313                 history(hist, &hist_event, H_SETSIZE, 1000);
 314                 el_set(el, EL_HIST, history, hist);
 315         }
 316         el_set(el, EL_UNBUFFERED, 1);
 317         el_set(el, EL_GETCFN, get_char);
 318 }
 319
 320 void reg_input_curses(void)
 321 {
 322         setup_el();
 323
 324         input_curses.fd = fileno(stdin);
 325         input_curses.proc_input = proc_keyboard;
 326         input_curses.history = show_history;
 327
 328         reg_input(&input_curses);
 329 }
 330
 331 void unreg_input_curses(void)
 332 {
 333         history_end(hist);
 334         el_end(el);
 335
 336         unreg_input(&input_curses);
 337 }