0de18e81f6bf4695e2840ce898959ca1999fccb0
[oweals/busybox.git] / cmdedit.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * Termios command line History and Editting, originally 
4  * intended for NetBSD sh (ash)
5  * Copyright (c) 1999
6  *      Main code:            Adam Rogoyski <rogoyski@cs.utexas.edu> 
7  *      Etc:                  Dave Cinege <dcinege@psychosis.com>
8  *  Majorly adjusted/re-written for busybox:
9  *                            Erik Andersen <andersee@debian.org>
10  *
11  * You may use this code as you wish, so long as the original author(s)
12  * are attributed in any redistributions of the source code.
13  * This code is 'as is' with no warranty.
14  * This code may safely be consumed by a BSD or GPL license.
15  *
16  * v 0.5  19990328      Initial release 
17  *
18  * Future plans: Simple file and path name completion. (like BASH)
19  *
20  */
21
22 /*
23    Usage and Known bugs:
24    Terminal key codes are not extensive, and more will probably
25    need to be added. This version was created on Debian GNU/Linux 2.x.
26    Delete, Backspace, Home, End, and the arrow keys were tested
27    to work in an Xterm and console. Ctrl-A also works as Home.
28    Ctrl-E also works as End. The binary size increase is <3K.
29
30    Editting will not display correctly for lines greater then the 
31    terminal width. (more then one line.) However, history will.
32  */
33
34 #include "internal.h"
35 #ifdef BB_FEATURE_SH_COMMAND_EDITING
36
37 #include <stdio.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <sys/ioctl.h>
43 #include <ctype.h>
44 #include <signal.h>
45
46
47 #define  MAX_HISTORY   15               /* Maximum length of the linked list for the command line history */
48
49 #define ESC     27
50 #define DEL     127
51 #define member(c, s) ((c) ? ((char *)strchr ((s), (c)) != (char *)NULL) : 0)
52 #define whitespace(c) (((c) == ' ') || ((c) == '\t'))
53
54 static struct history *his_front = NULL;        /* First element in command line list */
55 static struct history *his_end = NULL;  /* Last element in command line list */
56
57 /* ED: sparc termios is broken: revert back to old termio handling. */
58 #ifdef BB_FEATURE_USE_TERMIOS
59
60 #if #cpu(sparc)
61 #      include <termio.h>
62 #      define termios termio
63 #      define setTermSettings(fd,argp) ioctl(fd,TCSETAF,argp)
64 #      define getTermSettings(fd,argp) ioctl(fd,TCGETA,argp)
65 #else
66 #      include <termios.h>
67 #      define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp)
68 #      define getTermSettings(fd,argp) tcgetattr(fd, argp);
69 #endif
70
71 /* Current termio and the previous termio before starting sh */
72 struct termios initial_settings, new_settings;
73
74
75 #ifndef _POSIX_VDISABLE
76 #define _POSIX_VDISABLE '\0'
77 #endif
78
79 #endif
80
81
82
83 static int cmdedit_termw = 80;  /* actual terminal width */
84 static int cmdedit_scroll = 27; /* width of EOL scrolling region */
85 static int history_counter = 0; /* Number of commands in history list */
86 static int reset_term = 0;              /* Set to true if the terminal needs to be reset upon exit */
87
88 struct history {
89         char *s;
90         struct history *p;
91         struct history *n;
92 };
93
94 #define xwrite write
95
96 /*
97  * TODO: Someday we want to implement 'horizontal scrolling' of the
98  * command-line when the user has typed more than the current width. This
99  * would allow the user to see a 'window' of what he has typed.
100  */
101 void
102 cmdedit_setwidth(int w)
103 {
104         if (w > 20) {
105                 cmdedit_termw = w;
106                 cmdedit_scroll = w / 3;
107         } else {
108                 errorMsg("\n*** Error: minimum screen width is 21\n");
109         }
110 }
111
112
113 void cmdedit_reset_term(void)
114 {
115         if (reset_term)
116                 /* sparc and other have broken termios support: use old termio handling. */
117                 setTermSettings(fileno(stdin), (void*) &initial_settings);
118 }
119
120 void clean_up_and_die(int sig)
121 {
122         cmdedit_reset_term();
123         fprintf(stdout, "\n");
124         if (sig!=SIGINT)
125                 exit(TRUE);
126 }
127
128 /* Go to HOME position */
129 void input_home(int outputFd, int *cursor)
130 {
131         while (*cursor > 0) {
132                 xwrite(outputFd, "\b", 1);
133                 --*cursor;
134         }
135 }
136
137 /* Go to END position */
138 void input_end(int outputFd, int *cursor, int len)
139 {
140         while (*cursor < len) {
141                 xwrite(outputFd, "\033[C", 3);
142                 ++*cursor;
143         }
144 }
145
146 /* Delete the char in back of the cursor */
147 void input_backspace(char* command, int outputFd, int *cursor, int *len)
148 {
149         int j = 0;
150
151 /* Debug crap */
152 //fprintf(stderr, "\nerik: len=%d, cursor=%d, strlen(command)='%d'\n", *len, *cursor, strlen(command));
153 //xwrite(outputFd, command, *len);
154 //*cursor = *len;
155
156
157         if (*cursor > 0) {
158                 xwrite(outputFd, "\b \b", 3);
159                 --*cursor;
160                 memmove(command + *cursor, command + *cursor + 1,
161                                 BUFSIZ - *cursor + 1);
162
163                 for (j = *cursor; j < (BUFSIZ - 1); j++) {
164                         if (!*(command + j))
165                                 break;
166                         else
167                                 xwrite(outputFd, (command + j), 1);
168                 }
169
170                 xwrite(outputFd, " \b", 2);
171
172                 while (j-- > *cursor)
173                         xwrite(outputFd, "\b", 1);
174
175                 --*len;
176         }
177 }
178
179 /* Delete the char in front of the cursor */
180 void input_delete(char* command, int outputFd, int cursor, int *len)
181 {
182         int j = 0;
183
184         if (cursor == *len)
185                 return;
186         
187         memmove(command + cursor, command + cursor + 1,
188                         BUFSIZ - cursor - 1);
189         for (j = cursor; j < (BUFSIZ - 1); j++) {
190                 if (!*(command + j))
191                         break;
192                 else
193                         xwrite(outputFd, (command + j), 1);
194         }
195
196         xwrite(outputFd, " \b", 2);
197
198         while (j-- > cursor)
199                 xwrite(outputFd, "\b", 1);
200         --*len;
201 }
202
203 /* Move forward one charactor */
204 void input_forward(int outputFd, int *cursor, int len)
205 {
206         if (*cursor < len) {
207                 xwrite(outputFd, "\033[C", 3);
208                 ++*cursor;
209         }
210 }
211
212 /* Move back one charactor */
213 void input_backward(int outputFd, int *cursor)
214 {
215         if (*cursor > 0) {
216                 xwrite(outputFd, "\033[D", 3);
217                 --*cursor;
218         }
219 }
220
221
222
223 #ifdef BB_FEATURE_SH_TAB_COMPLETION
224 char** username_tab_completion(char* command, int *num_matches)
225 {
226         char **matches = (char **) NULL;
227         *num_matches=0;
228         fprintf(stderr, "\nin username_tab_completion\n");
229         return (matches);
230 }
231
232 #include <dirent.h>
233 char** exe_n_cwd_tab_completion(char* command, int *num_matches)
234 {
235         char *dirName;
236         char **matches = (char **) NULL;
237         DIR *dir;
238         struct dirent *next;
239                         
240         matches = malloc( sizeof(char*)*50);
241
242         /* Stick a wildcard onto the command, for later use */
243         strcat( command, "*");
244
245         /* Now wall the current directory */
246         dirName = get_current_dir_name();
247         dir = opendir(dirName);
248         if (!dir) {
249                 /* Don't print an error, just shut up and return */
250                 *num_matches=0;
251                 return (matches);
252         }
253         while ((next = readdir(dir)) != NULL) {
254
255                 /* Some quick sanity checks */
256                 if ((strcmp(next->d_name, "..") == 0)
257                         || (strcmp(next->d_name, ".") == 0)) {
258                         continue;
259                 } 
260                 /* See if this matches */
261                 if (check_wildcard_match(next->d_name, command) == TRUE) {
262                         /* Cool, found a match.  Add it to the list */
263                         matches[*num_matches] = malloc(strlen(next->d_name)+1);
264                         strcpy( matches[*num_matches], next->d_name);
265                         ++*num_matches;
266                         //matches = realloc( matches, sizeof(char*)*(*num_matches));
267                 }
268         }
269
270         return (matches);
271 }
272
273 void input_tab(char* command, char* prompt, int outputFd, int *cursor, int *len)
274 {
275         /* Do TAB completion */
276         static int num_matches=0;
277         static char **matches = (char **) NULL;
278         int pos = cursor;
279
280
281         if (lastWasTab == FALSE) {
282                 char *tmp, *tmp1, *matchBuf;
283
284                 /* For now, we will not bother with trying to distinguish
285                  * whether the cursor is in/at a command extression -- we
286                  * will always try all possible matches.  If you don't like
287                  * that then feel free to fix it.
288                  */
289
290                 /* Make a local copy of the string -- up 
291                  * to the position of the cursor */
292                 matchBuf = (char *) calloc(BUFSIZ, sizeof(char));
293                 strncpy(matchBuf, command, cursor);
294                 tmp=matchBuf;
295
296                 /* skip past any command seperator tokens */
297                 while (*tmp && (tmp1=strpbrk(tmp, ";|&{(`")) != NULL) {
298                         tmp=++tmp1;
299                         /* skip any leading white space */
300                         while (*tmp && isspace(*tmp)) 
301                                 ++tmp;
302                 }
303
304                 /* skip any leading white space */
305                 while (*tmp && isspace(*tmp)) 
306                         ++tmp;
307
308                 /* Free up any memory already allocated */
309                 if (matches) {
310                         free(matches);
311                         matches = (char **) NULL;
312                 }
313
314                 /* If the word starts with `~' and there is no slash in the word, 
315                  * then try completing this word as a username. */
316
317                 /* FIXME -- this check is broken! */
318                 if (*tmp == '~' && !strchr(tmp, '/'))
319                         matches = username_tab_completion(tmp, &num_matches);
320
321                 /* Try to match any executable in our path and everything 
322                  * in the current working directory that matches.  */
323                 if (!matches)
324                         matches = exe_n_cwd_tab_completion(tmp, &num_matches);
325
326                 /* Don't leak memory */
327                 free( matchBuf);
328
329                 /* Did we find exactly one match? */
330                 if (matches && num_matches==1) {
331                         /* write out the matched command */
332                         strncpy(command+pos, matches[0]+pos, strlen(matches[0])-pos);
333                         len=strlen(command);
334                         cursor=len;
335                         xwrite(outputFd, matches[0]+pos, strlen(matches[0])-pos);
336                         break;
337                 }
338         } else {
339                 /* Ok -- the last char was a TAB.  Since they
340                  * just hit TAB again, print a list of all the
341                  * available choices... */
342                 if ( matches && num_matches>0 ) {
343                         int i, col;
344
345                         /* Go to the next line */
346                         xwrite(outputFd, "\n", 1);
347                         /* Print the list of matches */
348                         for (i=0,col=0; i<num_matches; i++) {
349                                 char foo[17];
350                                 sprintf(foo, "%-14s  ", matches[i]);
351                                 col += xwrite(outputFd, foo, strlen(foo));
352                                 if (col > 60 && matches[i+1] != NULL) {
353                                         xwrite(outputFd, "\n", 1);
354                                         col = 0;
355                                 }
356                         }
357                         /* Go to the next line */
358                         xwrite(outputFd, "\n", 1);
359                         /* Rewrite the prompt */
360                         xwrite(outputFd, prompt, strlen(prompt));
361                         /* Rewrite the command */
362                         xwrite(outputFd, command, len);
363                         /* Put the cursor back to where it used to be */
364                         for (cursor=len; cursor > pos; cursor--)
365                                 xwrite(outputFd, "\b", 1);
366                 }
367         }
368 }
369 #endif
370
371 void get_previous_history(struct history **hp, char* command)
372 {
373         if ((*hp)->s)
374                 free((*hp)->s);
375         (*hp)->s = strdup(command);
376         *hp = (*hp)->p;
377 }
378
379 void get_next_history(struct history **hp, char* command)
380 {
381         if ((*hp)->s)
382                 free((*hp)->s);
383         (*hp)->s = strdup(command);
384         *hp = (*hp)->n;
385 }
386
387 /*
388  * This function is used to grab a character buffer
389  * from the input file descriptor and allows you to
390  * a string with full command editing (sortof like
391  * a mini readline).
392  *
393  * The following standard commands are not implemented:
394  * ESC-b -- Move back one word
395  * ESC-f -- Move forward one word
396  * ESC-d -- Delete back one word
397  * ESC-h -- Delete forward one word
398  * CTL-t -- Transpose two characters
399  *
400  * Furthermore, the "vi" command editing keys are not implemented.
401  *
402  * TODO: implement TAB command completion. :)
403  */
404 extern void cmdedit_read_input(char* prompt, char command[BUFSIZ])
405 {
406
407         int inputFd=fileno(stdin);
408         int outputFd=fileno(stdout);
409         int nr = 0;
410         int len = 0;
411         int j = 0;
412         int cursor = 0;
413         int break_out = 0;
414         int ret = 0;
415         int lastWasTab = FALSE;
416         char c = 0;
417         struct history *hp = his_end;
418
419         if (!reset_term) {
420                 
421                 getTermSettings(inputFd, (void*) &initial_settings);
422                 memcpy(&new_settings, &initial_settings, sizeof(struct termios));
423                 new_settings.c_cc[VMIN] = 1;
424                 new_settings.c_cc[VTIME] = 0;
425                 new_settings.c_cc[VINTR] = _POSIX_VDISABLE; /* Turn off CTRL-C, so we can trap it */
426                 new_settings.c_lflag &= ~ICANON;        /* unbuffered input */
427                 new_settings.c_lflag &= ~(ECHO|ECHOCTL|ECHONL); /* Turn off echoing */
428                 reset_term = 1;
429         }
430         setTermSettings(inputFd, (void*) &new_settings);
431
432         memset(command, 0, BUFSIZ);
433
434         while (1) {
435
436                 if ((ret = read(inputFd, &c, 1)) < 1)
437                         return;
438                 //fprintf(stderr, "got a '%c' (%d)\n", c, c);
439
440                 switch (c) {
441                 case '\n':
442                 case '\r':
443                         /* Enter */
444                         *(command + len++ + 1) = c;
445                         xwrite(outputFd, &c, 1);
446                         break_out = 1;
447                         break;
448                 case 1:
449                         /* Control-a -- Beginning of line */
450                         input_home(outputFd, &cursor);
451                 case 2:
452                         /* Control-b -- Move back one character */
453                         input_backward(outputFd, &cursor);
454                         break;
455                 case 3:
456                         /* Control-c -- leave the current line, 
457                          * and start over on the next line */ 
458
459                         /* Go to the next line */
460                         xwrite(outputFd, "\n", 1);
461
462                         /* Rewrite the prompt */
463                         xwrite(outputFd, prompt, strlen(prompt));
464
465                         /* Reset the command string */
466                         memset(command, 0, BUFSIZ);
467                         len = cursor = 0;
468
469                         break;
470                 case 4:
471                         /* Control-d -- Delete one character, or exit 
472                          * if the len=0 and no chars to delete */
473                         if (len == 0) {
474                                 xwrite(outputFd, "exit", 4);
475                                 clean_up_and_die(0);
476                         } else {
477                                 input_delete(command, outputFd, cursor, &len);
478                         }
479                         break;
480                 case 5:
481                         /* Control-e -- End of line */
482                         input_end(outputFd, &cursor, len);
483                         break;
484                 case 6:
485                         /* Control-f -- Move forward one character */
486                         input_forward(outputFd, &cursor, len);
487                         break;
488                 case '\b':
489                 case DEL:
490                         /* Control-h and DEL */
491                         input_backspace(command, outputFd, &cursor, &len);
492                         break;
493                 case '\t':
494 #ifdef BB_FEATURE_SH_TAB_COMPLETION
495                         input_tab(command, prompt, outputFd, &cursor, &len);
496 #endif
497                         break;
498                 case 14:
499                         /* Control-n -- Get next command in history */
500                         if (hp && hp->n && hp->n->s) {
501                                 get_next_history(&hp, command);
502                                 goto rewrite_line;
503                         } else {
504                                 xwrite(outputFd, "\007", 1);
505                         }
506                         break;
507                 case 16:
508                         /* Control-p -- Get previous command from history */
509                         if (hp && hp->p) {
510                                 get_previous_history(&hp, command);
511                                 goto rewrite_line;
512                         } else {
513                                 xwrite(outputFd, "\007", 1);
514                         }
515                         break;
516                 case ESC:{
517                                 /* escape sequence follows */
518                                 if ((ret = read(inputFd, &c, 1)) < 1)
519                                         return;
520
521                                 if (c == '[') { /* 91 */
522                                         if ((ret = read(inputFd, &c, 1)) < 1)
523                                                 return;
524
525                                         switch (c) {
526                                         case 'A':
527                                                 /* Up Arrow -- Get previous command from history */
528                                                 if (hp && hp->p) {
529                                                         get_previous_history(&hp, command);
530                                                         goto rewrite_line;
531                                                 } else {
532                                                         xwrite(outputFd, "\007", 1);
533                                                 }
534                                                 break;
535                                         case 'B':
536                                                 /* Down Arrow -- Get next command in history */
537                                                 if (hp && hp->n && hp->n->s) {
538                                                         get_next_history(&hp, command);
539                                                         goto rewrite_line;
540                                                 } else {
541                                                         xwrite(outputFd, "\007", 1);
542                                                 }
543                                                 break;
544
545                                                 /* Rewrite the line with the selected history item */
546                                           rewrite_line:
547                                                 /* erase old command from command line */
548                                                 len = strlen(command)-strlen(hp->s);
549
550                                                 while (len>cursor)
551                                                         input_delete(command, outputFd, cursor, &len);
552                                                 while (cursor>0)
553                                                         input_backspace(command, outputFd, &cursor, &len);
554                                                 input_home(outputFd, &cursor);
555                                                 
556                                                 /* write new command */
557                                                 strcpy(command, hp->s);
558                                                 len = strlen(hp->s);
559                                                 xwrite(outputFd, command, len);
560                                                 cursor = len;
561                                                 break;
562                                         case 'C':
563                                                 /* Right Arrow -- Move forward one character */
564                                                 input_forward(outputFd, &cursor, len);
565                                                 break;
566                                         case 'D':
567                                                 /* Left Arrow -- Move back one character */
568                                                 input_backward(outputFd, &cursor);
569                                                 break;
570                                         case '3':
571                                                 /* Delete */
572                                                 input_delete(command, outputFd, cursor, &len);
573                                                 break;
574                                         case '1':
575                                                 /* Home (Ctrl-A) */
576                                                 input_home(outputFd, &cursor);
577                                                 break;
578                                         case '4':
579                                                 /* End (Ctrl-E) */
580                                                 input_end(outputFd, &cursor, len);
581                                                 break;
582                                         default:
583                                                 xwrite(outputFd, "\007", 1);
584                                         }
585                                         if (c == '1' || c == '3' || c == '4')
586                                                 if ((ret = read(inputFd, &c, 1)) < 1)
587                                                         return; /* read 126 (~) */
588                                 }
589                                 if (c == 'O') {
590                                         /* 79 */
591                                         if ((ret = read(inputFd, &c, 1)) < 1)
592                                                 return;
593                                         switch (c) {
594                                         case 'H':
595                                                 /* Home (xterm) */
596                                                 input_home(outputFd, &cursor);
597                                                 break;
598                                         case 'F':
599                                                 /* End (xterm) */
600                                                 input_end(outputFd, &cursor, len);
601                                                 break;
602                                         default:
603                                                 xwrite(outputFd, "\007", 1);
604                                         }
605                                 }
606                                 c = 0;
607                                 break;
608                         }
609
610                 default:                                /* If it's regular input, do the normal thing */
611
612                         if (!isprint(c)) {      /* Skip non-printable characters */
613                                 break;
614                         }
615
616                         if (len >= (BUFSIZ - 2))        /* Need to leave space for enter */
617                                 break;
618
619                         len++;
620
621                         if (cursor == (len - 1)) {      /* Append if at the end of the line */
622                                 *(command + cursor) = c;
623                         } else {                        /* Insert otherwise */
624                                 memmove(command + cursor + 1, command + cursor,
625                                                 len - cursor - 1);
626
627                                 *(command + cursor) = c;
628
629                                 for (j = cursor; j < len; j++)
630                                         xwrite(outputFd, command + j, 1);
631                                 for (; j > cursor; j--)
632                                         xwrite(outputFd, "\033[D", 3);
633                         }
634
635                         cursor++;
636                         xwrite(outputFd, &c, 1);
637                         break;
638                 }
639                 if (c == '\t')
640                         lastWasTab = TRUE;
641                 else
642                         lastWasTab = FALSE;
643
644                 if (break_out)                  /* Enter is the command terminator, no more input. */
645                         break;
646         }
647
648         nr = len + 1;
649         setTermSettings(inputFd, (void *) &initial_settings);
650         reset_term = 0;
651
652
653         /* Handle command history log */
654         if (*(command)) {
655
656                 struct history *h = his_end;
657
658                 if (!h) {
659                         /* No previous history -- this memory is never freed */
660                         h = his_front = malloc(sizeof(struct history));
661                         h->n = malloc(sizeof(struct history));
662
663                         h->p = NULL;
664                         h->s = strdup(command);
665                         h->n->p = h;
666                         h->n->n = NULL;
667                         h->n->s = NULL;
668                         his_end = h->n;
669                         history_counter++;
670                 } else {
671                         /* Add a new history command -- this memory is never freed */
672                         h->n = malloc(sizeof(struct history));
673
674                         h->n->p = h;
675                         h->n->n = NULL;
676                         h->n->s = NULL;
677                         h->s = strdup(command);
678                         his_end = h->n;
679
680                         /* After max history, remove the oldest command */
681                         if (history_counter >= MAX_HISTORY) {
682
683                                 struct history *p = his_front->n;
684
685                                 p->p = NULL;
686                                 free(his_front->s);
687                                 free(his_front);
688                                 his_front = p;
689                         } else {
690                                 history_counter++;
691                         }
692                 }
693         }
694
695         return;
696 }
697
698 extern void cmdedit_init(void)
699 {
700         atexit(cmdedit_reset_term);
701         signal(SIGKILL, clean_up_and_die);
702         signal(SIGINT, clean_up_and_die);
703         signal(SIGQUIT, clean_up_and_die);
704         signal(SIGTERM, clean_up_and_die);
705 }
706 #endif                                                  /* BB_FEATURE_SH_COMMAND_EDITING */