add support sparse attribute

Author: bmx666

Makefile

@@ -6,7 +6,7 @@ CFLAGS += -O2 -Wall -g `pkg-config --cflags libxml-2.0 libusb-1.0`
 LDFLAGS += `pkg-config --libs libxml-2.0 libusb-1.0`
 prefix := /usr/local
 
-QDL_SRCS := firehose.c qdl.c sahara.c util.c patch.c program.c read.c ufs.c usb.c ux.c
+QDL_SRCS := firehose.c qdl.c sahara.c util.c patch.c program.c read.c ufs.c usb.c ux.c sparse.c
 QDL_OBJS := $(QDL_SRCS:.c=.o)
 
 RAMDUMP_SRCS := ramdump.c sahara.c usb.c util.c ux.c

firehose.c

@@ -50,6 +50,7 @@
 #include <unistd.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
+#include "sparse.h"
 #include "qdl.h"
 #include "ufs.h"
 
@@ -359,21 +360,24 @@ static int firehose_program(struct qdl_device *qdl, struct program *program, int
 	int left;
 	int ret;
 	int n;
+	uint32_t fill_value;
 
 	num_sectors = program->num_sectors;
 
 	ret = fstat(fd, &sb);
 	if (ret < 0)
 		err(1, "failed to stat \"%s\"\n", program->filename);
 
-	num_sectors = (sb.st_size + program->sector_size - 1) / program->sector_size;
+	if (!program->sparse) {
+		num_sectors = (sb.st_size + program->sector_size - 1) / program->sector_size;
 
-	if (program->num_sectors && num_sectors > program->num_sectors) {
-		ux_err("%s to big for %s truncated to %d\n",
-			program->filename,
-			program->label,
-			program->num_sectors * program->sector_size);
-		num_sectors = program->num_sectors;
+		if (program->num_sectors && num_sectors > program->num_sectors) {
+			ux_err("%s to big for %s truncated to %d\n",
+				program->filename,
+				program->label,
+				program->num_sectors * program->sector_size);
+			num_sectors = program->num_sectors;
+		}
 	}
 
 	buf = malloc(max_payload_size);
@@ -411,19 +415,38 @@ static int firehose_program(struct qdl_device *qdl, struct program *program, int
 
 	t0 = time(NULL);
 
-	lseek(fd, (off_t) program->file_offset * program->sector_size, SEEK_SET);
+	if (!program->sparse)
+		lseek(fd, (off_t) program->file_offset * program->sector_size, SEEK_SET);
+	else {
+		switch (program->sparse_chunk_type) {
+			case CHUNK_TYPE_RAW:
+				lseek(fd, (off_t) program->sparse_chunk_data, SEEK_SET);
+				break;
+			case CHUNK_TYPE_FILL:
+				fill_value = (uint32_t) program->sparse_chunk_data;
+				for (n = 0; n < max_payload_size; n += sizeof(fill_value))
+					memcpy(buf + n, &fill_value, sizeof(fill_value));
+				break;
+			default:
+				fprintf(stderr, "[SPARSE] invalid chunk type\n");
+				goto out;
+		}
+	}
+
 	left = num_sectors;
 	while (left > 0) {
 		chunk_size = MIN(max_payload_size / program->sector_size, left);
 
-		n = read(fd, buf, chunk_size * program->sector_size);
-		if (n < 0) {
-			ux_err("failed to read %s\n", program->filename);
-			goto out;
-		}
+		if (!program->sparse || program->sparse_chunk_type != CHUNK_TYPE_FILL) {
+			n = read(fd, buf, chunk_size * program->sector_size);
+			if (n < 0) {
+				ux_err("failed to read %s\n", program->filename);
+				goto out;
+			}
 
-		if (n < max_payload_size)
-			memset(buf + n, 0, max_payload_size - n);
+			if (n < max_payload_size)
+				memset(buf + n, 0, max_payload_size - n);
+		}
 
 		n = qdl_write(qdl, buf, chunk_size * program->sector_size);
 		if (n < 0) {

program.c

@@ -38,6 +38,7 @@
 
 #include "program.h"
 #include "qdl.h"
+#include "sparse.h"
 
 static struct program *programes;
 static struct program *programes_last;
@@ -80,6 +81,90 @@ static int load_erase_tag(xmlNode *node, bool is_nand)
 	return 0;
 }
 
+static struct program *program_load_sparse(struct program *program, int fd)
+{
+	struct program *program_sparse = NULL;
+	struct program *programes_sparse = NULL;
+	struct program *programes_sparse_last = NULL;
+	char tmp[PATH_MAX];
+
+	sparse_header_t sparse_header;
+	unsigned start_sector, chunk_size, chunk_type, chunk_data;
+
+	if (sparse_header_parse(fd, &sparse_header)) {
+		/* ignore false sparse images */
+		if (program->sector_size * program->num_sectors == lseek(fd, 0, SEEK_END)) {
+			program_sparse = calloc(1, sizeof(struct program));
+			memcpy(program_sparse, program, sizeof(struct program));
+			program_sparse->sparse = false;
+			program_sparse->next = NULL;
+			return program_sparse;
+		}
+
+		fprintf(stderr, "[PROGRAM] Unable to parse sparse header at %s...failed\n",
+				program->filename);
+		return NULL;
+	}
+
+	for (uint32_t i = 0; i < sparse_header.total_chunks; ++i) {
+
+		chunk_type = sparse_chunk_header_parse(fd, &sparse_header, &chunk_size, &chunk_data);
+
+		switch (chunk_type) {
+			case CHUNK_TYPE_RAW:
+			case CHUNK_TYPE_FILL:
+			case CHUNK_TYPE_DONT_CARE:
+				break;
+			default:
+				fprintf(stderr, "[PROGRAM] Unable to parse sparse chunk %i at %s...failed\n",
+						i, program->filename);
+				return NULL;
+		}
+
+		if (chunk_size == 0)
+			continue;
+
+		if (chunk_size % program->sector_size != 0) {
+			fprintf(stderr, "[SPARSE] File chunk #%u size %u is not a sector-multiple\n",
+					i, chunk_size);
+			return NULL;
+		}
+
+		switch (chunk_type) {
+			case CHUNK_TYPE_RAW:
+			case CHUNK_TYPE_FILL:
+
+				program_sparse = calloc(1, sizeof(struct program));
+				memcpy(program_sparse, program, sizeof(struct program));
+
+				program_sparse->next = NULL;
+				program_sparse->num_sectors = chunk_size / program->sector_size;
+
+				program_sparse->sparse_chunk_type = chunk_type;
+				program_sparse->sparse_chunk_data = chunk_data;
+
+				if (programes_sparse) {
+					programes_sparse_last->next = program_sparse;
+					programes_sparse_last = program_sparse;
+				} else {
+					programes_sparse = program_sparse;
+					programes_sparse_last = program_sparse;
+				}
+
+				break;
+			default:
+				break;
+		}
+
+		start_sector = (unsigned int) strtoul(program->start_sector, NULL, 0);
+		start_sector += chunk_size / program->sector_size;
+		sprintf(tmp, "%u", start_sector);
+		program->start_sector = strdup(tmp);
+	}
+
+	return programes_sparse;
+}
+
 static int load_program_tag(xmlNode *node, bool is_nand)
 {
 	struct program *program;
@@ -164,6 +249,7 @@ int program_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl,
 		    const char *incdir, bool allow_missing)
 {
 	struct program *program;
+	struct program *program_sparse;
 	const char *filename;
 	char tmp[PATH_MAX];
 	int ret;
@@ -192,7 +278,21 @@ int program_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl,
 			continue;
 		}
 
-		ret = apply(qdl, program, fd);
+		if (!program->sparse) {
+			ret = apply(qdl, program, fd);
+		} else {
+			program_sparse = program_load_sparse(program, fd);
+			if (!program_sparse) {
+				fprintf(stderr, "[PROGRAM] load sparse failed\n");
+				return -EINVAL;
+			}
+
+			for (; program_sparse; program_sparse = program_sparse->next) {
+				ret = apply(qdl, program_sparse, fd);
+				if (ret)
+					break;
+			}
+		}
 
 		close(fd);
 		if (ret)

program.h

@@ -19,6 +19,9 @@ struct program {
 	bool is_nand;
 	bool is_erase;
 
+	unsigned sparse_chunk_type;
+	unsigned sparse_chunk_data;
+
 	struct program *next;
 };
 

sparse.c

@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 2016, Bjorn Andersson <[email protected]>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. 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.
+ *
+ * 3. Neither the name of the copyright holder 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.
+ */
+#define _FILE_OFFSET_BITS 64
+#include <arpa/inet.h>
+#include <ctype.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "sparse.h"
+
+int sparse_header_parse(int fd, sparse_header_t* sparse_header)
+{
+	lseek(fd, 0, SEEK_SET);
+
+	if (read(fd, sparse_header, sizeof(sparse_header_t)) != sizeof(sparse_header_t)) {
+		fprintf(stderr, "[SPARSE] Unable to read sparse header\n");
+		return -EINVAL;
+	}
+
+	if (ntohl(sparse_header->magic) != ntohl(SPARSE_HEADER_MAGIC)) {
+		fprintf(stderr, "[SPARSE] Invalid magic in sparse header\n");
+		return -EINVAL;
+	}
+
+	if (ntohs(sparse_header->major_version) != ntohs(SPARSE_HEADER_MAJOR_VER)) {
+		fprintf(stderr, "[SPARSE] Invalid major version in sparse header\n");
+		return -EINVAL;
+	}
+
+	if (ntohs(sparse_header->minor_version) != ntohs(SPARSE_HEADER_MINOR_VER)) {
+		fprintf(stderr, "[SPARSE] Invalid minor version in sparse header\n");
+		return -EINVAL;
+	}
+
+	if (sparse_header->file_hdr_sz > sizeof(sparse_header_t))
+		lseek(fd, sparse_header->file_hdr_sz - sizeof(sparse_header_t), SEEK_CUR);
+
+	return 0;
+}
+
+int sparse_chunk_header_parse(int fd, sparse_header_t* sparse_header, unsigned *chunk_size, unsigned *value)
+{
+	chunk_header_t chunk_header;
+	uint32_t fill_value = 0;
+
+	*chunk_size = 0;
+	*value = 0;
+
+	if (read(fd, &chunk_header, sizeof(chunk_header_t)) != sizeof(chunk_header_t)) {
+		fprintf(stderr, "[SPARSE] Unable to read sparse chunk header\n");
+		return -EINVAL;
+	}
+
+	if (sparse_header->chunk_hdr_sz > sizeof(chunk_header_t))
+		lseek(fd, sparse_header->chunk_hdr_sz - sizeof(chunk_header_t), SEEK_CUR);
+
+	if (ntohs(chunk_header.chunk_type) == ntohs(CHUNK_TYPE_RAW)) {
+
+		*chunk_size = chunk_header.chunk_sz * sparse_header->blk_sz;
+
+		if (chunk_header.total_sz != (sparse_header->chunk_hdr_sz + *chunk_size)) {
+			fprintf(stderr, "[SPARSE] Bogus chunk size, type Raw\n");
+			return -EINVAL;
+		}
+
+		/* Save the current file offset in the 'value' variable */
+		*value = lseek(fd, 0, SEEK_CUR);
+
+		/* Move the file cursor forward by the size of the chunk */
+		lseek(fd, *chunk_size, SEEK_CUR);
+
+		return CHUNK_TYPE_RAW;
+	}
+	else if (ntohs(chunk_header.chunk_type) == ntohs(CHUNK_TYPE_DONT_CARE)) {
+
+		*chunk_size = chunk_header.chunk_sz * sparse_header->blk_sz;
+
+		if (chunk_header.total_sz != sparse_header->chunk_hdr_sz) {
+			fprintf(stderr, "[SPARSE] Bogus chunk size, type Don't Care\n");
+			return -EINVAL;
+		}
+
+		return CHUNK_TYPE_DONT_CARE;
+	}
+	else if (ntohs(chunk_header.chunk_type) == ntohs(CHUNK_TYPE_FILL)) {
+
+		*chunk_size = chunk_header.chunk_sz * sparse_header->blk_sz;
+
+		if (chunk_header.total_sz != (sparse_header->chunk_hdr_sz + sizeof(fill_value))) {
+			fprintf(stderr, "[SPARSE] Bogus chunk size, type Fill\n");
+			return -EINVAL;
+		}
+
+		if (read(fd, &fill_value, sizeof(fill_value)) != sizeof(fill_value)) {
+			fprintf(stderr, "[SPARSE] Unable to read fill value\n");
+			return -EINVAL;
+		}
+
+		/* Save the current fill value in the 'value' variable */
+		*value = ntohl(fill_value);
+
+		return CHUNK_TYPE_FILL;
+	}
+
+	fprintf(stderr, "[SPARSE] Unknown chunk\n");
+	return -EINVAL;
+}