static void set_env(char *var, char *val) { char *setenv[4] = { "setenv", NULL, NULL, NULL, }; setenv[1] = var; setenv[2] = val; do_setenv(NULL, 0, 3, setenv); }
void do_builtins(t_lst *list, char **cmd) //, char **paths) { t_lst *new_list; new_list = NULL; if (check_is_builtin(cmd[0]) == 1) do_cd(list, cmd); if (check_is_builtin(cmd[0]) == 2) do_setenv(list, cmd, 1); else if (check_is_builtin(cmd[0]) == 3) do_unsetenv(list, cmd); else if (check_is_builtin(cmd[0]) == 4) do_env(list, cmd); //, paths); }
void builtin_setenv(t_env *env) { const char error[] = "setenv: Too many arguments.\n"; char *ptr; char *name; char *extra_ptr; ptr = env->line + sizeof("setenv") - 1; name = NULL; while (*ptr == ' ' || *ptr == '\t') ++ptr; if (!*ptr) builtin_env(env); else { name = ptr; while (*ptr && !(*ptr == ' ' | *ptr == '\t')) ++ptr; while (*ptr == ' ' || *ptr == '\t') ++ptr; if (!*ptr) do_setenv(env, name, ""); else { extra_ptr = ptr; while (*extra_ptr && !(*extra_ptr == ' ' || *extra_ptr == '\t' || *extra_ptr == '\n')) ++extra_ptr; while (*extra_ptr == ' ' || *extra_ptr == '\t' || *extra_ptr == '\n') ++extra_ptr; if (*extra_ptr) write(2, error, sizeof(error) - 1); else do_setenv(env, name, ptr); } } }
static int do_arg(t_lst *node, char *arg) { int i; char **cmd; i = 0; cmd = ft_strsplit_ws(arg); if (!*cmd) return (-1); if (ft_strcmp(*cmd, "exit") == 0) i = do_exit(arg); else if (ft_strcmp(*cmd, "env") == 0) i = deal_with_env(node, arg); else if (ft_strcmp(*cmd, "setenv") == 0) i = do_setenv(node, arg); else if (ft_strcmp(*cmd, "unsetenv") == 0) i = do_unsetenv(node, arg); else if (ft_strcmp(*cmd, "cd") == 0) i = do_cd(node, arg); else if (*cmd) i = deal_with_command(node, cmd); ft_strdel(cmd); return (i); }
static void save_block_values(struct fastboot_ptentry *ptn, unsigned int offset, unsigned int size) { struct fastboot_ptentry *env_ptn; char var[64], val[32]; char start[32], length[32]; char ecc_type[32]; char *lock[5] = { "nand", "lock", NULL, NULL, NULL, }; char *unlock[5] = { "nand", "unlock", NULL, NULL, NULL, }; char *ecc[4] = { "nand", "ecc", NULL, NULL, }; char *setenv[4] = { "setenv", NULL, NULL, NULL, }; char *saveenv[2] = { "setenv", NULL, }; setenv[1] = var; setenv[2] = val; lock[2] = unlock[2] = start; lock[3] = unlock[3] = length; printf ("saving it..\n"); if (size == 0) { /* The error case, where the variables are being unset */ sprintf (var, "%s_nand_offset", ptn->name); sprintf (val, ""); do_setenv (NULL, 0, 3, setenv); sprintf (var, "%s_nand_size", ptn->name); sprintf (val, ""); do_setenv (NULL, 0, 3, setenv); } else { /* Normal case */ sprintf (var, "%s_nand_offset", ptn->name); sprintf (val, "0x%x", offset); printf ("%s %s %s\n", setenv[0], setenv[1], setenv[2]); do_setenv (NULL, 0, 3, setenv); sprintf (var, "%s_nand_size", ptn->name); sprintf (val, "0x%x", size); printf ("%s %s %s\n", setenv[0], setenv[1], setenv[2]); do_setenv (NULL, 0, 3, setenv); } /* Warning : The environment is assumed to be in a partition named 'enviroment'. It is very possible that your board stores the enviroment someplace else. */ env_ptn = fastboot_flash_find_ptn("environment"); if (env_ptn) { /* Some flashing requires the nand's ecc to be set */ ecc[2] = ecc_type; if ((env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_HW_ECC) && (env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_SW_ECC)) { /* Both can not be true */ printf ("Warning can not do hw and sw ecc for partition '%s'\n", ptn->name); printf ("Ignoring these flags\n"); } else if (env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_HW_ECC) { sprintf (ecc_type, "hw"); CFG_FASTBOOT_FLASHCMD (NULL, 0, 3, ecc); } else if (env_ptn->flags & FASTBOOT_PTENTRY_FLAGS_WRITE_SW_ECC) { sprintf (ecc_type, "sw"); CFG_FASTBOOT_FLASHCMD (NULL, 0, 3, ecc); } sprintf (start, "0x%x", env_ptn->start); sprintf (length, "0x%x", env_ptn->length); /* This could be a problem is there is an outstanding lock */ CFG_FASTBOOT_FLASHCMD (NULL, 0, 4, unlock); } do_saveenv (NULL, 0, 1, saveenv); if (env_ptn) { CFG_FASTBOOT_FLASHCMD (NULL, 0, 4, lock); } }
int do_mmc_read_img (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) { int device_num = 1; int dev_id = 0; ulong kernel_addr,ramdisk_addr; ulong blk_cnt_kenel, blk_cnt_ramdisk, page_cnt_kenel, page_cnt_ramdisk; ulong ret; static unsigned char data[512]; block_dev_desc_t *dev_desc=NULL; int dev=0; ulong part=1; char *ep; unsigned int page_size, kernel_size, ramdisk_size, total_size; char var[64], val[32]; char *setenv[4] = { "setenv", NULL, NULL, NULL, }; char *saveenv[2] = { "setenv", NULL, }; setenv[1] = var; setenv[2] = val; /*printf("%s\n", __FUNCTION__);*/ if (argc < 4) { printf("Usage:\n%s\n", cmdtp->usage); return 1; } /*get device id*/ dev_id = (int)simple_strtoul (argv[2], &ep, 16); if (dev_id == 0 || dev_id == 1 || dev_id == 2 || dev_id == 3) device_num = dev_id; else { printf("dev_id Invalid\n"); return 1; } /*get mmc dev descriptor*/ dev_desc=get_dev(argv[1], dev_id); if (dev_desc==NULL) { puts ("\n** Invalid boot device **\n"); return 1; } if (*ep) { if (*ep != ':') { puts ("\n** Invalid boot device, use `dev[:part]' **\n"); return 1; } part = (int)simple_strtoul(++ep, NULL, 16); } /*printf("dev_id:%x,part:%x\n",dev_id,part);*/ /* init mmc controller */ if (mmc_init(1, device_num)) { printf("mmc init failed?\n"); return 1; } if (mmc_register_device(dev_desc, part) != 0) { printf ("\n** Unable to use %s %d:%d for fatload **\n", argv[1], dev_id, part); return 1; } /*get kernel memory address*/ kernel_addr = simple_strtoul (argv[3], NULL, 16); if (kernel_addr < 0) { printf("kernel addr Invalid\n"); return 1; } /*get ramdisk memory address*/ ramdisk_addr = simple_strtoul (argv[4], NULL, 16); if (ramdisk_addr < 0) { printf("ramdisk addr Invalid\n"); return 1; } /*mmc block read partition offset sectors*/ ret = mmc_bread(device_num, mmc_part_offset, 1, (void *)data); if (ret == -1 ) { printf("Read Data Fail\n"); return 1; } else { printf("Read Data Success\n"); } /*memdump ((void *) data, 512);*/ struct fastboot_boot_img_hdr *fb_hdr = (struct fastboot_boot_img_hdr *)data; if (memcmp(data, "ANDROID!", 8)) { printf(" boot.img partition table not found\n"); return -1; } /*kernel size change to sectors*/ kernel_size = fb_hdr->kernel_size ; ramdisk_size = fb_hdr->ramdisk_size; page_size = fb_hdr->page_size ; total_size = 1*page_size + kernel_size + ramdisk_size; /* calculate transfer block count */ blk_cnt_kenel= (fb_hdr->kernel_size / 512); if (fb_hdr->kernel_size % 512) blk_cnt_kenel++; page_cnt_kenel= (fb_hdr->kernel_size / page_size); if (fb_hdr->kernel_size % page_size) page_cnt_kenel++; /* load kernel image from mmc boot image to kernel_addr */ /*printf(" mmc_part_offset + page_size:0x%x, fb_hdr->kernel_size:0x%x, mem kernel_addr:0x%x\n", mmc_part_offset + page_size / 512, fb_hdr->kernel_size, kernel_addr);*/ ret = mmc_bread(device_num, mmc_part_offset + page_size / 512, blk_cnt_kenel, kernel_addr); if (ret == -1 ) { printf("Read Kernel Data Fail\n"); return 1; } else { printf("Read Kernel Data Success\n"); } blk_cnt_ramdisk= (fb_hdr->ramdisk_size / 512); if (fb_hdr->ramdisk_size % 512) blk_cnt_ramdisk++; page_cnt_ramdisk= (fb_hdr->kernel_size / page_size); if (fb_hdr->kernel_size % page_size) page_cnt_ramdisk++; /* load ramdisk image from mmc boot image to ramdisk_addr */ /*printf("mmc_part_offset + page_size + blk_cnt_kenel:0x%x, fb_hdr->ramdisk_size:0x%x, mem ramdisk_addr:0x%x\n", mmc_part_offset + page_size /512 + page_cnt_kenel *(page_size/512), fb_hdr->ramdisk_size, ramdisk_addr);*/ ret = mmc_bread(device_num, mmc_part_offset + page_size /512 + page_cnt_kenel *(page_size /512), blk_cnt_ramdisk, ramdisk_addr); if (ret == -1 ) { printf("Read Ramdisk Data Fail\n"); return 1; } else { printf("Read Ramdisk Data Success\n"); } /*save ramdisk size to env argv[4]*/ sprintf (var, "%s", argv[5]); sprintf (val, "%x", fb_hdr->ramdisk_size); do_setenv (NULL, 0, 3, setenv); printf("%s %s %s\n", setenv[0], setenv[1], setenv[2]); /*do_saveenv (NULL, 0, 1, saveenv);*/ return 0; }