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;
}
