char *funrle_data_to(const u8 *data, ssize_t size, int fd_out)
{
int ret;
const u8 *data_end;
u8 tmp;
char buff[MAX_BUFFER_LEN];
char *p, *end_p;
struct progress_bar prg_bar;
progress_bar_init(&prg_bar, size);
p = buff;
end_p = buff + sizeof(buff);
for (data_end = data + size; data < data_end; data += 2)
{
tmp = *data;
println("tmp = %d", tmp);
while (p + tmp >= end_p)
{
memset(p, data[1], end_p - p);
ret = ffile_writeto(fd_out, buff, MAX_BUFFER_LEN, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
tmp -= end_p - p;
p = buff;
}
memset(p, data[1], tmp);
p += tmp;
progress_bar_add(&prg_bar, 2);
}
progress_bar_finish(&prg_bar);
if (p > buff)
{
ret = ffile_writeto(fd_out, buff, p - buff, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
}
return (char *) data;
}
char *frle_data_to(const u8 *data, ssize_t size, int fd_out)
{
int ret;
const u8 *data_end = data + size;
u8 tmp;
u8 buff[MAX_BUFFER_LEN];
const u8 *p;
u8 *q, *end_q;
struct progress_bar prg_bar;
q = buff;
end_q = buff + sizeof(buff) - 1;
progress_bar_init(&prg_bar, size);
while (data < data_end)
{
for (p = data, tmp = *p; tmp == *p && p < data_end; p++);
if (q >= end_q)
{
ret = ffile_writeto(fd_out, buff, q - buff, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
q = buff;
}
*q++ = p - data;
*q++ = tmp;
progress_bar_add(&prg_bar, p - data);
data = p;
}
progress_bar_finish(&prg_bar);
if (q > buff)
{
ret = ffile_writeto(fd_out, buff, q - buff, 0);
if (ret < 0)
{
error_msg("write file failed");
return NULL;
}
}
return (char *) data;
}
int bootimg_pack(struct bootimg_pack_option *option)
{
int fd;
int ret;
int image_count;
struct bootimg_header hdr;
struct bootimg_image images[4];
struct bootimg_image *p, *p_end;
struct cavan_sha_context context;
if (option->kernel == NULL || option->ramdisk == NULL)
{
pr_red_info("no kernel or ramdisk image specified");
return -EINVAL;
}
fd = open(option->output, O_WRONLY | O_CREAT | O_TRUNC, 0777);
if (fd < 0)
{
pr_error_info("open file `%s' failed", option->output);
return fd;
}
ret = lseek(fd, sizeof(hdr), SEEK_SET);
if (ret < 0)
{
pr_red_info("cavan_file_seek_page_align");
goto out_close_fd;
}
cavan_sha1_context_init(&context);
ret = cavan_sha_init(&context);
if (ret < 0)
{
pr_red_info("cavan_sha_init");
goto out_close_fd;
}
memset(&hdr, 0, sizeof(hdr));
memcpy(hdr.magic, BOOT_MAGIC, sizeof(hdr.magic));
if (option->config)
{
ret = bootimg_parse_config_file(&hdr, option->config);
if (ret < 0)
{
pr_red_info("bootimg_parse_config_file");
goto out_close_fd;
}
}
else
{
memcpy(hdr.unused, option->unused, sizeof(hdr.unused));
hdr.page_size = option->page_size;
hdr.kernel_addr = option->kernel_addr ?: option->base + option->kernel_offset;
hdr.ramdisk_addr = option->ramdisk_addr ?: option->base + option->ramdisk_offset;
hdr.second_addr = option->second_addr ?: option->base + option->second_offset;
hdr.tags_addr = option->tags_addr ?: option->base + option->tags_offset;
if (option->name)
{
strncpy((char *) hdr.name, option->name, sizeof(hdr.name));
}
if (option->cmdline)
{
bootimg_copy_cmdline(&hdr, option->cmdline);
}
}
images[0].name = option->kernel;
images[0].size_addr = &hdr.kernel_size;
images[1].name = option->ramdisk;
images[1].size_addr = &hdr.ramdisk_size;
images[2].name = option->second;
images[2].size_addr = &hdr.second_size;
image_count = 3;
if (option->dt)
{
images[image_count].name = option->dt;
images[image_count++].size_addr = &hdr.dt_size;
}
for (p = images, p_end = p + image_count; p < p_end; p++)
{
if (p->name)
{
println("write image %s", p->name);
ret = bootimg_write_image(fd, p->name, p->size_addr, hdr.page_size, &context);
if (ret < 0)
{
pr_red_info("bootimg_write_image");
goto out_close_fd;
}
}
else
{
*p->size_addr = 0;
}
cavan_sha_update(&context, p->size_addr, sizeof(unsigned));
}
if (option->remain)
{
println("write remain image %s", option->remain);
ret = file_copy3(option->remain, fd);
if (ret < 0)
{
pr_red_info("file_copy3");
goto out_close_fd;
}
}
if (option->check_all)
{
cavan_sha_update(&context, &hdr.tags_addr, sizeof(hdr.tags_addr));
cavan_sha_update(&context, &hdr.page_size, sizeof(hdr.page_size));
cavan_sha_update(&context, hdr.unused, sizeof(hdr.unused));
cavan_sha_update(&context, hdr.name, sizeof(hdr.name));
cavan_sha_update(&context, hdr.cmdline, sizeof(hdr.cmdline));
if (hdr.extra_cmdline[0])
{
cavan_sha_update(&context, hdr.extra_cmdline, sizeof(hdr.extra_cmdline));
}
}
cavan_sha_finish(&context, (u8 *) hdr.id);
bootimg_header_dump(&hdr);
ret = ffile_writeto(fd, &hdr, sizeof(hdr), 0);
if (ret < 0)
{
pr_red_info("ffile_writeto");
goto out_close_fd;
}
pr_green_info("pack %s successfull", option->output);
out_close_fd:
close(fd);
return ret;
}
static ssize_t ext2_write_block(struct ext2_desc *desc, u64 index, const void *blocks, size_t count)
{
off_t offset = block_index_to_offset(desc, index);
return ffile_writeto(desc->fd, blocks, desc->block_size * count, offset);
}
static ssize_t vfat_app_device_write_byte(struct cavan_block_device *bdev, u64 index, u32 offset, const void *buff, size_t size)
{
return ffile_writeto(*(int *) bdev->context, buff, size, (index << bdev->block_shift) + offset);
}
static ssize_t vfat_app_device_write_block(struct cavan_block_device *bdev, u64 index, const void *buff, size_t count)
{
return ffile_writeto(*(int *) bdev->context, buff, count << bdev->block_shift, index << bdev->block_shift);
}
