/*
* console.c
*
* Copyright 2001-2009 Texas Instruments, Inc. - http://www.ti.com/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/****************************************************************************
*
* MODULE: console.c
*
* PURPOSE:
*
* DESCRIPTION:
* ============
*
*
****************************************************************************/
/* includes */
/************/
#include <stdio.h>
#include "cu_osapi.h"
#include "console.h"
#include "cu_cmd.h"
/* defines */
/***********/
#define INBUF_LENGTH 2100
#define MAX_NAME_LEN 64
#define MAX_HELP_LEN 40
#define MAX_PARM_LEN 20
#define ALIAS_LEN 1
#define TOKEN_UP ".."
#define TOKEN_ROOT "/"
#define TOKEN_BREAK "#"
#define TOKEN_HELP "?"
#define TOKEN_DIRHELP "help"
#define TOKEN_QUIT "q1"
/* local types */
/***************/
typedef enum
{
Dir,
Token
} ConEntry_type_t;
/* Token types */
typedef enum
{
EmptyToken,
UpToken,
RootToken,
BreakToken,
HelpToken,
DirHelpToken,
QuitToken,
NameToken
} TokenType_t;
/* Monitor token structure */
typedef struct ConEntry_t
{
struct ConEntry_t *next;
S8 name[MAX_NAME_LEN+1]; /* Entry name */
S8 help[MAX_HELP_LEN+1]; /* Help string */
PS8 alias; /* Alias - always in upper case*/
ConEntry_type_t sel; /* Entry selector */
union
{
struct
{
struct ConEntry_t *upper; /* Upper directory */
struct ConEntry_t *first; /* First entry */
} dir;
struct t_Token
{
FuncToken_t f_tokenFunc; /* Token handler */
S32 totalParams;
ConParm_t *parm; /* Parameters array with totalParams size */
PS8 *name; /* Parameter name with totalParams size */
} token;
} u;
} ConEntry_t;
/* Module control block */
typedef struct Console_t
{
THandle hCuCmd;
S32 isDeviceOpen;
ConEntry_t *p_mon_root;
ConEntry_t *p_cur_dir;
PS8 p_inbuf;
volatile S32 stop_UI_Monitor;
} Console_t;
/* local variables */
/*******************/
/* local fucntions */
/*******************/
static VOID Console_allocRoot(Console_t* pConsole);
int consoleRunScript( char *script_file, THandle hConsole);
/* Remove leading blanks */
static PS8 Console_ltrim(PS8 s)
{
while( *s == ' ' || *s == '\t' ) s++;
return s;
}
/*
Make a preliminary analizis of <name> token.
Returns a token type (Empty, Up, Root, Break, Name)
*/
static TokenType_t Console_analizeToken( PS8 name )
{
if (!name[0])
return EmptyToken;
if (!os_strcmp(name, (PS8)TOKEN_UP ) )
return UpToken;
if (!os_strcmp(name, (PS8)TOKEN_ROOT ) )
return RootToken;
if (!os_strcmp(name, (PS8)TOKEN_BREAK ) )
return BreakToken;
if (!os_strcmp(name, (PS8)TOKEN_HELP ) )
return HelpToken;
if (!os_strcmp(name, (PS8)TOKEN_DIRHELP ) )
return DirHelpToken;
if (!os_strcmp(name, (PS8)TOKEN_QUIT ) )
return QuitToken;
return NameToken;
}
/* Compare strings case insensitive */
static S32 Console_stricmp( PS8 s1, PS8 s2, U16 len )
{
S32 i;
for( i=0; i<len && s1[i] && s2[i]; i++ )
{
if (os_tolower(s1[i]) != os_tolower(s2[i] ))
break;
}
return ( (len - i) * (s1[i] - s2[i]) );
}
/* Convert string s to lower case. Return pointer to s */
static PS8 Console_strlwr( PS8 s )
{
PS8 s0=s;
while( *s )
{
*s = (S8)os_tolower(*s );
++s;
}
return s0;
}
/* free the entries tree */
static VOID Console_FreeEntry(ConEntry_t *pEntry)
{
ConEntry_t *pEntryTemp,*pEntryTemp1;
if(pEntry->sel == Dir)
{
pEntryTemp = pEntry->u.dir.first;
while (pEntryTemp)
{
pEntryTemp1 = pEntryTemp->next;
Console_FreeEntry(pEntryTemp);
pEntryTemp = pEntryTemp1;
}
}
/* free the current entry */
os_MemoryFree(pEntry);
}
/* Allocate root directory */
static VOID Console_allocRoot(Console_t* pConsole)
{
/* The very first call. Allocate root structure */
if ((pConsole->p_mon_root=(ConEntry_t *)os_MemoryCAlloc(sizeof( ConEntry_t ), 1) ) == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)( "ERROR - Console_allocRoot(): cant allocate root\n") );
return;
}
os_strcpy((PS8)pConsole->p_mon_root->name, (PS8)("\\") );
pConsole->p_mon_root->sel = Dir;
pConsole->p_cur_dir = pConsole->p_mon_root;
}
/* Display current directory */
static VOID Console_displayDir(Console_t* pConsole)
{
S8 out_buf[512];
ConEntry_t *p_token;
ConEntry_t *p_dir = pConsole->p_cur_dir;
os_sprintf((PS8)out_buf, (PS8)("%s%s> "), (PS8)(p_dir==pConsole->p_mon_root)? (PS8)("") : (PS8)(".../"), (PS8)p_dir->name );
p_token = p_dir->u.dir.first;
while( p_token )
{
if( (os_strlen(out_buf) + os_strlen(p_token->name) + 2)>= sizeof(out_buf) )
{
os_error_printf(CU_MSG_ERROR, ( (PS8)"ERROR - Console_displayDir(): buffer too small....\n") );
break;
}
os_strcat(out_buf, p_token->name );
if ( p_token->sel == Dir )
os_strcat((PS8)out_buf, (PS8)("/" ) );
p_token = p_token->next;
if (p_token)
os_strcat((PS8)out_buf, (PS8)(", ") );
}
os_error_printf(CU_MSG_INFO2, (PS8)("%s\n"), (PS8)out_buf );
}
/*
Cut the first U16 from <p_inbuf>.
Return the U16 in <name> and updated <p_inbuf>
*/
static TokenType_t Console_getWord(Console_t* pConsole, PS8 name, U16 len )
{
U16 i=0;
TokenType_t tType;
pConsole->p_inbuf = Console_ltrim(pConsole->p_inbuf);
while( *pConsole->p_inbuf && *pConsole->p_inbuf!=' ' && i<len )
name[i++] = *(pConsole->p_inbuf++);
if (i<len)
name[i] = 0;
tType = Console_analizeToken( name );
return tType;
}
static TokenType_t Console_getStrParam(Console_t* pConsole, PS8 buf, ConParm_t *param )
{
TokenType_t tType;
U32 i, len = param->hi_val;
PS8 end_buf;
pConsole->p_inbuf = Console_ltrim(pConsole->p_inbuf);
if( param->flags & CON_PARM_LINE )
{
os_strcpy(buf, (PS8)pConsole->p_inbuf );
pConsole->p_inbuf += os_strlen(pConsole->p_inbuf);
}
else
{
if( *pConsole->p_inbuf == '\"' )
{
end_buf = os_strchr(pConsole->p_inbuf+1, '\"' );
if( !end_buf )
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR - invalid string param: '%s'\n"), (PS8)pConsole->p_inbuf );
pConsole->p_inbuf += os_strlen(pConsole->p_inbuf);
return EmptyToken;
}
if( (end_buf - pConsole->p_inbuf - 1) > (int)len )
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR - param is too long: '%s'\n"), (PS8)pConsole->p_inbuf );
pConsole->p_inbuf += os_strlen(pConsole->p_inbuf);
return EmptyToken;
}
*end_buf = 0;
os_strcpy( buf, (PS8)(pConsole->p_inbuf+1 ) );
pConsole->p_inbuf = end_buf + 1;
}
else
{
for( i=0; *pConsole->p_inbuf && *pConsole->p_inbuf!=' ' && i<len; i++ )
buf[i] = *(pConsole->p_inbuf++);
buf[i] = 0;
if( *pConsole->p_inbuf && *pConsole->p_inbuf != ' ' )
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR - param is too long: '%s'\n"), (PS8)( pConsole->p_inbuf-os_strlen( buf) ) );
pConsole->p_inbuf += os_strlen(pConsole->p_inbuf);
return EmptyToken;
}
}
}
tType = Console_analizeToken( buf );
return tType;
}
/* Returns number of parameters of the given token
*/
static U16 Console_getNParms( ConEntry_t *p_token )
{
U16 i;
if ( !p_token->u.token.parm )
return 0;
for( i=0;
(i<p_token->u.token.totalParams) &&
p_token->u.token.parm[i].name &&
p_token->u.token.parm[i].name[0];
i++ )
;
return i;
}
/* Parse p_inbuf string based on parameter descriptions in <p_token>.
Fill parameter values in <p_token>.
Returns the number of parameters filled.
To Do: add a option of one-by-one user input of missing parameters.
*/
static S32 Console_parseParms(Console_t* pConsole, ConEntry_t *p_token, U16 *pnParms )
{
U16 nTotalParms = Console_getNParms( p_token );
U16 nParms=0;
PS8 end_buf = NULL;
S8 parm[INBUF_LENGTH];
U16 i, print_params = 0;
U32 val = 0;
S32 sval = 0;
/* Mark all parameters as don't having an explicit value */
for( i=0; i<nTotalParms; i++ )
p_token->u.token.parm[i].flags |= CON_PARM_NOVAL;
/* ----------------- */
pConsole->p_inbuf = Console_ltrim(pConsole->p_inbuf);
if( pConsole->p_inbuf[0] == '!' && pConsole->p_inbuf[1] == '!' )
{
pConsole->p_inbuf += 2; print_params = 1;
}
/* ----------------- */
/* Build a format string */
for( i=0; i<nTotalParms; i++ )
{
if (p_token->u.token.parm[i].flags & (CON_PARM_STRING | CON_PARM_LINE) )
{
/* For a string parameter value is the string address */
/* and hi_val is the string length */
if (Console_getStrParam(pConsole, parm, &p_token->u.token.parm[i] ) != NameToken)
break;
if( os_strlen( parm) > p_token->u.token.parm[i].hi_val ||
(p_token->u.token.parm[i].low_val && p_token->u.token.parm[i].low_val > os_strlen( parm) ) )
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR - param '%s' must be %ld..%ld chars\n"), (PS8)p_token->u.token.parm[i].name,
(PS8)p_token->u.token.parm[i].low_val, (PS8)p_token->u.token.parm[i].hi_val);
return FALSE;
}
os_strcpy((PS8)(char *)p_token->u.token.parm[i].value, (PS8)parm);
}
else
{
if (Console_getWord(pConsole, parm, MAX_PARM_LEN ) != NameToken)
break;
if (p_token->u.token.parm[i].flags & CON_PARM_SIGN)
{
sval = os_strtol( parm, &end_buf, 0 );
}
else
{
val = os_strtoul( parm, &end_buf, 0 );
}
if( end_buf <= parm )
break;
/* Check value */
if (p_token->u.token.parm[i].flags & CON_PARM_RANGE)
{
if (p_token->u.token.parm[i].flags & CON_PARM_SIGN)
{
if ((sval < (S32)p_token->u.token.parm[i].low_val) ||
(sval > (S32)p_token->u.token.parm[i].hi_val) )
{
os_error_printf(CU_MSG_ERROR, (PS8)("%s: %d out of range (%d, %d)\n"),
(PS8)p_token->u.token.parm[i].name, (int)sval,
(int)p_token->u.token.parm[i].low_val, (int)p_token->u.token.parm[i].hi_val );
return FALSE;
}
}
else
{
if ((val < p_token->u.token.parm[i].low_val) ||
(val > p_token->u.token.parm[i].hi_val) )
{
os_error_printf(CU_MSG_ERROR , (PS8)("%s: %ld out of range (%ld, %ld)\n"),
(PS8)p_token->u.token.parm[i].name, (PS8)val,
(PS8)p_token->u.token.parm[i].low_val, (PS8)p_token->u.token.parm[i].hi_val );
return FALSE;
}
}
}
if (p_token->u.token.parm[i].flags & CON_PARM_SIGN)
p_token->u.token.parm[i].value = sval;
else
p_token->u.token.parm[i].value = val;
}
p_token->u.token.parm[i].flags &= ~CON_PARM_NOVAL;
++nParms;
}
/* Process default values */
for( ; i<nTotalParms; i++ )
{
if ((p_token->u.token.parm[i].flags & CON_PARM_DEFVAL) != 0)
{
p_token->u.token.parm[i].flags &= ~CON_PARM_NOVAL;
++nParms;
}
else if (!(p_token->u.token.parm[i].flags & CON_PARM_OPTIONAL) )
{
/* Mandatory parameter missing */
return FALSE;
}
}
if( print_params )
{
os_error_printf((S32)CU_MSG_INFO2, (PS8)("Params: %d\n"), nParms );
for (i=0; i<nParms; i++ )
{
os_error_printf(CU_MSG_INFO2, (PS8)("%d: %s - flags:%d"),
i+1, (PS8)p_token->u.token.parm[i].name,
p_token->u.token.parm[i].flags);
if (p_token->u.token.parm[i].flags & CON_PARM_SIGN)
os_error_printf(CU_MSG_INFO2, (PS8)("min:%d, max:%d, value:%d "),(PS8)p_token->u.token.parm[i].low_val, (PS8)p_token->u.token.parm[i].hi_val,
(PS8)p_token->u.token.parm[i].value);
else
os_error_printf(CU_MSG_INFO2, (PS8)("min:%ld, max:%ld, value:%ld "),(PS8)p_token->u.token.parm[i].low_val, (PS8)p_token->u.token.parm[i].hi_val,
(PS8)p_token->u.token.parm[i].value);
os_error_printf(CU_MSG_INFO2, (PS8)("(%#lx)"),(PS8)p_token->u.token.parm[i].value );
if( p_token->u.token.parm[i].flags & (CON_PARM_LINE | CON_PARM_STRING ))
{
os_error_printf(CU_MSG_INFO2, (PS8)(" - '%s'"), (PS8)(char *) p_token->u.token.parm[i].value );
}
os_error_printf(CU_MSG_INFO2, (PS8)("\n") );
}
}
*pnParms = nParms;
return TRUE;
}
/* Serach a token by name in the current directory */
static ConEntry_t *Console_searchToken( ConEntry_t *p_dir, PS8 name )
{
ConEntry_t *p_token;
U16 name_len = (U16)os_strlen( name );
/* Check alias */
p_token = p_dir->u.dir.first;
while( p_token )
{
if (p_token->alias &&
(name_len == ALIAS_LEN) &&
!Console_stricmp( p_token->alias, name, ALIAS_LEN ) )
return p_token;
p_token = p_token->next;
}
/* Check name */
p_token = p_dir->u.dir.first;
while( p_token )
{
if (!Console_stricmp( p_token->name, name, name_len ) )
break;
p_token = p_token->next;
}
return p_token;
}
/* Display help for each entry in the current directory */
VOID Console_dirHelp(Console_t* pConsole)
{
ConEntry_t *p_token;
S8 print_str[80];
p_token = pConsole->p_cur_dir->u.dir.first;
while( p_token )
{
if (p_token->sel == Dir)
os_sprintf( print_str, (PS8)"%s: directory\n", (PS8)p_token->name );
else
os_sprintf( print_str, (PS8)("%s(%d parms): %s\n"),
(PS8)p_token->name, Console_getNParms(p_token), p_token->help );
os_error_printf(CU_MSG_INFO2, (PS8)print_str );
p_token = p_token->next;
}
os_error_printf(CU_MSG_INFO2, (PS8)("Type ? <name> for command help, \"/\"-root, \"..\"-upper\n") );
}
/* Display help a token */
static VOID Console_displayHelp(Console_t* pConsole, ConEntry_t *p_token )
{
S8 bra, ket;
U16 nTotalParms = Console_getNParms( p_token );
U16 i;
os_error_printf(CU_MSG_INFO2, (PS8)("%s: %s "), (PS8)p_token->help, (PS8)p_token->name );
for( i=0; i<nTotalParms; i++ )
{
if (p_token->u.token.parm[i].flags & CON_PARM_OPTIONAL)
{
bra = '['; ket=']';
}
else
{
bra = '<'; ket='>';
}
os_error_printf(CU_MSG_INFO2, (PS8)("%c%s"), bra, (PS8)p_token->u.token.parm[i].name );
if (p_token->u.token.parm[i].flags & CON_PARM_DEFVAL)
{
os_error_printf(CU_MSG_INFO2, (PS8)("=%lu"), (PS8)p_token->u.token.parm[i].value);
}
if (p_token->u.token.parm[i].flags & CON_PARM_RANGE)
{
os_error_printf(CU_MSG_INFO2, (PS8)(p_token->u.token.parm[i].flags & CON_PARM_SIGN) ? (PS8)(" (%d..%d%s)") : (PS8)(" (%lu..%lu%s)"),
(PS8)p_token->u.token.parm[i].low_val,
(PS8)p_token->u.token.parm[i].hi_val,
(PS8)(p_token->u.token.parm[i].flags & (CON_PARM_STRING | CON_PARM_LINE)) ? (PS8)(" chars") : (PS8)("") );
}
os_error_printf(CU_MSG_INFO2, (PS8)("%c \n"),ket );
}
}
/* Choose unique alias for <name> in <p_dir> */
/* Currently only single-character aliases are supported */
static S32 Console_chooseAlias( ConEntry_t *p_dir, ConEntry_t *p_new_token )
{
ConEntry_t *p_token;
S32 i;
S8 c;
PS8 new_alias = NULL;
/* find alias given from user */
for(i=0; p_new_token->name[i]; i++ )
{
if( os_isupper( p_new_token->name[i]) )
{
new_alias = &p_new_token->name[i];
break;
}
}
Console_strlwr( p_new_token->name );
if( new_alias )
{
p_token = p_dir->u.dir.first;
while( p_token )
{
if (p_token->alias && (os_tolower(*p_token->alias ) == *new_alias) )
{
os_error_printf(CU_MSG_ERROR, (PS8)("Error - duplicated alias '%c' in <%s> and <%s>**\n"), *new_alias,
(PS8)p_token->name, (PS8)p_new_token->name );
return 0;
}
p_token = p_token->next;
}
*new_alias = (S8)os_toupper(*new_alias);
p_new_token->alias = new_alias;
return 1;
}
i = 0;
while( p_new_token->name[i] )
{
c = p_new_token->name[i];
p_token = p_dir->u.dir.first;
while( p_token )
{
if (p_token->alias &&
(os_tolower(*p_token->alias ) == c) )
break;
p_token = p_token->next;
}
if (p_token)
++i;
else
{
p_new_token->name[i] = (S8)os_toupper( c );
p_new_token->alias = &p_new_token->name[i];
break;
}
}
return 1;
}
/* Parse the given input string and exit.
All commands in the input string are executed one by one.
*/
static U8 Console_ParseString(Console_t* pConsole, PS8 input_string )
{
ConEntry_t *p_token;
S8 name[MAX_NAME_LEN];
TokenType_t tType;
U16 nParms;
if (!pConsole->p_mon_root)
return 1;
if(!pConsole->isDeviceOpen)
{
Console_GetDeviceStatus(pConsole);
if(!pConsole->isDeviceOpen)
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR - Console_ParseString - Device isn't loaded !!!\n") );
return 1;
}
}
if( input_string[os_strlen( input_string)-1] == '\n' )
{
PS8 s = &input_string[os_strlen( input_string)-1];
*s = 0;
}
pConsole->p_inbuf = input_string;
pConsole->stop_UI_Monitor = FALSE;
/* Interpret empty string as "display directory" */
if ( pConsole->p_inbuf && !*pConsole->p_inbuf )
Console_displayDir(pConsole);
while(!pConsole->stop_UI_Monitor && pConsole->p_inbuf && *pConsole->p_inbuf)
{
tType = Console_getWord(pConsole, name, MAX_NAME_LEN );
switch( tType )
{
case NameToken:
p_token = Console_searchToken( pConsole->p_cur_dir, name );
if (p_token == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)("**Error: '%s'**\n"),name);
pConsole->p_inbuf = NULL;
}
else if (p_token->sel == Dir)
{
pConsole->p_cur_dir = p_token;
Console_displayDir(pConsole);
}
else
{ /* Function token */
if (!Console_parseParms(pConsole, p_token, &nParms ))
{
Console_displayHelp(pConsole, p_token );
}
else
{
p_token->u.token.f_tokenFunc(pConsole->hCuCmd, p_token->u.token.parm, nParms );
}
}
break;
case UpToken: /* Go to upper directory */
if (pConsole->p_cur_dir->u.dir.upper)
pConsole->p_cur_dir = pConsole->p_cur_dir->u.dir.upper;
Console_displayDir(pConsole);
break;
case RootToken: /* Go to the root directory */
if (pConsole->p_cur_dir->u.dir.upper)
pConsole->p_cur_dir = pConsole->p_mon_root;
Console_displayDir(pConsole);
break;
case HelpToken: /* Display help */
if (( Console_getWord(pConsole, name, MAX_NAME_LEN ) == NameToken ) &&
((p_token = Console_searchToken( pConsole->p_cur_dir, name )) != NULL ) &&
(p_token->sel == Token) )
Console_displayHelp(pConsole, p_token);
else
Console_dirHelp(pConsole);
break;
case DirHelpToken:
Console_displayDir(pConsole);
os_error_printf(CU_MSG_INFO2, (PS8)("Type ? <name> for command help, \"/\"-root, \"..\"-upper\n") );
break;
case BreakToken: /* Clear buffer */
pConsole->p_inbuf = NULL;
break;
case QuitToken: /* Go to upper directory */
return 1;
case EmptyToken:
break;
}
}
return 0;
}
/* functions */
/*************/
THandle Console_Create(const PS8 device_name, S32 BypassSupplicant, PS8 pSupplIfFile)
{
Console_t* pConsole = (Console_t*)os_MemoryCAlloc(sizeof(Console_t), sizeof(U8));
if(pConsole == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)("Error - Console_Create - cant allocate control block\n") );
return NULL;
}
pConsole->hCuCmd = CuCmd_Create(device_name, pConsole, BypassSupplicant, pSupplIfFile);
if(pConsole->hCuCmd == NULL)
{
Console_Destroy(pConsole);
return NULL;
}
Console_allocRoot(pConsole);
pConsole->isDeviceOpen = FALSE;
return pConsole;
}
VOID Console_Destroy(THandle hConsole)
{
Console_t* pConsole = (Console_t*)hConsole;
if(pConsole->hCuCmd)
{
CuCmd_Destroy(pConsole->hCuCmd);
}
if (pConsole->p_mon_root)
{
Console_FreeEntry(pConsole->p_mon_root);
}
os_MemoryFree(pConsole);
}
VOID Console_Stop(THandle hConsole)
{
((Console_t*)hConsole)->stop_UI_Monitor = TRUE;
}
/* Monitor driver */
VOID Console_Start(THandle hConsole)
{
Console_t* pConsole = (Console_t*)hConsole;
S8 inbuf[INBUF_LENGTH];
S32 res;
if (!pConsole->p_mon_root)
return;
pConsole->stop_UI_Monitor = FALSE;
Console_displayDir(pConsole);
while(!pConsole->stop_UI_Monitor)
{
/* get input string */
res = os_getInputString(inbuf, sizeof(inbuf));
if (res == FALSE)
{
if(pConsole->stop_UI_Monitor)
{
continue;
}
else
{
return;
}
}
if(res == OS_GETINPUTSTRING_CONTINUE)
continue;
/* change to NULL terminated strings */
if( inbuf[os_strlen(inbuf)-1] == '\n' )
inbuf[os_strlen(inbuf)-1] = 0;
/* parse the string */
Console_ParseString(pConsole, inbuf);
}
}
VOID Console_GetDeviceStatus(THandle hConsole)
{
Console_t* pConsole = (Console_t*)hConsole;
if(OK == CuCmd_GetDeviceStatus(pConsole->hCuCmd))
{
pConsole->isDeviceOpen = TRUE;
}
}
/***************************************************************
Function : consoleAddDirExt
Description: Add subdirectory
Parameters: p_root - root directory handle (might be NULL)
name - directory name
Output: the new created directory handle
=NULL - failure
***************************************************************/
THandle Console_AddDirExt(THandle hConsole,
THandle hRoot, /* Upper directory handle. NULL=root */
const PS8 name, /* New directory name */
const PS8 desc ) /* Optional dir description */
{
Console_t* pConsole = (Console_t*)hConsole;
ConEntry_t *p_root = (ConEntry_t *)hRoot;
ConEntry_t *p_dir;
ConEntry_t **p_e;
if (!p_root)
p_root = pConsole->p_mon_root;
if(!( p_root && (p_root->sel == Dir)))
return NULL;
if ( (p_dir=(ConEntry_t *)os_MemoryAlloc(sizeof( ConEntry_t )) ) == NULL)
return NULL;
os_memset( p_dir, 0, sizeof( ConEntry_t ) );
os_strncpy( p_dir->name, name, MAX_NAME_LEN );
os_strncpy( p_dir->help, desc, MAX_HELP_LEN );
p_dir->sel = Dir;
Console_chooseAlias( p_root, p_dir );
/* Add new directory to the root's list */
p_dir->u.dir.upper = p_root;
p_e = &(p_root->u.dir.first);
while (*p_e)
p_e = &((*p_e)->next);
*p_e = p_dir;
return p_dir;
}
/***************************************************************
Function : consoleAddToken
Description: Add token
Parameters: p_dir - directory handle (might be NULL=root)
name - token name
help - help string
p_func - token handler
p_parms- array of parameter descriptions.
Must be terminated with {0}.
Each parm descriptor is a struct
{ "myname", - name
10, - low value
20, - high value
0 } - default value =-1 no default
or address for string parameter
Output: E_OK - OK
!=0 - error
***************************************************************/
consoleErr Console_AddToken( THandle hConsole,
THandle hDir,
const PS8 name,
const PS8 help,
FuncToken_t p_func,
ConParm_t p_parms[] )
{
Console_t* pConsole = (Console_t*)hConsole;
ConEntry_t *p_dir = (ConEntry_t *)hDir;
ConEntry_t *p_token;
ConEntry_t **p_e;
U16 i;
if (!pConsole->p_mon_root)
Console_allocRoot(pConsole);
if (!p_dir)
p_dir = pConsole->p_mon_root;
if(!( p_dir && (p_dir->sel == Dir)))
return E_ERROR;
/* Initialize token structure */
if((p_token = (ConEntry_t *)os_MemoryCAlloc(1,sizeof(ConEntry_t))) == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)("** no memory **\n") );
return E_NOMEMORY;
}
/* Copy name */
os_strncpy( p_token->name, name, MAX_NAME_LEN );
os_strncpy( p_token->help, help, MAX_HELP_LEN );
p_token->sel = Token;
p_token->u.token.f_tokenFunc = p_func;
p_token->u.token.totalParams = 0;
/* Convert name to lower case and choose alias */
Console_chooseAlias( p_dir, p_token );
/* Copy parameters */
if ( p_parms )
{
ConParm_t *p_tmpParms = p_parms;
/* find the number of params */
while( p_tmpParms->name && p_tmpParms->name[0] )
{
p_token->u.token.totalParams++;
p_tmpParms++;
}
/* allocate the parameters info */
p_token->u.token.parm = (ConParm_t *)os_MemoryAlloc(p_token->u.token.totalParams * sizeof(ConParm_t));
p_token->u.token.name = (PS8*)os_MemoryAlloc(p_token->u.token.totalParams * sizeof(PS8));
if ((p_token->u.token.parm == NULL) || (p_token->u.token.name == NULL))
{
os_error_printf(CU_MSG_ERROR, (PS8)("** no memory for params\n") );
os_MemoryFree(p_token);
return E_NOMEMORY;
}
for (i=0; i < p_token->u.token.totalParams; i++)
{
ConParm_t *p_token_parm = &p_token->u.token.parm[i];
/* String parameter must have an address */
if(p_parms->flags & (CON_PARM_STRING | CON_PARM_LINE))
{
if ( p_parms->hi_val >= INBUF_LENGTH )
{
os_error_printf(CU_MSG_ERROR, (PS8)("** buffer too big: %s/%s\n"), p_dir->name, name);
os_MemoryFree(p_token->u.token.parm);
os_MemoryFree(p_token->u.token.name);
os_MemoryFree(p_token);
return E_NOMEMORY;
}
if (p_parms->hi_val == 0 || (p_parms->flags & CON_PARM_RANGE) )
{
os_error_printf(CU_MSG_ERROR, (PS8)("** Bad string param definition: %s/%s\n"), p_dir->name, name );
os_MemoryFree(p_token->u.token.parm);
os_MemoryFree(p_token->u.token.name);
os_MemoryFree(p_token);
return E_BADPARM;
}
p_parms->value = (U32)os_MemoryCAlloc(1,p_parms->hi_val+1);
if( !p_parms->value )
{
os_error_printf(CU_MSG_ERROR, (PS8)("** No memory: %s/%s (max.size=%ld)\n"), p_dir->name, name, p_parms->hi_val );
os_MemoryFree(p_token->u.token.parm);
os_MemoryFree(p_token->u.token.name);
os_MemoryFree(p_token);
return E_NOMEMORY;
}
}
/* Copy parameter */
*p_token_parm = *p_parms;
if( p_token_parm->hi_val || p_token_parm->low_val )
p_token_parm->flags |= CON_PARM_RANGE;
p_token->u.token.name[i] = os_MemoryAlloc(os_strlen(p_parms->name));
if (p_token->u.token.name[i] == NULL)
{
os_error_printf(CU_MSG_ERROR, (PS8)("** Error allocate param name\n"));
os_MemoryFree(p_token->u.token.parm);
os_MemoryFree(p_token->u.token.name);
os_MemoryFree(p_token);
return E_NOMEMORY;
}
p_token_parm->name = (PS8)p_token->u.token.name[i];
os_strncpy( p_token->u.token.name[i], p_parms->name, os_strlen(p_parms->name) );
++p_parms;
} /*end of for loop*/
}
/* Add token to the directory */
p_e = &(p_dir->u.dir.first);
while (*p_e)
p_e = &((*p_e)->next);
*p_e = p_token;
return E_OK;
}
int consoleRunScript( char *script_file, THandle hConsole)
{
FILE *hfile = fopen(script_file, "r" );
U8 status = 0;
Console_t* pConsole = (Console_t*)hConsole;
if( hfile )
{
char buf[INBUF_LENGTH];
pConsole->stop_UI_Monitor = FALSE;
while( fgets(buf, sizeof(buf), hfile ) )
{
status = Console_ParseString(pConsole, buf);
if (status == 1)
return TRUE;
if( pConsole->stop_UI_Monitor )
break;
}
fclose(hfile);
}
else
{
os_error_printf(CU_MSG_ERROR, (PS8)("ERROR in script: %s \n"), (PS8)script_file);
}
return pConsole->stop_UI_Monitor;
}