src/utils/edit.c

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