razor: razor.c@d8cb523fca84

     1 #define _GNU_SOURCE

     3 #include <stdlib.h>

     4 #include <stddef.h>

     5 #include <stdio.h>

     6 #include <string.h>

     7 #include <sys/types.h>

     8 #include <sys/stat.h>

     9 #include <sys/mman.h>

    10 #include <unistd.h>

    11 #include <fcntl.h>

    12 #include <errno.h>

    14 #include "razor.h"

    16 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))

    18 struct array {

    19 	void *data;

    20 	int size, alloc;

    21 };

    23 struct razor_set_section {

    24 	unsigned int type;

    25 	unsigned int offset;

    26 	unsigned int size;

    27 };

    29 struct razor_set_header {

    30 	unsigned int magic;

    31 	unsigned int version;

    32 	struct razor_set_section sections[0];

    33 };

    35 #define RAZOR_MAGIC 0x7a7a7a7a

    36 #define RAZOR_VERSION 1

    38 #define RAZOR_PACKAGES 0

    39 #define RAZOR_REQUIRES 1

    40 #define RAZOR_PROVIDES 2

    41 #define RAZOR_STRING_POOL 3

    42 #define RAZOR_PROPERTY_POOL 4

    44 struct razor_package {

    45 	unsigned long name;

    46 	unsigned long version;

    47 	unsigned long requires;

    48 	unsigned long provides;

    49 };

    51 struct razor_property {

    52 	unsigned long name;

    53 	unsigned long version;

    54 	unsigned long packages;

    55 };

    57 struct razor_set {

    58 	struct array string_pool;

    59 	struct array property_pool;

    60  	struct array packages;

    61  	struct array requires;

    62  	struct array provides;

    63 	struct razor_set_header *header;

    64 };

    66 struct import_property_context {

    67 	struct array *all;

    68 	struct array package;

    69 };

    71 struct razor_importer {

    72 	struct razor_set *set;

    73 	struct array buckets;

    74 	struct import_property_context requires;

    75 	struct import_property_context provides;

    76 	struct razor_package *package;

    77 	unsigned long *requires_map;

    78 	unsigned long *provides_map;

    79 };

    81 static void

    82 array_init(struct array *array)

    83 {

    84 	memset(array, 0, sizeof *array);

    85 }

    87 static void

    88 array_release(struct array *array)

    89 {

    90 	free(array->data);

    91 }

    93 static void *

    94 array_add(struct array *array, int size)

    95 {

    96 	int alloc;

    97 	void *data, *p;

    99 	if (array->alloc > 0)

   100 		alloc = array->alloc;

   101 	else

   102 		alloc = 16;

   104 	while (alloc < array->size + size)

   105 		alloc *= 2;

   107 	if (array->alloc < alloc) {

   108 		data = realloc(array->data, alloc);

   109 		if (data == NULL)

   110 			return 0;

   111 		array->data = data;

   112 		array->alloc = alloc;

   113 	}

   115 	p = array->data + array->size;

   116 	array->size += size;

   118 	return p;

   119 }

   121 static int

   122 write_to_fd(int fd, void *p, size_t size)

   123 {

   124 	int rest, len;

   126 	rest = size;

   127 	while (rest > 0) {

   128 		len = write(fd, p, rest);

   129 		if (len < 0)

   130 			return -1;

   131 		rest -= len;

   132 	}

   134 	return 0;

   135 }

   137 static void *

   138 zalloc(size_t size)

   139 {

   140 	void *p;

   142 	p = malloc(size);

   143 	memset(p, 0, size);

   145 	return p;

   146 }

   148 struct razor_set_section razor_sections[] = {

   149 	{ RAZOR_PACKAGES,	offsetof(struct razor_set, packages) },

   150 	{ RAZOR_REQUIRES,	offsetof(struct razor_set, requires) },

   151 	{ RAZOR_PROVIDES,	offsetof(struct razor_set, provides) },

   152 	{ RAZOR_STRING_POOL,	offsetof(struct razor_set, string_pool) },

   153 	{ RAZOR_PROPERTY_POOL,	offsetof(struct razor_set, property_pool) },

   154 };

   156 struct razor_set *

   157 razor_set_create(void)

   158 {

   159 	return zalloc(sizeof(struct razor_set));

   160 }

   162 struct razor_set *

   163 razor_set_open(const char *filename)

   164 {

   165 	struct razor_set *set;

   166 	struct razor_set_section *s;

   167 	struct stat stat;

   168 	struct array *array;

   169 	int fd;

   171 	set = zalloc(sizeof *set);

   172 	fd = open(filename, O_RDONLY);

   173 	if (fstat(fd, &stat) < 0)

   174 		return NULL;

   175 	set->header = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

   176 	if (set->header == MAP_FAILED) {

   177 		free(set);

   178 		return NULL;

   179 	}

   181 	for (s = set->header->sections; ~s->type; s++) {

   182 		if (s->type >= ARRAY_SIZE(razor_sections))

   183 			continue;

   184 		if (s->type != razor_sections[s->type].type)

   185 			continue;

   186 		array = (void *) set + razor_sections[s->type].offset;

   187 		array->data = (void *) set->header + s->offset;

   188 		array->size = s->size;

   189 		array->alloc = s->size;

   190 	}

   191 	close(fd);

   193 	return set;

   194 }

   196 void

   197 razor_set_destroy(struct razor_set *set)

   198 {

   199 	unsigned int size;

   200 	struct array *a;

   201 	int i;

   203 	if (set->header) {

   204 		for (i = 0; set->header->sections[i].type; i++)

   205 			;

   206 		size = set->header->sections[i].type;

   207 		munmap(set->header, size);

   208 	} else {

   209 		for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {

   210 			a = (void *) set + razor_sections[i].offset;

   211 			free(a->data);

   212 		}

   213 	}

   215 	free(set);

   216 }

   218 static int

   219 razor_set_write(struct razor_set *set, const char *filename)

   220 {

   221 	char data[4096];

   222 	struct razor_set_header *header = (struct razor_set_header *) data;

   223 	struct array *a;

   224 	unsigned long offset;

   225 	int i, fd;

   227 	memset(data, 0, sizeof data);

   228 	header->magic = RAZOR_MAGIC;

   229 	header->version = RAZOR_VERSION;

   230 	offset = sizeof data;

   232 	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {

   233 		if (razor_sections[i].type != i)

   234 			continue;

   235 		a = (void *) set + razor_sections[i].offset;

   236 		header->sections[i].type = i;

   237 		header->sections[i].offset = offset;

   238 		header->sections[i].size = a->size;

   239 		offset += (a->size + 4095) & ~4095;

   240 	}

   242 	header->sections[i].type = ~0;

   243 	header->sections[i].offset = 0;

   244 	header->sections[i].size = 0;

   246 	fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);

   247 	if (fd < 0)

   248 		return -1;

   250 	write_to_fd(fd, data, sizeof data);

   251 	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {

   252 		if (razor_sections[i].type != i)

   253 			continue;

   254 		a = (void *) set + razor_sections[i].offset;

   255 		write_to_fd(fd, a->data, (a->size + 4095) & ~4095);

   256 	}

   258 	close(fd);

   260 	return 0;

   261 }

   263 static unsigned int

   264 hash_string(const char *key)

   265 {

   266 	const char *p;

   267 	unsigned int hash = 0;

   269 	for (p = key; *p; p++)

   270 		hash = (hash * 617) ^ *p;

   272 	return hash;

   273 }

   275 static unsigned long

   276 razor_importer_lookup(struct razor_importer *importer, const char *key)

   277 {

   278 	unsigned int mask, start, i;

   279 	unsigned long *b;

   280 	char *pool;

   282 	pool = importer->set->string_pool.data;

   283 	mask = importer->buckets.alloc - 1;

   284 	start = hash_string(key) * sizeof(unsigned long);

   286 	for (i = 0; i < importer->buckets.alloc; i += sizeof *b) {

   287 		b = importer->buckets.data + ((start + i) & mask);

   289 		if (*b == 0)

   290 			return 0;

   292 		if (strcmp(key, &pool[*b]) == 0)

   293 			return *b;

   294 	}

   296 	return 0;

   297 }

   299 static unsigned long

   300 add_to_string_pool(struct razor_set *set, const char *key)

   301 {

   302 	int len;

   303 	char *p;

   305 	len = strlen(key) + 1;

   306 	p = array_add(&set->string_pool, len);

   307 	memcpy(p, key, len);

   309 	return p - (char *) set->string_pool.data;

   310 }

   312 static unsigned long

   313 add_to_property_pool(struct razor_set *set, struct array *properties)

   314 {

   315 	unsigned long  *p;

   317 	p = array_add(properties, sizeof *p);

   318 	*p = ~0ul;

   319 	p = array_add(&set->property_pool, properties->size);

   320 	memcpy(p, properties->data, properties->size);

   322 	return p - (unsigned long *) set->property_pool.data;

   323 }

   325 static void

   326 do_insert(struct razor_importer *importer, unsigned long value)

   327 {

   328 	unsigned int mask, start, i;

   329 	unsigned long *b;

   330 	const char *key;

   332 	key = (char *) importer->set->string_pool.data + value;

   333 	mask = importer->buckets.alloc - 1;

   334 	start = hash_string(key) * sizeof(unsigned long);

   336 	for (i = 0; i < importer->buckets.alloc; i += sizeof *b) {

   337 		b = importer->buckets.data + ((start + i) & mask);

   338 		if (*b == 0) {

   339 			*b = value;

   340 			break;

   341 		}

   342 	}

   343 }

   345 static unsigned long

   346 razor_importer_insert(struct razor_importer *importer, const char *key)

   347 {

   348 	unsigned long value, *buckets, *b, *end;

   349 	int alloc;

   351 	alloc = importer->buckets.alloc;

   352 	array_add(&importer->buckets, 4 * sizeof *buckets);

   353 	if (alloc != importer->buckets.alloc) {

   354 		end = importer->buckets.data + alloc;

   355 		memset(end, 0, importer->buckets.alloc - alloc);

   356 		for (b = importer->buckets.data; b < end; b++) {

   357 			value = *b;

   358 			if (value != 0) {

   359 				*b = 0;

   360 				do_insert(importer, value);

   361 			}

   362 		}

   363 	}

   365 	value = add_to_string_pool(importer->set, key);

   366 	do_insert (importer, value);

   368 	return value;

   369 }

   371 static unsigned long

   372 razor_importer_tokenize(struct razor_importer *importer, const char *string)

   373 {

   374 	unsigned long token;

   376 	if (string == NULL)

   377 		return razor_importer_tokenize(importer, "");

   379 	token = razor_importer_lookup(importer, string);

   380 	if (token != 0)

   381 		return token;

   383 	return razor_importer_insert(importer, string);

   384 }

   386 void

   387 razor_importer_begin_package(struct razor_importer *importer,

   388 			     const char *name, const char *version)

   389 {

   390 	struct razor_package *p;

   392 	p = array_add(&importer->set->packages, sizeof *p);

   393 	p->name = razor_importer_tokenize(importer, name);

   394 	p->version = razor_importer_tokenize(importer, version);

   396 	importer->package = p;

   397 	array_init(&importer->requires.package);

   398 	array_init(&importer->provides.package);

   399 }

   401 void

   402 razor_importer_finish_package(struct razor_importer *importer)

   403 {

   404 	struct razor_package *p;

   406 	p = importer->package;

   407 	p->requires = add_to_property_pool(importer->set,

   408 					   &importer->requires.package);

   409 	p->provides = add_to_property_pool(importer->set,

   410 					   &importer->provides.package);

   412 	array_release(&importer->requires.package);

   413 	array_release(&importer->provides.package);

   414 }

   416 static void

   417 razor_importer_add_property(struct razor_importer *importer,

   418 			    struct import_property_context *pctx,

   419 			    const char *name, const char *version)

   420 {

   421 	struct razor_property *p;

   422 	unsigned long *r;

   424 	p = array_add(pctx->all, sizeof *p);

   425 	p->name = razor_importer_tokenize(importer, name);

   426 	p->version = razor_importer_tokenize(importer, version);

   427 	p->packages = importer->package -

   428 		(struct razor_package *) importer->set->packages.data;

   430 	r = array_add(&pctx->package, sizeof *r);

   431 	*r = p - (struct razor_property *) pctx->all->data;

   432 }

   434 void

   435 razor_importer_add_requires(struct razor_importer *importer,

   436 			    const char *name, const char *version)

   437 {

   438 	razor_importer_add_property(importer,

   439 				    &importer->requires, name, version);

   440 }

   442 void

   443 razor_importer_add_provides(struct razor_importer *importer,

   444 			    const char *name, const char *version)

   445 {

   446 	razor_importer_add_property(importer,

   447 				    &importer->provides, name, version);

   448 }

   450 struct razor_importer *

   451 razor_importer_new(void)

   452 {

   453 	struct razor_importer *importer;

   455 	importer = zalloc(sizeof *importer);

   456 	importer->set = razor_set_create();

   457 	importer->requires.all = &importer->set->requires;

   458 	importer->provides.all = &importer->set->provides;

   460 	return importer;

   461 }

   463 typedef int (*compare_with_data_func_t)(const void *p1,

   464 					const void *p,

   465 					void *data);

   467 struct qsort_context {

   468 	size_t size;

   469 	compare_with_data_func_t compare;

   470 	void *data;

   471 };

   473 static void

   474 qsort_swap(void *p1, void *p2, size_t size)

   475 {

   476 	char buffer[size];

   478 	memcpy(buffer, p1, size);

   479 	memcpy(p1, p2, size);

   480 	memcpy(p2, buffer, size);

   481 }

   483 static void

   484 __qsort_with_data(void *base, size_t nelem, unsigned long *map,

   485 		  struct qsort_context *ctx)

   486 {

   487 	void *p, *start, *end, *pivot;

   488 	unsigned long *mp, *mstart, *mend, tmp;

   489 	int left, right, result;

   490 	size_t size = ctx->size;

   492 	p = base;

   493 	start = base;

   494 	end = base + nelem * size;

   495 	mp = map;

   496 	mstart = map;

   497 	mend = map + nelem;

   498 	pivot = base + (random() % nelem) * size;

   500 	while (p < end) {

   501 		result = ctx->compare(p, pivot, ctx->data);

   502 		if (result < 0) {

   503 			qsort_swap(p, start, size);

   504 			tmp = *mp;

   505 			*mp = *mstart;

   506 			*mstart = tmp;

   507 			if (start == pivot)

   508 				pivot = p;

   509 			start += size;

   510 			mstart++;

   511 			p += size;

   512 			mp++;

   513 		} else if (result == 0) {

   514 			p += size;

   515 			mp++;

   516 		} else {

   517  			end -= size;

   518 			mend--;

   519 			qsort_swap(p, end, size);

   520 			tmp = *mp;

   521 			*mp = *mend;

   522 			*mend = tmp;

   523 			if (end == pivot)

   524 				pivot = p;

   525 		}

   526 	}

   528 	left = (start - base) / size;

   529 	right = (base + nelem * size - end) / size;

   530 	if (left > 1)

   531 		__qsort_with_data(base, left, map, ctx);

   532 	if (right > 1)

   533 		__qsort_with_data(end, right, mend, ctx);

   534 }

   536 unsigned long *

   537 qsort_with_data(void *base, size_t nelem, size_t size,

   538 		compare_with_data_func_t compare, void *data)

   539 {

   540 	struct qsort_context ctx;

   541 	unsigned long *map;

   542 	int i;

   544 	ctx.size = size;

   545 	ctx.compare = compare;

   546 	ctx.data = data;

   548 	map = malloc(nelem * sizeof (unsigned long));

   549 	for (i = 0; i < nelem; i++)

   550 		map[i] = i;

   552 	__qsort_with_data(base, nelem, map, &ctx);

   554 	return map;

   555 }

   557 static int

   558 compare_packages(const void *p1, const void *p2, void *data)

   559 {

   560 	const struct razor_package *pkg1 = p1, *pkg2 = p2;

   561 	struct razor_set *set = data;

   562 	char *pool = set->string_pool.data;

   564 	if (pkg1->name == pkg2->name)

   565 		return 0;

   566 	else

   567 		return strcmp(&pool[pkg1->name], &pool[pkg2->name]);

   568 }

   570 static int

   571 compare_properties(const void *p1, const void *p2, void *data)

   572 {

   573 	const struct razor_property *prop1 = p1, *prop2 = p2;

   574 	struct razor_set *set = data;

   575 	char *pool = set->string_pool.data;

   577 	if (prop1->name == prop2->name)

   578 		return strcmp(&pool[prop1->version], &pool[prop2->version]);

   579 	else

   580 		return strcmp(&pool[prop1->name], &pool[prop2->name]);

   581 }

   583 static unsigned long *

   584 uniqueify_properties(struct razor_set *set, struct array *properties)

   585 {

   586 	struct razor_property *rp, *up, *rp_end;

   587 	struct array *pkgs, *p;

   588 	unsigned long *map, *rmap, *r;

   589 	int i, count, unique;

   591 	count = properties->size / sizeof(struct razor_property);

   592 	map = qsort_with_data(properties->data,

   593 			      count,

   594 			      sizeof(struct razor_property),

   595 			      compare_properties,

   596 			      set);

   598 	rp_end = properties->data + properties->size;

   599 	rmap = malloc(count * sizeof *map);

   600 	pkgs = zalloc(count * sizeof *pkgs);

   601 	for (rp = properties->data, up = rp, i = 0; rp < rp_end; rp++, i++) {

   602 		if (rp->name != up->name || rp->version != up->version) {

   603 			up++;

   604 			up->name = rp->name;

   605 			up->version = rp->version;

   606 		}

   608 		unique = up - (struct razor_property *) properties->data;

   609 		rmap[map[i]] = unique;

   610 		r = array_add(&pkgs[unique], sizeof *r);

   611 		*r = rp->packages;

   612 	}

   613 	free(map);

   615 	up++;

   616 	properties->size = (void *) up - properties->data;

   617 	rp_end = up;

   618 	for (rp = properties->data, p = pkgs; rp < rp_end; rp++, p++) {

   619 		rp->packages = add_to_property_pool(set, p);

   620 		array_release(p);

   621 	}

   623 	free(pkgs);

   625 	return rmap;

   626 }

   628 static void

   629 remap_package_links(struct razor_importer *importer)

   630 {

   631 	struct razor_package *p, *end;

   632 	unsigned long *pool, *r;

   634 	pool = importer->set->property_pool.data;

   635 	end = importer->set->packages.data + importer->set->packages.size;

   636 	for (p = importer->set->packages.data; p < end; p++) {

   637 		for (r = &pool[p->requires]; ~*r; r++)

   638 			*r = importer->requires_map[*r];

   639 		for (r = &pool[p->provides]; ~*r; r++)

   640 			*r = importer->provides_map[*r];

   641 	}

   642 }

   644 static void

   645 remap_property_links(struct razor_importer *importer, unsigned long *map)

   646 {

   647 	struct razor_property *p, *end;

   648 	struct razor_package *rp;

   649 	unsigned long *pool, *r, *rmap;

   650 	int i, count;

   652 	pool = importer->set->property_pool.data;

   653 	count = importer->set->packages.size / sizeof(struct razor_package);

   654 	rmap = malloc(count * sizeof *map);

   655 	rp = importer->set->packages.data;

   656 	for (i = 0; i < count; i++)

   657 		rmap[map[i]] = i;

   659 	/* FIXME: This will break if we implement package list sharing

   660 	 * for all properties, since we'll remap those lists more than

   661 	 * once. We should just have a separate pool for property

   662 	 * lists and a separate pool for package lists and remap it as

   663 	 * a flat pool.  Right now, as property lists and package

   664 	 * lists are mixed, we can't do that. */

   666 	end = importer->set->requires.data + importer->set->requires.size;

   667 	for (p = importer->set->requires.data; p < end; p++)

   668 		for (r = &pool[p->packages]; ~*r; r++)

   669 			*r = rmap[*r];

   671 	end = importer->set->provides.data + importer->set->provides.size;

   672 	for (p = importer->set->provides.data; p < end; p++)

   673 		for (r = &pool[p->packages]; ~*r; r++)

   674 			*r = rmap[*r];

   676 	free(rmap);

   677 }

   679 struct razor_set *

   680 razor_importer_finish(struct razor_importer *importer)

   681 {

   682 	struct razor_set *set;

   683 	unsigned long *map;

   684 	int count;

   686 	importer->requires_map = uniqueify_properties(importer->set,

   687 						      importer->requires.all);

   688 	importer->provides_map = uniqueify_properties(importer->set,

   689 						      importer->provides.all);

   690 	remap_package_links(importer);

   691 	free(importer->requires_map);

   692 	free(importer->provides_map);

   694 	count = importer->set->packages.size / sizeof(struct razor_package);

   695 	map = qsort_with_data(importer->set->packages.data,

   696 			      count,

   697 			      sizeof(struct razor_package),

   698 			      compare_packages,

   699 			      importer->set);

   700 	remap_property_links(importer, map);

   701 	free(map);

   703 	set = importer->set;

   704 	array_release(&importer->buckets);

   705 	free(importer);

   707 	return set;

   708 }

   710 void

   711 razor_set_list(struct razor_set *set)

   712 {

   713 	struct razor_package *p, *end;

   714 	char *pool;

   716 	pool = set->string_pool.data;

   717 	end = set->packages.data + set->packages.size;

   718 	for (p = set->packages.data; p < end; p++)

   719 		printf("%s %s\n", &pool[p->name], &pool[p->version]);

   720 }

   722 struct razor_set *bsearch_set;

   724 static int

   725 compare_package_name(const void *key, const void *data)

   726 {

   727 	const struct razor_package *p = data;

   728 	char *pool;

   730 	pool = bsearch_set->string_pool.data;

   732 	return strcmp(key, &pool[p->name]);

   733 }

   735 struct razor_package *

   736 razor_set_get_package(struct razor_set *set, const char *package)

   737 {

   738 	bsearch_set = set;

   739 	return bsearch(package, set->packages.data,

   740 		       set->packages.size / sizeof(struct razor_package),

   741 		       sizeof(struct razor_package), compare_package_name);

   742 }

   744 static int

   745 compare_property_name(const void *key, const void *data)

   746 {

   747 	const struct razor_property *p = data;

   748 	char *pool;

   750 	pool = bsearch_set->string_pool.data;

   752 	return strcmp(key, &pool[p->name]);

   753 }

   755 struct razor_property *

   756 razor_set_get_property(struct razor_set *set,

   757 		       struct array *properties,

   758 		       const char *property)

   759 {

   760 	struct razor_property *p, *start;

   762 	bsearch_set = set;

   763 	p = bsearch(property, properties->data,

   764 		    properties->size / sizeof(struct razor_property),

   765 		    sizeof(struct razor_property), compare_property_name);

   767 	start = properties->data;

   768 	while (p > start && (p - 1)->name == p->name)

   769 		p--;

   771 	return p;

   772 }

   774 static void

   775 razor_set_list_all_properties(struct razor_set *set, struct array *properties)

   776 {

   777 	struct razor_property *p, *end;

   778 	char *pool;

   780 	pool = set->string_pool.data;

   781 	end = properties->data + properties->size;

   782 	for (p = properties->data; p < end; p++)

   783 		printf("%s %s\n", &pool[p->name], &pool[p->version]);

   784 }

   786 void

   787 razor_set_list_requires(struct razor_set *set, const char *name)

   788 {

   789 	struct razor_property *p, *requires;

   790 	struct razor_package *package;

   791 	unsigned long *r;

   792 	char *pool;

   794 	if (name) {

   795 		package = razor_set_get_package(set, name);

   796 		r = (unsigned long *) set->property_pool.data +

   797 			package->requires;

   798 		requires = set->requires.data;

   799 		pool = set->string_pool.data;

   800 		while (~*r) {

   801 			p = &requires[*r++];

   802 			printf("%s %s\n", &pool[p->name], &pool[p->version]);

   803 		}

   804 	} else

   805 		razor_set_list_all_properties(set, &set->requires);

   806 }

   808 void

   809 razor_set_list_provides(struct razor_set *set, const char *name)

   810 {

   811 	struct razor_property *p, *provides;

   812 	struct razor_package *package;

   813 	unsigned long *r;

   814 	char *pool;

   816 	if (name) {

   817 		package = razor_set_get_package(set, name);

   818 		r = (unsigned long *) set->property_pool.data +

   819 			package->provides;

   820 		provides = set->provides.data;

   821 		pool = set->string_pool.data;

   822 		while (~*r) {

   823 			p = &provides[*r++];

   824 			printf("%s %s\n", &pool[p->name], &pool[p->version]);

   825 		}

   826 	} else

   827 		razor_set_list_all_properties(set, &set->provides);

   828 }

   830 void

   831 razor_set_list_property_packages(struct razor_set *set,

   832 				 struct array *properties,

   833 				 const char *name,

   834 				 const char *version)

   835 {

   836 	struct razor_property *property, *end;

   837 	struct razor_package *p, *packages;

   838 	unsigned long *r;

   839 	char *pool;

   841 	if (name == NULL)

   842 		return;

   844 	property = razor_set_get_property(set, properties, name);

   845 	packages = set->packages.data;

   846 	pool = set->string_pool.data;

   847 	end = properties->data + properties->size;

   848 	while (property < end && strcmp(name, &pool[property->name]) == 0) {

   849 		if (version && strcmp(version, &pool[property->version]) != 0)

   850 			goto next;

   851 		r = (unsigned long *)

   852 			set->property_pool.data + property->packages;

   853 		while (~*r) {

   854 			p = &packages[*r++];

   855 			printf("%s %s\n",

   856 			       &pool[p->name], &pool[p->version]);

   857 		}

   858 	next:

   859 		property++;

   860 	}

   861 }

   863 void

   864 razor_set_validate(struct razor_set *set, struct array *unsatisfied)

   865 {

   866 	struct razor_property *r, *p, *rend, *pend;

   867 	unsigned long *u;

   868 	char *pool;

   870 	r = set->requires.data;

   871 	p = set->provides.data;

   872 	rend = set->requires.data + set->requires.size;

   873 	pend = set->provides.data + set->provides.size;

   874 	pool = set->string_pool.data;

   876 	while (r < rend) {

   877 		while (p < pend && strcmp(&pool[r->name], &pool[p->name]) > 0)

   878 			p++;

   879 		if (p == pend || strcmp(&pool[r->name], &pool[p->name]) != 0) {

   880 			u = array_add(unsatisfied, sizeof *u);

   881 			*u = r - (struct razor_property *) set->requires.data;

   882 		}

   883 		r++;

   884 	}

   885 }

   887 void

   888 razor_set_list_unsatisfied(struct razor_set *set)

   889 {

   890 	struct array unsatisfied;

   891 	struct razor_property *requires, *r;

   892 	unsigned long *u, *end;

   893 	char *pool;

   895 	array_init(&unsatisfied);

   896 	razor_set_validate(set, &unsatisfied);

   898 	end = unsatisfied.data + unsatisfied.size;

   899 	requires = set->requires.data;

   900 	pool = set->string_pool.data;

   902 	for (u = unsatisfied.data; u < end; u++) {

   903 		r = requires + *u;

   904 		printf("%s %s not satisfied\n",

   905 		       &pool[r->name], &pool[r->version]);

   906 	}

   908 	array_release(&unsatisfied);

   909 }

   911 static void

   912 add_package(struct razor_importer *importer,

   913 	    struct razor_package *package, struct razor_set *set)

   914 {

   915 	char *pool;

   916 	unsigned long *r;

   917 	struct razor_property *p, *properties;

   919 	pool = set->string_pool.data;

   920 	razor_importer_begin_package(importer,

   921 				     &pool[package->name],

   922 				     &pool[package->version]);

   924 	r = (unsigned long *) set->property_pool.data + package->requires;

   925 	properties = set->requires.data;

   926 	while (~*r) {

   927 		p = &properties[*r++];

   928 		razor_importer_add_requires(importer,

   929 					    &pool[p->name], &pool[p->version]);

   930 	}

   932 	r = (unsigned long *) set->property_pool.data + package->provides;

   933 	properties = set->provides.data;

   934 	while (~*r) {

   935 		p = &properties[*r++];

   936 		razor_importer_add_provides(importer,

   937 					    &pool[p->name], &pool[p->version]);

   938 	}

   940 	razor_importer_finish_package(importer);

   941 }

   943 /* Add packages from 'upstream' to 'set'.  The packages to add are

   944  * specified by the 'packages' array, which is a sorted list of

   945  * package indexes.  Returns a newly allocated package set.  Does not

   946  * enforce validity of the resulting package set. */

   948 struct razor_set *

   949 razor_set_add(struct razor_set *set, struct razor_set *upstream,

   950 	      struct array *packages)

   951 {

   952 	struct razor_importer *importer;

   953 	struct razor_package *upstream_packages, *p, *s, *send;

   954 	char *spool, *upool;

   955 	unsigned long *u, *uend;

   956 	int cmp;

   958 	importer = razor_importer_new();

   959 	upstream_packages = upstream->packages.data;

   960 	u = packages->data;

   961 	uend = packages->data + packages->size;

   962 	upool = upstream->string_pool.data;

   963 	s = set->packages.data;

   964 	send = set->packages.data + set->packages.size;

   965 	spool = set->string_pool.data;

   967 	while (s < send) {

   968 		p = upstream_packages + *u;

   969 		cmp = strcmp(&spool[s->name], &upool[p->name]);

   970 		if (cmp < 0 || u == uend) {

   971 			add_package(importer, s, set);

   972 			s++;

   973 		} else if (cmp == 0) {

   974 			add_package(importer, p, upstream);

   975 			s++;

   976 			u++;

   977 		} else {

   978 			add_package(importer, p, upstream);

   979 			u++;

   980 		}

   981 	}

   983 	return razor_importer_finish(importer);

   984 }

   986 struct razor_set *

   987 razor_set_update(struct razor_set *set, struct razor_set *upstream,

   988 		 int count, const char **packages)

   989 {

   990 	struct razor_package *p;

   991 	struct array list;

   992 	unsigned long *r;

   993 	int i;

   995 	array_init(&list);

   996 	for (i = 0; i < count; i++) {

   997 		p = razor_set_get_package(upstream, packages[i]);

   998 		r = array_add(&list, sizeof *r);

   999 		*r = p - (struct razor_package *) upstream->packages.data;

  1000 	}

  1002 	return razor_set_add(set, upstream, &list);

  1003 }

  1005 void

  1006 razor_set_info(struct razor_set *set)

  1007 {

  1008 	unsigned int offset, size;

  1009 	int i;

  1011 	for (i = 0; i < set->header->sections[i].type; i++) {

  1012 		offset = set->header->sections[i].offset;

  1013 		size = set->header->sections[i].size;

  1015 		switch (set->header->sections[i].type) {

  1016 		case RAZOR_PACKAGES:

  1017 			printf("package section:\t%dkb\n", size / 1024);

  1018 			break;

  1019 		case RAZOR_REQUIRES:

  1020 			printf("requires section:\t%dkb\n", size / 1024);

  1021 			break;

  1022 		case RAZOR_PROVIDES:

  1023 			printf("provides section:\t%dkb\n", size / 1024);

  1024 			break;

  1025 		case RAZOR_STRING_POOL:

  1026 			printf("string pool:\t\t%dkb\n", size / 1024);

  1027 			break;

  1028 		case RAZOR_PROPERTY_POOL:

  1029 			printf("properties section:\t%dkb\n", size / 1024);

  1030 			break;

  1031 		}

  1032 	}

  1033 }

  1035 static int

  1036 usage(void)

  1037 {

  1038 	printf("usage: razor [ import FILES | lookup <key> | "

  1039 	       "list | list-requires | list-provides | eat-yum | info ]\n");

  1040 	exit(1);

  1041 }

  1043 static const char *repo_filename = "system.repo";

  1044 static const char rawhide_repo_filename[] = "rawhide.repo";

  1046 int

  1047 main(int argc, const char *argv[])

  1048 {

  1049 	struct razor_set *set, *upstream, *new;

  1050 	struct stat statbuf;

  1051 	char *repo;

  1053 	repo = getenv("RAZOR_REPO");

  1054 	if (repo != NULL)

  1055 		repo_filename = repo;

  1057 	if (argc < 2) {

  1058 		usage();

  1059 	} else if (strcmp(argv[1], "import") == 0) {

  1060 		if (stat("set", &statbuf) && mkdir("set", 0777)) {

  1061 			fprintf(stderr, "could not create directory 'set'\n");

  1062 			exit(-1);

  1063 		}

  1065 		set = razor_import_rzr_files(argc - 2, argv + 2);

  1067 		printf("pool size: %d\n", set->string_pool.size);

  1068 		printf("pool allocation: %d\n", set->string_pool.alloc);

  1069 		printf("packages: %d\n",

  1070 		       set->packages.size / sizeof(struct razor_package));

  1071 		printf("requires: %d\n",

  1072 		       set->requires.size / sizeof(struct razor_property));

  1073 		printf("provides: %d\n",

  1074 		       set->provides.size / sizeof(struct razor_property));

  1076 		razor_set_write(set, repo_filename);

  1078 		razor_set_destroy(set);

  1079 	} else if (strcmp(argv[1], "list") == 0) {

  1080 		set = razor_set_open(repo_filename);

  1081 		razor_set_list(set);

  1082 		razor_set_destroy(set);

  1083 	} else if (strcmp(argv[1], "list-requires") == 0) {

  1084 		set = razor_set_open(repo_filename);

  1085 		razor_set_list_requires(set, argv[2]);

  1086 		razor_set_destroy(set);

  1087 	} else if (strcmp(argv[1], "list-provides") == 0) {

  1088 		set = razor_set_open(repo_filename);

  1089 		razor_set_list_provides(set, argv[2]);

  1090 		razor_set_destroy(set);

  1091 	} else if (strcmp(argv[1], "what-requires") == 0) {

  1092 		set = razor_set_open(repo_filename);

  1093 		razor_set_list_property_packages(set, &set->requires,

  1094 						 argv[2], argv[3]);

  1095 		razor_set_destroy(set);

  1096 	} else if (strcmp(argv[1], "what-provides") == 0) {

  1097 		set = razor_set_open(repo_filename);

  1098 		razor_set_list_property_packages(set, &set->provides,

  1099 						 argv[2], argv[3]);

  1100 		razor_set_destroy(set);

  1101 	} else if (strcmp(argv[1], "info") == 0) {

  1102 		set = razor_set_open(repo_filename);

  1103 		razor_set_info(set);

  1104 		razor_set_destroy(set);

  1105 	} else if (strcmp(argv[1], "eat-yum") == 0) {

  1106 		set = razor_set_create_from_yum_filelist(STDIN_FILENO);

  1107 		if (set == NULL)

  1108 			return 1;

  1109 		razor_set_write(set, rawhide_repo_filename);

  1110 		razor_set_destroy(set);

  1111 		printf("wrote %s\n", rawhide_repo_filename);

  1112 	} else if (strcmp(argv[1], "import-rpmdb") == 0) {

  1113 		set = razor_set_create_from_rpmdb();

  1114 		if (set == NULL)

  1115 			return 1;

  1116 		razor_set_write(set, repo_filename);

  1117 		razor_set_destroy(set);

  1118 		printf("wrote %s\n", repo_filename);

  1119 	} else if (strcmp(argv[1], "validate") == 0) {

  1120 		set = razor_set_open(repo_filename);

  1121 		if (set == NULL)

  1122 			return 1;

  1123 		razor_set_list_unsatisfied(set);

  1124 		razor_set_destroy(set);

  1125 	} else if (strcmp(argv[1], "update") == 0) {

  1126 		set = razor_set_open(repo_filename);

  1127 		upstream = razor_set_open(rawhide_repo_filename);

  1128 		if (set == NULL || upstream == NULL)

  1129 			return 1;

  1130 		new = razor_set_update(set, upstream, argc - 2, argv + 2);

  1131 		razor_set_write(new, "system-updated.repo");

  1132 		razor_set_destroy(new);

  1133 		razor_set_destroy(set);

  1134 		razor_set_destroy(upstream);

  1135 	} else {

  1136 		usage();

  1137 	}

  1139 	return 0;

  1140 }

author	Kristian H?gsberg <krh@redhat.com>
	Wed Sep 19 17:19:11 2007 -0400 (2007-09-19)
changeset 33	d8cb523fca84
parent 32	1609eb5d93a1
child 34	45caae67088b
permissions	-rw-r--r--