libaitcli/src/aitcli.c - diff

Return to aitcli.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / libaitcli / src

Diff for /libaitcli/src/aitcli.c between versions 1.2.2.18 and 1.5.4.2

version 1.2.2.18, 2010/12/07 15:09:02	version 1.5.4.2, 2013/01/17 16:20:19
Line 5	Line 5
* $Author$	* $Author$
* $Id$	* $Id$
*	*
*************************************************************************/	**************************************************************************
	The ELWIX and AITNET software is distributed under the following
	terms:

	All of the documentation and software included in the ELWIX and AITNET
	Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>

	Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
	by Michael Pounov <misho@elwix.org>. All rights reserved.

	Redistribution and use in source and binary forms, with or without
	modification, are permitted provided that the following conditions
	are met:
	1. Redistributions of source code must retain the above copyright
	notice, this list of conditions and the following disclaimer.
	2. Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.
	3. All advertising materials mentioning features or use of this software
	must display the following acknowledgement:
	This product includes software developed by Michael Pounov <misho@elwix.org>
	ELWIX - Embedded LightWeight unIX and its contributors.
	4. Neither the name of AITNET nor the names of its contributors
	may be used to endorse or promote products derived from this software
	without specific prior written permission.

	THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	SUCH DAMAGE.
	*/
#include "global.h"	#include "global.h"
#include "cli.h"	#include "cli.h"


#pragma GCC visibility push(hidden)	#pragma GCC visibility push(hidden)

// ------------------------------------------------

int cli_Errno;	int cli_Errno;
char cli_Error[STRSIZ];	char cli_Error[STRSIZ];

Line 26 cli_GetErrno()	Line 61 cli_GetErrno()
return cli_Errno;	return cli_Errno;
}	}

// io_GetError() Get error text of last operation	// cli_GetError() Get error text of last operation
inline const char *	inline const char *
cli_GetError()	cli_GetError()
{	{
Line 40 cli_SetErr(int eno, char *estr, ...)	Line 75 cli_SetErr(int eno, char *estr, ...)
va_list lst;	va_list lst;

cli_Errno = eno;	cli_Errno = eno;
memset(cli_Error, 0, STRSIZ);	memset(cli_Error, 0, sizeof cli_Error);
va_start(lst, estr);	va_start(lst, estr);
vsnprintf(cli_Error, STRSIZ, estr, lst);	vsnprintf(cli_Error, sizeof cli_Error, estr, lst);
va_end(lst);	va_end(lst);
}	}

Line 374 bufComp(int idx, void * __restrict buffer)	Line 409 bufComp(int idx, void * __restrict buffer)
if (!buffer \|\| idx < 0 \|\| idx > MAX_BINDKEY)	if (!buffer \|\| idx < 0 \|\| idx > MAX_BINDKEY)
return RETCODE_ERR;	return RETCODE_ERR;

str = strdup(buf->line_buf);	str = e_strdup(buf->line_buf);
if (!str)	if (!str)
return RETCODE_ERR;	return RETCODE_ERR;
else {	else {
s = str;	s = str;
io_TrimStr((u_char*) s);	str_Trim(s);
}	}

i = j = 0;	i = j = 0;
Line 451 bufComp(int idx, void * __restrict buffer)	Line 486 bufComp(int idx, void * __restrict buffer)
}	}

endcomp:	endcomp:
free(str);	e_free(str);
return ret;	return ret;
}	}

Line 470 bufHelp(int idx, void * __restrict buffer)	Line 505 bufHelp(int idx, void * __restrict buffer)
return RETCODE_OK;	return RETCODE_OK;
}	}

// ---------------------------------------------------------------

/*	/*
* cli_Printf() Send message to CLI session	* cli_Printf() - Send message to CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @fmt = printf format string	* @fmt = printf format string
* @... = arguments defined in fmt	* @... = arguments defined in fmt
Line 496 cli_Printf(linebuffer_t * __restrict buffer, char *fmt	Line 531 cli_Printf(linebuffer_t * __restrict buffer, char *fmt
vfprintf(f, fmt, lst);	vfprintf(f, fmt, lst);
va_end(lst);	va_end(lst);
} else	} else
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
}	}

/*	/*
* cli_PrintHelp() Print help screen	* cli_PrintHelp() - Print help screen
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: none	* return: none
*/	*/
inline void	inline void
cli_PrintHelp(linebuffer_t * __restrict buffer)	cli_PrintHelp(linebuffer_t * __restrict buffer)
{	{
if (buffer)	if (buffer) {
bufHelp(0, buffer);	bufHelp(0, buffer);
else	clrscrEOL(buffer);
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	} else
	cli_SetErr(EINVAL, "Invalid input parameters ...");
}	}


/*	/*
* cli_BindKey() Bind function to key	* cli_BindKey() - Bind function to key
	*
* @key = key structure	* @key = key structure
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position	* return: RETCODE_ERR error, RETCODE_OK ok, >0 bind at position
Line 526 cli_BindKey(bindkey_t * __restrict key, linebuffer_t *	Line 564 cli_BindKey(bindkey_t * __restrict key, linebuffer_t *
register int i;	register int i;

if (!key \|\| !buffer) {	if (!key \|\| !buffer) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}

Line 542 cli_BindKey(bindkey_t * __restrict key, linebuffer_t *	Line 580 cli_BindKey(bindkey_t * __restrict key, linebuffer_t *


/*	/*
* cli_addCommand() Add command to CLI session	* cli_addCommand() - Add command to CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @csCmd = Command name	* @csCmd = Command name
* @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ...	* @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ...
Line 558 cli_addCommand(linebuffer_t * __restrict buffer, const	Line 597 cli_addCommand(linebuffer_t * __restrict buffer, const
struct tagCommand *cmd;	struct tagCommand *cmd;

if (!buffer \|\| !csCmd) {	if (!buffer \|\| !csCmd) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}

cmd = malloc(sizeof(struct tagCommand));	cmd = e_malloc(sizeof(struct tagCommand));
if (!cmd) {	if (!cmd) {
LOGERR;	LOGERR;
return RETCODE_ERR;	return RETCODE_ERR;
Line 581 cli_addCommand(linebuffer_t * __restrict buffer, const	Line 620 cli_addCommand(linebuffer_t * __restrict buffer, const
}	}

/*	/*
* cli_delCommand() Delete command from CLI session	* cli_delCommand() - Delete command from CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @csCmd = Command name	* @csCmd = Command name
* @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ...	* @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ...
Line 594 cli_delCommand(linebuffer_t * __restrict buffer, const	Line 634 cli_delCommand(linebuffer_t * __restrict buffer, const
int ret = RETCODE_OK;	int ret = RETCODE_OK;

if (!buffer \|\| !csCmd) {	if (!buffer \|\| !csCmd) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}

Line 602 cli_delCommand(linebuffer_t * __restrict buffer, const	Line 642 cli_delCommand(linebuffer_t * __restrict buffer, const
if (cmd->cmd_level == cliLevel && !strcmp(cmd->cmd_name, csCmd)) {	if (cmd->cmd_level == cliLevel && !strcmp(cmd->cmd_name, csCmd)) {
ret = 1;	ret = 1;
SLIST_REMOVE(&buffer->line_cmds, cmd, tagCommand, cmd_next);	SLIST_REMOVE(&buffer->line_cmds, cmd, tagCommand, cmd_next);
free(cmd);	e_free(cmd);
break;	break;
}	}

Line 610 cli_delCommand(linebuffer_t * __restrict buffer, const	Line 650 cli_delCommand(linebuffer_t * __restrict buffer, const
}	}

/*	/*
* cli_updCommand() Update command in CLI session	* cli_updCommand() - Update command in CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @csCmd = Command name	* @csCmd = Command name
* @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ...	* @cliLevel = Level in CLI, -1 unprivi(view from all), 0 main config, 1 sub config ...
Line 627 cli_updCommand(linebuffer_t * __restrict buffer, const	Line 668 cli_updCommand(linebuffer_t * __restrict buffer, const
int ret = RETCODE_OK;	int ret = RETCODE_OK;

if (!buffer \|\| !csCmd) {	if (!buffer \|\| !csCmd) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}

Line 650 cli_updCommand(linebuffer_t * __restrict buffer, const	Line 691 cli_updCommand(linebuffer_t * __restrict buffer, const


/*	/*
* cli_addHistory() Add line to history	* cli_addHistory() - Add line to history
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @str = Add custom text or if NULL use readed line from CLI buffer	* @str = Add custom text or if NULL use readed line from CLI buffer
* return: RETCODE_ERR error, RETCODE_OK ok	* return: RETCODE_ERR error, RETCODE_OK ok
Line 661 cli_addHistory(linebuffer_t * __restrict buffer, const	Line 703 cli_addHistory(linebuffer_t * __restrict buffer, const
struct tagHistory *h;	struct tagHistory *h;

if (!buffer) {	if (!buffer) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}

if (!(h = malloc(sizeof(struct tagHistory)))) {	if (!(h = e_malloc(sizeof(struct tagHistory)))) {
LOGERR;	LOGERR;
return RETCODE_ERR;	return RETCODE_ERR;
} else	} else
Line 673 cli_addHistory(linebuffer_t * __restrict buffer, const	Line 715 cli_addHistory(linebuffer_t * __restrict buffer, const

if (str) {	if (str) {
if (!*str) {	if (!*str) {
free(h);	e_free(h);
return RETCODE_OK;	return RETCODE_OK;
}	}

h->hist_len = strlcpy(h->hist_line, str, BUFSIZ);	h->hist_len = strlcpy(h->hist_line, str, BUFSIZ);
} else {	} else {
if (!*buffer->line_buf \|\| buffer->line_len < 2) {	if (!*buffer->line_buf \|\| buffer->line_len < 2) {
free(h);	e_free(h);
return RETCODE_OK;	return RETCODE_OK;
}	}

memcpy(h->hist_line, buffer->line_buf, (h->hist_len = buffer->line_len));	memcpy(h->hist_line, buffer->line_buf, (h->hist_len = buffer->line_len));
io_TrimStr((u_char*) h->hist_line);	str_Trim(h->hist_line);
h->hist_len = strlen(h->hist_line);	h->hist_len = strlen(h->hist_line);
}	}

Line 694 cli_addHistory(linebuffer_t * __restrict buffer, const	Line 736 cli_addHistory(linebuffer_t * __restrict buffer, const
}	}

/*	/*
* cli_saveHistory() Save history to file	* cli_saveHistory() - Save history to file
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @histfile = History filename, if NULL will be use default name	* @histfile = History filename, if NULL will be use default name
* @lines = Maximum history lines to save	* @lines = Maximum history lines to save
Line 709 cli_saveHistory(linebuffer_t * __restrict buffer, cons	Line 752 cli_saveHistory(linebuffer_t * __restrict buffer, cons
struct tagHistory *h;	struct tagHistory *h;

if (!buffer) {	if (!buffer) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}
if (!histfile)	if (!histfile)
Line 740 cli_saveHistory(linebuffer_t * __restrict buffer, cons	Line 783 cli_saveHistory(linebuffer_t * __restrict buffer, cons
}	}

/*	/*
* cli_loadHistory() Load history from file	* cli_loadHistory() - Load history from file
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @histfile = History filename, if NULL will be use default name	* @histfile = History filename, if NULL will be use default name
* return: RETCODE_ERR error, RETCODE_OK ok	* return: RETCODE_ERR error, RETCODE_OK ok
Line 753 cli_loadHistory(linebuffer_t * __restrict buffer, cons	Line 797 cli_loadHistory(linebuffer_t * __restrict buffer, cons
struct tagHistory *h;	struct tagHistory *h;

if (!buffer) {	if (!buffer) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return RETCODE_ERR;	return RETCODE_ERR;
}	}
if (!histfile)	if (!histfile)
Line 769 cli_loadHistory(linebuffer_t * __restrict buffer, cons	Line 813 cli_loadHistory(linebuffer_t * __restrict buffer, cons
if (!buf \|\| buf == '#')	if (!buf \|\| buf == '#')
continue;	continue;
else	else
io_TrimStr((u_char*) buf);	str_Trim(buf);

if (!(h = malloc(sizeof(struct tagHistory)))) {	if (!(h = e_malloc(sizeof(struct tagHistory)))) {
LOGERR;	LOGERR;
fclose(f);	fclose(f);
return RETCODE_ERR;	return RETCODE_ERR;
Line 788 cli_loadHistory(linebuffer_t * __restrict buffer, cons	Line 832 cli_loadHistory(linebuffer_t * __restrict buffer, cons
}	}

/*	/*
* cli_resetHistory() Reset history search in CLI session	* cli_resetHistory() - Reset history search in CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: none	* return: none
*/	*/
Line 800 cli_resetHistory(linebuffer_t * __restrict buffer)	Line 845 cli_resetHistory(linebuffer_t * __restrict buffer)


/*	/*
* cli_freeLine() Clear entire line	* cli_freeLine() - Clear entire line
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: RETCODE_ERR error, RETCODE_OK ok	* return: RETCODE_ERR error, RETCODE_OK ok
*/	*/
Line 811 cli_freeLine(linebuffer_t * __restrict buffer)	Line 857 cli_freeLine(linebuffer_t * __restrict buffer)

if (buffer) {	if (buffer) {
if (buffer->line_buf)	if (buffer->line_buf)
free(buffer->line_buf);	e_free(buffer->line_buf);

buffer->line_buf = malloc(BUFSIZ);	buffer->line_buf = e_malloc(BUFSIZ);
if (buffer->line_buf) {	if (buffer->line_buf) {
memset(buffer->line_buf, 0, BUFSIZ);	memset(buffer->line_buf, 0, BUFSIZ);
buffer->line_eol = buffer->line_bol;	buffer->line_eol = buffer->line_bol;
Line 823 cli_freeLine(linebuffer_t * __restrict buffer)	Line 869 cli_freeLine(linebuffer_t * __restrict buffer)
} else	} else
LOGERR;	LOGERR;
} else	} else
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");

return code;	return code;
}	}

/*	/*
* cli_setPrompt() Set new prompt for CLI session	* cli_setPrompt() - Set new prompt for CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @prompt = new text for prompt or if NULL disable prompt	* @prompt = new text for prompt or if NULL disable prompt
* return: none	* return: none
Line 839 cli_setPrompt(linebuffer_t * __restrict buffer, const	Line 886 cli_setPrompt(linebuffer_t * __restrict buffer, const
{	{
if (buffer) {	if (buffer) {
if (buffer->line_prompt) {	if (buffer->line_prompt) {
free(buffer->line_prompt);	e_free(buffer->line_prompt);
buffer->line_prompt = NULL;	buffer->line_prompt = NULL;
buffer->line_bol = 0;	buffer->line_bol = 0;
}	}

if (prompt) {	if (prompt) {
buffer->line_prompt = strdup(prompt);	buffer->line_prompt = e_strdup(prompt);
if (buffer->line_prompt) {	if (buffer->line_prompt) {
buffer->line_bol = strlen(buffer->line_prompt);	buffer->line_bol = strlen(buffer->line_prompt);
buffer->line_eol = buffer->line_bol;	buffer->line_eol = buffer->line_bol;
Line 854 cli_setPrompt(linebuffer_t * __restrict buffer, const	Line 901 cli_setPrompt(linebuffer_t * __restrict buffer, const
LOGERR;	LOGERR;
}	}
} else	} else
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
}	}


/*	/*
* cliEnd() Clear data, Free resources and close CLI session	* cliEnd() - Clear data, Free resources and close CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: RETCODE_ERR error, RETCODE_OK ok	* return: RETCODE_ERR error, RETCODE_OK ok
*/	*/
Line 872 cliEnd(linebuffer_t * __restrict buffer)	Line 920 cliEnd(linebuffer_t * __restrict buffer)
if (buffer) {	if (buffer) {
while ((c = SLIST_FIRST(&buffer->line_cmds))) {	while ((c = SLIST_FIRST(&buffer->line_cmds))) {
SLIST_REMOVE_HEAD(&buffer->line_cmds, cmd_next);	SLIST_REMOVE_HEAD(&buffer->line_cmds, cmd_next);
free(c);	e_free(c);
}	}
while ((h = TAILQ_FIRST(&buffer->line_history))) {	while ((h = TAILQ_FIRST(&buffer->line_history))) {
TAILQ_REMOVE(&buffer->line_history, h, hist_next);	TAILQ_REMOVE(&buffer->line_history, h, hist_next);
free(h);	e_free(h);
}	}

if (buffer->line_prompt)	if (buffer->line_prompt)
free(buffer->line_prompt);	e_free(buffer->line_prompt);

if (buffer->line_keys)	if (buffer->line_keys)
free(buffer->line_keys);	e_free(buffer->line_keys);
if (buffer->line_buf)	if (buffer->line_buf)
free(buffer->line_buf);	e_free(buffer->line_buf);

free(buffer);	e_free(buffer);
buffer = NULL;	buffer = NULL;
} else	} else
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
}	}

/*	/*
* cliInit() Start CLI session, allocate memory for resources and bind keys	* cliInit() - Start CLI session, allocate memory for resources and bind keys
	*
* @fin = Input device handle	* @fin = Input device handle
* @fout = Output device handle	* @fout = Output device handle
* @prompt = text for prompt, if NULL disable prompt	* @prompt = text for prompt, if NULL disable prompt
Line 908 cliInit(int fin, int fout, const char *prompt)	Line 957 cliInit(int fin, int fout, const char *prompt)
register int i;	register int i;

/* init buffer */	/* init buffer */
buffer = malloc(sizeof(linebuffer_t));	buffer = e_malloc(sizeof(linebuffer_t));
if (!buffer) {	if (!buffer) {
LOGERR;	LOGERR;
return NULL;	return NULL;
Line 922 cliInit(int fin, int fout, const char *prompt)	Line 971 cliInit(int fin, int fout, const char *prompt)
SLIST_INIT(&buffer->line_cmds);	SLIST_INIT(&buffer->line_cmds);

if (prompt) {	if (prompt) {
buffer->line_prompt = strdup(prompt);	buffer->line_prompt = e_strdup(prompt);
if (!buffer->line_prompt) {	if (!buffer->line_prompt) {
LOGERR;	LOGERR;
free(buffer);	e_free(buffer);
return NULL;	return NULL;
} else	} else
buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);	buffer->line_eol = buffer->line_bol = strlen(buffer->line_prompt);
}	}
}	}
buffer->line_buf = malloc(BUFSIZ);	buffer->line_buf = e_malloc(BUFSIZ);
if (!buffer->line_buf) {	if (!buffer->line_buf) {
LOGERR;	LOGERR;
if (buffer->line_prompt)	if (buffer->line_prompt)
free(buffer->line_prompt);	e_free(buffer->line_prompt);
free(buffer);	e_free(buffer);
return NULL;	return NULL;
} else {	} else {
memset(buffer->line_buf, 0, BUFSIZ);	memset(buffer->line_buf, 0, BUFSIZ);
buffer->line_len = 1 + buffer->line_eol;	buffer->line_len = 1 + buffer->line_eol;
}	}
keys = calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));	keys = e_calloc(MAX_BINDKEY + 1, sizeof(bindkey_t));
if (!keys) {	if (!keys) {
LOGERR;	LOGERR;
if (buffer->line_prompt)	if (buffer->line_prompt)
free(buffer->line_prompt);	e_free(buffer->line_prompt);
free(buffer->line_buf);	e_free(buffer->line_buf);
free(buffer);	e_free(buffer);
return NULL;	return NULL;
} else	} else
memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));	memset(keys, 0, sizeof(bindkey_t) * (MAX_BINDKEY + 1));
Line 959 cliInit(int fin, int fout, const char *prompt)	Line 1008 cliInit(int fin, int fout, const char *prompt)
cli_addCommand(buffer, "-------", 0, NULL, "-------------------------", NULL);	cli_addCommand(buffer, "-------", 0, NULL, "-------------------------", NULL);

/* fill key bindings */	/* fill key bindings */
// ascii chars & ctrl+chars	/* ascii chars & ctrl+chars */
for (i = 0; i < 256; i++) {	for (i = 0; i < 256; i++) {
*keys[i].key_ch = (u_char) i;	*keys[i].key_ch = (u_char) i;
keys[i].key_len = 1;	keys[i].key_len = 1;
Line 985 cliInit(int fin, int fout, const char *prompt)	Line 1034 cliInit(int fin, int fout, const char *prompt)
if (i == '?')	if (i == '?')
keys[i].key_func = bufHelp;	keys[i].key_func = bufHelp;
}	}
// alt+chars	/* alt+chars */
for (i = 256; i < 512; i++) {	for (i = 256; i < 512; i++) {
keys[i].key_ch[0] = 0x1b;	keys[i].key_ch[0] = 0x1b;
keys[i].key_ch[1] = (u_char) i - 256;	keys[i].key_ch[1] = (u_char) i - 256;
keys[i].key_len = 2;	keys[i].key_len = 2;
}	}

// 3 bytes	/* 3 bytes */
keys[i].key_len = sizeof K_F1 - 1;	keys[i].key_len = sizeof K_F1 - 1;
memcpy(keys[i].key_ch, K_F1, keys[i].key_len);	memcpy(keys[i].key_ch, K_F1, keys[i].key_len);
i++;	i++;
Line 1105 cliInit(int fin, int fout, const char *prompt)	Line 1154 cliInit(int fin, int fout, const char *prompt)
keys[i].key_func = bufBTAB;	keys[i].key_func = bufBTAB;
memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);	memcpy(keys[i].key_ch, K_BTAB, keys[i].key_len);
i++;	i++;
// 4 bytes	/* 4 bytes */
keys[i].key_len = sizeof K_INS - 1;	keys[i].key_len = sizeof K_INS - 1;
keys[i].key_func = bufMODE;	keys[i].key_func = bufMODE;
memcpy(keys[i].key_ch, K_INS, keys[i].key_len);	memcpy(keys[i].key_ch, K_INS, keys[i].key_len);
Line 1120 cliInit(int fin, int fout, const char *prompt)	Line 1169 cliInit(int fin, int fout, const char *prompt)
keys[i].key_len = sizeof K_PGDN - 1;	keys[i].key_len = sizeof K_PGDN - 1;
memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);	memcpy(keys[i].key_ch, K_PGDN, keys[i].key_len);
i++;	i++;
// 5 bytes	/* 5 bytes */
keys[i].key_len = sizeof K_F5 - 1;	keys[i].key_len = sizeof K_F5 - 1;
memcpy(keys[i].key_ch, K_F5, keys[i].key_len);	memcpy(keys[i].key_ch, K_F5, keys[i].key_len);
i++;	i++;
Line 1151 cliInit(int fin, int fout, const char *prompt)	Line 1200 cliInit(int fin, int fout, const char *prompt)
}	}

/*	/*
* cliInitLine() Init CLI input line terminal	* cliInitLine() - Init CLI input line terminal
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: none	* return: none
*/	*/
Line 1170 cliInitLine(linebuffer_t * __restrict buffer)	Line 1220 cliInitLine(linebuffer_t * __restrict buffer)
}	}

/*	/*
* cliReadLine() Read line from opened CLI session	* cliReadLine() - Read line from opened CLI session
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* return: NULL if error or !=NULL readed line, must be free after use!	* return: NULL if error or !=NULL readed line, must be e_free after use!
*/	*/
char *	char *
cliReadLine(linebuffer_t * __restrict buffer)	cliReadLine(linebuffer_t * __restrict buffer)
Line 1183 cliReadLine(linebuffer_t * __restrict buffer)	Line 1234 cliReadLine(linebuffer_t * __restrict buffer)
char buf[BUFSIZ], *str = NULL;	char buf[BUFSIZ], *str = NULL;

if (!buffer) {	if (!buffer) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return NULL;	return NULL;
}	}

Line 1206 cliReadLine(linebuffer_t * __restrict buffer)	Line 1257 cliReadLine(linebuffer_t * __restrict buffer)
}	}
if (!readLen) {	if (!readLen) {
if (buffer->line_buf)	if (buffer->line_buf)
str = strdup(buffer->line_buf);	str = e_strdup(buffer->line_buf);
else	else
cli_SetErr(EPIPE, "Error:: unknown state ...");	cli_SetErr(EPIPE, "Unknown state ...");
return str;	return str;
}	}

Line 1238 recheck:	Line 1289 recheck:
}	}

if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)	if (code != RETCODE_ERR && code != RETCODE_EOF && buffer->line_buf)
str = strdup(buffer->line_buf);	str = e_strdup(buffer->line_buf);
return str;	return str;
}	}


/*	/*
* cliNetLoop() CLI network main loop binded to socket	* cliNetLoop() - CLI network main loop binded to socket
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @csHistFile = History file name	* @csHistFile = History file name
* @sock = client socket	* @sock = client socket
Line 1254 int	Line 1306 int
cliNetLoop(linebuffer_t * __restrict buffer, const char *csHistFile, int sock)	cliNetLoop(linebuffer_t * __restrict buffer, const char *csHistFile, int sock)
{	{
u_char buf[BUFSIZ];	u_char buf[BUFSIZ];
int pty, r, s, alen, flg, attrlen = 0, ret = 0;	int pid, stat, pty, r, s, alen, flg, attrlen = 0, ret = 0;
fd_set fds;	fd_set fds;
struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };	struct timeval tv = { DEFAULT_SOCK_TIMEOUT, 0 };
struct telnetAttrs *a, Attr[10];	struct telnetAttrs *a, Attr[10];

switch (forkpty(&pty, NULL, NULL, NULL)) {	switch ((pid = forkpty(&pty, NULL, NULL, NULL))) {
case -1:	case -1:
LOGERR;	LOGERR;
return -1;	return -1;
case 0:	case 0:
if (!buffer) {	if (!buffer) {
cli_SetErr(EINVAL, "Error:: invalid input parameters ...");	cli_SetErr(EINVAL, "Invalid input parameters ...");
return -1;	return -1;
} else	} else
close(sock);	close(sock);

cliInitLine(buffer);
ret = cliLoop(buffer, csHistFile) < 0 ? 1 : 0;	ret = cliLoop(buffer, csHistFile) < 0 ? 1 : 0;
cliEnd(buffer);	cliEnd(buffer);

exit(ret);	exit(ret);
default:	default:
telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);	cli_telnet_SetCmd(Attr + 0, DO, TELOPT_TTYPE);
telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);	cli_telnet_SetCmd(Attr + 1, WILL, TELOPT_ECHO);
telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);	cli_telnet_Set_SubOpt(Attr + 2, TELOPT_LFLOW, LFLOW_OFF, NULL, 0);
telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);	cli_telnet_Set_SubOpt(Attr + 3, TELOPT_LFLOW, LFLOW_RESTART_XON, NULL, 0);
telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);	cli_telnet_SetCmd(Attr + 4, DO, TELOPT_LINEMODE);
if ((ret = telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1) {	if ((ret = cli_telnetSend(sock, Attr, 5, NULL, 0, 0)) == -1)
cli_Errno = telnet_GetErrno();
strlcpy(cli_Error, telnet_GetError(), STRSIZ);
return -1;	return -1;
} else	else
flg = 0;	flg = 0;

while (42) {	while (42) {
	if (waitpid(pid, &stat, WNOHANG))
	break;

FD_ZERO(&fds);	FD_ZERO(&fds);
FD_SET(sock, &fds);	FD_SET(sock, &fds);
FD_SET(pty, &fds);	FD_SET(pty, &fds);
Line 1304 cliNetLoop(linebuffer_t * __restrict buffer, const cha	Line 1356 cliNetLoop(linebuffer_t * __restrict buffer, const cha

if (FD_ISSET(sock, &fds)) {	if (FD_ISSET(sock, &fds)) {
memset(buf, 0, BUFSIZ);	memset(buf, 0, BUFSIZ);
if ((ret = telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {	if ((ret = cli_telnetRecv(sock, &a, &alen, buf, BUFSIZ)) < 0) {
if (a)	if (a)
free(a);	e_free(a);

if (-2 == ret)	if (-2 == ret)
continue;	continue;
// EOF	// EOF
if (-3 == ret)	if (-3 == ret)
shutdown(sock, SHUT_RD);	shutdown(sock, SHUT_RD);
else {
cli_Errno = telnet_GetErrno();
strlcpy(cli_Error, telnet_GetError(), STRSIZ);
}
break;	break;
}	}
attrlen = 0;	attrlen = 0;
if (1 == flg && alen) {	if (1 == flg && alen) {
telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);	cli_telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_SGA);
telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);	cli_telnet_SetCmd(&Attr[attrlen++], DO, TELOPT_ECHO);
}	}
if (2 == flg && alen) {	if (2 == flg && alen) {
telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);	cli_telnet_SetCmd(&Attr[attrlen++], WILL, TELOPT_ECHO);
telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW,	cli_telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW,
LFLOW_OFF, NULL, 0);	LFLOW_OFF, NULL, 0);
telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW,	cli_telnet_Set_SubOpt(&Attr[attrlen++], TELOPT_LFLOW,
LFLOW_RESTART_XON, NULL, 0);	LFLOW_RESTART_XON, NULL, 0);
telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);	cli_telnet_SetCmd(&Attr[attrlen++], DONT, TELOPT_LINEMODE);
}	}
if (a)	if (a)
free(a);	e_free(a);

if ((ret = write(pty, buf, ret)) == -1) {	if ((ret = write(pty, buf, ret)) == -1) {
LOGERR;	LOGERR;
Line 1348 cliNetLoop(linebuffer_t * __restrict buffer, const cha	Line 1396 cliNetLoop(linebuffer_t * __restrict buffer, const cha
break;	break;
}	}

if ((ret = telnetSend(sock, Attr, pty == s ? 0 : attrlen, buf, ret, 0)) == -1) {	if ((ret = cli_telnetSend(sock, Attr, pty == s ? 0 : attrlen,
cli_Errno = telnet_GetErrno();	buf, ret, 0)) == -1)
strlcpy(cli_Error, telnet_GetError(), STRSIZ);
break;	break;
} else	else
flg++;	flg++;
}	}
}	}
Line 1364 cliNetLoop(linebuffer_t * __restrict buffer, const cha	Line 1411 cliNetLoop(linebuffer_t * __restrict buffer, const cha
}	}

/*	/*
* cliLoop() CLI main loop	* cliLoop() - CLI main loop
	*
* @buffer = CLI buffer	* @buffer = CLI buffer
* @csHistFile = History file name	* @csHistFile = History file name
* return: RETCODE_ERR error, RETCODE_OK ok	* return: RETCODE_ERR error, RETCODE_OK ok
Line 1378 cliLoop(linebuffer_t * __restrict buffer, const char *	Line 1426 cliLoop(linebuffer_t * __restrict buffer, const char *
struct tagCommand *cmd;	struct tagCommand *cmd;

/* --- main body of CLI --- */	/* --- main body of CLI --- */
	cliInitLine(buffer);

if (cli_loadHistory(buffer, csHistFile) == RETCODE_ERR)	if (cli_loadHistory(buffer, csHistFile) == RETCODE_ERR)
return RETCODE_ERR;	return RETCODE_ERR;
Line 1390 cliLoop(linebuffer_t * __restrict buffer, const char *	Line 1439 cliLoop(linebuffer_t * __restrict buffer, const char *
} else	} else
cli_addHistory(buffer, NULL);	cli_addHistory(buffer, NULL);
// clear whitespaces	// clear whitespaces
for (s = line; isspace(*s); s++);	for (s = line; isspace((int) *s); s++);
if (*s) {	if (*s) {
for (t = s + strlen(s) - 1; t > s && isspace(*t); t--);	for (t = s + strlen(s) - 1; t > s && isspace((int) *t); t--);
*++t = 0;	*++t = 0;
}	}

Line 1414 cliLoop(linebuffer_t * __restrict buffer, const char *	Line 1463 cliLoop(linebuffer_t * __restrict buffer, const char *
cli_Printf(buffer, "\nCommand '%s' not found!\n", items[0]);	cli_Printf(buffer, "\nCommand '%s' not found!\n", items[0]);
ret = -1;	ret = -1;
} else	} else
if (cmd->cmd_func)	if (cmd->cmd_func) {
	cli_Printf(buffer, "\n");
ret = cmd->cmd_func(buffer, i, items);	ret = cmd->cmd_func(buffer, i, items);
else {	} else {
clrscrEOL(buffer);	clrscrEOL(buffer);
printfCR(buffer, 1);	printfCR(buffer, 1);
}	}
Line 1424 cliLoop(linebuffer_t * __restrict buffer, const char *	Line 1474 cliLoop(linebuffer_t * __restrict buffer, const char *

cli_freeLine(buffer);	cli_freeLine(buffer);
cli_resetHistory(buffer);	cli_resetHistory(buffer);
free(line);	e_free(line);
} while (ret < 1);	} while (ret < 1);

cli_saveHistory(buffer, csHistFile, HISTORY_LINES);	cli_saveHistory(buffer, csHistFile, HISTORY_LINES);

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

Removed from v.1.2.2.18
changed lines
	Added in v.1.5.4.2