X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Fimage.c;h=608ac59d4586ac7b0973584611f4ac3450027908;hb=ef36a7fb3b87bddc14ad9c5d98fde1d041a0de2d;hp=d51e8743b23ba5f6c5b11c6972ae6bad9083800c;hpb=8b994145b849c40b0a195c3fb332b9770b2f9097;p=openocd.git

diff --git a/src/target/image.c b/src/target/image.c
index d51e8743b2..608ac59d45 100644
--- a/src/target/image.c
+++ b/src/target/image.c
@@ -8,6 +8,9 @@
  *   Copyright (C) 2008 by Spencer Oliver                                  *
  *   spen@spen-soft.co.uk                                                  *
  *                                                                         *
+ *   Copyright (C) 2009 by Franck Hereson                                  *
+ *   franck.hereson@secad.fr                                               *
+ *                                                                         *
  *   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     *
@@ -41,10 +44,10 @@
 	((elf->endianness == ELFDATA2LSB)? \
 		le_to_h_u32((uint8_t*)&field):be_to_h_u32((uint8_t*)&field))
 
-static int autodetect_image_type(image_t *image, char *url)
+static int autodetect_image_type(image_t *image, const char *url)
 {
 	int retval;
-	fileio_t fileio;
+	struct fileio fileio;
 	uint32_t read_bytes;
 	uint8_t buffer[9];
 
@@ -103,7 +106,7 @@ static int autodetect_image_type(image_t *image, char *url)
 	return ERROR_OK;
 }
 
-static int identify_image_type(image_t *image, char *type_string, char *url)
+static int identify_image_type(image_t *image, const char *type_string, const char *url)
 {
 	if (type_string)
 	{
@@ -146,8 +149,8 @@ static int identify_image_type(image_t *image, char *type_string, char *url)
 
 static int image_ihex_buffer_complete(image_t *image)
 {
-	image_ihex_t *ihex = image->type_private;
-	fileio_t *fileio = &ihex->fileio;
+	struct image_ihex *ihex = image->type_private;
+	struct fileio *fileio = &ihex->fileio;
 	uint32_t full_address = 0x0;
 	uint32_t cooked_bytes;
 	int i;
@@ -155,7 +158,7 @@ static int image_ihex_buffer_complete(image_t *image)
 
 	/* we can't determine the number of sections that we'll have to create ahead of time,
 	 * so we locally hold them until parsing is finished */
-	image_section_t section[IMAGE_MAX_SECTIONS];
+	struct image_section section[IMAGE_MAX_SECTIONS];
 
 	ihex->buffer = malloc(fileio->size >> 1);
 	cooked_bytes = 0x0;
@@ -196,6 +199,12 @@ static int image_ihex_buffer_complete(image_t *image)
 				if (section[image->num_sections].size != 0)
 				{
 					image->num_sections++;
+					if (image->num_sections >= IMAGE_MAX_SECTIONS)
+					{
+						/* too many sections */
+						LOG_ERROR("Too many sections found in IHEX file");
+						return ERROR_IMAGE_FORMAT_ERROR;
+					}
 					section[image->num_sections].size = 0x0;
 					section[image->num_sections].flags = 0;
 					section[image->num_sections].private = &ihex->buffer[cooked_bytes];
@@ -223,7 +232,7 @@ static int image_ihex_buffer_complete(image_t *image)
 			image->num_sections++;
 
 			/* copy section information */
-			image->sections = malloc(sizeof(image_section_t) * image->num_sections);
+			image->sections = malloc(sizeof(struct image_section) * image->num_sections);
 			for (i = 0; i < image->num_sections; i++)
 			{
 				image->sections[i].private = section[i].private;
@@ -252,6 +261,12 @@ static int image_ihex_buffer_complete(image_t *image)
 				if (section[image->num_sections].size != 0)
 				{
 					image->num_sections++;
+					if (image->num_sections >= IMAGE_MAX_SECTIONS)
+					{
+						/* too many sections */
+						LOG_ERROR("Too many sections found in IHEX file");
+						return ERROR_IMAGE_FORMAT_ERROR;
+					}
 					section[image->num_sections].size = 0x0;
 					section[image->num_sections].flags = 0;
 					section[image->num_sections].private = &ihex->buffer[cooked_bytes];
@@ -292,6 +307,12 @@ static int image_ihex_buffer_complete(image_t *image)
 				if (section[image->num_sections].size != 0)
 				{
 					image->num_sections++;
+					if (image->num_sections >= IMAGE_MAX_SECTIONS)
+					{
+						/* too many sections */
+						LOG_ERROR("Too many sections found in IHEX file");
+						return ERROR_IMAGE_FORMAT_ERROR;
+					}
 					section[image->num_sections].size = 0x0;
 					section[image->num_sections].flags = 0;
 					section[image->num_sections].private = &ihex->buffer[cooked_bytes];
@@ -418,7 +439,7 @@ static int image_elf_read_headers(image_t *image)
 		if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
 			image->num_sections++;
 	/* alloc and fill sections array with loadable segments */
-	image->sections = malloc(image->num_sections * sizeof(image_section_t));
+	image->sections = malloc(image->num_sections * sizeof(struct image_section));
 	for (i = 0,j = 0;i < elf->segment_count;i++)
 	{
 		if ((field32(elf, elf->segments[i].p_type) == PT_LOAD) && (field32(elf, elf->segments[i].p_filesz) != 0))
@@ -480,8 +501,8 @@ static int image_elf_read_section(image_t *image, int section, uint32_t offset,
 
 static int image_mot_buffer_complete(image_t *image)
 {
-	image_mot_t *mot = image->type_private;
-	fileio_t *fileio = &mot->fileio;
+	struct image_mot *mot = image->type_private;
+	struct fileio *fileio = &mot->fileio;
 	uint32_t full_address = 0x0;
 	uint32_t cooked_bytes;
 	int i;
@@ -489,7 +510,7 @@ static int image_mot_buffer_complete(image_t *image)
 
 	/* we can't determine the number of sections that we'll have to create ahead of time,
 	 * so we locally hold them until parsing is finished */
-	image_section_t section[IMAGE_MAX_SECTIONS];
+	struct image_section section[IMAGE_MAX_SECTIONS];
 
 	mot->buffer = malloc(fileio->size >> 1);
 	cooked_bytes = 0x0;
@@ -614,7 +635,7 @@ static int image_mot_buffer_complete(image_t *image)
 			image->num_sections++;
 
 			/* copy section information */
-			image->sections = malloc(sizeof(image_section_t) * image->num_sections);
+			image->sections = malloc(sizeof(struct image_section) * image->num_sections);
 			for (i = 0; i < image->num_sections; i++)
 			{
 				image->sections[i].private = section[i].private;
@@ -648,7 +669,7 @@ static int image_mot_buffer_complete(image_t *image)
 	return ERROR_IMAGE_FORMAT_ERROR;
 }
 
-int image_open(image_t *image, char *url, char *type_string)
+int image_open(image_t *image, const char *url, const char *type_string)
 {
 	int retval = ERROR_OK;
 
@@ -659,9 +680,9 @@ int image_open(image_t *image, char *url, char *type_string)
 
 	if (image->type == IMAGE_BINARY)
 	{
-		image_binary_t *image_binary;
+		struct image_binary *image_binary;
 
-		image_binary = image->type_private = malloc(sizeof(image_binary_t));
+		image_binary = image->type_private = malloc(sizeof(struct image_binary));
 
 		if ((retval = fileio_open(&image_binary->fileio, url, FILEIO_READ, FILEIO_BINARY)) != ERROR_OK)
 		{
@@ -669,16 +690,16 @@ int image_open(image_t *image, char *url, char *type_string)
 		}
 
 		image->num_sections = 1;
-		image->sections = malloc(sizeof(image_section_t));
+		image->sections = malloc(sizeof(struct image_section));
 		image->sections[0].base_address = 0x0;
 		image->sections[0].size = image_binary->fileio.size;
 		image->sections[0].flags = 0;
 	}
 	else if (image->type == IMAGE_IHEX)
 	{
-		image_ihex_t *image_ihex;
+		struct image_ihex *image_ihex;
 
-		image_ihex = image->type_private = malloc(sizeof(image_ihex_t));
+		image_ihex = image->type_private = malloc(sizeof(struct image_ihex));
 
 		if ((retval = fileio_open(&image_ihex->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
 		{
@@ -719,15 +740,15 @@ int image_open(image_t *image, char *url, char *type_string)
 			return ERROR_FAIL;
 		}
 
-		image_memory_t *image_memory;
+		struct image_memory *image_memory;
 
 		image->num_sections = 1;
-		image->sections = malloc(sizeof(image_section_t));
+		image->sections = malloc(sizeof(struct image_section));
 		image->sections[0].base_address = 0x0;
 		image->sections[0].size = 0xffffffff;
 		image->sections[0].flags = 0;
 
-		image_memory = image->type_private = malloc(sizeof(image_memory_t));
+		image_memory = image->type_private = malloc(sizeof(struct image_memory));
 
 		image_memory->target = target;
 		image_memory->cache = NULL;
@@ -735,9 +756,9 @@ int image_open(image_t *image, char *url, char *type_string)
 	}
 	else if (image->type == IMAGE_SRECORD)
 	{
-		image_mot_t *image_mot;
+		struct image_mot *image_mot;
 
-		image_mot = image->type_private = malloc(sizeof(image_mot_t));
+		image_mot = image->type_private = malloc(sizeof(struct image_mot));
 
 		if ((retval = fileio_open(&image_mot->fileio, url, FILEIO_READ, FILEIO_TEXT)) != ERROR_OK)
 		{
@@ -790,7 +811,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si
 
 	if (image->type == IMAGE_BINARY)
 	{
-		image_binary_t *image_binary = image->type_private;
+		struct image_binary *image_binary = image->type_private;
 
 		/* only one section in a plain binary */
 		if (section != 0)
@@ -821,7 +842,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si
 	}
 	else if (image->type == IMAGE_MEMORY)
 	{
-		image_memory_t *image_memory = image->type_private;
+		struct image_memory *image_memory = image->type_private;
 		uint32_t address = image->sections[section].base_address + offset;
 
 		*size_read = 0;
@@ -878,7 +899,7 @@ int image_read_section(image_t *image, int section, uint32_t offset, uint32_t si
 
 int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, uint8_t *data)
 {
-	image_section_t *section;
+	struct image_section *section;
 
 	/* only image builder supports adding sections */
 	if (image->type != IMAGE_BUILDER)
@@ -902,7 +923,7 @@ int image_add_section(image_t *image, uint32_t base, uint32_t size, int flags, u
 
 	/* allocate new section */
 	image->num_sections++;
-	image->sections = realloc(image->sections, sizeof(image_section_t) * image->num_sections);
+	image->sections = realloc(image->sections, sizeof(struct image_section) * image->num_sections);
 	section = &image->sections[image->num_sections - 1];
 	section->base_address = base;
 	section->size = size;
@@ -917,13 +938,13 @@ void image_close(image_t *image)
 {
 	if (image->type == IMAGE_BINARY)
 	{
-		image_binary_t *image_binary = image->type_private;
+		struct image_binary *image_binary = image->type_private;
 
 		fileio_close(&image_binary->fileio);
 	}
 	else if (image->type == IMAGE_IHEX)
 	{
-		image_ihex_t *image_ihex = image->type_private;
+		struct image_ihex *image_ihex = image->type_private;
 
 		fileio_close(&image_ihex->fileio);
 
@@ -953,7 +974,7 @@ void image_close(image_t *image)
 	}
 	else if (image->type == IMAGE_MEMORY)
 	{
-		image_memory_t *image_memory = image->type_private;
+		struct image_memory *image_memory = image->type_private;
 
 		if (image_memory->cache)
 		{
@@ -963,7 +984,7 @@ void image_close(image_t *image)
 	}
 	else if (image->type == IMAGE_SRECORD)
 	{
-		image_mot_t *image_mot = image->type_private;
+		struct image_mot *image_mot = image->type_private;
 
 		fileio_close(&image_mot->fileio);