// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2008 Semihalf
 *
 * (C) Copyright 2000-2004
 * DENX Software Engineering
 * Wolfgang Denk, wd@denx.de
 *
 * Updated-by: Prafulla Wadaskar <prafulla@marvell.com>
 *              FIT image specific code abstracted from mkimage.c
 *              some functions added to address abstraction
 *
 * All rights reserved.
 */

#include "imagetool.h"
#include "fit_common.h"
#include "mkimage.h"
#include <image.h>
#include <string.h>
#include <stdarg.h>
#include <version.h>
#include <u-boot/crc.h>

static image_header_t header;

static int fit_add_file_data(struct image_tool_params *params, size_t size_inc,
                             const char *tmpfile)
{
        int tfd, destfd = 0;
        void *dest_blob = NULL;
        off_t destfd_size = 0;
        struct stat sbuf;
        void *ptr;
        int ret = 0;

        tfd = mmap_fdt(params->cmdname, tmpfile, size_inc, &ptr, &sbuf, true,
                       false);
        if (tfd < 0)
                return -EIO;

        if (params->keydest) {
                struct stat dest_sbuf;

                destfd = mmap_fdt(params->cmdname, params->keydest, size_inc,
                                  &dest_blob, &dest_sbuf, false,
                                  false);
                if (destfd < 0) {
                        ret = -EIO;
                        goto err_keydest;
                }
                destfd_size = dest_sbuf.st_size;
        }

        /* for first image creation, add a timestamp at offset 0 i.e., root  */
        if (params->datafile || params->reset_timestamp) {
                time_t time = imagetool_get_source_date(params->cmdname,
                                                        sbuf.st_mtime);
                ret = fit_set_timestamp(ptr, 0, time);
        }

        if (!ret) {
                ret = fit_cipher_data(params->keydir, dest_blob, ptr,
                                      params->comment,
                                      params->require_keys,
                                      params->engine_id,
                                      params->cmdname);
        }

        if (!ret) {
                ret = fit_add_verification_data(params->keydir, dest_blob, ptr,
                                                params->comment,
                                                params->require_keys,
                                                params->engine_id,
                                                params->cmdname);
        }

        if (dest_blob) {
                munmap(dest_blob, destfd_size);
                close(destfd);
        }

err_keydest:
        munmap(ptr, sbuf.st_size);
        close(tfd);
        return ret;
}

/**
 * fit_calc_size() - Calculate the approximate size of the FIT we will generate
 */
static int fit_calc_size(struct image_tool_params *params)
{
        struct content_info *cont;
        int size, total_size;

        size = imagetool_get_filesize(params, params->datafile);
        if (size < 0)
                return -1;
        total_size = size;

        if (params->fit_ramdisk) {
                size = imagetool_get_filesize(params, params->fit_ramdisk);
                if (size < 0)
                        return -1;
                total_size += size;
        }

        for (cont = params->content_head; cont; cont = cont->next) {
                size = imagetool_get_filesize(params, cont->fname);
                if (size < 0)
                        return -1;

                /* Add space for properties and hash node */
                total_size += size + 300;
        }

        /* Add plenty of space for headers, properties, nodes, etc. */
        total_size += 4096;

        return total_size;
}

static int fdt_property_file(struct image_tool_params *params,
                             void *fdt, const char *name, const char *fname)
{
        struct stat sbuf;
        void *ptr;
        int ret;
        int fd;

        fd = open(fname, O_RDWR | O_BINARY);
        if (fd < 0) {
                fprintf(stderr, "%s: Can't open %s: %s\n",
                        params->cmdname, fname, strerror(errno));
                return -1;
        }

        if (fstat(fd, &sbuf) < 0) {
                fprintf(stderr, "%s: Can't stat %s: %s\n",
                        params->cmdname, fname, strerror(errno));
                goto err;
        }

        ret = fdt_property_placeholder(fdt, "data", sbuf.st_size, &ptr);
        if (ret)
                goto err;
        ret = read(fd, ptr, sbuf.st_size);
        if (ret != sbuf.st_size) {
                fprintf(stderr, "%s: Can't read %s: %s\n",
                        params->cmdname, fname, strerror(errno));
                goto err;
        }
        close(fd);

        return 0;
err:
        close(fd);
        return -1;
}

static int fdt_property_strf(void *fdt, const char *name, const char *fmt, ...)
{
        char str[100];
        va_list ptr;

        va_start(ptr, fmt);
        vsnprintf(str, sizeof(str), fmt, ptr);
        va_end(ptr);
        return fdt_property_string(fdt, name, str);
}

static void get_basename(char *str, int size, const char *fname)
{
        const char *p, *start, *end;
        int len;

        /*
         * Use the base name as the 'name' field. So for example:
         *
         * "arch/arm/dts/sun7i-a20-bananapro.dtb"
         * becomes "sun7i-a20-bananapro"
         */
        p = strrchr(fname, '/');
        start = p ? p + 1 : fname;
        p = strrchr(fname, '.');
        end = p ? p : fname + strlen(fname);
        len = end - start;
        if (len >= size)
                len = size - 1;
        memcpy(str, start, len);
        str[len] = '\0';
}

/**
 * add_crc_node() - Add a hash node to request a CRC checksum for an image
 *
 * @fdt: Device tree to add to (in sequential-write mode)
 */
static void add_crc_node(void *fdt)
{
        fdt_begin_node(fdt, "hash-1");
        fdt_property_string(fdt, FIT_ALGO_PROP, "crc32");
        fdt_end_node(fdt);
}

/**
 * fit_write_images() - Write out a list of images to the FIT
 *
 * We always include the main image (params->datafile). If there are device
 * tree files, we include an fdt- node for each of those too.
 */
static int fit_write_images(struct image_tool_params *params, char *fdt)
{
        struct content_info *cont;
        const char *typename;
        char str[100];
        int upto;
        int ret;

        fdt_begin_node(fdt, "images");

        /* First the main image */
        typename = genimg_get_type_short_name(params->fit_image_type);
        snprintf(str, sizeof(str), "%s-1", typename);
        fdt_begin_node(fdt, str);
        fdt_property_string(fdt, FIT_DESC_PROP, params->imagename);
        fdt_property_string(fdt, FIT_TYPE_PROP, typename);
        fdt_property_string(fdt, FIT_ARCH_PROP,
                            genimg_get_arch_short_name(params->arch));
        fdt_property_string(fdt, FIT_OS_PROP,
                            genimg_get_os_short_name(params->os));
        fdt_property_string(fdt, FIT_COMP_PROP,
                            genimg_get_comp_short_name(params->comp));
        fdt_property_u32(fdt, FIT_LOAD_PROP, params->addr);
        fdt_property_u32(fdt, FIT_ENTRY_PROP, params->ep);

        /*
         * Put data last since it is large. SPL may only load the first part
         * of the DT, so this way it can access all the above fields.
         */
        ret = fdt_property_file(params, fdt, FIT_DATA_PROP, params->datafile);
        if (ret)
                return ret;
        add_crc_node(fdt);
        fdt_end_node(fdt);

        /* Now the device tree files if available */
        upto = 0;
        for (cont = params->content_head; cont; cont = cont->next) {
                if (cont->type != IH_TYPE_FLATDT)
                        continue;
                typename = genimg_get_type_short_name(cont->type);
                snprintf(str, sizeof(str), "%s-%d", FIT_FDT_PROP, ++upto);
                fdt_begin_node(fdt, str);

                get_basename(str, sizeof(str), cont->fname);
                fdt_property_string(fdt, FIT_DESC_PROP, str);
                ret = fdt_property_file(params, fdt, FIT_DATA_PROP,
                                        cont->fname);
                if (ret)
                        return ret;
                fdt_property_string(fdt, FIT_TYPE_PROP, typename);
                fdt_property_string(fdt, FIT_ARCH_PROP,
                                    genimg_get_arch_short_name(params->arch));
                fdt_property_string(fdt, FIT_COMP_PROP,
                                    genimg_get_comp_short_name(IH_COMP_NONE));
                add_crc_node(fdt);
                fdt_end_node(fdt);
        }

        /* And a ramdisk file if available */
        if (params->fit_ramdisk) {
                fdt_begin_node(fdt, FIT_RAMDISK_PROP "-1");

                fdt_property_string(fdt, FIT_TYPE_PROP, FIT_RAMDISK_PROP);
                fdt_property_string(fdt, FIT_OS_PROP,
                                    genimg_get_os_short_name(params->os));
                fdt_property_string(fdt, FIT_ARCH_PROP,
                                    genimg_get_arch_short_name(params->arch));

                ret = fdt_property_file(params, fdt, FIT_DATA_PROP,
                                        params->fit_ramdisk);
                if (ret)
                        return ret;
                add_crc_node(fdt);
                fdt_end_node(fdt);
        }

        fdt_end_node(fdt);

        return 0;
}

/**
 * fit_write_configs() - Write out a list of configurations to the FIT
 *
 * If there are device tree files, we include a configuration for each, which
 * selects the main image (params->datafile) and its corresponding device
 * tree file.
 *
 * Otherwise we just create a configuration with the main image in it.
 */
static void fit_write_configs(struct image_tool_params *params, char *fdt)
{
        struct content_info *cont;
        const char *typename;
        char str[100];
        int upto;

        fdt_begin_node(fdt, "configurations");
        fdt_property_string(fdt, FIT_DEFAULT_PROP, "conf-1");

        upto = 0;
        for (cont = params->content_head; cont; cont = cont->next) {
                if (cont->type != IH_TYPE_FLATDT)
                        continue;
                typename = genimg_get_type_short_name(cont->type);
                snprintf(str, sizeof(str), "conf-%d", ++upto);
                fdt_begin_node(fdt, str);

                get_basename(str, sizeof(str), cont->fname);
                fdt_property_string(fdt, FIT_DESC_PROP, str);

                typename = genimg_get_type_short_name(params->fit_image_type);
                snprintf(str, sizeof(str), "%s-1", typename);
                fdt_property_string(fdt, typename, str);
                fdt_property_string(fdt, FIT_LOADABLE_PROP, str);

                if (params->fit_ramdisk)
                        fdt_property_string(fdt, FIT_RAMDISK_PROP,
                                            FIT_RAMDISK_PROP "-1");

                snprintf(str, sizeof(str), FIT_FDT_PROP "-%d", upto);
                fdt_property_string(fdt, FIT_FDT_PROP, str);
                fdt_end_node(fdt);
        }

        if (!upto) {
                fdt_begin_node(fdt, "conf-1");
                typename = genimg_get_type_short_name(params->fit_image_type);
                snprintf(str, sizeof(str), "%s-1", typename);
                fdt_property_string(fdt, typename, str);

                if (params->fit_ramdisk)
                        fdt_property_string(fdt, FIT_RAMDISK_PROP,
                                            FIT_RAMDISK_PROP "-1");

                fdt_end_node(fdt);
        }

        fdt_end_node(fdt);
}

static int fit_build_fdt(struct image_tool_params *params, char *fdt, int size)
{
        int ret;

        ret = fdt_create(fdt, size);
        if (ret)
                return ret;
        fdt_finish_reservemap(fdt);
        fdt_begin_node(fdt, "");
        fdt_property_strf(fdt, FIT_DESC_PROP,
                          "%s image with one or more FDT blobs",
                          genimg_get_type_name(params->fit_image_type));
        fdt_property_strf(fdt, "creator", "U-Boot mkimage %s", PLAIN_VERSION);
        fdt_property_u32(fdt, "#address-cells", 1);
        ret = fit_write_images(params, fdt);
        if (ret)
                return ret;
        fit_write_configs(params, fdt);
        fdt_end_node(fdt);
        ret = fdt_finish(fdt);
        if (ret)
                return ret;

        return fdt_totalsize(fdt);
}

static int fit_build(struct image_tool_params *params, const char *fname)
{
        char *buf;
        int size;
        int ret;
        int fd;

        size = fit_calc_size(params);
        if (size < 0)
                return -1;
        buf = calloc(1, size);
        if (!buf) {
                fprintf(stderr, "%s: Out of memory (%d bytes)\n",
                        params->cmdname, size);
                return -1;
        }
        ret = fit_build_fdt(params, buf, size);
        if (ret < 0) {
                fprintf(stderr, "%s: Failed to build FIT image\n",
                        params->cmdname);
                goto err_buf;
        }
        size = ret;
        fd = open(fname, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
        if (fd < 0) {
                fprintf(stderr, "%s: Can't open %s: %s\n",
                        params->cmdname, fname, strerror(errno));
                goto err_buf;
        }
        ret = write(fd, buf, size);
        if (ret != size) {
                fprintf(stderr, "%s: Can't write %s: %s\n",
                        params->cmdname, fname, strerror(errno));
                goto err;
        }
        close(fd);
        free(buf);

        return 0;
err:
        close(fd);
err_buf:
        free(buf);
        return -1;
}

/**
 * fit_extract_data() - Move all data outside the FIT
 *
 * This takes a normal FIT file and removes all the 'data' properties from it.
 * The data is placed in an area after the FIT so that it can be accessed
 * using an offset into that area. The 'data' properties turn into
 * 'data-offset' properties.
 *
 * This function cannot cope with FITs with 'data-offset' properties. All
 * data must be in 'data' properties on entry.
 */
static int fit_extract_data(struct image_tool_params *params, const char *fname)
{
        void *buf = NULL;
        int buf_ptr;
        int fit_size, new_size;
        int fd;
        struct stat sbuf;
        void *fdt;
        int ret;
        int images;
        int node;
        int image_number;
        int align_size;

        align_size = params->bl_len ? params->bl_len : 4;
        fd = mmap_fdt(params->cmdname, fname, 0, &fdt, &sbuf, false, false);
        if (fd < 0)
                return -EIO;
        fit_size = fdt_totalsize(fdt);

        images = fdt_path_offset(fdt, FIT_IMAGES_PATH);
        if (images < 0) {
                debug("%s: Cannot find /images node: %d\n", __func__, images);
                ret = -EINVAL;
                goto err_munmap;
        }
        image_number = fdtdec_get_child_count(fdt, images);

        /*
         * Allocate space to hold the image data we will extract,
         * extral space allocate for image alignment to prevent overflow.
         */
        buf = calloc(1, fit_size + (align_size * image_number));
        if (!buf) {
                ret = -ENOMEM;
                goto err_munmap;
        }
        buf_ptr = 0;

        for (node = fdt_first_subnode(fdt, images);
             node >= 0;
             node = fdt_next_subnode(fdt, node)) {
                const char *data;
                int len;

                data = fdt_getprop(fdt, node, FIT_DATA_PROP, &len);
                if (!data)
                        continue;
                memcpy(buf + buf_ptr, data, len);
                debug("Extracting data size %x\n", len);

                ret = fdt_delprop(fdt, node, FIT_DATA_PROP);
                if (ret) {
                        ret = -EPERM;
                        goto err_munmap;
                }
                if (params->external_offset > 0) {
                        /* An external offset positions the data absolutely. */
                        fdt_setprop_u32(fdt, node, FIT_DATA_POSITION_PROP,
                                        params->external_offset + buf_ptr);
                } else {
                        fdt_setprop_u32(fdt, node, FIT_DATA_OFFSET_PROP,
                                        buf_ptr);
                }
                fdt_setprop_u32(fdt, node, FIT_DATA_SIZE_PROP, len);
                buf_ptr += ALIGN(len, align_size);
        }

        /* Pack the FDT and place the data after it */
        fdt_pack(fdt);

        new_size = fdt_totalsize(fdt);
        new_size = ALIGN(new_size, align_size);
        fdt_set_totalsize(fdt, new_size);
        debug("Size reduced from %x to %x\n", fit_size, fdt_totalsize(fdt));
        debug("External data size %x\n", buf_ptr);
        munmap(fdt, sbuf.st_size);

        if (ftruncate(fd, new_size)) {
                debug("%s: Failed to truncate file: %s\n", __func__,
                      strerror(errno));
                ret = -EIO;
                goto err;
        }

        /* Check if an offset for the external data was set. */
        if (params->external_offset > 0) {
                if (params->external_offset < new_size) {
                        debug("External offset %x overlaps FIT length %x",
                              params->external_offset, new_size);
                        ret = -EINVAL;
                        goto err;
                }
                new_size = params->external_offset;
        }
        if (lseek(fd, new_size, SEEK_SET) < 0) {
                debug("%s: Failed to seek to end of file: %s\n", __func__,
                      strerror(errno));
                ret = -EIO;
                goto err;
        }
        if (write(fd, buf, buf_ptr) != buf_ptr) {
                debug("%s: Failed to write external data to file %s\n",
                      __func__, strerror(errno));
                ret = -EIO;
                goto err;
        }
        free(buf);
        close(fd);
        return 0;

err_munmap:
        munmap(fdt, sbuf.st_size);
err:
        free(buf);
        close(fd);
        return ret;
}

static int fit_import_data(struct image_tool_params *params, const char *fname)
{
        void *fdt, *old_fdt;
        int fit_size, new_size, size, data_base;
        int fd;
        struct stat sbuf;
        int ret;
        int images;
        int node;

        fd = mmap_fdt(params->cmdname, fname, 0, &old_fdt, &sbuf, false, false);
        if (fd < 0)
                return -EIO;
        fit_size = fdt_totalsize(old_fdt);
        data_base = ALIGN(fit_size, 4);

        /* Allocate space to hold the new FIT */
        size = sbuf.st_size + 16384;
        fdt = calloc(1, size);
        if (!fdt) {
                fprintf(stderr, "%s: Failed to allocate memory (%d bytes)\n",
                        __func__, size);
                ret = -ENOMEM;
                goto err_munmap;
        }
        ret = fdt_open_into(old_fdt, fdt, size);
        if (ret) {
                debug("%s: Failed to expand FIT: %s\n", __func__,
                      fdt_strerror(errno));
                ret = -EINVAL;
                goto err_munmap;
        }

        images = fdt_path_offset(fdt, FIT_IMAGES_PATH);
        if (images < 0) {
                debug("%s: Cannot find /images node: %d\n", __func__, images);
                ret = -EINVAL;
                goto err_munmap;
        }

        for (node = fdt_first_subnode(fdt, images);
             node >= 0;
             node = fdt_next_subnode(fdt, node)) {
                int buf_ptr;
                int len;

                buf_ptr = fdtdec_get_int(fdt, node, "data-offset", -1);
                len = fdtdec_get_int(fdt, node, "data-size", -1);
                if (buf_ptr == -1 || len == -1)
                        continue;
                debug("Importing data size %x\n", len);

                ret = fdt_setprop(fdt, node, "data",
                                  old_fdt + data_base + buf_ptr, len);
                if (ret) {
                        debug("%s: Failed to write property: %s\n", __func__,
                              fdt_strerror(ret));
                        ret = -EINVAL;
                        goto err_munmap;
                }
        }

        munmap(old_fdt, sbuf.st_size);

        /* Close the old fd so we can re-use it. */
        close(fd);

        /* Pack the FDT and place the data after it */
        fdt_pack(fdt);

        new_size = fdt_totalsize(fdt);
        debug("Size expanded from %x to %x\n", fit_size, new_size);

        fd = open(fname, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0666);
        if (fd < 0) {
                fprintf(stderr, "%s: Can't open %s: %s\n",
                        params->cmdname, fname, strerror(errno));
                ret = -EIO;
                goto err;
        }
        if (write(fd, fdt, new_size) != new_size) {
                debug("%s: Failed to write external data to file %s\n",
                      __func__, strerror(errno));
                ret = -EIO;
                goto err;
        }

        free(fdt);
        close(fd);
        return 0;

err_munmap:
        munmap(old_fdt, sbuf.st_size);
err:
        free(fdt);
        close(fd);
        return ret;
}

static int copyfile(const char *src, const char *dst)
{
        int fd_src = -1, fd_dst = -1;
        void *buf = NULL;
        ssize_t size;
        size_t count;
        int ret = -1;

        fd_src = open(src, O_RDONLY);
        if (fd_src < 0) {
                printf("Can't open file %s (%s)\n", src, strerror(errno));
                goto out;
        }

        fd_dst = open(dst, O_WRONLY | O_CREAT, 0666);
        if (fd_dst < 0) {
                printf("Can't open file %s (%s)\n", dst, strerror(errno));
                goto out;
        }

        buf = calloc(1, 512);
        if (!buf) {
                printf("Can't allocate buffer to copy file\n");
                goto out;
        }

        while (1) {
                size = read(fd_src, buf, 512);
                if (size < 0) {
                        printf("Can't read file %s\n", src);
                        goto out;
                }
                if (!size)
                        break;

                count = size;
                size = write(fd_dst, buf, count);
                if (size < 0) {
                        printf("Can't write file %s\n", dst);
                        goto out;
                }
        }

        ret = 0;

 out:
        if (fd_src >= 0)
                close(fd_src);
        if (fd_dst >= 0)
                close(fd_dst);
        if (buf)
                free(buf);

        return ret;
}

/**
 * fit_handle_file - main FIT file processing function
 *
 * fit_handle_file() runs dtc to convert .its to .itb, includes
 * binary data, updates timestamp property and calculates hashes.
 *
 * datafile  - .its file
 * imagefile - .itb file
 *
 * returns:
 *     only on success, otherwise calls exit (EXIT_FAILURE);
 */
static int fit_handle_file(struct image_tool_params *params)
{
        char tmpfile[MKIMAGE_MAX_TMPFILE_LEN];
        char bakfile[MKIMAGE_MAX_TMPFILE_LEN + 4] = {0};
        char cmd[MKIMAGE_MAX_DTC_CMDLINE_LEN];
        size_t size_inc;
        int ret;

        /* Flattened Image Tree (FIT) format  handling */
        debug ("FIT format handling\n");

        /* call dtc to include binary properties into the tmp file */
        if (strlen (params->imagefile) +
                strlen (MKIMAGE_TMPFILE_SUFFIX) + 1 > sizeof (tmpfile)) {
                fprintf (stderr, "%s: Image file name (%s) too long, "
                                "can't create tmpfile",
                                params->imagefile, params->cmdname);
                return (EXIT_FAILURE);
        }
        sprintf (tmpfile, "%s%s", params->imagefile, MKIMAGE_TMPFILE_SUFFIX);

        /* We either compile the source file, or use the existing FIT image */
        if (params->auto_its) {
                if (fit_build(params, tmpfile)) {
                        fprintf(stderr, "%s: failed to build FIT\n",
                                params->cmdname);
                        return EXIT_FAILURE;
                }
                *cmd = '\0';
        } else if (params->datafile) {
                /* dtc -I dts -O dtb -p 500 -o tmpfile datafile */
                snprintf(cmd, sizeof(cmd), "%s %s -o \"%s\" \"%s\"",
                         MKIMAGE_DTC, params->dtc, tmpfile, params->datafile);
                debug("Trying to execute \"%s\"\n", cmd);
        } else {
                snprintf(cmd, sizeof(cmd), "cp \"%s\" \"%s\"",
                         params->imagefile, tmpfile);
        }
        if (strlen(cmd) >= MKIMAGE_MAX_DTC_CMDLINE_LEN - 1) {
                fprintf(stderr, "WARNING: command-line for FIT creation might be truncated and will probably fail.\n");
        }

        if (*cmd && system(cmd) == -1) {
                fprintf (stderr, "%s: system(%s) failed: %s\n",
                                params->cmdname, cmd, strerror(errno));
                goto err_system;
        }

        /* Move the data so it is internal to the FIT, if needed */
        ret = fit_import_data(params, tmpfile);
        if (ret)
                goto err_system;

        /*
         * Copy the tmpfile to bakfile, then in the following loop
         * we copy bakfile to tmpfile. So we always start from the
         * beginning.
         */
        sprintf(bakfile, "%s%s", tmpfile, ".bak");
        rename(tmpfile, bakfile);

        /*
         * Set hashes for images in the blob. Unfortunately we may need more
         * space in either FDT, so keep trying until we succeed.
         *
         * Note: this is pretty inefficient for signing, since we must
         * calculate the signature every time. It would be better to calculate
         * all the data and then store it in a separate step. However, this
         * would be considerably more complex to implement. Generally a few
         * steps of this loop is enough to sign with several keys.
         */
        for (size_inc = 0; size_inc < 64 * 1024; size_inc += 1024) {
                if (copyfile(bakfile, tmpfile) < 0) {
                        printf("Can't copy %s to %s\n", bakfile, tmpfile);
                        ret = -EIO;
                        break;
                }
                ret = fit_add_file_data(params, size_inc, tmpfile);
                if (!ret || ret != -ENOSPC)
                        break;
        }

        if (ret) {
                fprintf(stderr, "%s Can't add hashes to FIT blob: %d\n",
                        params->cmdname, ret);
                goto err_system;
        }

        /* Move the data so it is external to the FIT, if requested */
        if (params->external_data) {
                ret = fit_extract_data(params, tmpfile);
                if (ret)
                        goto err_system;
        }

        if (rename (tmpfile, params->imagefile) == -1) {
                fprintf (stderr, "%s: Can't rename %s to %s: %s\n",
                                params->cmdname, tmpfile, params->imagefile,
                                strerror (errno));
                unlink (tmpfile);
                unlink(bakfile);
                unlink (params->imagefile);
                return EXIT_FAILURE;
        }
        unlink(bakfile);
        return EXIT_SUCCESS;

err_system:
        unlink(tmpfile);
        unlink(bakfile);
        return -1;
}

/**
 * fit_image_extract - extract a FIT component image
 * @fit: pointer to the FIT format image header
 * @image_noffset: offset of the component image node
 * @file_name: name of the file to store the FIT sub-image
 *
 * returns:
 *     zero in case of success or a negative value if fail.
 */
static int fit_image_extract(
        const void *fit,
        int image_noffset,
        const char *file_name)
{
        const void *file_data;
        size_t file_size = 0;
        int ret;

        /* get the data address and size of component at offset "image_noffset" */
        ret = fit_image_get_data_and_size(fit, image_noffset, &file_data, &file_size);
        if (ret) {
                fprintf(stderr, "Could not get component information\n");
                return ret;
        }

        /* save the "file_data" into the file specified by "file_name" */
        return imagetool_save_subimage(file_name, (ulong) file_data, file_size);
}

/**
 * fit_extract_contents - retrieve a sub-image component from the FIT image
 * @ptr: pointer to the FIT format image header
 * @params: command line parameters
 *
 * returns:
 *     zero in case of success or a negative value if fail.
 */
static int fit_extract_contents(void *ptr, struct image_tool_params *params)
{
        int images_noffset;
        int noffset;
        int ndepth;
        const void *fit = ptr;
        int count = 0;
        const char *p;

        /* Indent string is defined in header image.h */
        p = IMAGE_INDENT_STRING;

        if (fit_check_format(fit, IMAGE_SIZE_INVAL)) {
                printf("Bad FIT image format\n");
                return -1;
        }

        /* Find images parent node offset */
        images_noffset = fdt_path_offset(fit, FIT_IMAGES_PATH);
        if (images_noffset < 0) {
                printf("Can't find images parent node '%s' (%s)\n",
                       FIT_IMAGES_PATH, fdt_strerror(images_noffset));
                return -1;
        }

        /* Avoid any overrun */
        count = fit_get_subimage_count(fit, images_noffset);
        if ((params->pflag < 0) || (count <= params->pflag)) {
                printf("No such component at '%d'\n", params->pflag);
                return -1;
        }

        /* Process its subnodes, extract the desired component from image */
        for (ndepth = 0, count = 0,
                noffset = fdt_next_node(fit, images_noffset, &ndepth);
                (noffset >= 0) && (ndepth > 0);
                noffset = fdt_next_node(fit, noffset, &ndepth)) {
                if (ndepth == 1) {
                        /*
                         * Direct child node of the images parent node,
                         * i.e. component image node.
                         */
                        if (params->pflag == count) {
                                printf("Extracted:\n%s Image %u (%s)\n", p,
                                       count, fit_get_name(fit, noffset, NULL));

                                fit_image_print(fit, noffset, p);

                                return fit_image_extract(fit, noffset,
                                                params->outfile);
                        }

                        count++;
                }
        }

        return 0;
}

static int fit_check_params(struct image_tool_params *params)
{
        if (params->auto_its)
                return 0;
        return  ((params->dflag && params->fflag) ||
                 (params->fflag && params->lflag) ||
                 (params->lflag && params->dflag));
}

U_BOOT_IMAGE_TYPE(
        fitimage,
        "FIT Image support",
        sizeof(image_header_t),
        (void *)&header,
        fit_check_params,
        fit_verify_header,
        fit_print_contents,
        NULL,
        fit_extract_contents,
        fit_check_image_types,
        fit_handle_file,
        NULL /* FIT images use DTB header */
);