Mercurialrazor / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
librazor/razor.c
author J. Ali Harlow <ali@juiblex.co.uk>
Tue Jan 13 17:04:51 2009 +0000 (2009-01-13)
changeset 347 7538f8dc4425
parent 334 52871d4b9265
child 351 48b0adfe3059
permissions -rw-r--r--
Don't try and stat the installation root if it's the empty string. 
     1 /*

     2  * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

     3  * Copyright (C) 2008  Red Hat, Inc

     4  *

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

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

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

     8  * (at your option) any later version.

     9  *

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

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

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

    13  * GNU General Public License for more details.

    14  *

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

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

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

    18  */

    19 

    20 #define _GNU_SOURCE

    21 

    22 #include "config.h"

    23 

    24 #include <stdlib.h>

    25 #include <stddef.h>

    26 #include <stdint.h>

    27 #include <stdio.h>

    28 #include <stdarg.h>

    29 #include <string.h>

    30 #include <sys/types.h>

    31 #include <sys/stat.h>

    32 #include <unistd.h>

    33 #include <fcntl.h>

    34 #include <errno.h>

    35 #include <ctype.h>

    36 #include <fnmatch.h>

    37 #include <assert.h>

    38 

    39 #include "razor-internal.h"

    40 #include "razor.h"

    41 

    42 #ifndef O_BINARY

    43 #define O_BINARY	0

    44 #endif

    45 

    46 void *

    47 zalloc(size_t size)

    48 {

    49 	void *p;

    50 

    51 	p = malloc(size);

    52 	memset(p, 0, size);

    53 

    54 	return p;

    55 }

    56 

    57 struct razor_set_section_index {

    58 	const char *name;

    59 	uint32_t offset;

    60 };

    61 

    62 struct razor_set_section_index razor_sections[] = {

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

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

    65 	{ RAZOR_PROPERTIES,	offsetof(struct razor_set, properties) },

    66 	{ RAZOR_PACKAGE_POOL,	offsetof(struct razor_set, package_pool) },

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

    68 };

    69 

    70 struct razor_set_section_index razor_files_sections[] = {

    71 	{ RAZOR_FILES,			offsetof(struct razor_set, files) },

    72 	{ RAZOR_FILE_POOL,		offsetof(struct razor_set, file_pool) },

    73 	{ RAZOR_FILE_STRING_POOL,	offsetof(struct razor_set, file_string_pool) },

    74 };

    75 

    76 struct razor_set_section_index razor_details_sections[] = {

    77 	{ RAZOR_DETAILS_STRING_POOL,	offsetof(struct razor_set, details_string_pool) },

    78 };

    79 

    80 RAZOR_EXPORT struct razor_set *

    81 razor_set_create(void)

    82 {

    83 	struct razor_set *set;

    84 	struct razor_entry *e;

    85 	char *empty;

    86 

    87 	set = zalloc(sizeof *set);

    88 

    89 	e = array_add(&set->files, sizeof *e);

    90 	empty = array_add(&set->string_pool, 1);

    91 	*empty = '\0';

    92 	e->name = 0;

    93 	e->flags = RAZOR_ENTRY_LAST;

    94 	e->start = 0;

    95 	list_set_empty(&e->packages);

    96 

    97 	return set;

    98 }

    99 

   100 static int

   101 razor_set_bind_sections(struct razor_set *set,

   102 			struct razor_set_header **header,

   103 			size_t *header_size,

   104 			struct razor_set_section_index section_index[],

   105 			int section_index_size,

   106 			const char *filename)

   107 {

   108 	struct razor_set_section *s, *sections;

   109 	struct array *array;

   110 	const char *pool;

   111 	int i;

   112 

   113 	*header = razor_file_get_contents(filename, header_size);

   114 	if (!*header)

   115 		return -1;

   116 

   117 	sections = (void *) *header + sizeof **header;

   118 	pool = (void *) sections + (*header)->num_sections * sizeof *sections;

   119 

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

   121 		int j;

   122 		s = sections + i;

   123 		for (j = 0; j < section_index_size; j++)

   124 			if (!strcmp(section_index[j].name,

   125 				    &pool[s->name]))

   126 				break;

   127 		if (j == section_index_size)

   128 			continue;

   129 		array = (void *) set + section_index[j].offset;

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

   131 		array->size = s->size;

   132 		array->alloc = s->size;

   133 	}

   134 

   135 	return 0;

   136 }

   137 

   138 RAZOR_EXPORT struct razor_set *

   139 razor_set_open(const char *filename)

   140 {

   141 	struct razor_set *set;

   142 

   143 	set = zalloc(sizeof *set);

   144 	if (razor_set_bind_sections(set, &set->header, &set->header_size,

   145 				    razor_sections, ARRAY_SIZE(razor_sections),

   146 				    filename)){

   147 		free(set);

   148 		return NULL;

   149 	}

   150 	return set;

   151 }

   152 

   153 RAZOR_EXPORT int

   154 razor_set_open_details(struct razor_set *set, const char *filename)

   155 {

   156 	return razor_set_bind_sections(set, &set->details_header,

   157 				       &set->details_header_size,

   158 				       razor_details_sections,

   159 				       ARRAY_SIZE(razor_details_sections),

   160 				       filename);

   161 }

   162 

   163 RAZOR_EXPORT int

   164 razor_set_open_files(struct razor_set *set, const char *filename)

   165 {

   166 	return razor_set_bind_sections(set, &set->files_header,

   167 				       &set->files_header_size,

   168 				       razor_files_sections,

   169 				       ARRAY_SIZE(razor_files_sections),

   170 				       filename);

   171 }

   172 

   173 RAZOR_EXPORT void

   174 razor_set_destroy(struct razor_set *set)

   175 {

   176 	struct array *a;

   177 	int i;

   178 

   179 	assert (set != NULL);

   180 

   181 	if (set->header) {

   182 		razor_file_free_contents(set->header, set->header_size);

   183 	} else {

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

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

   186 			free(a->data);

   187 		}

   188 	}

   189 

   190 	if (set->details_header) {

   191 		razor_file_free_contents(set->details_header,

   192 			set->details_header_size);

   193 	} else {

   194 		for (i = 0; i < ARRAY_SIZE(razor_details_sections); i++) {

   195 			a = (void *) set + razor_details_sections[i].offset;

   196 			free(a->data);

   197 		}

   198 	}

   199 

   200 	if (set->files_header) {

   201 		razor_file_free_contents(set->files_header,

   202 			set->files_header_size);

   203 	} else {

   204 		for (i = 0; i < ARRAY_SIZE(razor_files_sections); i++) {

   205 			a = (void *) set + razor_files_sections[i].offset;

   206 			free(a->data);

   207 		}

   208 	}

   209 

   210 	free(set);

   211 }

   212 

   213 static int

   214 razor_set_write_sections_to_fd(struct razor_set *set, int fd,

   215 			       struct razor_set_section_index *sections,

   216 			       size_t array_size)

   217 {

   218 	struct razor_set_header header;

   219 	struct razor_set_section *out_sections =

   220 		malloc(array_size * sizeof *out_sections);

   221 	struct hashtable table;

   222 	struct array *a, pool;

   223 	uint32_t offset;

   224 	int i;

   225 

   226 	header.magic = RAZOR_MAGIC;

   227 	header.version = RAZOR_VERSION;

   228 	header.num_sections = array_size;

   229 	offset = sizeof header + array_size * sizeof *out_sections;

   230 

   231 	array_init(&pool);

   232 	hashtable_init(&table, &pool);

   233 

   234 	for (i = 0; i < array_size; i++)

   235 		out_sections[i].name =

   236 			hashtable_tokenize(&table, sections[i].name);

   237 

   238 	offset += pool.size;

   239 

   240 	for (i = 0; i < array_size; i++) {

   241 		a = (void *) set + sections[i].offset;

   242 		out_sections[i].offset = offset;

   243 		out_sections[i].size = a->size;

   244 		offset += a->size;

   245 	}

   246 

   247 	razor_write(fd, &header, sizeof header);

   248 	razor_write(fd, out_sections, array_size * sizeof *out_sections);

   249 	razor_write(fd, pool.data, pool.size);

   250 

   251 	for (i = 0; i < array_size; i++) {

   252 		a = (void *) set + sections[i].offset;

   253 		razor_write(fd, a->data, a->size);

   254 	}

   255 

   256 	free(out_sections);

   257 

   258 	return 0;

   259 }

   260 

   261 RAZOR_EXPORT int

   262 razor_set_write_to_fd(struct razor_set *set, int fd,

   263 		      enum razor_repo_file_type type)

   264 {

   265 	switch (type) {

   266 	case RAZOR_REPO_FILE_MAIN:

   267 		return razor_set_write_sections_to_fd(set, fd,

   268 						      razor_sections,

   269 						      ARRAY_SIZE(razor_sections));

   270 

   271 	case RAZOR_REPO_FILE_DETAILS:

   272 		return razor_set_write_sections_to_fd(set, fd,

   273 						      razor_details_sections,

   274 						      ARRAY_SIZE(razor_details_sections));

   275 	case RAZOR_REPO_FILE_FILES:

   276 		return razor_set_write_sections_to_fd(set, fd,

   277 						      razor_files_sections,

   278 						      ARRAY_SIZE(razor_files_sections));

   279 	default:

   280 		return -1;

   281 	}

   282 }

   283 

   284 RAZOR_EXPORT int

   285 razor_set_write(struct razor_set *set, const char *filename,

   286 		enum razor_repo_file_type type)

   287 {

   288 	int fd, status;

   289 

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

   291 	if (fd < 0)

   292 		return -1;

   293 

   294 	status = razor_set_write_to_fd(set, fd, type);

   295 	if (status) {

   296 	    close(fd);

   297 	    return status;

   298 	}

   299 

   300 	return close(fd);

   301 }

   302 

   303 RAZOR_EXPORT void

   304 razor_build_evr(char *evr_buf, int size, const char *epoch,

   305 		const char *version, const char *release)

   306 {

   307 	int len;

   308 

   309 	if (!version || !*version) {

   310 		*evr_buf = '\0';

   311 		return;

   312 	}

   313 

   314 	if (epoch && *epoch && strcmp(epoch, "0") != 0) {

   315 		len = snprintf(evr_buf, size, "%s:", epoch);

   316 		evr_buf += len;

   317 		size -= len;

   318 	}

   319 	len = snprintf(evr_buf, size, "%s", version);

   320 	evr_buf += len;

   321 	size -= len;

   322 	if (release && *release)

   323 		snprintf(evr_buf, size, "-%s", release);

   324 }

   325 

   326 RAZOR_EXPORT int

   327 razor_versioncmp(const char *s1, const char *s2)

   328 {

   329 	const char *p1, *p2;

   330 	long n1, n2;

   331 	int res;

   332 

   333 	assert (s1 != NULL);

   334 	assert (s2 != NULL);

   335 

   336 	n1 = strtol(s1, (char **) &p1, 10);

   337 	n2 = strtol(s2, (char **) &p2, 10);

   338 

   339 	/* Epoch; if one but not the other has an epoch set, default

   340 	 * the epoch-less version to 0. */

   341 	res = (*p1 == ':') - (*p2 == ':');

   342 	if (res < 0) {

   343 		n1 = 0;

   344 		p1 = s1;

   345 		p2++;

   346 	} else if (res > 0) {

   347 		p1++;

   348 		n2 = 0;

   349 		p2 = s2;

   350 	}

   351 

   352 	if (n1 != n2)

   353 		return n1 - n2;

   354 	while (*p1 && *p2) {

   355 		if (*p1 != *p2)

   356 			return *p1 - *p2;

   357 		p1++;

   358 		p2++;

   359 		if (isdigit(*p1) && isdigit(*p2))

   360 			return razor_versioncmp(p1, p2);

   361 	}

   362 

   363 	return *p1 - *p2;

   364 }

   365 

   366 static const char *

   367 razor_package_get_details_type(struct razor_set *set,

   368 			       struct razor_package *package,

   369 			       enum razor_detail_type type)

   370 {

   371 	const char *pool;

   372 

   373 	switch (type) {

   374 	case RAZOR_DETAIL_NAME:

   375 		pool = set->string_pool.data;

   376 		return &pool[package->name];

   377 

   378 	case RAZOR_DETAIL_VERSION:

   379 		pool = set->string_pool.data;

   380 		return &pool[package->version];

   381 

   382 	case RAZOR_DETAIL_ARCH:

   383 		pool = set->string_pool.data;

   384 		return &pool[package->arch];

   385 

   386 	case RAZOR_DETAIL_SUMMARY:

   387 		pool = set->details_string_pool.data;

   388 		return &pool[package->summary];

   389 

   390 	case RAZOR_DETAIL_DESCRIPTION:

   391 		pool = set->details_string_pool.data;

   392 		return &pool[package->description];

   393 

   394 	case RAZOR_DETAIL_URL:

   395 		pool = set->details_string_pool.data;

   396 		return &pool[package->url];

   397 

   398 	case RAZOR_DETAIL_LICENSE:

   399 		pool = set->details_string_pool.data;

   400 		return &pool[package->license];

   401 

   402 	default:

   403 		fprintf(stderr, "type %u not found\n", type);

   404 		return NULL;

   405 	}

   406 }

   407 

   408 /**

   409  * razor_package_get_details_varg:

   410  * @set: a %razor_set

   411  * @package: a %razor_package

   412  * @args: a va_list of arguments to set

   413  **/

   414 void

   415 razor_package_get_details_varg(struct razor_set *set,

   416 			       struct razor_package *package,

   417 			       va_list args)

   418 {

   419 	int i;

   420 	enum razor_detail_type type;

   421 	const char **data;

   422 

   423 	for (i = 0;; i += 2) {

   424 		type = va_arg(args, enum razor_detail_type);

   425 		if (type == RAZOR_DETAIL_LAST)

   426 			break;

   427 		data = va_arg(args, const char **);

   428 		*data = razor_package_get_details_type(set, package, type);

   429 	}

   430 

   431 }

   432 

   433 /**

   434  * razor_package_get_details:

   435  * @set: a %razor_set

   436  * @package: a %razor_package

   437  *

   438  * Gets details about a package using a varg interface

   439  * The vararg must be terminated with %RAZOR_DETAIL_LAST.

   440  *

   441  * Example: razor_package_get_details (set, package,

   442  *				       RAZOR_DETAIL_URL, &url,

   443  *				       RAZOR_DETAIL_LAST);

   444  **/

   445 RAZOR_EXPORT void

   446 razor_package_get_details(struct razor_set *set, struct razor_package *package, ...)

   447 {

   448 	va_list args;

   449 

   450 	assert (set != NULL);

   451 	assert (package != NULL);

   452 

   453 	va_start(args, NULL);

   454 	razor_package_get_details_varg (set, package, args);

   455 	va_end (args);

   456 }

   457 

   458 RAZOR_EXPORT const char *

   459 razor_property_relation_to_string(struct razor_property *p)

   460 {

   461 	assert (p != NULL);

   462 

   463 	switch (p->flags & RAZOR_PROPERTY_RELATION_MASK) {

   464 	case RAZOR_PROPERTY_LESS:

   465 		return "<";

   466 

   467 	case RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL:

   468 		return "<=";

   469 

   470 	case RAZOR_PROPERTY_EQUAL:

   471 		return "=";

   472 

   473 	case RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL:

   474 		return ">=";

   475 

   476 	case RAZOR_PROPERTY_GREATER:

   477 		return ">";

   478 

   479 	default:

   480 		return "?";

   481 	}

   482 }

   483 

   484 RAZOR_EXPORT const char *

   485 razor_property_type_to_string(struct razor_property *p)

   486 {

   487 	assert (p != NULL);

   488 

   489 	switch (p->flags & RAZOR_PROPERTY_TYPE_MASK) {

   490 	case RAZOR_PROPERTY_REQUIRES:

   491 		return "requires";

   492 	case RAZOR_PROPERTY_PROVIDES:

   493 		return "provides";

   494 	case RAZOR_PROPERTY_CONFLICTS:

   495 		return "conflicts";

   496 	case RAZOR_PROPERTY_OBSOLETES:

   497 		return "obsoletes";

   498 	default:

   499 		return NULL;

   500 	}

   501 }

   502 

   503 RAZOR_EXPORT struct razor_entry *

   504 razor_set_find_entry(struct razor_set *set,

   505 		     struct razor_entry *dir, const char *pattern)

   506 {

   507 	struct razor_entry *e;

   508 	const char *n, *pool = set->file_string_pool.data;

   509 	int len;

   510 

   511 	assert (set != NULL);

   512 	assert (dir != NULL);

   513 	assert (pattern != NULL);

   514 

   515 	e = (struct razor_entry *) set->files.data + dir->start;

   516 	do {

   517 		n = pool + e->name;

   518 		if (strcmp(pattern + 1, n) == 0)

   519 			return e;

   520 		len = strlen(n);

   521 		if (e->start != 0 && strncmp(pattern + 1, n, len) == 0 &&

   522 		    pattern[len + 1] == '/') {

   523 			return razor_set_find_entry(set, e, pattern + len + 1);

   524 		}

   525 	} while (!((e++)->flags & RAZOR_ENTRY_LAST));

   526 

   527 	return NULL;

   528 }

   529 

   530 static void

   531 list_dir(struct razor_set *set, struct razor_entry *dir,

   532 	 char *prefix, const char *pattern)

   533 {

   534 	struct razor_entry *e;

   535 	const char *n, *pool = set->file_string_pool.data;

   536 

   537 	e = (struct razor_entry *) set->files.data + dir->start;

   538 	do {

   539 		n = pool + e->name;

   540 		if (pattern && pattern[0] && fnmatch(pattern, n, 0) != 0)

   541 			continue;

   542 		printf("%s/%s\n", prefix, n);

   543 		if (e->start) {

   544 			char *sub = prefix + strlen (prefix);

   545 			*sub = '/';

   546 			strcpy (sub + 1, n);

   547 			list_dir(set, e, prefix, pattern);

   548 			*sub = '\0';

   549 		}

   550 	} while (!((e++)->flags & RAZOR_ENTRY_LAST));

   551 }

   552 

   553 RAZOR_EXPORT void

   554 razor_set_list_files(struct razor_set *set, const char *pattern)

   555 {

   556 	struct razor_entry *e;

   557 	char buffer[512], *p, *base;

   558 

   559 	assert (set != NULL);

   560 

   561 	if (pattern == NULL || !strcmp (pattern, "/")) {

   562 		buffer[0] = '\0';

   563 		list_dir(set, set->files.data, buffer, NULL);

   564 		return;

   565 	}

   566 

   567 	strcpy(buffer, pattern);

   568 	e = razor_set_find_entry(set, set->files.data, buffer);

   569 	if (e && e->start > 0) {

   570 		base = NULL;

   571 	} else {

   572 		p = strrchr(buffer, '/');

   573 		if (p) {

   574 			*p = '\0';

   575 			base = p + 1;

   576 		} else {

   577 			base = NULL;

   578 		}

   579 	}

   580 	e = razor_set_find_entry(set, set->files.data, buffer);

   581 	if (e && e->start != 0)

   582 		list_dir(set, e, buffer, base);

   583 }

   584 

   585 static struct list *

   586 list_package_files(struct razor_set *set, struct list *r,

   587 		   struct razor_entry *dir, uint32_t end,

   588 		   char *prefix)

   589 {

   590 	struct razor_entry *e, *f, *entries;

   591 	uint32_t next, file;

   592 	char *pool;

   593 	int len;

   594 

   595 	entries = (struct razor_entry *) set->files.data;

   596 	pool = set->file_string_pool.data;

   597 

   598 	e = entries + dir->start;

   599 	do {

   600 		if (entries + r->data == e) {

   601 			printf("%s/%s\n", prefix, pool + e->name);

   602 			r = list_next(r);

   603 			if (!r)

   604 				return NULL;

   605 			if (r->data >= end)

   606 				return r;

   607 		}

   608 	} while (!((e++)->flags & RAZOR_ENTRY_LAST));

   609 

   610 	e = entries + dir->start;

   611 	do {

   612 		if (e->start == 0)

   613 			continue;

   614 

   615 		if (e->flags & RAZOR_ENTRY_LAST)

   616 			next = end;

   617 		else {

   618 			f = e + 1;

   619 			while (f->start == 0 && !(f->flags & RAZOR_ENTRY_LAST))

   620 				f++;

   621 			if (f->start == 0)

   622 				next = end;

   623 			else

   624 				next = f->start;

   625 		}

   626 

   627 		file = r->data;

   628 		if (e->start <= file && file < next) {

   629 			len = strlen(prefix);

   630 			prefix[len] = '/';

   631 			strcpy(prefix + len + 1, pool + e->name);

   632 			r = list_package_files(set, r, e, next, prefix);

   633 			prefix[len] = '\0';

   634 		}

   635 	} while (!((e++)->flags & RAZOR_ENTRY_LAST) && r != NULL);

   636 

   637 	return r;

   638 }

   639 

   640 RAZOR_EXPORT void

   641 razor_set_list_package_files(struct razor_set *set,

   642 			     struct razor_package *package)

   643 {

   644 	struct list *r;

   645 	uint32_t end;

   646 	char buffer[512];

   647 

   648 	assert (set != NULL);

   649 	assert (package != NULL);

   650 

   651 	r = list_first(&package->files, &set->file_pool);

   652 	end = set->files.size / sizeof (struct razor_entry);

   653 	buffer[0] = '\0';

   654 	list_package_files(set, r, set->files.data, end, buffer);

   655 }

   656 

   657 /* The diff order matters.  We should sort the packages so that a

   658  * REMOVE of a package comes before the INSTALL, and so that all

   659  * requires for a package have been installed before the package.

   660  **/

   661 

   662 RAZOR_EXPORT void

   663 razor_set_diff(struct razor_set *set, struct razor_set *upstream,

   664 	       razor_diff_callback_t callback, void *data)

   665 {

   666  	struct razor_package_iterator *pi1, *pi2;

   667  	struct razor_package *p1, *p2;

   668 	const char *name1, *name2, *version1, *version2, *arch1, *arch2;

   669 	int res;

   670 

   671 	assert (set != NULL);

   672 	assert (upstream != NULL);

   673 

   674 	pi1 = razor_package_iterator_create(set);

   675 	pi2 = razor_package_iterator_create(upstream);

   676 

   677 	razor_package_iterator_next(pi1, &p1,

   678 				    RAZOR_DETAIL_NAME, &name1,

   679 				    RAZOR_DETAIL_VERSION, &version1,

   680 				    RAZOR_DETAIL_ARCH, &arch1,

   681 				    RAZOR_DETAIL_LAST);

   682 	razor_package_iterator_next(pi2, &p2,

   683 				    RAZOR_DETAIL_NAME, &name2,

   684 				    RAZOR_DETAIL_VERSION, &version2,

   685 				    RAZOR_DETAIL_ARCH, &arch2,

   686 				    RAZOR_DETAIL_LAST);

   687 

   688 	while (p1 || p2) {

   689 		if (p1 && p2) {

   690 			res = strcmp(name1, name2);

   691 			if (res == 0)

   692 				res = razor_versioncmp(version1, version2);

   693 		} else {

   694 			res = 0;

   695 		}

   696 

   697 		if (p2 == NULL || res < 0)

   698 			callback(RAZOR_DIFF_ACTION_REMOVE,

   699 				 p1, name1, version1, arch1, data);

   700 		else if (p1 == NULL || res > 0)

   701 			callback(RAZOR_DIFF_ACTION_ADD,

   702 				 p2, name2, version2, arch2, data);

   703 

   704 		if (p1 != NULL && res <= 0)

   705 			razor_package_iterator_next(pi1, &p1,

   706 						    RAZOR_DETAIL_NAME, &name1,

   707 						    RAZOR_DETAIL_VERSION, &version1,

   708 						    RAZOR_DETAIL_ARCH, &arch1,

   709 						    RAZOR_DETAIL_LAST);

   710 		if (p2 != NULL && res >= 0)

   711 			razor_package_iterator_next(pi2, &p2,

   712 						    RAZOR_DETAIL_NAME, &name2,

   713 						    RAZOR_DETAIL_VERSION, &version2,

   714 						    RAZOR_DETAIL_ARCH, &arch2,

   715 						    RAZOR_DETAIL_LAST);

   716 	}

   717 

   718 	razor_package_iterator_destroy(pi1);

   719 	razor_package_iterator_destroy(pi2);

   720 }

   721 

   722 struct install_action {

   723 	enum razor_install_action action;

   724 	struct razor_package *package;

   725 };

   726 

   727 struct razor_install_iterator {

   728 	struct razor_set *set;

   729 	struct razor_set *next;

   730 	struct array actions;

   731 	struct install_action *a, *end;

   732 };

   733 

   734 static void

   735 add_action(enum razor_diff_action action,

   736 	   struct razor_package *package,

   737 	   const char *name,

   738 	   const char *version,

   739 	   const char *arch,

   740 	   void *data)

   741 {

   742 	struct razor_install_iterator *ii = data;

   743 	struct install_action *a;

   744 

   745 	a = array_add(&ii->actions, sizeof *a);

   746 	a->package = package;

   747 

   748 	switch (action) {

   749 	case RAZOR_DIFF_ACTION_ADD:

   750 		a->action = RAZOR_INSTALL_ACTION_ADD;

   751 		break;

   752 	case RAZOR_DIFF_ACTION_REMOVE:

   753 		a->action = RAZOR_INSTALL_ACTION_REMOVE;

   754 		break;

   755 	}

   756 }

   757 

   758 RAZOR_EXPORT struct razor_install_iterator *

   759 razor_set_create_install_iterator(struct razor_set *set,

   760 				  struct razor_set *next)

   761 {

   762 	struct razor_install_iterator *ii;

   763 

   764 	assert (set != NULL);

   765 	assert (next != NULL);

   766 

   767 	ii = zalloc(sizeof *ii);

   768 	ii->set = set;

   769 	ii->next = next;

   770 	

   771 	razor_set_diff(set, next, add_action, ii);

   772 

   773 	ii->a = ii->actions.data;

   774 	ii->end = ii->actions.data + ii->actions.size;

   775 

   776 	/* FIXME: We need to figure out the right install order here,

   777 	 * so the post and pre scripts can run. */

   778 

   779 	return ii;

   780 }

   781 

   782 RAZOR_EXPORT int

   783 razor_install_iterator_next(struct razor_install_iterator *ii,

   784 			    struct razor_set **set,

   785 			    struct razor_package **package,

   786 			    enum razor_install_action *action,

   787 			    int *count)

   788 {

   789 	if (ii->a == ii->end)

   790 		return 0;

   791 

   792 	switch (ii->a->action) {

   793 	case RAZOR_INSTALL_ACTION_ADD:

   794 		*set = ii->next;

   795 		break;

   796 	case RAZOR_INSTALL_ACTION_REMOVE:

   797 		*set = ii->set;

   798 		break;

   799 	}

   800 

   801 	*package = ii->a->package;

   802 	*action = ii->a->action;

   803 	*count = 0;

   804 	ii->a++;

   805 

   806 	return 1;

   807 }

   808 

   809 RAZOR_EXPORT void

   810 razor_install_iterator_destroy(struct razor_install_iterator *ii)

   811 {

   812 	array_release(&ii->actions);

   813 	free(ii);

   814 }
razor