src/utils/edit.c

   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 }