image: log error when unknown image type is specified

[openocd.git] / src / target / image.c

diff --git a/src/target/image.c b/src/target/image.c
index df07ea3ef81edd1ada4a71852495e0185e9eac57..e998a35f4d55f4e9939f43714917acab3726136e 100644 (file)
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -1,3 +1,5 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+
 /***************************************************************************
  *   Copyright (C) 2007 by Dominic Rath                                    *
  *   Dominic.Rath@gmx.de                                                   *
@@ -13,19 +15,6 @@
  *                                                                         *
  *   Copyright (C) 2018 by Advantest                                       *
  *   florian.meister@advantest.com                                         *
- *                                                                         *
- *   This program is free software; you can redistribute it and/or modify  *
- *   it under the terms of the GNU General Public License as published by  *
- *   the Free Software Foundation; either version 2 of the License, or     *
- *   (at your option) any later version.                                   *
- *                                                                         *
- *   This program is distributed in the hope that it will be useful,       *
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
- *   GNU General Public License for more details.                          *
- *                                                                         *
- *   You should have received a copy of the GNU General Public License     *
- *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -61,12 +50,15 @@ static int autodetect_image_type(struct image *image, const char *url)
        if (retval != ERROR_OK)
                return retval;
        retval = fileio_read(fileio, 9, buffer, &read_bytes);
+       fileio_close(fileio);
 
-       if (retval == ERROR_OK) {
-               if (read_bytes != 9)
-                       retval = ERROR_FILEIO_OPERATION_FAILED;
+       /* If the file is smaller than 9 bytes, it can only be bin */
+       if (retval == ERROR_OK && read_bytes != 9) {
+               LOG_DEBUG("Less than 9 bytes in the image file found.");
+               LOG_DEBUG("BIN image detected.");
+               image->type = IMAGE_BINARY;
+               return ERROR_OK;
        }
-       fileio_close(fileio);
 
        if (retval != ERROR_OK)
                return retval;
@@ -93,8 +85,10 @@ static int autodetect_image_type(struct image *image, const char *url)
                && (buffer[1] >= '0') && (buffer[1] < '9')) {
                LOG_DEBUG("S19 image detected.");
                image->type = IMAGE_SRECORD;
-       } else
+       } else {
+               LOG_DEBUG("BIN image detected.");
                image->type = IMAGE_BINARY;
+       }
 
        return ERROR_OK;
 }
@@ -102,20 +96,22 @@ static int autodetect_image_type(struct image *image, const char *url)
 static int identify_image_type(struct image *image, const char *type_string, const char *url)
 {
        if (type_string) {
-               if (!strcmp(type_string, "bin"))
+               if (!strcmp(type_string, "bin")) {
                        image->type = IMAGE_BINARY;
-               else if (!strcmp(type_string, "ihex"))
+               } else if (!strcmp(type_string, "ihex")) {
                        image->type = IMAGE_IHEX;
-               else if (!strcmp(type_string, "elf"))
+               } else if (!strcmp(type_string, "elf")) {
                        image->type = IMAGE_ELF;
-               else if (!strcmp(type_string, "mem"))
+               } else if (!strcmp(type_string, "mem")) {
                        image->type = IMAGE_MEMORY;
-               else if (!strcmp(type_string, "s19"))
+               } else if (!strcmp(type_string, "s19")) {
                        image->type = IMAGE_SRECORD;
-               else if (!strcmp(type_string, "build"))
+               } else if (!strcmp(type_string, "build")) {
                        image->type = IMAGE_BUILDER;
-               else
+               } else {
+                       LOG_ERROR("Unknown image type: %s, use one of: bin, ihex, elf, mem, s19, build", type_string);
                        return ERROR_IMAGE_TYPE_UNKNOWN;
+               }
        } else
                return autodetect_image_type(image, url);
 
@@ -337,12 +333,12 @@ static int image_ihex_buffer_complete_inner(struct image *image,
 static int image_ihex_buffer_complete(struct image *image)
 {
        char *lpsz_line = malloc(1023);
-       if (lpsz_line == NULL) {
+       if (!lpsz_line) {
                LOG_ERROR("Out of memory");
                return ERROR_FAIL;
        }
        struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
-       if (section == NULL) {
+       if (!section) {
                free(lpsz_line);
                LOG_ERROR("Out of memory");
                return ERROR_FAIL;
@@ -374,7 +370,7 @@ static int image_elf32_read_headers(struct image *image)
 
        elf->header32 = malloc(sizeof(Elf32_Ehdr));
 
-       if (elf->header32 == NULL) {
+       if (!elf->header32) {
                LOG_ERROR("insufficient memory to perform operation");
                return ERROR_FILEIO_OPERATION_FAILED;
        }
@@ -402,7 +398,7 @@ static int image_elf32_read_headers(struct image *image)
        }
 
        elf->segments32 = malloc(elf->segment_count*sizeof(Elf32_Phdr));
-       if (elf->segments32 == NULL) {
+       if (!elf->segments32) {
                LOG_ERROR("insufficient memory to perform operation");
                return ERROR_FILEIO_OPERATION_FAILED;
        }
@@ -454,7 +450,7 @@ static int image_elf32_read_headers(struct image *image)
 
        /* alloc and fill sections array with loadable segments */
        image->sections = malloc(image->num_sections * sizeof(struct imagesection));
-       if (image->sections == NULL) {
+       if (!image->sections) {
                LOG_ERROR("insufficient memory to perform operation");
                return ERROR_FILEIO_OPERATION_FAILED;
        }
@@ -499,7 +495,7 @@ static int image_elf64_read_headers(struct image *image)
 
        elf->header64 = malloc(sizeof(Elf64_Ehdr));
 
-       if (elf->header64 == NULL) {
+       if (!elf->header64) {
                LOG_ERROR("insufficient memory to perform operation");
                return ERROR_FILEIO_OPERATION_FAILED;
        }
@@ -527,7 +523,7 @@ static int image_elf64_read_headers(struct image *image)
        }
 
        elf->segments64 = malloc(elf->segment_count*sizeof(Elf64_Phdr));
-       if (elf->segments64 == NULL) {
+       if (!elf->segments64) {
                LOG_ERROR("insufficient memory to perform operation");
                return ERROR_FILEIO_OPERATION_FAILED;
        }
@@ -579,7 +575,7 @@ static int image_elf64_read_headers(struct image *image)
 
        /* alloc and fill sections array with loadable segments */
        image->sections = malloc(image->num_sections * sizeof(struct imagesection));
-       if (image->sections == NULL) {
+       if (!image->sections) {
                LOG_ERROR("insufficient memory to perform operation");
                return ERROR_FILEIO_OPERATION_FAILED;
        }
@@ -596,7 +592,7 @@ static int image_elf64_read_headers(struct image *image)
                                image->sections[j].base_address = field64(elf,
                                                elf->segments64[i].p_paddr);
                        image->sections[j].private = &elf->segments64[i];
-                       image->sections[j].flags = field32(elf, elf->segments64[i].p_flags);
+                       image->sections[j].flags = field64(elf, elf->segments64[i].p_flags);
                        j++;
                }
        }
@@ -937,12 +933,12 @@ static int image_mot_buffer_complete_inner(struct image *image,
 static int image_mot_buffer_complete(struct image *image)
 {
        char *lpsz_line = malloc(1023);
-       if (lpsz_line == NULL) {
+       if (!lpsz_line) {
                LOG_ERROR("Out of memory");
                return ERROR_FAIL;
        }
        struct imagesection *section = malloc(sizeof(struct imagesection) * IMAGE_MAX_SECTIONS);
-       if (section == NULL) {
+       if (!section) {
                free(lpsz_line);
                LOG_ERROR("Out of memory");
                return ERROR_FAIL;
@@ -1018,7 +1014,7 @@ int image_open(struct image *image, const char *url, const char *type_string)
        } else if (image->type == IMAGE_MEMORY) {
                struct target *target = get_target(url);
 
-               if (target == NULL) {
+               if (!target) {
                        LOG_ERROR("target '%s' not defined", url);
                        return ERROR_FAIL;
                }
@@ -1168,7 +1164,7 @@ int image_read_section(struct image *image,
        return ERROR_OK;
 }
 
-int image_add_section(struct image *image, target_addr_t base, uint32_t size, int flags, uint8_t const *data)
+int image_add_section(struct image *image, target_addr_t base, uint32_t size, uint64_t flags, uint8_t const *data)
 {
        struct imagesection *section;