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>
Fri Jan 27 07:55:30 2012 +0000 (2012-01-27)
changeset 405 f960eb19dca2
parent 395 ed134fdfe95f
child 406 5ab137def3d1
permissions -rw-r--r--
Start 0.5.1 
     1 /*

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

     3  * Copyright (C) 2008  Red Hat, Inc

     4  * Copyright (C) 2009-2011  J. Ali Harlow <ali@juiblex.co.uk>

     5  *

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

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

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

     9  * (at your option) any later version.

    10  *

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

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

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

    14  * GNU General Public License for more details.

    15  *

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

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

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

    19  */

    20 

    21 #define _GNU_SOURCE

    22 

    23 #include "config.h"

    24 

    25 #include <stdlib.h>

    26 #include <stddef.h>

    27 #include <stdint.h>

    28 #include <stdio.h>

    29 #include <stdarg.h>

    30 #include <string.h>

    31 #include <sys/types.h>

    32 #include <sys/stat.h>

    33 #include <unistd.h>

    34 #include <fcntl.h>

    35 #include <errno.h>

    36 #include <ctype.h>

    37 #include <fnmatch.h>

    38 #include <limits.h>

    39 #include <assert.h>

    40 #ifdef MSWIN_API

    41 #include <windows.h>

    42 #endif

    43 

    44 #include "razor-internal.h"

    45 #include "razor.h"

    46 

    47 #ifndef O_BINARY

    48 #define O_BINARY	0

    49 #endif

    50 

    51 void *

    52 zalloc(size_t size)

    53 {

    54 	void *p;

    55 

    56 	p = malloc(size);

    57 	memset(p, 0, size);

    58 

    59 	return p;

    60 }

    61 

    62 struct razor_set_section_index {

    63 	const char *name;

    64 	uint32_t offset;

    65 	uint32_t flags;

    66 };

    67 

    68 #define MAIN(type, field) \

    69 	{ type, offsetof(struct razor_set, field), RAZOR_SECTION_MAIN }

    70 #define FILES(type, field) \

    71 	{ type, offsetof(struct razor_set, field), RAZOR_SECTION_FILES }

    72 #define DETAILS(type, field) \

    73 	{ type, offsetof(struct razor_set, field), RAZOR_SECTION_DETAILS }

    74 

    75 struct razor_set_section_index razor_sections[] = {

    76 	MAIN(RAZOR_STRING_POOL, string_pool),

    77 	MAIN(RAZOR_PACKAGES, packages),

    78 	MAIN(RAZOR_PROPERTIES, properties),

    79 	MAIN(RAZOR_PACKAGE_POOL, package_pool),

    80 	MAIN(RAZOR_PROPERTY_POOL, property_pool),

    81 	MAIN(RAZOR_PREFIX_POOL, prefix_pool),

    82 	FILES(RAZOR_FILES, files),

    83 	FILES(RAZOR_FILE_POOL, file_pool),

    84 	FILES(RAZOR_FILE_STRING_POOL, file_string_pool),

    85 	DETAILS(RAZOR_DETAILS_STRING_POOL, details_string_pool)

    86 };

    87 

    88 RAZOR_EXPORT struct razor_set *

    89 razor_set_create_without_root(void)

    90 {

    91 	struct razor_set *set;

    92 	char *empty;

    93 

    94 	set = zalloc(sizeof *set);

    95 

    96 	if (set) {

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

    98 		*empty = '\0';

    99 

   100 		set->lock_fd = -1;

   101 

   102 		set->ref_count = 1;

   103 

   104 		set->header_version = RAZOR_HEADER_VERSION;

   105 	}

   106 

   107 	return set;

   108 }

   109 

   110 RAZOR_EXPORT struct razor_set *

   111 razor_set_create(void)

   112 {

   113 	struct razor_set *set;

   114 	struct razor_entry *e;

   115 

   116 	set = razor_set_create_without_root();

   117 

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

   119 	e->name = 0;

   120 	e->flags = RAZOR_ENTRY_LAST;

   121 	e->start = 0;

   122 	list_set_empty(&e->packages);

   123 

   124 	return set;

   125 }

   126 

   127 RAZOR_EXPORT uint32_t

   128 razor_set_get_header_version(struct razor_set *set)

   129 {

   130 	return set->header_version;

   131 }

   132 

   133 RAZOR_EXPORT int

   134 razor_set_set_header_version(struct razor_set *set, uint32_t header_version)

   135 {

   136 	if (header_version<RAZOR_HEADER_VERSION_MIN ||

   137 	    header_version>RAZOR_HEADER_VERSION)

   138 		return -1;

   139 	else {

   140 		set->header_version = header_version;

   141 		return 0;

   142 	}

   143 }

   144 

   145 struct razor_mapped_file {

   146 	struct razor_set_header *header;

   147 	size_t size;

   148 	struct razor_mapped_file *next;

   149 };

   150 

   151 RAZOR_EXPORT int

   152 razor_set_bind_sections(struct razor_set *set, struct razor_atomic *atomic,

   153 			const char *filename)

   154 {

   155 	struct razor_set_section *s, *sections;

   156 	struct razor_mapped_file *file;

   157 	const char *pool, *reason;

   158 	char *msg;

   159 	struct array *array;

   160 	int i, j;

   161 

   162 	file = zalloc(sizeof *file);

   163 	if (file == NULL) {

   164 		razor_atomic_abort(atomic, "Not enough memory");

   165 		return -1;

   166 	}

   167 

   168 	file->header = razor_file_get_contents(filename, &file->size);

   169 	if (!file->header) {

   170 		msg = razor_concat(filename, ": ", strerror(errno), NULL);

   171 		razor_atomic_abort(atomic, msg);

   172 		free(msg);

   173 		free(file);

   174 		return -1;

   175 	}

   176 

   177 	if (file->size < sizeof *file->header)

   178 		reason = "Premature EOF";

   179 	else if (file->header->magic != RAZOR_MAGIC)

   180 		reason = "Bad magic number";

   181 	else if (file->header->version < RAZOR_HEADER_VERSION_MIN ||

   182 		 file->header->version > RAZOR_HEADER_VERSION)

   183 		reason = "Incompatible file version";

   184 	else

   185 		reason = NULL;

   186 

   187 	if (reason) {

   188 		msg = razor_concat(filename, ": ", reason, NULL);

   189 		razor_atomic_abort(atomic, msg);

   190 		free(msg);

   191 		razor_file_free_contents(file->header, file->size);

   192 		free(file);

   193 		return -1;

   194 	}

   195 

   196 	set->header_version = file->header->version;

   197 

   198 	if (set->mapped_files == NULL) {

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

   200 			array = (void *) set + razor_sections[i].offset;

   201 			array_release(array);

   202 		}

   203 	}

   204 

   205 	file->next = set->mapped_files;

   206 	set->mapped_files = file;

   207 

   208 	sections = (void *) file->header + sizeof *file->header;

   209 	pool = (void *) sections +

   210 		file->header->num_sections * sizeof *sections;

   211 

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

   213 		s = sections + i;

   214 		for (j = 0; j < ARRAY_SIZE(razor_sections); j++)

   215 			if (!strcmp(razor_sections[j].name, &pool[s->name]))

   216 				break;

   217 		if (j == ARRAY_SIZE(razor_sections))

   218 			continue;

   219 		array = (void *) set + razor_sections[j].offset;

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

   221 		array->size = s->size;

   222 		array->alloc = s->size;

   223 	}

   224 

   225 	return 0;

   226 }

   227 

   228 RAZOR_EXPORT struct razor_set *

   229 razor_set_open(const char *filename, struct razor_atomic *atomic)

   230 {

   231 	struct razor_set *set;

   232 

   233 	set = zalloc(sizeof *set);

   234 	if (!set) {

   235 		razor_atomic_abort(atomic, "Not enough memory");

   236 		return NULL;

   237 	}

   238 

   239 	set->lock_fd = -1;

   240 	if (razor_set_bind_sections(set, atomic, filename)) {

   241 		free(set);

   242 		return NULL;

   243 	}

   244 	return set;

   245 }

   246 

   247 int

   248 razor_set_aquire_lock(struct razor_set *set, const char *path, int exclusive)

   249 {

   250 	int fd;

   251 	assert(set != NULL);

   252 

   253 	if (path) {

   254 		fd = open(path, O_CREAT | O_RDWR | O_TRUNC | O_BINARY, 0666);

   255 		if (fd < 0)

   256 			return -1;

   257 	} else {

   258 		fd = -1;

   259 	}

   260 

   261 #ifdef MSWIN_API

   262 	DWORD flags = LOCKFILE_FAIL_IMMEDIATELY;

   263 	OVERLAPPED lock = {0};

   264 

   265 	if (exclusive)

   266 		flags |= LOCKFILE_EXCLUSIVE_LOCK;

   267 	if (fd >= 0 && !LockFileEx((HANDLE)_get_osfhandle(fd), flags, 0, 1, 0,

   268 				   &lock)) {

   269 		close(fd);

   270 		return -1;

   271 	}

   272 	if (set->lock_fd >= 0)

   273 		(void)UnlockFile((HANDLE)_get_osfhandle(set->lock_fd), 0, 0, 1,

   274 				 0);

   275 #else

   276 	struct flock lock = {0};

   277 

   278 	lock.l_type = exclusive ? F_WRLCK : F_RDLCK;

   279 	lock.l_whence = SEEK_SET;

   280 	lock.l_start = 0;

   281 	lock.l_len = 0;

   282 	if (fd >= 0 && fcntl(fd, F_SETLK, &lock) < 0) {

   283 		close(fd);

   284 		return -1;

   285 	}

   286 	if (set->lock_fd >= 0) {

   287 		lock.l_type = F_UNLCK;

   288 		(void)fcntl(set->lock_fd, F_SETLK, &lock);

   289 	}

   290 #endif

   291 

   292 	if (set->lock_fd >= 0)

   293 		close(set->lock_fd);

   294 	set->lock_fd = fd;

   295 

   296 	return 0;

   297 }

   298 

   299 static void

   300 razor_set_destroy(struct razor_set *set)

   301 {

   302 	struct razor_mapped_file *file, *next;

   303 	struct array *array;

   304 	int i;

   305 

   306 	assert (set != NULL);

   307 

   308 	if (set->mapped_files == NULL) {

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

   310 			array = (void *) set + razor_sections[i].offset;

   311 			array_release(array);

   312 		}

   313 	} else {

   314 		for (file = set->mapped_files; file != NULL; file = next) {

   315 			next = file->next;

   316 			razor_file_free_contents(file->header, file->size);

   317 			free(file);

   318 		}

   319 	}

   320 

   321 	razor_set_aquire_lock(set, NULL, 0);

   322 	free(set);

   323 }

   324 

   325 RAZOR_EXPORT void

   326 razor_set_unref(struct razor_set *set)

   327 {

   328 	if (set && !--set->ref_count)

   329 		razor_set_destroy(set);

   330 }

   331 

   332 RAZOR_EXPORT struct razor_set *

   333 razor_set_ref(struct razor_set *set)

   334 {

   335 	if (set)

   336 		set->ref_count++;

   337 	return set;

   338 }

   339 

   340 RAZOR_EXPORT void

   341 razor_set_write_to_handle(struct razor_set *set, struct razor_atomic *atomic,

   342 			  int handle, uint32_t section_mask)

   343 {

   344 	struct razor_set_header header;

   345 	struct razor_set_section sections[ARRAY_SIZE(razor_sections)];

   346 	struct hashtable table;

   347 	struct array pool, *arrays[ARRAY_SIZE(razor_sections)];

   348 	uint32_t offset;

   349 	int count, i, j;

   350 	static const char padding[4];

   351 

   352 	array_init(&pool);

   353 	hashtable_init(&table, &pool);

   354 

   355 	j = 0;

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

   357 		if ((razor_sections[i].flags & section_mask) == 0)

   358 			continue;

   359 

   360 		arrays[j] = (void *) set + razor_sections[i].offset;

   361 		sections[j].name =

   362 			hashtable_tokenize(&table, razor_sections[i].name);

   363 		j++;

   364 	}

   365 

   366 	count = j;

   367 	header.magic = RAZOR_MAGIC;

   368 	header.version = set->header_version;

   369 	header.num_sections = count;

   370 	offset = sizeof header + count * sizeof *sections + ALIGN(pool.size, 4);

   371 

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

   373 		sections[i].offset = offset;

   374 		sections[i].size = arrays[i]->size;

   375 		offset += ALIGN(arrays[i]->size, 4);

   376 	}

   377 

   378 	razor_atomic_write(atomic, handle, &header, sizeof header);

   379 	razor_atomic_write(atomic, handle, sections, count * sizeof *sections);

   380 	razor_atomic_write(atomic, handle, pool.data, pool.size);

   381 	razor_atomic_write(atomic, handle, padding, PADDING(pool.size, 4));

   382 

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

   384 		razor_atomic_write(atomic, handle, arrays[i]->data,

   385 				   arrays[i]->size);

   386 		razor_atomic_write(atomic, handle, padding,

   387 				   PADDING(arrays[i]->size, 4));

   388 	}

   389 

   390 	array_release(&pool);

   391 	hashtable_release(&table);

   392 }

   393 

   394 RAZOR_EXPORT int

   395 razor_set_write(struct razor_set *set, struct razor_atomic *atomic,

   396 		const char *filename, uint32_t sections)

   397 {

   398 	int h;

   399 

   400 	h = razor_atomic_create_file(atomic, filename,

   401 				     S_IRWXU | S_IRWXG | S_IRWXO);

   402 	if (h < 0)

   403 		return -1;

   404 

   405 	razor_set_write_to_handle(set, atomic, h, sections);

   406 

   407 	return razor_atomic_close(atomic, h);

   408 }

   409 

   410 RAZOR_EXPORT void

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

   412 		const char *version, const char *release)

   413 {

   414 	int len;

   415 

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

   417 		*evr_buf = '\0';

   418 		return;

   419 	}

   420 

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

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

   423 		evr_buf += len;

   424 		size -= len;

   425 	}

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

   427 	evr_buf += len;

   428 	size -= len;

   429 	if (release && *release)

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

   431 }

   432 

   433 RAZOR_EXPORT int

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

   435 {

   436 	const char *p1, *p2;

   437 	long n1, n2;

   438 	int res;

   439 

   440 	assert (s1 != NULL);

   441 	assert (s2 != NULL);

   442 

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

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

   445 

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

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

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

   449 	if (res < 0) {

   450 		n1 = 0;

   451 		p1 = s1;

   452 		p2++;

   453 	} else if (res > 0) {

   454 		p1++;

   455 		n2 = 0;

   456 		p2 = s2;

   457 	}

   458 

   459 	if (n1 != n2)

   460 		return n1 - n2;

   461 	while (*p1 && *p2) {

   462 		if (*p1 != *p2)

   463 			return *p1 - *p2;

   464 		p1++;

   465 		p2++;

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

   467 			return razor_versioncmp(p1, p2);

   468 	}

   469 

   470 	return *p1 - *p2;

   471 }

   472 

   473 static const char *

   474 razor_package_get_details_string(struct razor_set *set,

   475 				 struct razor_package *package,

   476 				 enum razor_detail_type type)

   477 {

   478 	const char *pool;

   479 

   480 	switch (type) {

   481 	case RAZOR_DETAIL_NAME:

   482 		pool = set->string_pool.data;

   483 		return &pool[package->name];

   484 

   485 	case RAZOR_DETAIL_VERSION:

   486 		pool = set->string_pool.data;

   487 		return &pool[package->version];

   488 

   489 	case RAZOR_DETAIL_ARCH:

   490 		pool = set->string_pool.data;

   491 		return &pool[package->arch];

   492 

   493 	case RAZOR_DETAIL_SUMMARY:

   494 		if (!set->details_string_pool.size)

   495 			return "";

   496 		pool = set->details_string_pool.data;

   497 		return &pool[package->summary];

   498 

   499 	case RAZOR_DETAIL_DESCRIPTION:

   500 		if (!set->details_string_pool.size)

   501 			return "";

   502 		pool = set->details_string_pool.data;

   503 		return &pool[package->description];

   504 

   505 	case RAZOR_DETAIL_URL:

   506 		if (!set->details_string_pool.size)

   507 			return "";

   508 		pool = set->details_string_pool.data;

   509 		return &pool[package->url];

   510 

   511 	case RAZOR_DETAIL_LICENSE:

   512 		if (!set->details_string_pool.size)

   513 			return "";

   514 		pool = set->details_string_pool.data;

   515 		return &pool[package->license];

   516 

   517 	case RAZOR_DETAIL_PREUNPROG:

   518 		pool = set->string_pool.data;

   519 		return &pool[package->preun.program];

   520 

   521 	case RAZOR_DETAIL_PREUN:

   522 		pool = set->string_pool.data;

   523 		return &pool[package->preun.body];

   524 

   525 	case RAZOR_DETAIL_POSTUNPROG:

   526 		pool = set->string_pool.data;

   527 		return &pool[package->postun.program];

   528 

   529 	case RAZOR_DETAIL_POSTUN:

   530 		pool = set->string_pool.data;

   531 		return &pool[package->postun.body];

   532 

   533 	default:

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

   535 		return NULL;

   536 	}

   537 }

   538 

   539 static const char *const *

   540 razor_package_get_details_array(struct razor_set *set,

   541 				struct razor_package *package,

   542 				enum razor_detail_type type)

   543 {

   544 	switch (type) {

   545 	case RAZOR_DETAIL_PREFIXES:

   546 		/* We don't track prefixes in packages. Install prefixes

   547 		 * are tracked, but we don't provide an API to get them.

   548 		 */

   549 		return NULL;

   550 

   551 	default:

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

   553 		return NULL;

   554 	}

   555 }

   556 

   557 /**

   558  * razor_package_get_details_varg:

   559  * @set: a %razor_set

   560  * @package: a %razor_package

   561  * @args: a va_list of arguments to set

   562  **/

   563 void

   564 razor_package_get_details_varg(struct razor_set *set,

   565 			       struct razor_package *package,

   566 			       va_list args)

   567 {

   568 	int i;

   569 	enum razor_detail_type type;

   570 	const char **string;

   571 	const char *const **array;

   572 

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

   574 		type = va_arg(args, enum razor_detail_type);

   575 		if (type == RAZOR_DETAIL_LAST)

   576 			break;

   577 		if (type == RAZOR_DETAIL_PREFIXES) {

   578 			array = va_arg(args, const char *const **);

   579 			*array = razor_package_get_details_array(set, package,

   580 								 type);

   581 		} else {

   582 			string = va_arg(args, const char **);

   583 			*string = razor_package_get_details_string(set, package,

   584 								   type);

   585 		}

   586 	}

   587 

   588 }

   589 

   590 /**

   591  * razor_package_get_details:

   592  * @set: a %razor_set

   593  * @package: a %razor_package

   594  *

   595  * Gets details about a package using a varg interface

   596  * The vararg must be terminated with %RAZOR_DETAIL_LAST.

   597  *

   598  * Example: razor_package_get_details (set, package,

   599  *				       RAZOR_DETAIL_URL, &url,

   600  *				       RAZOR_DETAIL_LAST);

   601  **/

   602 RAZOR_EXPORT void

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

   604 {

   605 	va_list args;

   606 

   607 	assert (set != NULL);

   608 	assert (package != NULL);

   609 

   610 	va_start(args, NULL);

   611 	razor_package_get_details_varg (set, package, args);

   612 	va_end (args);

   613 }

   614 

   615 /**

   616  * razor_package_remove:

   617  * @prev: The %razor_set before the current transaction

   618  * @next: The %razor_set after the current transaction is applied

   619  * @package: a %razor_package

   620  * @root: the root into which the package is currently installed

   621  * @install_count: the value to pass to uninstall scripts

   622  * @stage: Limit the removal to just the scripts or the files

   623  *

   624  * Removes an installed package.

   625  **/

   626 RAZOR_EXPORT int

   627 razor_package_remove(struct razor_set *prev, struct razor_set *next,

   628 		     struct razor_atomic *atomic, struct razor_package *package,

   629 		     const char *root, int install_count,

   630 		     enum razor_stage_type stage)

   631 {

   632 	struct razor_file_iterator *fi;

   633 	struct razor_package_iterator *pi;

   634 	struct razor_package *p;

   635 	char *buffer;

   636 	const char *name, *program, *script;

   637 	int i, count;

   638 	struct environment env;

   639 	struct list *link;

   640 	const char *prefix;

   641 

   642 	if (stage & RAZOR_STAGE_SCRIPTS) {

   643 		environment_init(&env);

   644 		link = list_first(&package->install_prefixes,

   645 				  &prev->prefix_pool);

   646 		for (i = 0; link; i++) {

   647 			prefix = (const char *)prev->string_pool.data +

   648 				 link->data;

   649 			sprintf(buffer, "RPM_INSTALL_PREFIX%d", i);

   650 			environment_add_variable(&env, buffer, prefix);

   651 			link = list_next(link);

   652 		}

   653 		environment_set(&env);

   654 	}

   655 

   656 	if (stage & RAZOR_STAGE_SCRIPTS_PRE) {

   657 		razor_package_get_details(prev, package,

   658 					  RAZOR_DETAIL_PREUNPROG, &program,

   659 					  RAZOR_DETAIL_PREUN, &script,

   660 					  RAZOR_DETAIL_LAST);

   661 

   662 		razor_run_script(root, RAZOR_PROPERTY_PREUN, program,

   663 				 script, install_count);

   664 	}

   665 

   666 	if (stage & RAZOR_STAGE_FILES) {

   667 		fi = razor_file_iterator_create(prev, package, 1);

   668 

   669 		while (razor_file_iterator_next(fi, &name)) {

   670 			pi = razor_package_iterator_create_for_file(next, name);

   671 			count = 0;

   672 			while (razor_package_iterator_next(pi, &p,

   673 							   RAZOR_DETAIL_LAST))

   674 				count++;

   675 			razor_package_iterator_destroy(pi);

   676 			if (count <= 0) {

   677 				buffer = razor_concat(root, name, NULL);

   678 				razor_atomic_remove(atomic, buffer);

   679 				free(buffer);

   680 			}

   681 		}

   682 

   683 		razor_file_iterator_destroy(fi);

   684 	}

   685 

   686 	if (stage & RAZOR_STAGE_SCRIPTS_POST) {

   687 		razor_package_get_details(prev, package,

   688 					  RAZOR_DETAIL_POSTUNPROG, &program,

   689 					  RAZOR_DETAIL_POSTUN, &script,

   690 					  RAZOR_DETAIL_LAST);

   691 

   692 		razor_run_script(root, RAZOR_PROPERTY_POSTUN, program, script,

   693 				 install_count);

   694 	}

   695 

   696 	if (stage & RAZOR_STAGE_SCRIPTS) {

   697 		environment_unset(&env);

   698 		environment_release(&env);

   699 	}

   700 

   701 	return razor_atomic_in_error_state(atomic);

   702 }

   703 

   704 RAZOR_EXPORT const char *

   705 razor_property_relation_to_string(struct razor_property *p)

   706 {

   707 	assert (p != NULL);

   708 

   709 	switch (p->flags & RAZOR_PROPERTY_RELATION_MASK) {

   710 	case RAZOR_PROPERTY_LESS:

   711 		return "<";

   712 

   713 	case RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL:

   714 		return "<=";

   715 

   716 	case RAZOR_PROPERTY_EQUAL:

   717 		return "=";

   718 

   719 	case RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL:

   720 		return ">=";

   721 

   722 	case RAZOR_PROPERTY_GREATER:

   723 		return ">";

   724 

   725 	default:

   726 		return "?";

   727 	}

   728 }

   729 

   730 RAZOR_EXPORT const char *

   731 razor_property_type_to_string(struct razor_property *p)

   732 {

   733 	assert (p != NULL);

   734 

   735 	switch (p->flags & RAZOR_PROPERTY_TYPE_MASK) {

   736 	case RAZOR_PROPERTY_REQUIRES:

   737 		return "requires";

   738 	case RAZOR_PROPERTY_PROVIDES:

   739 		return "provides";

   740 	case RAZOR_PROPERTY_CONFLICTS:

   741 		return "conflicts";

   742 	case RAZOR_PROPERTY_OBSOLETES:

   743 		return "obsoletes";

   744 	default:

   745 		return NULL;

   746 	}

   747 }

   748 

   749 RAZOR_EXPORT struct razor_entry *

   750 razor_set_find_entry(struct razor_set *set,

   751 		     struct razor_entry *dir, const char *pattern)

   752 {

   753 	struct razor_entry *e, *subdir;

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

   755 	int len;

   756 

   757 	assert (set != NULL);

   758 	assert (pattern != NULL);

   759 

   760 	if (dir == NULL)

   761 		return NULL;

   762 

   763 	e = dir;

   764 	do {

   765 		n = pool + e->name;

   766 		if (strcmp(pattern, n) == 0)

   767 			return e;

   768 		len = strlen(n);

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

   770 		    pattern[len] == '/') {

   771 			subdir = (struct razor_entry *) set->files.data +

   772 				 e->start;

   773 			return razor_set_find_entry(set, subdir,

   774 						    pattern + len + 1);

   775 		}

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

   777 

   778 	return NULL;

   779 }

   780 

   781 static void

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

   783 	 char *prefix, const char *pattern)

   784 {

   785 	struct razor_entry *e, *subdir;

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

   787 

   788 	e = dir;

   789 	do {

   790 		n = pool + e->name;

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

   792 			continue;

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

   794 		if (e->start) {

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

   796 			*sub = '/';

   797 			strcpy (sub + 1, n);

   798 			subdir = (struct razor_entry *) set->files.data +

   799 				 e->start;

   800 			list_dir(set, subdir, prefix, pattern);

   801 			*sub = '\0';

   802 		}

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

   804 }

   805 

   806 RAZOR_EXPORT void

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

   808 {

   809 	struct razor_entry *root, *e;

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

   811 

   812 	assert (set != NULL);

   813 

   814 	root = (struct razor_entry *) set->files.data;

   815 

   816 	if (pattern == NULL) {

   817 		p = set->file_string_pool.data;

   818 		e = root;

   819 		do {

   820 			if (e->start) {

   821 				strcpy(buffer, p + e->name);

   822 				list_dir(set, root + e->start, buffer, NULL);

   823 			}

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

   825 		return;

   826 	}

   827 

   828 	strcpy(buffer, pattern);

   829 	e = razor_set_find_entry(set, root, buffer);

   830 	if (e && e->start) {

   831 		base = NULL;

   832 	} else {

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

   834 		if (p) {

   835 			*p = '\0';

   836 			base = p + 1;

   837 		} else {

   838 			base = NULL;

   839 		}

   840 	}

   841 	e = razor_set_find_entry(set, root, buffer);

   842 	if (e && e->start)

   843 		list_dir(set, root + e->start, buffer, base);

   844 }

   845 

   846 RAZOR_EXPORT void

   847 razor_set_list_package_files(struct razor_set *set,

   848 			     struct razor_package *package)

   849 {

   850 	struct razor_file_iterator *fi;

   851 	const char *name;

   852 

   853 	assert (set != NULL);

   854 	assert (package != NULL);

   855 

   856 	fi = razor_file_iterator_create(set, package, 0);

   857 

   858 	while (razor_file_iterator_next(fi, &name))

   859 		printf("%s\n", name);

   860 

   861 	razor_file_iterator_destroy(fi);

   862 }

   863 

   864 /*

   865  * Package data can potentially come from two places. The so-called

   866  * metadata (eg., from comps.xml) and from an RPM file. We consider

   867  * a package which has additional data from an RPM file as "fixed".

   868  * If a package needs fixing, then razor_transaction_fixup_package()

   869  * will do so. When considering what packages to add and to remove

   870  * we need to take this into account since we always want to add

   871  * unfixed packages (otherwise we have a potential conflict between

   872  * the existing package data and that present in the RPM).

   873  */

   874 static int

   875 razor_package_is_fixed(struct razor_set *set, struct razor_package *p)

   876 {

   877 	const char *preunprog, *preun, *postunprog, *postun;

   878 

   879 	if (!p)

   880 		return 0;

   881 	razor_package_get_details(set, p,

   882 				  RAZOR_DETAIL_PREUNPROG, &preunprog,

   883 				  RAZOR_DETAIL_PREUN, &preun,

   884 				  RAZOR_DETAIL_POSTUNPROG, &postunprog,

   885 				  RAZOR_DETAIL_POSTUN, &postun,

   886 				  RAZOR_DETAIL_LAST);

   887 	return *preunprog || *preun || *postunprog || *postun;

   888 }

   889 

   890 RAZOR_EXPORT void

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

   892 	       razor_diff_callback_t callback, void *data)

   893 {

   894  	struct razor_package_iterator *pi1, *pi2;

   895  	struct razor_package *p1, *p2;

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

   897 	int res, is_fixed1, is_fixed2;

   898 

   899 	assert (set != NULL);

   900 	assert (upstream != NULL);

   901 

   902 	pi1 = razor_package_iterator_create(set);

   903 	pi2 = razor_package_iterator_create(upstream);

   904 

   905 	razor_package_iterator_next(pi1, &p1,

   906 				    RAZOR_DETAIL_NAME, &name1,

   907 				    RAZOR_DETAIL_VERSION, &version1,

   908 				    RAZOR_DETAIL_ARCH, &arch1,

   909 				    RAZOR_DETAIL_LAST);

   910 	is_fixed1 = razor_package_is_fixed(set, p1);

   911 	razor_package_iterator_next(pi2, &p2,

   912 				    RAZOR_DETAIL_NAME, &name2,

   913 				    RAZOR_DETAIL_VERSION, &version2,

   914 				    RAZOR_DETAIL_ARCH, &arch2,

   915 				    RAZOR_DETAIL_LAST);

   916 	is_fixed2 = razor_package_is_fixed(upstream, p2);

   917 

   918 	while (p1 || p2) {

   919 		if (p1 && p2) {

   920 			res = strcmp(name1, name2);

   921 			if (res == 0)

   922 				res = razor_versioncmp(version1, version2);

   923 			if (res == 0)

   924 				res = is_fixed1 - is_fixed2;

   925 		} else {

   926 			res = 0;

   927 		}

   928 

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

   930 			callback(RAZOR_DIFF_ACTION_REMOVE,

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

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

   933 			callback(RAZOR_DIFF_ACTION_ADD,

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

   935 

   936 		if (p1 != NULL && res <= 0) {

   937 			razor_package_iterator_next(pi1, &p1,

   938 						    RAZOR_DETAIL_NAME, &name1,

   939 						    RAZOR_DETAIL_VERSION, &version1,

   940 						    RAZOR_DETAIL_ARCH, &arch1,

   941 						    RAZOR_DETAIL_LAST);

   942 			is_fixed1 = razor_package_is_fixed(set, p1);

   943 		}

   944 		if (p2 != NULL && res >= 0) {

   945 			razor_package_iterator_next(pi2, &p2,

   946 						    RAZOR_DETAIL_NAME, &name2,

   947 						    RAZOR_DETAIL_VERSION, &version2,

   948 						    RAZOR_DETAIL_ARCH, &arch2,

   949 						    RAZOR_DETAIL_LAST);

   950 			is_fixed2 = razor_package_is_fixed(upstream, p2);

   951 		}

   952 	}

   953 

   954 	razor_package_iterator_destroy(pi1);

   955 	razor_package_iterator_destroy(pi2);

   956 }

   957 

   958 struct install_action {

   959 	enum razor_install_action action;

   960 	struct razor_package *package;

   961 };

   962 

   963 struct razor_install_iterator {

   964 	struct razor_set *set;

   965 	struct razor_set *next;

   966 	struct array actions;

   967 	struct deque *order, *left;

   968 };

   969 

   970 static void

   971 add_action(enum razor_diff_action action,

   972 	   struct razor_package *package,

   973 	   const char *name,

   974 	   const char *version,

   975 	   const char *arch,

   976 	   void *data)

   977 {

   978 	struct razor_install_iterator *ii = data;

   979 	struct install_action *a;

   980 

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

   982 	a->package = package;

   983 

   984 	switch (action) {

   985 	case RAZOR_DIFF_ACTION_ADD:

   986 		a->action = RAZOR_INSTALL_ACTION_ADD;

   987 		break;

   988 	case RAZOR_DIFF_ACTION_REMOVE:

   989 		a->action = RAZOR_INSTALL_ACTION_REMOVE;

   990 		break;

   991 	}

   992 }

   993 

   994 RAZOR_EXPORT struct razor_install_iterator *

   995 razor_set_create_install_iterator(struct razor_set *set,

   996 				  struct razor_set *next)

   997 {

   998 	struct razor_install_iterator *ii;

   999 	struct razor_property *prop;

  1000 	/* A graph of the actions to be perfomed where

  1001 	 * A->B means action A should follow action B.

  1002 	 */

  1003 	struct graph follows;

  1004 	struct install_action *actions, *ai, *aj;

  1005 	int i, j, count, vertex_added;

  1006 	struct list *link;

  1007 	struct razor_set *rs;

  1008 

  1009 	assert (set != NULL);

  1010 	assert (next != NULL);

  1011 

  1012 	ii = zalloc(sizeof *ii);

  1013 	ii->set = set;

  1014 	ii->next = next;

  1015 	

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

  1017 

  1018 	actions = ii->actions.data;

  1019 	count = ii->actions.size / sizeof (struct install_action);

  1020 

  1021 	graph_init(&follows);

  1022 

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

  1024 		ai = actions + i;

  1025 		rs = ai->action == RAZOR_INSTALL_ACTION_ADD ? next : set;

  1026 		vertex_added = 0;

  1027 		link = list_first(&ai->package->properties, &rs->property_pool);

  1028 		for(; link; link = list_next(link)) {

  1029 			prop = rs->properties.data;

  1030 			prop += link->data;

  1031 			switch(prop->flags & RAZOR_PROPERTY_TYPE_MASK) {

  1032 			case RAZOR_PROPERTY_REQUIRES:

  1033 			case RAZOR_PROPERTY_CONFLICTS:

  1034 				for(j = 0; j < count; j++) {

  1035 					if (j == i)

  1036 						continue;

  1037 					aj = actions + j;

  1038 					if (aj->package->name == prop->name) {

  1039 						if (ai->action ==

  1040 						    RAZOR_INSTALL_ACTION_ADD)

  1041 							graph_add_edge(&follows,

  1042 								       i, j);

  1043 						else

  1044 							graph_add_edge(&follows,

  1045 								       j, i);

  1046 						vertex_added++;

  1047 					}

  1048 				}

  1049 				break;

  1050 			}

  1051 		}

  1052 		if (ai->action == RAZOR_INSTALL_ACTION_ADD) {

  1053 			for(j = 0; j < count; j++) {

  1054 				if (j == i)

  1055 					continue;

  1056 				aj = actions + j;

  1057 				if (aj->package == ai->package &&

  1058 				    aj->action == RAZOR_INSTALL_ACTION_REMOVE) {

  1059 					graph_add_edge(&follows, i, j);

  1060 					vertex_added++;

  1061 				}

  1062 			}

  1063 		}

  1064 		if (!vertex_added)

  1065 			graph_add_edge(&follows, i, i);

  1066 	}

  1067 

  1068 	ii->order = graph_sort(&follows);

  1069 	ii->left = deque_dup(ii->order);

  1070 	graph_release(&follows);

  1071 

  1072 	return ii;

  1073 }

  1074 

  1075 RAZOR_EXPORT int

  1076 razor_install_iterator_next(struct razor_install_iterator *ii,

  1077 			    struct razor_package **package,

  1078 			    enum razor_install_action *action,

  1079 			    int *count)

  1080 {

  1081 	struct install_action *a;

  1082 	struct razor_package_iterator *pi;

  1083 	struct razor_package *pkg;

  1084 	const char *removing, *name;

  1085 

  1086 	if (deque_empty(ii->left))

  1087 		return 0;

  1088 

  1089 	a = (struct install_action *)ii->actions.data + deque_pop(ii->left);

  1090 	*package = a->package;

  1091 	*action = a->action;

  1092 	*count = 0;

  1093 

  1094 	if (a->action == RAZOR_INSTALL_ACTION_REMOVE) {

  1095 		razor_package_get_details(ii->set, a->package,

  1096 					  RAZOR_DETAIL_NAME, &removing,

  1097 					  RAZOR_DETAIL_LAST);

  1098 

  1099 		pi = razor_package_iterator_create(ii->next);

  1100 		while (razor_package_iterator_next(pi, &pkg,

  1101 						   RAZOR_DETAIL_NAME, &name,

  1102 						   RAZOR_DETAIL_LAST)) {

  1103 			if (!strcmp(name, removing))

  1104 				(*count)++;

  1105 		}

  1106 		razor_package_iterator_destroy(pi);

  1107 	} else

  1108 		*count = 1;

  1109 

  1110 	return 1;

  1111 }

  1112 

  1113 RAZOR_EXPORT void

  1114 razor_install_iterator_rewind(struct razor_install_iterator *ii)

  1115 {

  1116 	deque_free(ii->left);

  1117 	ii->left=deque_dup(ii->order);

  1118 }

  1119 

  1120 RAZOR_EXPORT void

  1121 razor_install_iterator_destroy(struct razor_install_iterator *ii)

  1122 {

  1123 	array_release(&ii->actions);

  1124 	deque_free(ii->order);

  1125 	deque_free(ii->left);

  1126 	free(ii);

  1127 }
razor