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