source: umon/main/common/env.c @ 87db514

/**************************************************************************
 *
 * Copyright (c) 2013 Alcatel-Lucent
 * 
 * Alcatel Lucent licenses this file to You under the Apache License,
 * Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License.  A copy of the License is contained the
 * file LICENSE at the top level of this repository.
 * You may also 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.
 *
 **************************************************************************
 *
 * env.c:
 * Shell variable functions used to load or retrieve shell variable
 * information from the shell variable table.
 *
 * Original author:     Ed Sutter (ed.sutter@alcatel-lucent.com)
 *
 */
#include <stdarg.h>
#include "config.h"
#include "tfs.h"
#include "tfsprivate.h"
#include "ether.h"
#include "genlib.h"
#include "stddefs.h"
#include "cli.h"
#include "version.h"
#include "boardinfo.h"
#include "timer.h"

#if INCLUDE_SHELLVARS

char *whatplatform = "@(#)PLATFORM=" PLATFORM_NAME;

#ifdef TARGET_ENV_SETUP
extern void TARGET_ENV_SETUP(void);
#endif

#ifndef PROMPT
#define PROMPT "uMON>"
#endif

int     shell_print(void);
int     envToExec(char *);
void clearenv(void);

/* Structure used for the shell variables: */
struct s_shell {
        char    *val;           /* Value stored in shell variable */
        char    *name;          /* Name of shell variable */
        int             vsize;          /* Size of storage allocated for value */
        struct  s_shell *next;
};

struct s_shell *shell_vars;

/* If no malloc, then use locally defined env_alloc() and env_free()...
 */
#if INCLUDE_MALLOC

#define env_alloc       malloc
#define env_free        free

#else

#define ENV_ALLOC_TOT   48
#define ENV_ALLOC_SIZE  (sizeof(struct s_shell)+8)

struct env_space {
        int inuse;
        char space[ENV_ALLOC_SIZE];
} envSpace[ENV_ALLOC_TOT];


char *
env_alloc(int size)
{
        int      i;

        if (size > ENV_ALLOC_SIZE)
                return(0);

        for(i=0;i<ENV_ALLOC_TOT;i++) {
                if (envSpace[i].inuse == 0) {
                        envSpace[i].inuse = 1;
                        memset(envSpace[i].space,0,ENV_ALLOC_SIZE);
                        return(envSpace[i].space);
                }
        }
        return(0);
}

void
env_free(char *space)
{
        int i;

        for(i=0;i<ENV_ALLOC_TOT;i++) {
                if (envSpace[i].space == space) {
                        envSpace[i].inuse = 0;
                        break;
                }
        }
        return;
}
#endif

/*
 *  Set()
 *
 *      Syntax:
 *              set var                         clears the variable 'var'
 *              set var value           assign "value" to variable 'var'
 *              set -a var value        AND 'var' with 'value'
 *              set -o var value        OR 'var' with 'value'
 *              set -i var [value]      increment 'var' by 'value' (or 1 if no value)
 *              set -d var [value]      decrement 'var' by 'value' (or 1 if no value)
 *              set -x                          result of -i/-d is in hex
 */
char *SetHelp[] = {
        "Shell variable operations",
#if INCLUDE_EE
        "-[ab:cdef:iox] [varname[=expression]] [value]",
#else
        "-[ab:cdef:iox] [varname] [value]",
#endif
#if INCLUDE_VERBOSEHELP
        " -a        AND var with value",
        " -b        set console baudrate",
        " -c        clear the environment",
        " -d        decrease var by value (or 1)",
        " -e        build an environ string",
#if INCLUDE_TFS
        " -f{file}  create script from environment",
#endif
        " -i        increase var by value (or 1)",
        " -o        OR var with value",
        " -x        result in hex (NA with expressions, use hex())",
#endif
        0,
};

#define SET_NOOP        0
#define SET_INCR        1
#define SET_DECR        2
#define SET_OR          3
#define SET_AND         4

int
Set(int argc,char *argv[])
{
        char    *envp, buf[CMDLINESIZE];
        int             opt, decimal, setop, i;

        setop = SET_NOOP;
        envp = (char *)0;
        decimal = 1;
        while((opt=getopt(argc,argv,"ab:cdef:iox")) != -1) {
                switch(opt) {
                case 'a':               /* logical and */
                        setop = SET_AND;
                        decimal = 0;
                        break;
                case 'b':
                        ChangeConsoleBaudrate(atoi(optarg));
                        return(CMD_SUCCESS);
                case 'c':               /* clear environment */
                        clearenv();
                        break;
                case 'd':               /* decrement */
                        setop = SET_DECR;
                        break;
                case 'e':       
                        envp = getenvp();
                        break;
#if INCLUDE_TFS 
                case 'f':               /* build script from environment */
                        envToExec(optarg);
                        return(0);
#endif
                case 'i':               /* increment */
                        setop = SET_INCR;
                        break;
                case 'o':               /* logical or */
                        setop = SET_OR;
                        decimal = 0;
                        break;
                case 'x':
                        decimal = 0;
                        break;
                default:
                        return(CMD_PARAM_ERROR);
                }
        }

        if (!shell_vars) {
                printf("No memory allocated for environment.\n");
                return(CMD_FAILURE);
        }

        if (setop != SET_NOOP) {        /* Do some operation on a shell variable */
                char    *varval;
                unsigned long   value, opval;

                /* For -i & -d, if value is not specified, then assume 1. */
                if (argc == optind+1) {
                        if ((setop == SET_INCR) || (setop == SET_DECR))
                                opval = 1;
                        else
                                return(CMD_PARAM_ERROR);
                }
                else if (argc == optind+2)
                        opval = strtoul(argv[optind+1],0,0);
                else
                        return(CMD_PARAM_ERROR);

                varval = getenv(argv[optind]);
                if (!varval) {
                        printf("%s: not found\n", argv[optind]);
                        return(CMD_FAILURE);
                }
                        
                value = strtoul(varval,(char **)0,0);
                switch(setop) {
                        case SET_INCR:
                                value += opval;
                                break;
                        case SET_DECR:
                                value -= opval;
                                break;
                        case SET_AND:
                                value &= opval;
                                break;
                        case SET_OR:
                                value |= opval;
                                break;
                }
                if (decimal)
                        sprintf(buf,"%ld",value);
                else
                        sprintf(buf,"0x%lx",value);
                setenv(argv[optind],buf);
        }
        else if (argc == optind) {      /* display all variables */
                shell_print();
        }
        else if (argc == (optind+1)) {  /* run EE or clear one var or set envp */
#if INCLUDE_EE
                switch(setEE(argv[optind])) {
                        case 1:
                                return(CMD_SUCCESS);
                        case -1:
                                return(CMD_FAILURE);
                }
#endif
                if (envp) 
                        shell_sprintf(argv[optind],"0x%lx",(ulong)envp);
                else
                        setenv(argv[optind],0);
        }
        else if (argc >= (optind+2)) {  /* Set a specific variable */
                buf[0] = 0;
                for(i=optind+1;i<argc;i++) {
                        if ((strlen(buf) + strlen(argv[i]) + 2) >= sizeof(buf)) {
                                printf("String too large\n");
                                break;
                        }
                        strcat(buf,argv[i]);
                        if (i != (argc-1))
                                strcat(buf," ");
                }
                if (!decimal)
                        shell_sprintf(argv[optind],"0x%lx",atoi(buf));
                else
                        setenv(argv[optind],buf);
        }
        else 
                return(CMD_PARAM_ERROR);

        return(CMD_SUCCESS);
}

/* Shell variable support routines...
 *      The basic scheme is to malloc in the space needed for the variable
 *      name and the value of that variable.  For each variable that 
 *      exists there is one s_shell structure that is in the linked list.
 *      As shell variables are removed, their corresonding s_shell structure
 *      is NOT removed, but the data pointed to within the structure is
 *      freed.  This keeps the linked list implementation extremely simple
 *      but maintains the versatility gained by using malloc for the 
 *      variables instead of some limted set of static arrays.
 */


/* shell_alloc():
 *      First scan through the entire list to see if the requested
 *      shell variable name already exists in the list; if it does,
 *      then just use the same s_shell entry but change the value.
 *      Also, if the new value fits in the same space as the older value,
 *      then just use the same memory space (don't do the free/malloc).
 *      If it doesn't, then scan through the list again.  If there
 *      is one that has no variable assigned to it (name = 0), then
 *      use it for the new allocation.  If all s_shell structures do 
 *      have valid entries, then malloc a new s_shell structure and then
 *      place the new shell variable data in that structure.
 */

static int
shell_alloc(char *name,char *value)
{
        int     namelen, valuelen;
        struct s_shell *sp;

        sp = shell_vars;
        namelen = strlen(name);
        valuelen = strlen(value);
        while(1) {
                if (sp->name == (char *)0) {
                        if (sp->next != (struct s_shell *)0) {
                                sp = sp->next;
                                continue;
                        }
                        else
                                break;
                }
                if (strcmp(sp->name,name) == 0) {
                        if (sp->vsize < valuelen+1) {           /* If new value is smaller      */
                                env_free(sp->val);                              /* than the old value, then */
                                sp->val = env_alloc(valuelen+1);/* don't re-allocate any        */
                                if (!sp->val)                                   /* memory, just copy into       */
                                        return(-1);                                     /* the space used by the        */
                                sp->vsize = valuelen+1;                 /* previous value.                      */
                        }
                        strcpy(sp->val,value);
                        return(0);
                }
                if (sp->next == (struct s_shell *)0) 
                        break;
                sp = sp->next;
        }
        sp = shell_vars;
        while(1) {
                if (sp->name == (char *)0) {
                        sp->name = env_alloc(namelen+1);
                        if (!sp->name)
                                return(-1);
                        strcpy(sp->name,name);
                        sp->val = env_alloc(valuelen+1);
                        if (!sp->val)
                                return(-1);
                        sp->vsize = valuelen+1;
                        strcpy(sp->val,value);
                        return(0);
                }
                if (sp->next != (struct s_shell *)0)
                        sp = sp->next;
                else {
                        sp->next = (struct s_shell *)env_alloc(sizeof(struct s_shell));
                        if (!sp->next)
                                return(-1);
                        sp = sp->next;
                        sp->name = env_alloc(namelen+1);
                        if (!sp->name)
                                return(-1);
                        strcpy(sp->name,name);
                        sp->val = env_alloc(valuelen+1);
                        if (!sp->val)
                                return(-1);
                        sp->vsize = valuelen+1;
                        strcpy(sp->val,value);
                        sp->next = (struct s_shell *)0;
                        return(0);
                }
        }
}

/* shell_dealloc():
 *      Remove the requested shell variable from the list.  Return 0 if
 *      the variable was removed successfully, otherwise return -1.
 */
static int
shell_dealloc(char *name)
{
        struct  s_shell *sp;

        sp = shell_vars;
        while(1) {
                if (sp->name == (char *)0) {
                        if (sp->next == (struct s_shell *)0)
                                return(-1);
                        else {
                                sp = sp->next;
                                continue;
                        }
                }
                if (strcmp(name,sp->name) == 0) {
                        env_free(sp->name);
                        env_free(sp->val);
                        sp->name = (char *)0;
                        sp->val = (char *)0;
                        return(0);
                }
                
                if (sp->next == (struct s_shell *)0)
                        return(-1);
                else
                        sp = sp->next;
        }
}

/* ConsoleBaudEnvSet():
 * Called by to load/reload the CONSOLEBAUD shell variable based on
 * the content of the global variable 'ConsoleBaudRate'.
 */
void
ConsoleBaudEnvSet(void)
{
        char    buf[16];

        sprintf(buf,"%d",ConsoleBaudRate);
        setenv("CONSOLEBAUD",buf);
}

/* ShellVarInit();
 *      Setup the shell_vars pointer appropriately for additional
 *      shell variable assignments that will be made through shell_alloc().
 */
int
ShellVarInit()
{
        char    buf[16];

#if !INCLUDE_MALLOC
        memset((char *)&envSpace,0,sizeof(envSpace));
#endif

        shell_vars = (struct s_shell *)env_alloc(sizeof(struct s_shell));
        if (!shell_vars) {
                printf("No memory for environment initialization\n");
                return(-1);
        }
        shell_vars->next = (struct s_shell *)0;
        shell_vars->name = (char *)0;
        setenv("PROMPT",PROMPT);
        sprintf(buf,"0x%lx",APPLICATION_RAMSTART);
        setenv("APPRAMBASE",buf);
        sprintf(buf,"0x%lx",BOOTROM_BASE);
        setenv("BOOTROMBASE",buf);
        setenv("PLATFORM",PLATFORM_NAME);
        setenv("MONITORBUILT",monBuilt());
        shell_sprintf("MONCOMPTR","0x%lx",(ulong)&moncomptr);
#if INCLUDE_HWTMR
        shell_sprintf("TARGETTIMER","0x%x",target_timer);
        shell_sprintf("TICKSPERMSEC","0x%x",TIMER_TICKS_PER_MSEC);
#endif

        /* Support the ability to have additional target-specific 
         * shell variables initialized at startup...
         */
#ifdef TARGET_ENV_SETUP
        TARGET_ENV_SETUP();
#endif

        shell_sprintf("VERSION_MAJ","%d",MAJOR_VERSION);
        shell_sprintf("VERSION_MIN","%d",MINOR_VERSION);
        shell_sprintf("VERSION_TGT","%d",TARGET_VERSION);
        return(0);
}

/* getenv:
 *      Return the pointer to the value entry if the shell variable
 *      name is currently set; otherwise, return a null pointer.
 */
char *
getenv(char *name)
{
        register struct s_shell *sp;

        for(sp = shell_vars;sp != (struct s_shell *)0;sp = sp->next) {
                if (sp->name != (char *)0) {
                        if (strcmp(sp->name,name) == 0)
                                return(sp->val);
                }
        }
        return((char *)0);
}

/* getenvp:
 *      Build an environment string consisting of all shell variables and
 *      their values concatenated into one string.  The format is
 *
 *        NAME=VALUE LF NAME=VALUE LF NAME=VALUE LF NULL
 *
 *      with the limit in size being driven only by the space
 *      available on the heap.  Note that this uses malloc, and it
 *      the responsibility of the caller to free the pointer when done.
 */
char *
getenvp(void)
{
        int size;
        char *envp, *cp;
        register struct s_shell *sp;

        size = 0;

        /* Get total size of the current environment vars */
        for(sp = shell_vars;sp != (struct s_shell *)0;sp = sp->next) {
                if (sp->name != (char *)0) {
                        size += (strlen(sp->name) + strlen(sp->val) + 2);
                }
        }
        if (size == 0)
                return((char *)0);

        envp = env_alloc(size+1);       /* leave room for final NULL */
        if (envp == 0)
                return((char *)0);

        cp = envp;
        for(sp = shell_vars;sp != (struct s_shell *)0;sp = sp->next) {
                if (sp->name != (char *)0)
                        cp += sprintf(cp,"%s=%s\n",sp->name,sp->val);
        }
        *cp = 0;                /* Append NULL after final separator */
        return(envp);
}

/* clearenv():
 * Clear out the entire environment.
 */
void
clearenv(void)
{
        struct  s_shell *sp;

        for(sp = shell_vars;sp != (struct s_shell *)0;sp = sp->next) {
                if (sp->name != (char *)0) {
                        env_free(sp->name);
                        env_free(sp->val);
                        sp->name = (char *)0;
                        sp->val = (char *)0;
                }
        }
}

/* setenv:
 *      Interface to shell_dealloc() and shell_alloc().
 */
int
setenv(char *name,char *value)
{
        if (!shell_vars)
                return(-1);
        if ((value == (char *)0) || (*value == 0))
                return(shell_dealloc(name));
        else
                return(shell_alloc(name,value));
}

/* shell_print():
 *      Print out all of the current shell variables and their values.
 */
int
shell_print(void)
{
        int     maxlen, len;
        char format[8];
        register struct s_shell *sp;

        /* Before printing the list, pass through the list to determine the
         * largest variable name.  This is used to create a format string
         * that is then passed to printf() when printing the list of
         * name/value pairs.  It guarantees that regardless of the length
         * of the name, the format of the printed out put will be consistent
         * for all variables.
         */
        maxlen = 0;
        sp = shell_vars;
        while(1) {
                if (sp->name) {
                        len = strlen(sp->name);
                        if (len > maxlen)
                                maxlen = len;
                }
                if (sp->next != (struct s_shell *)0)
                        sp = sp->next;
                else
                        break;
        }
        sprintf(format,"%%%ds = ",maxlen+1);

        /* Now that we know the size of the largest variable, we can 
         * print the list cleanly...
         */
        sp = shell_vars;
        while(1) {
                if (sp->name != (char *)0) {
                        printf(format, sp->name);
                        puts(sp->val);          /* sp->val may overflow printf, so use puts */
                }
                if (sp->next != (struct s_shell *)0)
                        sp = sp->next;
                else
                        break;
        }
        return(0);
}

/* shell_sprintf():
 *      Simple way to turn a printf-like formatted string into a shell variable.
 */
int
shell_sprintf(char *varname, char *fmt, ...)
{
        int     tot;
        char buf[CMDLINESIZE];
        va_list argp;

        va_start(argp,fmt);
        tot = vsnprintf(buf,CMDLINESIZE-1,fmt,argp);
        va_end(argp);
        setenv(varname,buf);
        return(tot);
}


#if INCLUDE_TFS
/* validEnvToExecVar():
 * Return 1 if the variable should be included in the script
 * generated by envToExec(); else return 0.
 * Specifically... if the variable is generated internally
 * then we don't want to include it in the script.
 */
int
validEnvToExecVar(char *varname)
{
        char **vp;
        static char *invalid_varprefixes[] = {
                "ARG",                  "TFS_PREFIX_",  "TFS_START_",
                "TFS_END_",             "TFS_SPARE_",   "TFS_SPARESZ_",
                "TFS_SCNT_",    "TFS_DEVINFO_", "FLASH_BASE_",
                "FLASH_SCNT_",  "FLASH_END_",
                0
        };
        static char *invalid_varnames[] = {
                "APPRAMBASE",   "BOOTROMBASE",  "CMDSTAT",
                "CONSOLEBAUD",  "MALLOC",               "MONCOMPTR",
                "MONITORBUILT", "PLATFORM",             "PROMPT",
                "TFS_DEVTOT",   "FLASH_DEVTOT", "PROMPT",
                "VERSION_MAJ",  "VERSION_MIN",  "VERSION_TGT",
                "MONCMD_SRCIP", "MONCMD_SRCPORT",
#if INCLUDE_HWTMR
                "TARGETTIMER",  "TICKSPERMSEC",
#endif
                0
        };

        if (varname == 0)
                return(0);

        if (strncmp(varname,"ARG",3) == 0)
                return(0);

#if INCLUDE_BOARDINFO
        if (BoardInfoVar(varname))
                return(0);
#endif

        for(vp=invalid_varnames;*vp;vp++) {
                if (!strcmp(varname,*vp))
                        return(0);
        }
        for(vp=invalid_varprefixes;*vp;vp++) {
                if (!strncmp(varname,*vp,strlen(*vp)))
                        return(0);
        }
        return(1);
}

/* envToExec():
   Create a file of "set" commands that can be run to recreate the
   current environment.
   Changed Oct 2008 to eliminate use of getAppRamStart().
*/
int
envToExec(char *filename)
{
        int             err, vartot, size, rc;
        char    *buf, *bp, *cp;
        register struct s_shell *sp;

        sp = shell_vars;
        vartot = size = rc = 0;

        /* First go through the list to see how much space we need
         * to allocate...
         */
        while(1) {
                if (validEnvToExecVar(sp->name)) {
                        size += strlen(sp->name) + 6;
                        cp = sp->val;
                        while(*cp) {
                                if (*cp == '$')
                                        size++;
                                size++;
                                cp++;
                        }
                        size += 3;
                        vartot++;
                }
                if (sp->next != (struct s_shell *)0)
                        sp = sp->next;
                else
                        break;
        }
        if (size == 0)
                return(0);

        /* Now that we know the space needed (stored in 'size' variable),
         * allocate it and build the new file in that space, then use tfsadd()
         * to create the file...
         */
        vartot = 0;
        sp = shell_vars;
        buf = bp = (char *)env_alloc(size);
        while(1) {
                /* Note: if this code changes, then the code above that is used to
                 * allocate the buffer size may also need to change...
                 */
                if (validEnvToExecVar(sp->name)) {
                        bp += sprintf(bp,"set %s \"",sp->name);
                        cp = sp->val;
                        while(*cp) {
                                if (*cp == '$')
                                        *bp++ = '\\';
                                *bp++ = *cp++;
                        }
                        *bp++ = '\"';
                        *bp++ = '\n';
                        *bp = 0;
                        vartot++;
                }
                if (sp->next != (struct s_shell *)0)
                        sp = sp->next;
                else
                        break;
        }
        if (vartot > 0) {
                err = tfsadd(filename,"envsetup","e",(unsigned char *)buf,strlen(buf));
                if (err != TFS_OKAY) {
                        printf("%s: %s\n",filename,(char *)tfsctrl(TFS_ERRMSG,err,0));
                        rc = -1;
                }
        }
        env_free(buf);
        return(rc);
}
#endif

#else

/* The 'set' command is part of the build even if INCLUDE_SHELLVARS
 * is false.  This allows the user to still access teh "set -b ###"
 * facility for changing the baudrate.
 */
char *SetHelp[] = {
        "Set baud",
        "-[b:] (no args)",
#if INCLUDE_VERBOSEHELP
        " -b        set console baudrate",
#endif
        0,
};

int
Set(int argc,char *argv[])
{
        int             opt;

        while((opt=getopt(argc,argv,"b:")) != -1) {
                switch(opt) {
                case 'b':
                        ChangeConsoleBaudrate(atoi(optarg));
                        return(CMD_SUCCESS);
                        break;
                default:
                        return(CMD_PARAM_ERROR);
                }
        }
        printf("Shell vars not included in build.\n");
        return(CMD_FAILURE);
}

int
setenv(char *name,char *value)
{
        return(-1);
}

char *
getenv(char *name)
{
        return(0);
}

int
shell_sprintf(char *varname, char *fmt, ...)
{
        return(0);
}

void
ConsoleBaudEnvSet(void)
{
}

char *
getenvp(void)
{
        return(0);
}

#endif

/* ChangeConsoleBaudrate():
 * Called to attempt to adjust the console baudrate.
 * Support 2 special cases:
 *   if baud == 0, then just turn off console echo;
 *   if baud == 1, turn it back on.
 */
int
ChangeConsoleBaudrate(int baud)
{
        if (baud == 0)
                console_echo(0);
        else if (baud == 1)
                console_echo(1);
        else {
                if (ConsoleBaudSet(baud) < 0) {
                        printf("Baud=%d failed\n",baud);
                        return(-1);
                }
                ConsoleBaudRate = baud;
                ConsoleBaudEnvSet();
        }
        return(0);
}