razor: librazor/dump.c@271bb9e6e10f

     1 /*

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

     3  *

     4  * This program is free software; you can redistribute it and/or modify

     5  * it under the terms of the GNU General Public License as published by

     6  * the Free Software Foundation; either version 2 of the License, or

     7  * (at your option) any later version.

     8  *

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU General Public License along

    15  * with this program; if not, write to the Free Software Foundation, Inc.,

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

    17  */

    19 #include "config.h"

    21 #include <stdlib.h>

    22 #include <stdio.h>

    23 #include <string.h>

    25 #include "razor.h"

    26 #include "razor-internal.h"

    28 static size_t

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

    30 {

    31 	size_t i, n = 0;

    32 	unsigned char *bytes = raw;

    34 	while (length) {

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

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

    37 			if (length >= 4) {

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

    39 				bytes += 4;

    40 				n += 4;

    41 				length -= 4;

    42 				i += 4;

    43 			} else if (length >= 2) {

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

    45 				bytes += 2;

    46 				n += 2;

    47 				length -= 2;

    48 				i += 2;

    49 			} else {

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

    51 				bytes++;

    52 				n++;

    53 				length--;

    54 				i++;

    55 			}

    56 		}

    57 		fprintf(fp, "\n");

    58 	}

    60 	return n;

    61 }

    63 static size_t

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

    65 {

    66 	size_t n = 0;

    67 	unsigned char c;

    69 	fprintf(fp, "\"");

    70 	while (offset + n < length) {

    71 		c = pool[offset + n++];

    72 		if (c == '\0') {

    73 			fprintf(fp, "\\0");

    74 			break;

    75 		}

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

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

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

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

    80 		else

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

    82 	}

    83 	fprintf(fp, "\"");

    85 	return n;

    86 }

    88 static size_t

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

    90 {

    91 	size_t n = 0;

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

    95 	while (n < length) {

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

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

    98 		fprintf(fp, "\n");

    99 	}

   101 	fprintf(fp, "}\n");

   103 	return n;

   104 }

   106 static size_t

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

   108 	    size_t offset)

   109 {

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

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

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

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

   114 		return sizeof(*header);

   115 	} else

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

   117 }

   119 static size_t

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

   121 	     size_t offset, int indx)

   122 {

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

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

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

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

   127 		return sizeof(*section);

   128 	} else

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

   130 }

   132 static void

   133 dump_list_head(FILE *fp, struct list_head *head)

   134 {

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

   136 		head->list_ptr, head->flags);

   137 	if (head->flags == RAZOR_EMPTY_LIST)

   138 		fprintf(fp, "(EMPTY_LIST) ");

   139 	else if (head->flags == RAZOR_IMMEDIATE)

   140 		fprintf(fp, "(IMMEDIATE) ");

   141 	fprintf(fp,"}");

   142 }

   144 static void

   145 dump_list_link(FILE *fp, struct list *list)

   146 {

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

   148 		list->data, list->flags);

   149 	if (list->flags == RAZOR_ENTRY_LAST)

   150 		fprintf(fp, "(ENTRY_LAST) ");

   151 	else if (list->flags == RAZOR_ENTRY_FIRST)

   152 		fprintf(fp, "(ENTRY_FIRST) ");

   153 	fprintf(fp,"}");

   154 }

   156 static void

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

   158 {

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

   160 		fprintf(fp, "(");

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

   162 		fprintf(fp, ") ");

   163 	}

   164 }

   166 static size_t

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

   168 	     size_t offset, struct array *string_pool, int indx)

   169 {

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

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

   172 			indx);

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

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

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

   176 			package->flags, package->version);

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

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

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

   180 		fprintf(fp, "\n            "

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

   182 			package->summary, package->description,

   183 			package->url, package->license);

   184 		fprintf(fp,"            properties=");

   185 		dump_list_head(fp, &package->properties);

   186 		fprintf(fp,"\n");

   187 		fprintf(fp,"            files=");

   188 		dump_list_head(fp, &package->files);

   189 		fprintf(fp,"\n");

   190 		fprintf(fp,"            install_prefixes=");

   191 		dump_list_head(fp, &package->install_prefixes);

   192 		fprintf(fp,"\n");

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

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

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

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

   197 		fprintf(fp,"    }\n");

   198 		return sizeof(*package);

   199 	} else

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

   201 }

   203 static size_t

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

   205 	      size_t offset, struct array *string_pool)

   206 {

   207 	size_t n = 0;

   208 	int i = 0;

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

   212 	while (n < length) {

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

   214 		packages++;

   215 		i++;

   216 	}

   218 	fprintf(fp, "}\n");

   220 	return n;

   221 }

   223 static size_t

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

   225 	      size_t offset, struct array *string_pool)

   226 {

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

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

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

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

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

   232 		if (property->flags & RAZOR_PROPERTY_LESS)

   233 			fprintf(fp, "<");

   234 		if (property->flags & RAZOR_PROPERTY_GREATER)

   235 			fprintf(fp, ">");

   236 		if (property->flags & RAZOR_PROPERTY_EQUAL)

   237 			fprintf(fp, "=");

   238 		switch (property->flags & RAZOR_PROPERTY_TYPE_MASK) {

   239 		case RAZOR_PROPERTY_REQUIRES:

   240 			fprintf(fp, " requires");

   241 			break;

   242 		case RAZOR_PROPERTY_PROVIDES:

   243 			fprintf(fp, " provides");

   244 			break;

   245 		case RAZOR_PROPERTY_CONFLICTS:

   246 			fprintf(fp, " conflicts");

   247 			break;

   248 		case RAZOR_PROPERTY_OBSOLETES:

   249 			fprintf(fp, " obsoletes");

   250 			break;

   251 		}

   252 		if (property->flags & RAZOR_PROPERTY_PRE)

   253 			fprintf(fp, " pre");

   254 		if (property->flags & RAZOR_PROPERTY_POST)

   255 			fprintf(fp, " post");

   256 		if (property->flags & RAZOR_PROPERTY_PREUN)

   257 			fprintf(fp, " preun");

   258 		if (property->flags & RAZOR_PROPERTY_POSTUN)

   259 			fprintf(fp, " postun");

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

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

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

   263 		dump_list_head(fp, &property->packages);

   264 		fprintf(fp,"\n");

   265 		fprintf(fp,"    }\n");

   266 		return sizeof(*property);

   267 	} else

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

   269 }

   271 static size_t

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

   273 		size_t offset, struct array *string_pool)

   274 {

   275 	size_t n = 0;

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

   279 	while (n < length) {

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

   281 		properties++;

   282 	}

   284 	fprintf(fp, "}\n");

   286 	return n;

   287 }

   289 static size_t

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

   291 	   struct array *string_pool, int indx)

   292 {

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

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

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

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

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

   298 		if (entry->flags == RAZOR_ENTRY_LAST)

   299 			fprintf(fp, "(LAST) ");

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

   301 		if (!entry->start)

   302 			fprintf(fp, " (NONE)");

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

   304 		dump_list_head(fp, &entry->packages);

   305 		fprintf(fp,"\n");

   306 		fprintf(fp,"    }\n");

   307 		return sizeof(*entry);

   308 	} else

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

   310 }

   312 static size_t

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

   314 	   struct array *string_pool)

   315 {

   316 	size_t n = 0;

   317 	int i = 0;

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

   321 	while (n < length) {

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

   323 		i++;

   324 		entries++;

   325 	}

   327 	fprintf(fp, "}\n");

   329 	return n;

   330 }

   332 static size_t

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

   334 	   size_t offset)

   335 {

   336 	int i = 0;

   337 	size_t n = 0;

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

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

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

   343 		dump_list_link(fp, lists);

   344 		fprintf(fp, "\n");

   345 		n += sizeof(*lists);

   346 		lists++;

   347 		i++;

   348 	}

   350 	if (length - n)

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

   353 	fprintf(fp, "}\n");

   355 	return n;

   356 }

   358 RAZOR_EXPORT int

   359 razor_dump_database(FILE *fp, const char *root, const char *filename,

   360 		    struct razor_error **error)

   361 {

   362 	int i;

   363 	char *s, *path, *data;

   364 	struct array pool = { 0, };

   365 	struct array string_pool = { 0, };

   366 	struct array file_string_pool = { 0, };

   367 	struct array details_string_pool = { 0, };

   368 	unsigned char *contents;

   369 	size_t length, len, n, min_offset;

   370 	struct razor_set_header *header;

   371 	struct razor_set_section *section, *sections;

   372 	struct razor_package *package;

   373 	struct razor_property *prop;

   374 	struct razor_entry *entry;

   375 	struct list *list;

   377 	if (!filename)

   378 		filename = "system.rzdb";

   380 	s = razor_concat(razor_get_database_path(), "/", filename, NULL);

   381 	path = razor_path_add_root(s, root);

   382 	free(s);

   383 	contents = razor_file_get_contents(path, &length, 0, error);

   384 	free(path);

   386 	if (!contents)

   387 		return -1;

   389 	n = 0;

   391 	header = (void *)contents;

   393 	if (length - n)

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

   396 	min_offset = length;

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

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

   399 		if (n == length)

   400 			break;

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

   402 		if (section->offset < min_offset)

   403 			min_offset = section->offset;

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

   405 	}

   407 	if (length - n) {

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

   409 		pool.size = min_offset - n;

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

   411 	}

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

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

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

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

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

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

   420 		else

   421 			continue;

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

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

   426 			string_pool.data = data;

   427 			string_pool.size = sections[i].size;

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

   429 			file_string_pool.data = data;

   430 			file_string_pool.size = sections[i].size;

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

   432 			details_string_pool.data = data;

   433 			details_string_pool.size = sections[i].size;

   434 		}

   435 	}

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

   438 		if (n == length)

   439 			break;

   440 		section = sections + i;

   441 		if (section->offset != n)

   442 			continue;

   443 		len = section->size;

   444 		if (len > length - n)

   445 			len = length - n;

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

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

   449 			s = pool.data + section->name;

   450 		else

   451 			s = "unknown";

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

   454 		    !strcmp(s, "file_string_pool") ||

   455 		    !strcmp(s, "details_string_pool"))

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

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

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

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

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

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

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

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

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

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

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

   467 			   !strcmp(s, "property_pool") ||

   468 			   !strcmp(s, "prefix_pool") ||

   469 			   !strcmp(s, "file_pool")) {

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

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

   472 		} else

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

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

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

   477 				      PADDING(n, 4), n);

   478 	}

   480 	if (length - n)

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

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

   485 	razor_file_free_contents(contents, length);

   487 	return 0;

   488 }

author	J. Ali Harlow <ali@juiblex.co.uk>
	Wed Apr 22 13:09:42 2015 +0100 (2015-04-22)
changeset 465	271bb9e6e10f
child 475	008c75a5e08d
permissions	-rw-r--r--