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

author	Kristian H?gsberg <krh@redhat.com>
	Mon Apr 07 12:29:13 2008 -0400 (2008-04-07)
changeset 204	60badcb3d8ea
parent 196	b38fc517ea04
child 208	7b460017c221
permissions	-rw-r--r--