razor: razor.c@d8b7dd11813d (annotated)

krh@15	1	#define _GNU_SOURCE
krh@15	2
krh@0	3	#include <stdlib.h>
krh@19	4	#include <stddef.h>
danw@108	5	#include <stdint.h>
krh@0	6	#include <stdio.h>
krh@0	7	#include <string.h>
krh@0	8	#include <sys/types.h>
krh@0	9	#include <sys/stat.h>
krh@0	10	#include <sys/mman.h>
krh@0	11	#include <unistd.h>
krh@0	12	#include <fcntl.h>
krh@15	13	#include <errno.h>
krh@35	14	#include <ctype.h>
krh@54	15	#include <fnmatch.h>
krh@0	16
krh@27	17	#include "razor.h"
krh@91	18	#include "razor-internal.h"
danw@115	19	#include "types.h"
krh@30	20
krh@30	21	struct razor_set_section {
danw@108	22	uint32_t type;
danw@108	23	uint32_t offset;
danw@108	24	uint32_t size;
krh@30	25	};
krh@30	26
krh@30	27	struct razor_set_header {
danw@108	28	uint32_t magic;
danw@108	29	uint32_t version;
krh@30	30	struct razor_set_section sections[0];
krh@30	31	};
krh@30	32
krh@30	33	#define RAZOR_MAGIC 0x7a7a7a7a
krh@30	34	#define RAZOR_VERSION 1
krh@30	35
krh@66	36	#define RAZOR_STRING_POOL 0
krh@66	37	#define RAZOR_PACKAGES 1
krh@66	38	#define RAZOR_PROPERTIES 2
krh@66	39	#define RAZOR_FILES 3
krh@66	40	#define RAZOR_PACKAGE_POOL 4
krh@66	41	#define RAZOR_PROPERTY_POOL 5
krh@66	42	#define RAZOR_FILE_POOL 6
krh@30	43
krh@30	44	struct razor_package {
danw@120	45	uint name : 24;
danw@120	46	uint flags : 8;
danw@108	47	uint32_t version;
danw@117	48	struct list_head properties;
danw@117	49	struct list_head files;
krh@30	50	};
krh@30	51
krh@30	52	struct razor_property {
danw@119	53	uint name : 24;
danw@119	54	uint flags : 6;
danw@162	55	enum razor_property_type type : 2;
danw@162	56	enum razor_version_relation relation : 32;
danw@108	57	uint32_t version;
danw@117	58	struct list_head packages;
krh@30	59	};
krh@30	60
krh@48	61	struct razor_entry {
danw@120	62	uint name : 24;
danw@120	63	uint flags : 8;
danw@108	64	uint32_t start;
danw@117	65	struct list_head packages;
krh@48	66	};
krh@48	67
danw@120	68	#define RAZOR_ENTRY_LAST 0x80
danw@120	69
krh@30	70	struct razor_set {
krh@30	71	struct array string_pool;
krh@30	72	struct array packages;
krh@66	73	struct array properties;
krh@56	74	struct array files;
krh@56	75	struct array package_pool;
krh@66	76	struct array property_pool;
krh@56	77	struct array file_pool;
krh@30	78	struct razor_set_header *header;
krh@30	79	};
krh@30	80
krh@52	81	struct import_entry {
danw@108	82	uint32_t package;
krh@52	83	char *name;
krh@52	84	};
krh@52	85
krh@52	86	struct import_directory {
danw@108	87	uint32_t name, count;
krh@52	88	struct array files;
krh@52	89	struct array packages;
krh@52	90	struct import_directory *last;
krh@52	91	};
krh@52	92
krh@30	93	struct razor_importer {
krh@30	94	struct razor_set *set;
krh@78	95	struct hashtable table;
krh@30	96	struct razor_package *package;
krh@66	97	struct array properties;
krh@48	98	struct array files;
danw@159	99	struct array file_requires;
krh@30	100	};
krh@30	101
krh@0	102	static void *
krh@0	103	zalloc(size_t size)
krh@0	104	{
krh@0	105	void *p;
krh@0	106
krh@0	107	p = malloc(size);
krh@0	108	memset(p, 0, size);
krh@0	109
krh@0	110	return p;
krh@0	111	}
krh@0	112
krh@19	113	struct razor_set_section razor_sections[] = {
krh@56	114	{ RAZOR_STRING_POOL, offsetof(struct razor_set, string_pool) },
krh@19	115	{ RAZOR_PACKAGES, offsetof(struct razor_set, packages) },
krh@66	116	{ RAZOR_PROPERTIES, offsetof(struct razor_set, properties) },
krh@56	117	{ RAZOR_FILES, offsetof(struct razor_set, files) },
krh@39	118	{ RAZOR_PACKAGE_POOL, offsetof(struct razor_set, package_pool) },
krh@66	119	{ RAZOR_PROPERTY_POOL, offsetof(struct razor_set, property_pool) },
krh@56	120	{ RAZOR_FILE_POOL, offsetof(struct razor_set, file_pool) },
krh@19	121	};
krh@19	122
krh@4	123	struct razor_set *
krh@4	124	razor_set_create(void)
krh@0	125	{
krh@150	126	struct razor_set *set;
krh@150	127	struct razor_entry *e;
danw@167	128	char *empty;
krh@150	129
krh@150	130	set = zalloc(sizeof *set);
krh@150	131
krh@150	132	e = array_add(&set->files, sizeof *e);
danw@167	133	empty = array_add(&set->string_pool, 1);
danw@167	134	*empty = '\0';
krh@150	135	e->name = 0;
krh@150	136	e->flags = RAZOR_ENTRY_LAST;
krh@150	137	e->start = 0;
krh@150	138	list_set_empty(&e->packages);
krh@150	139
krh@150	140	return set;
krh@0	141	}
krh@0	142
krh@4	143	struct razor_set *
krh@4	144	razor_set_open(const char *filename)
krh@0	145	{
krh@4	146	struct razor_set *set;
krh@19	147	struct razor_set_section *s;
krh@0	148	struct stat stat;
krh@19	149	struct array *array;
krh@19	150	int fd;
krh@0	151
krh@4	152	set = zalloc(sizeof *set);
krh@0	153	fd = open(filename, O_RDONLY);
krh@0	154	if (fstat(fd, &stat) < 0)
krh@0	155	return NULL;
krh@4	156	set->header = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
krh@4	157	if (set->header == MAP_FAILED) {
krh@4	158	free(set);
krh@0	159	return NULL;
krh@0	160	}
krh@0	161
krh@19	162	for (s = set->header->sections; ~s->type; s++) {
krh@19	163	if (s->type >= ARRAY_SIZE(razor_sections))
krh@19	164	continue;
krh@19	165	if (s->type != razor_sections[s->type].type)
krh@19	166	continue;
krh@19	167	array = (void *) set + razor_sections[s->type].offset;
krh@19	168	array->data = (void *) set->header + s->offset;
krh@19	169	array->size = s->size;
krh@19	170	array->alloc = s->size;
krh@0	171	}
krh@0	172	close(fd);
krh@0	173
krh@4	174	return set;
krh@0	175	}
krh@0	176
krh@0	177	void
krh@4	178	razor_set_destroy(struct razor_set *set)
krh@0	179	{
krh@0	180	unsigned int size;
krh@19	181	struct array *a;
krh@0	182	int i;
krh@0	183
krh@4	184	if (set->header) {
krh@4	185	for (i = 0; set->header->sections[i].type; i++)
krh@0	186	;
krh@4	187	size = set->header->sections[i].type;
krh@4	188	munmap(set->header, size);
krh@0	189	} else {
krh@19	190	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {
krh@19	191	a = (void *) set + razor_sections[i].offset;
krh@19	192	free(a->data);
krh@19	193	}
krh@0	194	}
krh@0	195
krh@4	196	free(set);
krh@0	197	}
krh@0	198
krh@43	199	int
krh@4	200	razor_set_write(struct razor_set set, const char filename)
krh@0	201	{
krh@0	202	char data[4096];
krh@4	203	struct razor_set_header header = (struct razor_set_header ) data;
krh@19	204	struct array *a;
danw@108	205	uint32_t offset;
krh@17	206	int i, fd;
krh@0	207
krh@0	208	memset(data, 0, sizeof data);
krh@4	209	header->magic = RAZOR_MAGIC;
krh@4	210	header->version = RAZOR_VERSION;
krh@17	211	offset = sizeof data;
krh@0	212
krh@19	213	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {
krh@19	214	if (razor_sections[i].type != i)
krh@19	215	continue;
krh@19	216	a = (void *) set + razor_sections[i].offset;
krh@19	217	header->sections[i].type = i;
krh@17	218	header->sections[i].offset = offset;
krh@19	219	header->sections[i].size = a->size;
krh@91	220	offset += ALIGN(a->size, 4096);
krh@17	221	}
krh@0	222
krh@19	223	header->sections[i].type = ~0;
krh@17	224	header->sections[i].offset = 0;
krh@17	225	header->sections[i].size = 0;
krh@10	226
krh@0	227	fd = open(filename, O_CREAT \| O_WRONLY \| O_TRUNC, 0666);
krh@0	228	if (fd < 0)
krh@0	229	return -1;
krh@0	230
krh@91	231	razor_write(fd, data, sizeof data);
danw@113	232	memset(data, 0, sizeof data);
krh@19	233	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {
krh@19	234	if (razor_sections[i].type != i)
krh@19	235	continue;
krh@19	236	a = (void *) set + razor_sections[i].offset;
danw@113	237	razor_write(fd, a->data, a->size);
danw@113	238	razor_write(fd, data, ALIGN(a->size, 4096) - a->size);
krh@19	239	}
krh@17	240
krh@17	241	close(fd);
krh@0	242
krh@0	243	return 0;
krh@0	244	}
krh@0	245
krh@27	246	void
danw@143	247	razor_build_evr(char evr_buf, int size, const char epoch,
danw@143	248	const char version, const char release)
danw@143	249	{
danw@143	250	int len;
danw@143	251
danw@143	252	if (!version \|\| !*version) {
danw@143	253	*evr_buf = '\0';
danw@143	254	return;
danw@143	255	}
danw@143	256
danw@143	257	if (epoch && *epoch && strcmp(epoch, "0") != 0) {
danw@143	258	len = snprintf(evr_buf, size, "%s:", epoch);
danw@143	259	evr_buf += len;
danw@143	260	size -= len;
danw@143	261	}
danw@143	262	len = snprintf(evr_buf, size, "%s", version);
danw@143	263	evr_buf += len;
danw@143	264	size -= len;
danw@143	265	if (release && *release)
danw@143	266	snprintf(evr_buf, size, "-%s", release);
danw@143	267	}
danw@143	268
danw@143	269	void
krh@30	270	razor_importer_begin_package(struct razor_importer *importer,
krh@30	271	const char name, const char version)
krh@13	272	{
krh@25	273	struct razor_package *p;
krh@13	274
krh@30	275	p = array_add(&importer->set->packages, sizeof *p);
krh@95	276	p->name = hashtable_tokenize(&importer->table, name);
danw@120	277	p->flags = 0;
krh@95	278	p->version = hashtable_tokenize(&importer->table, version);
krh@13	279
krh@30	280	importer->package = p;
krh@66	281	array_init(&importer->properties);
krh@13	282	}
krh@13	283
krh@13	284	void
krh@30	285	razor_importer_finish_package(struct razor_importer *importer)
krh@13	286	{
danw@117	287	list_set_array(&importer->package->properties,
danw@117	288	&importer->set->property_pool,
danw@124	289	&importer->properties,
danw@124	290	1);
krh@13	291
krh@66	292	array_release(&importer->properties);
krh@13	293	}
krh@13	294
krh@66	295	void
krh@30	296	razor_importer_add_property(struct razor_importer *importer,
danw@109	297	const char *name,
danw@109	298	enum razor_version_relation relation,
danw@109	299	const char *version,
krh@66	300	enum razor_property_type type)
krh@13	301	{
krh@25	302	struct razor_property *p;
danw@108	303	uint32_t *r;
krh@13	304
krh@66	305	p = array_add(&importer->set->properties, sizeof *p);
danw@119	306	p->name = hashtable_tokenize(&importer->table, name);
danw@119	307	p->flags = 0;
danw@119	308	p->type = type;
danw@109	309	p->relation = relation;
krh@95	310	p->version = hashtable_tokenize(&importer->table, version);
danw@117	311	list_set_ptr(&p->packages, importer->package -
danw@117	312	(struct razor_package *) importer->set->packages.data);
krh@13	313
krh@66	314	r = array_add(&importer->properties, sizeof *r);
krh@66	315	r = p - (struct razor_property ) importer->set->properties.data;
danw@159	316
danw@159	317	if (type == RAZOR_PROPERTY_REQUIRES && *name == '/') {
danw@159	318	r = array_add(&importer->file_requires, sizeof *r);
danw@159	319	*r = p->name;
danw@159	320	}
krh@30	321	}
krh@30	322
krh@46	323	void
krh@46	324	razor_importer_add_file(struct razor_importer importer, const char name)
krh@46	325	{
krh@52	326	struct import_entry *e;
krh@48	327
krh@52	328	e = array_add(&importer->files, sizeof *e);
krh@52	329
krh@52	330	e->package = importer->package -
krh@52	331	(struct razor_package *) importer->set->packages.data;
krh@52	332	e->name = strdup(name);
krh@46	333	}
krh@46	334
krh@30	335	struct razor_importer *
krh@30	336	razor_importer_new(void)
krh@30	337	{
krh@30	338	struct razor_importer *importer;
krh@30	339
krh@30	340	importer = zalloc(sizeof *importer);
krh@30	341	importer->set = razor_set_create();
krh@78	342	hashtable_init(&importer->table, &importer->set->string_pool);
krh@30	343
krh@30	344	return importer;
krh@9	345	}
krh@9	346
krh@75	347	/* Destroy an importer without creating the set. */
krh@75	348	void
krh@75	349	razor_importer_destroy(struct razor_importer *importer)
krh@75	350	{
krh@75	351	/* FIXME: write this */
krh@75	352	}
krh@75	353
krh@9	354	static int
krh@35	355	versioncmp(const char s1, const char s2)
krh@35	356	{
krh@35	357	const char p1, p2;
krh@35	358	long n1, n2;
krh@35	359	int res;
krh@35	360
danw@153	361	n1 = strtol(s1, (char **) &p1, 10);
danw@153	362	n2 = strtol(s2, (char **) &p2, 10);
krh@35	363
krh@35	364	/* Epoch; if one but not the other has an epoch set, default
krh@35	365	* the epoch-less version to 0. */
krh@35	366	res = (p1 == ':') - (p2 == ':');
krh@35	367	if (res < 0) {
krh@35	368	n1 = 0;
krh@35	369	p1 = s1;
krh@35	370	p2++;
krh@35	371	} else if (res > 0) {
krh@35	372	p1++;
krh@35	373	n2 = 0;
krh@35	374	p2 = s2;
krh@35	375	}
krh@35	376
krh@35	377	if (n1 != n2)
krh@35	378	return n1 - n2;
krh@35	379	while (p1 && p2) {
krh@35	380	if (p1 != p2)
krh@35	381	return p1 - p2;
krh@35	382	p1++;
krh@35	383	p2++;
krh@35	384	if (isdigit(p1) && isdigit(p2))
krh@35	385	return versioncmp(p1, p2);
krh@35	386	}
krh@35	387
krh@35	388	return p1 - p2;
krh@35	389	}
krh@35	390
krh@35	391	static int
krh@22	392	compare_packages(const void p1, const void p2, void *data)
krh@9	393	{
krh@25	394	const struct razor_package pkg1 = p1, pkg2 = p2;
krh@22	395	struct razor_set *set = data;
krh@22	396	char *pool = set->string_pool.data;
krh@9	397
danw@120	398	/* FIXME: what if the flags are different? */
krh@23	399	if (pkg1->name == pkg2->name)
krh@35	400	return versioncmp(&pool[pkg1->version], &pool[pkg2->version]);
krh@23	401	else
krh@23	402	return strcmp(&pool[pkg1->name], &pool[pkg2->name]);
krh@9	403	}
krh@9	404
krh@9	405	static int
krh@22	406	compare_properties(const void p1, const void p2, void *data)
krh@9	407	{
krh@25	408	const struct razor_property prop1 = p1, prop2 = p2;
krh@22	409	struct razor_set *set = data;
krh@22	410	char *pool = set->string_pool.data;
krh@9	411
danw@119	412	if (prop1->name != prop2->name)
danw@119	413	return strcmp(&pool[prop1->name], &pool[prop2->name]);
danw@119	414	else if (prop1->type != prop2->type)
danw@119	415	return prop1->type - prop2->type;
danw@119	416	else if (prop1->relation != prop2->relation)
danw@119	417	return prop1->relation - prop2->relation;
krh@12	418	else
danw@119	419	return versioncmp(&pool[prop1->version], &pool[prop2->version]);
krh@9	420	}
krh@9	421
danw@108	422	static uint32_t *
krh@66	423	uniqueify_properties(struct razor_set *set)
krh@9	424	{
krh@25	425	struct razor_property rp, up, *rp_end;
krh@18	426	struct array pkgs, p;
danw@117	427	struct list_head *r;
danw@117	428	uint32_t map, rmap;
krh@18	429	int i, count, unique;
krh@9	430
krh@66	431	count = set->properties.size / sizeof(struct razor_property);
krh@186	432	map = razor_qsort_with_data(set->properties.data,
krh@186	433	count,
krh@186	434	sizeof(struct razor_property),
krh@186	435	compare_properties,
krh@186	436	set);
krh@9	437
krh@66	438	rp_end = set->properties.data + set->properties.size;
krh@25	439	rmap = malloc(count * sizeof *map);
krh@25	440	pkgs = zalloc(count * sizeof *pkgs);
krh@66	441	for (rp = set->properties.data, up = rp, i = 0; rp < rp_end; rp++, i++) {
danw@119	442	if (rp->name != up->name \|\| rp->type != up->type \|\|
danw@119	443	rp->relation != up->relation \|\| rp->version != up->version) {
krh@25	444	up++;
krh@25	445	up->name = rp->name;
danw@119	446	up->flags = 0;
danw@119	447	up->type = rp->type;
danw@109	448	up->relation = rp->relation;
krh@25	449	up->version = rp->version;
krh@10	450	}
krh@25	451
krh@66	452	unique = up - (struct razor_property *) set->properties.data;
krh@25	453	rmap[map[i]] = unique;
krh@25	454	r = array_add(&pkgs[unique], sizeof *r);
krh@25	455	*r = rp->packages;
krh@10	456	}
krh@25	457	free(map);
krh@9	458
danw@124	459	if (up != rp)
danw@124	460	up++;
krh@66	461	set->properties.size = (void *) up - set->properties.data;
krh@25	462	rp_end = up;
krh@66	463	for (rp = set->properties.data, p = pkgs; rp < rp_end; rp++, p++) {
danw@124	464	list_set_array(&rp->packages, &set->package_pool, p, 0);
krh@25	465	array_release(p);
krh@18	466	}
krh@18	467
krh@18	468	free(pkgs);
krh@18	469
krh@25	470	return rmap;
krh@10	471	}
krh@10	472
krh@48	473	static int
krh@48	474	compare_filenames(const void p1, const void p2, void *data)
krh@48	475	{
krh@52	476	const struct import_entry *e1 = p1;
krh@52	477	const struct import_entry *e2 = p2;
danw@126	478	const char *n1 = e1->name;
danw@126	479	const char *n2 = e2->name;
krh@48	480
danw@126	481	/* Need to make sure that the contents of a directory
danw@126	482	* are sorted immediately after it. So "foo/bar" has to
danw@126	483	* sort before "foo.conf"
danw@126	484	*
danw@126	485	* FIXME: this is about 60% slower than strcmp
danw@126	486	*/
danw@126	487	while (n1 && n2) {
danw@126	488	if (n1 < n2)
danw@126	489	return *n2 == '/' ? 1 : -1;
danw@126	490	else if (n1 > n2)
danw@126	491	return *n1 == '/' ? -1 : 1;
danw@126	492	n1++;
danw@126	493	n2++;
danw@126	494	}
danw@126	495	if (*n1)
danw@126	496	return 1;
danw@126	497	else if (*n2)
danw@126	498	return -1;
danw@126	499	else
danw@126	500	return 0;
krh@48	501	}
krh@48	502
krh@48	503	static void
krh@52	504	count_entries(struct import_directory *d)
krh@48	505	{
krh@52	506	struct import_directory p, end;
krh@48	507
krh@48	508	p = d->files.data;
krh@48	509	end = d->files.data + d->files.size;
krh@48	510	d->count = 0;
krh@48	511	while (p < end) {
krh@48	512	count_entries(p);
krh@48	513	d->count += p->count + 1;
krh@48	514	p++;
krh@48	515	}
krh@48	516	}
krh@48	517
krh@48	518	static void
krh@52	519	serialize_files(struct razor_set *set,
krh@52	520	struct import_directory d, struct array array)
krh@48	521	{
krh@52	522	struct import_directory p, end;
krh@56	523	struct razor_entry *e = NULL;
danw@114	524	uint32_t s;
krh@48	525
krh@48	526	p = d->files.data;
krh@48	527	end = d->files.data + d->files.size;
krh@48	528	s = array->size / sizeof e + d->files.size / sizeof p;
krh@48	529	while (p < end) {
krh@48	530	e = array_add(array, sizeof *e);
krh@48	531	e->name = p->name;
danw@120	532	e->flags = 0;
krh@56	533	e->start = p->count > 0 ? s : 0;
krh@48	534	s += p->count;
krh@60	535
danw@124	536	list_set_array(&e->packages, &set->package_pool, &p->packages, 0);
krh@52	537	array_release(&p->packages);
krh@48	538	p++;
krh@48	539	}
krh@56	540	if (e != NULL)
danw@120	541	e->flags \|= RAZOR_ENTRY_LAST;
krh@48	542
krh@48	543	p = d->files.data;
krh@48	544	end = d->files.data + d->files.size;
krh@48	545	while (p < end) {
krh@52	546	serialize_files(set, p, array);
krh@48	547	p++;
krh@48	548	}
krh@48	549	}
krh@48	550
krh@48	551	static void
danw@108	552	remap_property_package_links(struct array properties, uint32_t rmap)
krh@61	553	{
krh@61	554	struct razor_property p, end;
krh@61	555
krh@61	556	end = properties->data + properties->size;
krh@61	557	for (p = properties->data; p < end; p++)
danw@117	558	list_remap_head(&p->packages, rmap);
krh@61	559	}
krh@61	560
krh@61	561	static void
krh@48	562	build_file_tree(struct razor_importer *importer)
krh@48	563	{
krh@48	564	int count, i, length;
krh@52	565	struct import_entry *filenames;
krh@52	566	char f, end;
danw@108	567	uint32_t name, *r;
krh@48	568	char dirname[256];
krh@52	569	struct import_directory *d, root;
krh@48	570	struct razor_entry *e;
krh@48	571
krh@52	572	count = importer->files.size / sizeof (struct import_entry);
krh@186	573	razor_qsort_with_data(importer->files.data,
krh@186	574	count,
krh@186	575	sizeof (struct import_entry),
krh@186	576	compare_filenames,
krh@186	577	NULL);
krh@48	578
krh@95	579	root.name = hashtable_tokenize(&importer->table, "");
krh@48	580	array_init(&root.files);
krh@52	581	array_init(&root.packages);
krh@48	582	root.last = NULL;
krh@48	583
krh@48	584	filenames = importer->files.data;
krh@48	585	for (i = 0; i < count; i++) {
krh@52	586	f = filenames[i].name;
krh@48	587	if (*f != '/')
krh@48	588	continue;
krh@57	589	f++;
krh@48	590
krh@48	591	d = &root;
krh@48	592	while (*f) {
krh@57	593	end = strchr(f, '/');
krh@48	594	if (end == NULL)
krh@48	595	end = f + strlen(f);
krh@57	596	length = end - f;
krh@57	597	memcpy(dirname, f, length);
krh@48	598	dirname[length] ='\0';
krh@95	599	name = hashtable_tokenize(&importer->table, dirname);
krh@48	600	if (d->last == NULL \|\| d->last->name != name) {
krh@48	601	d->last = array_add(&d->files, sizeof *d);
krh@48	602	d->last->name = name;
krh@48	603	d->last->last = NULL;
krh@48	604	array_init(&d->last->files);
krh@52	605	array_init(&d->last->packages);
krh@48	606	}
krh@48	607	d = d->last;
krh@57	608	f = end + 1;
krh@57	609	if (*end == '\0')
krh@57	610	break;
krh@48	611	}
krh@48	612
krh@52	613	r = array_add(&d->packages, sizeof *r);
krh@52	614	*r = filenames[i].package;
krh@52	615	free(filenames[i].name);
krh@48	616	}
krh@48	617
krh@48	618	count_entries(&root);
krh@150	619	e = importer->set->files.data;
danw@120	620	e->name = root.name;
danw@120	621	e->flags = RAZOR_ENTRY_LAST;
danw@129	622	e->start = importer->files.size ? 1 : 0;
danw@117	623	list_set_empty(&e->packages);
krh@48	624
krh@56	625	serialize_files(importer->set, &root, &importer->set->files);
krh@48	626
krh@48	627	array_release(&importer->files);
krh@48	628	}
krh@48	629
danw@159	630	static struct razor_entry *
danw@159	631	find_entry(struct razor_set set, struct razor_entry dir, const char *pattern);
danw@159	632
danw@159	633	static void
danw@159	634	list_to_array(struct list list, struct array array)
danw@159	635	{
danw@159	636	uint32_t *item;
danw@159	637
danw@159	638	while (list) {
danw@159	639	item = array_add(array, sizeof *item);
danw@159	640	*item = list->data;
danw@159	641	list = list_next(list);
danw@159	642	}
danw@159	643	}
danw@159	644
danw@159	645	static int
danw@159	646	compare_file_requires(const void p1, const void p2, void *data)
danw@159	647	{
danw@159	648	uint32_t f1 = (void )p1, f2 = (void )p2;
danw@159	649	const char *pool = data;
danw@159	650
danw@159	651	return strcmp(&pool[f1], &pool[f2]);
danw@159	652	}
danw@159	653
danw@159	654	static void
danw@159	655	find_file_provides(struct razor_importer *importer)
danw@159	656	{
danw@159	657	struct razor_property *prop;
danw@159	658	struct razor_entry top, entry;
danw@159	659	struct razor_package *packages;
danw@163	660	struct array pkgprops;
danw@163	661	struct list *pkg;
danw@163	662	uint32_t req, req_start, *req_end;
danw@163	663	uint32_t map, newprop;
danw@159	664	char *pool;
danw@159	665
danw@159	666	pool = importer->set->string_pool.data;
danw@159	667	packages = importer->set->packages.data;
danw@159	668	top = importer->set->files.data;
danw@159	669
danw@159	670	req = req_start = importer->file_requires.data;
danw@159	671	req_end = importer->file_requires.data + importer->file_requires.size;
krh@186	672	map = razor_qsort_with_data(req, req_end - req, sizeof *req,
krh@186	673	compare_file_requires, pool);
danw@159	674	free(map);
danw@159	675
danw@159	676	for (req = req_start; req < req_end; req++) {
danw@159	677	if (req > req_start && req[0] == req[-1])
danw@159	678	continue;
danw@159	679	entry = find_entry(importer->set, top, &pool[*req]);
danw@163	680	if (!entry)
danw@163	681	continue;
danw@163	682
danw@163	683	for (pkg = list_first(&entry->packages, &importer->set->package_pool); pkg; pkg = list_next(pkg)) {
danw@159	684	prop = array_add(&importer->set->properties, sizeof *prop);
danw@159	685	prop->name = *req;
danw@159	686	prop->type = RAZOR_PROPERTY_PROVIDES;
danw@159	687	prop->relation = RAZOR_VERSION_EQUAL;
danw@159	688	prop->version = hashtable_tokenize(&importer->table, "");
danw@163	689	list_set_ptr(&prop->packages, pkg->data);
danw@163	690
danw@163	691	/* Update property list of pkg */
danw@163	692	array_init(&pkgprops);
danw@163	693	list_to_array(list_first(&packages[pkg->data].properties, &importer->set->property_pool), &pkgprops);
danw@163	694	newprop = array_add(&pkgprops, sizeof *newprop);
danw@163	695	newprop = prop - (struct razor_property )importer->set->properties.data;
danw@163	696	list_set_array(&packages[pkg->data].properties, &importer->set->property_pool, &pkgprops, 1);
danw@163	697	array_release(&pkgprops);
danw@159	698	}
danw@159	699	}
danw@159	700
danw@159	701	array_release(&importer->file_requires);
danw@159	702	}
danw@159	703
krh@56	704	static void
danw@108	705	build_package_file_lists(struct razor_set set, uint32_t rmap)
krh@54	706	{
krh@56	707	struct razor_package p, packages;
krh@56	708	struct array *pkgs;
krh@54	709	struct razor_entry e, end;
danw@117	710	struct list *r;
danw@117	711	uint32_t *q;
krh@56	712	int i, count;
krh@54	713
krh@56	714	count = set->packages.size / sizeof *p;
krh@56	715	pkgs = zalloc(count * sizeof *pkgs);
krh@54	716
krh@56	717	end = set->files.data + set->files.size;
krh@92	718	for (e = set->files.data; e < end; e++) {
danw@117	719	list_remap_head(&e->packages, rmap);
danw@116	720	r = list_first(&e->packages, &set->package_pool);
danw@116	721	while (r) {
danw@117	722	q = array_add(&pkgs[r->data], sizeof *q);
krh@56	723	q = e - (struct razor_entry ) set->files.data;
danw@116	724	r = list_next(r);
krh@54	725	}
krh@54	726	}
krh@54	727
krh@56	728	packages = set->packages.data;
krh@56	729	for (i = 0; i < count; i++) {
danw@124	730	list_set_array(&packages[i].files, &set->file_pool, &pkgs[i], 0);
krh@56	731	array_release(&pkgs[i]);
krh@48	732	}
krh@56	733	free(pkgs);
krh@52	734	}
krh@52	735
krh@27	736	struct razor_set *
krh@30	737	razor_importer_finish(struct razor_importer *importer)
krh@9	738	{
krh@30	739	struct razor_set *set;
danw@108	740	uint32_t map, rmap;
krh@39	741	int i, count;
krh@18	742
danw@159	743	build_file_tree(importer);
danw@159	744	find_file_provides(importer);
danw@159	745
krh@66	746	map = uniqueify_properties(importer->set);
danw@116	747	list_remap_pool(&importer->set->property_pool, map);
krh@39	748	free(map);
krh@25	749
krh@30	750	count = importer->set->packages.size / sizeof(struct razor_package);
krh@186	751	map = razor_qsort_with_data(importer->set->packages.data,
krh@186	752	count,
krh@186	753	sizeof(struct razor_package),
krh@186	754	compare_packages,
krh@186	755	importer->set);
krh@39	756
krh@39	757	rmap = malloc(count * sizeof *rmap);
krh@39	758	for (i = 0; i < count; i++)
krh@39	759	rmap[map[i]] = i;
krh@25	760	free(map);
krh@13	761
danw@116	762	list_remap_pool(&importer->set->package_pool, rmap);
krh@60	763	build_package_file_lists(importer->set, rmap);
krh@66	764	remap_property_package_links(&importer->set->properties, rmap);
krh@52	765	free(rmap);
krh@48	766
krh@30	767	set = importer->set;
krh@78	768	hashtable_release(&importer->table);
krh@30	769	free(importer);
krh@30	770
krh@30	771	return set;
krh@9	772	}
krh@9	773
krh@92	774	struct razor_package_iterator {
krh@92	775	struct razor_set *set;
krh@92	776	struct razor_package package, end;
danw@117	777	struct list *index;
krh@92	778	};
krh@92	779
danw@137	780	static struct razor_package_iterator *
krh@101	781	razor_package_iterator_create_with_index(struct razor_set *set,
danw@117	782	struct list *index)
krh@3	783	{
krh@92	784	struct razor_package_iterator *pi;
krh@92	785
krh@92	786	pi = zalloc(sizeof *pi);
krh@92	787	pi->set = set;
krh@101	788	pi->index = index;
krh@92	789
krh@92	790	return pi;
krh@92	791	}
krh@92	792
krh@101	793	struct razor_package_iterator *
krh@101	794	razor_package_iterator_create(struct razor_set *set)
krh@101	795	{
danw@116	796	struct razor_package_iterator *pi;
danw@116	797
danw@116	798	pi = zalloc(sizeof *pi);
danw@116	799	pi->set = set;
danw@116	800	pi->end = set->packages.data + set->packages.size;
danw@116	801	pi->package = set->packages.data;
danw@116	802
danw@116	803	return pi;
krh@101	804	}
krh@101	805
krh@101	806	struct razor_package_iterator *
krh@101	807	razor_package_iterator_create_for_property(struct razor_set *set,
krh@101	808	struct razor_property *property)
krh@101	809	{
danw@117	810	struct list *index;
krh@101	811
danw@116	812	index = list_first(&property->packages, &set->package_pool);
krh@101	813	return razor_package_iterator_create_with_index(set, index);
krh@101	814	}
krh@101	815
krh@92	816	int
krh@92	817	razor_package_iterator_next(struct razor_package_iterator *pi,
krh@92	818	struct razor_package **package,
krh@92	819	const char name, const char version)
krh@92	820	{
krh@6	821	char *pool;
krh@101	822	int valid;
krh@101	823	struct razor_package p, packages;
krh@3	824
danw@116	825	if (pi->package) {
krh@101	826	p = pi->package++;
krh@101	827	valid = p < pi->end;
danw@116	828	} else if (pi->index) {
danw@116	829	packages = pi->set->packages.data;
danw@117	830	p = &packages[pi->index->data];
danw@116	831	pi->index = list_next(pi->index);
danw@116	832	valid = 1;
danw@116	833	} else
danw@116	834	valid = 0;
krh@92	835
krh@101	836	if (valid) {
krh@101	837	pool = pi->set->string_pool.data;
krh@101	838	*package = p;
danw@120	839	*name = &pool[p->name];
krh@101	840	*version = &pool[p->version];
krh@101	841	} else {
krh@101	842	*package = NULL;
krh@101	843	}
krh@101	844
krh@101	845	return valid;
krh@92	846	}
krh@92	847
krh@92	848	void
krh@92	849	razor_package_iterator_destroy(struct razor_package_iterator *pi)
krh@92	850	{
krh@92	851	free(pi);
krh@3	852	}
krh@3	853
krh@10	854	struct razor_package *
krh@10	855	razor_set_get_package(struct razor_set set, const char package)
krh@10	856	{
krh@97	857	struct razor_package_iterator *pi;
krh@97	858	struct razor_package *p;
krh@97	859	const char name, version;
krh@97	860
krh@97	861	pi = razor_package_iterator_create(set);
krh@97	862	while (razor_package_iterator_next(pi, &p, &name, &version)) {
krh@97	863	if (strcmp(package, name) == 0)
krh@97	864	break;
krh@97	865	}
krh@97	866	razor_package_iterator_destroy(pi);
krh@97	867
krh@97	868	return p;
krh@10	869	}
krh@10	870
krh@92	871	struct razor_property_iterator {
krh@92	872	struct razor_set *set;
krh@92	873	struct razor_property property, end;
danw@117	874	struct list *index;
krh@92	875	};
krh@92	876
krh@92	877	struct razor_property_iterator *
krh@92	878	razor_property_iterator_create(struct razor_set *set,
krh@92	879	struct razor_package *package)
krh@92	880	{
krh@92	881	struct razor_property_iterator *pi;
krh@92	882
krh@92	883	pi = zalloc(sizeof *pi);
krh@92	884	pi->set = set;
krh@98	885
danw@116	886	if (package) {
danw@117	887	pi->index = list_first(&package->properties,
danw@117	888	&set->property_pool);
danw@116	889	} else {
danw@116	890	pi->property = set->properties.data;
danw@116	891	pi->end = set->properties.data + set->properties.size;
danw@116	892	}
krh@92	893
krh@92	894	return pi;
krh@92	895	}
krh@92	896
krh@92	897	int
krh@92	898	razor_property_iterator_next(struct razor_property_iterator *pi,
krh@92	899	struct razor_property **property,
danw@109	900	const char **name,
danw@109	901	enum razor_version_relation *relation,
danw@109	902	const char **version,
krh@92	903	enum razor_property_type *type)
krh@92	904	{
krh@92	905	char *pool;
krh@92	906	int valid;
krh@92	907	struct razor_property p, properties;
krh@92	908
danw@116	909	if (pi->property) {
krh@92	910	p = pi->property++;
krh@92	911	valid = p < pi->end;
danw@116	912	} else if (pi->index) {
danw@116	913	properties = pi->set->properties.data;
danw@117	914	p = &properties[pi->index->data];
danw@116	915	pi->index = list_next(pi->index);
danw@116	916	valid = 1;
danw@116	917	} else
danw@116	918	valid = 0;
krh@92	919
krh@96	920	if (valid) {
krh@96	921	pool = pi->set->string_pool.data;
krh@96	922	*property = p;
danw@119	923	*name = &pool[p->name];
danw@109	924	*relation = p->relation;
krh@96	925	*version = &pool[p->version];
danw@119	926	*type = p->type;
krh@96	927	} else {
krh@96	928	*property = NULL;
krh@96	929	}
krh@92	930
krh@92	931	return valid;
krh@92	932	}
krh@92	933
krh@66	934	void
krh@92	935	razor_property_iterator_destroy(struct razor_property_iterator *pi)
krh@8	936	{
krh@92	937	free(pi);
krh@10	938	}
krh@10	939
krh@56	940	static struct razor_entry *
krh@56	941	find_entry(struct razor_set set, struct razor_entry dir, const char *pattern)
krh@56	942	{
krh@56	943	struct razor_entry *e;
krh@56	944	const char n, pool = set->string_pool.data;
krh@56	945	int len;
krh@56	946
krh@56	947	e = (struct razor_entry *) set->files.data + dir->start;
krh@56	948	do {
danw@120	949	n = pool + e->name;
krh@56	950	if (strcmp(pattern + 1, n) == 0)
krh@56	951	return e;
krh@57	952	len = strlen(n);
krh@56	953	if (e->start != 0 && strncmp(pattern + 1, n, len) == 0 &&
krh@56	954	pattern[len + 1] == '/') {
krh@56	955	return find_entry(set, e, pattern + len + 1);
krh@56	956	}
danw@120	957	} while (!((e++)->flags & RAZOR_ENTRY_LAST));
krh@56	958
krh@56	959	return NULL;
krh@56	960	}
krh@56	961
krh@56	962	static void
krh@56	963	list_dir(struct razor_set set, struct razor_entry dir,
danw@127	964	char prefix, const char pattern)
krh@56	965	{
krh@56	966	struct razor_entry *e;
krh@56	967	const char n, pool = set->string_pool.data;
krh@56	968
krh@56	969	e = (struct razor_entry *) set->files.data + dir->start;
krh@56	970	do {
danw@120	971	n = pool + e->name;
krh@56	972	if (pattern && pattern[0] && fnmatch(pattern, n, 0) != 0)
krh@56	973	continue;
danw@127	974	printf("%s/%s\n", prefix, n);
danw@127	975	if (e->start) {
danw@127	976	char *sub = prefix + strlen (prefix);
danw@127	977	*sub = '/';
danw@127	978	strcpy (sub + 1, n);
danw@127	979	list_dir(set, e, prefix, pattern);
danw@127	980	*sub = '\0';
danw@127	981	}
danw@120	982	} while (!((e++)->flags & RAZOR_ENTRY_LAST));
krh@56	983	}
krh@56	984
krh@56	985	void
krh@56	986	razor_set_list_files(struct razor_set set, const char pattern)
krh@56	987	{
krh@56	988	struct razor_entry *e;
krh@56	989	char buffer[512], p, base;
krh@56	990
danw@127	991	if (pattern == NULL \|\| !strcmp (pattern, "/")) {
danw@127	992	buffer[0] = '\0';
danw@127	993	list_dir(set, set->files.data, buffer, NULL);
danw@127	994	return;
danw@127	995	}
krh@56	996
krh@56	997	strcpy(buffer, pattern);
krh@56	998	e = find_entry(set, set->files.data, buffer);
krh@56	999	if (e && e->start > 0) {
krh@56	1000	base = NULL;
krh@56	1001	} else {
krh@56	1002	p = strrchr(buffer, '/');
krh@56	1003	if (p) {
krh@56	1004	*p = '\0';
krh@56	1005	base = p + 1;
krh@56	1006	} else {
krh@56	1007	base = NULL;
krh@56	1008	}
krh@56	1009	}
krh@56	1010	e = find_entry(set, set->files.data, buffer);
krh@56	1011	if (e->start != 0)
krh@56	1012	list_dir(set, e, buffer, base);
krh@56	1013	}
krh@56	1014
krh@102	1015	struct razor_package_iterator *
krh@102	1016	razor_package_iterator_create_for_file(struct razor_set *set,
krh@102	1017	const char *filename)
krh@56	1018	{
krh@102	1019	struct razor_entry *entry;
danw@117	1020	struct list *index;
krh@56	1021
krh@102	1022	entry = find_entry(set, set->files.data, filename);
krh@102	1023	if (entry == NULL)
krh@102	1024	return NULL;
krh@56	1025
danw@116	1026	index = list_first(&entry->packages, &set->package_pool);
krh@102	1027	return razor_package_iterator_create_with_index(set, index);
krh@56	1028	}
krh@56	1029
danw@117	1030	static struct list *
danw@117	1031	list_package_files(struct razor_set set, struct list r,
danw@108	1032	struct razor_entry *dir, uint32_t end,
krh@56	1033	char *prefix)
krh@56	1034	{
krh@56	1035	struct razor_entry e, f, *entries;
danw@108	1036	uint32_t next, file;
krh@56	1037	char *pool;
krh@56	1038	int len;
krh@56	1039
krh@56	1040	entries = (struct razor_entry *) set->files.data;
krh@56	1041	pool = set->string_pool.data;
krh@56	1042
krh@56	1043	e = entries + dir->start;
krh@56	1044	do {
danw@117	1045	if (entries + r->data == e) {
danw@120	1046	printf("%s/%s\n", prefix, pool + e->name);
danw@116	1047	r = list_next(r);
danw@116	1048	if (!r)
krh@83	1049	return NULL;
danw@117	1050	if (r->data >= end)
krh@83	1051	return r;
krh@56	1052	}
danw@120	1053	} while (!((e++)->flags & RAZOR_ENTRY_LAST));
krh@56	1054
krh@56	1055	e = entries + dir->start;
krh@56	1056	do {
krh@56	1057	if (e->start == 0)
krh@56	1058	continue;
krh@56	1059
danw@120	1060	if (e->flags & RAZOR_ENTRY_LAST)
krh@56	1061	next = end;
krh@56	1062	else {
krh@56	1063	f = e + 1;
danw@120	1064	while (f->start == 0 && !(f->flags & RAZOR_ENTRY_LAST))
krh@56	1065	f++;
krh@56	1066	if (f->start == 0)
krh@56	1067	next = end;
krh@56	1068	else
krh@56	1069	next = f->start;
krh@56	1070	}
krh@56	1071
danw@117	1072	file = r->data;
krh@83	1073	if (e->start <= file && file < next) {
krh@56	1074	len = strlen(prefix);
krh@56	1075	prefix[len] = '/';
danw@120	1076	strcpy(prefix + len + 1, pool + e->name);
krh@56	1077	r = list_package_files(set, r, e, next, prefix);
krh@56	1078	prefix[len] = '\0';
krh@56	1079	}
danw@120	1080	} while (!((e++)->flags & RAZOR_ENTRY_LAST) && r != NULL);
krh@56	1081
krh@56	1082	return r;
krh@56	1083	}
krh@56	1084
krh@56	1085	void
krh@56	1086	razor_set_list_package_files(struct razor_set set, const char name)
krh@56	1087	{
krh@56	1088	struct razor_package *package;
danw@117	1089	struct list *r;
danw@117	1090	uint32_t end;
krh@56	1091	char buffer[512];
krh@56	1092
krh@56	1093	package = razor_set_get_package(set, name);
krh@56	1094
danw@116	1095	r = list_first(&package->files, &set->file_pool);
krh@56	1096	end = set->files.size / sizeof (struct razor_entry);
krh@56	1097	buffer[0] = '\0';
krh@56	1098	list_package_files(set, r, set->files.data, end, buffer);
krh@56	1099	}
krh@56	1100
krh@43	1101	static void
krh@21	1102	razor_set_validate(struct razor_set set, struct array unsatisfied)
krh@21	1103	{
krh@66	1104	struct razor_property r, p, *end;
danw@108	1105	uint32_t *u;
krh@21	1106	char *pool;
krh@21	1107
krh@66	1108	end = set->properties.data + set->properties.size;
krh@21	1109	pool = set->string_pool.data;
krh@21	1110
krh@66	1111	for (r = set->properties.data, p = r; r < end; r++) {
danw@119	1112	if (r->type != RAZOR_PROPERTY_REQUIRES)
krh@66	1113	continue;
krh@66	1114
danw@129	1115	p = r;
danw@129	1116	while (p < end && p->name == r->name &&
danw@129	1117	p->type == r->type)
danw@129	1118	p++;
krh@37	1119
krh@35	1120	/* If there is more than one version of a provides,
krh@35	1121	* seek to the end for the highest version. */
krh@66	1122	/* FIXME: This doesn't work if we have a series of
krh@66	1123	* requires a = 1, provides a = 1, requires a = 2,
krh@66	1124	* provides a = 2, as the kernel and kernel-devel
krh@66	1125	* does.*/
danw@119	1126	while (p + 1 < end && p->name == (p + 1)->name &&
danw@119	1127	p->type == (p + 1)->type)
krh@35	1128	p++;
krh@37	1129
krh@37	1130	/* FIXME: We need to track property flags (<, <=, =
krh@37	1131	* etc) to properly determine if a requires is
krh@37	1132	* satisfied. The current code doesn't track that the
krh@37	1133	* requires a = 1 isn't satisfied by a = 2 provides. */
krh@37	1134
krh@66	1135	if (p == end \|\|
danw@119	1136	p->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@119	1137	r->name != p->name \|\|
krh@35	1138	versioncmp(&pool[r->version], &pool[p->version]) > 0) {
krh@35	1139	/* FIXME: We ignore file requires for now. */
danw@119	1140	if (pool[r->name] == '/')
krh@35	1141	continue;
krh@21	1142	u = array_add(unsatisfied, sizeof *u);
krh@66	1143	u = r - (struct razor_property ) set->properties.data;
krh@21	1144	}
krh@21	1145	}
krh@21	1146	}
krh@21	1147
krh@21	1148	void
krh@21	1149	razor_set_list_unsatisfied(struct razor_set *set)
krh@21	1150	{
krh@21	1151	struct array unsatisfied;
krh@66	1152	struct razor_property properties, r;
danw@108	1153	uint32_t u, end;
krh@21	1154	char *pool;
krh@21	1155
krh@21	1156	array_init(&unsatisfied);
krh@21	1157	razor_set_validate(set, &unsatisfied);
krh@21	1158
krh@21	1159	end = unsatisfied.data + unsatisfied.size;
krh@66	1160	properties = set->properties.data;
krh@21	1161	pool = set->string_pool.data;
krh@21	1162
krh@21	1163	for (u = unsatisfied.data; u < end; u++) {
krh@66	1164	r = properties + *u;
krh@66	1165	if (pool[r->version] == '\0')
krh@66	1166	printf("%ss not satisfied\n",
danw@119	1167	&pool[r->name]);
krh@66	1168	else
krh@66	1169	printf("%s-%s not satisfied\n",
danw@119	1170	&pool[r->name],
krh@66	1171	&pool[r->version]);
krh@21	1172	}
krh@21	1173
krh@21	1174	array_release(&unsatisfied);
krh@21	1175	}
krh@21	1176
danw@120	1177	#define UPSTREAM_SOURCE 0x80
krh@41	1178
krh@41	1179	struct source {
krh@41	1180	struct razor_set *set;
danw@108	1181	uint32_t *property_map;
danw@127	1182	uint32_t *file_map;
krh@41	1183	};
krh@41	1184
krh@79	1185	struct razor_merger {
krh@79	1186	struct razor_set *set;
krh@79	1187	struct hashtable table;
krh@79	1188	struct source source1;
krh@79	1189	struct source source2;
krh@79	1190	};
krh@79	1191
krh@79	1192	static struct razor_merger *
krh@79	1193	razor_merger_create(struct razor_set set1, struct razor_set set2)
krh@41	1194	{
krh@79	1195	struct razor_merger *merger;
krh@41	1196	int count;
krh@41	1197	size_t size;
krh@41	1198
krh@79	1199	merger = zalloc(sizeof *merger);
krh@79	1200	merger->set = razor_set_create();
krh@79	1201	hashtable_init(&merger->table, &merger->set->string_pool);
krh@41	1202
danw@127	1203	merger->source1.set = set1;
krh@79	1204	count = set1->properties.size / sizeof (struct razor_property);
krh@79	1205	size = count * sizeof merger->source1.property_map[0];
krh@79	1206	merger->source1.property_map = zalloc(size);
danw@127	1207	count = set1->files.size / sizeof (struct razor_entry);
danw@127	1208	size = count * sizeof merger->source1.file_map[0];
danw@127	1209	merger->source1.file_map = zalloc(size);
krh@79	1210
danw@127	1211	merger->source2.set = set2;
krh@79	1212	count = set2->properties.size / sizeof (struct razor_property);
krh@79	1213	size = count * sizeof merger->source2.property_map[0];
krh@79	1214	merger->source2.property_map = zalloc(size);
danw@127	1215	count = set2->files.size / sizeof (struct razor_entry);
danw@127	1216	size = count * sizeof merger->source2.file_map[0];
danw@127	1217	merger->source2.file_map = zalloc(size);
krh@79	1218
krh@79	1219	return merger;
krh@41	1220	}
krh@41	1221
krh@33	1222	static void
krh@79	1223	add_package(struct razor_merger *merger,
krh@41	1224	struct razor_package package, struct source source,
danw@108	1225	uint32_t flags)
krh@33	1226	{
krh@33	1227	char *pool;
danw@117	1228	struct list *r;
krh@41	1229	struct razor_package *p;
krh@33	1230
krh@41	1231	pool = source->set->string_pool.data;
krh@79	1232	p = array_add(&merger->set->packages, sizeof *p);
krh@79	1233	p->name = hashtable_tokenize(&merger->table, &pool[package->name]);
danw@120	1234	p->flags = flags;
krh@79	1235	p->version = hashtable_tokenize(&merger->table,
krh@79	1236	&pool[package->version]);
danw@127	1237
krh@66	1238	p->properties = package->properties;
danw@116	1239	r = list_first(&package->properties, &source->set->property_pool);
danw@116	1240	while (r) {
danw@117	1241	source->property_map[r->data] = 1;
danw@116	1242	r = list_next(r);
krh@64	1243	}
danw@127	1244
danw@127	1245	p->files = package->files;
danw@127	1246	r = list_first(&package->files, &source->set->file_pool);
danw@127	1247	while (r) {
danw@127	1248	source->file_map[r->data] = 1;
danw@127	1249	r = list_next(r);
danw@127	1250	}
krh@41	1251	}
krh@41	1252
danw@108	1253	static uint32_t
krh@79	1254	add_property(struct razor_merger *merger,
danw@109	1255	const char *name, enum razor_version_relation relation,
danw@109	1256	const char *version, int type)
krh@41	1257	{
krh@41	1258	struct razor_property *p;
krh@41	1259
krh@79	1260	p = array_add(&merger->set->properties, sizeof *p);
danw@119	1261	p->name = hashtable_tokenize(&merger->table, name);
danw@119	1262	p->flags = 0;
danw@119	1263	p->type = type;
danw@109	1264	p->relation = relation;
krh@79	1265	p->version = hashtable_tokenize(&merger->table, version);
krh@41	1266
krh@79	1267	return p - (struct razor_property *) merger->set->properties.data;
krh@41	1268	}
krh@41	1269
krh@41	1270	static void
krh@79	1271	merge_properties(struct razor_merger *merger)
krh@41	1272	{
krh@41	1273	struct razor_property p1, p2;
krh@79	1274	struct razor_set set1, set2;
danw@108	1275	uint32_t map1, map2;
krh@41	1276	int i, j, cmp, count1, count2;
krh@41	1277	char pool1, pool2;
krh@41	1278
krh@79	1279	set1 = merger->source1.set;
krh@79	1280	set2 = merger->source2.set;
krh@79	1281	map1 = merger->source1.property_map;
krh@79	1282	map2 = merger->source2.property_map;
krh@79	1283
krh@41	1284	i = 0;
krh@41	1285	j = 0;
krh@41	1286	pool1 = set1->string_pool.data;
krh@41	1287	pool2 = set2->string_pool.data;
krh@41	1288
krh@66	1289	count1 = set1->properties.size / sizeof *p1;
krh@66	1290	count2 = set2->properties.size / sizeof *p2;
krh@41	1291	while (i < count1 \|\| j < count2) {
krh@41	1292	if (i < count1 && map1[i] == 0) {
krh@41	1293	i++;
krh@41	1294	continue;
krh@41	1295	}
krh@41	1296	if (j < count2 && map2[j] == 0) {
krh@41	1297	j++;
krh@41	1298	continue;
krh@41	1299	}
krh@66	1300	p1 = (struct razor_property *) set1->properties.data + i;
krh@66	1301	p2 = (struct razor_property *) set2->properties.data + j;
krh@41	1302	if (i < count1 && j < count2)
danw@119	1303	cmp = strcmp(&pool1[p1->name], &pool2[p2->name]);
krh@41	1304	else if (i < count1)
krh@41	1305	cmp = -1;
krh@41	1306	else
krh@41	1307	cmp = 1;
krh@41	1308	if (cmp == 0)
danw@121	1309	cmp = p1->type - p2->type;
danw@121	1310	if (cmp == 0)
danw@109	1311	cmp = p1->relation - p2->relation;
danw@109	1312	if (cmp == 0)
krh@41	1313	cmp = versioncmp(&pool1[p1->version],
krh@41	1314	&pool2[p2->version]);
krh@41	1315	if (cmp < 0) {
krh@79	1316	map1[i++] = add_property(merger,
danw@119	1317	&pool1[p1->name],
danw@109	1318	p1->relation,
krh@69	1319	&pool1[p1->version],
danw@119	1320	p1->type);
krh@41	1321	} else if (cmp > 0) {
krh@79	1322	map2[j++] = add_property(merger,
danw@119	1323	&pool2[p2->name],
danw@109	1324	p2->relation,
krh@69	1325	&pool2[p2->version],
danw@119	1326	p2->type);
krh@41	1327	} else {
krh@79	1328	map1[i++] = map2[j++] = add_property(merger,
danw@119	1329	&pool1[p1->name],
danw@109	1330	p1->relation,
krh@69	1331	&pool1[p1->version],
danw@119	1332	p1->type);
krh@41	1333	}
krh@41	1334	}
krh@41	1335	}
krh@41	1336
danw@116	1337	static void
danw@117	1338	emit_properties(struct list_head properties, struct array source_pool,
danw@108	1339	uint32_t map, struct array pool)
krh@41	1340	{
danw@117	1341	uint32_t r;
danw@117	1342	struct list p, q;
krh@41	1343
krh@41	1344	r = pool->size / sizeof *q;
danw@116	1345	p = list_first(properties, source_pool);
danw@116	1346	while (p) {
krh@41	1347	q = array_add(pool, sizeof *q);
danw@117	1348	q->data = map[p->data];
danw@117	1349	q->flags = p->flags;
danw@116	1350	p = list_next(p);
krh@33	1351	}
krh@33	1352
danw@117	1353	list_set_ptr(properties, r);
krh@41	1354	}
danw@127	1355
danw@127	1356	static uint32_t
danw@127	1357	add_file(struct razor_merger merger, const char name)
danw@127	1358	{
danw@127	1359	struct razor_entry *e;
danw@127	1360
danw@127	1361	e = array_add(&merger->set->files, sizeof *e);
danw@127	1362	e->name = hashtable_tokenize(&merger->table, name);
danw@127	1363	e->flags = 0;
danw@127	1364	e->start = 0;
danw@127	1365
danw@127	1366	return e - (struct razor_entry *)merger->set->files.data;
danw@127	1367	}
danw@127	1368
danw@129	1369	/* FIXME. Blah */
danw@127	1370	static int
danw@127	1371	fix_file_map(uint32_t *map,
danw@127	1372	struct razor_entry *files,
danw@127	1373	struct razor_entry *top)
danw@127	1374	{
danw@127	1375	uint32_t e;
danw@127	1376	int found_file = 0;
danw@127	1377
danw@127	1378	e = top->start;
danw@127	1379	do {
danw@127	1380	if (files[e].start)
danw@127	1381	fix_file_map(map, files, &files[e]);
danw@127	1382	if (map[e])
danw@127	1383	found_file = 1;
danw@127	1384	} while (!(files[e++].flags & RAZOR_ENTRY_LAST));
danw@127	1385
danw@127	1386	if (found_file)
danw@127	1387	map[top - files] = 1;
danw@127	1388	return found_file;
danw@127	1389	}
danw@127	1390
danw@127	1391	struct merge_directory {
danw@127	1392	uint32_t merged, dir1, dir2;
danw@127	1393	};
danw@127	1394
danw@127	1395	static void
danw@127	1396	merge_one_directory(struct razor_merger merger, struct merge_directory md)
danw@127	1397	{
danw@127	1398	struct razor_entry root1, root2, mroot, e1, *e2;
danw@127	1399	struct razor_set set1, set2;
danw@127	1400	struct array merge_stack;
danw@127	1401	struct merge_directory child_md, end_md;
danw@127	1402	uint32_t map1, map2, start, last;
danw@127	1403	int cmp;
danw@127	1404	char pool1, pool2;
danw@127	1405
danw@127	1406	set1 = merger->source1.set;
danw@127	1407	set2 = merger->source2.set;
danw@127	1408	map1 = merger->source1.file_map;
danw@127	1409	map2 = merger->source2.file_map;
danw@127	1410	pool1 = set1->string_pool.data;
danw@127	1411	pool2 = set2->string_pool.data;
danw@127	1412	root1 = (struct razor_entry *) set1->files.data;
danw@127	1413	root2 = (struct razor_entry *) set2->files.data;
danw@127	1414
danw@127	1415	array_init(&merge_stack);
danw@127	1416
danw@127	1417	start = merger->set->files.size / sizeof (struct razor_entry);
danw@127	1418	last = 0;
danw@127	1419	e1 = md->dir1 ? root1 + md->dir1 : NULL;
danw@127	1420	e2 = md->dir2 ? root2 + md->dir2 : NULL;
danw@127	1421	while (e1 \|\| e2) {
danw@127	1422	if (!e2 && !map1[e1 - root1]) {
danw@127	1423	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1424	e1 = NULL;
danw@127	1425	continue;
danw@127	1426	}
danw@127	1427	if (!e1 && !map2[e2 - root2]) {
danw@127	1428	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1429	e2 = NULL;
danw@127	1430	continue;
danw@127	1431	}
danw@127	1432	if (e1 && !map1[e1 - root1] &&
danw@127	1433	e2 && !map1[e2 - root2]) {
danw@127	1434	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1435	e1 = NULL;
danw@127	1436	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1437	e2 = NULL;
danw@127	1438	continue;
danw@127	1439	}
danw@127	1440
danw@127	1441	if (!e1)
danw@127	1442	cmp = 1;
danw@127	1443	else if (!e2)
danw@127	1444	cmp = -1;
danw@127	1445	else {
danw@127	1446	cmp = strcmp (&pool1[e1->name],
danw@127	1447	&pool2[e2->name]);
danw@127	1448	}
danw@127	1449
danw@127	1450	if (cmp < 0) {
danw@127	1451	if (map1[e1 - root1]) {
danw@127	1452	map1[e1 - root1] = last =
danw@127	1453	add_file(merger, &pool1[e1->name]);
danw@127	1454	if (e1->start) {
danw@127	1455	child_md = array_add(&merge_stack, sizeof (struct merge_directory));
danw@127	1456	child_md->merged = last;
danw@127	1457	child_md->dir1 = e1->start;
danw@127	1458	child_md->dir2 = 0;
danw@127	1459	}
danw@127	1460	}
danw@127	1461	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1462	e1 = NULL;
danw@127	1463	} else if (cmp > 0) {
danw@127	1464	if (map2[e2 - root2]) {
danw@127	1465	map2[e2 - root2] = last =
danw@127	1466	add_file(merger, &pool2[e2->name]);
danw@127	1467	if (e2->start) {
danw@127	1468	child_md = array_add(&merge_stack, sizeof (struct merge_directory));
danw@127	1469	child_md->merged = last;
danw@127	1470	child_md->dir1 = 0;
danw@127	1471	child_md->dir2 = e2->start;
danw@127	1472	}
danw@127	1473	}
danw@127	1474	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1475	e2 = NULL;
danw@127	1476	} else {
danw@127	1477	map1[e1 - root1] = map2[e2- root2] = last =
danw@127	1478	add_file(merger, &pool1[e1->name]);
danw@127	1479	if (e1->start \|\| e2->start) {
danw@127	1480	child_md = array_add(&merge_stack, sizeof (struct merge_directory));
danw@127	1481	child_md->merged = last;
danw@127	1482	child_md->dir1 = e1->start;
danw@127	1483	child_md->dir2 = e2->start;
danw@127	1484	}
danw@127	1485	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1486	e1 = NULL;
danw@127	1487	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1488	e2 = NULL;
danw@127	1489	}
danw@127	1490	}
danw@127	1491
danw@127	1492	mroot = (struct razor_entry *)merger->set->files.data;
danw@127	1493	if (last) {
danw@127	1494	mroot[last].flags = RAZOR_ENTRY_LAST;
danw@127	1495	mroot[md->merged].start = start;
danw@127	1496	} else
danw@127	1497	mroot[md->merged].start = 0;
danw@127	1498
danw@127	1499	end_md = merge_stack.data + merge_stack.size;
danw@127	1500	for (child_md = merge_stack.data; child_md < end_md; child_md++)
danw@127	1501	merge_one_directory(merger, child_md);
danw@127	1502	array_release(&merge_stack);
danw@127	1503	}
danw@127	1504
danw@127	1505	static void
danw@127	1506	merge_files(struct razor_merger *merger)
danw@127	1507	{
danw@129	1508	struct razor_entry *root;
danw@127	1509	struct merge_directory md;
danw@127	1510	uint32_t map1, map2;
danw@127	1511
danw@127	1512	map1 = merger->source1.file_map;
danw@127	1513	map2 = merger->source2.file_map;
danw@127	1514
danw@164	1515	md.merged = 0;
danw@129	1516
danw@129	1517	if (merger->source1.set->files.size) {
danw@129	1518	root = (struct razor_entry *) merger->source1.set->files.data;
danw@129	1519	if (root->start)
danw@129	1520	fix_file_map(map1, root, root);
danw@129	1521	md.dir1 = root->start;
danw@129	1522	} else
danw@129	1523	md.dir1 = 0;
danw@129	1524
danw@129	1525	if (merger->source2.set->files.size) {
danw@129	1526	root = (struct razor_entry *) merger->source2.set->files.data;
danw@129	1527	if (root->start)
danw@129	1528	fix_file_map(map2, root, root);
danw@129	1529	md.dir2 = root->start;
danw@129	1530	} else
danw@129	1531	md.dir2 = 0;
danw@129	1532
danw@127	1533	merge_one_directory(merger, &md);
danw@127	1534	}
danw@127	1535
danw@127	1536	static void
danw@127	1537	emit_files(struct list_head files, struct array source_pool,
danw@127	1538	uint32_t map, struct array pool)
danw@127	1539	{
danw@127	1540	uint32_t r;
danw@127	1541	struct list p, q;
danw@127	1542
danw@127	1543	r = pool->size / sizeof *q;
danw@127	1544	p = list_first(files, source_pool);
danw@127	1545	while (p) {
danw@127	1546	q = array_add(pool, sizeof *q);
danw@127	1547	q->data = map[p->data];
danw@127	1548	q->flags = p->flags;
danw@127	1549	p = list_next(p);
danw@127	1550	}
danw@127	1551
danw@127	1552	list_set_ptr(files, r);
danw@127	1553	}
danw@127	1554
krh@41	1555	/* Rebuild property->packages maps. We can't just remap these, as a
krh@41	1556	* property may have lost or gained a number of packages. Allocate an
krh@41	1557	* array per property and loop through the packages and add them to
krh@41	1558	* the arrays for their properties. */
krh@41	1559	static void
danw@127	1560	rebuild_property_package_lists(struct razor_set *set)
krh@41	1561	{
krh@66	1562	struct array pkgs, a;
krh@41	1563	struct razor_package pkg, pkg_end;
krh@41	1564	struct razor_property prop, prop_end;
danw@117	1565	struct list *r;
danw@117	1566	uint32_t *q;
krh@66	1567	int count;
krh@41	1568
krh@66	1569	count = set->properties.size / sizeof (struct razor_property);
krh@66	1570	pkgs = zalloc(count * sizeof *pkgs);
krh@41	1571	pkg_end = set->packages.data + set->packages.size;
krh@41	1572
krh@41	1573	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {
danw@128	1574	r = list_first(&pkg->properties, &set->property_pool);
danw@116	1575	while (r) {
danw@117	1576	q = array_add(&pkgs[r->data], sizeof *q);
krh@41	1577	q = pkg - (struct razor_package ) set->packages.data;
danw@116	1578	r = list_next(r);
krh@41	1579	}
krh@33	1580	}
krh@33	1581
krh@66	1582	prop_end = set->properties.data + set->properties.size;
krh@66	1583	a = pkgs;
krh@66	1584	for (prop = set->properties.data; prop < prop_end; prop++, a++) {
danw@128	1585	list_set_array(&prop->packages, &set->package_pool, a, 0);
krh@41	1586	array_release(a);
krh@41	1587	}
krh@66	1588	free(pkgs);
krh@33	1589	}
krh@33	1590
danw@127	1591	static void
danw@127	1592	rebuild_file_package_lists(struct razor_set *set)
danw@127	1593	{
danw@127	1594	struct array pkgs, a;
danw@127	1595	struct razor_package pkg, pkg_end;
danw@127	1596	struct razor_entry entry, entry_end;
danw@127	1597	struct list *r;
danw@127	1598	uint32_t *q;
danw@127	1599	int count;
danw@127	1600
danw@127	1601	count = set->files.size / sizeof (struct razor_entry);
danw@127	1602	pkgs = zalloc(count * sizeof *pkgs);
danw@127	1603	pkg_end = set->packages.data + set->packages.size;
danw@127	1604
danw@127	1605	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {
danw@128	1606	r = list_first(&pkg->files, &set->file_pool);
danw@127	1607	while (r) {
danw@127	1608	q = array_add(&pkgs[r->data], sizeof *q);
danw@127	1609	q = pkg - (struct razor_package ) set->packages.data;
danw@127	1610	r = list_next(r);
danw@127	1611	}
danw@127	1612	}
danw@127	1613
danw@127	1614	entry_end = set->files.data + set->files.size;
danw@127	1615	a = pkgs;
danw@127	1616	for (entry = set->files.data; entry < entry_end; entry++, a++) {
danw@128	1617	list_set_array(&entry->packages, &set->package_pool, a, 0);
danw@127	1618	array_release(a);
danw@127	1619	}
danw@127	1620	free(pkgs);
danw@127	1621	}
danw@127	1622
danw@137	1623	static struct razor_set *
krh@79	1624	razor_merger_finish(struct razor_merger *merger)
krh@79	1625	{
krh@79	1626	struct razor_set *result;
krh@41	1627	struct razor_package p, pend;
krh@33	1628
krh@41	1629	/* As we built the package list, we filled out a bitvector of
krh@41	1630	* the properties that are referenced by the packages in the
krh@41	1631	* new set. Now we do a parallel loop through the properties
krh@41	1632	* and emit those marked in the bit vector to the new set. In
krh@41	1633	* the process, we update the bit vector to actually map from
krh@41	1634	* indices in the old property list to indices in the new
krh@41	1635	* property list for both sets. */
krh@41	1636
krh@79	1637	merge_properties(merger);
danw@127	1638	merge_files(merger);
krh@41	1639
krh@41	1640	/* Now we loop through the packages again and emit the
krh@41	1641	* property lists, remapped to point to the new properties. */
krh@41	1642
krh@79	1643	pend = merger->set->packages.data + merger->set->packages.size;
krh@79	1644	for (p = merger->set->packages.data; p < pend; p++) {
krh@41	1645	struct source *src;
krh@41	1646
danw@120	1647	if (p->flags & UPSTREAM_SOURCE)
krh@79	1648	src = &merger->source2;
krh@41	1649	else
krh@79	1650	src = &merger->source1;
krh@41	1651
danw@116	1652	emit_properties(&p->properties,
danw@116	1653	&src->set->property_pool,
danw@116	1654	src->property_map,
danw@116	1655	&merger->set->property_pool);
danw@127	1656	emit_files(&p->files,
danw@127	1657	&src->set->file_pool,
danw@127	1658	src->file_map,
danw@127	1659	&merger->set->file_pool);
danw@120	1660	p->flags &= ~UPSTREAM_SOURCE;
krh@33	1661	}
krh@33	1662
danw@127	1663	rebuild_property_package_lists(merger->set);
danw@127	1664	rebuild_file_package_lists(merger->set);
krh@41	1665
danw@129	1666	result = merger->set;
danw@129	1667	hashtable_release(&merger->table);
danw@129	1668	free(merger);
danw@129	1669
danw@129	1670	return result;
danw@129	1671	}
danw@129	1672
danw@146	1673	/* The diff order matters. We should sort the packages so that a
danw@146	1674	* REMOVE of a package comes before the INSTALL, and so that all
danw@146	1675	* requires for a package have been installed before the package.
danw@146	1676	**/
danw@146	1677
danw@146	1678	void
danw@146	1679	razor_set_diff(struct razor_set set, struct razor_set upstream,
danw@146	1680	razor_package_callback_t callback, void *data)
danw@146	1681	{
danw@146	1682	struct razor_package_iterator pi1, pi2;
danw@146	1683	struct razor_package p1, p2;
danw@146	1684	const char name1, name2, version1, version2;
danw@146	1685	int res;
danw@146	1686
danw@146	1687	pi1 = razor_package_iterator_create(set);
danw@146	1688	pi2 = razor_package_iterator_create(upstream);
danw@146	1689
danw@146	1690	razor_package_iterator_next(pi1, &p1, &name1, &version1);
danw@146	1691	razor_package_iterator_next(pi2, &p2, &name2, &version2);
danw@146	1692
danw@146	1693	while (p1 \|\| p2) {
danw@146	1694	if (p1 && p2) {
danw@146	1695	res = strcmp(name1, name2);
danw@146	1696	if (res == 0)
danw@146	1697	res = versioncmp(version1, version2);
danw@146	1698	} else {
danw@146	1699	res = 0;
danw@146	1700	}
danw@146	1701
danw@146	1702	if (p2 == NULL \|\| res < 0)
danw@146	1703	callback(name1, version1, NULL, data);
danw@146	1704	else if (p1 == NULL \|\| res > 0)
danw@146	1705	callback(name2, NULL, version2, data);
danw@146	1706
danw@146	1707	if (p1 != NULL && res <= 0)
danw@146	1708	razor_package_iterator_next(pi1, &p1,
danw@146	1709	&name1, &version1);
danw@146	1710	if (p2 != NULL && res >= 0)
danw@146	1711	razor_package_iterator_next(pi2, &p2,
danw@146	1712	&name2, &version2);
danw@146	1713	}
danw@146	1714
danw@146	1715	razor_package_iterator_destroy(pi1);
danw@146	1716	razor_package_iterator_destroy(pi2);
danw@146	1717	}
danw@146	1718
krh@190	1719	struct razor_transaction;
krh@190	1720	struct razor_transaction_package;
krh@190	1721	struct razor_transaction_resolver;
krh@190	1722
krh@190	1723	struct razor_transaction {
krh@190	1724	int package_count, errors;
krh@190	1725	struct razor_transaction_package *packages;
krh@190	1726
krh@190	1727	struct razor_set system, upstream;
krh@190	1728	};
krh@190	1729
krh@190	1730	struct razor_transaction_package {
krh@190	1731	const char name, old_version, *new_version;
krh@190	1732	struct razor_package old_package, new_package;
krh@190	1733	enum razor_transaction_package_state state;
krh@190	1734
krh@190	1735	/* dep_package is the name of the package that resulted in
krh@190	1736	* this entry being created (or NULL if the user requested the
krh@190	1737	* install/remove), with the other dep_ fields providing
krh@190	1738	* additional information.
krh@190	1739	*
krh@190	1740	* For INSTALL, if dep_type is REQUIRES, then dep_package
krh@190	1741	* required something that this package provides. If dep_type
krh@190	1742	* is CONFLICTS, then dep_package is a package that conflicted
krh@190	1743	* with an older version of this package, forcing an upgrade.
krh@190	1744	*
krh@190	1745	* For REMOVE, if dep_type is REQUIRES, then dep_package is a
krh@190	1746	* package that is being removed. If dep_type is OBSOLETES,
krh@190	1747	* then dep_package is a package that obsoletes this one.
krh@190	1748	*
krh@190	1749	* For OLD_CONFLICT or NEW_CONFLICT, dep_package is an
krh@190	1750	* existing package that conflicts with this one. The
krh@190	1751	* conflicting property comes from the already-installed
krh@190	1752	* package for OLD_CONFLICT, or the to-be-installed package
krh@190	1753	* for NEW_CONFLICT.
krh@190	1754	*
krh@190	1755	* For UNSATISFIABLE, the dep_ fields are as for an INSTALL,
krh@190	1756	* but the name field will be NULL.
krh@190	1757	*/
krh@190	1758	const char *dep_package;
krh@190	1759	enum razor_property_type dep_type;
krh@190	1760	const char *dep_property;
krh@190	1761	enum razor_version_relation dep_relation;
krh@190	1762	const char *dep_version;
krh@190	1763	};
danw@141	1764
danw@141	1765	struct razor_transaction_resolver {
danw@141	1766	struct razor_set system, upstream;
danw@141	1767	struct bitarray syspkgs, uppkgs;
danw@141	1768	struct array packages;
danw@141	1769	int errors;
danw@141	1770	};
danw@141	1771
danw@144	1772	static int
danw@144	1773	package_in_set(void package, struct razor_set set)
danw@144	1774	{
danw@144	1775	return package >= set->packages.data &&
danw@144	1776	package < set->packages.data + set->packages.size;
danw@144	1777	}
danw@144	1778
danw@144	1779	static int
danw@144	1780	property_in_set(void property, struct razor_set set)
danw@144	1781	{
danw@144	1782	return property >= set->properties.data &&
danw@144	1783	property < set->properties.data + set->properties.size;
danw@144	1784	}
danw@144	1785
danw@168	1786	static struct razor_package *
danw@168	1787	property_provider_package(struct razor_transaction_resolver *trans,
danw@168	1788	struct razor_property *prop,
danw@168	1789	int installed)
danw@168	1790	{
danw@168	1791	struct razor_set *set;
danw@168	1792	struct bitarray *pkgbits;
danw@168	1793	struct razor_package *pkgs;
danw@168	1794	struct list *p;
danw@168	1795
danw@168	1796	if (installed && prop->type != RAZOR_PROPERTY_PROVIDES)
danw@168	1797	return NULL;
danw@168	1798	else if (!installed &&
danw@168	1799	prop->type != RAZOR_PROPERTY_PROVIDES &&
danw@168	1800	prop->type != RAZOR_PROPERTY_OBSOLETES)
danw@168	1801	return NULL;
danw@168	1802
danw@168	1803	if (property_in_set(prop, trans->system)) {
danw@168	1804	set = trans->system;
danw@168	1805	pkgbits = &trans->syspkgs;
danw@168	1806	} else {
danw@168	1807	set = trans->upstream;
danw@168	1808	pkgbits = &trans->uppkgs;
danw@168	1809	}
danw@168	1810	pkgs = set->packages.data;
danw@168	1811
danw@168	1812	for (p = list_first(&prop->packages, &set->package_pool); p; p = list_next(p)) {
danw@168	1813	if (bitarray_get(pkgbits, p->data) != installed)
danw@168	1814	continue;
danw@168	1815	if (prop->type == RAZOR_PROPERTY_OBSOLETES \|\|
danw@168	1816	pkgs[p->data].name == prop->name)
danw@168	1817	return &pkgs[p->data];
danw@168	1818	}
danw@168	1819	return NULL;
danw@168	1820	}
danw@168	1821
danw@144	1822	static int
danw@144	1823	compare_transaction_packages(const void one, const void two)
danw@144	1824	{
danw@160	1825	struct razor_transaction_package *tp1 = (void )one;
danw@160	1826	struct razor_transaction_package *tp2 = (void )two;
danw@160	1827
danw@160	1828	if (!(*tp1)->name)
danw@160	1829	return 1;
danw@160	1830	else if (!(*tp2)->name)
danw@160	1831	return -1;
danw@160	1832	else
danw@160	1833	return strcmp((tp1)->name, (tp2)->name);
danw@144	1834	}
danw@144	1835
danw@168	1836	/* FIXME: merge this into the other property loop in razor_transaction_satisfy */
danw@141	1837	static void
danw@160	1838	resolve_new_packages(struct razor_transaction_resolver *trans,
danw@160	1839	int start, int end)
krh@38	1840	{
danw@168	1841	struct razor_property sp, up, sp_end, up_end;
danw@168	1842	struct razor_package spkg, spkgs, upkg, upkgs;
danw@160	1843	struct razor_transaction_package **packages;
danw@144	1844	const char spool, upool;
danw@144	1845	int i;
danw@144	1846
danw@168	1847	sp_end = trans->system->properties.data + trans->system->properties.size;
danw@168	1848	spool = trans->system->string_pool.data;
danw@144	1849	spkgs = trans->system->packages.data;
danw@168	1850	up_end = trans->upstream->properties.data + trans->upstream->properties.size;
danw@168	1851	upool = trans->upstream->string_pool.data;
danw@144	1852	upkgs = trans->upstream->packages.data;
danw@168	1853
danw@168	1854	/* FIXME, check if sorting the packages directly (rather than
danw@168	1855	* sorting pointers-to-packages) still results in confusing
danw@168	1856	* descriptions.
danw@168	1857	*/
danw@160	1858	packages = calloc(end - start, sizeof *packages);
danw@160	1859	for (i = start; i < end; i++)
danw@160	1860	packages[i - start] = ((struct razor_transaction_package *)trans->packages.data) + i;
danw@160	1861	qsort(packages, end - start, sizeof *packages,
danw@160	1862	compare_transaction_packages);
danw@144	1863
danw@168	1864	sp = trans->system->properties.data;
danw@168	1865	up = trans->upstream->properties.data;
danw@160	1866	for (i = 0; i < end - start; i++) {
danw@169	1867	if (!packages[i]->name \|\|
danw@169	1868	packages[i]->state >= RAZOR_PACKAGE_FIRST_ERROR_STATE)
danw@160	1869	continue;
danw@168	1870
danw@168	1871	spkg = NULL;
danw@168	1872	while (sp < sp_end &&
danw@168	1873	strcmp(&spool[sp->name], packages[i]->name) < 0)
danw@144	1874	sp++;
danw@168	1875	while (sp < sp_end &&
danw@168	1876	strcmp(&spool[sp->name], packages[i]->name) == 0 &&
danw@168	1877	!(spkg = property_provider_package(trans, sp, 1)))
danw@168	1878	sp++;
danw@168	1879
danw@168	1880	upkg = NULL;
danw@168	1881	while (up < up_end &&
danw@168	1882	strcmp(&upool[up->name], packages[i]->name) < 0)
danw@168	1883	up++;
danw@168	1884	while (up < up_end &&
danw@168	1885	strcmp(&upool[up->name], packages[i]->name) == 0 &&
danw@168	1886	!(upkg = property_provider_package(trans, up, 0)))
danw@144	1887	up++;
danw@144	1888
danw@160	1889	if (packages[i]->state == RAZOR_PACKAGE_REMOVE \|\|
danw@160	1890	packages[i]->state == RAZOR_PACKAGE_OBSOLETED) {
danw@168	1891	if (spkg) {
danw@168	1892	packages[i]->old_package = spkg;
danw@168	1893	packages[i]->name = &spool[spkg->name];
danw@168	1894	packages[i]->old_version = &spool[spkg->version];
danw@168	1895	bitarray_set(&trans->syspkgs, spkg - spkgs, 0);
danw@169	1896	}
danw@169	1897	if (!packages[i]->old_package) {
danw@160	1898	packages[i]->name = strdup(packages[i]->name);
danw@169	1899	packages[i]->state \|= RAZOR_PACKAGE_UNAVAILABLE_FLAG;
danw@144	1900	trans->errors++;
danw@144	1901	}
danw@144	1902	} else {
danw@168	1903	if (upkg) {
danw@168	1904	packages[i]->new_package = upkg;
danw@168	1905	packages[i]->name = &upool[upkg->name];
danw@168	1906	packages[i]->new_version = &upool[upkg->version];
danw@168	1907
danw@168	1908	if (up->name != upkg->name) {
danw@168	1909	packages[i]->dep_package = &upool[upkg->name];
danw@168	1910	packages[i]->dep_type = up->type;
danw@168	1911	packages[i]->dep_property = &upool[up->name];
danw@168	1912	packages[i]->dep_relation = up->relation;
danw@168	1913	packages[i]->dep_version = &upool[up->version];
danw@168	1914	}
danw@168	1915
danw@168	1916	if (spkg) {
danw@168	1917	packages[i]->old_package = spkg;
danw@168	1918	packages[i]->old_version = &spool[spkg->version];
danw@168	1919	if (versioncmp(&spool[spkg->version], &upool[up->version]) >= 0) {
danw@160	1920	packages[i]->state = RAZOR_PACKAGE_UP_TO_DATE;
danw@144	1921	trans->errors++;
danw@144	1922	continue;
danw@144	1923	}
danw@168	1924	bitarray_set(&trans->syspkgs, spkg - spkgs, 0);
danw@144	1925	}
danw@168	1926	bitarray_set(&trans->uppkgs, upkg - upkgs, 1);
danw@169	1927	}
danw@169	1928	if (!packages[i]->new_package) {
danw@160	1929	packages[i]->name = strdup(packages[i]->name);
danw@169	1930	packages[i]->state \|= RAZOR_PACKAGE_UNAVAILABLE_FLAG;
danw@144	1931	trans->errors++;
krh@105	1932	}
krh@105	1933	}
krh@38	1934	}
krh@38	1935	}
krh@38	1936
krh@38	1937	static void
danw@141	1938	find_all_packages(struct razor_transaction_resolver *trans)
krh@38	1939	{
danw@137	1940	struct razor_transaction_package *tp;
danw@144	1941	struct razor_package sp, spkgs, send, up, upkgs, uend;
danw@144	1942	const char spool, upool;
danw@144	1943
danw@144	1944	spkgs = trans->system->packages.data;
danw@144	1945	send = trans->system->packages.data + trans->system->packages.size;
danw@144	1946	spool = trans->system->string_pool.data;
danw@144	1947	up = upkgs = trans->upstream->packages.data;
danw@141	1948	uend = trans->upstream->packages.data + trans->upstream->packages.size;
danw@141	1949	upool = trans->upstream->string_pool.data;
krh@38	1950
danw@144	1951	for (sp = spkgs; sp < send; sp++) {
danw@144	1952	while (up < uend && strcmp(&spool[sp->name], &upool[up->name]) > 0)
danw@144	1953	up++;
krh@177	1954	if (strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
krh@177	1955	versioncmp(&spool[sp->version], &upool[up->version]) < 0) {
danw@141	1956	tp = array_add(&trans->packages, sizeof *tp);
danw@137	1957	memset(tp, 0, sizeof *tp);
danw@147	1958	tp->old_package = sp;
danw@147	1959	tp->new_package = up;
danw@144	1960	tp->name = &upool[up->name];
danw@147	1961	tp->old_version = &spool[sp->version];
danw@147	1962	tp->new_version = &upool[up->version];
danw@137	1963	tp->state = RAZOR_PACKAGE_INSTALL;
danw@144	1964	bitarray_set(&trans->uppkgs, up - upkgs, 1);
danw@144	1965	bitarray_set(&trans->syspkgs, sp - spkgs, 0);
krh@38	1966	}
krh@38	1967	}
krh@38	1968	}
krh@38	1969
danw@137	1970	static int
danw@137	1971	provider_satisfies_requirement(struct razor_property *provider,
danw@137	1972	const char *provider_strings,
danw@137	1973	struct razor_property *requirement,
danw@137	1974	const char *requirement_strings)
danw@137	1975	{
danw@137	1976	int cmp, len;
danw@137	1977	const char *provided = &provider_strings[provider->version];
danw@137	1978	const char *required = &requirement_strings[requirement->version];
danw@137	1979
danw@137	1980	if (!*required)
danw@137	1981	return 1;
danw@170	1982	if (!*provided) {
danw@170	1983	if (requirement->relation >= RAZOR_VERSION_EQUAL)
danw@170	1984	return 1;
danw@170	1985	else
danw@170	1986	return 0;
danw@170	1987	}
danw@137	1988
danw@137	1989	cmp = versioncmp(provided, required);
danw@137	1990
danw@137	1991	switch (requirement->relation) {
danw@137	1992	case RAZOR_VERSION_LESS:
danw@137	1993	return cmp < 0;
danw@137	1994
danw@137	1995	case RAZOR_VERSION_LESS_OR_EQUAL:
danw@137	1996	if (cmp <= 0)
danw@137	1997	return 1;
danw@137	1998	/* fall through: FIXME, make sure this is correct */
danw@137	1999
danw@137	2000	case RAZOR_VERSION_EQUAL:
danw@137	2001	if (cmp == 0)
danw@137	2002	return 1;
danw@137	2003
danw@137	2004	/* "foo == 1.1" is satisfied by "foo 1.1-2" */
danw@137	2005	len = strlen(required);
danw@137	2006	if (!strncmp(required, provided, len) && provided[len] == '-')
danw@137	2007	return 1;
danw@137	2008	return 0;
danw@137	2009
danw@137	2010	case RAZOR_VERSION_GREATER_OR_EQUAL:
danw@137	2011	return cmp >= 0;
danw@137	2012
danw@137	2013	case RAZOR_VERSION_GREATER:
danw@137	2014	return cmp > 0;
danw@137	2015	}
danw@137	2016
danw@137	2017	/* shouldn't happen */
danw@137	2018	return 0;
danw@137	2019	}
danw@137	2020
danw@142	2021	static struct razor_package *
danw@144	2022	find_package_for_file(struct razor_set set, struct bitarray pkgbits,
danw@144	2023	const char *filename, int installed)
danw@134	2024	{
danw@142	2025	struct razor_package *pkgs = set->packages.data;
danw@140	2026	struct razor_entry *entry;
danw@140	2027	struct list *p;
danw@134	2028
danw@140	2029	if (filename[0] != '/')
danw@140	2030	return 0;
danw@140	2031
danw@142	2032	entry = find_entry(set, set->files.data, filename);
danw@140	2033	if (!entry)
danw@140	2034	return 0;
danw@140	2035
danw@142	2036	for (p = list_first(&entry->packages, &set->package_pool); p; p = list_next(p)) {
danw@142	2037	if (bitarray_get(pkgbits, p->data) == installed)
danw@142	2038	return &pkgs[p->data];
danw@134	2039	}
danw@142	2040	return NULL;
danw@142	2041	}
danw@142	2042
danw@142	2043	static struct razor_package *
danw@144	2044	find_installed_package_for_file(struct razor_transaction_resolver *trans,
danw@144	2045	const char *filename)
danw@142	2046	{
danw@144	2047	struct razor_package *pkg;
danw@144	2048
danw@144	2049	pkg = find_package_for_file(trans->system, &trans->syspkgs,
danw@144	2050	filename, 1);
danw@144	2051	if (!pkg)
danw@144	2052	pkg = find_package_for_file(trans->upstream, &trans->uppkgs,
danw@144	2053	filename, 1);
danw@144	2054	return pkg;
danw@142	2055	}
danw@142	2056
danw@142	2057	static struct razor_package *
danw@144	2058	find_uninstalled_package_for_file(struct razor_transaction_resolver *trans,
danw@144	2059	const char *filename)
danw@142	2060	{
danw@144	2061	struct razor_package *pkg;
danw@144	2062
danw@144	2063	pkg = find_package_for_file(trans->upstream, &trans->uppkgs,
danw@144	2064	filename, 0);
danw@144	2065	if (!pkg)
danw@144	2066	pkg = find_package_for_file(trans->system, &trans->syspkgs,
danw@144	2067	filename, 0);
danw@144	2068	return pkg;
danw@134	2069	}
danw@134	2070
danw@154	2071	static struct razor_property *
danw@154	2072	skip_to_matching_property(struct razor_transaction_resolver *trans,
danw@154	2073	struct razor_property *match,
danw@154	2074	struct razor_property *prop)
danw@154	2075	{
danw@154	2076	struct razor_set mset, pset;
danw@154	2077	const char ppool, mpool;
danw@154	2078	struct razor_property *prop_end;
danw@154	2079
danw@154	2080	if (property_in_set(match, trans->system))
danw@154	2081	mset = trans->system;
danw@154	2082	else
danw@154	2083	mset = trans->upstream;
danw@154	2084
danw@154	2085	if (property_in_set(prop, trans->system))
danw@154	2086	pset = trans->system;
danw@154	2087	else if (property_in_set(prop, trans->upstream))
danw@154	2088	pset = trans->upstream;
danw@154	2089	else
danw@154	2090	return prop;
danw@154	2091
danw@154	2092	prop_end = pset->properties.data + pset->properties.size;
danw@154	2093	ppool = pset->string_pool.data;
danw@154	2094	mpool = mset->string_pool.data;
danw@154	2095
danw@154	2096	while (prop < prop_end &&
danw@154	2097	strcmp(&ppool[prop->name], &mpool[match->name]) < 0)
danw@154	2098	prop++;
danw@154	2099	return prop;
danw@154	2100	}
danw@154	2101
danw@140	2102	static struct razor_package *
danw@144	2103	find_package_matching(struct razor_transaction_resolver *trans, int installed,
danw@154	2104	struct razor_property *prop,
danw@144	2105	struct razor_property *req,
danw@144	2106	struct razor_set *req_set)
danw@138	2107	{
danw@144	2108	struct razor_set *set;
danw@144	2109	struct bitarray *pkgbits;
danw@144	2110	struct razor_package *pkgs;
danw@154	2111	struct razor_property props, prop_end;
danw@144	2112	enum razor_property_type match_type;
danw@144	2113	const char *pool;
danw@154	2114	const char *rpool;
danw@154	2115	int match_name = (req->type == RAZOR_PROPERTY_OBSOLETES);
danw@144	2116	int match;
danw@144	2117
danw@144	2118	if (property_in_set(prop, trans->system)) {
danw@144	2119	set = trans->system;
danw@144	2120	pkgbits = &trans->syspkgs;
danw@144	2121	} else if (property_in_set(prop, trans->upstream)) {
danw@144	2122	set = trans->upstream;
danw@144	2123	pkgbits = &trans->uppkgs;
danw@144	2124	} else
danw@144	2125	return NULL;
danw@144	2126
danw@154	2127	if (!req_set) {
danw@154	2128	if (property_in_set(req, trans->system))
danw@154	2129	req_set = trans->system;
danw@154	2130	else
danw@154	2131	req_set = trans->upstream;
danw@154	2132	}
danw@154	2133	rpool = req_set->string_pool.data;
danw@154	2134
danw@144	2135	if (req->type == RAZOR_PROPERTY_PROVIDES)
danw@144	2136	match_type = RAZOR_PROPERTY_CONFLICTS;
danw@144	2137	else
danw@144	2138	match_type = RAZOR_PROPERTY_PROVIDES;
danw@144	2139
danw@144	2140	pkgs = set->packages.data;
danw@144	2141	props = set->properties.data;
danw@144	2142	prop_end = set->properties.data + set->properties.size;
danw@144	2143	pool = set->string_pool.data;
danw@144	2144
danw@144	2145	/* Find first matching property */
danw@144	2146	while (prop < prop_end &&
danw@144	2147	strcmp(&pool[prop->name], &rpool[req->name]) < 0)
danw@144	2148	prop++;
danw@144	2149	if (prop == prop_end \|\|
danw@144	2150	strcmp(&pool[prop->name], &rpool[req->name]) > 0)
danw@144	2151	return NULL;
danw@144	2152
danw@144	2153	if (prop->type < match_type) {
danw@144	2154	while (prop < prop_end && prop->type != match_type)
danw@144	2155	prop++;
danw@144	2156	} else {
danw@144	2157	while (prop >= props && prop->type != match_type)
danw@144	2158	prop--;
danw@183	2159	while (prop > props + 1 && (prop - 1)->name == prop->name &&
danw@183	2160	(prop - 1)->type == match_type)
danw@144	2161	prop--;
danw@144	2162	}
danw@144	2163
danw@153	2164	/* Scan matching properties */
danw@144	2165	while (prop < prop_end && prop->type == match_type &&
danw@144	2166	strcmp(&pool[prop->name], &rpool[req->name]) == 0) {
danw@144	2167	if (match_type == RAZOR_PROPERTY_PROVIDES)
danw@144	2168	match = provider_satisfies_requirement(prop, pool, req, rpool);
danw@144	2169	else
danw@144	2170	match = provider_satisfies_requirement(req, rpool, prop, pool);
danw@144	2171	if (match) {
danw@140	2172	struct list *pkg;
danw@140	2173
danw@144	2174	for (pkg = list_first(&prop->packages, &set->package_pool); pkg; pkg = list_next(pkg)) {
danw@144	2175	if (bitarray_get(pkgbits, pkg->data) != installed)
danw@140	2176	continue;
danw@140	2177	if (!match_name \|\|
danw@144	2178	strcmp(&pool[pkgs[pkg->data].name],
danw@144	2179	&rpool[req->name]) == 0)
danw@144	2180	return &pkgs[pkg->data];
danw@140	2181	}
danw@140	2182	}
danw@144	2183	prop++;
danw@140	2184	}
danw@140	2185
danw@140	2186	return NULL;
danw@138	2187	}
danw@138	2188
danw@140	2189	static struct razor_package *
danw@144	2190	find_installed_package_for_property(struct razor_transaction_resolver *trans,
danw@154	2191	struct razor_property *sys_start,
danw@154	2192	struct razor_property *up_start,
danw@144	2193	struct razor_property *req)
danw@138	2194	{
danw@144	2195	struct razor_package *pkg;
danw@144	2196
danw@154	2197	pkg = find_package_matching(trans, 1, sys_start, req, NULL);
danw@144	2198	if (!pkg)
danw@154	2199	pkg = find_package_matching(trans, 1, up_start, req, NULL);
danw@144	2200	return pkg;
danw@144	2201	}
danw@144	2202
danw@144	2203	static struct razor_package *
danw@144	2204	find_uninstalled_package_for_property(struct razor_transaction_resolver *trans,
danw@154	2205	struct razor_property *sys_start,
danw@154	2206	struct razor_property *up_start,
danw@144	2207	struct razor_property *req)
danw@144	2208	{
danw@144	2209	struct razor_package *pkg;
danw@144	2210
danw@154	2211	pkg = find_package_matching(trans, 0, up_start, req, NULL);
danw@144	2212	if (!pkg)
danw@154	2213	pkg = find_package_matching(trans, 0, sys_start, req, NULL);
danw@144	2214	return pkg;
danw@140	2215	}
danw@140	2216
danw@147	2217	static struct razor_transaction_package *
danw@147	2218	find_transaction_package(struct razor_transaction_resolver *trans,
danw@147	2219	const char *name)
danw@147	2220	{
danw@147	2221	struct razor_transaction_package *packages;
danw@147	2222	int count, i;
danw@147	2223
danw@147	2224	packages = trans->packages.data;
danw@147	2225	count = trans->packages.size / sizeof *packages;
danw@147	2226	for (i = 0; i < count; i++) {
danw@147	2227	if (packages[i].name && !strcmp(packages[i].name, name))
danw@147	2228	return &packages[i];
danw@147	2229	}
danw@147	2230	return NULL;
danw@147	2231	}
danw@147	2232
danw@160	2233	/* FIXME? */
danw@160	2234	static int
danw@160	2235	prop_is_being_installed(struct razor_transaction_resolver *trans,
danw@160	2236	struct razor_property *prop)
danw@160	2237	{
danw@160	2238	struct list *pkg;
danw@160	2239
danw@160	2240	for (pkg = list_first(&prop->packages, &trans->upstream->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2241	if (bitarray_get(&trans->uppkgs, pkg->data))
danw@160	2242	return 1;
danw@160	2243	}
danw@160	2244	return 0;
danw@160	2245	}
danw@160	2246
danw@160	2247	static int
danw@160	2248	prop_is_being_removed(struct razor_transaction_resolver *trans,
danw@160	2249	struct razor_property *prop)
danw@160	2250	{
danw@160	2251	struct list *pkg;
danw@160	2252
danw@160	2253	for (pkg = list_first(&prop->packages, &trans->system->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2254	if (bitarray_get(&trans->syspkgs, pkg->data))
danw@160	2255	return 0;
danw@160	2256	}
danw@160	2257	return 1;
danw@160	2258	}
danw@160	2259
danw@160	2260	static int
danw@160	2261	prop_is_being_updated(struct razor_transaction_resolver *trans,
danw@160	2262	struct razor_property *prop)
danw@160	2263	{
danw@160	2264	struct razor_package *packages = trans->system->packages.data;
danw@160	2265	const char *pool = trans->system->string_pool.data;
danw@160	2266	struct razor_transaction_package *tp;
danw@160	2267	struct list *pkg;
danw@160	2268
danw@160	2269	/* Assumes prop_is_being_removed returns true */
danw@160	2270
danw@160	2271	for (pkg = list_first(&prop->packages, &trans->system->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2272	tp = find_transaction_package(trans, &pool[packages[pkg->data].name]);
danw@160	2273	if (tp && tp->state == RAZOR_PACKAGE_REMOVE)
danw@160	2274	return 0;
danw@160	2275	}
danw@160	2276	return 1;
danw@160	2277	}
danw@160	2278
danw@131	2279	static void
danw@141	2280	add_transaction_package(struct razor_transaction_resolver *trans,
danw@147	2281	struct razor_package *new_package,
danw@147	2282	struct razor_package *old_package,
danw@140	2283	enum razor_transaction_package_state state,
danw@144	2284	const char *req_package,
danw@144	2285	struct razor_property *req_prop)
danw@131	2286	{
danw@147	2287	struct razor_set new_package_set, old_package_set, *req_set;
danw@160	2288	struct bitarray *reqpkgbits;
danw@147	2289	struct razor_transaction_package tp, already;
danw@140	2290	const char *pool;
danw@140	2291	struct razor_package *pkgs;
danw@140	2292	struct list *pkg;
danw@147	2293	int contradiction = 0;
danw@147	2294
danw@160	2295	if (package_in_set(new_package, trans->system))
danw@147	2296	new_package_set = trans->system;
danw@160	2297	else
danw@147	2298	new_package_set = trans->upstream;
danw@160	2299	if (package_in_set(old_package, trans->system))
danw@147	2300	old_package_set = trans->system;
danw@160	2301	else
danw@147	2302	old_package_set = trans->upstream;
danw@145	2303	if (property_in_set(req_prop, trans->system)) {
danw@145	2304	req_set = trans->system;
danw@145	2305	reqpkgbits = &trans->syspkgs;
danw@145	2306	} else {
danw@145	2307	req_set = trans->upstream;
danw@145	2308	reqpkgbits = &trans->uppkgs;
danw@145	2309	}
danw@144	2310
danw@147	2311	if (new_package) {
danw@147	2312	pool = new_package_set->string_pool.data;
danw@147	2313	already = find_transaction_package(trans, &pool[new_package->name]);
danw@147	2314	if (already) {
danw@147	2315	if (already->new_package == new_package) {
danw@147	2316	/* Already taken care of */
danw@147	2317	return;
danw@166	2318	} else if (new_package_set == trans->upstream &&
danw@166	2319	already->state == RAZOR_PACKAGE_FORCED_UPDATE) {
danw@166	2320	already->new_package = new_package;
danw@166	2321	return;
danw@147	2322	}
danw@166	2323
danw@147	2324	/* Oops. We lose */
danw@147	2325	if (state != RAZOR_PACKAGE_CONTRADICTION)
danw@147	2326	contradiction = 1;
danw@147	2327	}
danw@147	2328	} else if (old_package) {
danw@147	2329	pool = old_package_set->string_pool.data;
danw@147	2330	already = find_transaction_package(trans, &pool[old_package->name]);
danw@147	2331	if (already) {
danw@147	2332	if (already->old_package == old_package) {
danw@147	2333	/* Already taken care of */
danw@147	2334	return;
danw@166	2335	} else if (old_package_set == trans->system) {
danw@166	2336	already->old_package = old_package;
danw@166	2337	return;
danw@147	2338	}
danw@166	2339
danw@147	2340	/* Oops. We lose */
danw@147	2341	if (state != RAZOR_PACKAGE_CONTRADICTION)
danw@147	2342	contradiction = 1;
danw@147	2343	}
danw@147	2344	} else
danw@147	2345	state = RAZOR_PACKAGE_UNSATISFIABLE;
danw@147	2346
danw@141	2347	tp = array_add(&trans->packages, sizeof *tp);
danw@140	2348	memset(tp, 0, sizeof *tp);
danw@131	2349
danw@147	2350	if (new_package) {
danw@147	2351	pool = new_package_set->string_pool.data;
danw@147	2352	tp->new_package = new_package;
danw@147	2353	tp->name = &pool[new_package->name];
danw@147	2354	tp->new_version = &pool[new_package->version];
danw@147	2355
danw@147	2356	pkgs = new_package_set->packages.data;
danw@147	2357	}
danw@147	2358	if (old_package) {
danw@147	2359	pool = old_package_set->string_pool.data;
danw@147	2360	tp->old_package = old_package;
danw@147	2361	tp->name = &pool[old_package->name];
danw@147	2362	tp->old_version = &pool[old_package->version];
danw@147	2363
danw@147	2364	pkgs = old_package_set->packages.data;
danw@147	2365	}
danw@147	2366
danw@147	2367	tp->state = state;
danw@147	2368	if (state != RAZOR_PACKAGE_INSTALL &&
danw@154	2369	state != RAZOR_PACKAGE_FORCED_UPDATE &&
danw@154	2370	state != RAZOR_PACKAGE_REMOVE &&
danw@154	2371	state != RAZOR_PACKAGE_OBSOLETED)
danw@145	2372	trans->errors++;
danw@147	2373
danw@147	2374	if (contradiction) {
danw@147	2375	/* Do this now, after adding tp, so that it ends up
danw@147	2376	* after both the INSTALL and the REMOVE in the array.
danw@147	2377	*/
danw@147	2378	add_transaction_package(trans, new_package, old_package,
danw@147	2379	RAZOR_PACKAGE_CONTRADICTION,
danw@147	2380	NULL, NULL);
danw@145	2381	}
danw@140	2382
danw@144	2383	if (req_package)
danw@145	2384	tp->dep_package = req_package;
danw@145	2385	if (!req_prop)
danw@145	2386	return;
danw@145	2387
danw@145	2388	pool = req_set->string_pool.data;
danw@145	2389	pkgs = req_set->packages.data;
danw@145	2390	if (!req_package) {
danw@145	2391	for (pkg = list_first(&req_prop->packages, &req_set->package_pool); pkg; pkg = list_next(pkg)) {
danw@145	2392	if (bitarray_get(reqpkgbits, pkg->data))
danw@144	2393	break;
danw@144	2394	}
danw@145	2395	if (pkg)
danw@145	2396	tp->dep_package = &pool[pkgs[pkg->data].name];
danw@131	2397	}
danw@144	2398
danw@145	2399	tp->dep_type = req_prop->type;
danw@145	2400	tp->dep_property = &pool[req_prop->name];
danw@145	2401	tp->dep_relation = req_prop->relation;
danw@145	2402	tp->dep_version = &pool[req_prop->version];
danw@140	2403	}
danw@140	2404
danw@160	2405	static void
danw@160	2406	razor_transaction_satisfy(struct razor_transaction_resolver *trans)
danw@147	2407	{
danw@160	2408	struct razor_package spkgs, upkgs, *pkg;
danw@144	2409	struct razor_property sp, sprops, *sprop_end;
danw@144	2410	struct razor_property up, uprops, *uprop_end;
danw@160	2411	struct razor_property sr, ur, *first_up;
danw@160	2412	const char spool, upool, *removed_package;
danw@160	2413	struct list *reqpkg;
danw@134	2414
danw@140	2415	spkgs = trans->system->packages.data;
danw@140	2416	sprops = trans->system->properties.data;
danw@144	2417	sprop_end = trans->system->properties.data + trans->system->properties.size;
danw@145	2418	spool = trans->system->string_pool.data;
danw@140	2419	upkgs = trans->upstream->packages.data;
danw@140	2420	uprops = trans->upstream->properties.data;
danw@144	2421	uprop_end = trans->upstream->properties.data + trans->upstream->properties.size;
danw@140	2422	upool = trans->upstream->string_pool.data;
krh@33	2423
danw@144	2424	sp = sprops;
danw@160	2425	for (up = uprops; up < uprop_end; up++) {
danw@140	2426	/* Skip 'up' ahead to a property of a package which is
danw@140	2427	* to-be-installed.
danw@140	2428	*/
danw@144	2429	while (up < uprop_end &&
danw@144	2430	!prop_is_being_installed(trans, up))
danw@140	2431	up++;
danw@144	2432	if (up == uprop_end)
danw@140	2433	break;
danw@154	2434	sp = skip_to_matching_property(trans, up, sp);
krh@33	2435
danw@144	2436	switch (up->type) {
danw@140	2437	case RAZOR_PROPERTY_REQUIRES:
danw@144	2438	if (!strncmp(&upool[up->name], "rpmlib(", 7))
danw@140	2439	break;
danw@131	2440
danw@154	2441	if (find_installed_package_for_property(trans, sp, up, up) \|\|
danw@144	2442	find_installed_package_for_file(trans, &upool[up->name])) {
danw@140	2443	/* Requires something that is either installed
danw@140	2444	* or to-be-installed.
danw@140	2445	*/
danw@140	2446	break;
danw@137	2447	}
danw@137	2448
danw@140	2449	/* See if we can install a new upstream provider */
danw@154	2450	pkg = find_uninstalled_package_for_property(trans, sp, up, up);
danw@154	2451	if (!pkg)
danw@144	2452	pkg = find_uninstalled_package_for_file(trans, &upool[up->name]);
danw@160	2453	add_transaction_package(trans, pkg, NULL,
danw@144	2454	RAZOR_PACKAGE_INSTALL,
danw@144	2455	NULL, up);
danw@144	2456	break;
danw@144	2457
danw@144	2458	case RAZOR_PROPERTY_PROVIDES:
danw@144	2459	/* find_installed_package_for_property works backwards
danw@144	2460	* here, finding a conflicting installed package.
danw@144	2461	*/
danw@154	2462	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@140	2463	if (!pkg)
danw@144	2464	break;
danw@144	2465
danw@145	2466	if (package_in_set(pkg, trans->system)) {
danw@145	2467	/* pkg CONFLICTS with what 'up' PROVIDES. Try
danw@145	2468	* finding an upgrade
danw@145	2469	*/
danw@160	2470	add_transaction_package(trans, NULL, pkg,
danw@160	2471	RAZOR_PACKAGE_FORCED_UPDATE,
danw@165	2472	&upool[up->name], sp);
danw@160	2473	} else {
danw@160	2474	add_transaction_package(trans, NULL, pkg,
danw@160	2475	RAZOR_PACKAGE_CONTRADICTION,
danw@160	2476	NULL, up);
danw@144	2477	}
danw@140	2478	break;
danw@140	2479
danw@140	2480	case RAZOR_PROPERTY_CONFLICTS:
danw@154	2481	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@144	2482	if (!pkg)
danw@144	2483	break;
danw@144	2484
danw@144	2485	if (package_in_set(pkg, trans->system)) {
danw@140	2486	/* Conflicts with something already installed.
danw@140	2487	* Try to upgrade out.
danw@140	2488	*/
danw@160	2489	add_transaction_package(trans, NULL, pkg,
danw@160	2490	RAZOR_PACKAGE_FORCED_UPDATE,
danw@160	2491	NULL, up);
danw@160	2492	} else {
danw@160	2493	add_transaction_package(trans, pkg, NULL,
danw@160	2494	RAZOR_PACKAGE_CONTRADICTION,
danw@160	2495	NULL, up);
danw@140	2496	}
danw@140	2497	break;
danw@140	2498
danw@140	2499	case RAZOR_PROPERTY_OBSOLETES:
danw@154	2500	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@145	2501	if (pkg) {
danw@145	2502	/* If pkg is to-be-installed, this
danw@145	2503	* will add a CONTRADICTION error as well.
danw@145	2504	*/
danw@147	2505	add_transaction_package(trans, NULL, pkg,
danw@154	2506	RAZOR_PACKAGE_OBSOLETED,
danw@144	2507	NULL, up);
danw@140	2508	}
danw@140	2509	break;
danw@140	2510
danw@140	2511	default:
danw@140	2512	/* can't happen */
danw@140	2513	break;
danw@131	2514	}
krh@37	2515	}
danw@154	2516
danw@154	2517	up = uprops;
danw@154	2518	for (sp = sprops; sp < sprop_end; sp++) {
danw@154	2519	/* Skip 'sp' ahead to a PROVIDES of a package which is
danw@154	2520	* to-be-removed.
danw@154	2521	*/
danw@154	2522	while (sp < sprop_end &&
danw@154	2523	(sp->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@154	2524	!prop_is_being_removed(trans, sp)))
danw@154	2525	sp++;
danw@154	2526	if (sp == sprop_end)
danw@154	2527	break;
danw@154	2528
danw@154	2529	removed_package = &spool[spkgs[list_first(&sp->packages, &trans->system->package_pool)->data].name];
danw@154	2530
danw@154	2531	/* Skip 'up' to match */
danw@154	2532	up = skip_to_matching_property(trans, sp, up);
danw@154	2533	ur = first_up = up;
danw@154	2534
danw@154	2535	/* If the package is just being upgraded, we may
danw@154	2536	* already be installing an identical PROVIDES, so
danw@154	2537	* check for that.
danw@154	2538	*/
danw@154	2539	while (up < uprop_end &&
danw@154	2540	strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
danw@154	2541	(up->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@154	2542	sp->relation != up->relation \|\|
danw@154	2543	strcmp(&spool[sp->name], &upool[up->name]) != 0))
danw@154	2544	up++;
danw@154	2545	if (up < uprop_end &&
danw@154	2546	up->type == RAZOR_PROPERTY_PROVIDES &&
danw@154	2547	strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
danw@154	2548	sp->relation == up->relation &&
danw@154	2549	strcmp(&spool[sp->version], &upool[up->version]) == 0 &&
danw@154	2550	prop_is_being_installed(trans, up)) {
danw@154	2551	up = first_up;
danw@154	2552	continue;
danw@154	2553	}
danw@154	2554	up = first_up;
danw@154	2555
danw@154	2556	/* For all still-installed packages that require
danw@154	2557	* sp->name, see if they are satisfied by any other
danw@154	2558	* still-installed or to-be-installed property. If
danw@154	2559	* not, either remove or attempt to update the
danw@154	2560	* package, depending on why the required property has
danw@154	2561	* disappeared
danw@154	2562	*/
danw@154	2563	sr = sp;
danw@154	2564	while (sr > sprops + 1 && (sr - 1)->name == sr->name)
danw@154	2565	sr--;
danw@154	2566	for (; sr->type == RAZOR_PROPERTY_REQUIRES; sr++) {
danw@154	2567	if (prop_is_being_removed(trans, sr))
danw@154	2568	continue;
danw@154	2569	if (find_installed_package_for_property(trans, sp, up, sr))
danw@154	2570	continue;
danw@154	2571
danw@154	2572	for (reqpkg = list_first(&sr->packages, &trans->system->package_pool); reqpkg; reqpkg = list_next(reqpkg)) {
danw@154	2573	if (!bitarray_get(&trans->syspkgs, reqpkg->data))
danw@154	2574	continue;
danw@154	2575	pkg = &spkgs[reqpkg->data];
danw@154	2576	if (prop_is_being_updated(trans, sp)) {
danw@160	2577	add_transaction_package(trans, NULL, pkg,
danw@160	2578	RAZOR_PACKAGE_FORCED_UPDATE,
danw@160	2579	removed_package, NULL);
danw@154	2580	} else {
danw@154	2581	add_transaction_package(trans, NULL, pkg,
danw@154	2582	RAZOR_PACKAGE_REMOVE,
danw@154	2583	removed_package, sr);
danw@154	2584	}
danw@154	2585	}
danw@154	2586	}
danw@154	2587	}
danw@154	2588	}
danw@129	2589
danw@137	2590	struct razor_transaction *
danw@137	2591	razor_transaction_create(struct razor_set system, struct razor_set upstream,
danw@137	2592	int update_count, const char **update_packages,
danw@137	2593	int remove_count, const char **remove_packages)
danw@137	2594	{
danw@141	2595	struct razor_transaction_resolver trans;
danw@141	2596	struct razor_transaction *ret_trans;
danw@160	2597	struct razor_transaction_package *tp;
danw@160	2598	int start, end, i;
danw@137	2599
danw@141	2600	trans.system = system;
danw@141	2601	trans.upstream = upstream ? upstream : razor_set_create();
danw@141	2602	array_init(&trans.packages);
danw@141	2603	bitarray_init(&trans.syspkgs, trans.system->packages.size / sizeof (struct razor_package), 1);
danw@141	2604	bitarray_init(&trans.uppkgs, trans.upstream->packages.size / sizeof (struct razor_package), 0);
danw@141	2605	trans.errors = 0;
danw@137	2606
danw@144	2607	if (update_count > 0 \|\| remove_count > 0) {
danw@160	2608	for (i = 0; i < update_count; i++) {
danw@160	2609	tp = array_add(&trans.packages, sizeof *tp);
danw@160	2610	memset(tp, 0, sizeof *tp);
danw@160	2611	tp->name = update_packages[i];
danw@160	2612	tp->state = RAZOR_PACKAGE_INSTALL;
danw@160	2613	}
danw@160	2614	for (i = 0; i < remove_count; i++) {
danw@160	2615	tp = array_add(&trans.packages, sizeof *tp);
danw@160	2616	memset(tp, 0, sizeof *tp);
danw@160	2617	tp->name = remove_packages[i];
danw@160	2618	tp->state = RAZOR_PACKAGE_REMOVE;
danw@160	2619	}
danw@144	2620	} else
danw@141	2621	find_all_packages(&trans);
danw@137	2622
danw@137	2623	start = 0;
danw@141	2624	end = trans.packages.size / sizeof (struct razor_transaction_package);
danw@137	2625
danw@160	2626	while (start != end) {
danw@160	2627	resolve_new_packages(&trans, start, end);
danw@160	2628	if (trans.errors)
danw@160	2629	break;
danw@160	2630
danw@160	2631	razor_transaction_satisfy(&trans);
danw@137	2632
danw@137	2633	start = end;
danw@141	2634	end = trans.packages.size / sizeof (struct razor_transaction_package);
danw@137	2635	}
danw@137	2636
danw@141	2637	ret_trans = zalloc(sizeof *ret_trans);
danw@141	2638	ret_trans->system = trans.system;
danw@141	2639	ret_trans->upstream = trans.upstream;
danw@141	2640	ret_trans->packages = trans.packages.data;
danw@141	2641	ret_trans->package_count = end;
danw@141	2642	ret_trans->errors = trans.errors;
danw@141	2643	return ret_trans;
danw@137	2644	}
danw@137	2645
danw@137	2646	const char * const razor_version_relations[] = {
danw@137	2647	/* same order as enum razor_version_relation */
danw@137	2648	"<", "<=", "=", ">=", ">"
danw@137	2649	};
danw@137	2650
danw@140	2651	const char * const razor_property_types[] = {
danw@140	2652	/* same order as enum razor_property_type */
danw@140	2653	"requires", "provides", "conflicts with", "obsoletes"
danw@140	2654	};
danw@140	2655
danw@169	2656	static void
danw@169	2657	print_requirement(struct razor_transaction_package *p)
danw@169	2658	{
danw@169	2659	if (p->dep_type == RAZOR_PROPERTY_CONFLICTS &&
danw@169	2660	!strcmp(p->dep_package, p->name)) {
danw@169	2661	printf(" because %s %s conflicts with %s",
danw@169	2662	p->name, p->old_version, p->dep_property);
danw@169	2663	if (*p->dep_version) {
danw@169	2664	printf(" %s %s",
danw@169	2665	razor_version_relations[p->dep_relation],
danw@169	2666	p->dep_version);
danw@169	2667	}
danw@169	2668	} else {
danw@169	2669	if (strcmp(p->name, p->dep_package) != 0)
danw@169	2670	printf(" for %s", p->dep_package);
danw@169	2671	if (*p->dep_version) {
danw@169	2672	printf(", which %s %s %s %s",
danw@169	2673	razor_property_types[p->dep_type],
danw@169	2674	p->dep_property,
danw@169	2675	razor_version_relations[p->dep_relation],
danw@169	2676	p->dep_version);
danw@169	2677	} else if (strcmp(p->dep_property, p->name) != 0) {
danw@169	2678	printf(", which %s %s",
danw@169	2679	razor_property_types[p->dep_type],
danw@169	2680	p->dep_property);
danw@169	2681	}
danw@169	2682	}
danw@169	2683	}
danw@169	2684
krh@190	2685	int
danw@137	2686	razor_transaction_describe(struct razor_transaction *trans)
danw@137	2687	{
danw@137	2688	struct razor_transaction_package p, pend, *tps;
danw@137	2689	int errors_only = 0;
danw@137	2690
danw@137	2691	tps = trans->packages;
danw@137	2692	pend = trans->packages + trans->package_count;
danw@137	2693	for (p = trans->packages; p < pend; p++) {
danw@137	2694	switch (p->state) {
danw@137	2695	case RAZOR_PACKAGE_INSTALL:
danw@137	2696	if (errors_only)
danw@137	2697	break;
danw@137	2698
danw@147	2699	printf("Installing %s %s", p->name, p->new_version);
danw@169	2700	if (p->dep_package)
danw@169	2701	print_requirement(p);
danw@137	2702	printf("\n");
danw@137	2703	break;
danw@137	2704
danw@154	2705	case RAZOR_PACKAGE_FORCED_UPDATE:
danw@154	2706	if (errors_only)
danw@154	2707	break;
danw@154	2708
danw@154	2709	printf("Updating %s to %s due to update of %s\n",
danw@154	2710	p->name, p->new_version, p->dep_package);
danw@154	2711	break;
danw@154	2712
danw@137	2713	case RAZOR_PACKAGE_REMOVE:
danw@137	2714	if (errors_only)
danw@137	2715	break;
danw@147	2716	printf("Removing %s %s", p->name, p->old_version);
danw@145	2717	if (p->dep_package) {
danw@154	2718	printf(" which required %s",
danw@154	2719	p->dep_package);
danw@162	2720	if (strcmp(p->dep_property, p->dep_package) != 0)
danw@154	2721	printf(" for %s", p->dep_property);
danw@154	2722	}
danw@154	2723	printf("\n");
danw@154	2724	break;
danw@154	2725
danw@154	2726	case RAZOR_PACKAGE_OBSOLETED:
danw@154	2727	if (errors_only)
danw@154	2728	break;
danw@154	2729	printf("Removing %s %s", p->name, p->old_version);
danw@154	2730	if (p->dep_package) {
danw@154	2731	printf(" which is obsoleted by %s",
danw@154	2732	p->dep_package);
danw@137	2733	}
danw@137	2734	printf("\n");
danw@137	2735	break;
danw@137	2736
danw@145	2737	case RAZOR_PACKAGE_INSTALL_UNAVAILABLE:
danw@169	2738	printf("Error: can't find %s", p->name);
danw@169	2739	if (p->dep_package) {
danw@169	2740	printf(" (which is required");
danw@169	2741	print_requirement(p);
danw@169	2742	printf(")");
danw@169	2743	}
danw@169	2744	printf("\n");
danw@169	2745	errors_only = 1;
danw@169	2746	break;
danw@169	2747
danw@169	2748	case RAZOR_PACKAGE_UPDATE_UNAVAILABLE:
danw@169	2749	printf("Error: can't find an updated version of %s (which must be updated due to update of %s)\n",
danw@169	2750	p->name, p->dep_package);
danw@137	2751	errors_only = 1;
danw@137	2752	break;
danw@137	2753
danw@145	2754	case RAZOR_PACKAGE_REMOVE_NOT_INSTALLED:
danw@145	2755	printf("Error: can't remove %s: not installed\n", p->name);
danw@137	2756	errors_only = 1;
danw@137	2757	break;
danw@137	2758
danw@145	2759	case RAZOR_PACKAGE_UP_TO_DATE:
danw@169	2760	printf("Error: can't update %s", p->name);
danw@169	2761	if (p->dep_package)
danw@169	2762	printf(" (which must be updated due to update of %s)", p->dep_package);
danw@169	2763	printf(": %s is most recent version\n", p->old_version);
danw@145	2764	errors_only = 1;
danw@145	2765	break;
danw@145	2766
danw@145	2767	case RAZOR_PACKAGE_CONTRADICTION:
danw@147	2768	printf("Error: package %s is marked for both installation and removal\n", p->name);
danw@145	2769	errors_only = 1;
danw@145	2770	break;
danw@145	2771
danw@145	2772	case RAZOR_PACKAGE_OLD_CONFLICT:
danw@145	2773	printf("Error: can't install %s, because installed package %s conflicts with ",
danw@145	2774	p->name, p->dep_package);
danw@145	2775	if (*p->dep_version) {
danw@145	2776	printf("%s %s %s",
danw@145	2777	p->dep_property,
danw@145	2778	razor_version_relations[p->dep_relation],
danw@145	2779	p->dep_version);
danw@145	2780	} else
danw@145	2781	printf("it");
danw@145	2782	printf("\n");
danw@145	2783
danw@145	2784	errors_only = 1;
danw@145	2785	break;
danw@145	2786
danw@145	2787	case RAZOR_PACKAGE_NEW_CONFLICT:
danw@145	2788	printf("Error: can't install %s, because it conflicts with %s",
danw@145	2789	p->name, p->dep_package);
danw@145	2790	if (*p->dep_version) {
danw@145	2791	printf(" %s %s",
danw@145	2792	razor_version_relations[p->dep_relation],
danw@145	2793	p->dep_version);
danw@145	2794	}
danw@145	2795	printf("\n");
danw@145	2796
danw@145	2797	errors_only = 1;
danw@145	2798	break;
danw@145	2799
danw@145	2800	case RAZOR_PACKAGE_UNSATISFIABLE:
danw@145	2801	printf("Error: can't find package for %s", p->dep_property);
danw@145	2802	if (*p->dep_version) {
danw@145	2803	printf(" %s %s",
danw@145	2804	razor_version_relations[p->dep_relation],
danw@145	2805	p->dep_version);
danw@145	2806	}
danw@145	2807	printf(" which is required by %s\n",
danw@145	2808	p->dep_package);
danw@140	2809	errors_only = 1;
danw@140	2810	break;
danw@140	2811
danw@137	2812	default:
danw@137	2813	/* Shouldn't actually happen */
danw@137	2814	break;
danw@137	2815	}
danw@137	2816	}
krh@190	2817
krh@190	2818	return trans->errors;
krh@190	2819	}
krh@190	2820
krh@190	2821	int
krh@190	2822	razor_transaction_unsatisfied_property(struct razor_transaction *trans,
krh@190	2823	const char *name,
krh@190	2824	enum razor_version_relation rel,
krh@190	2825	const char *version)
krh@190	2826	{
krh@190	2827	struct razor_transaction_package p, end;
krh@190	2828
krh@190	2829	end = trans->packages + trans->package_count;
krh@190	2830	for (p = trans->packages; p < end; p++) {
krh@190	2831	if (p->state != RAZOR_PACKAGE_UNSATISFIABLE)
krh@190	2832	continue;
krh@190	2833	if (strcmp(name, p->dep_property) != 0 \|\|
krh@190	2834	rel != p->dep_relation \|\|
krh@190	2835	strcmp(version, p->dep_version) != 0)
krh@190	2836	continue;
krh@190	2837
krh@190	2838	return 1;
krh@190	2839	}
krh@190	2840
krh@190	2841	return 0;
danw@137	2842	}
danw@137	2843
danw@137	2844	struct razor_set *
danw@137	2845	razor_transaction_run(struct razor_transaction *trans)
danw@137	2846	{
danw@137	2847	struct array install_packages, remove_packages;
danw@137	2848	struct razor_merger *merger;
danw@137	2849	struct razor_package pkg, i, iend, r, rend, s, *send;
danw@137	2850	struct source source1, source2;
danw@137	2851	char spool, ipool, *rpool;
danw@137	2852	uint32_t *map;
danw@137	2853	int p, cmp;
danw@137	2854
danw@137	2855	/* FIXME */
danw@137	2856	if (trans->errors)
danw@137	2857	return NULL;
danw@137	2858
danw@137	2859	/* Sort the transaction packages into two arrays */
danw@137	2860	array_init(&install_packages);
danw@137	2861	array_init(&remove_packages);
danw@137	2862	for (p = 0; p < trans->package_count; p++) {
danw@160	2863	if (trans->packages[p].new_package) {
danw@137	2864	pkg = array_add(&install_packages, sizeof *pkg);
danw@147	2865	pkg = trans->packages[p].new_package;
danw@147	2866	} else {
danw@137	2867	pkg = array_add(&remove_packages, sizeof *pkg);
danw@147	2868	pkg = trans->packages[p].old_package;
danw@147	2869	}
danw@137	2870	}
krh@186	2871	map = razor_qsort_with_data(install_packages.data,
krh@186	2872	install_packages.size / sizeof *pkg,
krh@186	2873	sizeof *pkg,
krh@186	2874	compare_packages,
krh@186	2875	trans->upstream);
danw@137	2876	free(map);
krh@186	2877	map = razor_qsort_with_data(remove_packages.data,
krh@186	2878	remove_packages.size / sizeof *pkg,
krh@186	2879	sizeof *pkg,
krh@186	2880	compare_packages,
krh@186	2881	trans->system);
danw@137	2882	free(map);
danw@137	2883
danw@137	2884	merger = razor_merger_create(trans->system, trans->upstream);
danw@137	2885
danw@137	2886	source1 = &merger->source1;
danw@137	2887	source2 = &merger->source2;
danw@137	2888
danw@137	2889	i = install_packages.data;
danw@137	2890	iend = install_packages.data + install_packages.size;
danw@137	2891	ipool = trans->upstream->string_pool.data;
danw@137	2892
danw@137	2893	r = remove_packages.data;
danw@137	2894	rend = remove_packages.data + remove_packages.size;
danw@137	2895	rpool = trans->system->string_pool.data;
danw@137	2896
danw@137	2897	s = trans->system->packages.data;
danw@137	2898	send = trans->system->packages.data + trans->system->packages.size;
danw@137	2899	spool = trans->system->string_pool.data;
danw@137	2900
danw@137	2901	while (s < send \|\| i < iend) {
danw@137	2902	/* Check if s is being removed */
danw@137	2903	if (s < send && r < rend &&
danw@137	2904	s->name == r->name && s->version && r->version) {
danw@137	2905	s++;
danw@137	2906	r++;
danw@137	2907	continue;
danw@137	2908	}
danw@137	2909
danw@137	2910	if (s < send && i < iend)
danw@137	2911	cmp = strcmp(&spool[s->name], &ipool[i->name]);
danw@137	2912	else if (s < send)
danw@137	2913	cmp = -1;
danw@137	2914	else
danw@137	2915	cmp = 1;
danw@137	2916	if (cmp < 0) {
danw@137	2917	add_package(merger, s, source1, 0);
danw@137	2918	s++;
danw@137	2919	} else if (cmp == 0) {
danw@137	2920	add_package(merger, i, source2, UPSTREAM_SOURCE);
danw@137	2921	s++;
danw@137	2922	i++;
danw@137	2923	} else {
danw@137	2924	add_package(merger, i, source2, UPSTREAM_SOURCE);
danw@137	2925	i++;
danw@137	2926	}
danw@137	2927	}
danw@137	2928
danw@137	2929	array_release(&install_packages);
danw@137	2930	array_release(&remove_packages);
danw@137	2931
danw@137	2932	return razor_merger_finish(merger);
danw@137	2933	}
danw@137	2934
danw@137	2935	void
danw@137	2936	razor_transaction_destroy(struct razor_transaction *trans)
danw@137	2937	{
danw@137	2938	int p;
danw@137	2939
danw@137	2940	for (p = 0; p < trans->package_count; p++) {
danw@145	2941	if (!trans->packages[p].dep_package &&
danw@137	2942	(trans->packages[p].state == RAZOR_PACKAGE_INSTALL_UNAVAILABLE \|\|
danw@137	2943	trans->packages[p].state == RAZOR_PACKAGE_REMOVE_NOT_INSTALLED))
danw@137	2944	free((char *)trans->packages[p].name);
danw@137	2945	}
danw@137	2946	free(trans);
danw@137	2947
danw@137	2948	/* FIXME: free upstream if it was created as an empty set */
danw@137	2949	}

author	Kristian H?gsberg <krh@redhat.com>
	Sun Apr 06 19:24:07 2008 -0400 (2008-04-06)
changeset 190	d8b7dd11813d
parent 186	7f45d0401e37
child 191	6e94ebe58141
permissions	-rw-r--r--