+// SPDX-License-Identifier: GPL-2.0-or-later
+
/***************************************************************************
* Copyright (C) 2007 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
* 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
#include "image.h"
#include "target.h"
#include <helper/log.h>
+#include <server/server.h>
/* convert ELF header field to host endianness */
#define field16(elf, field) \
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;
&& (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;
}
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);
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;
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;
}
}
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;
}
/* 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;
}
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;
}
}
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;
}
/* 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;
}
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++;
}
}
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;
retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY);
if (retval != ERROR_OK)
- return retval;
+ goto free_mem_on_error;
+
size_t filesize;
retval = fileio_size(image_binary->fileio, &filesize);
if (retval != ERROR_OK) {
fileio_close(image_binary->fileio);
- return retval;
+ goto free_mem_on_error;
}
image->num_sections = 1;
retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT);
if (retval != ERROR_OK)
- return retval;
+ goto free_mem_on_error;
retval = image_ihex_buffer_complete(image);
if (retval != ERROR_OK) {
LOG_ERROR(
"failed buffering IHEX image, check server output for additional information");
fileio_close(image_ihex->fileio);
- return retval;
+ goto free_mem_on_error;
}
} else if (image->type == IMAGE_ELF) {
struct image_elf *image_elf;
retval = fileio_open(&image_elf->fileio, url, FILEIO_READ, FILEIO_BINARY);
if (retval != ERROR_OK)
- return retval;
+ goto free_mem_on_error;
retval = image_elf_read_headers(image);
if (retval != ERROR_OK) {
fileio_close(image_elf->fileio);
- return retval;
+ goto free_mem_on_error;
}
} 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;
}
retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT);
if (retval != ERROR_OK)
- return retval;
+ goto free_mem_on_error;
retval = image_mot_buffer_complete(image);
if (retval != ERROR_OK) {
LOG_ERROR(
"failed buffering S19 image, check server output for additional information");
fileio_close(image_mot->fileio);
- return retval;
+ goto free_mem_on_error;
}
} else if (image->type == IMAGE_BUILDER) {
image->num_sections = 0;
}
return retval;
+
+free_mem_on_error:
+ free(image->type_private);
+ image->type_private = NULL;
+ return retval;
};
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;
crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ *buffer++) & 255];
}
keep_alive();
+ if (openocd_is_shutdown_pending())
+ return ERROR_SERVER_INTERRUPTED;
}
LOG_DEBUG("Calculating checksum done; checksum=0x%" PRIx32, crc);