defaultenv (doesn't work)

diff --git a/avr/command_tbl.c b/avr/command_tbl.c
index 6fcbee71472026acf229e08a8be6a7c34597112f..6e8a91b5fa67541221b42afb8816c10f3e3c86fb 100644 (file)
--- 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 c6e173c8feffb7785ed1f1c3be73447ae0f0699d..f743f417424c3961746f1da207a282ba1f71f964 100644 (file)
--- 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;