path: root/main/common/env.c

/**************************************************************************
 *
 * 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);
}