Replace fip_create with fiptool
fiptool provides a more consistent and intuitive interface compared to
the fip_create program. It serves as a better base to build on more
features in the future.
fiptool supports various subcommands. Below are the currently
supported subcommands:
1) info - List the images contained in a FIP file.
2) create - Create a new FIP file with the given images.
3) update - Update an existing FIP with the given images.
4) unpack - Extract a selected set or all the images from a FIP file.
5) remove - Remove images from a FIP file. This is a new command that
was not present in fip_create.
To create a new FIP file, replace "fip_create" with "fiptool create".
To update a FIP file, replace "fip_create" with "fiptool update".
To dump the contents of a FIP file, replace "fip_create --dump" with
"fiptool info".
A compatibility script that emulates the basic functionality of
fip_create is provided. Existing scripts might or might not work with
the compatibility script. Users are strongly encouraged to migrate to
fiptool.
Fixes ARM-Software/tf-issues#87
Fixes ARM-Software/tf-issues#108
Fixes ARM-Software/tf-issues#361
Change-Id: I7ee4da7ac60179cc83cf46af890fd8bc61a53330
diff --git a/tools/fiptool/fiptool.c b/tools/fiptool/fiptool.c
new file mode 100644
index 0000000..4a3e61a
--- /dev/null
+++ b/tools/fiptool/fiptool.c
@@ -0,0 +1,977 @@
+/*
+ * Copyright (c) 2016, ARM Limited and Contributors. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ *
+ * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * Neither the name of ARM nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific
+ * prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <assert.h>
+#include <errno.h>
+#include <getopt.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "fiptool.h"
+#include "firmware_image_package.h"
+#include "tbbr_config.h"
+
+#define OPT_TOC_ENTRY 0
+#define OPT_PLAT_TOC_FLAGS 1
+
+static int info_cmd(int argc, char *argv[]);
+static void info_usage(void);
+static int create_cmd(int argc, char *argv[]);
+static void create_usage(void);
+static int update_cmd(int argc, char *argv[]);
+static void update_usage(void);
+static int unpack_cmd(int argc, char *argv[]);
+static void unpack_usage(void);
+static int remove_cmd(int argc, char *argv[]);
+static void remove_usage(void);
+static int version_cmd(int argc, char *argv[]);
+static void version_usage(void);
+static int help_cmd(int argc, char *argv[]);
+static void usage(void);
+
+/* Available subcommands. */
+static cmd_t cmds[] = {
+ { .name = "info", .handler = info_cmd, .usage = info_usage },
+ { .name = "create", .handler = create_cmd, .usage = create_usage },
+ { .name = "update", .handler = update_cmd, .usage = update_usage },
+ { .name = "unpack", .handler = unpack_cmd, .usage = unpack_usage },
+ { .name = "remove", .handler = remove_cmd, .usage = remove_usage },
+ { .name = "version", .handler = version_cmd, .usage = version_usage },
+ { .name = "help", .handler = help_cmd, .usage = NULL },
+};
+
+static image_t *images[MAX_IMAGES];
+static size_t nr_images;
+static uuid_t uuid_null = { 0 };
+static int verbose;
+
+static void vlog(int prio, char *msg, va_list ap)
+{
+ char *prefix[] = { "DEBUG", "WARN", "ERROR" };
+
+ fprintf(stderr, "%s: ", prefix[prio]);
+ vfprintf(stderr, msg, ap);
+ fputc('\n', stderr);
+}
+
+static void log_dbgx(char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ vlog(LOG_DBG, msg, ap);
+ va_end(ap);
+}
+
+static void log_warnx(char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ vlog(LOG_WARN, msg, ap);
+ va_end(ap);
+}
+
+static void log_err(char *msg, ...)
+{
+ char buf[512];
+ va_list ap;
+
+ va_start(ap, msg);
+ snprintf(buf, sizeof(buf), "%s: %s", msg, strerror(errno));
+ vlog(LOG_ERR, buf, ap);
+ va_end(ap);
+ exit(1);
+}
+
+static void log_errx(char *msg, ...)
+{
+ va_list ap;
+
+ va_start(ap, msg);
+ vlog(LOG_ERR, msg, ap);
+ va_end(ap);
+ exit(1);
+}
+
+static void add_image(image_t *image)
+{
+ if (nr_images + 1 > MAX_IMAGES)
+ log_errx("Too many images");
+ images[nr_images++] = image;
+}
+
+static void free_image(image_t *image)
+{
+ free(image->buffer);
+ free(image);
+}
+
+static void replace_image(image_t *image_dst, image_t *image_src)
+{
+ int i;
+
+ for (i = 0; i < nr_images; i++) {
+ if (images[i] == image_dst) {
+ free_image(images[i]);
+ images[i] = image_src;
+ break;
+ }
+ }
+ assert(i != nr_images);
+}
+
+static void remove_image(image_t *image)
+{
+ int i;
+
+ for (i = 0; i < nr_images; i++) {
+ if (images[i] == image) {
+ free_image(images[i]);
+ images[i] = NULL;
+ break;
+ }
+ }
+ assert(i != nr_images);
+
+ /* Compact array. */
+ memmove(&images[i], &images[i + 1],
+ (nr_images - i - 1) * sizeof(*images));
+ nr_images--;
+}
+
+static void free_images(void)
+{
+ int i;
+
+ for (i = 0; i < nr_images; i++) {
+ free_image(images[i]);
+ images[i] = NULL;
+ }
+}
+
+static toc_entry_t *get_entry_lookup_from_uuid(const uuid_t *uuid)
+{
+ toc_entry_t *toc_entry = toc_entries;
+
+ for (; toc_entry->cmdline_name != NULL; toc_entry++)
+ if (memcmp(&toc_entry->uuid, uuid, sizeof(uuid_t)) == 0)
+ return toc_entry;
+ return NULL;
+}
+
+static int parse_fip(char *filename, fip_toc_header_t *toc_header_out)
+{
+ struct stat st;
+ FILE *fp;
+ char *buf, *bufend;
+ fip_toc_header_t *toc_header;
+ fip_toc_entry_t *toc_entry;
+ image_t *image;
+ int terminated = 0;
+
+ fp = fopen(filename, "r");
+ if (fp == NULL)
+ log_err("fopen %s", filename);
+
+ if (fstat(fileno(fp), &st) == -1)
+ log_err("fstat %s", filename);
+
+ buf = malloc(st.st_size);
+ if (buf == NULL)
+ log_err("malloc");
+
+ if (fread(buf, 1, st.st_size, fp) != st.st_size)
+ log_errx("Failed to read %s", filename);
+ bufend = buf + st.st_size;
+ fclose(fp);
+
+ if (st.st_size < sizeof(fip_toc_header_t))
+ log_errx("FIP %s is truncated", filename);
+
+ toc_header = (fip_toc_header_t *)buf;
+ toc_entry = (fip_toc_entry_t *)(toc_header + 1);
+
+ if (toc_header->name != TOC_HEADER_NAME)
+ log_errx("%s is not a FIP file", filename);
+
+ /* Return the ToC header if the caller wants it. */
+ if (toc_header_out != NULL)
+ *toc_header_out = *toc_header;
+
+ /* Walk through each ToC entry in the file. */
+ while ((char *)toc_entry + sizeof(*toc_entry) - 1 < bufend) {
+ /* Found the ToC terminator, we are done. */
+ if (memcmp(&toc_entry->uuid, &uuid_null, sizeof(uuid_t)) == 0) {
+ terminated = 1;
+ break;
+ }
+
+ /*
+ * Build a new image out of the ToC entry and add it to the
+ * table of images.
+ */
+ image = malloc(sizeof(*image));
+ if (image == NULL)
+ log_err("malloc");
+
+ memcpy(&image->uuid, &toc_entry->uuid, sizeof(uuid_t));
+
+ image->buffer = malloc(toc_entry->size);
+ if (image->buffer == NULL)
+ log_err("malloc");
+
+ /* Overflow checks before memory copy. */
+ if (toc_entry->size > (uint64_t)-1 - toc_entry->offset_address)
+ log_errx("FIP %s is corrupted", filename);
+ if (toc_entry->size + toc_entry->offset_address > st.st_size)
+ log_errx("FIP %s is corrupted", filename);
+
+ memcpy(image->buffer, buf + toc_entry->offset_address,
+ toc_entry->size);
+ image->size = toc_entry->size;
+
+ image->toc_entry = get_entry_lookup_from_uuid(&toc_entry->uuid);
+ if (image->toc_entry == NULL) {
+ add_image(image);
+ toc_entry++;
+ continue;
+ }
+
+ assert(image->toc_entry->image == NULL);
+ /* Link backpointer from lookup entry. */
+ image->toc_entry->image = image;
+ add_image(image);
+
+ toc_entry++;
+ }
+
+ if (terminated == 0)
+ log_errx("FIP %s does not have a ToC terminator entry",
+ filename);
+ free(buf);
+ return 0;
+}
+
+static image_t *read_image_from_file(toc_entry_t *toc_entry, char *filename)
+{
+ struct stat st;
+ image_t *image;
+ FILE *fp;
+
+ fp = fopen(filename, "r");
+ if (fp == NULL)
+ log_err("fopen %s", filename);
+
+ if (fstat(fileno(fp), &st) == -1)
+ log_errx("fstat %s", filename);
+
+ image = malloc(sizeof(*image));
+ if (image == NULL)
+ log_err("malloc");
+
+ memcpy(&image->uuid, &toc_entry->uuid, sizeof(uuid_t));
+
+ image->buffer = malloc(st.st_size);
+ if (image->buffer == NULL)
+ log_err("malloc");
+ if (fread(image->buffer, 1, st.st_size, fp) != st.st_size)
+ log_errx("Failed to read %s", filename);
+ image->size = st.st_size;
+ image->toc_entry = toc_entry;
+
+ fclose(fp);
+ return image;
+}
+
+static int write_image_to_file(image_t *image, char *filename)
+{
+ FILE *fp;
+
+ fp = fopen(filename, "w");
+ if (fp == NULL)
+ log_err("fopen");
+ if (fwrite(image->buffer, 1, image->size, fp) != image->size)
+ log_errx("Failed to write %s", filename);
+ fclose(fp);
+ return 0;
+}
+
+static int fill_common_opts(struct option *opts, int has_arg)
+{
+ int i;
+
+ for (i = 0; toc_entries[i].cmdline_name != NULL; i++) {
+ opts[i].name = toc_entries[i].cmdline_name;
+ opts[i].has_arg = has_arg;
+ opts[i].flag = NULL;
+ opts[i].val = 0;
+ }
+ return i;
+}
+
+static void add_opt(struct option *opts, int idx, char *name,
+ int has_arg, int val)
+{
+ opts[idx].name = name;
+ opts[idx].has_arg = has_arg;
+ opts[idx].flag = NULL;
+ opts[idx].val = val;
+}
+
+static int info_cmd(int argc, char *argv[])
+{
+ image_t *image;
+ uint64_t image_offset;
+ uint64_t image_size = 0;
+ fip_toc_header_t toc_header;
+ int i;
+
+ if (argc != 2)
+ usage();
+ argc--, argv++;
+
+ parse_fip(argv[0], &toc_header);
+
+ if (verbose) {
+ log_dbgx("toc_header[name]: 0x%llX",
+ (unsigned long long)toc_header.name);
+ log_dbgx("toc_header[serial_number]: 0x%llX",
+ (unsigned long long)toc_header.serial_number);
+ log_dbgx("toc_header[flags]: 0x%llX",
+ (unsigned long long)toc_header.flags);
+ }
+
+ image_offset = sizeof(fip_toc_header_t) +
+ (sizeof(fip_toc_entry_t) * (nr_images + 1));
+
+ for (i = 0; i < nr_images; i++) {
+ image = images[i];
+ if (image->toc_entry != NULL)
+ printf("%s: ", image->toc_entry->name);
+ else
+ printf("Unknown entry: ");
+ image_size = image->size;
+ printf("offset=0x%llX, size=0x%llX",
+ (unsigned long long)image_offset,
+ (unsigned long long)image_size);
+ if (image->toc_entry != NULL)
+ printf(", cmdline=\"--%s\"\n",
+ image->toc_entry->cmdline_name);
+ else
+ putchar('\n');
+ image_offset += image_size;
+ }
+
+ free_images();
+ return 0;
+}
+
+static void info_usage(void)
+{
+ printf("fiptool info FIP_FILENAME\n");
+}
+
+static int pack_images(char *filename, uint64_t toc_flags)
+{
+ FILE *fp;
+ image_t *image;
+ fip_toc_header_t *toc_header;
+ fip_toc_entry_t *toc_entry;
+ char *buf;
+ uint64_t entry_offset, buf_size, payload_size;
+ int i;
+
+ /* Calculate total payload size and allocate scratch buffer. */
+ payload_size = 0;
+ for (i = 0; i < nr_images; i++)
+ payload_size += images[i]->size;
+
+ buf_size = sizeof(fip_toc_header_t) +
+ sizeof(fip_toc_entry_t) * (nr_images + 1);
+ buf = calloc(1, buf_size);
+ if (buf == NULL)
+ log_err("calloc");
+
+ /* Build up header and ToC entries from the image table. */
+ toc_header = (fip_toc_header_t *)buf;
+ toc_header->name = TOC_HEADER_NAME;
+ toc_header->serial_number = TOC_HEADER_SERIAL_NUMBER;
+ toc_header->flags = toc_flags;
+
+ toc_entry = (fip_toc_entry_t *)(toc_header + 1);
+
+ entry_offset = buf_size;
+ for (i = 0; i < nr_images; i++) {
+ image = images[i];
+ memcpy(&toc_entry->uuid, &image->uuid, sizeof(uuid_t));
+ toc_entry->offset_address = entry_offset;
+ toc_entry->size = image->size;
+ toc_entry->flags = 0;
+ entry_offset += toc_entry->size;
+ toc_entry++;
+ }
+
+ /* Append a null uuid entry to mark the end of ToC entries. */
+ memcpy(&toc_entry->uuid, &uuid_null, sizeof(uuid_t));
+ toc_entry->offset_address = entry_offset;
+ toc_entry->size = 0;
+ toc_entry->flags = 0;
+
+ /* Generate the FIP file. */
+ fp = fopen(filename, "w");
+ if (fp == NULL)
+ log_err("fopen %s", filename);
+
+ if (verbose)
+ log_dbgx("Metadata size: %zu bytes", buf_size);
+
+ if (fwrite(buf, 1, buf_size, fp) != buf_size)
+ log_errx("Failed to write image to %s", filename);
+ free(buf);
+
+ if (verbose)
+ log_dbgx("Payload size: %zu bytes", payload_size);
+
+ for (i = 0; i < nr_images; i++) {
+ image = images[i];
+ if (fwrite(image->buffer, 1, image->size, fp) != image->size)
+ log_errx("Failed to write image to %s", filename);
+ }
+
+ fclose(fp);
+ return 0;
+}
+
+/*
+ * This function is shared between the create and update subcommands.
+ * The difference between the two subcommands is that when the FIP file
+ * is created, the parsing of an existing FIP is skipped. This results
+ * in update_fip() creating the new FIP file from scratch because the
+ * internal image table is not populated.
+ */
+static void update_fip(void)
+{
+ toc_entry_t *toc_entry;
+ image_t *image;
+
+ /* Add or replace images in the FIP file. */
+ for (toc_entry = toc_entries;
+ toc_entry->cmdline_name != NULL;
+ toc_entry++) {
+ if (toc_entry->action != DO_PACK)
+ continue;
+
+ image = read_image_from_file(toc_entry, toc_entry->action_arg);
+ if (toc_entry->image != NULL) {
+ if (verbose)
+ log_dbgx("Replacing image %s.bin with %s",
+ toc_entry->cmdline_name,
+ toc_entry->action_arg);
+ replace_image(toc_entry->image, image);
+ } else {
+ if (verbose)
+ log_dbgx("Adding image %s",
+ toc_entry->action_arg);
+ add_image(image);
+ }
+ /* Link backpointer from lookup entry. */
+ toc_entry->image = image;
+
+ free(toc_entry->action_arg);
+ toc_entry->action_arg = NULL;
+ }
+}
+
+static void parse_plat_toc_flags(char *arg, unsigned long long *toc_flags)
+{
+ unsigned long long flags;
+ char *endptr;
+
+ errno = 0;
+ flags = strtoull(arg, &endptr, 16);
+ if (*endptr != '\0' || flags > UINT16_MAX || errno != 0)
+ log_errx("Invalid platform ToC flags: %s", arg);
+ /* Platform ToC flags is a 16-bit field occupying bits [32-47]. */
+ *toc_flags |= flags << 32;
+}
+
+static int create_cmd(int argc, char *argv[])
+{
+ struct option opts[toc_entries_len + 1];
+ unsigned long long toc_flags = 0;
+ int i;
+
+ if (argc < 2)
+ usage();
+
+ i = fill_common_opts(opts, required_argument);
+ add_opt(opts, i, "plat-toc-flags", required_argument,
+ OPT_PLAT_TOC_FLAGS);
+ add_opt(opts, ++i, NULL, 0, 0);
+
+ while (1) {
+ int c, opt_index;
+
+ c = getopt_long(argc, argv, "o:", opts, &opt_index);
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case OPT_TOC_ENTRY: {
+ toc_entry_t *toc_entry;
+
+ toc_entry = &toc_entries[opt_index];
+ toc_entry->action = DO_PACK;
+ toc_entry->action_arg = strdup(optarg);
+ if (toc_entry->action_arg == NULL)
+ log_err("strdup");
+ break;
+ }
+ case OPT_PLAT_TOC_FLAGS:
+ parse_plat_toc_flags(optarg, &toc_flags);
+ break;
+ default:
+ usage();
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc == 0)
+ usage();
+
+ update_fip();
+
+ pack_images(argv[0], toc_flags);
+ free_images();
+ return 0;
+}
+
+static void create_usage(void)
+{
+ toc_entry_t *toc_entry = toc_entries;
+
+ printf("fiptfool create [--plat-toc-flags <value>] [opts] FIP_FILENAME\n");
+ printf(" --plat-toc-flags <value>\t16-bit platform specific flag field "
+ "occupying bits 32-47 in 64-bit ToC header.\n");
+ fputc('\n', stderr);
+ printf("Specific images are packed with the following options:\n");
+ for (; toc_entry->cmdline_name != NULL; toc_entry++)
+ printf(" --%-16s FILENAME\t%s\n", toc_entry->cmdline_name,
+ toc_entry->name);
+}
+
+static int update_cmd(int argc, char *argv[])
+{
+ struct option opts[toc_entries_len + 2];
+ char outfile[FILENAME_MAX] = { 0 };
+ fip_toc_header_t toc_header = { 0 };
+ unsigned long long toc_flags = 0;
+ int pflag = 0;
+ int i;
+
+ if (argc < 2)
+ usage();
+
+ i = fill_common_opts(opts, required_argument);
+ add_opt(opts, i, "out", required_argument, 'o');
+ add_opt(opts, ++i, "plat-toc-flags", required_argument,
+ OPT_PLAT_TOC_FLAGS);
+ add_opt(opts, ++i, NULL, 0, 0);
+
+ while (1) {
+ int c, opt_index;
+
+ c = getopt_long(argc, argv, "o:", opts, &opt_index);
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case OPT_TOC_ENTRY: {
+ toc_entry_t *toc_entry;
+
+ toc_entry = &toc_entries[opt_index];
+ toc_entry->action = DO_PACK;
+ toc_entry->action_arg = strdup(optarg);
+ if (toc_entry->action_arg == NULL)
+ log_err("strdup");
+ break;
+ }
+ case OPT_PLAT_TOC_FLAGS: {
+ parse_plat_toc_flags(optarg, &toc_flags);
+ pflag = 1;
+ break;
+ }
+ case 'o':
+ snprintf(outfile, sizeof(outfile), "%s", optarg);
+ break;
+ default:
+ usage();
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc == 0)
+ usage();
+
+ if (outfile[0] == '\0')
+ snprintf(outfile, sizeof(outfile), "%s", argv[0]);
+
+ if (access(outfile, F_OK) == 0)
+ parse_fip(argv[0], &toc_header);
+
+ if (pflag)
+ toc_header.flags &= ~(0xffffULL << 32);
+ toc_flags = (toc_header.flags |= toc_flags);
+
+ update_fip();
+
+ pack_images(outfile, toc_flags);
+ free_images();
+ return 0;
+}
+
+static void update_usage(void)
+{
+ toc_entry_t *toc_entry = toc_entries;
+
+ printf("fiptfool update [--out FIP_FILENAME] "
+ "[--plat-toc-flags <value>] [opts] FIP_FILENAME\n");
+ printf(" --out FIP_FILENAME\t\tSet an alternative output FIP file.\n");
+ printf(" --plat-toc-flags <value>\t16-bit platform specific flag field "
+ "occupying bits 32-47 in 64-bit ToC header.\n");
+ fputc('\n', stderr);
+ printf("Specific images are packed with the following options:\n");
+ for (; toc_entry->cmdline_name != NULL; toc_entry++)
+ printf(" --%-16s FILENAME\t%s\n", toc_entry->cmdline_name,
+ toc_entry->name);
+}
+
+static int unpack_cmd(int argc, char *argv[])
+{
+ struct option opts[toc_entries_len + 3];
+ char file[FILENAME_MAX], outdir[PATH_MAX] = { 0 };
+ toc_entry_t *toc_entry;
+ int fflag = 0;
+ int unpack_all = 1;
+ int i;
+
+ if (argc < 2)
+ usage();
+
+ i = fill_common_opts(opts, required_argument);
+ add_opt(opts, i, "force", no_argument, 'f');
+ add_opt(opts, ++i, "out", required_argument, 'o');
+ add_opt(opts, ++i, NULL, 0, 0);
+
+ while (1) {
+ int c, opt_index;
+
+ c = getopt_long(argc, argv, "fo:", opts, &opt_index);
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case OPT_TOC_ENTRY:
+ unpack_all = 0;
+ toc_entry = &toc_entries[opt_index];
+ toc_entry->action = DO_UNPACK;
+ toc_entry->action_arg = strdup(optarg);
+ if (toc_entry->action_arg == NULL)
+ log_err("strdup");
+ break;
+ case 'f':
+ fflag = 1;
+ break;
+ case 'o':
+ snprintf(outdir, sizeof(outdir), "%s", optarg);
+ break;
+ default:
+ usage();
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc == 0)
+ usage();
+
+ parse_fip(argv[0], NULL);
+
+ if (outdir[0] != '\0')
+ if (chdir(outdir) == -1)
+ log_err("chdir %s", outdir);
+
+ /* Mark all images to be unpacked. */
+ if (unpack_all) {
+ for (toc_entry = toc_entries;
+ toc_entry->cmdline_name != NULL;
+ toc_entry++) {
+ if (toc_entry->image != NULL) {
+ toc_entry->action = DO_UNPACK;
+ toc_entry->action_arg = NULL;
+ }
+ }
+ }
+
+ /* Unpack all specified images. */
+ for (toc_entry = toc_entries;
+ toc_entry->cmdline_name != NULL;
+ toc_entry++) {
+ if (toc_entry->action != DO_UNPACK)
+ continue;
+
+ /* Build filename. */
+ if (toc_entry->action_arg == NULL)
+ snprintf(file, sizeof(file), "%s.bin",
+ toc_entry->cmdline_name);
+ else
+ snprintf(file, sizeof(file), "%s",
+ toc_entry->action_arg);
+
+ if (toc_entry->image == NULL) {
+ log_warnx("Requested image %s is not in %s",
+ file, argv[0]);
+ free(toc_entry->action_arg);
+ toc_entry->action_arg = NULL;
+ continue;
+ }
+
+ if (access(file, F_OK) != 0 || fflag) {
+ if (verbose)
+ log_dbgx("Unpacking %s", file);
+ write_image_to_file(toc_entry->image, file);
+ } else {
+ log_warnx("File %s already exists, use --force to overwrite it",
+ file);
+ }
+
+ free(toc_entry->action_arg);
+ toc_entry->action_arg = NULL;
+ }
+
+ free_images();
+ return 0;
+}
+
+static void unpack_usage(void)
+{
+ toc_entry_t *toc_entry = toc_entries;
+
+ printf("fiptool unpack [--force] [--out <path>] [opts] FIP_FILENAME\n");
+ printf(" --force\tIf the output file already exists, use --force to "
+ "overwrite it.\n");
+ printf(" --out path\tSet the output directory path.\n");
+ fputc('\n', stderr);
+ printf("Specific images are unpacked with the following options:\n");
+ for (; toc_entry->cmdline_name != NULL; toc_entry++)
+ printf(" --%-16s FILENAME\t%s\n", toc_entry->cmdline_name,
+ toc_entry->name);
+ fputc('\n', stderr);
+ printf("If no options are provided, all images will be unpacked.\n");
+}
+
+static int remove_cmd(int argc, char *argv[])
+{
+ struct option opts[toc_entries_len + 2];
+ char outfile[FILENAME_MAX] = { 0 };
+ fip_toc_header_t toc_header;
+ toc_entry_t *toc_entry;
+ int fflag = 0;
+ int i;
+
+ if (argc < 2)
+ usage();
+
+ i = fill_common_opts(opts, no_argument);
+ add_opt(opts, i, "force", no_argument, 'f');
+ add_opt(opts, ++i, "out", required_argument, 'o');
+ add_opt(opts, ++i, NULL, 0, 0);
+
+ while (1) {
+ int c, opt_index;
+
+ c = getopt_long(argc, argv, "fo:", opts, &opt_index);
+ if (c == -1)
+ break;
+
+ switch (c) {
+ case OPT_TOC_ENTRY:
+ toc_entry = &toc_entries[opt_index];
+ toc_entry->action = DO_REMOVE;
+ break;
+ case 'f':
+ fflag = 1;
+ break;
+ case 'o':
+ snprintf(outfile, sizeof(outfile), "%s", optarg);
+ break;
+ default:
+ usage();
+ }
+ }
+ argc -= optind;
+ argv += optind;
+
+ if (argc == 0)
+ usage();
+
+ if (outfile[0] != '\0' && access(outfile, F_OK) == 0 && !fflag)
+ log_errx("File %s already exists, use --force to overwrite it",
+ outfile);
+
+ if (outfile[0] == '\0')
+ snprintf(outfile, sizeof(outfile), "%s", argv[0]);
+
+ parse_fip(argv[0], &toc_header);
+
+ for (toc_entry = toc_entries;
+ toc_entry->cmdline_name != NULL;
+ toc_entry++) {
+ if (toc_entry->action != DO_REMOVE)
+ continue;
+ if (toc_entry->image != NULL) {
+ if (verbose)
+ log_dbgx("Removing %s.bin",
+ toc_entry->cmdline_name);
+ remove_image(toc_entry->image);
+ } else {
+ log_warnx("Requested image %s.bin is not in %s",
+ toc_entry->cmdline_name, argv[0]);
+ }
+ }
+
+ pack_images(outfile, toc_header.flags);
+ free_images();
+ return 0;
+}
+
+static void remove_usage(void)
+{
+ toc_entry_t *toc_entry = toc_entries;
+
+ printf("fiptool remove [--force] [--out FIP_FILENAME] [opts] FIP_FILENAME\n");
+ printf(" --force\t\tIf the output FIP file already exists, use --force to "
+ "overwrite it.\n");
+ printf(" --out FIP_FILENAME\tSet an alternative output FIP file.\n");
+ fputc('\n', stderr);
+ printf("Specific images are removed with the following options:\n");
+ for (; toc_entry->cmdline_name != NULL; toc_entry++)
+ printf(" --%-16s\t%s\n", toc_entry->cmdline_name,
+ toc_entry->name);
+}
+
+static int version_cmd(int argc, char *argv[])
+{
+#ifdef VERSION
+ puts(VERSION);
+#else
+ /* If built from fiptool directory, VERSION is not set. */
+ puts("Unknown version");
+#endif
+ return 0;
+}
+
+static void version_usage(void)
+{
+ printf("fiptool version\n");
+}
+
+static int help_cmd(int argc, char *argv[])
+{
+ int i;
+
+ if (argc < 2)
+ usage();
+ argc--, argv++;
+
+ for (i = 0; i < NELEM(cmds); i++) {
+ if (strcmp(cmds[i].name, argv[0]) == 0 &&
+ cmds[i].usage != NULL) {
+ cmds[i].usage();
+ break;
+ }
+ }
+ if (i == NELEM(cmds))
+ printf("No help for subcommand '%s'\n", argv[0]);
+ return 0;
+}
+
+static void usage(void)
+{
+ printf("usage: [--verbose] fiptool <command> [<args>]\n");
+ printf("Global options supported:\n");
+ printf(" --verbose\tEnable verbose output for all commands.\n");
+ fputc('\n', stderr);
+ printf("Commands supported:\n");
+ printf(" info\t\tList images contained in FIP.\n");
+ printf(" create\tCreate a new FIP with the given images.\n");
+ printf(" update\tUpdate an existing FIP with the given images.\n");
+ printf(" unpack\tUnpack images from FIP.\n");
+ printf(" remove\tRemove images from FIP.\n");
+ printf(" version\tShow fiptool version.\n");
+ printf(" help\t\tShow help for given command.\n");
+ exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+ int i, ret = 0;
+
+ if (argc < 2)
+ usage();
+ argc--, argv++;
+
+ if (strcmp(argv[0], "-v") == 0 ||
+ strcmp(argv[0], "--verbose") == 0) {
+ verbose = 1;
+ argc--, argv++;
+ }
+
+ for (i = 0; i < NELEM(cmds); i++) {
+ if (strcmp(cmds[i].name, argv[0]) == 0) {
+ ret = cmds[i].handler(argc, argv);
+ break;
+ }
+ }
+ if (i == NELEM(cmds))
+ usage();
+ return ret;
+}