cp_key_os_version_t
cp_os_version(void)
{
static cp_key_os_version_t cp_os_version;
if (cp_os_version)
return cp_os_version;
if (!osversion[0])
return 0;
cp_os_version = parse_os_version(osversion);
if (!cp_os_version) {
printf("cp_os_version: unable to parse osversion `%s'\n", osversion);
cp_os_version = 1;
}
return cp_os_version;
}
int main(int argc, char **argv)
{
boot_img_hdr_v2 hdr;
char *kernel_fn = NULL;
void *kernel_data = NULL;
char *ramdisk_fn = NULL;
void *ramdisk_data = NULL;
char *second_fn = NULL;
void *second_data = NULL;
char *dtb_fn = NULL;
void *dtb_data = NULL;
char *recovery_dtbo_fn = NULL;
void *recovery_dtbo_data = NULL;
char *cmdline = "";
char *bootimg = NULL;
char *board = "";
int os_version = 0;
int os_patch_level = 0;
int header_version = 0;
char *dt_fn = NULL;
void *dt_data = NULL;
uint32_t pagesize = 2048;
int fd;
uint32_t base = 0x10000000U;
uint32_t kernel_offset = 0x00008000U;
uint32_t ramdisk_offset = 0x01000000U;
uint32_t second_offset = 0x00f00000U;
uint32_t tags_offset = 0x00000100U;
uint32_t kernel_sz = 0;
uint32_t ramdisk_sz = 0;
uint32_t second_sz = 0;
uint32_t dt_sz = 0;
uint32_t rec_dtbo_sz = 0;
uint64_t rec_dtbo_offset= 0;
uint32_t header_sz = 0;
uint32_t dtb_sz = 0;
uint64_t dtb_offset = 0x01f00000U;
size_t cmdlen;
enum hash_alg hash_alg = HASH_SHA1;
argc--;
argv++;
memset(&hdr, 0, sizeof(hdr));
bool get_id = false;
while(argc > 0){
char *arg = argv[0];
if(!strcmp(arg, "--id")) {
get_id = true;
argc -= 1;
argv += 1;
} else if(argc >= 2) {
char *val = argv[1];
argc -= 2;
argv += 2;
if(!strcmp(arg, "--output") || !strcmp(arg, "-o")) {
bootimg = val;
} else if(!strcmp(arg, "--kernel")) {
kernel_fn = val;
} else if(!strcmp(arg, "--ramdisk")) {
ramdisk_fn = val;
} else if(!strcmp(arg, "--second")) {
second_fn = val;
} else if(!strcmp(arg, "--dtb")) {
dtb_fn = val;
} else if(!strcmp(arg, "--recovery_dtbo") || !strcmp(arg, "--recovery_acpio")) {
recovery_dtbo_fn = val;
} else if(!strcmp(arg, "--cmdline")) {
cmdline = val;
} else if(!strcmp(arg, "--base")) {
base = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--kernel_offset")) {
kernel_offset = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--ramdisk_offset")) {
ramdisk_offset = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--second_offset")) {
second_offset = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--tags_offset")) {
tags_offset = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--dtb_offset")) {
dtb_offset = strtoul(val, 0, 16);
} else if(!strcmp(arg, "--board")) {
board = val;
} else if(!strcmp(arg,"--pagesize")) {
pagesize = strtoul(val, 0, 10);
if((pagesize != 2048) && (pagesize != 4096)
&& (pagesize != 8192) && (pagesize != 16384)
&& (pagesize != 32768) && (pagesize != 65536)
&& (pagesize != 131072)) {
fprintf(stderr,"error: unsupported page size %d\n", pagesize);
return -1;
}
} else if(!strcmp(arg, "--dt")) {
dt_fn = val;
} else if(!strcmp(arg, "--os_version")) {
os_version = parse_os_version(val);
} else if(!strcmp(arg, "--os_patch_level")) {
os_patch_level = parse_os_patch_level(val);
} else if(!strcmp(arg, "--header_version")) {
header_version = strtoul(val, 0, 10);
} else if(!strcmp(arg, "--hash")) {
hash_alg = parse_hash_alg(val);
if(hash_alg == HASH_UNKNOWN) {
fprintf(stderr, "error: unknown hash algorithm '%s'\n", val);
return -1;
}
} else {
return usage();
}
} else {
return usage();
}
}
hdr.page_size = pagesize;
hdr.kernel_addr = base + kernel_offset;
hdr.ramdisk_addr = base + ramdisk_offset;
hdr.second_addr = base + second_offset;
hdr.tags_addr = base + tags_offset;
hdr.header_version = header_version;
hdr.os_version = (os_version << 11) | os_patch_level;
if(bootimg == 0) {
fprintf(stderr,"error: no output filename specified\n");
return usage();
}
if(kernel_fn == 0) {
fprintf(stderr,"error: no kernel image specified\n");
return usage();
}
if(strlen(board) >= BOOT_NAME_SIZE) {
fprintf(stderr,"error: board name too large\n");
return usage();
}
strcpy((char *) hdr.name, board);
memcpy(hdr.magic, BOOT_MAGIC, BOOT_MAGIC_SIZE);
cmdlen = strlen(cmdline);
if(cmdlen <= BOOT_ARGS_SIZE) {
strcpy((char *)hdr.cmdline, cmdline);
} else if(cmdlen <= BOOT_ARGS_SIZE + BOOT_EXTRA_ARGS_SIZE) {
/* exceeds the limits of the base command-line size, go for the extra */
memcpy(hdr.cmdline, cmdline, BOOT_ARGS_SIZE);
strcpy((char *)hdr.extra_cmdline, cmdline+BOOT_ARGS_SIZE);
} else {
fprintf(stderr,"error: kernel commandline too large\n");
return 1;
}
kernel_data = load_file(kernel_fn, &kernel_sz);
if(kernel_data == 0) {
fprintf(stderr,"error: could not load kernel '%s'\n", kernel_fn);
return 1;
}
hdr.kernel_size = kernel_sz;
if(ramdisk_fn == NULL) {
ramdisk_data = 0;
} else {
ramdisk_data = load_file(ramdisk_fn, &ramdisk_sz);
if(ramdisk_data == 0) {
fprintf(stderr,"error: could not load ramdisk '%s'\n", ramdisk_fn);
return 1;
}
}
hdr.ramdisk_size = ramdisk_sz;
if(second_fn) {
second_data = load_file(second_fn, &second_sz);
if(second_data == 0) {
fprintf(stderr,"error: could not load secondstage '%s'\n", second_fn);
return 1;
}
}
hdr.second_size = second_sz;
if(header_version == 0) {
if(dt_fn) {
dt_data = load_file(dt_fn, &dt_sz);
if(dt_data == 0) {
fprintf(stderr,"error: could not load device tree image '%s'\n", dt_fn);
return 1;
}
}
hdr.dt_size = dt_sz; /* overrides hdr.header_version */
} else {
if(recovery_dtbo_fn) {
recovery_dtbo_data = load_file(recovery_dtbo_fn, &rec_dtbo_sz);
if(recovery_dtbo_data == 0) {
fprintf(stderr,"error: could not load recovery dtbo image '%s'\n", recovery_dtbo_fn);
return 1;
}
/* header occupies a page */
rec_dtbo_offset = pagesize * (1 + \
(kernel_sz + pagesize - 1) / pagesize + \
(ramdisk_sz + pagesize - 1) / pagesize + \
(second_sz + pagesize - 1) / pagesize);
}
if(header_version == 1) {
header_sz = 1648;
} else {
header_sz = sizeof(hdr);
}
if(header_version > 1) {
if(dtb_fn) {
dtb_data = load_file(dtb_fn, &dtb_sz);
if(dtb_data == 0) {
fprintf(stderr,"error: could not load recovery dtb image '%s'\n", dtb_fn);
return 1;
}
}
}
}
hdr.recovery_dtbo_size = rec_dtbo_sz;
hdr.recovery_dtbo_offset = rec_dtbo_offset;
hdr.header_size = header_sz;
hdr.dtb_size = dtb_sz;
if(header_version > 1) {
hdr.dtb_addr = base + dtb_offset;
} else {
hdr.dtb_addr = 0;
}
/* put a hash of the contents in the header so boot images can be
* differentiated based on their first 2k.
*/
generate_id(hash_alg, &hdr, kernel_data, ramdisk_data, second_data, dt_data, recovery_dtbo_data, dtb_data);
fd = open(bootimg, O_CREAT | O_TRUNC | O_WRONLY, 0644);
if(fd < 0) {
fprintf(stderr,"error: could not create '%s'\n", bootimg);
return 1;
}
if(write(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) goto fail;
if(write_padding(fd, pagesize, sizeof(hdr))) goto fail;
if(write(fd, kernel_data, hdr.kernel_size) != (ssize_t) hdr.kernel_size) goto fail;
if(write_padding(fd, pagesize, hdr.kernel_size)) goto fail;
if(write(fd, ramdisk_data, hdr.ramdisk_size) != (ssize_t) hdr.ramdisk_size) goto fail;
if(write_padding(fd, pagesize, hdr.ramdisk_size)) goto fail;
if(second_data) {
if(write(fd, second_data, hdr.second_size) != (ssize_t) hdr.second_size) goto fail;
if(write_padding(fd, pagesize, hdr.second_size)) goto fail;
}
if(dt_data) {
if(write(fd, dt_data, hdr.dt_size) != (ssize_t) hdr.dt_size) goto fail;
if(write_padding(fd, pagesize, hdr.dt_size)) goto fail;
} else {
if(recovery_dtbo_data) {
if(write(fd, recovery_dtbo_data, hdr.recovery_dtbo_size) != (ssize_t) hdr.recovery_dtbo_size) goto fail;
if(write_padding(fd, pagesize, hdr.recovery_dtbo_size)) goto fail;
}
if(dtb_data) {
if(write(fd, dtb_data, hdr.dtb_size) != (ssize_t) hdr.dtb_size) goto fail;
if(write_padding(fd, pagesize, hdr.dtb_size)) goto fail;
}
}
if(get_id) {
print_id((uint8_t *) hdr.id, sizeof(hdr.id));
}
return 0;
fail:
unlink(bootimg);
close(fd);
fprintf(stderr,"error: failed writing '%s': %s\n", bootimg,
strerror(errno));
return 1;
}
