defaultenv (doesn't work)

2 files changed, 196 insertions, 174 deletions

diff --git a/avr/command_tbl.c b/avr/command_tbl.c
index 6fcbee7..6e8a91b 100644
--- a/avr/command_tbl.c
+++ b/avr/command_tbl.c
@@ -8,6 +8,7 @@
 extern command_ret_t do_help(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_echo(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_env_print(cmd_tbl_t *, int, int, char * const []);
+extern command_ret_t do_env_default(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_env_set(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_env_save(cmd_tbl_t *, int, int, char * const []);
 extern command_ret_t do_loadf(cmd_tbl_t *, int, int, char * const []);
@@ -89,6 +90,11 @@ CMD_TBL_ITEM(
 	"save environment variables to persistent storage",
 	""
 ),
+CMD_TBL_ITEM(
+	defaultenv,	1,	0,	do_env_default,
+	"set all environment variables to their default values",
+	""
+),
 
 CMD_TBL_ITEM(
 	loadf,	1,	0,	do_loadf,
diff --git a/avr/env.c b/avr/env.c
index c6e173c..f743f41 100644
--- a/avr/env.c
+++ b/avr/env.c
@@ -18,6 +18,8 @@
 #define OBSOLETE_FLAG	0
 #define ENV_GET_VAL	(1<<0)
 
+#define ENVLIST_DELETE	(1<<0)
+
 
 /*
  * Default Environment
@@ -71,7 +73,7 @@ char env_get_char(uint16_t index)
 	if (env_valid == 2)
 		off = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 
-	return (char) eeprom_read_byte((const uint8_t *)off + index + 
+	return (char) eeprom_read_byte((const uint8_t *)off + index +
 				offsetof(env_t, data));
 }
 
@@ -81,7 +83,7 @@ uint16_t varname_get(char *buf, env_item_t *ep)
 {
 	int i = 0;
 	char c;
-	
+
 	if (ep->flags & EF_N_EEP) {
 
 		while ((c = env_get_char(ep->name.eep + i)) != '=' &&
@@ -120,16 +122,16 @@ uint16_t varval_get(char *buf, uint16_t index, int len)
 {
 	int i = 0;
 	char c;
-	
+
 	while ((c = env_get_char (index + i)) != '\0' && i < len) {
 		buf[i] = c;
 		i++;
 	};
-		
+
 	buf[i] = '\0';
-	
+
 	/* TODO: len check */
-	
+
 	return i;
 }
 
@@ -138,9 +140,9 @@ int comp_env_key_item(const void *key, const void *item)
 {
 	char buf[CONFIG_SYS_ENV_NAMELEN+1];
 	env_item_t *ep = (env_item_t *) item;
-	
+
 	varname_get(buf, ep);
-	
+
 	return strcmp((char *) key, buf);
 }
 
@@ -149,36 +151,165 @@ int comp_env_items(const void *m1, const void *m2)
 {
 	char b1[CONFIG_SYS_ENV_NAMELEN+1];
 	char b2[CONFIG_SYS_ENV_NAMELEN+1];
-	
+
 	env_item_t *ep1 = (env_item_t *) m1;
 	env_item_t *ep2 = (env_item_t *) m2;
-	
+
 	varname_get(b1, ep1);
 	varname_get(b2, ep2);
-	
+
 	return strcmp(b1, b2);
 }
 
 
+env_item_t *envlist_search(const MEMX char *name)
+{
+	char *p = (char *) name;
+
+#ifdef __MEMX
+	char buf[CONFIG_SYS_ENV_NAMELEN+1];
+
+	if (__builtin_avr_flash_segment(name) != -1) {
+		p = buf;
+		while ((*p++ = *name++) != '\0')
+			;
+		p = buf;
+	}
+#endif /* __MEMX */
+
+	return bsearch(p, env_list, entrycount,
+				sizeof(env_item_t), comp_env_key_item);
+}
+
+
+static
+env_item_t *envlist_enter(env_item_t *e)
+{
+	char *key = e->name.ram;
+	const size_t size = sizeof(env_item_t);
+	env_item_t *ep;
+
+	ep = bsearch(key, env_list, entrycount,
+			size, comp_env_key_item);
+
+	if (ep == NULL) {
+		if (entrycount < CONFIG_ENVVAR_MAX) {
+
+			env_list[entrycount++] = *e;
+			qsort(env_list, entrycount, size, comp_env_items);
+			ep = bsearch(key, env_list, entrycount,
+						size, comp_env_key_item);
+		}
+	} else {
+		if ((ep->flags & EF_V_EEP) == 0) {
+			free(ep->val.ram);
+		}
+		ep->val.ram = e->val.ram;
+	}
+
+	if (ep != NULL) {
+		ep->flags |= EF_DIRTY;
+		ep->flags &= ~EF_V_EEP;
+
+		if ((ep->flags & EF_N_EEP) == 0) {
+			int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
+			char *name = xmalloc(nlen + 1);
+			if (name == NULL) {
+				printf_P(PSTR("## Can't malloc %d bytes\n"),
+					nlen + 1);
+				return NULL;
+			}
+			strcpy(name, key);
+			name[nlen] = '\0';
+			ep->name.ram = name;
+		}
+	}
+
+	return ep;
+}
+
+
+static
+int env_item_delete(env_item_t *ep)
+{
+	if (entrycount == 0)
+		return -1;
+	if ((ep->flags & EF_V_EEP) == 0)
+		free(ep->val.ram);
+	if ((ep->flags & EF_N_EEP) == 0)
+		free(ep->name.ram);
+
+	entrycount--;
+	size_t size = sizeof(env_item_t);
+	memmove(ep, ep + 1, (env_list - ep)*size + entrycount*size);
+
+	return 0;
+}
+
+static
+int envlist_delete(const char *name)
+{
+	env_item_t *ep = bsearch(name, env_list, entrycount,
+				sizeof(env_item_t), comp_env_key_item);
+
+	if (ep != NULL)
+		return env_item_delete(ep);
+
+	return 1;
+}
+
+
 static
-int envlist_import(void)
+env_item_t *envlist_get(const MEMX char *name, uint_fast8_t flag)
+{
+	env_item_t *ep;
+
+	ep = envlist_search(name);
+
+	if (ep != NULL && (flag & ENV_GET_VAL)) {
+		if (ep->flags & EF_V_EEP) {
+			char *vp;
+			int len;
+			len = varval_getlen(ep->val.eep);
+			if (len > CONFIG_SYS_CBSIZE)
+				len = CONFIG_SYS_CBSIZE;
+			vp = xmalloc(len + 1);
+			if (vp) {
+				varval_get(vp, ep->val.eep, len + 1);
+				ep->val.ram = vp;
+				ep->flags &= ~EF_V_EEP;
+			} else
+				printf_P(PSTR("Out of memory!\n"));
+		}
+	}
+
+	return ep;
+}
+
+
+static
+int envlist_import(uint8_t flags)
 {
 	char name[CONFIG_SYS_ENV_NAMELEN+1];
 	uint16_t idx = 0;
 	int nlen;
 	env_item_t e;
-	
+
+	if ((flags & ENVLIST_DELETE) != 0)
+		while (entrycount != 0)
+			env_item_delete(&env_list[entrycount-1]);
+
 	e.flags = EF_N_EEP | EF_V_EEP;
 	e.name.eep = idx;
-	while ((nlen = varname_get(name, &e)) != 0 && idx < ENV_SIZE) {
-	
+	while (idx < ENV_SIZE && (nlen = varname_get(name, &e)) != 0) {
+
 		if (entrycount <= CONFIG_ENVVAR_MAX) {
 			e.val.eep = idx + nlen + 1;
-	
+
 			env_list[entrycount++] = e;
 
 			idx += nlen + 1;
-			while (env_get_char(idx++) != 0 && idx < ENV_SIZE)
+			while (idx < ENV_SIZE && env_get_char(idx++) != 0)
 				;
 			e.name.eep = idx;
 		} else {
@@ -193,7 +324,7 @@ int envlist_import(void)
 
 
 static
-int set_default_env(void)
+int set_default_env(const FLASH char* msg)
 {
 	char buf[56];
 	uint16_t eep = CONFIG_ENV_OFFSET + offsetof(env_t, data);
@@ -201,6 +332,9 @@ int set_default_env(void)
 	unsigned int i, src = 0;
 	char c = 0xff, c0 = c;
 
+	if (msg)
+		printf_P(msg);
+
 	if (env_valid == 1) {
 		eep = CONFIG_ENV_OFFSET + offsetof(env_t, data) + CONFIG_ENV_SIZE;
 	}
@@ -228,7 +362,7 @@ int set_default_env(void)
 static
 uint16_t env_crc(uint16_t data_offset)
 {
-	uint16_t crc; 
+	uint16_t crc;
 	uint16_t i;
 	char c, c0;
 
@@ -236,7 +370,7 @@ uint16_t env_crc(uint16_t data_offset)
 	c = 0xff;
 	for (i = 0; !(c == 0 && c0 == 0) && i < ENV_SIZE; i++)
 	{
-		c0 = c; 
+		c0 = c;
 		c = eeprom_read_byte((const uint8_t *) data_offset + i);
 		crc = crc16(crc, c);
 	}
@@ -302,7 +436,7 @@ int env_check_valid(void)
 			rc = 1;
 #endif
 	}
-	
+
 	return rc;
 }
 
@@ -311,140 +445,13 @@ int env_init(void)
 {
 	env_valid = env_check_valid();
 	if (env_valid == 0) {
-		printf_P(PSTR("*** Warning - bad CRC, "
+		set_default_env(PSTR("*** Warning - bad CRC, "
 				"using default environment\n\n"));
-		set_default_env();
-	}
-	entrycount = 0;
-	envlist_import();
-	return 0; 
-}	
-
-
-
-env_item_t *envlist_search(const MEMX char *name)
-{
-	char *p = (char *) name;
-
-#ifdef __MEMX
-	char buf[CONFIG_SYS_ENV_NAMELEN+1];
-
-	if (__builtin_avr_flash_segment(name) != -1) {
-		p = buf;
-		while ((*p++ = *name++) != '\0')
-			;
-		p = buf;
-	}
-#endif /* __MEMX */
-
-	return bsearch(p, env_list, entrycount,
-				sizeof(env_item_t), comp_env_key_item);
-}
-			
-
-static
-env_item_t *envlist_enter(env_item_t *e)
-{
-	char *key = e->name.ram;
-	const size_t size = sizeof(env_item_t);
-	env_item_t *ep;
-	
-	ep = bsearch(key, env_list, entrycount, 
-			size, comp_env_key_item);
-					
-	if (ep == NULL) {
-		if (entrycount < CONFIG_ENVVAR_MAX) {
-			
-			env_list[entrycount++] = *e;
-			qsort(env_list, entrycount, size, comp_env_items);
-			ep = bsearch(key, env_list, entrycount, 
-						size, comp_env_key_item);
-		}
-	} else { 
-		if ((ep->flags & EF_V_EEP) == 0) {
-			free(ep->val.ram);
-		}
-		ep->val.ram = e->val.ram;
-	}		
-
-	if (ep != NULL) {
-		ep->flags |= EF_DIRTY;
-		ep->flags &= ~EF_V_EEP;
-		
-		if ((ep->flags & EF_N_EEP) == 0) {
-			int nlen = strnlen(key, CONFIG_SYS_ENV_NAMELEN);
-			char *name = xmalloc(nlen + 1);
-			if (name == NULL) {
-				printf_P(PSTR("## Can't malloc %d bytes\n"), 
-					nlen + 1);
-				return NULL;
-			}
-			strcpy(name, key);
-			name[nlen] = '\0';
-			ep->name.ram = name;
-		}
 	}
-
-	return ep;		
-}	
-
-
-static
-int env_item_delete(env_item_t *ep)
-{
-	if (entrycount == 0)
-		return -1;
-	if ((ep->flags & EF_V_EEP) == 0) 
-		free(ep->val.ram);
-	if ((ep->flags & EF_N_EEP) == 0) 
-		free(ep->name.ram); 
-
-	entrycount--;
-	size_t size = sizeof(env_item_t);
-	memmove(ep, ep + 1, (env_list - ep)*size + entrycount*size);
-
-	return 0;		
+	envlist_import(ENVLIST_DELETE);
+	return 0;
 }
 
-static
-int envlist_delete(const char *name)
-{
-	env_item_t *ep = bsearch(name, env_list, entrycount, 
-				sizeof(env_item_t), comp_env_key_item);
-
-	if (ep != NULL)
-		return env_item_delete(ep);
-
-	return 1;
-}
-
-	
-static
-env_item_t *envlist_get(const MEMX char *name, uint_fast8_t flag)
-{
-	env_item_t *ep;
-	
-	ep = envlist_search(name);
-
-	if (ep != NULL && (flag & ENV_GET_VAL)) {
-		if (ep->flags & EF_V_EEP) {
-			char *vp;
-			int len;
-			len = varval_getlen(ep->val.eep);
-			if (len > CONFIG_SYS_CBSIZE)
-				len = CONFIG_SYS_CBSIZE;
-			vp = xmalloc(len + 1);
-			if (vp) {
-				varval_get(vp, ep->val.eep, len + 1);
-				ep->val.ram = vp;
-				ep->flags &= ~EF_V_EEP;
-			} else
-				printf_P(PSTR("Out of memory!\n"));
-		}
-	}			
-	
-	return ep;
-}
 
 
 char *getenv(const MEMX char *name)
@@ -473,18 +480,18 @@ int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
 
 	if (space_left <= 0)
 		return 0;
-	
+
 	eeprom_update_block(buf, (uint8_t *) offset, len);
 	offset += len;
-	
+
 	if (e.val.ram != NULL) {
 		char c;
 		do {
-			if (e.flags & EF_V_EEP) 
+			if (e.flags & EF_V_EEP)
 				c = env_get_char(e.val.eep++);
 			else
 				c = *e.val.ram++;
-			
+
 			eeprom_update_byte((uint8_t *) offset, c);
 			offset++;
 			space_left--;
@@ -492,7 +499,7 @@ int env_item_save(env_item_t *ep, uint16_t offset, int space_left)
 		} while ((c != '\0') && space_left );
 	}
 	return len;
-}	
+}
 
 
 static
@@ -510,7 +517,7 @@ int saveenv(void)
 		off_red	= CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
 	}
 
-	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff); 
+	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 0xff);
 
 	pos = off + offsetof(env_t, data);
 	left = ENV_SIZE - 1;
@@ -526,20 +533,17 @@ int saveenv(void)
 	eeprom_update_byte((uint8_t *) pos, 0);
 	crc = env_crc(off + offsetof(env_t, data));
 	eeprom_update_word((uint16_t *) off + offsetof(env_t, crc), crc);
-	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags), 
+	eeprom_update_byte((uint8_t *) off + offsetof(env_t, flags),
 					ACTIVE_FLAG);
 
 	if (rc == 0) {
-		while (entrycount != 0) {
-			env_item_delete(&env_list[entrycount-1]);
-		}
-		eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags), 
+		eeprom_update_byte((uint8_t *) off_red + offsetof(env_t, flags),
 					OBSOLETE_FLAG);
 		env_valid = (env_valid == 2) ? 1 : 2;
 
-		envlist_import();
+		envlist_import(ENVLIST_DELETE);
 	}
-	
+
 	return rc;
 }
 
@@ -550,18 +554,18 @@ int env_item_print(env_item_t *ep)
 	char buf[CONFIG_SYS_ENV_NAMELEN+1];
 	int len;
 	env_item_t e = *ep;
-	
+
 	varname_get(buf, ep);
 	len = printf_P(PSTR("%s="), buf);
-	
+
 	if (e.val.ram != NULL) {
 		while (1) {
 			char c;
-			if (e.flags & EF_V_EEP) 
+			if (e.flags & EF_V_EEP)
 				c = env_get_char(e.val.eep++);
 			else
 				c = *e.val.ram++;
-			
+
 			if (c != '\0') {
 				putchar(c);
 				len++;
@@ -573,7 +577,7 @@ int env_item_print(env_item_t *ep)
 	len ++;
 
 	return len;
-}	
+}
 
 
 /*
@@ -581,13 +585,13 @@ int env_item_print(env_item_t *ep)
  *
  * Returns -1 in case of error, or length of printed string
  */
-static 
+static
 int env_print(const MEMX char *name)
 {
 	int len = -1;
 
 	if (name) {		/* print a single name */
-	
+
 		env_item_t *ep = envlist_search(name);
 		if (ep != NULL)
 			len = env_item_print(ep);
@@ -607,7 +611,7 @@ int env_print_ramsize(void)
 	int size = 0;
 	uint8_t name_cnt = 0;
 	uint8_t val_cnt = 0;
-	
+
 	for (int i = 0 ; i < entrycount; i++) {
 		if ((env_list[i].flags & EF_N_EEP) == 0 &&
 				(env_list[i].name.ram != NULL)) {
@@ -751,7 +755,7 @@ int setenv(const char *varname, const char *varvalue)
 
 	if (varvalue == NULL || varvalue[0] == '\0')
 		--argc;
-		
+
 	return (int) _do_env_set(0, argc, (char * const *)argv);
 }
 
@@ -834,6 +838,18 @@ command_ret_t do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv
 }
 
 
+command_ret_t do_env_default(cmd_tbl_t *cmdtp, int flag,
+			  int argc, char * const argv[])
+{
+	(void) cmdtp; (void) flag; (void) argc;	(void) argv;
+
+	/* Reset the whole environment */
+	set_default_env(PSTR("## Resetting to default environment\n"));
+	envlist_import(ENVLIST_DELETE);
+
+	return CMD_RET_SUCCESS;
+}
+
 command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 {
 	(void) cmdtp; (void) flag; (void) argc;	(void) argv;
@@ -842,7 +858,7 @@ command_ret_t do_env_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const arg
 	return saveenv() ? CMD_RET_FAILURE : CMD_RET_SUCCESS;
 }
 
-#if defined(CONFIG_AUTO_COMPLETE) 
+#if defined(CONFIG_AUTO_COMPLETE)
 int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
 {
 	ENTRY *match;