move shell/cmdedit.c -> libbb/lineedit.c

1 files changed, 1798 insertions, 0 deletions

diff --git a/libbb/lineedit.c b/libbb/lineedit.c
new file mode 100644
index 0000000..e62975d
--- /dev/null
+++ b/libbb/lineedit.c
@@ -0,0 +1,1798 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Termios command line History and Editing.
+ *
+ * Copyright (c) 1986-2003 may safely be consumed by a BSD or GPL license.
+ * Written by:   Vladimir Oleynik <dzo@simtreas.ru>
+ *
+ * Used ideas:
+ *      Adam Rogoyski    <rogoyski@cs.utexas.edu>
+ *      Dave Cinege      <dcinege@psychosis.com>
+ *      Jakub Jelinek (c) 1995
+ *      Erik Andersen    <andersen@codepoet.org> (Majorly adjusted for busybox)
+ *
+ * This code is 'as is' with no warranty.
+ */
+
+/*
+   Usage and known bugs:
+   Terminal key codes are not extensive, and more will probably
+   need to be added. This version was created on Debian GNU/Linux 2.x.
+   Delete, Backspace, Home, End, and the arrow keys were tested
+   to work in an Xterm and console. Ctrl-A also works as Home.
+   Ctrl-E also works as End.
+
+   Small bugs (simple effect):
+   - not true viewing if terminal size (x*y symbols) less
+     size (prompt + editor's line + 2 symbols)
+   - not true viewing if length prompt less terminal width
+ */
+
+#include <sys/ioctl.h>
+#include "busybox.h"
+
+
+/* FIXME: obsolete CONFIG item? */
+#define ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT 0
+
+
+#ifdef TEST
+
+#define ENABLE_FEATURE_EDITING 0
+#define ENABLE_FEATURE_TAB_COMPLETION 0
+#define ENABLE_FEATURE_USERNAME_COMPLETION 0
+#define ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT 0
+#define ENABLE_FEATURE_CLEAN_UP 0
+
+#endif  /* TEST */
+
+
+/* Entire file (except TESTing part) sits inside this #if */
+#if ENABLE_FEATURE_EDITING
+
+#if ENABLE_LOCALE_SUPPORT
+#define Isprint(c) isprint(c)
+#else
+#define Isprint(c) ((c) >= ' ' && (c) != ((unsigned char)'\233'))
+#endif
+
+#define ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR \
+(ENABLE_FEATURE_USERNAME_COMPLETION || ENABLE_FEATURE_EDITING_FANCY_PROMPT)
+
+
+static line_input_t *state;
+
+static struct termios initial_settings, new_settings;
+
+static volatile unsigned cmdedit_termw = 80;        /* actual terminal width */
+
+static int cmdedit_x;           /* real x terminal position */
+static int cmdedit_y;           /* pseudoreal y terminal position */
+static int cmdedit_prmt_len;    /* length of prompt (without colors etc) */
+
+static unsigned cursor;
+static unsigned command_len;
+static char *command_ps;
+static const char *cmdedit_prompt;
+
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+static char *hostname_buf;
+static int num_ok_lines = 1;
+#endif
+
+#if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR
+static char *user_buf = "";
+static char *home_pwd_buf = "";
+#endif
+
+#if ENABLE_FEATURE_TAB_COMPLETION
+static int my_uid;
+static int my_gid;
+#endif
+
+/* Put 'command_ps[cursor]', cursor++.
+ * Advance cursor on screen. If we reached right margin, scroll text up
+ * and remove terminal margin effect by printing 'next_char' */
+static void cmdedit_set_out_char(int next_char)
+{
+	int c = (unsigned char)command_ps[cursor];
+
+	if (c == '\0') {
+		/* erase character after end of input string */
+		c = ' ';
+	}
+#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
+	/* Display non-printable characters in reverse */
+	if (!Isprint(c)) {
+		if (c >= 128)
+			c -= 128;
+		if (c < ' ')
+			c += '@';
+		if (c == 127)
+			c = '?';
+		printf("\033[7m%c\033[0m", c);
+	} else
+#endif
+	{
+		if (initial_settings.c_lflag & ECHO)
+			putchar(c);
+	}
+	if (++cmdedit_x >= cmdedit_termw) {
+		/* terminal is scrolled down */
+		cmdedit_y++;
+		cmdedit_x = 0;
+		/* destroy "(auto)margin" */
+		putchar(next_char);
+		putchar('\b');
+	}
+// Huh? What if command_ps[cursor] == '\0' (we are at the end already?)
+	cursor++;
+}
+
+/* Move to end of line (by printing all chars till the end) */
+static void input_end(void)
+{
+	while (cursor < command_len)
+		cmdedit_set_out_char(' ');
+}
+
+/* Go to the next line */
+static void goto_new_line(void)
+{
+	input_end();
+	if (cmdedit_x)
+		putchar('\n');
+}
+
+
+static void out1str(const char *s)
+{
+	if (s)
+		fputs(s, stdout);
+}
+
+static void beep(void)
+{
+	putchar('\007');
+}
+
+/* Move back one character */
+/* (optimized for slow terminals) */
+static void input_backward(unsigned num)
+{
+	int count_y;
+
+	if (num > cursor)
+		num = cursor;
+	if (!num)
+		return;
+	cursor -= num;
+
+	if (cmdedit_x >= num) {
+		cmdedit_x -= num;
+		if (num <= 4) {
+			do putchar('\b'); while (--num);
+			return;
+		}
+		printf("\033[%uD", num);
+		return;
+	}
+
+	/* Need to go one or more lines up */
+	num -= cmdedit_x;
+	count_y = 1 + (num / cmdedit_termw);
+	cmdedit_y -= count_y;
+	cmdedit_x = cmdedit_termw * count_y - num;
+	/* go to 1st col; go up; go to correct column */
+	printf("\r" "\033[%dA" "\033[%dC", count_y, cmdedit_x);
+}
+
+static void put_prompt(void)
+{
+	out1str(cmdedit_prompt);
+	cmdedit_x = cmdedit_prmt_len;
+	cursor = 0;
+// Huh? what if cmdedit_prmt_len >= width?
+	cmdedit_y = 0;                  /* new quasireal y */
+}
+
+/* draw prompt, editor line, and clear tail */
+static void redraw(int y, int back_cursor)
+{
+	if (y > 0)                              /* up to start y */
+		printf("\033[%dA", y);
+	putchar('\r');
+	put_prompt();
+	input_end();                            /* rewrite */
+	printf("\033[J");                       /* erase after cursor */
+	input_backward(back_cursor);
+}
+
+#if ENABLE_FEATURE_EDITING_VI
+#define DELBUFSIZ 128
+static char *delbuf;  /* a (malloced) place to store deleted characters */
+static char *delp;
+static char newdelflag;      /* whether delbuf should be reused yet */
+#endif
+
+/* Delete the char in front of the cursor, optionally saving it
+ * for later putback */
+static void input_delete(int save)
+{
+	int j = cursor;
+
+	if (j == command_len)
+		return;
+
+#if ENABLE_FEATURE_EDITING_VI
+	if (save) {
+		if (newdelflag) {
+			if (!delbuf)
+				delbuf = malloc(DELBUFSIZ);
+			/* safe if malloc fails */
+			delp = delbuf;
+			newdelflag = 0;
+		}
+		if (delbuf && (delp - delbuf < DELBUFSIZ))
+			*delp++ = command_ps[j];
+	}
+#endif
+
+	strcpy(command_ps + j, command_ps + j + 1);
+	command_len--;
+	input_end();                    /* rewrite new line */
+	cmdedit_set_out_char(' ');      /* erase char */
+	input_backward(cursor - j);     /* back to old pos cursor */
+}
+
+#if ENABLE_FEATURE_EDITING_VI
+static void put(void)
+{
+	int ocursor;
+	int j = delp - delbuf;
+
+	if (j == 0)
+		return;
+	ocursor = cursor;
+	/* open hole and then fill it */
+	memmove(command_ps + cursor + j, command_ps + cursor, command_len - cursor + 1);
+	strncpy(command_ps + cursor, delbuf, j);
+	command_len += j;
+	input_end();                    /* rewrite new line */
+	input_backward(cursor - ocursor - j + 1); /* at end of new text */
+}
+#endif
+
+/* Delete the char in back of the cursor */
+static void input_backspace(void)
+{
+	if (cursor > 0) {
+		input_backward(1);
+		input_delete(0);
+	}
+}
+
+/* Move forward one character */
+static void input_forward(void)
+{
+	if (cursor < command_len)
+		cmdedit_set_out_char(command_ps[cursor + 1]);
+}
+
+
+#if ENABLE_FEATURE_TAB_COMPLETION
+
+static char **matches;
+static unsigned num_matches;
+
+static void free_tab_completion_data(void)
+{
+	if (matches) {
+		while (num_matches)
+			free(matches[--num_matches]);
+		free(matches);
+		matches = NULL;
+	}
+}
+
+static void add_match(char *matched)
+{
+	int nm = num_matches;
+	int nm1 = nm + 1;
+
+	matches = xrealloc(matches, nm1 * sizeof(char *));
+	matches[nm] = matched;
+	num_matches++;
+}
+
+#if ENABLE_FEATURE_USERNAME_COMPLETION
+static void username_tab_completion(char *ud, char *with_shash_flg)
+{
+	struct passwd *entry;
+	int userlen;
+
+	ud++;                           /* ~user/... to user/... */
+	userlen = strlen(ud);
+
+	if (with_shash_flg) {           /* "~/..." or "~user/..." */
+		char *sav_ud = ud - 1;
+		char *home = 0;
+		char *temp;
+
+		if (*ud == '/') {       /* "~/..."     */
+			home = home_pwd_buf;
+		} else {
+			/* "~user/..." */
+			temp = strchr(ud, '/');
+			*temp = 0;              /* ~user\0 */
+			entry = getpwnam(ud);
+			*temp = '/';            /* restore ~user/... */
+			ud = temp;
+			if (entry)
+				home = entry->pw_dir;
+		}
+		if (home) {
+			if ((userlen + strlen(home) + 1) < BUFSIZ) {
+				char temp2[BUFSIZ];     /* argument size */
+
+				/* /home/user/... */
+				sprintf(temp2, "%s%s", home, ud);
+				strcpy(sav_ud, temp2);
+			}
+		}
+	} else {
+		/* "~[^/]*" */
+		setpwent();
+
+		while ((entry = getpwent()) != NULL) {
+			/* Null usernames should result in all users as possible completions. */
+			if ( /*!userlen || */ !strncmp(ud, entry->pw_name, userlen)) {
+				add_match(xasprintf("~%s/", entry->pw_name));
+			}
+		}
+
+		endpwent();
+	}
+}
+#endif  /* FEATURE_COMMAND_USERNAME_COMPLETION */
+
+enum {
+	FIND_EXE_ONLY = 0,
+	FIND_DIR_ONLY = 1,
+	FIND_FILE_ONLY = 2,
+};
+
+static int path_parse(char ***p, int flags)
+{
+	int npth;
+	const char *pth;
+	char *tmp;
+	char **res;
+
+	/* if not setenv PATH variable, to search cur dir "." */
+	if (flags != FIND_EXE_ONLY)
+		return 1;
+
+	if (state->flags & WITH_PATH_LOOKUP)
+		pth = state->path_lookup;
+	else
+		pth = getenv("PATH");
+	/* PATH=<empty> or PATH=:<empty> */
+	if (!pth || !pth[0] || LONE_CHAR(pth, ':'))
+		return 1;
+
+	tmp = (char*)pth;
+	npth = 1; /* path component count */
+	while (1) {
+		tmp = strchr(tmp, ':');
+		if (!tmp)
+			break;
+		if (*++tmp == '\0')
+			break;  /* :<empty> */
+		npth++;
+	}
+
+	res = xmalloc(npth * sizeof(char*));
+	res[0] = tmp = xstrdup(pth);
+	npth = 1;
+	while (1) {
+		tmp = strchr(tmp, ':');
+		if (!tmp)
+			break;
+		*tmp++ = '\0'; /* ':' -> '\0' */
+		if (*tmp == '\0')
+			break; /* :<empty> */
+		res[npth++] = tmp;
+	}
+	*p = res;
+	return npth;
+}
+
+static void exe_n_cwd_tab_completion(char *command, int type)
+{
+	DIR *dir;
+	struct dirent *next;
+	char dirbuf[BUFSIZ];
+	struct stat st;
+	char *path1[1];
+	char **paths = path1;
+	int npaths;
+	int i;
+	char *found;
+	char *pfind = strrchr(command, '/');
+
+	npaths = 1;
+	path1[0] = ".";
+
+	if (pfind == NULL) {
+		/* no dir, if flags==EXE_ONLY - get paths, else "." */
+		npaths = path_parse(&paths, type);
+		pfind = command;
+	} else {
+		/* dirbuf = ".../.../.../" */
+		safe_strncpy(dirbuf, command, (pfind - command) + 2);
+#if ENABLE_FEATURE_USERNAME_COMPLETION
+		if (dirbuf[0] == '~')   /* ~/... or ~user/... */
+			username_tab_completion(dirbuf, dirbuf);
+#endif
+		paths[0] = dirbuf;
+		/* point to 'l' in "..../last_component" */
+		pfind++;
+	}
+
+	for (i = 0; i < npaths; i++) {
+		dir = opendir(paths[i]);
+		if (!dir)                       /* Don't print an error */
+			continue;
+
+		while ((next = readdir(dir)) != NULL) {
+			int len1;
+			char *str_found = next->d_name;
+
+			/* matched? */
+			if (strncmp(str_found, pfind, strlen(pfind)))
+				continue;
+			/* not see .name without .match */
+			if (*str_found == '.' && *pfind == 0) {
+				if (NOT_LONE_CHAR(paths[i], '/') || str_found[1])
+					continue;
+				str_found = ""; /* only "/" */
+			}
+			found = concat_path_file(paths[i], str_found);
+			/* hmm, remover in progress? */
+			if (stat(found, &st) < 0)
+				goto cont;
+			/* find with dirs? */
+			if (paths[i] != dirbuf)
+				strcpy(found, next->d_name);    /* only name */
+
+			len1 = strlen(found);
+			found = xrealloc(found, len1 + 2);
+			found[len1] = '\0';
+			found[len1+1] = '\0';
+
+			if (S_ISDIR(st.st_mode)) {
+				/* name is directory      */
+				if (found[len1-1] != '/') {
+					found[len1] = '/';
+				}
+			} else {
+				/* not put found file if search only dirs for cd */
+				if (type == FIND_DIR_ONLY)
+					goto cont;
+			}
+			/* Add it to the list */
+			add_match(found);
+			continue;
+ cont:
+			free(found);
+		}
+		closedir(dir);
+	}
+	if (paths != path1) {
+		free(paths[0]);                 /* allocated memory only in first member */
+		free(paths);
+	}
+}
+
+#define QUOT (UCHAR_MAX+1)
+
+#define collapse_pos(is, in) { \
+	memmove(int_buf+(is), int_buf+(in), (BUFSIZ+1-(is)-(in))*sizeof(int)); \
+	memmove(pos_buf+(is), pos_buf+(in), (BUFSIZ+1-(is)-(in))*sizeof(int)); }
+
+static int find_match(char *matchBuf, int *len_with_quotes)
+{
+	int i, j;
+	int command_mode;
+	int c, c2;
+	int int_buf[BUFSIZ + 1];
+	int pos_buf[BUFSIZ + 1];
+
+	/* set to integer dimension characters and own positions */
+	for (i = 0;; i++) {
+		int_buf[i] = (unsigned char)matchBuf[i];
+		if (int_buf[i] == 0) {
+			pos_buf[i] = -1;        /* indicator end line */
+			break;
+		}
+		pos_buf[i] = i;
+	}
+
+	/* mask \+symbol and convert '\t' to ' ' */
+	for (i = j = 0; matchBuf[i]; i++, j++)
+		if (matchBuf[i] == '\\') {
+			collapse_pos(j, j + 1);
+			int_buf[j] |= QUOT;
+			i++;
+#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
+			if (matchBuf[i] == '\t')        /* algorithm equivalent */
+				int_buf[j] = ' ' | QUOT;
+#endif
+		}
+#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
+		else if (matchBuf[i] == '\t')
+			int_buf[j] = ' ';
+#endif
+
+	/* mask "symbols" or 'symbols' */
+	c2 = 0;
+	for (i = 0; int_buf[i]; i++) {
+		c = int_buf[i];
+		if (c == '\'' || c == '"') {
+			if (c2 == 0)
+				c2 = c;
+			else {
+				if (c == c2)
+					c2 = 0;
+				else
+					int_buf[i] |= QUOT;
+			}
+		} else if (c2 != 0 && c != '$')
+			int_buf[i] |= QUOT;
+	}
+
+	/* skip commands with arguments if line has commands delimiters */
+	/* ';' ';;' '&' '|' '&&' '||' but `>&' `<&' `>|' */
+	for (i = 0; int_buf[i]; i++) {
+		c = int_buf[i];
+		c2 = int_buf[i + 1];
+		j = i ? int_buf[i - 1] : -1;
+		command_mode = 0;
+		if (c == ';' || c == '&' || c == '|') {
+			command_mode = 1 + (c == c2);
+			if (c == '&') {
+				if (j == '>' || j == '<')
+					command_mode = 0;
+			} else if (c == '|' && j == '>')
+				command_mode = 0;
+		}
+		if (command_mode) {
+			collapse_pos(0, i + command_mode);
+			i = -1;                         /* hack incremet */
+		}
+	}
+	/* collapse `command...` */
+	for (i = 0; int_buf[i]; i++)
+		if (int_buf[i] == '`') {
+			for (j = i + 1; int_buf[j]; j++)
+				if (int_buf[j] == '`') {
+					collapse_pos(i, j + 1);
+					j = 0;
+					break;
+				}
+			if (j) {
+				/* not found close ` - command mode, collapse all previous */
+				collapse_pos(0, i + 1);
+				break;
+			} else
+				i--;                    /* hack incremet */
+		}
+
+	/* collapse (command...(command...)...) or {command...{command...}...} */
+	c = 0;                                          /* "recursive" level */
+	c2 = 0;
+	for (i = 0; int_buf[i]; i++)
+		if (int_buf[i] == '(' || int_buf[i] == '{') {
+			if (int_buf[i] == '(')
+				c++;
+			else
+				c2++;
+			collapse_pos(0, i + 1);
+			i = -1;                         /* hack incremet */
+		}
+	for (i = 0; pos_buf[i] >= 0 && (c > 0 || c2 > 0); i++)
+		if ((int_buf[i] == ')' && c > 0) || (int_buf[i] == '}' && c2 > 0)) {
+			if (int_buf[i] == ')')
+				c--;
+			else
+				c2--;
+			collapse_pos(0, i + 1);
+			i = -1;                         /* hack incremet */
+		}
+
+	/* skip first not quote space */
+	for (i = 0; int_buf[i]; i++)
+		if (int_buf[i] != ' ')
+			break;
+	if (i)
+		collapse_pos(0, i);
+
+	/* set find mode for completion */
+	command_mode = FIND_EXE_ONLY;
+	for (i = 0; int_buf[i]; i++)
+		if (int_buf[i] == ' ' || int_buf[i] == '<' || int_buf[i] == '>') {
+			if (int_buf[i] == ' ' && command_mode == FIND_EXE_ONLY
+			 && matchBuf[pos_buf[0]]=='c'
+			 && matchBuf[pos_buf[1]]=='d'
+			) {
+				command_mode = FIND_DIR_ONLY;
+			} else {
+				command_mode = FIND_FILE_ONLY;
+				break;
+			}
+		}
+	for (i = 0; int_buf[i]; i++)
+		/* "strlen" */;
+	/* find last word */
+	for (--i; i >= 0; i--) {
+		c = int_buf[i];
+		if (c == ' ' || c == '<' || c == '>' || c == '|' || c == '&') {
+			collapse_pos(0, i + 1);
+			break;
+		}
+	}
+	/* skip first not quoted '\'' or '"' */
+	for (i = 0; int_buf[i] == '\'' || int_buf[i] == '"'; i++)
+		/*skip*/;
+	/* collapse quote or unquote // or /~ */
+	while ((int_buf[i] & ~QUOT) == '/'
+	 && ((int_buf[i+1] & ~QUOT) == '/' || (int_buf[i+1] & ~QUOT) == '~')
+	) {
+		i++;
+	}
+
+	/* set only match and destroy quotes */
+	j = 0;
+	for (c = 0; pos_buf[i] >= 0; i++) {
+		matchBuf[c++] = matchBuf[pos_buf[i]];
+		j = pos_buf[i] + 1;
+	}
+	matchBuf[c] = 0;
+	/* old lenght matchBuf with quotes symbols */
+	*len_with_quotes = j ? j - pos_buf[0] : 0;
+
+	return command_mode;
+}
+
+/*
+ * display by column (original idea from ls applet,
+ * very optimized by me :)
+ */
+static void showfiles(void)
+{
+	int ncols, row;
+	int column_width = 0;
+	int nfiles = num_matches;
+	int nrows = nfiles;
+	int l;
+
+	/* find the longest file name-  use that as the column width */
+	for (row = 0; row < nrows; row++) {
+		l = strlen(matches[row]);
+		if (column_width < l)
+			column_width = l;
+	}
+	column_width += 2;              /* min space for columns */
+	ncols = cmdedit_termw / column_width;
+
+	if (ncols > 1) {
+		nrows /= ncols;
+		if (nfiles % ncols)
+			nrows++;        /* round up fractionals */
+	} else {
+		ncols = 1;
+	}
+	for (row = 0; row < nrows; row++) {
+		int n = row;
+		int nc;
+
+		for (nc = 1; nc < ncols && n+nrows < nfiles; n += nrows, nc++) {
+			printf("%s%-*s", matches[n],
+				(int)(column_width - strlen(matches[n])), "");
+		}
+		printf("%s\n", matches[n]);
+	}
+}
+
+static char *add_quote_for_spec_chars(char *found)
+{
+	int l = 0;
+	char *s = xmalloc((strlen(found) + 1) * 2);
+
+	while (*found) {
+		if (strchr(" `\"#$%^&*()=+{}[]:;\'|\\<>", *found))
+			s[l++] = '\\';
+		s[l++] = *found++;
+	}
+	s[l] = 0;
+	return s;
+}
+
+static int match_compare(const void *a, const void *b)
+{
+	return strcmp(*(char**)a, *(char**)b);
+}
+
+/* Do TAB completion */
+static void input_tab(int *lastWasTab)
+{
+	if (!(state->flags & TAB_COMPLETION))
+		return;
+
+	if (!*lastWasTab) {
+		char *tmp, *tmp1;
+		int len_found;
+		char matchBuf[BUFSIZ];
+		int find_type;
+		int recalc_pos;
+
+		*lastWasTab = TRUE;             /* flop trigger */
+
+		/* Make a local copy of the string -- up
+		 * to the position of the cursor */
+		tmp = strncpy(matchBuf, command_ps, cursor);
+		tmp[cursor] = '\0';
+
+		find_type = find_match(matchBuf, &recalc_pos);
+
+		/* Free up any memory already allocated */
+		free_tab_completion_data();
+
+#if ENABLE_FEATURE_USERNAME_COMPLETION
+		/* If the word starts with `~' and there is no slash in the word,
+		 * then try completing this word as a username. */
+		if (state->flags & USERNAME_COMPLETION)
+			if (matchBuf[0] == '~' && strchr(matchBuf, '/') == 0)
+				username_tab_completion(matchBuf, NULL);
+#endif
+		/* Try to match any executable in our path and everything
+		 * in the current working directory */
+		if (!matches)
+			exe_n_cwd_tab_completion(matchBuf, find_type);
+		/* Sort, then remove any duplicates found */
+		if (matches) {
+			int i, n = 0;
+			qsort(matches, num_matches, sizeof(char*), match_compare);
+			for (i = 0; i < num_matches - 1; ++i) {
+				if (matches[i] && matches[i+1]) { /* paranoia */
+					if (strcmp(matches[i], matches[i+1]) == 0) {
+						free(matches[i]);
+						matches[i] = NULL; /* paranoia */
+					} else {
+						matches[n++] = matches[i];
+					}
+				}
+			}
+			matches[n] = matches[i];
+			num_matches = n + 1;
+		}
+		/* Did we find exactly one match? */
+		if (!matches || num_matches > 1) {
+			beep();
+			if (!matches)
+				return;         /* not found */
+			/* find minimal match */
+			tmp1 = xstrdup(matches[0]);
+			for (tmp = tmp1; *tmp; tmp++)
+				for (len_found = 1; len_found < num_matches; len_found++)
+					if (matches[len_found][(tmp - tmp1)] != *tmp) {
+						*tmp = '\0';
+						break;
+					}
+			if (*tmp1 == '\0') {        /* have unique */
+				free(tmp1);
+				return;
+			}
+			tmp = add_quote_for_spec_chars(tmp1);
+			free(tmp1);
+		} else {                        /* one match */
+			tmp = add_quote_for_spec_chars(matches[0]);
+			/* for next completion current found */
+			*lastWasTab = FALSE;
+
+			len_found = strlen(tmp);
+			if (tmp[len_found-1] != '/') {
+				tmp[len_found] = ' ';
+				tmp[len_found+1] = '\0';
+			}
+		}
+		len_found = strlen(tmp);
+		/* have space to placed match? */
+		if ((len_found - strlen(matchBuf) + command_len) < BUFSIZ) {
+			/* before word for match   */
+			command_ps[cursor - recalc_pos] = 0;
+			/* save   tail line        */
+			strcpy(matchBuf, command_ps + cursor);
+			/* add    match            */
+			strcat(command_ps, tmp);
+			/* add    tail             */
+			strcat(command_ps, matchBuf);
+			/* back to begin word for match    */
+			input_backward(recalc_pos);
+			/* new pos                         */
+			recalc_pos = cursor + len_found;
+			/* new len                         */
+			command_len = strlen(command_ps);
+			/* write out the matched command   */
+			redraw(cmdedit_y, command_len - recalc_pos);
+		}
+		free(tmp);
+	} else {
+		/* Ok -- the last char was a TAB.  Since they
+		 * just hit TAB again, print a list of all the
+		 * available choices... */
+		if (matches && num_matches > 0) {
+			int sav_cursor = cursor;        /* change goto_new_line() */
+
+			/* Go to the next line */
+			goto_new_line();
+			showfiles();
+			redraw(0, command_len - sav_cursor);
+		}
+	}
+}
+
+#else
+#define input_tab(a) ((void)0)
+#endif  /* FEATURE_COMMAND_TAB_COMPLETION */
+
+
+#if MAX_HISTORY > 0
+
+/* state->flags is already checked to be nonzero */
+static void get_previous_history(void)
+{
+	if (command_ps[0] != '\0' || state->history[state->cur_history] == NULL) {
+		free(state->history[state->cur_history]);
+		state->history[state->cur_history] = xstrdup(command_ps);
+	}
+	state->cur_history--;
+}
+
+static int get_next_history(void)
+{
+	if (state->flags & DO_HISTORY) {
+		int ch = state->cur_history;
+		if (ch < state->cnt_history) {
+			get_previous_history(); /* save the current history line */
+			state->cur_history = ch + 1;
+			return state->cur_history;
+		}
+	}
+	beep();
+	return 0;
+}
+
+#if ENABLE_FEATURE_EDITING_SAVEHISTORY
+/* state->flags is already checked to be nonzero */
+void load_history(const char *fromfile)
+{
+	FILE *fp;
+	int hi;
+
+	/* cleanup old */
+	for (hi = state->cnt_history; hi > 0;) {
+		hi--;
+		free(state->history[hi]);
+	}
+
+	fp = fopen(fromfile, "r");
+	if (fp) {
+		for (hi = 0; hi < MAX_HISTORY;) {
+			char * hl = xmalloc_getline(fp);
+			int l;
+
+			if (!hl)
+				break;
+			l = strlen(hl);
+			if (l >= BUFSIZ)
+				hl[BUFSIZ-1] = 0;
+			if (l == 0 || hl[0] == ' ') {
+				free(hl);
+				continue;
+			}
+			state->history[hi++] = hl;
+		}
+		fclose(fp);
+	}
+	state->cur_history = state->cnt_history = hi;
+}
+
+/* state->flags is already checked to be nonzero */
+void save_history(const char *tofile)
+{
+	FILE *fp;
+
+	fp = fopen(tofile, "w");
+	if (fp) {
+		int i;
+
+		for (i = 0; i < state->cnt_history; i++) {
+			fprintf(fp, "%s\n", state->history[i]);
+		}
+		fclose(fp);
+	}
+}
+#else
+#define load_history(a) ((void)0)
+#define save_history(a) ((void)0)
+#endif /* FEATURE_COMMAND_SAVEHISTORY */
+
+static void remember_in_history(const char *str)
+{
+	int i;
+
+	if (!(state->flags & DO_HISTORY))
+		return;
+
+	i = state->cnt_history;
+	free(state->history[MAX_HISTORY]);
+	state->history[MAX_HISTORY] = NULL;
+	/* After max history, remove the oldest command */
+	if (i >= MAX_HISTORY) {
+		free(state->history[0]);
+		for (i = 0; i < MAX_HISTORY-1; i++)
+			state->history[i] = state->history[i+1];
+	}
+// Maybe "if (!i || strcmp(history[i-1], command) != 0) ..."
+// (i.e. do not save dups?)
+	state->history[i++] = xstrdup(str);
+	state->cur_history = i;
+	state->cnt_history = i;
+	if (state->flags & SAVE_HISTORY)
+		save_history(state->hist_file);
+	USE_FEATURE_EDITING_FANCY_PROMPT(num_ok_lines++;)
+}
+
+#else /* MAX_HISTORY == 0 */
+#define remember_in_history(a) ((void)0)
+#endif /* MAX_HISTORY */
+
+
+/*
+ * This function is used to grab a character buffer
+ * from the input file descriptor and allows you to
+ * a string with full command editing (sort of like
+ * a mini readline).
+ *
+ * The following standard commands are not implemented:
+ * ESC-b -- Move back one word
+ * ESC-f -- Move forward one word
+ * ESC-d -- Delete back one word
+ * ESC-h -- Delete forward one word
+ * CTL-t -- Transpose two characters
+ *
+ * Minimalist vi-style command line editing available if configured.
+ * vi mode implemented 2005 by Paul Fox <pgf@foxharp.boston.ma.us>
+ */
+
+#if ENABLE_FEATURE_EDITING_VI
+static void
+vi_Word_motion(char *command, int eat)
+{
+	while (cursor < command_len && !isspace(command[cursor]))
+		input_forward();
+	if (eat) while (cursor < command_len && isspace(command[cursor]))
+		input_forward();
+}
+
+static void
+vi_word_motion(char *command, int eat)
+{
+	if (isalnum(command[cursor]) || command[cursor] == '_') {
+		while (cursor < command_len
+		 && (isalnum(command[cursor+1]) || command[cursor+1] == '_'))
+			input_forward();
+	} else if (ispunct(command[cursor])) {
+		while (cursor < command_len && ispunct(command[cursor+1]))
+			input_forward();
+	}
+
+	if (cursor < command_len)
+		input_forward();
+
+	if (eat && cursor < command_len && isspace(command[cursor]))
+		while (cursor < command_len && isspace(command[cursor]))
+			input_forward();
+}
+
+static void
+vi_End_motion(char *command)
+{
+	input_forward();
+	while (cursor < command_len && isspace(command[cursor]))
+		input_forward();
+	while (cursor < command_len-1 && !isspace(command[cursor+1]))
+		input_forward();
+}
+
+static void
+vi_end_motion(char *command)
+{
+	if (cursor >= command_len-1)
+		return;
+	input_forward();
+	while (cursor < command_len-1 && isspace(command[cursor]))
+		input_forward();
+	if (cursor >= command_len-1)
+		return;
+	if (isalnum(command[cursor]) || command[cursor] == '_') {
+		while (cursor < command_len-1
+		 && (isalnum(command[cursor+1]) || command[cursor+1] == '_')
+		) {
+			input_forward();
+		}
+	} else if (ispunct(command[cursor])) {
+		while (cursor < command_len-1 && ispunct(command[cursor+1]))
+			input_forward();
+	}
+}
+
+static void
+vi_Back_motion(char *command)
+{
+	while (cursor > 0 && isspace(command[cursor-1]))
+		input_backward(1);
+	while (cursor > 0 && !isspace(command[cursor-1]))
+		input_backward(1);
+}
+
+static void
+vi_back_motion(char *command)
+{
+	if (cursor <= 0)
+		return;
+	input_backward(1);
+	while (cursor > 0 && isspace(command[cursor]))
+		input_backward(1);
+	if (cursor <= 0)
+		return;
+	if (isalnum(command[cursor]) || command[cursor] == '_') {
+		while (cursor > 0
+		 && (isalnum(command[cursor-1]) || command[cursor-1] == '_')
+		) {
+			input_backward(1);
+		}
+	} else if (ispunct(command[cursor])) {
+		while (cursor > 0 && ispunct(command[cursor-1]))
+			input_backward(1);
+	}
+}
+#endif
+
+
+/*
+ * read_line_input and its helpers
+ */
+
+#if !ENABLE_FEATURE_EDITING_FANCY_PROMPT
+static void parse_prompt(const char *prmt_ptr)
+{
+	cmdedit_prompt = prmt_ptr;
+	cmdedit_prmt_len = strlen(prmt_ptr);
+	put_prompt();
+}
+#else
+static void parse_prompt(const char *prmt_ptr)
+{
+	int prmt_len = 0;
+	size_t cur_prmt_len = 0;
+	char flg_not_length = '[';
+	char *prmt_mem_ptr = xzalloc(1);
+	char *pwd_buf = xgetcwd(0);
+	char buf2[PATH_MAX + 1];
+	char buf[2];
+	char c;
+	char *pbuf;
+
+	cmdedit_prmt_len = 0;
+
+	if (!pwd_buf) {
+		pwd_buf = (char *)bb_msg_unknown;
+	}
+
+	while (*prmt_ptr) {
+		pbuf = buf;
+		pbuf[1] = 0;
+		c = *prmt_ptr++;
+		if (c == '\\') {
+			const char *cp = prmt_ptr;
+			int l;
+
+			c = bb_process_escape_sequence(&prmt_ptr);
+			if (prmt_ptr == cp) {
+				if (*cp == 0)
+					break;
+				c = *prmt_ptr++;
+				switch (c) {
+#if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR
+				case 'u':
+					pbuf = user_buf;
+					break;
+#endif
+				case 'h':
+					pbuf = hostname_buf;
+					if (!pbuf) {
+						pbuf = xzalloc(256);
+						if (gethostname(pbuf, 255) < 0) {
+							strcpy(pbuf, "?");
+						} else {
+							char *s = strchr(pbuf, '.');
+							if (s)
+								*s = '\0';
+						}
+						hostname_buf = pbuf;
+					}
+					break;
+				case '$':
+					c = (geteuid() == 0 ? '#' : '$');
+					break;
+#if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR
+				case 'w':
+					pbuf = pwd_buf;
+					l = strlen(home_pwd_buf);
+					if (home_pwd_buf[0] != 0
+					 && strncmp(home_pwd_buf, pbuf, l) == 0
+					 && (pbuf[l]=='/' || pbuf[l]=='\0')
+					 && strlen(pwd_buf+l)<PATH_MAX
+					) {
+						pbuf = buf2;
+						*pbuf = '~';
+						strcpy(pbuf+1, pwd_buf+l);
+					}
+					break;
+#endif
+				case 'W':
+					pbuf = pwd_buf;
+					cp = strrchr(pbuf,'/');
+					if (cp != NULL && cp != pbuf)
+						pbuf += (cp-pbuf) + 1;
+					break;
+				case '!':
+					pbuf = buf2;
+					snprintf(buf2, sizeof(buf2), "%d", num_ok_lines);
+					break;
+				case 'e': case 'E':     /* \e \E = \033 */
+					c = '\033';
+					break;
+				case 'x': case 'X':
+					for (l = 0; l < 3;) {
+						int h;
+						buf2[l++] = *prmt_ptr;
+						buf2[l] = 0;
+						h = strtol(buf2, &pbuf, 16);
+						if (h > UCHAR_MAX || (pbuf - buf2) < l) {
+							l--;
+							break;
+						}
+						prmt_ptr++;
+					}
+					buf2[l] = 0;
+					c = (char)strtol(buf2, NULL, 16);
+					if (c == 0)
+						c = '?';
+					pbuf = buf;
+					break;
+				case '[': case ']':
+					if (c == flg_not_length) {
+						flg_not_length = flg_not_length == '[' ? ']' : '[';
+						continue;
+					}
+					break;
+				}
+			}
+		}
+		if (pbuf == buf)
+			*pbuf = c;
+		cur_prmt_len = strlen(pbuf);
+		prmt_len += cur_prmt_len;
+		if (flg_not_length != ']')
+			cmdedit_prmt_len += cur_prmt_len;
+		prmt_mem_ptr = strcat(xrealloc(prmt_mem_ptr, prmt_len+1), pbuf);
+	}
+	if (pwd_buf != (char *)bb_msg_unknown)
+		free(pwd_buf);
+	cmdedit_prompt = prmt_mem_ptr;
+	put_prompt();
+}
+#endif
+
+#define setTermSettings(fd, argp) tcsetattr(fd, TCSANOW, argp)
+#define getTermSettings(fd, argp) tcgetattr(fd, argp);
+
+static sighandler_t previous_SIGWINCH_handler;
+
+static void cmdedit_setwidth(unsigned w, int redraw_flg)
+{
+	cmdedit_termw = w;
+	if (redraw_flg) {
+		/* new y for current cursor */
+		int new_y = (cursor + cmdedit_prmt_len) / w;
+		/* redraw */
+		redraw((new_y >= cmdedit_y ? new_y : cmdedit_y), command_len - cursor);
+		fflush(stdout);
+	}
+}
+
+static void win_changed(int nsig)
+{
+	int width;
+	get_terminal_width_height(0, &width, NULL);
+	cmdedit_setwidth(width, nsig /* - just a yes/no flag */);
+	if (nsig == SIGWINCH)
+		signal(SIGWINCH, win_changed); /* rearm ourself */
+}
+
+/*
+ * The emacs and vi modes share much of the code in the big
+ * command loop.  Commands entered when in vi's command mode (aka
+ * "escape mode") get an extra bit added to distinguish them --
+ * this keeps them from being self-inserted.  This clutters the
+ * big switch a bit, but keeps all the code in one place.
+ */
+
+#define vbit 0x100
+
+/* leave out the "vi-mode"-only case labels if vi editing isn't
+ * configured. */
+#define vi_case(caselabel) USE_FEATURE_EDITING(case caselabel)
+
+/* convert uppercase ascii to equivalent control char, for readability */
+#undef CTRL
+#define CTRL(a) ((a) & ~0x40)
+
+int read_line_input(const char* prompt, char* command, int maxsize, line_input_t *st)
+{
+	static const int null_flags;
+
+	int lastWasTab = FALSE;
+	unsigned int ic;
+	unsigned char c;
+	smallint break_out = 0;
+#if ENABLE_FEATURE_EDITING_VI
+	smallint vi_cmdmode = 0;
+	smalluint prevc;
+#endif
+
+// FIXME: audit & improve this
+	if (maxsize > BUFSIZ)
+		maxsize = BUFSIZ;
+
+	/* With null flags, no other fields are ever used */
+	state = st ? st : (line_input_t*) &null_flags;
+	if (state->flags & SAVE_HISTORY)
+		load_history(state->hist_file);
+
+	/* prepare before init handlers */
+	cmdedit_y = 0;  /* quasireal y, not true if line > xt*yt */
+	command_len = 0;
+	command_ps = command;
+	command[0] = '\0';
+
+	getTermSettings(0, (void *) &initial_settings);
+	memcpy(&new_settings, &initial_settings, sizeof(new_settings));
+	new_settings.c_lflag &= ~ICANON;        /* unbuffered input */
+	/* Turn off echoing and CTRL-C, so we can trap it */
+	new_settings.c_lflag &= ~(ECHO | ECHONL | ISIG);
+	/* Hmm, in linux c_cc[] is not parsed if ICANON is off */
+	new_settings.c_cc[VMIN] = 1;
+	new_settings.c_cc[VTIME] = 0;
+	/* Turn off CTRL-C, so we can trap it */
+#ifndef _POSIX_VDISABLE
+#define _POSIX_VDISABLE '\0'
+#endif
+	new_settings.c_cc[VINTR] = _POSIX_VDISABLE;
+	setTermSettings(0, (void *) &new_settings);
+
+	/* Now initialize things */
+	previous_SIGWINCH_handler = signal(SIGWINCH, win_changed);
+	win_changed(0); /* do initial resizing */
+#if ENABLE_FEATURE_GETUSERNAME_AND_HOMEDIR
+	{
+		struct passwd *entry;
+
+		entry = getpwuid(geteuid());
+		if (entry) {
+			user_buf = xstrdup(entry->pw_name);
+			home_pwd_buf = xstrdup(entry->pw_dir);
+		}
+	}
+#endif
+#if ENABLE_FEATURE_TAB_COMPLETION
+	my_uid = getuid();
+	my_gid = getgid();
+#endif
+	/* Print out the command prompt */
+	parse_prompt(prompt);
+
+	while (1) {
+		fflush(stdout);
+
+		if (safe_read(0, &c, 1) < 1) {
+			/* if we can't read input then exit */
+			goto prepare_to_die;
+		}
+
+		ic = c;
+
+#if ENABLE_FEATURE_EDITING_VI
+		newdelflag = 1;
+		if (vi_cmdmode)
+			ic |= vbit;
+#endif
+		switch (ic) {
+		case '\n':
+		case '\r':
+		vi_case('\n'|vbit:)
+		vi_case('\r'|vbit:)
+			/* Enter */
+			goto_new_line();
+			break_out = 1;
+			break;
+#if ENABLE_FEATURE_EDITING_FANCY_KEYS
+		case CTRL('A'):
+		vi_case('0'|vbit:)
+			/* Control-a -- Beginning of line */
+			input_backward(cursor);
+			break;
+		case CTRL('B'):
+		vi_case('h'|vbit:)
+		vi_case('\b'|vbit:)
+		vi_case('\x7f'|vbit:) /* DEL */
+			/* Control-b -- Move back one character */
+			input_backward(1);
+			break;
+#endif
+		case CTRL('C'):
+		vi_case(CTRL('C')|vbit:)
+			/* Control-c -- stop gathering input */
+			goto_new_line();
+			command_len = 0;
+			break_out = -1; /* "do not append '\n'" */
+			break;
+		case CTRL('D'):
+			/* Control-d -- Delete one character, or exit
+			 * if the len=0 and no chars to delete */
+			if (command_len == 0) {
+				errno = 0;
+ prepare_to_die:
+				/* to control stopped jobs */
+				break_out = command_len = -1;
+				break;
+			}
+			input_delete(0);
+			break;
+
+#if ENABLE_FEATURE_EDITING_FANCY_KEYS
+		case CTRL('E'):
+		vi_case('$'|vbit:)
+			/* Control-e -- End of line */
+			input_end();
+			break;
+		case CTRL('F'):
+		vi_case('l'|vbit:)
+		vi_case(' '|vbit:)
+			/* Control-f -- Move forward one character */
+			input_forward();
+			break;
+#endif
+
+		case '\b':
+		case '\x7f': /* DEL */
+			/* Control-h and DEL */
+			input_backspace();
+			break;
+
+		case '\t':
+			input_tab(&lastWasTab);
+			break;
+
+#if ENABLE_FEATURE_EDITING_FANCY_KEYS
+		case CTRL('K'):
+			/* Control-k -- clear to end of line */
+			command[cursor] = 0;
+			command_len = cursor;
+			printf("\033[J");
+			break;
+		case CTRL('L'):
+		vi_case(CTRL('L')|vbit:)
+			/* Control-l -- clear screen */
+			printf("\033[H");
+			redraw(0, command_len - cursor);
+			break;
+#endif
+
+#if MAX_HISTORY > 0
+		case CTRL('N'):
+		vi_case(CTRL('N')|vbit:)
+		vi_case('j'|vbit:)
+			/* Control-n -- Get next command in history */
+			if (get_next_history())
+				goto rewrite_line;
+			break;
+		case CTRL('P'):
+		vi_case(CTRL('P')|vbit:)
+		vi_case('k'|vbit:)
+			/* Control-p -- Get previous command from history */
+			if ((state->flags & DO_HISTORY) && state->cur_history > 0) {
+				get_previous_history();
+				goto rewrite_line;
+			}
+			beep();
+			break;
+#endif
+
+#if ENABLE_FEATURE_EDITING_FANCY_KEYS
+		case CTRL('U'):
+		vi_case(CTRL('U')|vbit:)
+			/* Control-U -- Clear line before cursor */
+			if (cursor) {
+				strcpy(command, command + cursor);
+				command_len -= cursor;
+				redraw(cmdedit_y, command_len);
+			}
+			break;
+#endif
+		case CTRL('W'):
+		vi_case(CTRL('W')|vbit:)
+			/* Control-W -- Remove the last word */
+			while (cursor > 0 && isspace(command[cursor-1]))
+				input_backspace();
+			while (cursor > 0 && !isspace(command[cursor-1]))
+				input_backspace();
+			break;
+
+#if ENABLE_FEATURE_EDITING_VI
+		case 'i'|vbit:
+			vi_cmdmode = 0;
+			break;
+		case 'I'|vbit:
+			input_backward(cursor);
+			vi_cmdmode = 0;
+			break;
+		case 'a'|vbit:
+			input_forward();
+			vi_cmdmode = 0;
+			break;
+		case 'A'|vbit:
+			input_end();
+			vi_cmdmode = 0;
+			break;
+		case 'x'|vbit:
+			input_delete(1);
+			break;
+		case 'X'|vbit:
+			if (cursor > 0) {
+				input_backward(1);
+				input_delete(1);
+			}
+			break;
+		case 'W'|vbit:
+			vi_Word_motion(command, 1);
+			break;
+		case 'w'|vbit:
+			vi_word_motion(command, 1);
+			break;
+		case 'E'|vbit:
+			vi_End_motion(command);
+			break;
+		case 'e'|vbit:
+			vi_end_motion(command);
+			break;
+		case 'B'|vbit:
+			vi_Back_motion(command);
+			break;
+		case 'b'|vbit:
+			vi_back_motion(command);
+			break;
+		case 'C'|vbit:
+			vi_cmdmode = 0;
+			/* fall through */
+		case 'D'|vbit:
+			goto clear_to_eol;
+
+		case 'c'|vbit:
+			vi_cmdmode = 0;
+			/* fall through */
+		case 'd'|vbit: {
+			int nc, sc;
+			sc = cursor;
+			prevc = ic;
+			if (safe_read(0, &c, 1) < 1)
+				goto prepare_to_die;
+			if (c == (prevc & 0xff)) {
+				/* "cc", "dd" */
+				input_backward(cursor);
+				goto clear_to_eol;
+				break;
+			}
+			switch (c) {
+			case 'w':
+			case 'W':
+			case 'e':
+			case 'E':
+				switch (c) {
+				case 'w':   /* "dw", "cw" */
+					vi_word_motion(command, vi_cmdmode);
+					break;
+				case 'W':   /* 'dW', 'cW' */
+					vi_Word_motion(command, vi_cmdmode);
+					break;
+				case 'e':   /* 'de', 'ce' */
+					vi_end_motion(command);
+					input_forward();
+					break;
+				case 'E':   /* 'dE', 'cE' */
+					vi_End_motion(command);
+					input_forward();
+					break;
+				}
+				nc = cursor;
+				input_backward(cursor - sc);
+				while (nc-- > cursor)
+					input_delete(1);
+				break;
+			case 'b':  /* "db", "cb" */
+			case 'B':  /* implemented as B */
+				if (c == 'b')
+					vi_back_motion(command);
+				else
+					vi_Back_motion(command);
+				while (sc-- > cursor)
+					input_delete(1);
+				break;
+			case ' ':  /* "d ", "c " */
+				input_delete(1);
+				break;
+			case '$':  /* "d$", "c$" */
+			clear_to_eol:
+				while (cursor < command_len)
+					input_delete(1);
+				break;
+			}
+			break;
+		}
+		case 'p'|vbit:
+			input_forward();
+			/* fallthrough */
+		case 'P'|vbit:
+			put();
+			break;
+		case 'r'|vbit:
+			if (safe_read(0, &c, 1) < 1)
+				goto prepare_to_die;
+			if (c == 0)
+				beep();
+			else {
+				*(command + cursor) = c;
+				putchar(c);
+				putchar('\b');
+			}
+			break;
+#endif /* FEATURE_COMMAND_EDITING_VI */
+
+		case '\x1b': /* ESC */
+
+#if ENABLE_FEATURE_EDITING_VI
+			if (state->flags & VI_MODE) {
+				/* ESC: insert mode --> command mode */
+				vi_cmdmode = 1;
+				input_backward(1);
+				break;
+			}
+#endif
+			/* escape sequence follows */
+			if (safe_read(0, &c, 1) < 1)
+				goto prepare_to_die;
+			/* different vt100 emulations */
+			if (c == '[' || c == 'O') {
+		vi_case('['|vbit:)
+		vi_case('O'|vbit:)
+				if (safe_read(0, &c, 1) < 1)
+					goto prepare_to_die;
+			}
+			if (c >= '1' && c <= '9') {
+				unsigned char dummy;
+
+				if (safe_read(0, &dummy, 1) < 1)
+					goto prepare_to_die;
+				if (dummy != '~')
+					c = '\0';
+			}
+
+			switch (c) {
+#if ENABLE_FEATURE_TAB_COMPLETION
+			case '\t':                      /* Alt-Tab */
+				input_tab(&lastWasTab);
+				break;
+#endif
+#if MAX_HISTORY > 0
+			case 'A':
+				/* Up Arrow -- Get previous command from history */
+				if ((state->flags & DO_HISTORY) && state->cur_history > 0) {
+					get_previous_history();
+					goto rewrite_line;
+				}
+				beep();
+				break;
+			case 'B':
+				/* Down Arrow -- Get next command in history */
+				if (!get_next_history())
+					break;
+ rewrite_line:
+				/* Rewrite the line with the selected history item */
+				/* change command */
+				command_len = strlen(strcpy(command, state->history[state->cur_history]));
+				/* redraw and go to eol (bol, in vi */
+				redraw(cmdedit_y, (state->flags & VI_MODE) ? 9999 : 0);
+				break;
+#endif
+			case 'C':
+				/* Right Arrow -- Move forward one character */
+				input_forward();
+				break;
+			case 'D':
+				/* Left Arrow -- Move back one character */
+				input_backward(1);
+				break;
+			case '3':
+				/* Delete */
+				input_delete(0);
+				break;
+			case '1':
+			case 'H':
+				/* <Home> */
+				input_backward(cursor);
+				break;
+			case '4':
+			case 'F':
+				/* <End> */
+				input_end();
+				break;
+			default:
+				c = '\0';
+				beep();
+			}
+			break;
+
+		default:        /* If it's regular input, do the normal thing */
+#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
+			/* Control-V -- Add non-printable symbol */
+			if (c == CTRL('V')) {
+				if (safe_read(0, &c, 1) < 1)
+					goto prepare_to_die;
+				if (c == 0) {
+					beep();
+					break;
+				}
+			} else
+#endif
+
+#if ENABLE_FEATURE_EDITING_VI
+			if (vi_cmdmode)  /* Don't self-insert */
+				break;
+#endif
+			if (!Isprint(c)) /* Skip non-printable characters */
+				break;
+
+			if (command_len >= (maxsize - 2))        /* Need to leave space for enter */
+				break;
+
+			command_len++;
+			if (cursor == (command_len - 1)) {      /* Append if at the end of the line */
+				command[cursor] = c;
+				command[cursor+1] = '\0';
+				cmdedit_set_out_char(' ');
+			} else {                        /* Insert otherwise */
+				int sc = cursor;
+
+				memmove(command + sc + 1, command + sc, command_len - sc);
+				command[sc] = c;
+				sc++;
+				/* rewrite from cursor */
+				input_end();
+				/* to prev x pos + 1 */
+				input_backward(cursor - sc);
+			}
+			break;
+		}
+		if (break_out)                  /* Enter is the command terminator, no more input. */
+			break;
+
+		if (c != '\t')
+			lastWasTab = FALSE;
+	}
+
+	if (command_len > 0)
+		remember_in_history(command);
+
+	if (break_out > 0) {
+		command[command_len++] = '\n';
+		command[command_len] = '\0';
+	}
+
+#if ENABLE_FEATURE_CLEAN_UP && ENABLE_FEATURE_TAB_COMPLETION
+	free_tab_completion_data();
+#endif
+
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+	free((char*)cmdedit_prompt);
+#endif
+	/* restore initial_settings */
+	setTermSettings(STDIN_FILENO, (void *) &initial_settings);
+	/* restore SIGWINCH handler */
+	signal(SIGWINCH, previous_SIGWINCH_handler);
+	fflush(stdout);
+	return command_len;
+}
+
+line_input_t *new_line_input_t(int flags)
+{
+	line_input_t *n = xzalloc(sizeof(*n));
+	n->flags = flags;
+	return n;
+}
+
+#else
+
+#undef read_line_input
+int read_line_input(const char* prompt, char* command, int maxsize)
+{
+	fputs(prompt, stdout);
+	fflush(stdout);
+	fgets(command, maxsize, stdin);
+	return strlen(command);
+}
+
+#endif  /* FEATURE_COMMAND_EDITING */
+
+
+/*
+ * Testing
+ */
+
+#ifdef TEST
+
+#include <locale.h>
+
+const char *applet_name = "debug stuff usage";
+
+int main(int argc, char **argv)
+{
+	char buff[BUFSIZ];
+	char *prompt =
+#if ENABLE_FEATURE_EDITING_FANCY_PROMPT
+		"\\[\\033[32;1m\\]\\u@\\[\\x1b[33;1m\\]\\h:"
+		"\\[\\033[34;1m\\]\\w\\[\\033[35;1m\\] "
+		"\\!\\[\\e[36;1m\\]\\$ \\[\\E[0m\\]";
+#else
+		"% ";
+#endif
+
+#if ENABLE_FEATURE_NONPRINTABLE_INVERSE_PUT
+	setlocale(LC_ALL, "");
+#endif
+	while (1) {
+		int l;
+		l = read_line_input(prompt, buff);
+		if (l <= 0 || buff[l-1] != '\n')
+			break;
+		buff[l-1] = 0;
+		printf("*** read_line_input() returned line =%s=\n", buff);
+	}
+	printf("*** read_line_input() detect ^D\n");
+	return 0;
+}
+
+#endif  /* TEST */