static ssize_t parse_string_list(const char *dirname, struct modem_prop *props, size_t size) { char buff[STRING_LIST_MAX_LEN]; char pathname[1024], *p, *end_p; size_t prop_count; ssize_t readlen; text_path_cat(pathname, sizeof(pathname), dirname, STRING_LIST_NAME); readlen = file_read(pathname, buff, sizeof(buff)); if (readlen < 0) { error_msg("file_read \"%s\" failed", pathname); return readlen; } prop_count = 0; p = buff; end_p = buff + readlen; while (p < end_p && prop_count < size) { int i; char *tmp_text; for (i = 0, tmp_text = props[prop_count].name; i < 2; i++, p++) { do { if (p >= end_p) { return prop_count; } } while (*p++ != '"'); do { if (p >= end_p) { return prop_count; } *tmp_text++ = *p++; } while (*p != '"'); tmp_text = props[prop_count].value; } #ifdef CAVAN_DEBUG println("%s = %s", props[prop_count].name, props[prop_count].value); #endif prop_count++; while (p < end_p && *p++ != '\n'); } return prop_count; }
static int cavan_inotify_event_handle(struct cavan_inotify_descriptor *desc, struct cavan_inotify_watch *watch, struct inotify_event *event) { char buff[1024]; const char *pathname; const char *command = desc->private_data; if (event->len > 0) { pathname = buff; text_path_cat(buff, sizeof(buff), watch->pathname, event->name); } else { pathname = watch->pathname; } if (command && command[0]) { setenv("CAVAN_INOTIFY_PATH", pathname, 1); if (system(command) != 0) { return -EFAULT; } } else { println("%s", pathname); } return 0; }
static ssize_t write_wifi_mac(const char *system_mnt_point, char *mac, size_t size) { int ret; char i600_wifi_mac[1024], i200_wifi_mac[1024]; text_path_cat(i200_wifi_mac, sizeof(i200_wifi_mac), system_mnt_point, I200_WIFI_MAC_FILE); ret = file_writeto(i200_wifi_mac, mac, size, 0, O_TRUNC); if (ret < 0) { print_error("file_writeto"); return ret; } text_path_cat(i600_wifi_mac, sizeof(i600_wifi_mac), system_mnt_point, I600_WIFI_MAC_FILE); return file_hardlink(i600_wifi_mac, i200_wifi_mac); }
static int cftp_client_send_directory(struct cftp_descriptor *desc, const char *dir_in, const char *dir_out) { DIR *dp; struct dirent *entry; int ret; char tmp_file_in[256], tmp_file_out[256]; char *p_in, *p_out; dp = opendir(dir_in); if (dp == NULL) { print_error("fail to open directory %s", dir_in); return -EFAULT; } p_in = text_path_cat(tmp_file_in, sizeof(tmp_file_in), dir_in, NULL); p_out = text_path_cat(tmp_file_out, sizeof(tmp_file_out), dir_out, NULL); while ((entry = readdir(dp))) { if (text_is_dot_name(entry->d_name)) { continue; } text_copy(p_in, entry->d_name); text_copy(p_out, entry->d_name); ret = cftp_client_send_file(desc, tmp_file_in, 0, tmp_file_out, 0, 0); if (ret < 0) { goto out_close_dir; } } ret = 0; out_close_dir: closedir(dp); return ret; }
static int upgrade_modem(const char *resource) { int ret; char update_wizard[1024]; pid_t pid; pthread_t usb_thread; text_path_cat(update_wizard, sizeof(update_wizard), resource, UPDATE_WIZARD_NAME); ret = chmod(update_wizard, 0777); if (ret < 0) { print_error("chmod \"%s\"", update_wizard); return ret; } pid = fork(); if (pid < 0) { print_error("fork"); return pid; } if (pid == 0) { if (file_test("/bin/sh", "x") == 0) { ret = system_command("%s %s | tee %s", update_wizard, resource, SWAN_CONSOLE_DEVICE); exit(ret); } else { ret = execl(update_wizard, update_wizard, resource, NULL); if (ret < 0) { error_msg("execl"); } exit(-1); } } pthread_create(&usb_thread, NULL, set_usb_power_handle, NULL); waitpid(pid, &ret, 0); if (!WIFEXITED(ret) || WEXITSTATUS(ret) != 0) { error_msg("upgrade modem failed"); return -1; } return 0; }
pid_t process_find_by_cmdline(const char *proc_path, const char *cmdline) { DIR *dir_proc; pid_t pid; struct dirent *en; char pathname[64], *p_name; if (proc_path == NULL) { proc_path = "/proc"; } dir_proc = opendir(proc_path); if (dir_proc == NULL) { print_error("Open directroy %s failed", proc_path); return -EFAULT; } pid = -1; p_name = text_path_cat(pathname, sizeof(pathname), proc_path, NULL); while ((en = readdir(dir_proc))) { char buff[1024]; ssize_t readlen; if (text_is_number(en->d_name) == 0) { continue; } sprintf(p_name, "%s/cmdline", en->d_name); readlen = file_read(pathname, buff, sizeof(buff)); if (readlen < 0) { continue; } buff[readlen] = 0; if (text_lhcmp(cmdline, buff) == 0) { pid = text2value_unsigned(en->d_name, NULL, 10); break; } } closedir(dir_proc); return pid; }
static char *ftp_get_abs_path(const char *curr_path, const char *path, char *abs_path, size_t size) { if (*path == '/') { text_ncopy(abs_path, path, size); } else { text_path_cat(abs_path, size, curr_path, path); } #if FTP_DEBUG println("curr_path = %s, abs_path = %s, path = %s", curr_path, abs_path, path); #endif return abs_path; }
static char *get_bt_mac_file(const char *system_mnt_point, char *pathname, size_t size) { unsigned int i; const char *bt_mac_files[] = {I600_BT_MAC_FILE, I200_BT_MAC_FILE}; char *name_p; name_p = text_path_cat(pathname, size, system_mnt_point, NULL); for (i = 0; i < ARRAY_SIZE(bt_mac_files); i++) { text_copy(name_p, bt_mac_files[i]); if (access(pathname, W_OK) == 0) { return pathname; } } return NULL; }
int unpack(const char *pkg_name, const char *dir_name) { int ret; int pkg_fd; int img_fd; struct swan_file_info file_info; struct swan_package_info pkg_info; struct swan_image_info img_info; char tmp_path[1024]; pr_std_info("unpack upgrade file \"%s\" -> \"%s\"", pkg_name, dir_name); ret = swan_check_md5sum(pkg_name); if (ret < 0) { pr_err_info("swan_check_md5sum"); return ret; } pkg_fd = open(pkg_name, O_RDONLY | O_BINARY); if (pkg_fd < 0) { pr_err_info("open file \"%s\"", pkg_name); return -1; } ret = cavan_mkdir(dir_name); if (ret < 0) { pr_err_info("cavan_mkdir"); goto out_close_pkg; } text_path_cat(tmp_path, sizeof(tmp_path), dir_name, HEADER_BIN_NAME); ret = read_upgrade_program(pkg_fd, &file_info, tmp_path); if (ret < 0) { pr_err_info("get_upgrade_program"); goto out_close_pkg; } ret = read_resource_image(pkg_fd, &pkg_info, dir_name, 0, 0); if (ret < 0) { pr_err_info("get_resource_image"); goto out_close_pkg; } while (pkg_info.image_count) { ret = read_image_info(pkg_fd, &img_info); if (ret < 0) { pr_err_info("read_image_info"); goto out_close_pkg; } text_path_cat(tmp_path, sizeof(tmp_path), dir_name, img_info.filename); img_fd = open(tmp_path, O_WRONLY | O_CREAT | O_SYNC | O_TRUNC | O_BINARY, 0777); if (img_fd < 0) { pr_err_info("open"); goto out_close_pkg; } ret = read_simple_image(pkg_fd, img_fd, img_info.length, 0); if (ret < 0) { pr_err_info("get_image"); goto out_close_img; } close(img_fd); pkg_info.image_count--; } println_green("Decompression upgrade package \"%s\" to \"%s\" is ok", pkg_name, dir_name); ret = 0; goto out_close_pkg; out_close_img: close(img_fd); out_close_pkg: close(pkg_fd); if (ret < 0) { rmdir(dir_name); } return ret; }
int package(const char *pkg_name, const char *dir_name) { int ret; int pkg_fd; struct swan_package_info pkg_info; struct swan_file_info file_info; char tmp_path[1024], *name_p; int shrink_image_table[] = { SWAN_IMAGE_SYSTEM, SWAN_IMAGE_RECOVERY, SWAN_IMAGE_USERDATA, SWAN_IMAGE_VENDOR, }; struct swan_image_info *p, *p_end; name_p = text_path_cat(tmp_path, sizeof(tmp_path), dir_name, NULL); if (swan_machine_type == SWAN_BOARD_UNKNOWN) { text_copy(name_p, "system.img"); swan_machine_type = get_swan_board_type_by_system_img(tmp_path); } if (swan_machine_type == SWAN_BOARD_UNKNOWN) { pr_err_info("Machine type no set"); } else { struct swan_image_info *img_info; img_info = get_swan_image_info_by_type(SWAN_IMAGE_LOGO); if (img_info) { text_copy(img_info->filename, get_logo_name_by_board_type(swan_machine_type)); } img_info = get_swan_image_info_by_type(SWAN_IMAGE_BUSYBOX); if (img_info) { text_copy(img_info->filename, get_busybox_name_by_board_type(swan_machine_type)); } } pkg_fd = open(pkg_name, O_RDWR | O_CREAT | O_SYNC | O_TRUNC | O_BINARY, 0777); if (pkg_fd < 0) { pr_err_info("open file \"%s\"", pkg_name); return -1; } text_copy(name_p, HEADER_BIN_NAME); ret = write_upgrade_program(pkg_fd, &file_info, tmp_path); if (ret < 0) { pr_err_info("write_upgrade_program"); goto out_close_pkg; } ret = lseek(pkg_fd, sizeof(pkg_info), SEEK_CUR); if (ret < 0) { pr_err_info("lseek"); goto out_close_pkg; } ret = write_resource_image(pkg_fd, &pkg_info, dir_name, get_resource_name_by_board_type(swan_machine_type), RESOURCE_IMAGE_NAME, I600_RESOURCE_NAME, I200_RESOURCE_NAME, MODEM_RESOURCE_NAME, NULL); if (ret < 0) { pr_err_info("write_resource_image"); goto out_close_pkg; } pkg_info.image_count = 0; for (p = swan_images, p_end = p + ARRAY_SIZE(swan_images); p < p_end; p++) { text_copy(name_p, p->filename); if (array_has_element(p->type, (int *) swan_exclude_images, swan_exclude_image_count) || file_test(tmp_path, "r") < 0) { println_cyan("exclude image \"%s\"", tmp_path); continue; } if (swan_need_shrink && array_has_element(p->type, shrink_image_table, ARRAY_SIZE(shrink_image_table))) { ret = swan_shrink_image(dir_name, p); if (ret < 0) { pr_err_info("image_shrink"); goto out_close_pkg; } } ret = write_simple_image(pkg_fd, dir_name, p, &swan_emmc_part_table); if (ret < 0) { pr_err_info("write_image"); goto out_close_pkg; } pkg_info.image_count++; } pkg_info.crc32 = 0; ret = ffile_crc32_seek(pkg_fd, sizeof(file_info) + file_info.header_size + sizeof(pkg_info), 0, &pkg_info.crc32); if (ret < 0) { pr_err_info("ffile_crc32"); goto out_close_pkg; } strncpy(pkg_info.volume, swan_vfat_volume, sizeof(pkg_info.volume)); pkg_info.mkfs_mask = swan_mkfs_mask; pkg_info.board_type = swan_machine_type; pkg_info.upgrade_flags = swan_upgrade_flags; pkg_info.part_table = swan_emmc_part_table; show_package_info(&pkg_info); ret = lseek(pkg_fd, sizeof(file_info) + file_info.header_size, SEEK_SET); if (ret < 0) { pr_err_info("lseek"); goto out_close_pkg; } ret = write_package_info(pkg_fd, &pkg_info); if (ret < 0) { pr_err_info("write_package_info"); goto out_close_pkg; } ret = swan_set_md5sum(pkg_name); if (ret < 0) { pr_err_info("swan_set_md5sum"); } out_close_pkg: close(pkg_fd); if (ret < 0) { remove(pkg_name); return ret; } return 0; }
static int ftp_list_directory1(const char *dirpath, const char *newline) { int fd; DIR *dp; int ret; struct dirent *ep; char *filename; char pathname[1024]; char buff[1024]; char *buff_end = buff + sizeof(buff); #if FTP_DEBUG pr_bold_info("dirpath = `%s'", dirpath); #endif dp = opendir(dirpath); if (dp == NULL) { pr_red_info("opendir failed"); return -EFAULT; } fd = cavan_temp_file_open(pathname, sizeof(pathname), "cavan-ftp-XXXXXX"); if (fd < 0) { pr_red_info("cavan_temp_file_open"); ret = fd; goto out_closedir; } filename = text_path_cat(pathname, sizeof(pathname), dirpath, NULL); while ((ep = readdir(dp))) { char *p; text_copy(filename, ep->d_name); p = ftp_file_stat_tostring(pathname, buff, buff_end); if (p == NULL) { continue; } p += snprintf(p, buff_end - p, " %s%s", ep->d_name, newline); ret = ffile_write(fd, buff, p - buff); if (ret < 0) { pr_red_info("ffile_write"); goto out_close_fd; } } if (lseek(fd, 0, SEEK_SET) != 0) { pr_error_info("lseek"); ret = -EFAULT; goto out_close_fd; } closedir(dp); return fd; out_close_fd: close(fd); out_closedir: closedir(dp); return ret; }
int main(int argc, char *argv[]) { int fd; int ret; char *content = NULL; struct cavan_vfat_fs fs; struct cavan_block_device bdev = { .block_shift = 0, .block_size = VFAT_APP_DEVICE_BLOCK_SIZE, .block_mask = 0, .read_block = vfat_app_device_read_block, .write_block = vfat_app_device_write_block, .read_byte = vfat_app_device_read_byte, .write_byte = vfat_app_device_write_byte }; assert(argc > 1); fd = open(argv[1], O_RDONLY); if (fd < 0) { pr_error_info("open"); return fd; } ret = cavan_block_device_init(&bdev, &fd); if (ret < 0) { pr_red_info("cavan_block_device_init"); goto out_close_fd; } ret = cavan_vfat_init(&fs, &bdev); if (ret < 0) { pr_red_info("cavan_vfat_init"); goto out_cavan_block_device_deinit; } if (argc > 2) { struct cavan_vfat_file *fp; fp = cavan_vfat_open_file(&fs, argv[2]); if (fp == NULL) { ret = -EFAULT; pr_red_info("cavan_vfat_open_file"); goto out_cavan_vfat_deinit; } if (VFAT_IS_DIRECTORY(&fp->entry)) { ret = cavan_vfat_list_dir(fp, vfat_app_device_list_dir_handler, fp); if (ret < 0) { pr_red_info("cavan_vfat_list_dir"); goto out_cavan_vfat_deinit; } } else { ssize_t rdlen; if (argc > 3) { char path_buff[1024]; const char *pathname; if (file_type_test(argv[3], S_IFDIR)) { text_basename_base(text_path_cat(path_buff, sizeof(path_buff), argv[3], NULL), argv[2]); pathname = path_buff; } else { pathname = argv[3]; } println("%s@%s => %s", argv[1], argv[2], pathname); rdlen = cavan_vfat_read_file3(fp, 0, pathname, O_TRUNC); if (rdlen < 0) { pr_red_info("cavan_vfat_read_file3"); goto out_cavan_vfat_deinit; } } else { content = malloc(fp->entry.file_size); if (content == NULL) { pr_error_info("malloc"); goto out_cavan_vfat_deinit; } rdlen = cavan_vfat_read_file(fp, 0, content, fp->entry.file_size); if (rdlen < 0) { pr_red_info("cavan_vfat_read_file"); goto out_free_content; } print_ntext(content, rdlen); print_char('\n'); } } cavan_vfat_close_file(fp); } else { char buff[32]; ssize_t rdlen; println("type = %s", cavan_vfat_type_to_string(fs.type)); rdlen = cavan_vfat_read_volume_label(&fs, buff, sizeof(buff) - 1); if (rdlen < 0) { pr_red_info("cavan_vfat_read_volume_label"); goto out_cavan_vfat_deinit; } buff[rdlen] = 0; println("volume label = %s", buff); } out_free_content: if (content) { free(content); } out_cavan_vfat_deinit: cavan_vfat_deinit(&fs); out_cavan_block_device_deinit: cavan_block_device_deinit(&bdev); out_close_fd: close(fd); return ret; }