/*
 * Calvaria - Maemo CAL partition variable access tool.
 *
 * Copyright (c) 2011 Michael Buesch <mb@bu3sch.de>
 *
 * Licensed under the GNU General Public License
 * version 2 or (at your option) any later version.
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <getopt.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <stdint.h>
#include <sys/mman.h>


#define _packed		__attribute__((__packed__))

typedef uint16_t le16_t;
typedef uint32_t le32_t;

struct header {
	char magic[4];		/* Magic sequence */
	uint8_t type;		/* Type number */
	uint8_t index;		/* Index number */
	le16_t flags;		/* Flags */
	char name[16];		/* Human readable section name */
	le32_t length;		/* Payload length */
	le32_t datasum;		/* Data CRC32 checksum */
	le32_t hdrsum;		/* Header CRC32 checksum */
} _packed;

#define HDR_MAGIC	"ConF"


static char toAscii(char c)
{
	if (c >= 32 && c <= 126)
		return c;
	return '.';
}

static void dump(FILE *outstream, const char *buf, size_t size)
{
	size_t i, ascii_cnt = 0;
	char ascii[17] = { 0, };

	for (i = 0; i < size; i++) {
		if (i % 16 == 0) {
			if (i != 0) {
				fprintf(outstream, "  |%s|\n", ascii);
				ascii[0] = 0;
				ascii_cnt = 0;
			}
			fprintf(outstream, "[%04X]: ", (unsigned int)i);
		}
		fprintf(outstream, " %02X", buf[i]);
		ascii[ascii_cnt] = toAscii(buf[i]);
		ascii[ascii_cnt + 1] = 0;
		ascii_cnt++;
	}
	if (ascii[0]) {
		if (size % 16) {
			for (i = 0; i < 16 - (size % 16); i++)
				fprintf(outstream, "   ");
		}
		fprintf(outstream, "  |%s|\n", ascii);
	}
	fprintf(outstream, "\n");
}

static uint32_t crc32(uint32_t crc, const void *_data, size_t size)
{
	const uint8_t *data = _data;
	uint8_t value;
	unsigned int bit;
	size_t i;
	const uint32_t poly = 0xEDB88320;

	for (i = 0; i < size; i++) {
		value = data[i];
		for (bit = 8; bit; bit--) {
			if ((crc & 1) != (value & 1))
				crc = (crc >> 1) ^ poly;
			else
				crc >>= 1;
			value >>= 1;
		}
	}

	return crc;
}

static inline uint16_t le16_to_cpu(le16_t x)
{
	uint8_t *bytes = (uint8_t *)&x;
	uint16_t ret;

	ret = bytes[0];
	ret |= (uint16_t)(bytes[1]) << 8;

	return ret;
}

static inline uint32_t le32_to_cpu(le32_t x)
{
	uint8_t *bytes = (uint8_t *)&x;
	uint32_t ret;

	ret = bytes[0];
	ret |= (uint32_t)(bytes[1]) << 8;
	ret |= (uint32_t)(bytes[2]) << 16;
	ret |= (uint32_t)(bytes[3]) << 24;

	return ret;
}

static int is_header(void *data, size_t size)
{
	struct header *hdr = data;

	if (size < sizeof(struct header))
		return 0;
	if (memcmp(hdr->magic, HDR_MAGIC, sizeof(hdr->magic)) != 0)
		return 0;
	return 1;
}

static int dump_section(const struct header *hdr,
			const void *payload, size_t payload_len,
			int dump_payload,
			FILE *outstream)
{
	char name[sizeof(hdr->name) + 1] = { 0, };
	int hdrsum_ok, datasum_ok;

	memcpy(name, hdr->name, sizeof(hdr->name));
	hdrsum_ok = (crc32(0, hdr, sizeof(*hdr) - 4) == le32_to_cpu(hdr->hdrsum));
	datasum_ok = (crc32(0, payload, payload_len) == le32_to_cpu(hdr->datasum));

	fprintf(outstream, "Section:       %s\n", name);
	fprintf(outstream, "Type:          %u (0x%X)\n", hdr->type, hdr->type);
	fprintf(outstream, "Index:         %u (0x%X)\n", hdr->index, hdr->index);
	fprintf(outstream, "Flags:         0x%04X\n", le16_to_cpu(hdr->flags));
	fprintf(outstream, "Length:        %u (0x%X)\n",
		le32_to_cpu(hdr->length), le32_to_cpu(hdr->length));
	fprintf(outstream, "Data CRC32:    0x%08X (%s)\n", le32_to_cpu(hdr->datasum),
		datasum_ok ? "Ok" : "MISMATCH");
	fprintf(outstream, "Header CRC32:  0x%08X (%s)\n", le32_to_cpu(hdr->hdrsum),
		hdrsum_ok ? "Ok" : "MISMATCH");
	if (dump_payload)
		dump(outstream, payload, payload_len);
	fprintf(outstream, "\n");

	return 0;
}

static void * map_file(const char *filepath, int readonly,
		       uint64_t *filelen)
{
	int fd;
	off_t len;
	void *data;

	fd = open(filepath, readonly ? O_RDONLY : O_RDWR);
	if (fd < 0) {
		fprintf(stderr, "Failed to open file %s: %s\n",
			filepath, strerror(errno));
		return NULL;
	}
	len = lseek(fd, 0, SEEK_END);
	if (len < 0 || lseek(fd, 0, SEEK_SET)) {
		fprintf(stderr, "Failed to calculate file length of %s: %s\n",
			filepath, strerror(errno));
		close(fd);
		return NULL;
	}

	data = mmap(NULL, len,
		    readonly ? PROT_READ : (PROT_READ | PROT_WRITE),
		    readonly ? MAP_PRIVATE : 0,
		    fd, 0);
	close(fd);
	if (data == MAP_FAILED) {
		fprintf(stderr, "Failed to MMAP file %s: %s\n",
			filepath, strerror(errno));
		return NULL;
	}
	madvise(data, len, MADV_SEQUENTIAL);

	*filelen = len;

	return data;
}

static void unmap_file(void *mapping, uint64_t len)
{
	munmap(mapping, len);
}

static int64_t find_section(void *start, uint64_t count,
			    int want_index, const char *want_name)
{
	uint64_t offset = 0;
	uint8_t *data = start;
	struct header *hdr;
	char sectname[sizeof(hdr->name) + 1] = { 0, };
	uint32_t payload_len;

	while (1) {
		/* Find header start */
		if (count < sizeof(struct header))
			break;
		if (!is_header(data + offset, count)) {
			count--;
			offset++;
			continue;
		}
		hdr = (struct header *)(data + offset);
		payload_len = le32_to_cpu(hdr->length);
		if (count - sizeof(struct header) < payload_len) {
			fprintf(stderr, "Premature EOF\n");
			return -1;
		}
		memcpy(sectname, hdr->name, sizeof(hdr->name));

		if (want_index >= 0 && want_index != hdr->index)
			goto next;
		if (want_name && strcmp(sectname, want_name) != 0)
			goto next;

		/* Found it */
		return offset;

next:
		count -= sizeof(struct header) + payload_len;
		offset += sizeof(struct header) + payload_len;
	}

	return -1;
}

static int dump_image(const char *filepath,
		      int want_section_index, const char *want_section_name,
		      int want_headers_only,
		      FILE *outstream)
{
	int err, ret = 0;
	uint64_t filelen;
	uint64_t count, offset;
	int64_t find_offset;
	uint8_t *data, *section;
	struct header *hdr;
	uint32_t payload_len;

	data = map_file(filepath, 1, &filelen);
	if (!data)
		return -EIO;

	count = filelen;
	offset = 0;
	while (1) {
		find_offset = find_section(data + offset, count,
					   want_section_index, want_section_name);
		if (find_offset < 0)
			break;
		offset += find_offset;
		count -= find_offset;

		section = data + offset;
		hdr = (struct header *)section;
		payload_len = le32_to_cpu(hdr->length);

		err = dump_section(hdr, section + sizeof(struct header),
				   payload_len,
				   !want_headers_only,
				   outstream);
		if (err) {
			ret = err;
			goto out;
		}

		count -= sizeof(struct header) + payload_len;
		offset += sizeof(struct header) + payload_len;
	}
out:
	unmap_file(data, filelen);

	return ret;
}

static int write_payload(const char *filepath,
			 int want_section_index, const char *want_section_name,
			 FILE *outstream)
{
	int64_t find_offset;
	uint64_t filelen;
	uint8_t *data;
	struct header *hdr;

	data = map_file(filepath, 1, &filelen);
	if (!data)
		return -EIO;

	find_offset = find_section(data, filelen,
				   want_section_index, want_section_name);
	if (find_offset < 0) {
		fprintf(stderr, "Section %s, index %d not found\n",
			want_section_name, want_section_index);
		unmap_file(data, filelen);
		return -ESRCH;
	}

	hdr = (struct header *)(data + find_offset);
	if (fwrite(data + find_offset + sizeof(struct header),
		   le32_to_cpu(hdr->length), 1, outstream) != 1) {
		fprintf(stderr, "Could not write output data\n");
		unmap_file(data, filelen);
		return -EIO;
	}

	unmap_file(data, filelen);

	return 0;
}

static void usage(FILE *fd)
{
	fprintf(fd, "Calvaria - Maemo CAL partition variable access tool\n");
	fprintf(fd, "\n");
	fprintf(fd, "Usage: calvaria [OPTIONS] FILE\n");
	fprintf(fd, "\n");
	fprintf(fd, "Actions:\n");
	fprintf(fd, "  -d|--dump            Dump the contents of the image\n");
	fprintf(fd, "  -H|--headers         Dump the headers of the image, only\n");
	fprintf(fd, "  -p|--payload         Write the binary payload to stdout.\n");
	fprintf(fd, "                       Requires -i and -n to be set, too\n");
	fprintf(fd, "\n");
	fprintf(fd, "Options:\n");
	fprintf(fd, "  -i|--index NUMBER    Use this section index number\n");
	fprintf(fd, "  -n|--name STRING     Use this section name\n");
	fprintf(fd, "\n");
	fprintf(fd, "  -h|--help            Print this help text\n");
}

enum action {
	ACTION_NONE,
	ACTION_DUMP,
	ACTION_DUMPHDRS,
	ACTION_GETPAYLOAD,
};

int main(int argc, char **argv)
{
	int err, c, idx = 0;
	const char *filepath;
	enum action action = ACTION_NONE;
	int opt_index = -1;
	const char *opt_name = NULL;

	static struct option long_options[] = {
		{ "dump", no_argument, 0, 'd', },
		{ "headers", no_argument, 0, 'H', },
		{ "payload", no_argument, 0, 'p', },
		{ "index", required_argument, 0, 'i', },
		{ "name", required_argument, 0, 'n', },
		{ "help", no_argument, 0, 'h', },
		{ },
	};

	while (1) {
		c = getopt_long(argc, argv, "dHphi:n:",
				long_options, &idx);
		if (c == -1)
			break;
		switch (c) {
		case 'h':
			usage(stdout);
			return 0;
		case 'd':
			action = ACTION_DUMP;
			break;
		case 'H':
			action = ACTION_DUMPHDRS;
			break;
		case 'p':
			action = ACTION_GETPAYLOAD;
			break;
		case 'i':
			if (sscanf(optarg, "%d", &opt_index) != 1 || opt_index < 0) {
				fprintf(stderr, "-i|--index is not a positive integer\n");
				return 1;
			}
			break;
		case 'n':
			opt_name = optarg;
			break;
		default:
			return 1;
		}
	}
	argc -= optind;
	argv += optind;
	if (action == ACTION_NONE) {
		fprintf(stderr, "No action specified.\n");
		return 1;
	}
	if (action == ACTION_GETPAYLOAD) {
		if (opt_index < 0 || !opt_name) {
			fprintf(stderr, "Required options -i|--index or -n|--name "
				"not specified for action -p|--payload\n");
			return 1;
		}
	}
	if (argc != 1) {
		usage(stderr);
		return 1;
	}
	filepath = argv[0];

	switch (action) {
	case ACTION_NONE:
		break;
	case ACTION_DUMP:
	case ACTION_DUMPHDRS:
		err = dump_image(filepath, opt_index, opt_name,
				 (action == ACTION_DUMPHDRS),
				 stdout);
		if (err)
			return 1;
		break;
	case ACTION_GETPAYLOAD:
		err = write_payload(filepath, opt_index, opt_name, stdout);
		if (err)
			return 1;
		break;
	}

	return 0;
}