--- /dev/null
+/*
+ * Copyright (C) 2014 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, const char *filename,
+ struct razor_error **error)
+{
+ int i;
+ char *s, *path, *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";
+
+ s = razor_concat(razor_get_database_path(), "/", filename, NULL);
+ path = razor_path_add_root(s, root);
+ free(s);
+ contents = razor_file_get_contents(path, &length, 0, error);
+ free(path);
+
+ 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_file_free_contents(contents, length);
+
+ return 0;
+}
git://project.juiblex.co.uk / razor.git / commitdiff