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

author	Kristian H?gsberg <krh@redhat.com>
	Mon Apr 07 00:02:01 2008 -0400 (2008-04-07)
changeset 195	7a53d1711083
parent 192	55b177b689c0
child 196	b38fc517ea04
permissions	-rw-r--r--