--- libaitcli/src/aitcli.c	2010/04/16 13:20:29	1.1.1.1
+++ 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 2010/04/16 13:20:29 misho Exp $
+* $Id: aitcli.c,v 1.2.2.3 2010/06/04 13:51:21 misho Exp $
 *
 *************************************************************************/
 #include "global.h"
@@ -11,13 +11,15 @@
 
 #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 }
 };
+*/
 
 // ------------------------------------------------
 
@@ -26,21 +28,23 @@ char cli_Error[STRSIZ];
 
 #pragma GCC visibility pop
 
-
 // cli_GetErrno() Get error code of last operation
-inline int cli_GetErrno()
+inline int
+cli_GetErrno()
 {
 	return cli_Errno;
 }
 
 // io_GetError() Get error text of last operation
-inline const char *cli_GetError()
+inline const char *
+cli_GetError()
 {
 	return cli_Error;
 }
 
 // cli_SetErr() Set error to variables for internal use!!!
-inline void cli_SetErr(int eno, char *estr, ...)
+inline void
+cli_SetErr(int eno, char *estr, ...)
 {
 	va_list lst;
 
@@ -53,54 +57,1007 @@ inline void cli_SetErr(int eno, char *estr, ...)
 
 // ------------------------------------------------------------
 
+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);
+	}
+}
+
+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);
+	}
+}
+
+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);
+	}
+}
+
+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);
+	}
+}
+
+// ------------------------------------------------------------
+
+static int
+bufCHAR(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+	int pos;
+
+	if (!buffer || idx < 0 || idx > MAX_BINDKEY)
+		return RETCODE_ERR;
+
+	pos = buf->line_eol - buf->line_bol;
+
+	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;
+}
+
+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);
+	}
+
+	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);
+	}
+
+	return RETCODE_OK;
+}
+
+static int
+bufMODE(int idx, void * __restrict buffer)
+{
+	linebuffer_t *buf = buffer;
+
+	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)
+{
+	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;
+}
+
+static int
+bufEND(int idx, void * __restrict buffer)
+{
+	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;
+}
+
+static int
+bufLEFT(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)
+		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
+ * cli_BindKey() Bind function to key
+ * @key = key structure
+ * @buffer = CLI buffer
+ * return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position
+*/
+int
+cli_BindKey(bindkey_t * __restrict key, linebuffer_t * __restrict buffer)
+{
+	register int i;
+
+	if (!key || !buffer) {
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+		return RETCODE_ERR;
+	}
+
+	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));
+
+	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;
+}
+
+/*
+ * 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 int cli_Printf(FILE *out, const char *csFormat, ...)
+inline void
+cli_resetHistory(linebuffer_t * __restrict buffer)
 {
-	va_list lst;
-	int ret;
+	buffer->line_h = NULL;
+}
 
-	va_start(lst, csFormat);
 
-	ret = vfprintf(out, csFormat, lst);
-	if (-1 == ret)
+/*
+ * cli_freeLine() Clear entire line
+ * @buffer = CLI buffer
+ * return: RETCODE_ERR error, RETCODE_OK ok
+*/
+inline int
+cli_freeLine(linebuffer_t * __restrict buffer)
+{
+	int code = RETCODE_ERR;
+
+	if (buffer) {
+		if (buffer->line_buf)
+			free(buffer->line_buf);
+
+		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;
+
+			code = RETCODE_OK;
+		} else
+			LOGERR;
+	} else
+		cli_SetErr(EINVAL, "Error:: invalid input parameters ...");
+
+	return code;
+}
+
+/*
+ * cli_setPrompt() Set new prompt for CLI session
+ * @buffer = CLI buffer
+ * @prompt = new text for prompt or if NULL disable prompt
+ * return: none
+*/
+inline void
+cli_setPrompt(linebuffer_t * __restrict buffer, const char *prompt)
+{
+	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 ...");
+}
+
+
+/*
+ * cliEnd() Clear data, Free resources and close CLI session
+ * @buffer = CLI buffer
+ * return: RETCODE_ERR error, RETCODE_OK ok
+*/
+void
+cliEnd(linebuffer_t * __restrict buffer)
+{
+	struct tagHistory *h;
+
+	if (buffer) {
+		while ((h = TAILQ_FIRST(&buffer->line_history))) {
+			TAILQ_REMOVE(&buffer->line_history, h, hist_next);
+			free(h);
+		}
+
+		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));
 
-	va_end(lst);
-	return ret;
+		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;
 }
 
 
+
 /*
- * cliComp() Initialize completion CLI features
- * @cmdComplete = Completion function
- * @cmdEntry = Compentry function
+ * cliNetInit() Initialize Readline if CLI bind to socket
+ * @csProg = program name
+ * @pty = Master pty
+ * @term = stdin termios
  * return: none
 */
-inline void cliComp(cli_Completion_t *cmdComplete, cli_CompEntry_t *cmdEntry)
+/*
+void cliNetInit(const char *csProg, int pty, struct termios *term)
 {
-	// command completon
-	rl_attempted_completion_function = cmdComplete;
-	rl_completion_entry_function = cmdEntry;
+	struct termios t;
+	int on = 1;
+
+	memset(&t, 0, sizeof t);
+	if (term)
+		t = *term;
+	else {
+		t.c_lflag = TTYDEF_LFLAG;
+		t.c_iflag = TTYDEF_IFLAG;
+		t.c_oflag = TTYDEF_OFLAG;
+		t.c_cflag = TTYDEF_CFLAG;
+		cfsetspeed(&t, B9600);
+	}
+
+	t.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOCTL | ECHOE | ECHOK | ECHOKE | ECHONL | ECHOPRT);
+//	t.c_iflag &= ~(ICRNL | BRKINT | INPCK | ISTRIP | IXON);
+	t.c_iflag &= ~ICRNL;
+	t.c_iflag |= IGNBRK;
+	t.c_cc[VMIN] = 1;
+	t.c_cc[VTIME] = 0;
+	tcsetattr(pty, TCSANOW, &t);
+
+	ioctl(pty, TIOCPKT, &on);
+
+	rl_readline_name = csProg;
+	rl_variable_bind("editing-mode", "emacs");
+
+	rl_instream = fdopen(pty, "r");
+	rl_outstream = NULL;
 }
+*/
+/*
+ * cliNetExec() Execute net CLI main loop
+ * @cmdList = Commands list
+ * @csPrompt = Prompt text
+ * @sock = client socket
+ * @term = stdin termios
+ * @win = window size of tty
+ * return: -1 error, 0 = exit w/^+D, 1 done.
+*/
+int
+cliNetExec(commands_t *cmdList, const char *csPrompt, int sock, struct termios *term, struct winsize *win)
+{
+	int pty, ret = 0, r, s, alen, attrlen, flg;
+	fd_set fds;
+	struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
+	u_char buf[BUFSIZ];
+	struct telnetAttrs *a, Attr[10];
 
+	switch (forkpty(&pty, NULL, term, win)) {
+		case -1:
+			LOGERR;
+			return -1;
+		case 0:
+			close(sock);
+
+			ret = cliExec(cmdList, csPrompt) < 0 ? 1 : 0;
+			/* spawn Shell mode */
+			/*
+			execl("/bin/tcsh", "tcsh", NULL);
+			*/
+			_exit(ret);
+		default:
+			/* 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);
+			if ((ret = telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1) {
+				cli_Errno = telnet_GetErrno();
+				strlcpy(cli_Error, telnet_GetError(), STRSIZ);
+				return -1;
+			} else
+				flg = 0;
+
+			while (42) {
+				FD_ZERO(&fds);
+				FD_SET(sock, &fds);
+				FD_SET(pty, &fds);
+				if ((ret = select(FD_SETSIZE, &fds, NULL, NULL, &tv)) < 1) {
+					if (!ret)
+						cli_SetErr(ETIMEDOUT, "Client session timeout ...");
+
+					break;
+				}
+
+				r = FD_ISSET(sock, &fds) ? sock : pty;
+				s = FD_ISSET(sock, &fds) ? pty : sock;
+
+				if ((ret = telnetRecv(r, &a, &alen, buf, BUFSIZ)) < 0) {
+					if (a)
+						free(a);
+
+					if (-2 == ret)
+						continue;
+					// EOF
+					if (-3 == ret)
+						shutdown(r, SHUT_RD);
+					else {
+						cli_Errno = telnet_GetErrno();
+						strlcpy(cli_Error, telnet_GetError(), STRSIZ);
+					}
+					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);
+	}
+
+	return ret;
+}
+
 /*
  * cliExec() Execute CLI main loop
  * @cmdList = Commands list
- * @out = Output handle
  * @csPrompt = Prompt text
  * return: -1 error, 0 = exit w/^+D, 1 done.
 */
-int cliExec(cliCommands_t *cmdList, FILE *out, const char *csPrompt)
+/*
+int cliExec(cliCommands_t *cmdList, const char *csPrompt)
 {
 	char *line, *s, *t, **app, *items[MAX_PROMPT_ITEMS];
 	int ret = 0;
 	register int i;
 	cliCommands_t *cmd = NULL;
+	FILE *out;
 
 	inline int inline_help()
 	{
@@ -143,8 +1100,12 @@ int cliExec(cliCommands_t *cmdList, FILE *out, const c
 	{
 		return NULL;
 	}
-
+*/
 	/* --- main body of CLI --- */
+/*
+	out = rl_outstream;
+	if (!out)
+		out = stdout;
 
 	rl_bind_key('?', inline_help);
 	if (!rl_attempted_completion_function) 
@@ -170,11 +1131,6 @@ int cliExec(cliCommands_t *cmdList, FILE *out, const c
 			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]))) {
@@ -193,3 +1149,4 @@ int cliExec(cliCommands_t *cmdList, FILE *out, const c
 
 	return ret;
 }
+*/