razor: razor.c@6ff03223ce4c (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
danw@141	1719
danw@141	1720	struct razor_transaction_resolver {
danw@141	1721	struct razor_set system, upstream;
danw@141	1722	struct bitarray syspkgs, uppkgs;
danw@141	1723	struct array packages;
danw@141	1724	int errors;
danw@141	1725	};
danw@141	1726
danw@144	1727	static int
danw@144	1728	package_in_set(void package, struct razor_set set)
danw@144	1729	{
danw@144	1730	return package >= set->packages.data &&
danw@144	1731	package < set->packages.data + set->packages.size;
danw@144	1732	}
danw@144	1733
danw@144	1734	static int
danw@144	1735	property_in_set(void property, struct razor_set set)
danw@144	1736	{
danw@144	1737	return property >= set->properties.data &&
danw@144	1738	property < set->properties.data + set->properties.size;
danw@144	1739	}
danw@144	1740
danw@168	1741	static struct razor_package *
danw@168	1742	property_provider_package(struct razor_transaction_resolver *trans,
danw@168	1743	struct razor_property *prop,
danw@168	1744	int installed)
danw@168	1745	{
danw@168	1746	struct razor_set *set;
danw@168	1747	struct bitarray *pkgbits;
danw@168	1748	struct razor_package *pkgs;
danw@168	1749	struct list *p;
danw@168	1750
danw@168	1751	if (installed && prop->type != RAZOR_PROPERTY_PROVIDES)
danw@168	1752	return NULL;
danw@168	1753	else if (!installed &&
danw@168	1754	prop->type != RAZOR_PROPERTY_PROVIDES &&
danw@168	1755	prop->type != RAZOR_PROPERTY_OBSOLETES)
danw@168	1756	return NULL;
danw@168	1757
danw@168	1758	if (property_in_set(prop, trans->system)) {
danw@168	1759	set = trans->system;
danw@168	1760	pkgbits = &trans->syspkgs;
danw@168	1761	} else {
danw@168	1762	set = trans->upstream;
danw@168	1763	pkgbits = &trans->uppkgs;
danw@168	1764	}
danw@168	1765	pkgs = set->packages.data;
danw@168	1766
danw@168	1767	for (p = list_first(&prop->packages, &set->package_pool); p; p = list_next(p)) {
danw@168	1768	if (bitarray_get(pkgbits, p->data) != installed)
danw@168	1769	continue;
danw@168	1770	if (prop->type == RAZOR_PROPERTY_OBSOLETES \|\|
danw@168	1771	pkgs[p->data].name == prop->name)
danw@168	1772	return &pkgs[p->data];
danw@168	1773	}
danw@168	1774	return NULL;
danw@168	1775	}
danw@168	1776
danw@144	1777	static int
danw@144	1778	compare_transaction_packages(const void one, const void two)
danw@144	1779	{
danw@160	1780	struct razor_transaction_package *tp1 = (void )one;
danw@160	1781	struct razor_transaction_package *tp2 = (void )two;
danw@160	1782
danw@160	1783	if (!(*tp1)->name)
danw@160	1784	return 1;
danw@160	1785	else if (!(*tp2)->name)
danw@160	1786	return -1;
danw@160	1787	else
danw@160	1788	return strcmp((tp1)->name, (tp2)->name);
danw@144	1789	}
danw@144	1790
danw@168	1791	/* FIXME: merge this into the other property loop in razor_transaction_satisfy */
danw@141	1792	static void
danw@160	1793	resolve_new_packages(struct razor_transaction_resolver *trans,
danw@160	1794	int start, int end)
krh@38	1795	{
danw@168	1796	struct razor_property sp, up, sp_end, up_end;
danw@168	1797	struct razor_package spkg, spkgs, upkg, upkgs;
danw@160	1798	struct razor_transaction_package **packages;
danw@144	1799	const char spool, upool;
danw@144	1800	int i;
danw@144	1801
danw@168	1802	sp_end = trans->system->properties.data + trans->system->properties.size;
danw@168	1803	spool = trans->system->string_pool.data;
danw@144	1804	spkgs = trans->system->packages.data;
danw@168	1805	up_end = trans->upstream->properties.data + trans->upstream->properties.size;
danw@168	1806	upool = trans->upstream->string_pool.data;
danw@144	1807	upkgs = trans->upstream->packages.data;
danw@168	1808
danw@168	1809	/* FIXME, check if sorting the packages directly (rather than
danw@168	1810	* sorting pointers-to-packages) still results in confusing
danw@168	1811	* descriptions.
danw@168	1812	*/
danw@160	1813	packages = calloc(end - start, sizeof *packages);
danw@160	1814	for (i = start; i < end; i++)
danw@160	1815	packages[i - start] = ((struct razor_transaction_package *)trans->packages.data) + i;
danw@160	1816	qsort(packages, end - start, sizeof *packages,
danw@160	1817	compare_transaction_packages);
danw@144	1818
danw@168	1819	sp = trans->system->properties.data;
danw@168	1820	up = trans->upstream->properties.data;
danw@160	1821	for (i = 0; i < end - start; i++) {
danw@169	1822	if (!packages[i]->name \|\|
danw@169	1823	packages[i]->state >= RAZOR_PACKAGE_FIRST_ERROR_STATE)
danw@160	1824	continue;
danw@168	1825
danw@168	1826	spkg = NULL;
danw@168	1827	while (sp < sp_end &&
danw@168	1828	strcmp(&spool[sp->name], packages[i]->name) < 0)
danw@144	1829	sp++;
danw@168	1830	while (sp < sp_end &&
danw@168	1831	strcmp(&spool[sp->name], packages[i]->name) == 0 &&
danw@168	1832	!(spkg = property_provider_package(trans, sp, 1)))
danw@168	1833	sp++;
danw@168	1834
danw@168	1835	upkg = NULL;
danw@168	1836	while (up < up_end &&
danw@168	1837	strcmp(&upool[up->name], packages[i]->name) < 0)
danw@168	1838	up++;
danw@168	1839	while (up < up_end &&
danw@168	1840	strcmp(&upool[up->name], packages[i]->name) == 0 &&
danw@168	1841	!(upkg = property_provider_package(trans, up, 0)))
danw@144	1842	up++;
danw@144	1843
danw@160	1844	if (packages[i]->state == RAZOR_PACKAGE_REMOVE \|\|
danw@160	1845	packages[i]->state == RAZOR_PACKAGE_OBSOLETED) {
danw@168	1846	if (spkg) {
danw@168	1847	packages[i]->old_package = spkg;
danw@168	1848	packages[i]->name = &spool[spkg->name];
danw@168	1849	packages[i]->old_version = &spool[spkg->version];
danw@168	1850	bitarray_set(&trans->syspkgs, spkg - spkgs, 0);
danw@169	1851	}
danw@169	1852	if (!packages[i]->old_package) {
danw@160	1853	packages[i]->name = strdup(packages[i]->name);
danw@169	1854	packages[i]->state \|= RAZOR_PACKAGE_UNAVAILABLE_FLAG;
danw@144	1855	trans->errors++;
danw@144	1856	}
danw@144	1857	} else {
danw@168	1858	if (upkg) {
danw@168	1859	packages[i]->new_package = upkg;
danw@168	1860	packages[i]->name = &upool[upkg->name];
danw@168	1861	packages[i]->new_version = &upool[upkg->version];
danw@168	1862
danw@168	1863	if (up->name != upkg->name) {
danw@168	1864	packages[i]->dep_package = &upool[upkg->name];
danw@168	1865	packages[i]->dep_type = up->type;
danw@168	1866	packages[i]->dep_property = &upool[up->name];
danw@168	1867	packages[i]->dep_relation = up->relation;
danw@168	1868	packages[i]->dep_version = &upool[up->version];
danw@168	1869	}
danw@168	1870
danw@168	1871	if (spkg) {
danw@168	1872	packages[i]->old_package = spkg;
danw@168	1873	packages[i]->old_version = &spool[spkg->version];
danw@168	1874	if (versioncmp(&spool[spkg->version], &upool[up->version]) >= 0) {
danw@160	1875	packages[i]->state = RAZOR_PACKAGE_UP_TO_DATE;
danw@144	1876	trans->errors++;
danw@144	1877	continue;
danw@144	1878	}
danw@168	1879	bitarray_set(&trans->syspkgs, spkg - spkgs, 0);
danw@144	1880	}
danw@168	1881	bitarray_set(&trans->uppkgs, upkg - upkgs, 1);
danw@169	1882	}
danw@169	1883	if (!packages[i]->new_package) {
danw@160	1884	packages[i]->name = strdup(packages[i]->name);
danw@169	1885	packages[i]->state \|= RAZOR_PACKAGE_UNAVAILABLE_FLAG;
danw@144	1886	trans->errors++;
krh@105	1887	}
krh@105	1888	}
krh@38	1889	}
krh@38	1890	}
krh@38	1891
krh@38	1892	static void
danw@141	1893	find_all_packages(struct razor_transaction_resolver *trans)
krh@38	1894	{
danw@137	1895	struct razor_transaction_package *tp;
danw@144	1896	struct razor_package sp, spkgs, send, up, upkgs, uend;
danw@144	1897	const char spool, upool;
danw@144	1898
danw@144	1899	spkgs = trans->system->packages.data;
danw@144	1900	send = trans->system->packages.data + trans->system->packages.size;
danw@144	1901	spool = trans->system->string_pool.data;
danw@144	1902	up = upkgs = trans->upstream->packages.data;
danw@141	1903	uend = trans->upstream->packages.data + trans->upstream->packages.size;
danw@141	1904	upool = trans->upstream->string_pool.data;
krh@38	1905
danw@144	1906	for (sp = spkgs; sp < send; sp++) {
danw@144	1907	while (up < uend && strcmp(&spool[sp->name], &upool[up->name]) > 0)
danw@144	1908	up++;
krh@177	1909	if (strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
krh@177	1910	versioncmp(&spool[sp->version], &upool[up->version]) < 0) {
danw@141	1911	tp = array_add(&trans->packages, sizeof *tp);
danw@137	1912	memset(tp, 0, sizeof *tp);
danw@147	1913	tp->old_package = sp;
danw@147	1914	tp->new_package = up;
danw@144	1915	tp->name = &upool[up->name];
danw@147	1916	tp->old_version = &spool[sp->version];
danw@147	1917	tp->new_version = &upool[up->version];
danw@137	1918	tp->state = RAZOR_PACKAGE_INSTALL;
danw@144	1919	bitarray_set(&trans->uppkgs, up - upkgs, 1);
danw@144	1920	bitarray_set(&trans->syspkgs, sp - spkgs, 0);
krh@38	1921	}
krh@38	1922	}
krh@38	1923	}
krh@38	1924
danw@137	1925	static int
danw@137	1926	provider_satisfies_requirement(struct razor_property *provider,
danw@137	1927	const char *provider_strings,
danw@137	1928	struct razor_property *requirement,
danw@137	1929	const char *requirement_strings)
danw@137	1930	{
danw@137	1931	int cmp, len;
danw@137	1932	const char *provided = &provider_strings[provider->version];
danw@137	1933	const char *required = &requirement_strings[requirement->version];
danw@137	1934
danw@137	1935	if (!*required)
danw@137	1936	return 1;
danw@170	1937	if (!*provided) {
danw@170	1938	if (requirement->relation >= RAZOR_VERSION_EQUAL)
danw@170	1939	return 1;
danw@170	1940	else
danw@170	1941	return 0;
danw@170	1942	}
danw@137	1943
danw@137	1944	cmp = versioncmp(provided, required);
danw@137	1945
danw@137	1946	switch (requirement->relation) {
danw@137	1947	case RAZOR_VERSION_LESS:
danw@137	1948	return cmp < 0;
danw@137	1949
danw@137	1950	case RAZOR_VERSION_LESS_OR_EQUAL:
danw@137	1951	if (cmp <= 0)
danw@137	1952	return 1;
danw@137	1953	/* fall through: FIXME, make sure this is correct */
danw@137	1954
danw@137	1955	case RAZOR_VERSION_EQUAL:
danw@137	1956	if (cmp == 0)
danw@137	1957	return 1;
danw@137	1958
danw@137	1959	/* "foo == 1.1" is satisfied by "foo 1.1-2" */
danw@137	1960	len = strlen(required);
danw@137	1961	if (!strncmp(required, provided, len) && provided[len] == '-')
danw@137	1962	return 1;
danw@137	1963	return 0;
danw@137	1964
danw@137	1965	case RAZOR_VERSION_GREATER_OR_EQUAL:
danw@137	1966	return cmp >= 0;
danw@137	1967
danw@137	1968	case RAZOR_VERSION_GREATER:
danw@137	1969	return cmp > 0;
danw@137	1970	}
danw@137	1971
danw@137	1972	/* shouldn't happen */
danw@137	1973	return 0;
danw@137	1974	}
danw@137	1975
danw@142	1976	static struct razor_package *
danw@144	1977	find_package_for_file(struct razor_set set, struct bitarray pkgbits,
danw@144	1978	const char *filename, int installed)
danw@134	1979	{
danw@142	1980	struct razor_package *pkgs = set->packages.data;
danw@140	1981	struct razor_entry *entry;
danw@140	1982	struct list *p;
danw@134	1983
danw@140	1984	if (filename[0] != '/')
danw@140	1985	return 0;
danw@140	1986
danw@142	1987	entry = find_entry(set, set->files.data, filename);
danw@140	1988	if (!entry)
danw@140	1989	return 0;
danw@140	1990
danw@142	1991	for (p = list_first(&entry->packages, &set->package_pool); p; p = list_next(p)) {
danw@142	1992	if (bitarray_get(pkgbits, p->data) == installed)
danw@142	1993	return &pkgs[p->data];
danw@134	1994	}
danw@142	1995	return NULL;
danw@142	1996	}
danw@142	1997
danw@142	1998	static struct razor_package *
danw@144	1999	find_installed_package_for_file(struct razor_transaction_resolver *trans,
danw@144	2000	const char *filename)
danw@142	2001	{
danw@144	2002	struct razor_package *pkg;
danw@144	2003
danw@144	2004	pkg = find_package_for_file(trans->system, &trans->syspkgs,
danw@144	2005	filename, 1);
danw@144	2006	if (!pkg)
danw@144	2007	pkg = find_package_for_file(trans->upstream, &trans->uppkgs,
danw@144	2008	filename, 1);
danw@144	2009	return pkg;
danw@142	2010	}
danw@142	2011
danw@142	2012	static struct razor_package *
danw@144	2013	find_uninstalled_package_for_file(struct razor_transaction_resolver *trans,
danw@144	2014	const char *filename)
danw@142	2015	{
danw@144	2016	struct razor_package *pkg;
danw@144	2017
danw@144	2018	pkg = find_package_for_file(trans->upstream, &trans->uppkgs,
danw@144	2019	filename, 0);
danw@144	2020	if (!pkg)
danw@144	2021	pkg = find_package_for_file(trans->system, &trans->syspkgs,
danw@144	2022	filename, 0);
danw@144	2023	return pkg;
danw@134	2024	}
danw@134	2025
danw@154	2026	static struct razor_property *
danw@154	2027	skip_to_matching_property(struct razor_transaction_resolver *trans,
danw@154	2028	struct razor_property *match,
danw@154	2029	struct razor_property *prop)
danw@154	2030	{
danw@154	2031	struct razor_set mset, pset;
danw@154	2032	const char ppool, mpool;
danw@154	2033	struct razor_property *prop_end;
danw@154	2034
danw@154	2035	if (property_in_set(match, trans->system))
danw@154	2036	mset = trans->system;
danw@154	2037	else
danw@154	2038	mset = trans->upstream;
danw@154	2039
danw@154	2040	if (property_in_set(prop, trans->system))
danw@154	2041	pset = trans->system;
danw@154	2042	else if (property_in_set(prop, trans->upstream))
danw@154	2043	pset = trans->upstream;
danw@154	2044	else
danw@154	2045	return prop;
danw@154	2046
danw@154	2047	prop_end = pset->properties.data + pset->properties.size;
danw@154	2048	ppool = pset->string_pool.data;
danw@154	2049	mpool = mset->string_pool.data;
danw@154	2050
danw@154	2051	while (prop < prop_end &&
danw@154	2052	strcmp(&ppool[prop->name], &mpool[match->name]) < 0)
danw@154	2053	prop++;
danw@154	2054	return prop;
danw@154	2055	}
danw@154	2056
danw@140	2057	static struct razor_package *
danw@144	2058	find_package_matching(struct razor_transaction_resolver *trans, int installed,
danw@154	2059	struct razor_property *prop,
danw@144	2060	struct razor_property *req,
danw@144	2061	struct razor_set *req_set)
danw@138	2062	{
danw@144	2063	struct razor_set *set;
danw@144	2064	struct bitarray *pkgbits;
danw@144	2065	struct razor_package *pkgs;
danw@154	2066	struct razor_property props, prop_end;
danw@144	2067	enum razor_property_type match_type;
danw@144	2068	const char *pool;
danw@154	2069	const char *rpool;
danw@154	2070	int match_name = (req->type == RAZOR_PROPERTY_OBSOLETES);
danw@144	2071	int match;
danw@144	2072
danw@144	2073	if (property_in_set(prop, trans->system)) {
danw@144	2074	set = trans->system;
danw@144	2075	pkgbits = &trans->syspkgs;
danw@144	2076	} else if (property_in_set(prop, trans->upstream)) {
danw@144	2077	set = trans->upstream;
danw@144	2078	pkgbits = &trans->uppkgs;
danw@144	2079	} else
danw@144	2080	return NULL;
danw@144	2081
danw@154	2082	if (!req_set) {
danw@154	2083	if (property_in_set(req, trans->system))
danw@154	2084	req_set = trans->system;
danw@154	2085	else
danw@154	2086	req_set = trans->upstream;
danw@154	2087	}
danw@154	2088	rpool = req_set->string_pool.data;
danw@154	2089
danw@144	2090	if (req->type == RAZOR_PROPERTY_PROVIDES)
danw@144	2091	match_type = RAZOR_PROPERTY_CONFLICTS;
danw@144	2092	else
danw@144	2093	match_type = RAZOR_PROPERTY_PROVIDES;
danw@144	2094
danw@144	2095	pkgs = set->packages.data;
danw@144	2096	props = set->properties.data;
danw@144	2097	prop_end = set->properties.data + set->properties.size;
danw@144	2098	pool = set->string_pool.data;
danw@144	2099
danw@144	2100	/* Find first matching property */
danw@144	2101	while (prop < prop_end &&
danw@144	2102	strcmp(&pool[prop->name], &rpool[req->name]) < 0)
danw@144	2103	prop++;
danw@144	2104	if (prop == prop_end \|\|
danw@144	2105	strcmp(&pool[prop->name], &rpool[req->name]) > 0)
danw@144	2106	return NULL;
danw@144	2107
danw@144	2108	if (prop->type < match_type) {
danw@144	2109	while (prop < prop_end && prop->type != match_type)
danw@144	2110	prop++;
danw@144	2111	} else {
danw@144	2112	while (prop >= props && prop->type != match_type)
danw@144	2113	prop--;
danw@183	2114	while (prop > props + 1 && (prop - 1)->name == prop->name &&
danw@183	2115	(prop - 1)->type == match_type)
danw@144	2116	prop--;
danw@144	2117	}
danw@144	2118
danw@153	2119	/* Scan matching properties */
danw@144	2120	while (prop < prop_end && prop->type == match_type &&
danw@144	2121	strcmp(&pool[prop->name], &rpool[req->name]) == 0) {
danw@144	2122	if (match_type == RAZOR_PROPERTY_PROVIDES)
danw@144	2123	match = provider_satisfies_requirement(prop, pool, req, rpool);
danw@144	2124	else
danw@144	2125	match = provider_satisfies_requirement(req, rpool, prop, pool);
danw@144	2126	if (match) {
danw@140	2127	struct list *pkg;
danw@140	2128
danw@144	2129	for (pkg = list_first(&prop->packages, &set->package_pool); pkg; pkg = list_next(pkg)) {
danw@144	2130	if (bitarray_get(pkgbits, pkg->data) != installed)
danw@140	2131	continue;
danw@140	2132	if (!match_name \|\|
danw@144	2133	strcmp(&pool[pkgs[pkg->data].name],
danw@144	2134	&rpool[req->name]) == 0)
danw@144	2135	return &pkgs[pkg->data];
danw@140	2136	}
danw@140	2137	}
danw@144	2138	prop++;
danw@140	2139	}
danw@140	2140
danw@140	2141	return NULL;
danw@138	2142	}
danw@138	2143
danw@140	2144	static struct razor_package *
danw@144	2145	find_installed_package_for_property(struct razor_transaction_resolver *trans,
danw@154	2146	struct razor_property *sys_start,
danw@154	2147	struct razor_property *up_start,
danw@144	2148	struct razor_property *req)
danw@138	2149	{
danw@144	2150	struct razor_package *pkg;
danw@144	2151
danw@154	2152	pkg = find_package_matching(trans, 1, sys_start, req, NULL);
danw@144	2153	if (!pkg)
danw@154	2154	pkg = find_package_matching(trans, 1, up_start, req, NULL);
danw@144	2155	return pkg;
danw@144	2156	}
danw@144	2157
danw@144	2158	static struct razor_package *
danw@144	2159	find_uninstalled_package_for_property(struct razor_transaction_resolver *trans,
danw@154	2160	struct razor_property *sys_start,
danw@154	2161	struct razor_property *up_start,
danw@144	2162	struct razor_property *req)
danw@144	2163	{
danw@144	2164	struct razor_package *pkg;
danw@144	2165
danw@154	2166	pkg = find_package_matching(trans, 0, up_start, req, NULL);
danw@144	2167	if (!pkg)
danw@154	2168	pkg = find_package_matching(trans, 0, sys_start, req, NULL);
danw@144	2169	return pkg;
danw@140	2170	}
danw@140	2171
danw@147	2172	static struct razor_transaction_package *
danw@147	2173	find_transaction_package(struct razor_transaction_resolver *trans,
danw@147	2174	const char *name)
danw@147	2175	{
danw@147	2176	struct razor_transaction_package *packages;
danw@147	2177	int count, i;
danw@147	2178
danw@147	2179	packages = trans->packages.data;
danw@147	2180	count = trans->packages.size / sizeof *packages;
danw@147	2181	for (i = 0; i < count; i++) {
danw@147	2182	if (packages[i].name && !strcmp(packages[i].name, name))
danw@147	2183	return &packages[i];
danw@147	2184	}
danw@147	2185	return NULL;
danw@147	2186	}
danw@147	2187
danw@160	2188	/* FIXME? */
danw@160	2189	static int
danw@160	2190	prop_is_being_installed(struct razor_transaction_resolver *trans,
danw@160	2191	struct razor_property *prop)
danw@160	2192	{
danw@160	2193	struct list *pkg;
danw@160	2194
danw@160	2195	for (pkg = list_first(&prop->packages, &trans->upstream->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2196	if (bitarray_get(&trans->uppkgs, pkg->data))
danw@160	2197	return 1;
danw@160	2198	}
danw@160	2199	return 0;
danw@160	2200	}
danw@160	2201
danw@160	2202	static int
danw@160	2203	prop_is_being_removed(struct razor_transaction_resolver *trans,
danw@160	2204	struct razor_property *prop)
danw@160	2205	{
danw@160	2206	struct list *pkg;
danw@160	2207
danw@160	2208	for (pkg = list_first(&prop->packages, &trans->system->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2209	if (bitarray_get(&trans->syspkgs, pkg->data))
danw@160	2210	return 0;
danw@160	2211	}
danw@160	2212	return 1;
danw@160	2213	}
danw@160	2214
danw@160	2215	static int
danw@160	2216	prop_is_being_updated(struct razor_transaction_resolver *trans,
danw@160	2217	struct razor_property *prop)
danw@160	2218	{
danw@160	2219	struct razor_package *packages = trans->system->packages.data;
danw@160	2220	const char *pool = trans->system->string_pool.data;
danw@160	2221	struct razor_transaction_package *tp;
danw@160	2222	struct list *pkg;
danw@160	2223
danw@160	2224	/* Assumes prop_is_being_removed returns true */
danw@160	2225
danw@160	2226	for (pkg = list_first(&prop->packages, &trans->system->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2227	tp = find_transaction_package(trans, &pool[packages[pkg->data].name]);
danw@160	2228	if (tp && tp->state == RAZOR_PACKAGE_REMOVE)
danw@160	2229	return 0;
danw@160	2230	}
danw@160	2231	return 1;
danw@160	2232	}
danw@160	2233
danw@131	2234	static void
danw@141	2235	add_transaction_package(struct razor_transaction_resolver *trans,
danw@147	2236	struct razor_package *new_package,
danw@147	2237	struct razor_package *old_package,
danw@140	2238	enum razor_transaction_package_state state,
danw@144	2239	const char *req_package,
danw@144	2240	struct razor_property *req_prop)
danw@131	2241	{
danw@147	2242	struct razor_set new_package_set, old_package_set, *req_set;
danw@160	2243	struct bitarray *reqpkgbits;
danw@147	2244	struct razor_transaction_package tp, already;
danw@140	2245	const char *pool;
danw@140	2246	struct razor_package *pkgs;
danw@140	2247	struct list *pkg;
danw@147	2248	int contradiction = 0;
danw@147	2249
danw@160	2250	if (package_in_set(new_package, trans->system))
danw@147	2251	new_package_set = trans->system;
danw@160	2252	else
danw@147	2253	new_package_set = trans->upstream;
danw@160	2254	if (package_in_set(old_package, trans->system))
danw@147	2255	old_package_set = trans->system;
danw@160	2256	else
danw@147	2257	old_package_set = trans->upstream;
danw@145	2258	if (property_in_set(req_prop, trans->system)) {
danw@145	2259	req_set = trans->system;
danw@145	2260	reqpkgbits = &trans->syspkgs;
danw@145	2261	} else {
danw@145	2262	req_set = trans->upstream;
danw@145	2263	reqpkgbits = &trans->uppkgs;
danw@145	2264	}
danw@144	2265
danw@147	2266	if (new_package) {
danw@147	2267	pool = new_package_set->string_pool.data;
danw@147	2268	already = find_transaction_package(trans, &pool[new_package->name]);
danw@147	2269	if (already) {
danw@147	2270	if (already->new_package == new_package) {
danw@147	2271	/* Already taken care of */
danw@147	2272	return;
danw@166	2273	} else if (new_package_set == trans->upstream &&
danw@166	2274	already->state == RAZOR_PACKAGE_FORCED_UPDATE) {
danw@166	2275	already->new_package = new_package;
danw@166	2276	return;
danw@147	2277	}
danw@166	2278
danw@147	2279	/* Oops. We lose */
danw@147	2280	if (state != RAZOR_PACKAGE_CONTRADICTION)
danw@147	2281	contradiction = 1;
danw@147	2282	}
danw@147	2283	} else if (old_package) {
danw@147	2284	pool = old_package_set->string_pool.data;
danw@147	2285	already = find_transaction_package(trans, &pool[old_package->name]);
danw@147	2286	if (already) {
danw@147	2287	if (already->old_package == old_package) {
danw@147	2288	/* Already taken care of */
danw@147	2289	return;
danw@166	2290	} else if (old_package_set == trans->system) {
danw@166	2291	already->old_package = old_package;
danw@166	2292	return;
danw@147	2293	}
danw@166	2294
danw@147	2295	/* Oops. We lose */
danw@147	2296	if (state != RAZOR_PACKAGE_CONTRADICTION)
danw@147	2297	contradiction = 1;
danw@147	2298	}
danw@147	2299	} else
danw@147	2300	state = RAZOR_PACKAGE_UNSATISFIABLE;
danw@147	2301
danw@141	2302	tp = array_add(&trans->packages, sizeof *tp);
danw@140	2303	memset(tp, 0, sizeof *tp);
danw@131	2304
danw@147	2305	if (new_package) {
danw@147	2306	pool = new_package_set->string_pool.data;
danw@147	2307	tp->new_package = new_package;
danw@147	2308	tp->name = &pool[new_package->name];
danw@147	2309	tp->new_version = &pool[new_package->version];
danw@147	2310
danw@147	2311	pkgs = new_package_set->packages.data;
danw@147	2312	}
danw@147	2313	if (old_package) {
danw@147	2314	pool = old_package_set->string_pool.data;
danw@147	2315	tp->old_package = old_package;
danw@147	2316	tp->name = &pool[old_package->name];
danw@147	2317	tp->old_version = &pool[old_package->version];
danw@147	2318
danw@147	2319	pkgs = old_package_set->packages.data;
danw@147	2320	}
danw@147	2321
danw@147	2322	tp->state = state;
danw@147	2323	if (state != RAZOR_PACKAGE_INSTALL &&
danw@154	2324	state != RAZOR_PACKAGE_FORCED_UPDATE &&
danw@154	2325	state != RAZOR_PACKAGE_REMOVE &&
danw@154	2326	state != RAZOR_PACKAGE_OBSOLETED)
danw@145	2327	trans->errors++;
danw@147	2328
danw@147	2329	if (contradiction) {
danw@147	2330	/* Do this now, after adding tp, so that it ends up
danw@147	2331	* after both the INSTALL and the REMOVE in the array.
danw@147	2332	*/
danw@147	2333	add_transaction_package(trans, new_package, old_package,
danw@147	2334	RAZOR_PACKAGE_CONTRADICTION,
danw@147	2335	NULL, NULL);
danw@145	2336	}
danw@140	2337
danw@144	2338	if (req_package)
danw@145	2339	tp->dep_package = req_package;
danw@145	2340	if (!req_prop)
danw@145	2341	return;
danw@145	2342
danw@145	2343	pool = req_set->string_pool.data;
danw@145	2344	pkgs = req_set->packages.data;
danw@145	2345	if (!req_package) {
danw@145	2346	for (pkg = list_first(&req_prop->packages, &req_set->package_pool); pkg; pkg = list_next(pkg)) {
danw@145	2347	if (bitarray_get(reqpkgbits, pkg->data))
danw@144	2348	break;
danw@144	2349	}
danw@145	2350	if (pkg)
danw@145	2351	tp->dep_package = &pool[pkgs[pkg->data].name];
danw@131	2352	}
danw@144	2353
danw@145	2354	tp->dep_type = req_prop->type;
danw@145	2355	tp->dep_property = &pool[req_prop->name];
danw@145	2356	tp->dep_relation = req_prop->relation;
danw@145	2357	tp->dep_version = &pool[req_prop->version];
danw@140	2358	}
danw@140	2359
danw@160	2360	static void
danw@160	2361	razor_transaction_satisfy(struct razor_transaction_resolver *trans)
danw@147	2362	{
danw@160	2363	struct razor_package spkgs, upkgs, *pkg;
danw@144	2364	struct razor_property sp, sprops, *sprop_end;
danw@144	2365	struct razor_property up, uprops, *uprop_end;
danw@160	2366	struct razor_property sr, ur, *first_up;
danw@160	2367	const char spool, upool, *removed_package;
danw@160	2368	struct list *reqpkg;
danw@134	2369
danw@140	2370	spkgs = trans->system->packages.data;
danw@140	2371	sprops = trans->system->properties.data;
danw@144	2372	sprop_end = trans->system->properties.data + trans->system->properties.size;
danw@145	2373	spool = trans->system->string_pool.data;
danw@140	2374	upkgs = trans->upstream->packages.data;
danw@140	2375	uprops = trans->upstream->properties.data;
danw@144	2376	uprop_end = trans->upstream->properties.data + trans->upstream->properties.size;
danw@140	2377	upool = trans->upstream->string_pool.data;
krh@33	2378
danw@144	2379	sp = sprops;
danw@160	2380	for (up = uprops; up < uprop_end; up++) {
danw@140	2381	/* Skip 'up' ahead to a property of a package which is
danw@140	2382	* to-be-installed.
danw@140	2383	*/
danw@144	2384	while (up < uprop_end &&
danw@144	2385	!prop_is_being_installed(trans, up))
danw@140	2386	up++;
danw@144	2387	if (up == uprop_end)
danw@140	2388	break;
danw@154	2389	sp = skip_to_matching_property(trans, up, sp);
krh@33	2390
danw@144	2391	switch (up->type) {
danw@140	2392	case RAZOR_PROPERTY_REQUIRES:
danw@144	2393	if (!strncmp(&upool[up->name], "rpmlib(", 7))
danw@140	2394	break;
danw@131	2395
danw@154	2396	if (find_installed_package_for_property(trans, sp, up, up) \|\|
danw@144	2397	find_installed_package_for_file(trans, &upool[up->name])) {
danw@140	2398	/* Requires something that is either installed
danw@140	2399	* or to-be-installed.
danw@140	2400	*/
danw@140	2401	break;
danw@137	2402	}
danw@137	2403
danw@140	2404	/* See if we can install a new upstream provider */
danw@154	2405	pkg = find_uninstalled_package_for_property(trans, sp, up, up);
danw@154	2406	if (!pkg)
danw@144	2407	pkg = find_uninstalled_package_for_file(trans, &upool[up->name]);
danw@160	2408	add_transaction_package(trans, pkg, NULL,
danw@144	2409	RAZOR_PACKAGE_INSTALL,
danw@144	2410	NULL, up);
danw@144	2411	break;
danw@144	2412
danw@144	2413	case RAZOR_PROPERTY_PROVIDES:
danw@144	2414	/* find_installed_package_for_property works backwards
danw@144	2415	* here, finding a conflicting installed package.
danw@144	2416	*/
danw@154	2417	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@140	2418	if (!pkg)
danw@144	2419	break;
danw@144	2420
danw@145	2421	if (package_in_set(pkg, trans->system)) {
danw@145	2422	/* pkg CONFLICTS with what 'up' PROVIDES. Try
danw@145	2423	* finding an upgrade
danw@145	2424	*/
danw@160	2425	add_transaction_package(trans, NULL, pkg,
danw@160	2426	RAZOR_PACKAGE_FORCED_UPDATE,
danw@165	2427	&upool[up->name], sp);
danw@160	2428	} else {
danw@160	2429	add_transaction_package(trans, NULL, pkg,
danw@160	2430	RAZOR_PACKAGE_CONTRADICTION,
danw@160	2431	NULL, up);
danw@144	2432	}
danw@140	2433	break;
danw@140	2434
danw@140	2435	case RAZOR_PROPERTY_CONFLICTS:
danw@154	2436	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@144	2437	if (!pkg)
danw@144	2438	break;
danw@144	2439
danw@144	2440	if (package_in_set(pkg, trans->system)) {
danw@140	2441	/* Conflicts with something already installed.
danw@140	2442	* Try to upgrade out.
danw@140	2443	*/
danw@160	2444	add_transaction_package(trans, NULL, pkg,
danw@160	2445	RAZOR_PACKAGE_FORCED_UPDATE,
danw@160	2446	NULL, up);
danw@160	2447	} else {
danw@160	2448	add_transaction_package(trans, pkg, NULL,
danw@160	2449	RAZOR_PACKAGE_CONTRADICTION,
danw@160	2450	NULL, up);
danw@140	2451	}
danw@140	2452	break;
danw@140	2453
danw@140	2454	case RAZOR_PROPERTY_OBSOLETES:
danw@154	2455	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@145	2456	if (pkg) {
danw@145	2457	/* If pkg is to-be-installed, this
danw@145	2458	* will add a CONTRADICTION error as well.
danw@145	2459	*/
danw@147	2460	add_transaction_package(trans, NULL, pkg,
danw@154	2461	RAZOR_PACKAGE_OBSOLETED,
danw@144	2462	NULL, up);
danw@140	2463	}
danw@140	2464	break;
danw@140	2465
danw@140	2466	default:
danw@140	2467	/* can't happen */
danw@140	2468	break;
danw@131	2469	}
krh@37	2470	}
danw@154	2471
danw@154	2472	up = uprops;
danw@154	2473	for (sp = sprops; sp < sprop_end; sp++) {
danw@154	2474	/* Skip 'sp' ahead to a PROVIDES of a package which is
danw@154	2475	* to-be-removed.
danw@154	2476	*/
danw@154	2477	while (sp < sprop_end &&
danw@154	2478	(sp->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@154	2479	!prop_is_being_removed(trans, sp)))
danw@154	2480	sp++;
danw@154	2481	if (sp == sprop_end)
danw@154	2482	break;
danw@154	2483
danw@154	2484	removed_package = &spool[spkgs[list_first(&sp->packages, &trans->system->package_pool)->data].name];
danw@154	2485
danw@154	2486	/* Skip 'up' to match */
danw@154	2487	up = skip_to_matching_property(trans, sp, up);
danw@154	2488	ur = first_up = up;
danw@154	2489
danw@154	2490	/* If the package is just being upgraded, we may
danw@154	2491	* already be installing an identical PROVIDES, so
danw@154	2492	* check for that.
danw@154	2493	*/
danw@154	2494	while (up < uprop_end &&
danw@154	2495	strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
danw@154	2496	(up->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@154	2497	sp->relation != up->relation \|\|
danw@154	2498	strcmp(&spool[sp->name], &upool[up->name]) != 0))
danw@154	2499	up++;
danw@154	2500	if (up < uprop_end &&
danw@154	2501	up->type == RAZOR_PROPERTY_PROVIDES &&
danw@154	2502	strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
danw@154	2503	sp->relation == up->relation &&
danw@154	2504	strcmp(&spool[sp->version], &upool[up->version]) == 0 &&
danw@154	2505	prop_is_being_installed(trans, up)) {
danw@154	2506	up = first_up;
danw@154	2507	continue;
danw@154	2508	}
danw@154	2509	up = first_up;
danw@154	2510
danw@154	2511	/* For all still-installed packages that require
danw@154	2512	* sp->name, see if they are satisfied by any other
danw@154	2513	* still-installed or to-be-installed property. If
danw@154	2514	* not, either remove or attempt to update the
danw@154	2515	* package, depending on why the required property has
danw@154	2516	* disappeared
danw@154	2517	*/
danw@154	2518	sr = sp;
danw@154	2519	while (sr > sprops + 1 && (sr - 1)->name == sr->name)
danw@154	2520	sr--;
danw@154	2521	for (; sr->type == RAZOR_PROPERTY_REQUIRES; sr++) {
danw@154	2522	if (prop_is_being_removed(trans, sr))
danw@154	2523	continue;
danw@154	2524	if (find_installed_package_for_property(trans, sp, up, sr))
danw@154	2525	continue;
danw@154	2526
danw@154	2527	for (reqpkg = list_first(&sr->packages, &trans->system->package_pool); reqpkg; reqpkg = list_next(reqpkg)) {
danw@154	2528	if (!bitarray_get(&trans->syspkgs, reqpkg->data))
danw@154	2529	continue;
danw@154	2530	pkg = &spkgs[reqpkg->data];
danw@154	2531	if (prop_is_being_updated(trans, sp)) {
danw@160	2532	add_transaction_package(trans, NULL, pkg,
danw@160	2533	RAZOR_PACKAGE_FORCED_UPDATE,
danw@160	2534	removed_package, NULL);
danw@154	2535	} else {
danw@154	2536	add_transaction_package(trans, NULL, pkg,
danw@154	2537	RAZOR_PACKAGE_REMOVE,
danw@154	2538	removed_package, sr);
danw@154	2539	}
danw@154	2540	}
danw@154	2541	}
danw@154	2542	}
danw@154	2543	}
danw@129	2544
danw@137	2545	struct razor_transaction *
danw@137	2546	razor_transaction_create(struct razor_set system, struct razor_set upstream,
danw@137	2547	int update_count, const char **update_packages,
danw@137	2548	int remove_count, const char **remove_packages)
danw@137	2549	{
danw@141	2550	struct razor_transaction_resolver trans;
danw@141	2551	struct razor_transaction *ret_trans;
danw@160	2552	struct razor_transaction_package *tp;
danw@160	2553	int start, end, i;
danw@137	2554
danw@141	2555	trans.system = system;
danw@141	2556	trans.upstream = upstream ? upstream : razor_set_create();
danw@141	2557	array_init(&trans.packages);
danw@141	2558	bitarray_init(&trans.syspkgs, trans.system->packages.size / sizeof (struct razor_package), 1);
danw@141	2559	bitarray_init(&trans.uppkgs, trans.upstream->packages.size / sizeof (struct razor_package), 0);
danw@141	2560	trans.errors = 0;
danw@137	2561
danw@144	2562	if (update_count > 0 \|\| remove_count > 0) {
danw@160	2563	for (i = 0; i < update_count; i++) {
danw@160	2564	tp = array_add(&trans.packages, sizeof *tp);
danw@160	2565	memset(tp, 0, sizeof *tp);
danw@160	2566	tp->name = update_packages[i];
danw@160	2567	tp->state = RAZOR_PACKAGE_INSTALL;
danw@160	2568	}
danw@160	2569	for (i = 0; i < remove_count; i++) {
danw@160	2570	tp = array_add(&trans.packages, sizeof *tp);
danw@160	2571	memset(tp, 0, sizeof *tp);
danw@160	2572	tp->name = remove_packages[i];
danw@160	2573	tp->state = RAZOR_PACKAGE_REMOVE;
danw@160	2574	}
danw@144	2575	} else
danw@141	2576	find_all_packages(&trans);
danw@137	2577
danw@137	2578	start = 0;
danw@141	2579	end = trans.packages.size / sizeof (struct razor_transaction_package);
danw@137	2580
danw@160	2581	while (start != end) {
danw@160	2582	resolve_new_packages(&trans, start, end);
danw@160	2583	if (trans.errors)
danw@160	2584	break;
danw@160	2585
danw@160	2586	razor_transaction_satisfy(&trans);
danw@137	2587
danw@137	2588	start = end;
danw@141	2589	end = trans.packages.size / sizeof (struct razor_transaction_package);
danw@137	2590	}
danw@137	2591
danw@141	2592	ret_trans = zalloc(sizeof *ret_trans);
danw@141	2593	ret_trans->system = trans.system;
danw@141	2594	ret_trans->upstream = trans.upstream;
danw@141	2595	ret_trans->packages = trans.packages.data;
danw@141	2596	ret_trans->package_count = end;
danw@141	2597	ret_trans->errors = trans.errors;
danw@141	2598	return ret_trans;
danw@137	2599	}
danw@137	2600
danw@137	2601	const char * const razor_version_relations[] = {
danw@137	2602	/* same order as enum razor_version_relation */
danw@137	2603	"<", "<=", "=", ">=", ">"
danw@137	2604	};
danw@137	2605
danw@140	2606	const char * const razor_property_types[] = {
danw@140	2607	/* same order as enum razor_property_type */
danw@140	2608	"requires", "provides", "conflicts with", "obsoletes"
danw@140	2609	};
danw@140	2610
danw@169	2611	static void
danw@169	2612	print_requirement(struct razor_transaction_package *p)
danw@169	2613	{
danw@169	2614	if (p->dep_type == RAZOR_PROPERTY_CONFLICTS &&
danw@169	2615	!strcmp(p->dep_package, p->name)) {
danw@169	2616	printf(" because %s %s conflicts with %s",
danw@169	2617	p->name, p->old_version, p->dep_property);
danw@169	2618	if (*p->dep_version) {
danw@169	2619	printf(" %s %s",
danw@169	2620	razor_version_relations[p->dep_relation],
danw@169	2621	p->dep_version);
danw@169	2622	}
danw@169	2623	} else {
danw@169	2624	if (strcmp(p->name, p->dep_package) != 0)
danw@169	2625	printf(" for %s", p->dep_package);
danw@169	2626	if (*p->dep_version) {
danw@169	2627	printf(", which %s %s %s %s",
danw@169	2628	razor_property_types[p->dep_type],
danw@169	2629	p->dep_property,
danw@169	2630	razor_version_relations[p->dep_relation],
danw@169	2631	p->dep_version);
danw@169	2632	} else if (strcmp(p->dep_property, p->name) != 0) {
danw@169	2633	printf(", which %s %s",
danw@169	2634	razor_property_types[p->dep_type],
danw@169	2635	p->dep_property);
danw@169	2636	}
danw@169	2637	}
danw@169	2638	}
danw@169	2639
danw@137	2640	void
danw@137	2641	razor_transaction_describe(struct razor_transaction *trans)
danw@137	2642	{
danw@137	2643	struct razor_transaction_package p, pend, *tps;
danw@137	2644	int errors_only = 0;
danw@137	2645
danw@137	2646	tps = trans->packages;
danw@137	2647	pend = trans->packages + trans->package_count;
danw@137	2648	for (p = trans->packages; p < pend; p++) {
danw@137	2649	switch (p->state) {
danw@137	2650	case RAZOR_PACKAGE_INSTALL:
danw@137	2651	if (errors_only)
danw@137	2652	break;
danw@137	2653
danw@147	2654	printf("Installing %s %s", p->name, p->new_version);
danw@169	2655	if (p->dep_package)
danw@169	2656	print_requirement(p);
danw@137	2657	printf("\n");
danw@137	2658	break;
danw@137	2659
danw@154	2660	case RAZOR_PACKAGE_FORCED_UPDATE:
danw@154	2661	if (errors_only)
danw@154	2662	break;
danw@154	2663
danw@154	2664	printf("Updating %s to %s due to update of %s\n",
danw@154	2665	p->name, p->new_version, p->dep_package);
danw@154	2666	break;
danw@154	2667
danw@137	2668	case RAZOR_PACKAGE_REMOVE:
danw@137	2669	if (errors_only)
danw@137	2670	break;
danw@147	2671	printf("Removing %s %s", p->name, p->old_version);
danw@145	2672	if (p->dep_package) {
danw@154	2673	printf(" which required %s",
danw@154	2674	p->dep_package);
danw@162	2675	if (strcmp(p->dep_property, p->dep_package) != 0)
danw@154	2676	printf(" for %s", p->dep_property);
danw@154	2677	}
danw@154	2678	printf("\n");
danw@154	2679	break;
danw@154	2680
danw@154	2681	case RAZOR_PACKAGE_OBSOLETED:
danw@154	2682	if (errors_only)
danw@154	2683	break;
danw@154	2684	printf("Removing %s %s", p->name, p->old_version);
danw@154	2685	if (p->dep_package) {
danw@154	2686	printf(" which is obsoleted by %s",
danw@154	2687	p->dep_package);
danw@137	2688	}
danw@137	2689	printf("\n");
danw@137	2690	break;
danw@137	2691
danw@145	2692	case RAZOR_PACKAGE_INSTALL_UNAVAILABLE:
danw@169	2693	printf("Error: can't find %s", p->name);
danw@169	2694	if (p->dep_package) {
danw@169	2695	printf(" (which is required");
danw@169	2696	print_requirement(p);
danw@169	2697	printf(")");
danw@169	2698	}
danw@169	2699	printf("\n");
danw@169	2700	errors_only = 1;
danw@169	2701	break;
danw@169	2702
danw@169	2703	case RAZOR_PACKAGE_UPDATE_UNAVAILABLE:
danw@169	2704	printf("Error: can't find an updated version of %s (which must be updated due to update of %s)\n",
danw@169	2705	p->name, p->dep_package);
danw@137	2706	errors_only = 1;
danw@137	2707	break;
danw@137	2708
danw@145	2709	case RAZOR_PACKAGE_REMOVE_NOT_INSTALLED:
danw@145	2710	printf("Error: can't remove %s: not installed\n", p->name);
danw@137	2711	errors_only = 1;
danw@137	2712	break;
danw@137	2713
danw@145	2714	case RAZOR_PACKAGE_UP_TO_DATE:
danw@169	2715	printf("Error: can't update %s", p->name);
danw@169	2716	if (p->dep_package)
danw@169	2717	printf(" (which must be updated due to update of %s)", p->dep_package);
danw@169	2718	printf(": %s is most recent version\n", p->old_version);
danw@145	2719	errors_only = 1;
danw@145	2720	break;
danw@145	2721
danw@145	2722	case RAZOR_PACKAGE_CONTRADICTION:
danw@147	2723	printf("Error: package %s is marked for both installation and removal\n", p->name);
danw@145	2724	errors_only = 1;
danw@145	2725	break;
danw@145	2726
danw@145	2727	case RAZOR_PACKAGE_OLD_CONFLICT:
danw@145	2728	printf("Error: can't install %s, because installed package %s conflicts with ",
danw@145	2729	p->name, p->dep_package);
danw@145	2730	if (*p->dep_version) {
danw@145	2731	printf("%s %s %s",
danw@145	2732	p->dep_property,
danw@145	2733	razor_version_relations[p->dep_relation],
danw@145	2734	p->dep_version);
danw@145	2735	} else
danw@145	2736	printf("it");
danw@145	2737	printf("\n");
danw@145	2738
danw@145	2739	errors_only = 1;
danw@145	2740	break;
danw@145	2741
danw@145	2742	case RAZOR_PACKAGE_NEW_CONFLICT:
danw@145	2743	printf("Error: can't install %s, because it conflicts with %s",
danw@145	2744	p->name, p->dep_package);
danw@145	2745	if (*p->dep_version) {
danw@145	2746	printf(" %s %s",
danw@145	2747	razor_version_relations[p->dep_relation],
danw@145	2748	p->dep_version);
danw@145	2749	}
danw@145	2750	printf("\n");
danw@145	2751
danw@145	2752	errors_only = 1;
danw@145	2753	break;
danw@145	2754
danw@145	2755	case RAZOR_PACKAGE_UNSATISFIABLE:
danw@145	2756	printf("Error: can't find package for %s", p->dep_property);
danw@145	2757	if (*p->dep_version) {
danw@145	2758	printf(" %s %s",
danw@145	2759	razor_version_relations[p->dep_relation],
danw@145	2760	p->dep_version);
danw@145	2761	}
danw@145	2762	printf(" which is required by %s\n",
danw@145	2763	p->dep_package);
danw@140	2764	errors_only = 1;
danw@140	2765	break;
danw@140	2766
danw@137	2767	default:
danw@137	2768	/* Shouldn't actually happen */
danw@137	2769	break;
danw@137	2770	}
danw@137	2771	}
danw@137	2772	}
danw@137	2773
danw@137	2774	struct razor_set *
danw@137	2775	razor_transaction_run(struct razor_transaction *trans)
danw@137	2776	{
danw@137	2777	struct array install_packages, remove_packages;
danw@137	2778	struct razor_merger *merger;
danw@137	2779	struct razor_package pkg, i, iend, r, rend, s, *send;
danw@137	2780	struct source source1, source2;
danw@137	2781	char spool, ipool, *rpool;
danw@137	2782	uint32_t *map;
danw@137	2783	int p, cmp;
danw@137	2784
danw@137	2785	/* FIXME */
danw@137	2786	if (trans->errors)
danw@137	2787	return NULL;
danw@137	2788
danw@137	2789	/* Sort the transaction packages into two arrays */
danw@137	2790	array_init(&install_packages);
danw@137	2791	array_init(&remove_packages);
danw@137	2792	for (p = 0; p < trans->package_count; p++) {
danw@160	2793	if (trans->packages[p].new_package) {
danw@137	2794	pkg = array_add(&install_packages, sizeof *pkg);
danw@147	2795	pkg = trans->packages[p].new_package;
danw@147	2796	} else {
danw@137	2797	pkg = array_add(&remove_packages, sizeof *pkg);
danw@147	2798	pkg = trans->packages[p].old_package;
danw@147	2799	}
danw@137	2800	}
krh@186	2801	map = razor_qsort_with_data(install_packages.data,
krh@186	2802	install_packages.size / sizeof *pkg,
krh@186	2803	sizeof *pkg,
krh@186	2804	compare_packages,
krh@186	2805	trans->upstream);
danw@137	2806	free(map);
krh@186	2807	map = razor_qsort_with_data(remove_packages.data,
krh@186	2808	remove_packages.size / sizeof *pkg,
krh@186	2809	sizeof *pkg,
krh@186	2810	compare_packages,
krh@186	2811	trans->system);
danw@137	2812	free(map);
danw@137	2813
danw@137	2814	merger = razor_merger_create(trans->system, trans->upstream);
danw@137	2815
danw@137	2816	source1 = &merger->source1;
danw@137	2817	source2 = &merger->source2;
danw@137	2818
danw@137	2819	i = install_packages.data;
danw@137	2820	iend = install_packages.data + install_packages.size;
danw@137	2821	ipool = trans->upstream->string_pool.data;
danw@137	2822
danw@137	2823	r = remove_packages.data;
danw@137	2824	rend = remove_packages.data + remove_packages.size;
danw@137	2825	rpool = trans->system->string_pool.data;
danw@137	2826
danw@137	2827	s = trans->system->packages.data;
danw@137	2828	send = trans->system->packages.data + trans->system->packages.size;
danw@137	2829	spool = trans->system->string_pool.data;
danw@137	2830
danw@137	2831	while (s < send \|\| i < iend) {
danw@137	2832	/* Check if s is being removed */
danw@137	2833	if (s < send && r < rend &&
danw@137	2834	s->name == r->name && s->version && r->version) {
danw@137	2835	s++;
danw@137	2836	r++;
danw@137	2837	continue;
danw@137	2838	}
danw@137	2839
danw@137	2840	if (s < send && i < iend)
danw@137	2841	cmp = strcmp(&spool[s->name], &ipool[i->name]);
danw@137	2842	else if (s < send)
danw@137	2843	cmp = -1;
danw@137	2844	else
danw@137	2845	cmp = 1;
danw@137	2846	if (cmp < 0) {
danw@137	2847	add_package(merger, s, source1, 0);
danw@137	2848	s++;
danw@137	2849	} else if (cmp == 0) {
danw@137	2850	add_package(merger, i, source2, UPSTREAM_SOURCE);
danw@137	2851	s++;
danw@137	2852	i++;
danw@137	2853	} else {
danw@137	2854	add_package(merger, i, source2, UPSTREAM_SOURCE);
danw@137	2855	i++;
danw@137	2856	}
danw@137	2857	}
danw@137	2858
danw@137	2859	array_release(&install_packages);
danw@137	2860	array_release(&remove_packages);
danw@137	2861
danw@137	2862	return razor_merger_finish(merger);
danw@137	2863	}
danw@137	2864
danw@137	2865	void
danw@137	2866	razor_transaction_destroy(struct razor_transaction *trans)
danw@137	2867	{
danw@137	2868	int p;
danw@137	2869
danw@137	2870	for (p = 0; p < trans->package_count; p++) {
danw@145	2871	if (!trans->packages[p].dep_package &&
danw@137	2872	(trans->packages[p].state == RAZOR_PACKAGE_INSTALL_UNAVAILABLE \|\|
danw@137	2873	trans->packages[p].state == RAZOR_PACKAGE_REMOVE_NOT_INSTALLED))
danw@137	2874	free((char *)trans->packages[p].name);
danw@137	2875	}
danw@137	2876	free(trans);
danw@137	2877
danw@137	2878	/* FIXME: free upstream if it was created as an empty set */
danw@137	2879	}

author	Kristian H?gsberg <krh@redhat.com>
	Sat Apr 05 23:55:00 2008 -0400 (2008-04-05)
changeset 187	6ff03223ce4c
parent 183	8f4402ee125d
child 190	d8b7dd11813d
permissions	-rw-r--r--