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