razor: razor.c@b97c130460a5 (annotated)

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

author	Kristian H?gsberg <krh@redhat.com>
	Wed Jun 04 13:27:49 2008 -0400 (2008-06-04)
changeset 216	b97c130460a5
parent 212	e8f493d8ff9a
child 220	1fcb5c23034a
permissions	-rw-r--r--