void set_default_env(const char *s, int flags) { if (sizeof(default_environment) > ENV_SIZE) { puts("*** Error - default environment is too large\n\n"); return; } if (s) { if ((flags & H_INTERACTIVE) == 0) { printf("*** Warning - %s, " "using default environment\n\n", s); } else { puts(s); } } else { debug("Using default environment\n"); } if (himport_r(&env_htab, (char *)default_environment, sizeof(default_environment), '\0', flags, 0, 0, NULL) == 0) pr_err("## Error: Environment import failed: errno = %d\n", errno); gd->flags |= GD_FLG_ENV_READY; gd->flags |= GD_FLG_ENV_DEFAULT; }
void set_default_env(const char *s) { if (sizeof(default_environment) > ENV_SIZE) { puts("*** Error - default environment is too large\n\n"); return; } if (s) { if (*s == '!') { printf("*** Warning - %s, " "using default environment\n\n", s + 1); } else { puts(s); } } else { puts("Using default environment\n\n"); } if (himport_r(&env_htab, (char *)default_environment, sizeof(default_environment), '\0', 0) == 0) error("Environment import failed: errno = %d\n", errno); gd->flags |= GD_FLG_ENV_READY; }
/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("bad CRC", 0); return -EIO; } } if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, 0, NULL)) { gd->flags |= GD_FLG_ENV_READY; return 0; } pr_err("Cannot import environment: errno = %d\n", errno); set_default_env("import failed", 0); return -EIO; }
/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("!bad CRC"); return 0; }else if(ep->data[0] == 0xff){ printf("check env data = 0xff, set default env\n"); set_default_env("!check env data is 0xff"); saveenv(); return 0; } } if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0)) { gd->flags |= GD_FLG_ENV_READY; return 1; } error("Cannot import environment: errno = %d\n", errno); set_default_env("!import failed"); return 0; }
/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; tick_printf(__FILE__, __LINE__); if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("!bad CRC"); return 0; } } tick_printf(__FILE__, __LINE__); if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0)) { gd->flags |= GD_FLG_ENV_READY; tick_printf(__FILE__, __LINE__); return 1; } error("Cannot import environment: errno = %d\n", errno); set_default_env("!import failed"); return 0; }
static void flash_use_efex_env(void) { if (himport_r(&env_htab, (char *)sunxi_sprite_environment, sizeof(sunxi_sprite_environment), '\0', 0) == 0) { error("Environment import failed: errno = %d\n", errno); } gd->flags |= GD_FLG_ENV_READY; return ; }
/* [re]set individual variables to their value in the default environment */ int set_default_vars(int nvars, char * const vars[]) { /* * Special use-case: import from default environment * (and use \0 as a separator) */ return himport_r(&env_htab, (const char *)default_environment, sizeof(default_environment), '\0', H_NOCLEAR, nvars, vars, 1 /* do_apply */); }
/* [re]set individual variables to their value in the default environment */ int set_default_vars(int nvars, char * const vars[], int flags) { /* * Special use-case: import from default environment * (and use \0 as a separator) */ flags |= H_NOCLEAR; return himport_r(&env_htab, (const char *)default_environment, sizeof(default_environment), '\0', flags, 0, nvars, vars); }
void set_default_env(const char *s) { /* * By default, do not apply changes as they will eventually * be applied by someone else */ int do_apply = 0; if (sizeof(default_environment) > ENV_SIZE) { puts("*** Error - default environment is too large\n\n"); return; } if (s) { if (*s == '!') { printf("*** Warning - %s, " "using default environment\n\n", s + 1); } else { /* * This set_to_default was explicitly asked for * by the user, as opposed to being a recovery * mechanism. Therefore we check every single * variable and apply changes to the system * right away (e.g. baudrate, console). */ do_apply = 1; puts(s); } } else { puts("Using default environment\n\n"); } if (himport_r(&env_htab, (char *)default_environment, sizeof(default_environment), '\0', 0, 0, NULL, do_apply) == 0) error("Environment import failed: errno = %d\n", errno); gd->flags |= GD_FLG_ENV_READY; }
//base on env_import static int env_append(const char *buf, int check) { env_t *ep = (env_t *)buf; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { return 0; } } if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', H_NOCLEAR, 0, NULL)) { gd->flags |= GD_FLG_ENV_READY; return 1; } printf("Cannot import environment: errno = %d\n", errno); return 0; }
/* * Check if CRC is valid and (if yes) import the environment. * Note that "buf" may or may not be aligned. */ int env_import(const char *buf, int check) { env_t *ep = (env_t *)buf; int ret; if (check) { uint32_t crc; memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, ENV_SIZE) != crc) { set_default_env("!bad CRC"); return 0; } } /* Decrypt the env if desired. */ ret = env_aes_cbc_crypt(ep, 0); if (ret) { error("Failed to decrypt env!\n"); set_default_env("!import failed"); return ret; } if (himport_r(&env_htab, (char *)ep->data, ENV_SIZE, '\0', 0, 0, 0, NULL)) { gd->flags |= GD_FLG_ENV_READY; return 1; } error("Cannot import environment: errno = %d\n", errno); set_default_env("!import failed"); return 0; }
/* * env import [-d] [-t | -b | -c] addr [size] * -d: delete existing environment before importing; * otherwise overwrite / append to existion definitions * -t: assume text format; either "size" must be given or the * text data must be '\0' terminated * -b: assume binary format ('\0' separated, "\0\0" terminated) * -c: assume checksum protected environment format * addr: memory address to read from * size: length of input data; if missing, proper '\0' * termination is mandatory */ static int do_env_import(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) { char *cmd, *addr; char sep = '\n'; int chk = 0; int fmt = 0; int del = 0; size_t size; cmd = *argv; while (--argc > 0 && **++argv == '-') { char *arg = *argv; while (*++arg) { switch (*arg) { case 'b': /* raw binary format */ if (fmt++) goto sep_err; sep = '\0'; break; case 'c': /* external checksum format */ if (fmt++) goto sep_err; sep = '\0'; chk = 1; break; case 't': /* text format */ if (fmt++) goto sep_err; sep = '\n'; break; case 'd': del = 1; break; default: return cmd_usage(cmdtp); } } } if (argc < 1) return cmd_usage(cmdtp); if (!fmt) printf("## Warning: defaulting to text format\n"); addr = (char *)simple_strtoul(argv[0], NULL, 16); if (argc == 2) { size = simple_strtoul(argv[1], NULL, 16); } else { char *s = addr; size = 0; while (size < MAX_ENV_SIZE) { if ((*s == sep) && (*(s+1) == '\0')) break; ++s; ++size; } if (size == MAX_ENV_SIZE) { printf("## Warning: Input data exceeds %d bytes" " - truncated\n", MAX_ENV_SIZE); } ++size; printf("## Info: input data size = %zd = 0x%zX\n", size, size); } if (chk) { uint32_t crc; env_t *ep = (env_t *)addr; size -= offsetof(env_t, data); memcpy(&crc, &ep->crc, sizeof(crc)); if (crc32(0, ep->data, size) != crc) { puts("## Error: bad CRC, import failed\n"); return 1; } addr = (char *)ep->data; } if (himport_r(&env_htab, addr, size, sep, del ? 0 : H_NOCLEAR) == 0) { error("Environment import failed: errno = %d\n", errno); return 1; } gd->flags |= GD_FLG_ENV_READY; return 0; sep_err: printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n", cmd); return 1; }