--- libaitcli/src/aitcli.c	2010/06/04 11:30:31	1.1.1.1.2.17
+++ libaitcli/src/aitcli.c	2010/06/04 13:51:21	1.2.2.3
@@ -3,7 +3,7 @@
 *  by Michael Pounov <misho@openbsd-bg.org>
 *
 * $Author: misho $
-* $Id: aitcli.c,v 1.1.1.1.2.17 2010/06/04 11:30:31 misho Exp $
+* $Id: aitcli.c,v 1.2.2.3 2010/06/04 13:51:21 misho Exp $
 *
 *************************************************************************/
 #include "global.h"
@@ -11,224 +11,902 @@
 
 #pragma GCC visibility push(hidden)
 
-cliCommands_t cli_stdCmds[] = {
+/*
+commands_t cli_stdCmds[] = {
 	{ "test", cli_Cmd_Unsupported, "Test - Don`t use default command structure!", "test <cr>", cli_Comp_Filename }, 
 	{ "-------", NULL, "---------------------", NULL, NULL }, 
 	{ "help", cli_Cmd_Help, "Help screen", "help [command] <cr>", NULL }, 
 	{ "exit", cli_Cmd_Exit, "Exit from console", "exit <cr>", NULL }, 
 	{ NULL, NULL, NULL, NULL }
 };
+*/
 
 // ------------------------------------------------
 
 int cli_Errno;
 char cli_Error[STRSIZ];
 
-char cli_pending_special_char;
-
 #pragma GCC visibility pop
 
+// cli_GetErrno() Get error code of last operation
+inline int
+cli_GetErrno()
+{
+	return cli_Errno;
+}
 
-static void cli_Null_Prep_Term(int meta)
+// io_GetError() Get error text of last operation
+inline const char *
+cli_GetError()
 {
+	return cli_Error;
 }
 
-static int cli_Net_rl_GetCh(FILE *s)
+// cli_SetErr() Set error to variables for internal use!!!
+inline void
+cli_SetErr(int eno, char *estr, ...)
 {
-	int ch = rl_getc(s);
+	va_list lst;
 
-	if (!cli_pending_special_char && 0x1b == ch) {
-		cli_pending_special_char = ch;
-		return ch;
+	cli_Errno = eno;
+	memset(cli_Error, 0, STRSIZ);
+	va_start(lst, estr);
+	vsnprintf(cli_Error, STRSIZ, estr, lst);
+	va_end(lst);
+}
+
+// ------------------------------------------------------------
+
+static inline void
+clrscrEOL(linebuffer_t * __restrict buf)
+{
+	register int i;
+
+	if (buf) {
+		write(buf->line_out, K_CR, 1);
+
+		for (i = 0; i < buf->line_len; i++)
+			write(buf->line_out, K_SPACE, 1);
 	}
-	if (cli_pending_special_char && 0x5b == ch) {
-		cli_pending_special_char = ch;
-		return ch;
+}
+
+static inline void
+printfEOL(linebuffer_t * __restrict buf, int len, int prompt)
+{
+	if (buf) {
+		write(buf->line_out, K_CR, 1);
+
+		if (prompt && buf->line_prompt)
+			write(buf->line_out, buf->line_prompt, buf->line_bol);
+
+		write(buf->line_out, buf->line_buf, len == -1 ? buf->line_eol - buf->line_bol: len);
 	}
-	if (0x5b == cli_pending_special_char) {
-		cli_pending_special_char = 0;
-		return ch;
+}
+
+static inline void
+printfCR(linebuffer_t * __restrict buf, int prompt)
+{
+	if (buf) {
+		write(buf->line_out, K_CR, 1);
+
+		if (prompt)
+			if (prompt && buf->line_prompt)
+				write(buf->line_out, buf->line_prompt, buf->line_bol);
 	}
+}
 
-	cli_pending_special_char = 0;
-	fputc(ch, rl_outstream);
-	fflush(rl_outstream);
-	return ch;
+static inline void
+printfCLI(linebuffer_t * __restrict buf, const unsigned char *text, int textlen, int prompt)
+{
+	if (buf && text && textlen) {
+		if (prompt && buf->line_prompt)
+			write(buf->line_out, buf->line_prompt, buf->line_bol);
+
+		write(buf->line_out, text, textlen);
+	}
 }
 
-#if 0
-static void cli_Line_Handler(char *line)
+// ------------------------------------------------------------
+
+static int
+bufCHAR(int idx, void * __restrict buffer)
 {
-	int len;
-	static char cli_Buffer[BUFSIZ];
-	static int cli_BufferLen, cli_BufferPos;
+	linebuffer_t *buf = buffer;
+	int pos;
 
-	if (!line) {	// EOF
-		fwrite("\x4", 1, 1, rl_outstream);	// ctrl+D
-		goto end;
-	} else
-		len = strlen(line);
-	if (BUFSIZ - 2 < len)
-		cli_BufferPos = cli_BufferLen = 0;
-	else {
-		if (BUFSIZ - 2 < len + cli_BufferLen) {
-			if (BUFSIZ - 2 >= cli_BufferLen - cli_BufferPos + len) {
-				cli_BufferLen -= cli_BufferPos;
-				memmove(cli_Buffer, cli_Buffer + cli_BufferPos, cli_BufferLen);
-			} else
-				cli_BufferLen = 0;
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
 
-			cli_BufferPos = 0;
-		}
+	pos = buf->line_eol - buf->line_bol;
 
-		memcpy(cli_Buffer + cli_BufferLen, line, len);
-		cli_BufferLen += len;
-		cli_Buffer[cli_BufferLen++] = '\r';
-		cli_Buffer[cli_BufferLen++] = '\n';
+	if (buf->line_mode == LINEMODE_INS)
+		memmove(buf->line_buf + pos + buf->line_keys[idx].key_len, buf->line_buf + pos, 
+				buf->line_len - buf->line_eol);
+	if (buf->line_mode == LINEMODE_INS || buf->line_eol == buf->line_len - 1)
+		buf->line_len += buf->line_keys[idx].key_len;
+	buf->line_eol += buf->line_keys[idx].key_len;
+
+	memcpy(buf->line_buf + pos, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
+	buf->line_buf[buf->line_len - 1] = 0;
+
+	write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
+
+	if (buf->line_mode == LINEMODE_INS) {
+		printfCLI(buf, (const u_char*) buf->line_buf + pos + buf->line_keys[idx].key_len, 
+				buf->line_len - buf->line_eol, 0);
+		printfEOL(buf, -1, 1);
 	}
+	return RETCODE_OK;
+}
 
-	fwrite(cli_Buffer, 1, cli_BufferLen, rl_outstream);
-	if (!cli_pending_special_char) {
-		fwrite("\r", 1, 1, rl_outstream);
-		if (*line)
-			add_history(line);
+static int
+bufEOL(int idx, void * __restrict buffer)
+{
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	printfCR(buffer, 1);
+	return RETCODE_EOL;
+}
+
+static int
+bufEOF(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	write(buf->line_out, buf->line_keys[idx].key_ch, buf->line_keys[idx].key_len);
+	return RETCODE_EOF;
+}
+
+static int
+bufUP(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+	int pos;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	if (!buf->line_h)
+		buf->line_h = TAILQ_FIRST(&buf->line_history);
+	else
+		buf->line_h = TAILQ_NEXT(buf->line_h, hist_next);
+	if (!buf->line_h)
+		return RETCODE_OK;
+
+	clrscrEOL(buf);
+	cli_freeLine(buf);
+
+	pos = buf->line_eol - buf->line_bol;
+
+	buf->line_len += buf->line_h->hist_len;
+	buf->line_eol += buf->line_h->hist_len;
+
+	memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len);
+	buf->line_buf[buf->line_len - 1] = 0;
+
+	printfEOL(buf, -1, 1);
+	return RETCODE_OK;
+}
+
+static int
+bufDOWN(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+	int pos;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	if (!buf->line_h)
+		buf->line_h = TAILQ_LAST(&buf->line_history, tqHistoryHead);
+	else
+		buf->line_h = TAILQ_PREV(buf->line_h, tqHistoryHead, hist_next);
+	if (!buf->line_h)
+		return RETCODE_OK;
+
+	clrscrEOL(buf);
+	cli_freeLine(buf);
+
+	pos = buf->line_eol - buf->line_bol;
+
+	buf->line_len += buf->line_h->hist_len;
+	buf->line_eol += buf->line_h->hist_len;
+
+	memcpy(buf->line_buf + pos, buf->line_h->hist_line, buf->line_h->hist_len);
+	buf->line_buf[buf->line_len - 1] = 0;
+
+	printfEOL(buf, -1, 1);
+	return RETCODE_OK;
+}
+
+static int
+bufCLR(int idx, void * __restrict buffer)
+{
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	clrscrEOL(buffer);
+	cli_freeLine(buffer);
+
+	printfCR(buffer, 1);
+	return RETCODE_OK;
+}
+
+static int
+bufBS(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	if (buf->line_bol < buf->line_eol) {
+		clrscrEOL(buf);
+
+		buf->line_eol--;
+		buf->line_len--;
+		memmove(buf->line_buf + buf->line_eol - buf->line_bol, 
+				buf->line_buf + buf->line_eol - buf->line_bol + 1, 
+				buf->line_len - buf->line_eol);
+		buf->line_buf[buf->line_len - 1] = 0;
+
+		printfEOL(buf, buf->line_len - 1, 1);
+		printfEOL(buf, -1, 1);
 	}
 
-	free(line);
-end:
-	rl_callback_handler_remove();
-	if (cli_pending_special_char) {
-		fwrite(&cli_pending_special_char, 1, 1, rl_outstream);
-		cli_pending_special_char = 0;
+	return RETCODE_OK;
+}
+
+static int
+bufBTAB(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	if (buf->line_bol < buf->line_eol) {
+		clrscrEOL(buf);
+
+		buf->line_len = buf->line_eol - buf->line_bol + 1;
+		buf->line_buf[buf->line_len - 1] = 0;
+
+		printfEOL(buf, -1, 1);
 	}
-	fflush(rl_outstream);
+
+	return RETCODE_OK;
 }
-#endif
 
+static int
+bufMODE(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
 
-// cli_GetErrno() Get error code of last operation
-inline int cli_GetErrno()
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	buf->line_mode = !buf->line_mode ? LINEMODE_OVER : LINEMODE_INS;
+	return RETCODE_OK;
+}
+
+static int
+bufBEGIN(int idx, void * __restrict buffer)
 {
-	return cli_Errno;
+	linebuffer_t *buf = buffer;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	buf->line_eol = buf->line_bol;
+
+	printfCR(buf, 1);
+	return RETCODE_OK;
 }
 
-// io_GetError() Get error text of last operation
-inline const char *cli_GetError()
+static int
+bufEND(int idx, void * __restrict buffer)
 {
-	return cli_Error;
+	linebuffer_t *buf = buffer;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	buf->line_eol = buf->line_len - 1;
+
+	printfEOL(buf, -1, 1);
+	return RETCODE_OK;
 }
 
-// cli_SetErr() Set error to variables for internal use!!!
-inline void cli_SetErr(int eno, char *estr, ...)
+static int
+bufLEFT(int idx, void * __restrict buffer)
 {
-	va_list lst;
+	linebuffer_t *buf = buffer;
 
-	cli_Errno = eno;
-	memset(cli_Error, 0, STRSIZ);
-	va_start(lst, estr);
-	vsnprintf(cli_Error, STRSIZ, estr, lst);
-	va_end(lst);
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	if (buf->line_bol < buf->line_eol)
+		printfEOL(buf, --buf->line_eol - buf->line_bol, 1);
+
+	return RETCODE_OK;
 }
 
-// ------------------------------------------------------------
+static int
+bufRIGHT(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
 
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	if (buf->line_eol < buf->line_len - 1)
+		printfEOL(buf, ++buf->line_eol - buf->line_bol, 1);
+
+	return RETCODE_OK;
+}
+
+static int
+bufDEL(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	clrscrEOL(buf);
+
+	buf->line_len--;
+	memmove(buf->line_buf + buf->line_eol - buf->line_bol, 
+			buf->line_buf + buf->line_eol - buf->line_bol + 1, 
+			buf->line_len - buf->line_eol);
+	buf->line_buf[buf->line_len - 1] = 0;
+
+	printfEOL(buf, buf->line_len - 1, 1);
+	printfEOL(buf, -1, 1);
+
+	return RETCODE_OK;
+}
+
+// ---------------------------------------------------------------
+
 /*
- * cli_Printf() Printf CLI features
- * @out = Output stream
- * @csFormat = Printf format string
- * return: -1 error, != -1 printed chars
+ * cli_BindKey() Bind function to key
+ * @key = key structure
+ * @buffer = CLI buffer
+ * return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position
 */
-inline int cli_Printf(FILE *out, const char *csFormat, ...)
+int
+cli_BindKey(bindkey_t * __restrict key, linebuffer_t * __restrict buffer)
 {
-	va_list lst;
-	int ret;
+	register int i;
 
-	va_start(lst, csFormat);
+	if (!key || !buffer) {
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+		return RETCODE_ERR;
+	}
 
-	ret = vfprintf(out, csFormat, lst);
-	if (-1 == ret)
+	for (i = 0; i < MAX_BINDKEY; i++)
+		if (key->key_len == buffer->line_keys[i].key_len && 
+				!memcmp(key->key_ch, buffer->line_keys[i].key_ch, key->key_len)) {
+			buffer->line_keys[i].key_func = key->key_func;
+			return i;
+		}
+
+	return RETCODE_OK;
+}
+
+
+/*
+ * cli_addHistory() Add line to history
+ * @buffer = CLI buffer
+ * @str = Add text
+ * return: RETCODE_ERR error, RETCODE_OK ok
+*/
+int
+cli_addHistory(linebuffer_t * __restrict buffer, const char * __restrict str)
+{
+	struct tagHistory *h;
+
+	if (!buffer) {
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+		return RETCODE_ERR;
+	}
+
+	if (!(h = malloc(sizeof(struct tagHistory)))) {
 		LOGERR;
+		return RETCODE_ERR;
+	} else
+		memset(h, 0, sizeof(struct tagHistory));
 
-	va_end(lst);
-	return ret;
+	if (str) {
+		if (!*str) {
+			free(h);
+			return RETCODE_OK;
+		}
+
+		h->hist_len = strlcpy(h->hist_line, str, BUFSIZ);
+	} else {
+		if (!*buffer->line_buf || buffer->line_len < 2) {
+			free(h);
+			return RETCODE_OK;
+		}
+
+		memcpy(h->hist_line, buffer->line_buf, (h->hist_len = buffer->line_len));
+		io_TrimStr((u_char*) h->hist_line);
+		h->hist_len = strlen(h->hist_line);
+	}
+
+	TAILQ_INSERT_HEAD(&buffer->line_history, h, hist_next);
+	return h->hist_len;
 }
 
+/*
+ * cli_saveHistory() Save history to file
+ * @buffer = CLI buffer
+ * @histfile = History filename, if NULL will be use default name
+ * @lines = Maximum history lines to save
+ * return: RETCODE_ERR error, RETCODE_OK ok
+*/
+int
+cli_saveHistory(linebuffer_t * __restrict buffer, const char *histfile, int lines)
+{
+	FILE *f;
+	mode_t mode;
+	char szFName[MAXPATHLEN];
+	struct tagHistory *h;
 
+	if (!buffer) {
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+		return RETCODE_ERR;
+	}
+	if (!histfile)
+		strlcpy(szFName, HISTORY_FILE, MAXPATHLEN);
+	else
+		strlcpy(szFName, histfile, MAXPATHLEN);
+
+	mode = umask(0177);
+	f = fopen(szFName, "w");
+	if (!f) {
+		LOGERR;
+		return RETCODE_ERR;
+	}
+
+	TAILQ_FOREACH(h, &buffer->line_history, hist_next) {
+		fprintf(f, "%s\n", h->hist_line);
+
+		if (lines)
+			lines--;
+		else
+			break;
+	}
+
+	fclose(f);
+	umask(mode);
+
+	return RETCODE_OK;
+}
+
 /*
- * cliComp() Initialize completion CLI features
- * @cmdComplete = Completion function
- * @cmdEntry = Compentry function
+ * cli_loadHistory() Load history from file
+ * @buffer = CLI buffer
+ * @histfile = History filename, if NULL will be use default name
+ * return: RETCODE_ERR error, RETCODE_OK ok
+*/
+int
+cli_loadHistory(linebuffer_t * __restrict buffer, const char *histfile)
+{
+	FILE *f;
+	char szFName[MAXPATHLEN], buf[BUFSIZ];
+	struct tagHistory *h;
+
+	if (!buffer) {
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+		return RETCODE_ERR;
+	}
+	if (!histfile)
+		strlcpy(szFName, HISTORY_FILE, MAXPATHLEN);
+	else
+		strlcpy(szFName, histfile, MAXPATHLEN);
+
+	f = fopen(szFName, "r");
+	if (!f) {
+		LOGERR;
+		return RETCODE_ERR;
+	}
+
+	while (fgets(buf, BUFSIZ, f)) {
+		if (!*buf || *buf == '#')
+			continue;
+		else
+			io_TrimStr((u_char*) buf);
+
+		if (!(h = malloc(sizeof(struct tagHistory)))) {
+			LOGERR;
+			fclose(f);
+			return RETCODE_ERR;
+		} else
+			memset(h, 0, sizeof(struct tagHistory));
+
+		h->hist_len = strlcpy(h->hist_line, buf, BUFSIZ);
+		TAILQ_INSERT_TAIL(&buffer->line_history, h, hist_next);
+	}
+
+	fclose(f);
+
+	return RETCODE_OK;
+}
+
+/*
+ * cli_resetHistory() Reset history search in CLI session
+ * @buffer = CLI buffer
  * return: none
 */
-inline void cliComp(cli_Completion_t *cmdComplete, cli_CompEntry_t *cmdEntry)
+inline void
+cli_resetHistory(linebuffer_t * __restrict buffer)
 {
-	// command completon
-	rl_attempted_completion_function = cmdComplete;
-	rl_completion_entry_function = cmdEntry;
+	buffer->line_h = NULL;
 }
 
+
 /*
- * cliTTY() Initialize I/O TTY CLI features
- * @term = terminal name
- * @inp = input handle
- * @out = output handle
- * @win = window size
- * return: -1 error, != -1 ok
+ * cli_freeLine() Clear entire line
+ * @buffer = CLI buffer
+ * return: RETCODE_ERR error, RETCODE_OK ok
 */
-inline int cliTTY(const char *term, FILE *inp, FILE *out, struct winsize *win)
+inline int
+cli_freeLine(linebuffer_t * __restrict buffer)
 {
-	if (term)
-		rl_terminal_name = term;
+	int code = RETCODE_ERR;
 
-	if (inp)
-		rl_instream = inp;
-	if (out)
-		rl_outstream = out;
+	if (buffer) {
+		if (buffer->line_buf)
+			free(buffer->line_buf);
 
-	if (win)
-	       if (ioctl(!rl_outstream ? STDOUT_FILENO : fileno(rl_outstream), TIOCSWINSZ, win) == -1) {
-		       LOGERR;
-		       return -1;
-	       }
+		buffer->line_buf = malloc(BUFSIZ);
+		if (buffer->line_buf) {
+			memset(buffer->line_buf, 0, BUFSIZ);
+			buffer->line_eol = buffer->line_bol;
+			buffer->line_len = 1 + buffer->line_eol;
 
-	return 0;
+			code = RETCODE_OK;
+		} else
+			LOGERR;
+	} else
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+
+	return code;
 }
 
 /*
- * cli_ReadHistory() Read CLI History from file
- * @csFile = history file name, if NULL default history name is ".aitcli.history"
- * return: -1 error; != -1 readed ok
+ * cli_setPrompt() Set new prompt for CLI session
+ * @buffer = CLI buffer
+ * @prompt = new text for prompt or if NULL disable prompt
+ * return: none
 */
-inline int cli_ReadHistory(const char *csFile)
+inline void
+cli_setPrompt(linebuffer_t * __restrict buffer, const char *prompt)
 {
-	return read_history(!csFile ? ".aitcli.history" : csFile);
+	if (buffer) {
+		if (buffer->line_prompt) {
+			free(buffer->line_prompt);
+			buffer->line_prompt = NULL;
+			buffer->line_bol = 0;
+		}
+
+		if (prompt) {
+			buffer->line_prompt = strdup(prompt);
+			if (buffer->line_prompt) {
+				buffer->line_bol = strlen(buffer->line_prompt);
+				buffer->line_eol = buffer->line_bol;
+				buffer->line_len = 1 + buffer->line_eol;
+			} else
+				LOGERR;
+		}
+	} else
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
 }
 
+
 /*
- * cli_WriteHistory() Write CLI History to file
- * @csFile = history file name, if NULL default history name is ".aitcli.history"
- * @lineNum = save number of history entry lines, if -1 all lines saved without limit
- * return: -1 error; != -1 readed ok
+ * cliEnd() Clear data, Free resources and close CLI session
+ * @buffer = CLI buffer
+ * return: RETCODE_ERR error, RETCODE_OK ok
 */
-inline int cli_WriteHistory(const char *csFile, int lineNum)
+void
+cliEnd(linebuffer_t * __restrict buffer)
 {
-	int ret;
-	const char *psFile = !csFile ? ".aitcli.history" : csFile;
+	struct tagHistory *h;
 
-	ret = write_history(psFile);
-	if (-1 != ret && -1 != lineNum)
-		history_truncate_file(psFile, lineNum);
+	if (buffer) {
+		while ((h = TAILQ_FIRST(&buffer->line_history))) {
+			TAILQ_REMOVE(&buffer->line_history, h, hist_next);
+			free(h);
+		}
 
-	return ret;
+		if (buffer->line_prompt)
+			free(buffer->line_prompt);
+
+		if (buffer->line_keys)
+			free(buffer->line_keys);
+		if (buffer->line_buf)
+			free(buffer->line_buf);
+
+		free(buffer);
+		buffer = NULL;
+	} else
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
 }
 
 /*
+ * cliInit() Start CLI session, allocate memory for resources and bind keys
+ * @fin = Input device handle
+ * @fout = Output device handle
+ * @prompt = text for prompt, if NULL disable prompt
+ * return: NULL if error or !=NULL CLI buffer
+*/
+linebuffer_t *
+cliInit(int fin, int fout, const char *prompt)
+{
+	linebuffer_t *buffer;
+	bindkey_t *keys;
+	register int i;
+	struct termios t;
+
+	memset(&t, 0, sizeof t);
+	/* init buffer */
+	buffer = malloc(sizeof (linebuffer_t));
+	if (!buffer) {
+		LOGERR;
+		return NULL;
+	} else {
+		memset(buffer, 0, sizeof(linebuffer_t));
+
+		buffer->line_in = fin;
+		buffer->line_out = fout;
+
+		TAILQ_INIT(&buffer->line_history);
+
+		if (prompt) {
+			buffer->line_prompt = strdup(prompt);
+			if (!buffer->line_prompt) {
+				LOGERR;
+				free(buffer);
+				return NULL;
+			} else
+				buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);
+		}
+	}
+	buffer->line_buf = malloc(BUFSIZ);
+	if (!buffer->line_buf) {
+		LOGERR;
+		if (buffer->line_prompt)
+			free(buffer->line_prompt);
+		free(buffer);
+		return NULL;
+	} else {
+		memset(buffer->line_buf, 0, BUFSIZ);
+		buffer->line_len = 1 + buffer->line_eol;
+	}
+	keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
+	if (!keys) {
+		LOGERR;
+		if (buffer->line_prompt)
+			free(buffer->line_prompt);
+		free(buffer->line_buf);
+		free(buffer);
+		return NULL;
+	} else
+		memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));
+
+	/* fill key bindings */
+	// ascii chars & ctrl+chars
+	for (i = 0; i < 256; i++) {
+		*keys[i].key_ch = (u_char) i;
+		keys[i].key_len = 1;
+
+		if (!i || i == *K_CTRL_D)
+			keys[i].key_func = bufEOF;
+		if (i == *K_CTRL_M || i == *K_CTRL_J)
+			keys[i].key_func = bufEOL;
+		if (i == *K_CTRL_H || i == *K_BACKSPACE)
+			keys[i].key_func = bufBS;
+		if (i == *K_CTRL_C)
+			keys[i].key_func = bufCLR;
+		if (i == *K_CTRL_A)
+			keys[i].key_func = bufBEGIN;
+		if (i == *K_CTRL_E)
+			keys[i].key_func = bufEND;
+		if (i >= *K_SPACE && i < *K_BACKSPACE)
+			keys[i].key_func = bufCHAR;
+		if (i > *K_BACKSPACE && i < 0xff)
+			keys[i].key_func = bufCHAR;
+	}
+	// alt+chars
+	for (i = 256; i < 512; i++) {
+		keys[i].key_ch[0] = 0x1b;
+		keys[i].key_ch[1] = (u_char) i - 256;
+		keys[i].key_len = 2;
+	}
+
+	// 3 bytes
+	keys[i].key_len = sizeof K_F1 - 1;
+	memcpy(keys[i].key_ch, K_F1, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F2 - 1;
+	memcpy(keys[i].key_ch, K_F2, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F3 - 1;
+	memcpy(keys[i].key_ch, K_F3, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F4 - 1;
+	memcpy(keys[i].key_ch, K_F4, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F1 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F1, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F2 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F2, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F3 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F3, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F4 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F4, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F5 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F5, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F6 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F6, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F7 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F7, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F8 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F8, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F9 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F9, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F10 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F10, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F11 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F11, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_SH_F12 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_SH_F12, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F1 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F1, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F2 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F2, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F3 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F3, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F4 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F4, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F5 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F5, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F6 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F6, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F7 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F7, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F8 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F8, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F9 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F9, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F10 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F10, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F11 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F11, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_CTRL_F12 - 1;
+	memcpy(keys[i].key_ch, K_CTRL_F12, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_HOME - 1;
+	keys[i].key_func = bufBEGIN;
+	memcpy(keys[i].key_ch, K_HOME, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_END - 1;
+	keys[i].key_func = bufEND;
+	memcpy(keys[i].key_ch, K_END, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_UP - 1;
+	keys[i].key_func = bufUP;
+	memcpy(keys[i].key_ch, K_UP, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_DOWN - 1;
+	keys[i].key_func = bufDOWN;
+	memcpy(keys[i].key_ch, K_DOWN, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_RIGHT - 1;
+	keys[i].key_func = bufRIGHT;
+	memcpy(keys[i].key_ch, K_RIGHT, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_LEFT - 1;
+	keys[i].key_func = bufLEFT;
+	memcpy(keys[i].key_ch, K_LEFT, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_BTAB - 1;
+	keys[i].key_func = bufBTAB;
+	memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);
+	i++;
+	// 4 bytes
+	keys[i].key_len = sizeof K_INS - 1;
+	keys[i].key_func = bufMODE;
+	memcpy(keys[i].key_ch, K_INS, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_DEL - 1;
+	keys[i].key_func = bufDEL;
+	memcpy(keys[i].key_ch, K_DEL, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_PGUP - 1;
+	memcpy(keys[i].key_ch, K_PGUP, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_PGDN - 1;
+	memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);
+	i++;
+	// 5 bytes
+	keys[i].key_len = sizeof K_F5 - 1;
+	memcpy(keys[i].key_ch, K_F5, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F6 - 1;
+	memcpy(keys[i].key_ch, K_F6, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F7 - 1;
+	memcpy(keys[i].key_ch, K_F7, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F8 - 1;
+	memcpy(keys[i].key_ch, K_F8, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F9 - 1;
+	memcpy(keys[i].key_ch, K_F9, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F10 - 1;
+	memcpy(keys[i].key_ch, K_F10, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F11 - 1;
+	memcpy(keys[i].key_ch, K_F11, keys[i].key_len);
+	i++;
+	keys[i].key_len = sizeof K_F12 - 1;
+	memcpy(keys[i].key_ch, K_F12, keys[i].key_len);
+	i++;
+
+	tcgetattr(buffer->line_in, &t);
+	t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOCTL | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT);
+	t.c_iflag |= IGNBRK;
+	t.c_cc[VMIN] = 1;
+	t.c_cc[VTIME] = 0;
+	tcsetattr(buffer->line_in, TCSANOW, &t);
+
+	buffer->line_keys = keys;
+	return buffer;
+}
+
+
+
+/*
  * cliNetInit() Initialize Readline if CLI bind to socket
  * @csProg = program name
  * @pty = Master pty
  * @term = stdin termios
  * return: none
 */
+/*
 void cliNetInit(const char *csProg, int pty, struct termios *term)
 {
 	struct termios t;
@@ -261,7 +939,7 @@ void cliNetInit(const char *csProg, int pty, struct te
 	rl_instream = fdopen(pty, "r");
 	rl_outstream = NULL;
 }
-
+*/
 /*
  * cliNetExec() Execute net CLI main loop
  * @cmdList = Commands list
@@ -271,9 +949,10 @@ void cliNetInit(const char *csProg, int pty, struct te
  * @win = window size of tty
  * return: -1 error, 0 = exit w/^+D, 1 done.
 */
-int cliNetExec(cliCommands_t *cmdList, const char *csPrompt, int sock, struct termios *term, struct winsize *win)
+int
+cliNetExec(commands_t *cmdList, const char *csPrompt, int sock, struct termios *term, struct winsize *win)
 {
-	int pty, ret = 0, alen, attrlen, flg;
+	int pty, ret = 0, r, s, alen, attrlen, flg;
 	fd_set fds;
 	struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
 	u_char buf[BUFSIZ];
@@ -286,10 +965,6 @@ int cliNetExec(cliCommands_t *cmdList, const char *csP
 		case 0:
 			close(sock);
 
-			rl_prep_term_function = cli_Null_Prep_Term;
-			rl_getc_function = cli_Net_rl_GetCh;
-
-			cliNetInit(getprogname(), STDIN_FILENO, term);
 			ret = cliExec(cmdList, csPrompt) < 0 ? 1 : 0;
 			/* spawn Shell mode */
 			/*
@@ -297,21 +972,12 @@ int cliNetExec(cliCommands_t *cmdList, const char *csP
 			*/
 			_exit(ret);
 		default:
-			cliNetInit(getprogname(), pty, term);
-
 			/* spawn Shell mode */
-			/*
 			telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
 			telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
 			telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);
 			telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);
 			telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);
-			*/
-			telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
-			telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
-			telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);
-			telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);
-			telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);
 			if ((ret = telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1) {
 				cli_Errno = telnet_GetErrno();
 				strlcpy(cli_Error, telnet_GetError(), STRSIZ);
@@ -330,80 +996,46 @@ int cliNetExec(cliCommands_t *cmdList, const char *csP
 					break;
 				}
 
-				if (FD_ISSET(sock, &fds)) {
-					memset(buf, 0, BUFSIZ);
-					if ((ret = telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {
-						if (a)
-							free(a);
+				r = FD_ISSET(sock, &fds) ? sock : pty;
+				s = FD_ISSET(sock, &fds) ? pty : sock;
 
-						if (-2 == ret)
-							continue;
-						// EOF
-						if (-3 == ret)
-							shutdown(sock, SHUT_RD);
-						else {
-							cli_Errno = telnet_GetErrno();
-							strlcpy(cli_Error, telnet_GetError(), STRSIZ);
-						}
-						break;
-					}
+				if ((ret = telnetRecv(r, &a, &alen, buf, BUFSIZ)) < 0) {
 					if (a)
 						free(a);
-					if (alen) {
-						attrlen = 0;
-						if (1 == flg && alen) {
-							telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);
-							telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);
-						}
-						if (2 == flg && alen) {
-							telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);
-							telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
-									LFLOW_OFF, NULL, 0);
-							telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
-									LFLOW_RESTART_XON, NULL, 0);
-							telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
-						}
-						if ((ret = telnetSend(sock, Attr, attrlen, buf, ret, 0)) == -1) {
-							cli_Errno = telnet_GetErrno();
-							strlcpy(cli_Error, telnet_GetError(), STRSIZ);
-							break;
-						}
-					}
 
-					if ((ret = write(pty, buf, ret)) == -1) {
-						LOGERR;
-						break;
-					}
-				}
-
-				if (FD_ISSET(pty, &fds)) {
-					memset(buf, 0, BUFSIZ);
-					if ((ret = read(pty, buf, BUFSIZ)) < 1) {
-						if (!ret)
-							shutdown(sock, SHUT_WR);
-						else
-							LOGERR;
-						break;
-					}
-					attrlen = 0;
-					if (1 == flg && alen) {
-						telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);
-						telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);
-					}
-					if (2 == flg && alen) {
-						telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);
-						telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
-								LFLOW_OFF, NULL, 0);
-						telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
-								LFLOW_RESTART_XON, NULL, 0);
-						telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
-					}
-					if ((ret = telnetSend(sock, Attr, attrlen, buf, ret, 0)) == -1) {
+					if (-2 == ret)
+						continue;
+					// EOF
+					if (-3 == ret)
+						shutdown(r, SHUT_RD);
+					else {
 						cli_Errno = telnet_GetErrno();
 						strlcpy(cli_Error, telnet_GetError(), STRSIZ);
-						break;
 					}
+					break;
 				}
+				attrlen = 0;
+				if (1 == flg && alen) {
+					telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);
+					telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);
+				}
+				if (2 == flg && alen) {
+					telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);
+					telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
+							LFLOW_OFF, NULL, 0);
+					telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW, 
+							LFLOW_RESTART_XON, NULL, 0);
+					telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
+				}
+				if (a)
+					free(a);
+
+				if ((ret = telnetSend(s, Attr, pty == s ? 0 : attrlen, buf, ret, 0)) == -1) {
+					cli_Errno = telnet_GetErrno();
+					strlcpy(cli_Error, telnet_GetError(), STRSIZ);
+					break;
+				} else
+					flg++;
 			}
 
 			close(pty);
@@ -418,6 +1050,7 @@ int cliNetExec(cliCommands_t *cmdList, const char *csP
  * @csPrompt = Prompt text
  * return: -1 error, 0 = exit w/^+D, 1 done.
 */
+/*
 int cliExec(cliCommands_t *cmdList, const char *csPrompt)
 {
 	char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
@@ -467,9 +1100,9 @@ int cliExec(cliCommands_t *cmdList, const char *csProm
 	{
 		return NULL;
 	}
-
+*/
 	/* --- main body of CLI --- */
-
+/*
 	out = rl_outstream;
 	if (!out)
 		out = stdout;
@@ -498,11 +1131,6 @@ int cliExec(cliCommands_t *cmdList, const char *csProm
 			for (app = items; app < items + MAX_PROMPT_ITEMS - 1 && (*app = strsep(&s, " \t")); 
 					*app ? app++ : app);
 
-			/*
-			for (i = 0; i < MAX_PROMPT_ITEMS; i++)
-				cli_Printf(out, "i=%d %s\n", i, items[i]);
-				*/
-
 			// exec_cmd ...
 			for (cmd = NULL, i = 0; cmdList[i].cmd_name; i++)
 				if (*items[0] && !strncmp(cmdList[i].cmd_name, items[0], strlen(items[0]))) {
@@ -521,3 +1149,4 @@ int cliExec(cliCommands_t *cmdList, const char *csProm
 
 	return ret;
 }
+*/