/*

 * Copyright (C) 2014, 2016  J. Ali Harlow <ali@juiblex.co.uk>

 *

 * 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.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#include "config.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "razor.h"

#include "razor-internal.h"

static size_t

dump_raw(FILE *fp, void *raw, char *what, size_t length, size_t offset)

{

	size_t i, n = 0;

	unsigned char *bytes = raw;

	while (length) {

		fprintf(fp, "%05lX %s", (unsigned long)(offset + n), what);

		for (i = 0; (i < 16) && (length > 0);) {

			if (length >= 4) {

				fprintf(fp, " %08X", *(uint32_t *)bytes);

				bytes += 4;

				n += 4;

				length -= 4;

				i += 4;

			} else if (length >= 2) {

				fprintf(fp, " %04X", *(unsigned short *)bytes);

				bytes += 2;

				n += 2;

				length -= 2;

				i += 2;

			} else {

				fprintf(fp, " %02X", *bytes);

				bytes++;

				n++;

				length--;

				i++;

			}

		}

		fprintf(fp, "\n");

	}

	return n;

}

static size_t

dump_string(FILE *fp, char *pool, size_t length, size_t offset)

{

	size_t n = 0;

	unsigned char c;

	fprintf(fp, "\"");

	while (offset + n < length) {

		c = pool[offset + n++];

		if (c == '\0') {

			fprintf(fp, "\\0");

			break;

		}

		else if (c == '\\' || c == '"')

			fprintf(fp, "\\%c", c);

		else if (c >= ' ' && c <= '~')

			fprintf(fp, "%c", c);

		else

			fprintf(fp, "\\x%02X", c);

	}

	fprintf(fp, "\"");

	return n;

}

static size_t

dump_pool(FILE *fp, char *pool, char *what, size_t length, size_t offset)

{

	size_t n = 0;

	fprintf(fp, "%05lX %s {\n", (unsigned long)offset, what);

	while (n < length) {

		fprintf(fp, "    %08X ", (uint32_t)n);

		n += dump_string(fp, pool, length, n);

		fprintf(fp, "\n");

	}

	fprintf(fp, "}\n");

	return n;

}

static size_t

dump_header(FILE *fp, struct razor_set_header *header, size_t length,

	    size_t offset)

{

	if (length >= sizeof(*header)) {

		fprintf(fp, "%05lX header ", (unsigned long)offset);

		fprintf(fp, "{ magic=%08X version=%08X num_sections=%08X }\n",

			header->magic, header->version, header->num_sections);

		return sizeof(*header);

	} else

		return dump_raw(fp, header, "unknown", length, offset);

}

static size_t

dump_section(FILE *fp, struct razor_set_section *section, size_t length,

	     size_t offset, int indx)

{

	if (length >= sizeof(*section)) {

		fprintf(fp, "%05lX section %X ", (unsigned long)offset, indx);

		fprintf(fp, "{ name=%08X offset=%08X size=%08X }\n",

			section->name, section->offset, section->size);

		return sizeof(*section);

	} else

		return dump_raw(fp, section, "unknown", length, offset);

}

static void

dump_list_head(FILE *fp, struct list_head *head)

{

	fprintf(fp, "{ list_ptr=%06X flags=%02X ",

		head->list_ptr, head->flags);

	if (head->flags == RAZOR_EMPTY_LIST)

		fprintf(fp, "(EMPTY_LIST) ");

	else if (head->flags == RAZOR_IMMEDIATE)

		fprintf(fp, "(IMMEDIATE) ");

	fprintf(fp,"}");

}

static void

dump_list_link(FILE *fp, struct list *list)

{

	fprintf(fp, "{ data=%06X flags=%02X ",

		list->data, list->flags);

	if (list->flags == RAZOR_ENTRY_LAST)

		fprintf(fp, "(ENTRY_LAST) ");

	else if (list->flags == RAZOR_ENTRY_FIRST)

		fprintf(fp, "(ENTRY_FIRST) ");

	fprintf(fp,"}");

}

static void

expand_pooled_string(FILE *fp, struct array *pool, uint32_t str)

{

	if (pool->data && str < pool->size) {

		fprintf(fp, "(");

		dump_string(fp, pool->data, pool->size, str);

		fprintf(fp, ") ");

	}

}

static size_t

dump_package(FILE *fp, struct razor_package *package, size_t length,

	     size_t offset, struct array *string_pool, int indx)

{

	if (length >= sizeof(*package)) {

		fprintf(fp, "    %05lX package %X ", (unsigned long)offset,

			indx);

		fprintf(fp, "{ name=%06X ", package->name);

		expand_pooled_string(fp, string_pool, package->name);

		fprintf(fp, "flags=%02X\n            version=%08X ",

			package->flags, package->version);

		expand_pooled_string(fp, string_pool, package->version);

		fprintf(fp, "arch=%08X ", package->arch);

		expand_pooled_string(fp, string_pool, package->arch);

		fprintf(fp, "\n            "

			"summary=%08X description=%08X url=%08X license=%08X\n",

			package->summary, package->description,

			package->url, package->license);

		fprintf(fp,"            properties=");

		dump_list_head(fp, &package->properties);

		fprintf(fp,"\n");

		fprintf(fp,"            files=");

		dump_list_head(fp, &package->files);

		fprintf(fp,"\n");

		fprintf(fp,"            install_prefixes=");

		dump_list_head(fp, &package->install_prefixes);

		fprintf(fp,"\n");

		fprintf(fp,"            preun={ program=%08X body=%08X }\n",

		        package->preun.program, package->preun.body);

		fprintf(fp,"            postun={ program=%08X body=%08X }\n",

		        package->postun.program, package->postun.body);

		fprintf(fp,"    }\n");

		return sizeof(*package);

	} else

		return dump_raw(fp, package, "unknown", length, offset);

}

static size_t

dump_packages(FILE *fp, struct razor_package *packages, size_t length,

	      size_t offset, struct array *string_pool)

{

	size_t n = 0;

	int i = 0;

	fprintf(fp, "%05lX packages {\n", (unsigned long)offset);

	while (n < length) {

		n += dump_package(fp, packages, length - n, n, string_pool, i);

		packages++;

		i++;

	}

	fprintf(fp, "}\n");

	return n;

}

static size_t

dump_property(FILE *fp, struct razor_property *property, size_t length,

	      size_t offset, struct array *string_pool)

{

	if (length >= sizeof(*property)) {

		fprintf(fp, "    %05lX property ", (unsigned long)offset);

		fprintf(fp, "{ name=%08X ", property->name);

		expand_pooled_string(fp, string_pool, property->name);

		fprintf(fp, "\n            flags=%08X (", property->flags);

		if (property->flags & RAZOR_PROPERTY_LESS)

			fprintf(fp, "<");

		if (property->flags & RAZOR_PROPERTY_GREATER)

			fprintf(fp, ">");

		if (property->flags & RAZOR_PROPERTY_EQUAL)

			fprintf(fp, "=");

		switch (property->flags & RAZOR_PROPERTY_TYPE_MASK) {

		case RAZOR_PROPERTY_REQUIRES:

			fprintf(fp, " requires");

			break;

		case RAZOR_PROPERTY_PROVIDES:

			fprintf(fp, " provides");

			break;

		case RAZOR_PROPERTY_CONFLICTS:

			fprintf(fp, " conflicts");

			break;

		case RAZOR_PROPERTY_OBSOLETES:

			fprintf(fp, " obsoletes");

			break;

		}

		if (property->flags & RAZOR_PROPERTY_PRE)

			fprintf(fp, " pre");

		if (property->flags & RAZOR_PROPERTY_POST)

			fprintf(fp, " post");

		if (property->flags & RAZOR_PROPERTY_PREUN)

			fprintf(fp, " preun");

		if (property->flags & RAZOR_PROPERTY_POSTUN)

			fprintf(fp, " postun");

		fprintf(fp, ") version=%08X ", property->version);

		expand_pooled_string(fp, string_pool, property->version);

		fprintf(fp,"\n            packages=");

		dump_list_head(fp, &property->packages);

		fprintf(fp,"\n");

		fprintf(fp,"    }\n");

		return sizeof(*property);

	} else

		return dump_raw(fp, property, "unknown", length, offset);

}

static size_t

dump_properties(FILE *fp, struct razor_property *properties, size_t length,

		size_t offset, struct array *string_pool)

{

	size_t n = 0;

	fprintf(fp, "%05lX properties {\n", (unsigned long)offset);

	while (n < length) {

		n += dump_property(fp, properties, length - n, n, string_pool);

		properties++;

	}

	fprintf(fp, "}\n");

	return n;

}

static size_t

dump_entry(FILE *fp, struct razor_entry *entry, size_t length, size_t offset,

	   struct array *string_pool, int indx)

{

	if (length >= sizeof(*entry)) {

		fprintf(fp, "    %05lX entry %X ", (unsigned long)offset, indx);

		fprintf(fp, "{ name=%06X ", entry->name);

		expand_pooled_string(fp, string_pool, entry->name);

		fprintf(fp, "\n            flags=%02X ", entry->flags);

		if (entry->flags == RAZOR_ENTRY_LAST)

			fprintf(fp, "(LAST) ");

		fprintf(fp, "start=%08X", entry->start);

		if (!entry->start)

			fprintf(fp, " (NONE)");

		fprintf(fp,"\n            packages=");

		dump_list_head(fp, &entry->packages);

		fprintf(fp,"\n");

		fprintf(fp,"    }\n");

		return sizeof(*entry);

	} else

		return dump_raw(fp, entry, "unknown", length, offset);

}

static size_t

dump_files(FILE *fp, struct razor_entry *entries, size_t length, size_t offset,

	   struct array *string_pool)

{

	size_t n = 0;

	int i = 0;

	fprintf(fp, "%05lX files {\n", (unsigned long)offset);

	while (n < length) {

		n += dump_entry(fp, entries, length - n, n, string_pool, i);

		i++;

		entries++;

	}

	fprintf(fp, "}\n");

	return n;

}

static size_t

dump_lists(FILE *fp, struct list *lists, char *what, size_t length,

	   size_t offset)

{

	int i = 0;

	size_t n = 0;

	fprintf(fp, "%05lX %s {\n", (unsigned long)offset, what);

	while (n + sizeof(*lists) <= length) {

		fprintf(fp, "    list %06X ", i);

		dump_list_link(fp, lists);

		fprintf(fp, "\n");

		n += sizeof(*lists);

		lists++;

		i++;

	}

	if (length - n)

		n += dump_raw(fp, lists, "unknown", length - n, offset + n);

	fprintf(fp, "}\n");

	return n;

}

RAZOR_EXPORT int

razor_dump_database(FILE *fp, const char *root_uri, const char *filename,

		    struct razor_error **error)

{

	int i;

	char *s, *uri, *data;

	struct array pool = { 0, };

	struct array string_pool = { 0, };

	struct array file_string_pool = { 0, };

	struct array details_string_pool = { 0, };

	unsigned char *contents;

	size_t length, len, n, min_offset;

	struct razor_set_header *header;

	struct razor_set_section *section, *sections;

	struct razor_package *package;

	struct razor_property *prop;

	struct razor_entry *entry;

	struct list *list;

	if (!filename)

		filename = "system.rzdb";

	uri = razor_resolve_database_file(root_uri, filename, error);

	if (!uri)

		return -1;

	contents = razor_uri_get_contents(uri, &length, 0, error);

	free(uri);

	if (!contents)

		return -1;

	n = 0;

	header = (void *)contents;

	if (length - n)

		n += dump_header(fp, header, length - n, n);

	min_offset = length;

	sections = (void *)(contents + n);

	for (i = 0; i < header->num_sections; i++) {

		if (n == length)

			break;

		section = (void *)(contents + n);

		if (section->offset < min_offset)

			min_offset = section->offset;

		n += dump_section(fp, section, length - n, n, i);

	}

	if (length - n) {

		pool.data = (char *)(contents + n);

		pool.size = min_offset - n;

		n += dump_pool(fp, pool.data, "pool", pool.size, n);

	}

	if ((length - n) && PADDING(n, 4))

		n += dump_raw(fp, contents + n, "padding", PADDING(n, 4), n);

	for (i = 0; length - n && i < header->num_sections; i++) {

		if (sections[i].name < pool.size &&

		    ((char *)pool.data)[pool.size - 1] == '\0')

			s = pool.data + sections[i].name;

		else

			continue;

		data = (char *)(contents + sections[i].offset);

		if (!strcmp(s, "string_pool")) {

			string_pool.data = data;

			string_pool.size = sections[i].size;

		} else if (!strcmp(s, "file_string_pool")) {

			file_string_pool.data = data;

			file_string_pool.size = sections[i].size;

		} else if (!strcmp(s, "details_string_pool")) {

			details_string_pool.data = data;

			details_string_pool.size = sections[i].size;

		}

	}

	for (i = 0; i < header->num_sections; i++) {

		if (n == length)

			break;

		section = sections + i;

		if (section->offset != n)

			continue;

		len = section->size;

		if (len > length - n)

			len = length - n;

		if (section->name < pool.size &&

		    ((char *)pool.data)[pool.size - 1] == '\0')

			s = pool.data + section->name;

		else

			s = "unknown";

		if (!strcmp(s, "string_pool") ||

		    !strcmp(s, "file_string_pool") ||

		    !strcmp(s, "details_string_pool"))

			n += dump_pool(fp, (char *)(contents + n), s, len, n);

		else if (!strcmp(s, "packages")) {

			package = (void *)(contents + n);

			n += dump_packages(fp, package, len, n, &string_pool);

		} else if (!strcmp(s, "properties")) {

			prop = (void *)(contents + n);

			n += dump_properties(fp, prop, len, n, &string_pool);

		} else if (!strcmp(s, "files")) {

			entry = (void *)(contents + n);

			n += dump_files(fp, entry, len, n, &file_string_pool);

		} else if (!strcmp(s, "package_pool") ||

			   !strcmp(s, "property_pool") ||

			   !strcmp(s, "prefix_pool") ||

			   !strcmp(s, "file_pool")) {

			list = (void *)(contents + n);

			n += dump_lists(fp, list, s, len, n);

		} else

			n += dump_raw(fp, contents + n, s, len, n);

		if ((length - n) && PADDING(n, 4))

			n += dump_raw(fp, contents + n, "padding",

				      PADDING(n, 4), n);

	}

	if (length - n)

		n += dump_raw(fp, contents + n, "unknown", length - n, n);

	fprintf(fp, "%05lX EOF\n", (unsigned long)n);

	razor_uri_free_contents(contents, length);

	return 0;

}