1/* vi: set sw=4 ts=4: */
2/*
3 * Termios command line History and Editting.
4 *
5 * Copyright (c) 1986-2001 may safely be consumed by a BSD or GPL license.
6 * Written by:   Vladimir Oleynik <dzo@simtreas.ru>
7 *
8 * Used ideas:
9 *      Adam Rogoyski    <rogoyski@cs.utexas.edu>
10 *      Dave Cinege      <dcinege@psychosis.com>
11 *      Jakub Jelinek (c) 1995
12 *      Erik Andersen    <andersee@debian.org> (Majorly adjusted for busybox)
13 *
14 * This code is 'as is' with no warranty.
15 *
16 *
17 */
18
19/*
20   Usage and Known bugs:
21   Terminal key codes are not extensive, and more will probably
22   need to be added. This version was created on Debian GNU/Linux 2.x.
23   Delete, Backspace, Home, End, and the arrow keys were tested
24   to work in an Xterm and console. Ctrl-A also works as Home.
25   Ctrl-E also works as End.
26
27   Small bugs (simple effect):
28   - not true viewing if terminal size (x*y symbols) less
29     size (prompt + editor`s line + 2 symbols)
30   - not true viewing if length prompt less terminal width
31 */
32
33
34#include <stdio.h>
35#include <errno.h>
36#include <unistd.h>
37#include <stdlib.h>
38#include <string.h>
39#include <sys/ioctl.h>
40#include <ctype.h>
41#include <signal.h>
42#include <limits.h>
43
44#include "busybox.h"
45
46#ifdef BB_LOCALE_SUPPORT
47#define Isprint(c) isprint((c))
48#else
49#define Isprint(c) ( (c) >= ' ' && (c) != ((unsigned char)'\233') )
50#endif
51
52#ifndef TEST
53
54#define D(x)
55
56#else
57
58#define BB_FEATURE_COMMAND_EDITING
59#define BB_FEATURE_COMMAND_TAB_COMPLETION
60#define BB_FEATURE_COMMAND_USERNAME_COMPLETION
61#define BB_FEATURE_NONPRINTABLE_INVERSE_PUT
62#define BB_FEATURE_CLEAN_UP
63
64#define D(x)  x
65
66#endif							/* TEST */
67
68#ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
69#include <dirent.h>
70#include <sys/stat.h>
71#endif
72
73#ifdef BB_FEATURE_COMMAND_EDITING
74
75#ifndef BB_FEATURE_COMMAND_TAB_COMPLETION
76#undef  BB_FEATURE_COMMAND_USERNAME_COMPLETION
77#endif
78
79#if defined(BB_FEATURE_COMMAND_USERNAME_COMPLETION) || defined(BB_FEATURE_SH_FANCY_PROMPT)
80#define BB_FEATURE_GETUSERNAME_AND_HOMEDIR
81#endif
82
83#ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
84#       ifndef TEST
85#               include "pwd_grp/pwd.h"
86#       else
87#               include <pwd.h>
88#       endif  /* TEST */
89#endif							/* advanced FEATURES */
90
91
92
93struct history {
94	char *s;
95	struct history *p;
96	struct history *n;
97};
98
99/* Maximum length of the linked list for the command line history */
100static const int MAX_HISTORY = 15;
101
102/* First element in command line list */
103static struct history *his_front = NULL;
104
105/* Last element in command line list */
106static struct history *his_end = NULL;
107
108
109#include <termios.h>
110#define setTermSettings(fd,argp) tcsetattr(fd,TCSANOW,argp)
111#define getTermSettings(fd,argp) tcgetattr(fd, argp);
112
113/* Current termio and the previous termio before starting sh */
114static struct termios initial_settings, new_settings;
115
116
117static
118volatile int cmdedit_termw = 80;	/* actual terminal width */
119static int history_counter = 0;	/* Number of commands in history list */
120static
121volatile int handlers_sets = 0;	/* Set next bites: */
122
123enum {
124	SET_ATEXIT = 1,		/* when atexit() has been called
125				   and get euid,uid,gid to fast compare */
126	SET_WCHG_HANDLERS = 2,  /* winchg signal handler */
127	SET_RESET_TERM = 4,     /* if the terminal needs to be reset upon exit */
128};
129
130
131static int cmdedit_x;		/* real x terminal position */
132static int cmdedit_y;		/* pseudoreal y terminal position */
133static int cmdedit_prmt_len;	/* lenght prompt without colores string */
134
135static int cursor;		/* required global for signal handler */
136static int len;			/* --- "" - - "" - -"- --""-- --""--- */
137static char *command_ps;	/* --- "" - - "" - -"- --""-- --""--- */
138static
139#ifndef BB_FEATURE_SH_FANCY_PROMPT
140	const
141#endif
142char *cmdedit_prompt;		/* --- "" - - "" - -"- --""-- --""--- */
143
144#ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
145static char *user_buf = "";
146static char *home_pwd_buf = "";
147static int my_euid;
148#endif
149
150#ifdef BB_FEATURE_SH_FANCY_PROMPT
151static char *hostname_buf = "";
152static int num_ok_lines = 1;
153#endif
154
155
156#ifdef  BB_FEATURE_COMMAND_TAB_COMPLETION
157
158#ifndef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
159static int my_euid;
160#endif
161
162static int my_uid;
163static int my_gid;
164
165#endif	/* BB_FEATURE_COMMAND_TAB_COMPLETION */
166
167/* It seems that libc5 doesn't know what a sighandler_t is... */
168#if (__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 1)
169typedef void (*sighandler_t) (int);
170#endif
171
172static void cmdedit_setwidth(int w, int redraw_flg);
173
174static void win_changed(int nsig)
175{
176	struct winsize win = { 0, 0, 0, 0 };
177	static sighandler_t previous_SIGWINCH_handler;	/* for reset */
178
179	/*   emulate      || signal call */
180	if (nsig == -SIGWINCH || nsig == SIGWINCH) {
181		ioctl(0, TIOCGWINSZ, &win);
182		if (win.ws_col > 0) {
183			cmdedit_setwidth(win.ws_col, nsig == SIGWINCH);
184		}
185	}
186	/* Unix not all standart in recall signal */
187
188	if (nsig == -SIGWINCH)		/* save previous handler   */
189		previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
190	else if (nsig == SIGWINCH)	/* signaled called handler */
191		signal(SIGWINCH, win_changed);	/* set for next call       */
192	else						/* nsig == 0 */
193		/* set previous handler    */
194		signal(SIGWINCH, previous_SIGWINCH_handler);	/* reset    */
195}
196
197static void cmdedit_reset_term(void)
198{
199	if ((handlers_sets & SET_RESET_TERM) != 0) {
200/* sparc and other have broken termios support: use old termio handling. */
201		setTermSettings(fileno(stdin), (void *) &initial_settings);
202		handlers_sets &= ~SET_RESET_TERM;
203	}
204	if ((handlers_sets & SET_WCHG_HANDLERS) != 0) {
205		/* reset SIGWINCH handler to previous (default) */
206		win_changed(0);
207		handlers_sets &= ~SET_WCHG_HANDLERS;
208	}
209	fflush(stdout);
210#ifdef BB_FEATURE_CLEAN_UP
211	if (his_front) {
212		struct history *n;
213
214		while (his_front != his_end) {
215			n = his_front->n;
216			free(his_front->s);
217			free(his_front);
218			his_front = n;
219		}
220	}
221#endif
222}
223
224
225/* special for recount position for scroll and remove terminal margin effect */
226static void cmdedit_set_out_char(int next_char)
227{
228
229	int c = (int)((unsigned char) command_ps[cursor]);
230
231	if (c == 0)
232		c = ' ';	/* destroy end char? */
233#ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
234	if (!Isprint(c)) {	/* Inverse put non-printable characters */
235		if (c >= 128)
236			c -= 128;
237		if (c < ' ')
238			c += '@';
239		if (c == 127)
240			c = '?';
241		printf("\033[7m%c\033[0m", c);
242	} else
243#endif
244		putchar(c);
245	if (++cmdedit_x >= cmdedit_termw) {
246		/* terminal is scrolled down */
247		cmdedit_y++;
248		cmdedit_x = 0;
249
250		if (!next_char)
251			next_char = ' ';
252		/* destroy "(auto)margin" */
253		putchar(next_char);
254		putchar('\b');
255	}
256	cursor++;
257}
258
259/* Move to end line. Bonus: rewrite line from cursor */
260static void input_end(void)
261{
262	while (cursor < len)
263		cmdedit_set_out_char(0);
264}
265
266/* Go to the next line */
267static void goto_new_line(void)
268{
269	input_end();
270	if (cmdedit_x)
271		putchar('\n');
272}
273
274
275static inline void out1str(const char *s)
276{
277	fputs(s, stdout);
278}
279static inline void beep(void)
280{
281	putchar('\007');
282}
283
284/* Move back one charactor */
285/* special for slow terminal */
286static void input_backward(int num)
287{
288	if (num > cursor)
289		num = cursor;
290	cursor -= num;		/* new cursor (in command, not terminal) */
291
292	if (cmdedit_x >= num) {		/* no to up line */
293		cmdedit_x -= num;
294		if (num < 4)
295			while (num-- > 0)
296				putchar('\b');
297
298		else
299			printf("\033[%dD", num);
300	} else {
301		int count_y;
302
303		if (cmdedit_x) {
304			putchar('\r');		/* back to first terminal pos.  */
305			num -= cmdedit_x;	/* set previous backward        */
306		}
307		count_y = 1 + num / cmdedit_termw;
308		printf("\033[%dA", count_y);
309		cmdedit_y -= count_y;
310		/*  require  forward  after  uping   */
311		cmdedit_x = cmdedit_termw * count_y - num;
312		printf("\033[%dC", cmdedit_x);	/* set term cursor   */
313	}
314}
315
316static void put_prompt(void)
317{
318	out1str(cmdedit_prompt);
319	cmdedit_x = cmdedit_prmt_len;	/* count real x terminal position */
320	cursor = 0;
321	cmdedit_y = 0;                  /* new quasireal y */
322}
323
324#ifndef BB_FEATURE_SH_FANCY_PROMPT
325static void parse_prompt(const char *prmt_ptr)
326{
327	cmdedit_prompt = prmt_ptr;
328	cmdedit_prmt_len = strlen(prmt_ptr);
329	put_prompt();
330}
331#else
332static void parse_prompt(const char *prmt_ptr)
333{
334	int prmt_len = 0;
335	int sub_len = 0;
336	char  flg_not_length = '[';
337	char *prmt_mem_ptr = xcalloc(1, 1);
338	char *pwd_buf = xgetcwd(0);
339	char  buf2[PATH_MAX + 1];
340	char  buf[2];
341	char  c;
342	char *pbuf;
343
344	if (!pwd_buf) {
345		pwd_buf=(char *)unknown;
346	}
347
348	while (*prmt_ptr) {
349		pbuf    = buf;
350		pbuf[1] = 0;
351		c = *prmt_ptr++;
352		if (c == '\\') {
353			const char *cp = prmt_ptr;
354			int l;
355
356			c = process_escape_sequence(&prmt_ptr);
357			if(prmt_ptr==cp) {
358			  if (*cp == 0)
359				break;
360			  c = *prmt_ptr++;
361			  switch (c) {
362#ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
363			  case 'u':
364				pbuf = user_buf;
365				break;
366#endif
367			  case 'h':
368				pbuf = hostname_buf;
369				if (*pbuf == 0) {
370					pbuf = xcalloc(256, 1);
371					if (gethostname(pbuf, 255) < 0) {
372						strcpy(pbuf, "?");
373					} else {
374						char *s = strchr(pbuf, '.');
375
376						if (s)
377							*s = 0;
378					}
379					hostname_buf = pbuf;
380				}
381				break;
382			  case '$':
383				c = my_euid == 0 ? '#' : '$';
384				break;
385#ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
386			  case 'w':
387				pbuf = pwd_buf;
388				l = strlen(home_pwd_buf);
389				if (home_pwd_buf[0] != 0 &&
390				    strncmp(home_pwd_buf, pbuf, l) == 0 &&
391				    (pbuf[l]=='/' || pbuf[l]=='\0') &&
392				    strlen(pwd_buf+l)<PATH_MAX) {
393					pbuf = buf2;
394					*pbuf = '~';
395					strcpy(pbuf+1, pwd_buf+l);
396					}
397				break;
398#endif
399			  case 'W':
400				pbuf = pwd_buf;
401				cp = strrchr(pbuf,'/');
402				if ( (cp != NULL) && (cp != pbuf) )
403					pbuf += (cp-pbuf)+1;
404				break;
405			  case '!':
406				snprintf(pbuf = buf2, sizeof(buf2), "%d", num_ok_lines);
407				break;
408			  case 'e': case 'E':     /* \e \E = \033 */
409				c = '\033';
410				break;
411			  case 'x': case 'X':
412				for (l = 0; l < 3;) {
413					int h;
414					buf2[l++] = *prmt_ptr;
415					buf2[l] = 0;
416					h = strtol(buf2, &pbuf, 16);
417					if (h > UCHAR_MAX || (pbuf - buf2) < l) {
418						l--;
419						break;
420					}
421					prmt_ptr++;
422				}
423				buf2[l] = 0;
424				c = (char)strtol(buf2, 0, 16);
425				if(c==0)
426					c = '?';
427				pbuf = buf;
428				break;
429			  case '[': case ']':
430				if (c == flg_not_length) {
431					flg_not_length = flg_not_length == '[' ? ']' : '[';
432					continue;
433				}
434				break;
435			  }
436			}
437		}
438		if(pbuf == buf)
439			*pbuf = c;
440		prmt_len += strlen(pbuf);
441		prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
442		if (flg_not_length == ']')
443			sub_len++;
444	}
445	if(pwd_buf!=(char *)unknown)
446		free(pwd_buf);
447	cmdedit_prompt = prmt_mem_ptr;
448	cmdedit_prmt_len = prmt_len - sub_len;
449	put_prompt();
450}
451#endif
452
453
454/* draw promt, editor line, and clear tail */
455static void redraw(int y, int back_cursor)
456{
457	if (y > 0)				/* up to start y */
458		printf("\033[%dA", y);
459	putchar('\r');
460	put_prompt();
461	input_end();				/* rewrite */
462	printf("\033[J");			/* destroy tail after cursor */
463	input_backward(back_cursor);
464}
465
466/* Delete the char in front of the cursor */
467static void input_delete(void)
468{
469	int j = cursor;
470
471	if (j == len)
472		return;
473
474	strcpy(command_ps + j, command_ps + j + 1);
475	len--;
476	input_end();			/* rewtite new line */
477	cmdedit_set_out_char(0);	/* destroy end char */
478	input_backward(cursor - j);	/* back to old pos cursor */
479}
480
481/* Delete the char in back of the cursor */
482static void input_backspace(void)
483{
484	if (cursor > 0) {
485		input_backward(1);
486		input_delete();
487	}
488}
489
490
491/* Move forward one charactor */
492static void input_forward(void)
493{
494	if (cursor < len)
495		cmdedit_set_out_char(command_ps[cursor + 1]);
496}
497
498
499static void cmdedit_setwidth(int w, int redraw_flg)
500{
501	cmdedit_termw = cmdedit_prmt_len + 2;
502	if (w <= cmdedit_termw) {
503		cmdedit_termw = cmdedit_termw % w;
504	}
505	if (w > cmdedit_termw) {
506		cmdedit_termw = w;
507
508		if (redraw_flg) {
509			/* new y for current cursor */
510			int new_y = (cursor + cmdedit_prmt_len) / w;
511
512			/* redraw */
513			redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), len - cursor);
514			fflush(stdout);
515		}
516	}
517}
518
519static void cmdedit_init(void)
520{
521	cmdedit_prmt_len = 0;
522	if ((handlers_sets & SET_WCHG_HANDLERS) == 0) {
523		/* emulate usage handler to set handler and call yours work */
524		win_changed(-SIGWINCH);
525		handlers_sets |= SET_WCHG_HANDLERS;
526	}
527
528	if ((handlers_sets & SET_ATEXIT) == 0) {
529#ifdef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
530		struct passwd *entry;
531
532		my_euid = geteuid();
533		entry = getpwuid(my_euid);
534		if (entry) {
535			user_buf = xstrdup(entry->pw_name);
536			home_pwd_buf = xstrdup(entry->pw_dir);
537		}
538#endif
539
540#ifdef  BB_FEATURE_COMMAND_TAB_COMPLETION
541
542#ifndef BB_FEATURE_GETUSERNAME_AND_HOMEDIR
543		my_euid = geteuid();
544#endif
545		my_uid = getuid();
546		my_gid = getgid();
547#endif	/* BB_FEATURE_COMMAND_TAB_COMPLETION */
548		handlers_sets |= SET_ATEXIT;
549		atexit(cmdedit_reset_term);	/* be sure to do this only once */
550	}
551}
552
553#ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
554
555static int is_execute(const struct stat *st)
556{
557	if ((!my_euid && (st->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) ||
558		(my_uid == st->st_uid && (st->st_mode & S_IXUSR)) ||
559		(my_gid == st->st_gid && (st->st_mode & S_IXGRP)) ||
560		(st->st_mode & S_IXOTH)) return TRUE;
561	return FALSE;
562}
563
564#ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
565
566static char **username_tab_completion(char *ud, int *num_matches)
567{
568	struct passwd *entry;
569	int userlen;
570	char *temp;
571
572
573	ud++;				/* ~user/... to user/... */
574	userlen = strlen(ud);
575
576	if (num_matches == 0) {		/* "~/..." or "~user/..." */
577		char *sav_ud = ud - 1;
578		char *home = 0;
579
580		if (*ud == '/') {	/* "~/..."     */
581			home = home_pwd_buf;
582		} else {
583			/* "~user/..." */
584			temp = strchr(ud, '/');
585			*temp = 0;		/* ~user\0 */
586			entry = getpwnam(ud);
587			*temp = '/';		/* restore ~user/... */
588			ud = temp;
589			if (entry)
590				home = entry->pw_dir;
591		}
592		if (home) {
593			if ((userlen + strlen(home) + 1) < BUFSIZ) {
594				char temp2[BUFSIZ];	/* argument size */
595
596				/* /home/user/... */
597				sprintf(temp2, "%s%s", home, ud);
598				strcpy(sav_ud, temp2);
599			}
600		}
601		return 0;	/* void, result save to argument :-) */
602	} else {
603		/* "~[^/]*" */
604		char **matches = (char **) NULL;
605		int nm = 0;
606
607		setpwent();
608
609		while ((entry = getpwent()) != NULL) {
610			/* Null usernames should result in all users as possible completions. */
611			if ( /*!userlen || */ !strncmp(ud, entry->pw_name, userlen)) {
612
613				temp = xmalloc(3 + strlen(entry->pw_name));
614				sprintf(temp, "~%s/", entry->pw_name);
615				matches = xrealloc(matches, (nm + 1) * sizeof(char *));
616
617				matches[nm++] = temp;
618			}
619		}
620
621		endpwent();
622		(*num_matches) = nm;
623		return (matches);
624	}
625}
626#endif	/* BB_FEATURE_COMMAND_USERNAME_COMPLETION */
627
628enum {
629	FIND_EXE_ONLY = 0,
630	FIND_DIR_ONLY = 1,
631	FIND_FILE_ONLY = 2,
632};
633
634static int path_parse(char ***p, int flags)
635{
636	int npth;
637	char *tmp;
638	char *pth;
639
640	/* if not setenv PATH variable, to search cur dir "." */
641	if (flags != FIND_EXE_ONLY || (pth = getenv("PATH")) == 0 ||
642		/* PATH=<empty> or PATH=:<empty> */
643		*pth == 0 || (*pth == ':' && *(pth + 1) == 0)) {
644		return 1;
645	}
646
647	tmp = pth;
648	npth = 0;
649
650	for (;;) {
651		npth++;			/* count words is + 1 count ':' */
652		tmp = strchr(tmp, ':');
653		if (tmp) {
654			if (*++tmp == 0)
655				break;	/* :<empty> */
656		} else
657			break;
658	}
659
660	*p = xmalloc(npth * sizeof(char *));
661
662	tmp = pth;
663	(*p)[0] = xstrdup(tmp);
664	npth = 1;			/* count words is + 1 count ':' */
665
666	for (;;) {
667		tmp = strchr(tmp, ':');
668		if (tmp) {
669			(*p)[0][(tmp - pth)] = 0;	/* ':' -> '\0' */
670			if (*++tmp == 0)
671				break;			/* :<empty> */
672		} else
673			break;
674		(*p)[npth++] = &(*p)[0][(tmp - pth)];	/* p[next]=p[0][&'\0'+1] */
675	}
676
677	return npth;
678}
679
680static char *add_quote_for_spec_chars(char *found)
681{
682	int l = 0;
683	char *s = xmalloc((strlen(found) + 1) * 2);
684
685	while (*found) {
686		if (strchr(" `\"#$%^&*()=+{}[]:;\'|\\<>", *found))
687			s[l++] = '\\';
688		s[l++] = *found++;
689	}
690	s[l] = 0;
691	return s;
692}
693
694static char **exe_n_cwd_tab_completion(char *command, int *num_matches,
695					int type)
696{
697
698	char **matches = 0;
699	DIR *dir;
700	struct dirent *next;
701	char dirbuf[BUFSIZ];
702	int nm = *num_matches;
703	struct stat st;
704	char *path1[1];
705	char **paths = path1;
706	int npaths;
707	int i;
708	char *found;
709	char *pfind = strrchr(command, '/');
710
711	path1[0] = ".";
712
713	if (pfind == NULL) {
714		/* no dir, if flags==EXE_ONLY - get paths, else "." */
715		npaths = path_parse(&paths, type);
716		pfind = command;
717	} else {
718		/* with dir */
719		/* save for change */
720		strcpy(dirbuf, command);
721		/* set dir only */
722		dirbuf[(pfind - command) + 1] = 0;
723#ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
724		if (dirbuf[0] == '~')	/* ~/... or ~user/... */
725			username_tab_completion(dirbuf, 0);
726#endif
727		/* "strip" dirname in command */
728		pfind++;
729
730		paths[0] = dirbuf;
731		npaths = 1;				/* only 1 dir */
732	}
733
734	for (i = 0; i < npaths; i++) {
735
736		dir = opendir(paths[i]);
737		if (!dir)			/* Don't print an error */
738			continue;
739
740		while ((next = readdir(dir)) != NULL) {
741			char *str_found = next->d_name;
742
743			/* matched ? */
744			if (strncmp(str_found, pfind, strlen(pfind)))
745				continue;
746			/* not see .name without .match */
747			if (*str_found == '.' && *pfind == 0) {
748				if (*paths[i] == '/' && paths[i][1] == 0
749					&& str_found[1] == 0) str_found = "";	/* only "/" */
750				else
751					continue;
752			}
753			found = concat_path_file(paths[i], str_found);
754			/* hmm, remover in progress? */
755			if (stat(found, &st) < 0)
756				goto cont;
757			/* find with dirs ? */
758			if (paths[i] != dirbuf)
759				strcpy(found, next->d_name);	/* only name */
760			if (S_ISDIR(st.st_mode)) {
761				/* name is directory      */
762				str_found = found;
763				found = concat_path_file(found, "");
764				free(str_found);
765				str_found = add_quote_for_spec_chars(found);
766			} else {
767				/* not put found file if search only dirs for cd */
768				if (type == FIND_DIR_ONLY)
769					goto cont;
770				str_found = add_quote_for_spec_chars(found);
771				if (type == FIND_FILE_ONLY ||
772					(type == FIND_EXE_ONLY && is_execute(&st) == TRUE))
773					strcat(str_found, " ");
774			}
775			/* Add it to the list */
776			matches = xrealloc(matches, (nm + 1) * sizeof(char *));
777
778			matches[nm++] = str_found;
779cont:
780			free(found);
781		}
782		closedir(dir);
783	}
784	if (paths != path1) {
785		free(paths[0]);			/* allocated memory only in first member */
786		free(paths);
787	}
788	*num_matches = nm;
789	return (matches);
790}
791
792static int match_compare(const void *a, const void *b)
793{
794	return strcmp(*(char **) a, *(char **) b);
795}
796
797
798
799#define QUOT    (UCHAR_MAX+1)
800
801#define collapse_pos(is, in) { \
802	memcpy(int_buf+is, int_buf+in, (BUFSIZ+1-is-in)*sizeof(int)); \
803	memcpy(pos_buf+is, pos_buf+in, (BUFSIZ+1-is-in)*sizeof(int)); }
804
805static int find_match(char *matchBuf, int *len_with_quotes)
806{
807	int i, j;
808	int command_mode;
809	int c, c2;
810	int int_buf[BUFSIZ + 1];
811	int pos_buf[BUFSIZ + 1];
812
813	/* set to integer dimension characters and own positions */
814	for (i = 0;; i++) {
815		int_buf[i] = (int) ((unsigned char) matchBuf[i]);
816		if (int_buf[i] == 0) {
817			pos_buf[i] = -1;	/* indicator end line */
818			break;
819		} else
820			pos_buf[i] = i;
821	}
822
823	/* mask \+symbol and convert '\t' to ' ' */
824	for (i = j = 0; matchBuf[i]; i++, j++)
825		if (matchBuf[i] == '\\') {
826			collapse_pos(j, j + 1);
827			int_buf[j] |= QUOT;
828			i++;
829#ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
830			if (matchBuf[i] == '\t')	/* algorithm equivalent */
831				int_buf[j] = ' ' | QUOT;
832#endif
833		}
834#ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
835		else if (matchBuf[i] == '\t')
836			int_buf[j] = ' ';
837#endif
838
839	/* mask "symbols" or 'symbols' */
840	c2 = 0;
841	for (i = 0; int_buf[i]; i++) {
842		c = int_buf[i];
843		if (c == '\'' || c == '"') {
844			if (c2 == 0)
845				c2 = c;
846			else {
847				if (c == c2)
848					c2 = 0;
849				else
850					int_buf[i] |= QUOT;
851			}
852		} else if (c2 != 0 && c != '$')
853			int_buf[i] |= QUOT;
854	}
855
856	/* skip commands with arguments if line have commands delimiters */
857	/* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */
858	for (i = 0; int_buf[i]; i++) {
859		c = int_buf[i];
860		c2 = int_buf[i + 1];
861		j = i ? int_buf[i - 1] : -1;
862		command_mode = 0;
863		if (c == ';' || c == '&' || c == '|') {
864			command_mode = 1 + (c == c2);
865			if (c == '&') {
866				if (j == '>' || j == '<')
867					command_mode = 0;
868			} else if (c == '|' && j == '>')
869				command_mode = 0;
870		}
871		if (command_mode) {
872			collapse_pos(0, i + command_mode);
873			i = -1;				/* hack incremet */
874		}
875	}
876	/* collapse `command...` */
877	for (i = 0; int_buf[i]; i++)
878		if (int_buf[i] == '`') {
879			for (j = i + 1; int_buf[j]; j++)
880				if (int_buf[j] == '`') {
881					collapse_pos(i, j + 1);
882					j = 0;
883					break;
884				}
885			if (j) {
886				/* not found close ` - command mode, collapse all previous */
887				collapse_pos(0, i + 1);
888				break;
889			} else
890				i--;			/* hack incremet */
891		}
892
893	/* collapse (command...(command...)...) or {command...{command...}...} */
894	c = 0;						/* "recursive" level */
895	c2 = 0;
896	for (i = 0; int_buf[i]; i++)
897		if (int_buf[i] == '(' || int_buf[i] == '{') {
898			if (int_buf[i] == '(')
899				c++;
900			else
901				c2++;
902			collapse_pos(0, i + 1);
903			i = -1;				/* hack incremet */
904		}
905	for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++)
906		if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) {
907			if (int_buf[i] == ')')
908				c--;
909			else
910				c2--;
911			collapse_pos(0, i + 1);
912			i = -1;				/* hack incremet */
913		}
914
915	/* skip first not quote space */
916	for (i = 0; int_buf[i]; i++)
917		if (int_buf[i] != ' ')
918			break;
919	if (i)
920		collapse_pos(0, i);
921
922	/* set find mode for completion */
923	command_mode = FIND_EXE_ONLY;
924	for (i = 0; int_buf[i]; i++)
925		if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') {
926			if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY
927				&& matchBuf[pos_buf[0]]=='c'
928				&& matchBuf[pos_buf[1]]=='d' )
929				command_mode = FIND_DIR_ONLY;
930			else {
931				command_mode = FIND_FILE_ONLY;
932				break;
933			}
934		}
935	/* "strlen" */
936	for (i = 0; int_buf[i]; i++);
937	/* find last word */
938	for (--i; i >= 0; i--) {
939		c = int_buf[i];
940		if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') {
941			collapse_pos(0, i + 1);
942			break;
943		}
944	}
945	/* skip first not quoted '\'' or '"' */
946	for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++);
947	/* collapse quote or unquote // or /~ */
948	while ((int_buf[i] & ~QUOT) == '/' &&
949			((int_buf[i + 1] & ~QUOT) == '/'
950			 || (int_buf[i + 1] & ~QUOT) == '~')) {
951		i++;
952	}
953
954	/* set only match and destroy quotes */
955	j = 0;
956	for (c = 0; pos_buf[i] >= 0; i++) {
957		matchBuf[c++] = matchBuf[pos_buf[i]];
958		j = pos_buf[i] + 1;
959	}
960	matchBuf[c] = 0;
961	/* old lenght matchBuf with quotes symbols */
962	*len_with_quotes = j ? j - pos_buf[0] : 0;
963
964	return command_mode;
965}
966
967
968static void input_tab(int *lastWasTab)
969{
970	/* Do TAB completion */
971	static int num_matches;
972	static char **matches;
973
974	if (lastWasTab == 0) {		/* free all memory */
975		if (matches) {
976			while (num_matches > 0)
977				free(matches[--num_matches]);
978			free(matches);
979			matches = (char **) NULL;
980		}
981		return;
982	}
983	if (*lastWasTab == FALSE) {
984
985		char *tmp;
986		int len_found;
987		char matchBuf[BUFSIZ];
988		int find_type;
989		int recalc_pos;
990
991		*lastWasTab = TRUE;		/* flop trigger */
992
993		/* Make a local copy of the string -- up
994		 * to the position of the cursor */
995		tmp = strncpy(matchBuf, command_ps, cursor);
996		tmp[cursor] = 0;
997
998		find_type = find_match(matchBuf, &recalc_pos);
999
1000		/* Free up any memory already allocated */
1001		input_tab(0);
1002
1003#ifdef BB_FEATURE_COMMAND_USERNAME_COMPLETION
1004		/* If the word starts with `~' and there is no slash in the word,
1005		 * then try completing this word as a username. */
1006
1007		if (matchBuf[0] == '~' && strchr(matchBuf, '/') == 0)
1008			matches = username_tab_completion(matchBuf, &num_matches);
1009#endif
1010		/* Try to match any executable in our path and everything
1011		 * in the current working directory that matches.  */
1012		if (!matches)
1013			matches =
1014				exe_n_cwd_tab_completion(matchBuf,
1015					&num_matches, find_type);
1016		/* Remove duplicate found */
1017		if(matches) {
1018			int i, j;
1019			/* bubble */
1020			for(i=0; i<(num_matches-1); i++)
1021				for(j=i+1; j<num_matches; j++)
1022					if(matches[i]!=0 && matches[j]!=0 &&
1023						strcmp(matches[i], matches[j])==0) {
1024							free(matches[j]);
1025							matches[j]=0;
1026					}
1027			j=num_matches;
1028			num_matches = 0;
1029			for(i=0; i<j; i++)
1030				if(matches[i]) {
1031					if(!strcmp(matches[i], "./"))
1032						matches[i][1]=0;
1033					else if(!strcmp(matches[i], "../"))
1034						matches[i][2]=0;
1035					matches[num_matches++]=matches[i];
1036				}
1037		}
1038		/* Did we find exactly one match? */
1039		if (!matches || num_matches > 1) {
1040			char *tmp1;
1041
1042			beep();
1043			if (!matches)
1044				return;		/* not found */
1045			/* sort */
1046			qsort(matches, num_matches, sizeof(char *), match_compare);
1047
1048			/* find minimal match */
1049			tmp = xstrdup(matches[0]);
1050			for (tmp1 = tmp; *tmp1; tmp1++)
1051				for (len_found = 1; len_found < num_matches; len_found++)
1052					if (matches[len_found][(tmp1 - tmp)] != *tmp1) {
1053						*tmp1 = 0;
1054						break;
1055					}
1056			if (*tmp == 0) {	/* have unique */
1057				free(tmp);
1058				return;
1059			}
1060		} else {			/* one match */
1061			tmp = matches[0];
1062			/* for next completion current found */
1063			*lastWasTab = FALSE;
1064		}
1065
1066		len_found = strlen(tmp);
1067		/* have space to placed match? */
1068		if ((len_found - strlen(matchBuf) + len) < BUFSIZ) {
1069
1070			/* before word for match   */
1071			command_ps[cursor - recalc_pos] = 0;
1072			/* save   tail line        */
1073			strcpy(matchBuf, command_ps + cursor);
1074			/* add    match            */
1075			strcat(command_ps, tmp);
1076			/* add    tail             */
1077			strcat(command_ps, matchBuf);
1078			/* back to begin word for match    */
1079			input_backward(recalc_pos);
1080			/* new pos                         */
1081			recalc_pos = cursor + len_found;
1082			/* new len                         */
1083			len = strlen(command_ps);
1084			/* write out the matched command   */
1085			redraw(cmdedit_y, len - recalc_pos);
1086		}
1087		if (tmp != matches[0])
1088			free(tmp);
1089	} else {
1090		/* Ok -- the last char was a TAB.  Since they
1091		 * just hit TAB again, print a list of all the
1092		 * available choices... */
1093		if (matches && num_matches > 0) {
1094			int i, col, l;
1095			int sav_cursor = cursor;	/* change goto_new_line() */
1096
1097			/* Go to the next line */
1098			goto_new_line();
1099			for (i = 0, col = 0; i < num_matches; i++) {
1100				l = strlen(matches[i]);
1101				if (l < 14)
1102					l = 14;
1103				printf("%-14s  ", matches[i]);
1104				if ((l += 2) > 16)
1105					while (l % 16) {
1106						putchar(' ');
1107						l++;
1108					}
1109				col += l;
1110				col -= (col / cmdedit_termw) * cmdedit_termw;
1111				if (col > 60 && matches[i + 1] != NULL) {
1112					putchar('\n');
1113					col = 0;
1114				}
1115			}
1116			/* Go to the next line and rewrite */
1117			putchar('\n');
1118			redraw(0, len - sav_cursor);
1119		}
1120	}
1121}
1122#endif	/* BB_FEATURE_COMMAND_TAB_COMPLETION */
1123
1124static void get_previous_history(struct history **hp, struct history *p)
1125{
1126	if ((*hp)->s)
1127		free((*hp)->s);
1128	(*hp)->s = xstrdup(command_ps);
1129	*hp = p;
1130}
1131
1132static inline void get_next_history(struct history **hp)
1133{
1134	get_previous_history(hp, (*hp)->n);
1135}
1136
1137enum {
1138	ESC = 27,
1139	DEL = 127,
1140};
1141
1142
1143/*
1144 * This function is used to grab a character buffer
1145 * from the input file descriptor and allows you to
1146 * a string with full command editing (sortof like
1147 * a mini readline).
1148 *
1149 * The following standard commands are not implemented:
1150 * ESC-b -- Move back one word
1151 * ESC-f -- Move forward one word
1152 * ESC-d -- Delete back one word
1153 * ESC-h -- Delete forward one word
1154 * CTL-t -- Transpose two characters
1155 *
1156 * Furthermore, the "vi" command editing keys are not implemented.
1157 *
1158 */
1159
1160
1161int cmdedit_read_input(char *prompt, char command[BUFSIZ])
1162{
1163
1164	int break_out = 0;
1165	int lastWasTab = FALSE;
1166	unsigned char c = 0;
1167	struct history *hp = his_end;
1168
1169	/* prepare before init handlers */
1170	cmdedit_y = 0;	/* quasireal y, not true work if line > xt*yt */
1171	len = 0;
1172	command_ps = command;
1173
1174	getTermSettings(0, (void *) &initial_settings);
1175	memcpy(&new_settings, &initial_settings, sizeof(struct termios));
1176	new_settings.c_lflag &= ~ICANON;        /* unbuffered input */
1177	/* Turn off echoing and CTRL-C, so we can trap it */
1178	new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
1179#ifndef linux
1180	/* Hmm, in linux c_cc[] not parsed if set ~ICANON */
1181	new_settings.c_cc[VMIN] = 1;
1182	new_settings.c_cc[VTIME] = 0;
1183	/* Turn off CTRL-C, so we can trap it */
1184#       ifndef _POSIX_VDISABLE
1185#               define _POSIX_VDISABLE '\0'
1186#       endif
1187	new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
1188#endif
1189	command[0] = 0;
1190
1191	setTermSettings(0, (void *) &new_settings);
1192	handlers_sets |= SET_RESET_TERM;
1193
1194	/* Now initialize things */
1195	cmdedit_init();
1196	/* Print out the command prompt */
1197	parse_prompt(prompt);
1198
1199	while (1) {
1200
1201		fflush(stdout);			/* buffered out to fast */
1202
1203		if (safe_read(0, &c, 1) < 1)
1204			/* if we can't read input then exit */
1205			goto prepare_to_die;
1206
1207		switch (c) {
1208		case '\n':
1209		case '\r':
1210			/* Enter */
1211			goto_new_line();
1212			break_out = 1;
1213			break;
1214		case 1:
1215			/* Control-a -- Beginning of line */
1216			input_backward(cursor);
1217			break;
1218		case 2:
1219			/* Control-b -- Move back one character */
1220			input_backward(1);
1221			break;
1222		case 3:
1223			/* Control-c -- stop gathering input */
1224			goto_new_line();
1225			command[0] = 0;
1226			len = 0;
1227			lastWasTab = FALSE;
1228			put_prompt();
1229			break;
1230		case 4:
1231			/* Control-d -- Delete one character, or exit
1232			 * if the len=0 and no chars to delete */
1233			if (len == 0) {
1234prepare_to_die:
1235#if !defined(BB_ASH)
1236				printf("exit");
1237				goto_new_line();
1238				/* cmdedit_reset_term() called in atexit */
1239				exit(EXIT_SUCCESS);
1240#else
1241				break_out = -1; /* for control stoped jobs */
1242				break;
1243#endif
1244			} else {
1245				input_delete();
1246			}
1247			break;
1248		case 5:
1249			/* Control-e -- End of line */
1250			input_end();
1251			break;
1252		case 6:
1253			/* Control-f -- Move forward one character */
1254			input_forward();
1255			break;
1256		case '\b':
1257		case DEL:
1258			/* Control-h and DEL */
1259			input_backspace();
1260			break;
1261		case '\t':
1262#ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
1263			input_tab(&lastWasTab);
1264#endif
1265			break;
1266		case 14:
1267			/* Control-n -- Get next command in history */
1268			if (hp && hp->n && hp->n->s) {
1269				get_next_history(&hp);
1270				goto rewrite_line;
1271			} else {
1272				beep();
1273			}
1274			break;
1275		case 16:
1276			/* Control-p -- Get previous command from history */
1277			if (hp && hp->p) {
1278				get_previous_history(&hp, hp->p);
1279				goto rewrite_line;
1280			} else {
1281				beep();
1282			}
1283			break;
1284		case 21:
1285			/* Control-U -- Clear line before cursor */
1286			if (cursor) {
1287				strcpy(command, command + cursor);
1288				redraw(cmdedit_y, len -= cursor);
1289			}
1290			break;
1291
1292		case ESC:{
1293			/* escape sequence follows */
1294			if (safe_read(0, &c, 1) < 1)
1295				goto prepare_to_die;
1296			/* different vt100 emulations */
1297			if (c == '[' || c == 'O') {
1298				if (safe_read(0, &c, 1) < 1)
1299					goto prepare_to_die;
1300			}
1301			switch (c) {
1302#ifdef BB_FEATURE_COMMAND_TAB_COMPLETION
1303			case '\t':			/* Alt-Tab */
1304
1305				input_tab(&lastWasTab);
1306				break;
1307#endif
1308			case 'A':
1309				/* Up Arrow -- Get previous command from history */
1310				if (hp && hp->p) {
1311					get_previous_history(&hp, hp->p);
1312					goto rewrite_line;
1313				} else {
1314					beep();
1315				}
1316				break;
1317			case 'B':
1318				/* Down Arrow -- Get next command in history */
1319				if (hp && hp->n && hp->n->s) {
1320					get_next_history(&hp);
1321					goto rewrite_line;
1322				} else {
1323					beep();
1324				}
1325				break;
1326
1327				/* Rewrite the line with the selected history item */
1328			  rewrite_line:
1329				/* change command */
1330				len = strlen(strcpy(command, hp->s));
1331				/* redraw and go to end line */
1332				redraw(cmdedit_y, 0);
1333				break;
1334			case 'C':
1335				/* Right Arrow -- Move forward one character */
1336				input_forward();
1337				break;
1338			case 'D':
1339				/* Left Arrow -- Move back one character */
1340				input_backward(1);
1341				break;
1342			case '3':
1343				/* Delete */
1344				input_delete();
1345				break;
1346			case '1':
1347			case 'H':
1348				/* Home (Ctrl-A) */
1349				input_backward(cursor);
1350				break;
1351			case '4':
1352			case 'F':
1353				/* End (Ctrl-E) */
1354				input_end();
1355				break;
1356			default:
1357				if (!(c >= '1' && c <= '9'))
1358					c = 0;
1359				beep();
1360			}
1361			if (c >= '1' && c <= '9')
1362				do
1363					if (safe_read(0, &c, 1) < 1)
1364						goto prepare_to_die;
1365				while (c != '~');
1366			break;
1367		}
1368
1369		default:	/* If it's regular input, do the normal thing */
1370#ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1371			/* Control-V -- Add non-printable symbol */
1372			if (c == 22) {
1373				if (safe_read(0, &c, 1) < 1)
1374					goto prepare_to_die;
1375				if (c == 0) {
1376					beep();
1377					break;
1378				}
1379			} else
1380#endif
1381			if (!Isprint(c))	/* Skip non-printable characters */
1382				break;
1383
1384			if (len >= (BUFSIZ - 2))	/* Need to leave space for enter */
1385				break;
1386
1387			len++;
1388
1389			if (cursor == (len - 1)) {	/* Append if at the end of the line */
1390				*(command + cursor) = c;
1391				*(command + cursor + 1) = 0;
1392				cmdedit_set_out_char(0);
1393			} else {			/* Insert otherwise */
1394				int sc = cursor;
1395
1396				memmove(command + sc + 1, command + sc, len - sc);
1397				*(command + sc) = c;
1398				sc++;
1399				/* rewrite from cursor */
1400				input_end();
1401				/* to prev x pos + 1 */
1402				input_backward(cursor - sc);
1403			}
1404
1405			break;
1406		}
1407		if (break_out)			/* Enter is the command terminator, no more input. */
1408			break;
1409
1410		if (c != '\t')
1411			lastWasTab = FALSE;
1412	}
1413
1414	setTermSettings(0, (void *) &initial_settings);
1415	handlers_sets &= ~SET_RESET_TERM;
1416
1417	/* Handle command history log */
1418	if (len) {					/* no put empty line */
1419
1420		struct history *h = his_end;
1421		char *ss;
1422
1423		ss = xstrdup(command);	/* duplicate */
1424
1425		if (h == 0) {
1426			/* No previous history -- this memory is never freed */
1427			h = his_front = xmalloc(sizeof(struct history));
1428			h->n = xmalloc(sizeof(struct history));
1429
1430			h->p = NULL;
1431			h->s = ss;
1432			h->n->p = h;
1433			h->n->n = NULL;
1434			h->n->s = NULL;
1435			his_end = h->n;
1436			history_counter++;
1437		} else {
1438			/* Add a new history command -- this memory is never freed */
1439			h->n = xmalloc(sizeof(struct history));
1440
1441			h->n->p = h;
1442			h->n->n = NULL;
1443			h->n->s = NULL;
1444			h->s = ss;
1445			his_end = h->n;
1446
1447			/* After max history, remove the oldest command */
1448			if (history_counter >= MAX_HISTORY) {
1449
1450				struct history *p = his_front->n;
1451
1452				p->p = NULL;
1453				free(his_front->s);
1454				free(his_front);
1455				his_front = p;
1456			} else {
1457				history_counter++;
1458			}
1459		}
1460#if defined(BB_FEATURE_SH_FANCY_PROMPT)
1461		num_ok_lines++;
1462#endif
1463	}
1464	if(break_out>0) {
1465	command[len++] = '\n';		/* set '\n' */
1466	command[len] = 0;
1467	}
1468#if defined(BB_FEATURE_CLEAN_UP) && defined(BB_FEATURE_COMMAND_TAB_COMPLETION)
1469	input_tab(0);				/* strong free */
1470#endif
1471#if defined(BB_FEATURE_SH_FANCY_PROMPT)
1472	free(cmdedit_prompt);
1473#endif
1474	cmdedit_reset_term();
1475	return len;
1476}
1477
1478
1479
1480#endif	/* BB_FEATURE_COMMAND_EDITING */
1481
1482
1483#ifdef TEST
1484
1485const char *applet_name = "debug stuff usage";
1486const char *memory_exhausted = "Memory exhausted";
1487
1488#ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1489#include <locale.h>
1490#endif
1491
1492int main(int argc, char **argv)
1493{
1494	char buff[BUFSIZ];
1495	char *prompt =
1496#if defined(BB_FEATURE_SH_FANCY_PROMPT)
1497		"\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:\
1498\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] \
1499\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
1500#else
1501		"% ";
1502#endif
1503
1504#ifdef BB_FEATURE_NONPRINTABLE_INVERSE_PUT
1505	setlocale(LC_ALL, "");
1506#endif
1507	while(1) {
1508		int l;
1509		cmdedit_read_input(prompt, buff);
1510		l = strlen(buff);
1511		if(l==0)
1512			break;
1513		if(l > 0 && buff[l-1] == '\n')
1514			buff[l-1] = 0;
1515		printf("*** cmdedit_read_input() returned line =%s=\n", buff);
1516	}
1517	printf("*** cmdedit_read_input() detect ^C\n");
1518	return 0;
1519}
1520
1521#endif	/* TEST */
1522