path: root/ubi-utils/src/unubi.c

/*
 * Copyright (c) International Business Machines Corp., 2006, 2007
 *
 * 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, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*
 * Authors: Drake Dowsett, dowsett@de.ibm.com
 *          Frank Haverkamp, haver@vnet.ibm.com
 *
 * 1.2 Removed argp because we want to use uClibc.
 * 1.3 Minor cleanups.
 * 1.4 Meanwhile Drake had done a lot of changes, syncing those.
 * 1.5 Bugfixes, simplifications
 */

/*
 * unubi  reads  an  image  file containing blocks of UBI headers and data
 * (such as produced from nand2bin) and rebuilds the volumes within.   The
 * default  operation  (when  no  flags are given) is to rebuild all valid
 * volumes found in the image. unubi  can  also  read  straight  from  the
 * onboard MTD device (ex. /dev/mtdblock/NAND).
 */

/* TODO: consideration for dynamic vs. static volumes */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdint.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <mtd/ubi-header.h>

#include "crc32.h"
#include "unubi_analyze.h"

#define EXEC		"unubi"
#define CONTACT		"haver@vnet.ibm.com"
#define VERSION		"1.5"

static char doc[] = "\nVersion: " VERSION "\n";
static int debug = 0;

static const char *optionsstr =
"Extract volumes and/or analysis information from an UBI data file.\n"
"When no parameters are flagged or given, the default operation is\n"
"to rebuild all valid complete UBI volumes found within the image.\n"
"\n"
" OPERATIONS\n"
"  -a, --analyze              Analyze image and create gnuplot graphs\n"
"  -i, --info-table           Extract volume information tables\n"
"  -r, --rebuild=<volume-id>  Extract and rebuild volume\n"
"\n"
" OPTIONS\n"
"  -b, --blocksize=<block-size>   Specify size of eraseblocks in image in bytes\n"
"                             (default 128KiB)\n"
"  -d, --dir=<output-dir>     Specify output directory\n"
"  -D, --debug                Enable debug output\n"
"  -s, --headersize=<header-size>   Specify size reserved for metadata in eraseblock\n"
	"                             in bytes (default 2048 Byte)\n"
 /* the -s option might be insufficient when using different vid
    offset than what we used when writing this tool ... Better would
    probably be --vid-hdr-offset or alike */
"\n"
" ADVANCED\n"
"  -e, --eb-split             Generate individual eraseblock images (all\n"
"                             eraseblocks)\n"
"  -v, --vol-split            Generate individual eraseblock images (valid\n"
"                             eraseblocks only)\n"
"  -V, --vol-split!           Raw split by eraseblock (valid eraseblocks only)\n"
"\n"
"  -?, --help                 Give this help list\n"
"      --usage                Give a short usage message\n"
"      --version              Print program version\n"
"\n";

static const char *usage =
"Usage: unubi [-aievV?] [-r <volume-id>] [-b <block-size>] [-d <output-dir>]\n"
"            [-s <header-size>] [--analyze] [--info-table]\n"
"            [--rebuild=<volume-id>] [--blocksize=<block-size>]\n"
"            [--dir=<output-dir>] [--headersize=<header-size>] [--eb-split]\n"
"            [--vol-split] [--vol-split!] [--help] [--usage] [--version]\n"
"            image-file\n";

#define ERR_MSG(fmt...)							\
	fprintf(stderr, EXEC ": " fmt)

#define SPLIT_DATA	1
#define SPLIT_RAW	2

#define DIR_FMT		"unubi_%s"
#define KIB		1024
#define MIB		(KIB * KIB)
#define MAXPATH		KIB

/* filenames */
#define FN_INVAL	"%s/eb%04u%s"			/* invalid eraseblock */
#define FN_NSURE	"%s/eb%04u_%03u_%03u_%03x%s"	/* unsure eraseblock */
#define FN_VALID	"%s/eb%04u_%03u_%03u_%03x%s"	/* valid eraseblock */
#define FN_VOLSP	"%s/vol%03u_%03u_%03u_%04u"	/* split volume */
#define FN_VOLWH	"%s/volume%03u"			/* whole volume */
#define FN_VITBL	"%s/vol_info_table%u"		/* vol info table */

static uint32_t crc32_table[256];

/* struct args:
 *	bsize		int, blocksize of image blocks
 *	hsize		int, eraseblock header size
 *	analyze		flag, when non-zero produce analysis
 *	eb_split	flag, when non-zero output eb####
 *			note: SPLIT_DATA vs. SPLIT_RAW
 *	vol_split	flag, when non-zero output vol###_####
 *			note: SPLIT_DATA vs. SPLIT_RAW
 *	odir_path	string, directory to place volumes in
 *	img_path	string, file to read as ubi image
 *	vols		int array of size UBI_MAX_VOLUMES, where a 1 can be
 *			written for each --rebuild flag in the index specified
 *			then the array can be counted and collapsed using
 *			count_set() and collapse()
 */
struct args {
	int analyze;
	int itable;
	uint32_t *vols;

	size_t vid_hdr_offset;
	size_t data_offset;
	size_t bsize;		/* FIXME replace by vid_hdr/data offs? */
	size_t hsize;

	char *odir_path;
	int eb_split;
	int vol_split;
	char *img_path;

	char **options;
};

struct option long_options[] = {
	{ .name = "rebuild", .has_arg = 1, .flag = NULL, .val = 'r' },
	{ .name = "dir", .has_arg = 1, .flag = NULL, .val = 'd' },
	{ .name = "analyze", .has_arg = 0, .flag = NULL, .val = 'a' },
	{ .name = "blocksize", .has_arg = 1, .flag = NULL, .val = 'b' },
	{ .name = "eb-split", .has_arg = 0, .flag = NULL, .val = 'e' },
	{ .name = "vol-split", .has_arg = 0, .flag = NULL, .val = 'v' },
	{ .name = "vol-split!", .has_arg = 0, .flag = NULL, .val = 'e' },
	{ .name = "help", .has_arg = 0, .flag = NULL, .val = '?' },
	{ .name = "usage", .has_arg = 0, .flag = NULL, .val = 0 },
	{ .name = "version", .has_arg = 0, .flag = NULL, .val = 'J' },
	{ NULL, 0, NULL, 0}
};

/**
 * parses out a numerical value from a string of numbers followed by:
 *	k, K, kib, KiB for kibibyte
 *	m, M, mib, MiB for mebibyte
 **/
static uint32_t
str_to_num(char *str)
{
	char *s;
	ulong num;

	s = str;
	num = strtoul(s, &s, 0);

	if (*s != '\0') {
		if ((strcmp(s, "KiB") == 0) || (strcmp(s, "K") == 0) ||
		    (strcmp(s, "kib") == 0) || (strcmp(s, "k") == 0))
			num *= KIB;
		else if ((strcmp(s, "MiB") == 0) || (strcmp(s, "M") == 0) ||
		    (strcmp(s, "mib") == 0) || (strcmp(s, "m") == 0))
			num *= MIB;
		else
			ERR_MSG("couldn't parse '%s', assuming %lu\n",
				s, num);
	}
	return num;
}

static int
parse_opt(int argc, char **argv, struct args *args)
{
	uint32_t i;

	while (1) {
		int key;

		key = getopt_long(argc, argv, "ab:s:d:Deir:vV?J",
				  long_options, NULL);
		if (key == -1)
			break;

		switch (key) {
		case 'a': /* --analyze */
			args->analyze = 1;
			break;
		case 'b': /* --block-size=<block-size> */
			args->bsize = str_to_num(optarg);
			break;
		case 's': /* --header-size=<header-size> */
			args->hsize = str_to_num(optarg);
			break;
		case 'd': /* --dir=<output-dir> */
			args->odir_path = optarg;
			break;
		case 'D': /* --debug */
			/* I wanted to use -v but that was already
			   used ... */
			debug = 1;
			break;
		case 'e': /* --eb-split */
			args->eb_split = SPLIT_RAW;
			break;
		case 'i': /* --info-table */
			args->itable = 1;
			break;
		case 'r': /* --rebuild=<volume-id> */
			i = str_to_num(optarg);
			if (i < UBI_MAX_VOLUMES)
				args->vols[str_to_num(optarg)] = 1;
			else {
				ERR_MSG("volume-id out of bounds\n");
				return -1;
			}
			break;
		case 'v': /* --vol-split */
			if (args->vol_split != SPLIT_RAW)
				args->vol_split = SPLIT_DATA;
			break;
		case 'V': /* --vol-split! */
			args->vol_split = SPLIT_RAW;
			break;
		case '?': /* help */
			fprintf(stderr,	"Usage: unubi [OPTION...] "
				"image-file\n%s%s\nReport bugs to %s\n",
				doc, optionsstr, CONTACT);
			exit(0);
			break;
		case 'J':
			fprintf(stderr, "%s\n", VERSION);
			exit(0);
			break;
		default:
			fprintf(stderr, "%s", usage);
			exit(-1);
		}
	}

	/* FIXME I suppose hsize should be replaced! */
	args->vid_hdr_offset = args->hsize - UBI_VID_HDR_SIZE;
	args->data_offset = args->hsize;

	if (optind < argc)
		args->img_path = argv[optind++];
	return 0;
}


/**
 * counts the number of indicies which are flagged in full_array;
 * full_array is an array of flags (1/0);
 **/
static size_t
count_set(uint32_t *full_array, size_t full_len)
{
	size_t count, i;

	if (full_array == NULL)
		return 0;

	for (i = 0, count = 0; i < full_len; i++)
		if (full_array[i] != 0)
			count++;

	return count;
}


/**
 * generates coll_array from full_array;
 * full_array is an array of flags (1/0);
 * coll_array is an array of the indicies in full_array which are flagged (1);
 **/
static size_t
collapse(uint32_t *full_array, size_t full_len,
	 uint32_t *coll_array, size_t coll_len)
{
	size_t i, j;

	if ((full_array == NULL) || (coll_array == NULL))
		return 0;

	for (i = 0, j = 0; (i < full_len) && (j < coll_len); i++)
		if (full_array[i] != 0) {
			coll_array[j] = i;
			j++;
		}

	return j;
}

/**
 * data_crc: save the FILE* position, calculate the crc over a span,
 *	reset the position
 * returns non-zero when EOF encountered
 **/
static int
data_crc(FILE* fpin, size_t length, uint32_t *ret_crc)
{
	int rc;
	size_t i;
	char buf[length];
	uint32_t crc;
	fpos_t start;

	rc = fgetpos(fpin, &start);
	if (rc < 0)
		return -1;

	for (i = 0; i < length; i++) {
		int c = fgetc(fpin);
		if (c == EOF) {
			ERR_MSG("unexpected EOF\n");
			return -1;
		}
		buf[i] = (char)c;
	}

	rc = fsetpos(fpin, &start);
	if (rc < 0)
		return -1;

	crc = clc_crc32(crc32_table, UBI_CRC32_INIT, buf, length);
	*ret_crc = crc;
	return 0;
}


/**
 * reads data of size len from fpin and writes it to path
 **/
static int
extract_data(FILE* fpin, size_t len, const char *path)
{
	int rc;
	size_t i;
	FILE* fpout;

	rc = 0;
	fpout = NULL;

	fpout = fopen(path, "wb");
	if (fpout == NULL) {
		ERR_MSG("couldn't open file for writing: %s\n", path);
		rc = -1;
		goto err;
	}

	for (i = 0; i < len; i++) {
		int c = fgetc(fpin);
		if (c == EOF) {
			ERR_MSG("unexpected EOF while writing: %s\n", path);
			rc = -2;
			goto err;
		}
		c = fputc(c, fpout);
		if (c == EOF) {
			ERR_MSG("couldn't write: %s\n", path);
			rc = -3;
			goto err;
		}
	}

 err:
	if (fpout != NULL)
		fclose(fpout);
	return rc;
}


/**
 * extract volume information table from block. saves and reloads fpin
 * position
 * returns -1 when a fpos set or get fails, otherwise <= -2 on other
 * failure and 0 on success
 **/
static int
extract_itable(FILE *fpin, struct eb_info *cur, size_t bsize, size_t num,
	       const char *path)
{
	char filename[MAXPATH + 1];
	int rc;
	size_t i, max;
	fpos_t temp;
	FILE* fpout = NULL;
	struct ubi_vol_tbl_record rec;

	if (fpin == NULL || cur == NULL || path == NULL)
		return -2;

	/* remember position */
	rc = fgetpos(fpin, &temp);
	if (rc < 0)
		return -1;

	/* jump to top of eraseblock, skip to data section */
	fsetpos(fpin, &cur->eb_top);
	if (rc < 0)
		return -1;
	fseek(fpin, ubi32_to_cpu(cur->ec.data_offset), SEEK_CUR);

	/* prepare output file */
	if (ubi32_to_cpu(cur->vid.vol_id) != UBI_LAYOUT_VOL_ID)
		return -2;
	memset(filename, 0, MAXPATH + 1);
	snprintf(filename, MAXPATH, FN_VITBL, path, num);
	fpout = fopen(filename, "w");
	if (fpout == NULL)
		return -2;

	/* loop through entries */
	fprintf(fpout,
		"index\trpebs\talign\ttype\tcrc\t\tname\n");
	max = bsize - ubi32_to_cpu(cur->ec.data_offset);
	for (i = 0; i < (max / sizeof(rec)); i++) {
		int blank = 1;
		char *ptr, *base;
		char name[UBI_VOL_NAME_MAX + 1];
		const char *type = "unknown\0";
		uint32_t crc;

		/* read record */
		rc = fread(&rec, 1, sizeof(rec), fpin);
		if (rc == 0)
			break;
		if (rc != sizeof(rec)) {
			ERR_MSG("reading volume information "
				"table record failed\n");
			rc = -3;
			goto exit;
		}

		/* check crc */
		crc = clc_crc32(crc32_table, UBI_CRC32_INIT, &rec,
				UBI_VTBL_RECORD_SIZE_CRC);
		if (crc != ubi32_to_cpu(rec.crc))
			continue;

		/* check for empty */
		base = (char *)&rec;
		ptr = base;
		while (blank &&
		       ((unsigned)(ptr - base) < UBI_VTBL_RECORD_SIZE_CRC)) {
			if (*ptr != 0)
				blank = 0;
			ptr++;
		}

		if (blank)
			continue;

		/* prep type string */
		if (rec.vol_type == UBI_VID_DYNAMIC)
			type = "dynamic\0";
		else if (rec.vol_type == UBI_VID_STATIC)
			type = "static\0";

		/* prep name string */
		rec.name[ubi16_to_cpu(rec.name_len)] = '\0';
		sprintf(name, "%s", rec.name);

		/* print record line to fpout */
		fprintf(fpout, "%u\t%u\t%u\t%s\t0x%08x\t%s\n",
			i,
			ubi32_to_cpu(rec.reserved_pebs),
			ubi32_to_cpu(rec.alignment),
			type,
			ubi32_to_cpu(rec.crc),
			name);
	}

 exit:
	/* reset position */
	if (fsetpos(fpin, &temp) < 0)
		rc = -1;

	if (fpout != NULL)
		fclose(fpout);

	return rc;
}


/**
 * using eb chain, tries to rebuild the data of volume at vol_id, or for all
 * the known volumes, if vol_id is NULL;
 **/
static int
rebuild_volume(FILE * fpin, uint32_t *vol_id, struct eb_info **head,
	       const char *path, size_t block_size, size_t header_size)
{
	char filename[MAXPATH];
	int rc;
	uint32_t vol, num, data_size;
	FILE* fpout;
	struct eb_info *cur;

	rc = 0;

	if ((fpin == NULL) || (head == NULL) || (*head == NULL))
		return 0;

	/* when vol_id is null, then do all  */
	if (vol_id == NULL) {
		cur = *head;
		vol = ubi32_to_cpu(cur->vid.vol_id);
	} else {
		vol = *vol_id;
		eb_chain_position(head, vol, NULL, &cur);
		if (cur == NULL) {
			if (debug)
				ERR_MSG("no valid volume %d was found\n", vol);
			return -1;
		}
	}

	num = 0;
	snprintf(filename, MAXPATH, FN_VOLWH, path, vol);
	fpout = fopen(filename, "wb");
	if (fpout == NULL) {
		ERR_MSG("couldn't open file for writing: %s\n", filename);
		return -1;
	}

	while (cur != NULL) {
		size_t i;

		if (ubi32_to_cpu(cur->vid.vol_id) != vol) {
			/* close out file */
			fclose(fpout);

			/* only stay around if that was the only volume */
			if (vol_id != NULL)
				goto out;

			/* begin with next */
			vol = ubi32_to_cpu(cur->vid.vol_id);
			num = 0;
			snprintf(filename, MAXPATH, FN_VOLWH, path, vol);
			fpout = fopen(filename, "wb");
			if (fpout == NULL) {
				ERR_MSG("couldn't open file for writing: %s\n",
					filename);
				return -1;
			}
		}

		while (num < ubi32_to_cpu(cur->vid.lnum)) {
			/* FIXME haver: I hope an empty block is
			   written out so that the binary has no holes
			   ... */
			if (debug)
				ERR_MSG("missing valid block %d for volume %d\n",
					num, vol);
			num++;
		}

		rc = fsetpos(fpin, &(cur->eb_top));
		if (rc < 0)
			goto out;
		fseek(fpin, ubi32_to_cpu(cur->ec.data_offset), SEEK_CUR);

		if (cur->vid.vol_type == UBI_VID_DYNAMIC)
			/* FIXME It might be that alignment has influence */
			data_size = block_size - header_size;
		else
			data_size = ubi32_to_cpu(cur->vid.data_size);

		for (i = 0; i < data_size; i++) {
			int c = fgetc(fpin);
			if (c == EOF) {
				ERR_MSG("unexpected EOF while writing: %s\n",
					filename);
				rc = -2;
				goto out;
			}
			c = fputc(c, fpout);
			if (c == EOF) {
				ERR_MSG("couldn't write: %s\n", filename);
				rc = -3;
				goto out;
			}
		}

		cur = cur->next;
		num++;
	}

 out:
	if (vol_id == NULL)
		fclose(fpout);
	return rc;
}


/**
 * traverses FILE* trying to load complete, valid and accurate header data
 * into the eb chain;
 **/
static int
unubi_volumes(FILE* fpin, uint32_t *vols, size_t vc, struct args *a)
{
	char filename[MAXPATH + 1];
	char reason[MAXPATH + 1];
	int rc;
	size_t i, count, itable_num;
	/* relations:
	 * cur ~ head
	 * next ~ first */
	struct eb_info *head, *cur, *first, *next;
	struct eb_info **next_ptr;

	rc = 0;
	count = 0;
	itable_num = 0;
	head = NULL;
	first = NULL;
	next = NULL;
	cur = malloc(sizeof(*cur));
	if (cur == NULL) {
		ERR_MSG("out of memory\n");
		rc = -ENOMEM;
		goto err;
	}
	memset(cur, 0, sizeof(*cur));

	fgetpos(fpin, &(cur->eb_top));
	while (1) {
		const char *raw_path;
		uint32_t crc;

		cur->phys_addr = ftell(fpin);
		cur->phys_block = cur->phys_addr / a->bsize;
		cur->data_crc_ok = 0;
		cur->ec_crc_ok   = 0;
		cur->vid_crc_ok  = 0;

		memset(filename, 0, MAXPATH + 1);
		memset(reason, 0, MAXPATH + 1);

		/* in case of an incomplete ec header */
		raw_path = FN_INVAL;

		/* read erasecounter header */
		rc = fread(&cur->ec, 1, sizeof(cur->ec), fpin);
		if (rc == 0)
			goto out; /* EOF */
		if (rc != sizeof(cur->ec)) {
			ERR_MSG("reading ec-hdr failed\n");
			rc = -1;
			goto err;
		}

		/* check erasecounter header magic */
		if (ubi32_to_cpu(cur->ec.magic) != UBI_EC_HDR_MAGIC) {
			snprintf(reason, MAXPATH, ".invalid.ec_magic");
			goto invalid;
		}

		/* check erasecounter header crc */
		crc = clc_crc32(crc32_table, UBI_CRC32_INIT, &(cur->ec),
				UBI_EC_HDR_SIZE_CRC);
		if (ubi32_to_cpu(cur->ec.hdr_crc) != crc) {
			snprintf(reason, MAXPATH, ".invalid.ec_hdr_crc");
			goto invalid;
		}

		/* read volume id header */
		rc = fsetpos(fpin, &(cur->eb_top));
		if (rc != 0)
			goto err;
		fseek(fpin, ubi32_to_cpu(cur->ec.vid_hdr_offset), SEEK_CUR);
		rc = fread(&cur->vid, 1, sizeof(cur->vid), fpin);
		if (rc == 0)
			goto out; /* EOF */
		if (rc != sizeof(cur->vid)) {
			ERR_MSG("reading vid-hdr failed\n");
			rc = -1;
			goto err;
		}

		/* if the magic number is 0xFFFFFFFF, then it's very likely
		 * that the volume is empty */
		if (ubi32_to_cpu(cur->vid.magic) == 0xffffffff) {
			snprintf(reason, MAXPATH, ".empty");
			goto invalid;
		}

		/* vol_id should be in bounds */
		if ((ubi32_to_cpu(cur->vid.vol_id) >= UBI_MAX_VOLUMES) &&
		    (ubi32_to_cpu(cur->vid.vol_id) <
		     UBI_INTERNAL_VOL_START)) {
			snprintf(reason, MAXPATH, ".invalid");
			goto invalid;
		} else
			raw_path = FN_NSURE;

		/* check volume id header magic */
		if (ubi32_to_cpu(cur->vid.magic) != UBI_VID_HDR_MAGIC) {
			snprintf(reason, MAXPATH, ".invalid.vid_magic");
			goto invalid;
		}
		cur->ec_crc_ok = 1;

		/* check volume id header crc */
		crc = clc_crc32(crc32_table, UBI_CRC32_INIT, &(cur->vid),
				UBI_VID_HDR_SIZE_CRC);
		if (ubi32_to_cpu(cur->vid.hdr_crc) != crc) {
			snprintf(reason, MAXPATH, ".invalid.vid_hdr_crc");
			goto invalid;
		}
		cur->vid_crc_ok = 1;

		/* check data crc, but only for a static volume */
		if (cur->vid.vol_type == UBI_VID_STATIC) {
			rc = data_crc(fpin, ubi32_to_cpu(cur->vid.data_size),
				      &crc);
			if (rc < 0)
				goto err;
			if (ubi32_to_cpu(cur->vid.data_crc) != crc) {
				snprintf(reason, MAXPATH, ".invalid.data_crc");
				goto invalid;
			}
			cur->data_crc_ok = 1;
		}

		/* enlist this vol, it's valid */
		raw_path = FN_VALID;
		cur->linear = count;
		rc = eb_chain_insert(&head, cur);
		if (rc < 0) {
			if (rc == -ENOMEM) {
				ERR_MSG("out of memory\n");
				goto err;
			}
			ERR_MSG("unknown and unexpected error, please contact "
				CONTACT "\n");
			goto err;
		}

		/* extract info-table */
		if (a->itable &&
		    (ubi32_to_cpu(cur->vid.vol_id) == UBI_LAYOUT_VOL_ID)) {
			extract_itable(fpin, cur, a->bsize,
				       itable_num, a->odir_path);
			itable_num++;
		}

		/* split volumes */
		if (a->vol_split) {
			size_t size = 0;

			rc = fsetpos(fpin, &(cur->eb_top));
			if (rc != 0)
				goto err;

			/*
			 * FIXME For dynamic UBI volumes we must write
			 * the maximum available data. The
			 * vid.data_size field is not used in this
			 * case. The dynamic volume user is
			 * responsible for the content.
			 */
			if (a->vol_split == SPLIT_DATA) {
				/* Write only data section */
				if (cur->vid.vol_type == UBI_VID_DYNAMIC) {
					/* FIXME Formular is not
					   always right ... */
					size = a->bsize - a->hsize;
				} else
					size = ubi32_to_cpu(cur->vid.data_size);

				fseek(fpin,
				      ubi32_to_cpu(cur->ec.data_offset),
				      SEEK_CUR);
			}
			else if (a->vol_split == SPLIT_RAW)
				/* write entire eraseblock */
				size = a->bsize;

			snprintf(filename, MAXPATH, FN_VOLSP,
				 a->odir_path,
				 ubi32_to_cpu(cur->vid.vol_id),
				 ubi32_to_cpu(cur->vid.lnum),
				 ubi32_to_cpu(cur->vid.leb_ver), count);
			rc = extract_data(fpin, size, filename);
			if (rc < 0)
				goto err;
		}

 invalid:
		/* split eraseblocks */
		if (a->eb_split) {
			/* jump to top of block */
			rc = fsetpos(fpin, &(cur->eb_top));
			if (rc != 0)
				goto err;

			if (strcmp(raw_path, FN_INVAL) == 0)
				snprintf(filename, MAXPATH, raw_path,
					 a->odir_path, count, reason);
			else
				snprintf(filename, MAXPATH, raw_path,
					 a->odir_path,
					 count,
					 ubi32_to_cpu(cur->vid.vol_id),
					 ubi32_to_cpu(cur->vid.lnum),
					 ubi32_to_cpu(cur->vid.leb_ver),
					 reason);

			rc = extract_data(fpin, a->bsize, filename);
			if (rc < 0)
				goto err;
		}

		/* append to simple linked list */
		if (first == NULL)
			next_ptr = &first;
		else
			next_ptr = &next->next;

		*next_ptr = malloc(sizeof(**next_ptr));
		if (*next_ptr == NULL) {
			ERR_MSG("out of memory\n");
			rc = -ENOMEM;
			goto err;
		}
		memset(*next_ptr, 0, sizeof(**next_ptr));

		next = *next_ptr;
		memcpy(next, cur, sizeof(*next));
		next->next = NULL;

		count++;
		rc = fsetpos(fpin, &(cur->eb_top));
		if (rc != 0)
			goto err;
		fseek(fpin, a->bsize, SEEK_CUR);
		memset(cur, 0, sizeof(*cur));

		fgetpos(fpin, &(cur->eb_top));
	}

 out:
	for (i = 0; i < vc; i++) {
		rc = rebuild_volume(fpin, &vols[i], &head, a->odir_path,
			       a->bsize, a->hsize);
		if (rc < 0)
			goto err;
	}

	/* if there were no volumes specified, rebuild them all,
	 * UNLESS eb_ or vol_ split or analyze was specified */
	if ((vc == 0) && (!a->eb_split) && (!a->vol_split) &&
	    (!a->analyze) && (!a->itable)) {
		rc = rebuild_volume(fpin, NULL, &head, a->odir_path, a->bsize,
				    a->hsize);
		if (rc < 0)
			goto err;
	}

 err:
	free(cur);

	if (a->analyze) {
		char fname[PATH_MAX];
		FILE *fp;

		unubi_analyze(&head, first, a->odir_path);

		/* prepare output files */
		memset(fname, 0, PATH_MAX + 1);
		snprintf(fname, PATH_MAX, "%s/%s", a->odir_path, FN_EH_STAT);
		fp = fopen(fname, "w");
		if (fp != NULL) {
			eb_chain_print(fp, head);
			fclose(fp);
		}
	}
	eb_chain_destroy(&head);
	eb_chain_destroy(&first);

	return rc;
}


/**
 * handles command line arguments, then calls unubi_volumes
 **/
int
main(int argc, char *argv[])
{
	int rc, free_a_odir;
	size_t vols_len;
	uint32_t *vols;
	FILE* fpin;
	struct args a;

	rc = 0;
	free_a_odir = 0;
	vols_len = 0;
	vols = NULL;
	fpin = NULL;
	init_crc32_table(crc32_table);

	/* setup struct args a */
	memset(&a, 0, sizeof(a));
	a.bsize = 128 * KIB;
	a.hsize = 2 * KIB;
	a.vols = malloc(sizeof(*a.vols) * UBI_MAX_VOLUMES);
	if (a.vols == NULL) {
		ERR_MSG("out of memory\n");
		rc = ENOMEM;
		goto err;
	}
	memset(a.vols, 0, sizeof(*a.vols) * UBI_MAX_VOLUMES);

	/* parse args and check for validity */
	parse_opt(argc, argv, &a);
	if (a.img_path == NULL) {
		ERR_MSG("no image file specified\n");
		rc = EINVAL;
		goto err;
	}
	else if (a.odir_path == NULL) {
		char *ptr;
		int len;

		ptr = strrchr(a.img_path, '/');
		if (ptr == NULL)
			ptr = a.img_path;
		else
			ptr++;

		len = strlen(DIR_FMT) + strlen(ptr);
		free_a_odir = 1;
		a.odir_path = malloc(sizeof(*a.odir_path) * len);
		if (a.odir_path == NULL) {
			ERR_MSG("out of memory\n");
			rc = ENOMEM;
			goto err;
		}
		snprintf(a.odir_path, len, DIR_FMT, ptr);
	}

	fpin = fopen(a.img_path, "rb");
	if (fpin == NULL) {
		ERR_MSG("couldn't open file for reading: "
			"%s\n", a.img_path);
		rc = EINVAL;
		goto err;
	}

	rc = mkdir(a.odir_path, 0777);
	if ((rc < 0) && (errno != EEXIST)) {
		ERR_MSG("couldn't create ouput directory: "
			"%s\n", a.odir_path);
		rc = -rc;
		goto err;
	}

	/* fill in vols array */
	vols_len = count_set(a.vols, UBI_MAX_VOLUMES);
	if (vols_len > 0) {
		vols = malloc(sizeof(*vols) * vols_len);
		if (vols == NULL) {
			ERR_MSG("out of memory\n");
			rc = ENOMEM;
			goto err;
		}
		collapse(a.vols, UBI_MAX_VOLUMES, vols, vols_len);
	}

	/* unubi volumes */
	rc = unubi_volumes(fpin, vols, vols_len, &a);
	if (rc < 0) {
		/* ERR_MSG("error encountered while working on image file: "
		   "%s\n", a.img_path); */
		rc = -rc;
		goto err;
	}

 err:
	free(a.vols);
	if (free_a_odir != 0)
		free(a.odir_path);
	if (fpin != NULL)
		fclose(fpin);
	if (vols_len > 0)
		free(vols);
	return rc;
}