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