xref: /freebsd/contrib/wpa/src/utils/edit.c (revision 7ef62cebc2f965b0f640263e179276928885e33d) 
1 /*
2  * Command line editing and history
3  * Copyright (c) 2010-2011, Jouni Malinen <j@w1.fi>
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8 
9 #include "includes.h"
10 #include <termios.h>
11 
12 #include "common.h"
13 #include "eloop.h"
14 #include "list.h"
15 #include "edit.h"
16 
17 #define CMD_BUF_LEN 4096
18 static char cmdbuf[CMD_BUF_LEN];
19 static int cmdbuf_pos = 0;
20 static int cmdbuf_len = 0;
21 static char currbuf[CMD_BUF_LEN];
22 static int currbuf_valid = 0;
23 static const char *ps2 = NULL;
24 
25 #define HISTORY_MAX 100
26 
27 struct edit_history {
28 	struct dl_list list;
29 	char str[1];
30 };
31 
32 static struct dl_list history_list;
33 static struct edit_history *history_curr;
34 
35 static void *edit_cb_ctx;
36 static void (*edit_cmd_cb)(void *ctx, char *cmd);
37 static void (*edit_eof_cb)(void *ctx);
38 static char ** (*edit_completion_cb)(void *ctx, const char *cmd, int pos) =
39 	NULL;
40 
41 static struct termios prevt, newt;
42 
43 
44 #define CLEAR_END_LINE "\e[K"
45 
46 
47 void edit_clear_line(void)
48 {
49 	int i;
50 	putchar('\r');
51 	for (i = 0; i < cmdbuf_len + 2 + (ps2 ? (int) os_strlen(ps2) : 0); i++)
52 		putchar(' ');
53 }
54 
55 
56 static void move_start(void)
57 {
58 	cmdbuf_pos = 0;
59 	edit_redraw();
60 }
61 
62 
63 static void move_end(void)
64 {
65 	cmdbuf_pos = cmdbuf_len;
66 	edit_redraw();
67 }
68 
69 
70 static void move_left(void)
71 {
72 	if (cmdbuf_pos > 0) {
73 		cmdbuf_pos--;
74 		edit_redraw();
75 	}
76 }
77 
78 
79 static void move_right(void)
80 {
81 	if (cmdbuf_pos < cmdbuf_len) {
82 		cmdbuf_pos++;
83 		edit_redraw();
84 	}
85 }
86 
87 
88 static void move_word_left(void)
89 {
90 	while (cmdbuf_pos > 0 && cmdbuf[cmdbuf_pos - 1] == ' ')
91 		cmdbuf_pos--;
92 	while (cmdbuf_pos > 0 && cmdbuf[cmdbuf_pos - 1] != ' ')
93 		cmdbuf_pos--;
94 	edit_redraw();
95 }
96 
97 
98 static void move_word_right(void)
99 {
100 	while (cmdbuf_pos < cmdbuf_len && cmdbuf[cmdbuf_pos] == ' ')
101 		cmdbuf_pos++;
102 	while (cmdbuf_pos < cmdbuf_len && cmdbuf[cmdbuf_pos] != ' ')
103 		cmdbuf_pos++;
104 	edit_redraw();
105 }
106 
107 
108 static void delete_left(void)
109 {
110 	if (cmdbuf_pos == 0)
111 		return;
112 
113 	edit_clear_line();
114 	os_memmove(cmdbuf + cmdbuf_pos - 1, cmdbuf + cmdbuf_pos,
115 		   cmdbuf_len - cmdbuf_pos);
116 	cmdbuf_pos--;
117 	cmdbuf_len--;
118 	edit_redraw();
119 }
120 
121 
122 static void delete_current(void)
123 {
124 	if (cmdbuf_pos == cmdbuf_len)
125 		return;
126 
127 	edit_clear_line();
128 	os_memmove(cmdbuf + cmdbuf_pos, cmdbuf + cmdbuf_pos + 1,
129 		   cmdbuf_len - cmdbuf_pos);
130 	cmdbuf_len--;
131 	edit_redraw();
132 }
133 
134 
135 static void delete_word(void)
136 {
137 	int pos;
138 
139 	edit_clear_line();
140 	pos = cmdbuf_pos;
141 	while (pos > 0 && cmdbuf[pos - 1] == ' ')
142 		pos--;
143 	while (pos > 0 && cmdbuf[pos - 1] != ' ')
144 		pos--;
145 	os_memmove(cmdbuf + pos, cmdbuf + cmdbuf_pos, cmdbuf_len - cmdbuf_pos);
146 	cmdbuf_len -= cmdbuf_pos - pos;
147 	cmdbuf_pos = pos;
148 	edit_redraw();
149 }
150 
151 
152 static void clear_left(void)
153 {
154 	if (cmdbuf_pos == 0)
155 		return;
156 
157 	edit_clear_line();
158 	os_memmove(cmdbuf, cmdbuf + cmdbuf_pos, cmdbuf_len - cmdbuf_pos);
159 	cmdbuf_len -= cmdbuf_pos;
160 	cmdbuf_pos = 0;
161 	edit_redraw();
162 }
163 
164 
165 static void clear_right(void)
166 {
167 	if (cmdbuf_pos == cmdbuf_len)
168 		return;
169 
170 	edit_clear_line();
171 	cmdbuf_len = cmdbuf_pos;
172 	edit_redraw();
173 }
174 
175 
176 static void history_add(const char *str)
177 {
178 	struct edit_history *h, *match = NULL, *last = NULL;
179 	size_t len, count = 0;
180 
181 	if (str[0] == '\0')
182 		return;
183 
184 	dl_list_for_each(h, &history_list, struct edit_history, list) {
185 		if (os_strcmp(str, h->str) == 0) {
186 			match = h;
187 			break;
188 		}
189 		last = h;
190 		count++;
191 	}
192 
193 	if (match) {
194 		dl_list_del(&h->list);
195 		dl_list_add(&history_list, &h->list);
196 		history_curr = h;
197 		return;
198 	}
199 
200 	if (count >= HISTORY_MAX && last) {
201 		dl_list_del(&last->list);
202 		os_free(last);
203 	}
204 
205 	len = os_strlen(str);
206 	h = os_zalloc(sizeof(*h) + len);
207 	if (h == NULL)
208 		return;
209 	dl_list_add(&history_list, &h->list);
210 	os_strlcpy(h->str, str, len + 1);
211 	history_curr = h;
212 }
213 
214 
215 static void history_use(void)
216 {
217 	edit_clear_line();
218 	cmdbuf_len = cmdbuf_pos = os_strlen(history_curr->str);
219 	os_memcpy(cmdbuf, history_curr->str, cmdbuf_len);
220 	edit_redraw();
221 }
222 
223 
224 static void history_prev(void)
225 {
226 	if (history_curr == NULL)
227 		return;
228 
229 	if (history_curr ==
230 	    dl_list_first(&history_list, struct edit_history, list)) {
231 		if (!currbuf_valid) {
232 			cmdbuf[cmdbuf_len] = '\0';
233 			os_memcpy(currbuf, cmdbuf, cmdbuf_len + 1);
234 			currbuf_valid = 1;
235 			history_use();
236 			return;
237 		}
238 	}
239 
240 	if (history_curr ==
241 	    dl_list_last(&history_list, struct edit_history, list))
242 		return;
243 
244 	history_curr = dl_list_entry(history_curr->list.next,
245 				     struct edit_history, list);
246 	history_use();
247 }
248 
249 
250 static void history_next(void)
251 {
252 	if (history_curr == NULL ||
253 	    history_curr ==
254 	    dl_list_first(&history_list, struct edit_history, list)) {
255 		if (currbuf_valid) {
256 			currbuf_valid = 0;
257 			edit_clear_line();
258 			cmdbuf_len = cmdbuf_pos = os_strlen(currbuf);
259 			os_memcpy(cmdbuf, currbuf, cmdbuf_len);
260 			edit_redraw();
261 		}
262 		return;
263 	}
264 
265 	history_curr = dl_list_entry(history_curr->list.prev,
266 				     struct edit_history, list);
267 	history_use();
268 }
269 
270 
271 static void history_read(const char *fname)
272 {
273 	FILE *f;
274 	char buf[CMD_BUF_LEN], *pos;
275 
276 	f = fopen(fname, "r");
277 	if (f == NULL)
278 		return;
279 
280 	while (fgets(buf, CMD_BUF_LEN, f)) {
281 		for (pos = buf; *pos; pos++) {
282 			if (*pos == '\r' || *pos == '\n') {
283 				*pos = '\0';
284 				break;
285 			}
286 		}
287 		history_add(buf);
288 	}
289 
290 	fclose(f);
291 }
292 
293 
294 static void history_write(const char *fname,
295 			  int (*filter_cb)(void *ctx, const char *cmd))
296 {
297 	FILE *f;
298 	struct edit_history *h;
299 
300 	f = fopen(fname, "w");
301 	if (f == NULL)
302 		return;
303 
304 	dl_list_for_each_reverse(h, &history_list, struct edit_history, list) {
305 		if (filter_cb && filter_cb(edit_cb_ctx, h->str))
306 			continue;
307 		fprintf(f, "%s\n", h->str);
308 	}
309 
310 	fclose(f);
311 }
312 
313 
314 static void history_debug_dump(void)
315 {
316 	struct edit_history *h;
317 	edit_clear_line();
318 	printf("\r");
319 	dl_list_for_each_reverse(h, &history_list, struct edit_history, list)
320 		printf("%s%s\n", h == history_curr ? "[C]" : "", h->str);
321 	if (currbuf_valid)
322 		printf("{%s}\n", currbuf);
323 	edit_redraw();
324 }
325 
326 
327 static void insert_char(int c)
328 {
329 	if (cmdbuf_len >= (int) sizeof(cmdbuf) - 1)
330 		return;
331 	if (cmdbuf_len == cmdbuf_pos) {
332 		cmdbuf[cmdbuf_pos++] = c;
333 		cmdbuf_len++;
334 		putchar(c);
335 		fflush(stdout);
336 	} else {
337 		os_memmove(cmdbuf + cmdbuf_pos + 1, cmdbuf + cmdbuf_pos,
338 			   cmdbuf_len - cmdbuf_pos);
339 		cmdbuf[cmdbuf_pos++] = c;
340 		cmdbuf_len++;
341 		edit_redraw();
342 	}
343 }
344 
345 
346 static void process_cmd(void)
347 {
348 	currbuf_valid = 0;
349 	if (cmdbuf_len == 0) {
350 		printf("\n%s> ", ps2 ? ps2 : "");
351 		fflush(stdout);
352 		return;
353 	}
354 	printf("\n");
355 	cmdbuf[cmdbuf_len] = '\0';
356 	history_add(cmdbuf);
357 	cmdbuf_pos = 0;
358 	cmdbuf_len = 0;
359 	edit_cmd_cb(edit_cb_ctx, cmdbuf);
360 	printf("%s> ", ps2 ? ps2 : "");
361 	fflush(stdout);
362 }
363 
364 
365 static void free_completions(char **c)
366 {
367 	int i;
368 	if (c == NULL)
369 		return;
370 	for (i = 0; c[i]; i++)
371 		os_free(c[i]);
372 	os_free(c);
373 }
374 
375 
376 static int filter_strings(char **c, char *str, size_t len)
377 {
378 	int i, j;
379 
380 	for (i = 0, j = 0; c[j]; j++) {
381 		if (os_strncasecmp(c[j], str, len) == 0) {
382 			if (i != j) {
383 				c[i] = c[j];
384 				c[j] = NULL;
385 			}
386 			i++;
387 		} else {
388 			os_free(c[j]);
389 			c[j] = NULL;
390 		}
391 	}
392 	c[i] = NULL;
393 	return i;
394 }
395 
396 
397 static int common_len(const char *a, const char *b)
398 {
399 	int len = 0;
400 	while (a[len] && a[len] == b[len])
401 		len++;
402 	return len;
403 }
404 
405 
406 static int max_common_length(char **c)
407 {
408 	int len, i;
409 
410 	len = os_strlen(c[0]);
411 	for (i = 1; c[i]; i++) {
412 		int same = common_len(c[0], c[i]);
413 		if (same < len)
414 			len = same;
415 	}
416 
417 	return len;
418 }
419 
420 
421 static int cmp_str(const void *a, const void *b)
422 {
423 	return os_strcmp(* (const char **) a, * (const char **) b);
424 }
425 
426 static void complete(int list)
427 {
428 	char **c;
429 	int i, len, count;
430 	int start, end;
431 	int room, plen, add_space;
432 
433 	if (edit_completion_cb == NULL)
434 		return;
435 
436 	cmdbuf[cmdbuf_len] = '\0';
437 	c = edit_completion_cb(edit_cb_ctx, cmdbuf, cmdbuf_pos);
438 	if (c == NULL)
439 		return;
440 
441 	end = cmdbuf_pos;
442 	start = end;
443 	while (start > 0 && cmdbuf[start - 1] != ' ')
444 		start--;
445 	plen = end - start;
446 
447 	count = filter_strings(c, &cmdbuf[start], plen);
448 	if (count == 0) {
449 		free_completions(c);
450 		return;
451 	}
452 
453 	len = max_common_length(c);
454 	if (len <= plen && count > 1) {
455 		if (list) {
456 			qsort(c, count, sizeof(char *), cmp_str);
457 			edit_clear_line();
458 			printf("\r");
459 			for (i = 0; c[i]; i++)
460 				printf("%s%s", i > 0 ? " " : "", c[i]);
461 			printf("\n");
462 			edit_redraw();
463 		}
464 		free_completions(c);
465 		return;
466 	}
467 	len -= plen;
468 
469 	room = sizeof(cmdbuf) - 1 - cmdbuf_len;
470 	if (room < len)
471 		len = room;
472 	add_space = count == 1 && len < room;
473 
474 	os_memmove(cmdbuf + cmdbuf_pos + len + add_space, cmdbuf + cmdbuf_pos,
475 		   cmdbuf_len - cmdbuf_pos);
476 	os_memcpy(&cmdbuf[cmdbuf_pos - plen], c[0], plen + len);
477 	if (add_space)
478 		cmdbuf[cmdbuf_pos + len] = ' ';
479 
480 	cmdbuf_pos += len + add_space;
481 	cmdbuf_len += len + add_space;
482 
483 	edit_redraw();
484 
485 	free_completions(c);
486 }
487 
488 
489 enum edit_key_code {
490 	EDIT_KEY_NONE = 256,
491 	EDIT_KEY_TAB,
492 	EDIT_KEY_UP,
493 	EDIT_KEY_DOWN,
494 	EDIT_KEY_RIGHT,
495 	EDIT_KEY_LEFT,
496 	EDIT_KEY_ENTER,
497 	EDIT_KEY_BACKSPACE,
498 	EDIT_KEY_INSERT,
499 	EDIT_KEY_DELETE,
500 	EDIT_KEY_HOME,
501 	EDIT_KEY_END,
502 	EDIT_KEY_PAGE_UP,
503 	EDIT_KEY_PAGE_DOWN,
504 	EDIT_KEY_F1,
505 	EDIT_KEY_F2,
506 	EDIT_KEY_F3,
507 	EDIT_KEY_F4,
508 	EDIT_KEY_F5,
509 	EDIT_KEY_F6,
510 	EDIT_KEY_F7,
511 	EDIT_KEY_F8,
512 	EDIT_KEY_F9,
513 	EDIT_KEY_F10,
514 	EDIT_KEY_F11,
515 	EDIT_KEY_F12,
516 	EDIT_KEY_CTRL_UP,
517 	EDIT_KEY_CTRL_DOWN,
518 	EDIT_KEY_CTRL_RIGHT,
519 	EDIT_KEY_CTRL_LEFT,
520 	EDIT_KEY_CTRL_A,
521 	EDIT_KEY_CTRL_B,
522 	EDIT_KEY_CTRL_D,
523 	EDIT_KEY_CTRL_E,
524 	EDIT_KEY_CTRL_F,
525 	EDIT_KEY_CTRL_G,
526 	EDIT_KEY_CTRL_H,
527 	EDIT_KEY_CTRL_J,
528 	EDIT_KEY_CTRL_K,
529 	EDIT_KEY_CTRL_L,
530 	EDIT_KEY_CTRL_N,
531 	EDIT_KEY_CTRL_O,
532 	EDIT_KEY_CTRL_P,
533 	EDIT_KEY_CTRL_R,
534 	EDIT_KEY_CTRL_T,
535 	EDIT_KEY_CTRL_U,
536 	EDIT_KEY_CTRL_V,
537 	EDIT_KEY_CTRL_W,
538 	EDIT_KEY_ALT_UP,
539 	EDIT_KEY_ALT_DOWN,
540 	EDIT_KEY_ALT_RIGHT,
541 	EDIT_KEY_ALT_LEFT,
542 	EDIT_KEY_SHIFT_UP,
543 	EDIT_KEY_SHIFT_DOWN,
544 	EDIT_KEY_SHIFT_RIGHT,
545 	EDIT_KEY_SHIFT_LEFT,
546 	EDIT_KEY_ALT_SHIFT_UP,
547 	EDIT_KEY_ALT_SHIFT_DOWN,
548 	EDIT_KEY_ALT_SHIFT_RIGHT,
549 	EDIT_KEY_ALT_SHIFT_LEFT,
550 	EDIT_KEY_EOF
551 };
552 
553 static void show_esc_buf(const char *esc_buf, char c, int i)
554 {
555 	edit_clear_line();
556 	printf("\rESC buffer '%s' c='%c' [%d]\n", esc_buf, c, i);
557 	edit_redraw();
558 }
559 
560 
561 static enum edit_key_code esc_seq_to_key1_no(char last)
562 {
563 	switch (last) {
564 	case 'A':
565 		return EDIT_KEY_UP;
566 	case 'B':
567 		return EDIT_KEY_DOWN;
568 	case 'C':
569 		return EDIT_KEY_RIGHT;
570 	case 'D':
571 		return EDIT_KEY_LEFT;
572 	default:
573 		return EDIT_KEY_NONE;
574 	}
575 }
576 
577 
578 static enum edit_key_code esc_seq_to_key1_shift(char last)
579 {
580 	switch (last) {
581 	case 'A':
582 		return EDIT_KEY_SHIFT_UP;
583 	case 'B':
584 		return EDIT_KEY_SHIFT_DOWN;
585 	case 'C':
586 		return EDIT_KEY_SHIFT_RIGHT;
587 	case 'D':
588 		return EDIT_KEY_SHIFT_LEFT;
589 	default:
590 		return EDIT_KEY_NONE;
591 	}
592 }
593 
594 
595 static enum edit_key_code esc_seq_to_key1_alt(char last)
596 {
597 	switch (last) {
598 	case 'A':
599 		return EDIT_KEY_ALT_UP;
600 	case 'B':
601 		return EDIT_KEY_ALT_DOWN;
602 	case 'C':
603 		return EDIT_KEY_ALT_RIGHT;
604 	case 'D':
605 		return EDIT_KEY_ALT_LEFT;
606 	default:
607 		return EDIT_KEY_NONE;
608 	}
609 }
610 
611 
612 static enum edit_key_code esc_seq_to_key1_alt_shift(char last)
613 {
614 	switch (last) {
615 	case 'A':
616 		return EDIT_KEY_ALT_SHIFT_UP;
617 	case 'B':
618 		return EDIT_KEY_ALT_SHIFT_DOWN;
619 	case 'C':
620 		return EDIT_KEY_ALT_SHIFT_RIGHT;
621 	case 'D':
622 		return EDIT_KEY_ALT_SHIFT_LEFT;
623 	default:
624 		return EDIT_KEY_NONE;
625 	}
626 }
627 
628 
629 static enum edit_key_code esc_seq_to_key1_ctrl(char last)
630 {
631 	switch (last) {
632 	case 'A':
633 		return EDIT_KEY_CTRL_UP;
634 	case 'B':
635 		return EDIT_KEY_CTRL_DOWN;
636 	case 'C':
637 		return EDIT_KEY_CTRL_RIGHT;
638 	case 'D':
639 		return EDIT_KEY_CTRL_LEFT;
640 	default:
641 		return EDIT_KEY_NONE;
642 	}
643 }
644 
645 
646 static enum edit_key_code esc_seq_to_key1(int param1, int param2, char last)
647 {
648 	/* ESC-[<param1>;<param2><last> */
649 
650 	if (param1 < 0 && param2 < 0)
651 		return esc_seq_to_key1_no(last);
652 
653 	if (param1 == 1 && param2 == 2)
654 		return esc_seq_to_key1_shift(last);
655 
656 	if (param1 == 1 && param2 == 3)
657 		return esc_seq_to_key1_alt(last);
658 
659 	if (param1 == 1 && param2 == 4)
660 		return esc_seq_to_key1_alt_shift(last);
661 
662 	if (param1 == 1 && param2 == 5)
663 		return esc_seq_to_key1_ctrl(last);
664 
665 	if (param2 < 0) {
666 		if (last != '~')
667 			return EDIT_KEY_NONE;
668 		switch (param1) {
669 		case 2:
670 			return EDIT_KEY_INSERT;
671 		case 3:
672 			return EDIT_KEY_DELETE;
673 		case 5:
674 			return EDIT_KEY_PAGE_UP;
675 		case 6:
676 			return EDIT_KEY_PAGE_DOWN;
677 		case 15:
678 			return EDIT_KEY_F5;
679 		case 17:
680 			return EDIT_KEY_F6;
681 		case 18:
682 			return EDIT_KEY_F7;
683 		case 19:
684 			return EDIT_KEY_F8;
685 		case 20:
686 			return EDIT_KEY_F9;
687 		case 21:
688 			return EDIT_KEY_F10;
689 		case 23:
690 			return EDIT_KEY_F11;
691 		case 24:
692 			return EDIT_KEY_F12;
693 		}
694 	}
695 
696 	return EDIT_KEY_NONE;
697 }
698 
699 
700 static enum edit_key_code esc_seq_to_key2(int param1, int param2, char last)
701 {
702 	/* ESC-O<param1>;<param2><last> */
703 
704 	if (param1 >= 0 || param2 >= 0)
705 		return EDIT_KEY_NONE;
706 
707 	switch (last) {
708 	case 'F':
709 		return EDIT_KEY_END;
710 	case 'H':
711 		return EDIT_KEY_HOME;
712 	case 'P':
713 		return EDIT_KEY_F1;
714 	case 'Q':
715 		return EDIT_KEY_F2;
716 	case 'R':
717 		return EDIT_KEY_F3;
718 	case 'S':
719 		return EDIT_KEY_F4;
720 	default:
721 		return EDIT_KEY_NONE;
722 	}
723 }
724 
725 
726 static enum edit_key_code esc_seq_to_key(char *seq)
727 {
728 	char last, *pos;
729 	int param1 = -1, param2 = -1;
730 	enum edit_key_code ret = EDIT_KEY_NONE;
731 
732 	last = '\0';
733 	for (pos = seq; *pos; pos++)
734 		last = *pos;
735 
736 	if (seq[1] >= '0' && seq[1] <= '9') {
737 		param1 = atoi(&seq[1]);
738 		pos = os_strchr(seq, ';');
739 		if (pos)
740 			param2 = atoi(pos + 1);
741 	}
742 
743 	if (seq[0] == '[')
744 		ret = esc_seq_to_key1(param1, param2, last);
745 	else if (seq[0] == 'O')
746 		ret = esc_seq_to_key2(param1, param2, last);
747 
748 	if (ret != EDIT_KEY_NONE)
749 		return ret;
750 
751 	edit_clear_line();
752 	printf("\rUnknown escape sequence '%s'\n", seq);
753 	edit_redraw();
754 	return EDIT_KEY_NONE;
755 }
756 
757 
758 static enum edit_key_code edit_read_key(int sock)
759 {
760 	int c;
761 	unsigned char buf[1];
762 	int res;
763 	static int esc = -1;
764 	static char esc_buf[7];
765 
766 	res = read(sock, buf, 1);
767 	if (res < 0)
768 		perror("read");
769 	if (res <= 0)
770 		return EDIT_KEY_EOF;
771 
772 	c = buf[0];
773 
774 	if (esc >= 0) {
775 		if (c == 27 /* ESC */) {
776 			esc = 0;
777 			return EDIT_KEY_NONE;
778 		}
779 
780 		if (esc == 6) {
781 			show_esc_buf(esc_buf, c, 0);
782 			esc = -1;
783 		} else {
784 			esc_buf[esc++] = c;
785 			esc_buf[esc] = '\0';
786 		}
787 	}
788 
789 	if (esc == 1) {
790 		if (esc_buf[0] != '[' && esc_buf[0] != 'O') {
791 			show_esc_buf(esc_buf, c, 1);
792 			esc = -1;
793 			return EDIT_KEY_NONE;
794 		} else
795 			return EDIT_KEY_NONE; /* Escape sequence continues */
796 	}
797 
798 	if (esc > 1) {
799 		if ((c >= '0' && c <= '9') || c == ';')
800 			return EDIT_KEY_NONE; /* Escape sequence continues */
801 
802 		if (c == '~' || (c >= 'A' && c <= 'Z')) {
803 			esc = -1;
804 			return esc_seq_to_key(esc_buf);
805 		}
806 
807 		show_esc_buf(esc_buf, c, 2);
808 		esc = -1;
809 		return EDIT_KEY_NONE;
810 	}
811 
812 	switch (c) {
813 	case 1:
814 		return EDIT_KEY_CTRL_A;
815 	case 2:
816 		return EDIT_KEY_CTRL_B;
817 	case 4:
818 		return EDIT_KEY_CTRL_D;
819 	case 5:
820 		return EDIT_KEY_CTRL_E;
821 	case 6:
822 		return EDIT_KEY_CTRL_F;
823 	case 7:
824 		return EDIT_KEY_CTRL_G;
825 	case 8:
826 		return EDIT_KEY_CTRL_H;
827 	case 9:
828 		return EDIT_KEY_TAB;
829 	case 10:
830 		return EDIT_KEY_CTRL_J;
831 	case 13: /* CR */
832 		return EDIT_KEY_ENTER;
833 	case 11:
834 		return EDIT_KEY_CTRL_K;
835 	case 12:
836 		return EDIT_KEY_CTRL_L;
837 	case 14:
838 		return EDIT_KEY_CTRL_N;
839 	case 15:
840 		return EDIT_KEY_CTRL_O;
841 	case 16:
842 		return EDIT_KEY_CTRL_P;
843 	case 18:
844 		return EDIT_KEY_CTRL_R;
845 	case 20:
846 		return EDIT_KEY_CTRL_T;
847 	case 21:
848 		return EDIT_KEY_CTRL_U;
849 	case 22:
850 		return EDIT_KEY_CTRL_V;
851 	case 23:
852 		return EDIT_KEY_CTRL_W;
853 	case 27: /* ESC */
854 		esc = 0;
855 		return EDIT_KEY_NONE;
856 	case 127:
857 		return EDIT_KEY_BACKSPACE;
858 	default:
859 		return c;
860 	}
861 }
862 
863 
864 static char search_buf[21];
865 static int search_skip;
866 
867 static char * search_find(void)
868 {
869 	struct edit_history *h;
870 	size_t len = os_strlen(search_buf);
871 	int skip = search_skip;
872 
873 	if (len == 0)
874 		return NULL;
875 
876 	dl_list_for_each(h, &history_list, struct edit_history, list) {
877 		if (os_strstr(h->str, search_buf)) {
878 			if (skip == 0)
879 				return h->str;
880 			skip--;
881 		}
882 	}
883 
884 	search_skip = 0;
885 	return NULL;
886 }
887 
888 
889 static void search_redraw(void)
890 {
891 	char *match = search_find();
892 	printf("\rsearch '%s': %s" CLEAR_END_LINE,
893 	       search_buf, match ? match : "");
894 	printf("\rsearch '%s", search_buf);
895 	fflush(stdout);
896 }
897 
898 
899 static void search_start(void)
900 {
901 	edit_clear_line();
902 	search_buf[0] = '\0';
903 	search_skip = 0;
904 	search_redraw();
905 }
906 
907 
908 static void search_clear(void)
909 {
910 	search_redraw();
911 	printf("\r" CLEAR_END_LINE);
912 }
913 
914 
915 static void search_stop(void)
916 {
917 	char *match = search_find();
918 	search_buf[0] = '\0';
919 	search_clear();
920 	if (match) {
921 		os_strlcpy(cmdbuf, match, CMD_BUF_LEN);
922 		cmdbuf_len = os_strlen(cmdbuf);
923 		cmdbuf_pos = cmdbuf_len;
924 	}
925 	edit_redraw();
926 }
927 
928 
929 static void search_cancel(void)
930 {
931 	search_buf[0] = '\0';
932 	search_clear();
933 	edit_redraw();
934 }
935 
936 
937 static void search_backspace(void)
938 {
939 	size_t len;
940 	len = os_strlen(search_buf);
941 	if (len == 0)
942 		return;
943 	search_buf[len - 1] = '\0';
944 	search_skip = 0;
945 	search_redraw();
946 }
947 
948 
949 static void search_next(void)
950 {
951 	search_skip++;
952 	search_find();
953 	search_redraw();
954 }
955 
956 
957 static void search_char(char c)
958 {
959 	size_t len;
960 	len = os_strlen(search_buf);
961 	if (len == sizeof(search_buf) - 1)
962 		return;
963 	search_buf[len] = c;
964 	search_buf[len + 1] = '\0';
965 	search_skip = 0;
966 	search_redraw();
967 }
968 
969 
970 static enum edit_key_code search_key(enum edit_key_code c)
971 {
972 	switch (c) {
973 	case EDIT_KEY_ENTER:
974 	case EDIT_KEY_CTRL_J:
975 	case EDIT_KEY_LEFT:
976 	case EDIT_KEY_RIGHT:
977 	case EDIT_KEY_HOME:
978 	case EDIT_KEY_END:
979 	case EDIT_KEY_CTRL_A:
980 	case EDIT_KEY_CTRL_E:
981 		search_stop();
982 		return c;
983 	case EDIT_KEY_DOWN:
984 	case EDIT_KEY_UP:
985 		search_cancel();
986 		return EDIT_KEY_EOF;
987 	case EDIT_KEY_CTRL_H:
988 	case EDIT_KEY_BACKSPACE:
989 		search_backspace();
990 		break;
991 	case EDIT_KEY_CTRL_R:
992 		search_next();
993 		break;
994 	default:
995 		if (c >= 32 && c <= 255)
996 			search_char(c);
997 		break;
998 	}
999 
1000 	return EDIT_KEY_NONE;
1001 }
1002 
1003 
1004 static void edit_read_char(int sock, void *eloop_ctx, void *sock_ctx)
1005 {
1006 	static int last_tab = 0;
1007 	static int search = 0;
1008 	enum edit_key_code c;
1009 
1010 	c = edit_read_key(sock);
1011 
1012 	if (search) {
1013 		c = search_key(c);
1014 		if (c == EDIT_KEY_NONE)
1015 			return;
1016 		search = 0;
1017 		if (c == EDIT_KEY_EOF)
1018 			return;
1019 	}
1020 
1021 	if (c != EDIT_KEY_TAB && c != EDIT_KEY_NONE)
1022 		last_tab = 0;
1023 
1024 	switch (c) {
1025 	case EDIT_KEY_NONE:
1026 		break;
1027 	case EDIT_KEY_EOF:
1028 		edit_eof_cb(edit_cb_ctx);
1029 		break;
1030 	case EDIT_KEY_TAB:
1031 		complete(last_tab);
1032 		last_tab = 1;
1033 		break;
1034 	case EDIT_KEY_UP:
1035 	case EDIT_KEY_CTRL_P:
1036 		history_prev();
1037 		break;
1038 	case EDIT_KEY_DOWN:
1039 	case EDIT_KEY_CTRL_N:
1040 		history_next();
1041 		break;
1042 	case EDIT_KEY_RIGHT:
1043 	case EDIT_KEY_CTRL_F:
1044 		move_right();
1045 		break;
1046 	case EDIT_KEY_LEFT:
1047 	case EDIT_KEY_CTRL_B:
1048 		move_left();
1049 		break;
1050 	case EDIT_KEY_CTRL_RIGHT:
1051 		move_word_right();
1052 		break;
1053 	case EDIT_KEY_CTRL_LEFT:
1054 		move_word_left();
1055 		break;
1056 	case EDIT_KEY_DELETE:
1057 		delete_current();
1058 		break;
1059 	case EDIT_KEY_END:
1060 		move_end();
1061 		break;
1062 	case EDIT_KEY_HOME:
1063 	case EDIT_KEY_CTRL_A:
1064 		move_start();
1065 		break;
1066 	case EDIT_KEY_F2:
1067 		history_debug_dump();
1068 		break;
1069 	case EDIT_KEY_CTRL_D:
1070 		if (cmdbuf_len > 0) {
1071 			delete_current();
1072 			return;
1073 		}
1074 		printf("\n");
1075 		edit_eof_cb(edit_cb_ctx);
1076 		break;
1077 	case EDIT_KEY_CTRL_E:
1078 		move_end();
1079 		break;
1080 	case EDIT_KEY_CTRL_H:
1081 	case EDIT_KEY_BACKSPACE:
1082 		delete_left();
1083 		break;
1084 	case EDIT_KEY_ENTER:
1085 	case EDIT_KEY_CTRL_J:
1086 		process_cmd();
1087 		break;
1088 	case EDIT_KEY_CTRL_K:
1089 		clear_right();
1090 		break;
1091 	case EDIT_KEY_CTRL_L:
1092 		edit_clear_line();
1093 		edit_redraw();
1094 		break;
1095 	case EDIT_KEY_CTRL_R:
1096 		search = 1;
1097 		search_start();
1098 		break;
1099 	case EDIT_KEY_CTRL_U:
1100 		clear_left();
1101 		break;
1102 	case EDIT_KEY_CTRL_W:
1103 		delete_word();
1104 		break;
1105 	default:
1106 		if (c >= 32 && c <= 255)
1107 			insert_char(c);
1108 		break;
1109 	}
1110 }
1111 
1112 
1113 int edit_init(void (*cmd_cb)(void *ctx, char *cmd),
1114 	      void (*eof_cb)(void *ctx),
1115 	      char ** (*completion_cb)(void *ctx, const char *cmd, int pos),
1116 	      void *ctx, const char *history_file, const char *ps)
1117 {
1118 	currbuf[0] = '\0';
1119 	dl_list_init(&history_list);
1120 	history_curr = NULL;
1121 	if (history_file)
1122 		history_read(history_file);
1123 
1124 	edit_cb_ctx = ctx;
1125 	edit_cmd_cb = cmd_cb;
1126 	edit_eof_cb = eof_cb;
1127 	edit_completion_cb = completion_cb;
1128 
1129 	tcgetattr(STDIN_FILENO, &prevt);
1130 	newt = prevt;
1131 	newt.c_lflag &= ~(ICANON | ECHO);
1132 	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
1133 
1134 	eloop_register_read_sock(STDIN_FILENO, edit_read_char, NULL, NULL);
1135 
1136 	ps2 = ps;
1137 	printf("%s> ", ps2 ? ps2 : "");
1138 	fflush(stdout);
1139 
1140 	return 0;
1141 }
1142 
1143 
1144 void edit_deinit(const char *history_file,
1145 		 int (*filter_cb)(void *ctx, const char *cmd))
1146 {
1147 	struct edit_history *h;
1148 	if (history_file)
1149 		history_write(history_file, filter_cb);
1150 	while ((h = dl_list_first(&history_list, struct edit_history, list))) {
1151 		dl_list_del(&h->list);
1152 		os_free(h);
1153 	}
1154 	edit_clear_line();
1155 	putchar('\r');
1156 	fflush(stdout);
1157 	eloop_unregister_read_sock(STDIN_FILENO);
1158 	tcsetattr(STDIN_FILENO, TCSANOW, &prevt);
1159 }
1160 
1161 
1162 void edit_redraw(void)
1163 {
1164 	char tmp;
1165 	cmdbuf[cmdbuf_len] = '\0';
1166 	printf("\r%s> %s", ps2 ? ps2 : "", cmdbuf);
1167 	if (cmdbuf_pos != cmdbuf_len) {
1168 		tmp = cmdbuf[cmdbuf_pos];
1169 		cmdbuf[cmdbuf_pos] = '\0';
1170 		printf("\r%s> %s", ps2 ? ps2 : "", cmdbuf);
1171 		cmdbuf[cmdbuf_pos] = tmp;
1172 	}
1173 	fflush(stdout);
1174 }
1175