razor: razor.c@e8f493d8ff9a (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@92	813	};
krh@92	814
danw@137	815	static struct razor_package_iterator *
krh@101	816	razor_package_iterator_create_with_index(struct razor_set *set,
danw@117	817	struct list *index)
krh@3	818	{
krh@92	819	struct razor_package_iterator *pi;
krh@92	820
krh@92	821	pi = zalloc(sizeof *pi);
krh@92	822	pi->set = set;
krh@101	823	pi->index = index;
krh@92	824
krh@92	825	return pi;
krh@92	826	}
krh@92	827
krh@101	828	struct razor_package_iterator *
krh@101	829	razor_package_iterator_create(struct razor_set *set)
krh@101	830	{
danw@116	831	struct razor_package_iterator *pi;
danw@116	832
danw@116	833	pi = zalloc(sizeof *pi);
danw@116	834	pi->set = set;
danw@116	835	pi->end = set->packages.data + set->packages.size;
danw@116	836	pi->package = set->packages.data;
danw@116	837
danw@116	838	return pi;
krh@101	839	}
krh@101	840
krh@101	841	struct razor_package_iterator *
krh@101	842	razor_package_iterator_create_for_property(struct razor_set *set,
krh@101	843	struct razor_property *property)
krh@101	844	{
danw@117	845	struct list *index;
krh@101	846
danw@116	847	index = list_first(&property->packages, &set->package_pool);
krh@101	848	return razor_package_iterator_create_with_index(set, index);
krh@101	849	}
krh@101	850
krh@92	851	int
krh@92	852	razor_package_iterator_next(struct razor_package_iterator *pi,
krh@92	853	struct razor_package **package,
krh@192	854	const char **name,
krh@192	855	const char **version,
krh@192	856	const char **arch)
krh@92	857	{
krh@6	858	char *pool;
krh@101	859	int valid;
krh@101	860	struct razor_package p, packages;
krh@3	861
danw@116	862	if (pi->package) {
krh@101	863	p = pi->package++;
krh@101	864	valid = p < pi->end;
danw@116	865	} else if (pi->index) {
danw@116	866	packages = pi->set->packages.data;
danw@117	867	p = &packages[pi->index->data];
danw@116	868	pi->index = list_next(pi->index);
danw@116	869	valid = 1;
danw@116	870	} else
danw@116	871	valid = 0;
krh@92	872
krh@101	873	if (valid) {
krh@101	874	pool = pi->set->string_pool.data;
krh@101	875	*package = p;
danw@120	876	*name = &pool[p->name];
krh@101	877	*version = &pool[p->version];
krh@192	878	*arch = &pool[p->arch];
krh@101	879	} else {
krh@101	880	*package = NULL;
krh@101	881	}
krh@101	882
krh@101	883	return valid;
krh@92	884	}
krh@92	885
krh@92	886	void
krh@92	887	razor_package_iterator_destroy(struct razor_package_iterator *pi)
krh@92	888	{
krh@92	889	free(pi);
krh@3	890	}
krh@3	891
krh@10	892	struct razor_package *
krh@10	893	razor_set_get_package(struct razor_set set, const char package)
krh@10	894	{
krh@97	895	struct razor_package_iterator *pi;
krh@97	896	struct razor_package *p;
krh@192	897	const char name, version, *arch;
krh@97	898
krh@97	899	pi = razor_package_iterator_create(set);
krh@192	900	while (razor_package_iterator_next(pi, &p, &name, &version, &arch)) {
krh@97	901	if (strcmp(package, name) == 0)
krh@97	902	break;
krh@97	903	}
krh@97	904	razor_package_iterator_destroy(pi);
krh@97	905
krh@97	906	return p;
krh@10	907	}
krh@10	908
krh@92	909	struct razor_property_iterator {
krh@92	910	struct razor_set *set;
krh@92	911	struct razor_property property, end;
danw@117	912	struct list *index;
krh@92	913	};
krh@92	914
krh@92	915	struct razor_property_iterator *
krh@92	916	razor_property_iterator_create(struct razor_set *set,
krh@92	917	struct razor_package *package)
krh@92	918	{
krh@92	919	struct razor_property_iterator *pi;
krh@92	920
krh@92	921	pi = zalloc(sizeof *pi);
krh@92	922	pi->set = set;
krh@98	923
danw@116	924	if (package) {
danw@117	925	pi->index = list_first(&package->properties,
danw@117	926	&set->property_pool);
danw@116	927	} else {
danw@116	928	pi->property = set->properties.data;
danw@116	929	pi->end = set->properties.data + set->properties.size;
danw@116	930	}
krh@92	931
krh@92	932	return pi;
krh@92	933	}
krh@92	934
krh@92	935	int
krh@92	936	razor_property_iterator_next(struct razor_property_iterator *pi,
krh@92	937	struct razor_property **property,
danw@109	938	const char **name,
danw@109	939	enum razor_version_relation *relation,
danw@109	940	const char **version,
krh@92	941	enum razor_property_type *type)
krh@92	942	{
krh@92	943	char *pool;
krh@92	944	int valid;
krh@92	945	struct razor_property p, properties;
krh@92	946
danw@116	947	if (pi->property) {
krh@92	948	p = pi->property++;
krh@92	949	valid = p < pi->end;
danw@116	950	} else if (pi->index) {
danw@116	951	properties = pi->set->properties.data;
danw@117	952	p = &properties[pi->index->data];
danw@116	953	pi->index = list_next(pi->index);
danw@116	954	valid = 1;
danw@116	955	} else
danw@116	956	valid = 0;
krh@92	957
krh@96	958	if (valid) {
krh@96	959	pool = pi->set->string_pool.data;
krh@96	960	*property = p;
danw@119	961	*name = &pool[p->name];
danw@109	962	*relation = p->relation;
krh@96	963	*version = &pool[p->version];
danw@119	964	*type = p->type;
krh@96	965	} else {
krh@96	966	*property = NULL;
krh@96	967	}
krh@92	968
krh@92	969	return valid;
krh@92	970	}
krh@92	971
krh@66	972	void
krh@92	973	razor_property_iterator_destroy(struct razor_property_iterator *pi)
krh@8	974	{
krh@92	975	free(pi);
krh@10	976	}
krh@10	977
krh@56	978	static struct razor_entry *
krh@56	979	find_entry(struct razor_set set, struct razor_entry dir, const char *pattern)
krh@56	980	{
krh@56	981	struct razor_entry *e;
krh@56	982	const char n, pool = set->string_pool.data;
krh@56	983	int len;
krh@56	984
krh@56	985	e = (struct razor_entry *) set->files.data + dir->start;
krh@56	986	do {
danw@120	987	n = pool + e->name;
krh@56	988	if (strcmp(pattern + 1, n) == 0)
krh@56	989	return e;
krh@57	990	len = strlen(n);
krh@56	991	if (e->start != 0 && strncmp(pattern + 1, n, len) == 0 &&
krh@56	992	pattern[len + 1] == '/') {
krh@56	993	return find_entry(set, e, pattern + len + 1);
krh@56	994	}
danw@120	995	} while (!((e++)->flags & RAZOR_ENTRY_LAST));
krh@56	996
krh@56	997	return NULL;
krh@56	998	}
krh@56	999
krh@56	1000	static void
krh@56	1001	list_dir(struct razor_set set, struct razor_entry dir,
danw@127	1002	char prefix, const char pattern)
krh@56	1003	{
krh@56	1004	struct razor_entry *e;
krh@56	1005	const char n, pool = set->string_pool.data;
krh@56	1006
krh@56	1007	e = (struct razor_entry *) set->files.data + dir->start;
krh@56	1008	do {
danw@120	1009	n = pool + e->name;
krh@56	1010	if (pattern && pattern[0] && fnmatch(pattern, n, 0) != 0)
krh@56	1011	continue;
danw@127	1012	printf("%s/%s\n", prefix, n);
danw@127	1013	if (e->start) {
danw@127	1014	char *sub = prefix + strlen (prefix);
danw@127	1015	*sub = '/';
danw@127	1016	strcpy (sub + 1, n);
danw@127	1017	list_dir(set, e, prefix, pattern);
danw@127	1018	*sub = '\0';
danw@127	1019	}
danw@120	1020	} while (!((e++)->flags & RAZOR_ENTRY_LAST));
krh@56	1021	}
krh@56	1022
krh@56	1023	void
krh@56	1024	razor_set_list_files(struct razor_set set, const char pattern)
krh@56	1025	{
krh@56	1026	struct razor_entry *e;
krh@56	1027	char buffer[512], p, base;
krh@56	1028
danw@127	1029	if (pattern == NULL \|\| !strcmp (pattern, "/")) {
danw@127	1030	buffer[0] = '\0';
danw@127	1031	list_dir(set, set->files.data, buffer, NULL);
danw@127	1032	return;
danw@127	1033	}
krh@56	1034
krh@56	1035	strcpy(buffer, pattern);
krh@56	1036	e = find_entry(set, set->files.data, buffer);
krh@56	1037	if (e && e->start > 0) {
krh@56	1038	base = NULL;
krh@56	1039	} else {
krh@56	1040	p = strrchr(buffer, '/');
krh@56	1041	if (p) {
krh@56	1042	*p = '\0';
krh@56	1043	base = p + 1;
krh@56	1044	} else {
krh@56	1045	base = NULL;
krh@56	1046	}
krh@56	1047	}
krh@56	1048	e = find_entry(set, set->files.data, buffer);
krh@56	1049	if (e->start != 0)
krh@56	1050	list_dir(set, e, buffer, base);
krh@56	1051	}
krh@56	1052
krh@102	1053	struct razor_package_iterator *
krh@102	1054	razor_package_iterator_create_for_file(struct razor_set *set,
krh@102	1055	const char *filename)
krh@56	1056	{
krh@102	1057	struct razor_entry *entry;
danw@117	1058	struct list *index;
krh@56	1059
krh@102	1060	entry = find_entry(set, set->files.data, filename);
krh@102	1061	if (entry == NULL)
krh@102	1062	return NULL;
krh@56	1063
danw@116	1064	index = list_first(&entry->packages, &set->package_pool);
krh@102	1065	return razor_package_iterator_create_with_index(set, index);
krh@56	1066	}
krh@56	1067
danw@117	1068	static struct list *
danw@117	1069	list_package_files(struct razor_set set, struct list r,
danw@108	1070	struct razor_entry *dir, uint32_t end,
krh@56	1071	char *prefix)
krh@56	1072	{
krh@56	1073	struct razor_entry e, f, *entries;
danw@108	1074	uint32_t next, file;
krh@56	1075	char *pool;
krh@56	1076	int len;
krh@56	1077
krh@56	1078	entries = (struct razor_entry *) set->files.data;
krh@56	1079	pool = set->string_pool.data;
krh@56	1080
krh@56	1081	e = entries + dir->start;
krh@56	1082	do {
danw@117	1083	if (entries + r->data == e) {
danw@120	1084	printf("%s/%s\n", prefix, pool + e->name);
danw@116	1085	r = list_next(r);
danw@116	1086	if (!r)
krh@83	1087	return NULL;
danw@117	1088	if (r->data >= end)
krh@83	1089	return r;
krh@56	1090	}
danw@120	1091	} while (!((e++)->flags & RAZOR_ENTRY_LAST));
krh@56	1092
krh@56	1093	e = entries + dir->start;
krh@56	1094	do {
krh@56	1095	if (e->start == 0)
krh@56	1096	continue;
krh@56	1097
danw@120	1098	if (e->flags & RAZOR_ENTRY_LAST)
krh@56	1099	next = end;
krh@56	1100	else {
krh@56	1101	f = e + 1;
danw@120	1102	while (f->start == 0 && !(f->flags & RAZOR_ENTRY_LAST))
krh@56	1103	f++;
krh@56	1104	if (f->start == 0)
krh@56	1105	next = end;
krh@56	1106	else
krh@56	1107	next = f->start;
krh@56	1108	}
krh@56	1109
danw@117	1110	file = r->data;
krh@83	1111	if (e->start <= file && file < next) {
krh@56	1112	len = strlen(prefix);
krh@56	1113	prefix[len] = '/';
danw@120	1114	strcpy(prefix + len + 1, pool + e->name);
krh@56	1115	r = list_package_files(set, r, e, next, prefix);
krh@56	1116	prefix[len] = '\0';
krh@56	1117	}
danw@120	1118	} while (!((e++)->flags & RAZOR_ENTRY_LAST) && r != NULL);
krh@56	1119
krh@56	1120	return r;
krh@56	1121	}
krh@56	1122
krh@56	1123	void
krh@56	1124	razor_set_list_package_files(struct razor_set set, const char name)
krh@56	1125	{
krh@56	1126	struct razor_package *package;
danw@117	1127	struct list *r;
danw@117	1128	uint32_t end;
krh@56	1129	char buffer[512];
krh@56	1130
krh@56	1131	package = razor_set_get_package(set, name);
krh@56	1132
danw@116	1133	r = list_first(&package->files, &set->file_pool);
krh@56	1134	end = set->files.size / sizeof (struct razor_entry);
krh@56	1135	buffer[0] = '\0';
krh@56	1136	list_package_files(set, r, set->files.data, end, buffer);
krh@56	1137	}
krh@56	1138
krh@43	1139	static void
krh@21	1140	razor_set_validate(struct razor_set set, struct array unsatisfied)
krh@21	1141	{
krh@66	1142	struct razor_property r, p, *end;
danw@108	1143	uint32_t *u;
krh@21	1144	char *pool;
krh@21	1145
krh@66	1146	end = set->properties.data + set->properties.size;
krh@21	1147	pool = set->string_pool.data;
krh@21	1148
krh@66	1149	for (r = set->properties.data, p = r; r < end; r++) {
danw@119	1150	if (r->type != RAZOR_PROPERTY_REQUIRES)
krh@66	1151	continue;
krh@66	1152
danw@129	1153	p = r;
danw@129	1154	while (p < end && p->name == r->name &&
danw@129	1155	p->type == r->type)
danw@129	1156	p++;
krh@37	1157
krh@35	1158	/* If there is more than one version of a provides,
krh@35	1159	* seek to the end for the highest version. */
krh@66	1160	/* FIXME: This doesn't work if we have a series of
krh@66	1161	* requires a = 1, provides a = 1, requires a = 2,
krh@66	1162	* provides a = 2, as the kernel and kernel-devel
krh@66	1163	* does.*/
danw@119	1164	while (p + 1 < end && p->name == (p + 1)->name &&
danw@119	1165	p->type == (p + 1)->type)
krh@35	1166	p++;
krh@37	1167
krh@37	1168	/* FIXME: We need to track property flags (<, <=, =
krh@37	1169	* etc) to properly determine if a requires is
krh@37	1170	* satisfied. The current code doesn't track that the
krh@37	1171	* requires a = 1 isn't satisfied by a = 2 provides. */
krh@37	1172
krh@66	1173	if (p == end \|\|
danw@119	1174	p->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@119	1175	r->name != p->name \|\|
krh@35	1176	versioncmp(&pool[r->version], &pool[p->version]) > 0) {
krh@35	1177	/* FIXME: We ignore file requires for now. */
danw@119	1178	if (pool[r->name] == '/')
krh@35	1179	continue;
krh@21	1180	u = array_add(unsatisfied, sizeof *u);
krh@66	1181	u = r - (struct razor_property ) set->properties.data;
krh@21	1182	}
krh@21	1183	}
krh@21	1184	}
krh@21	1185
krh@21	1186	void
krh@21	1187	razor_set_list_unsatisfied(struct razor_set *set)
krh@21	1188	{
krh@21	1189	struct array unsatisfied;
krh@66	1190	struct razor_property properties, r;
danw@108	1191	uint32_t u, end;
krh@21	1192	char *pool;
krh@21	1193
krh@21	1194	array_init(&unsatisfied);
krh@21	1195	razor_set_validate(set, &unsatisfied);
krh@21	1196
krh@21	1197	end = unsatisfied.data + unsatisfied.size;
krh@66	1198	properties = set->properties.data;
krh@21	1199	pool = set->string_pool.data;
krh@21	1200
krh@21	1201	for (u = unsatisfied.data; u < end; u++) {
krh@66	1202	r = properties + *u;
krh@66	1203	if (pool[r->version] == '\0')
krh@66	1204	printf("%ss not satisfied\n",
danw@119	1205	&pool[r->name]);
krh@66	1206	else
krh@66	1207	printf("%s-%s not satisfied\n",
danw@119	1208	&pool[r->name],
krh@66	1209	&pool[r->version]);
krh@21	1210	}
krh@21	1211
krh@21	1212	array_release(&unsatisfied);
krh@21	1213	}
krh@21	1214
danw@120	1215	#define UPSTREAM_SOURCE 0x80
krh@41	1216
krh@41	1217	struct source {
krh@41	1218	struct razor_set *set;
danw@108	1219	uint32_t *property_map;
danw@127	1220	uint32_t *file_map;
krh@41	1221	};
krh@41	1222
krh@79	1223	struct razor_merger {
krh@79	1224	struct razor_set *set;
krh@79	1225	struct hashtable table;
krh@79	1226	struct source source1;
krh@79	1227	struct source source2;
krh@79	1228	};
krh@79	1229
krh@79	1230	static struct razor_merger *
krh@79	1231	razor_merger_create(struct razor_set set1, struct razor_set set2)
krh@41	1232	{
krh@79	1233	struct razor_merger *merger;
krh@41	1234	int count;
krh@41	1235	size_t size;
krh@41	1236
krh@79	1237	merger = zalloc(sizeof *merger);
krh@79	1238	merger->set = razor_set_create();
krh@79	1239	hashtable_init(&merger->table, &merger->set->string_pool);
krh@41	1240
danw@127	1241	merger->source1.set = set1;
krh@79	1242	count = set1->properties.size / sizeof (struct razor_property);
krh@79	1243	size = count * sizeof merger->source1.property_map[0];
krh@79	1244	merger->source1.property_map = zalloc(size);
danw@127	1245	count = set1->files.size / sizeof (struct razor_entry);
danw@127	1246	size = count * sizeof merger->source1.file_map[0];
danw@127	1247	merger->source1.file_map = zalloc(size);
krh@79	1248
danw@127	1249	merger->source2.set = set2;
krh@79	1250	count = set2->properties.size / sizeof (struct razor_property);
krh@79	1251	size = count * sizeof merger->source2.property_map[0];
krh@79	1252	merger->source2.property_map = zalloc(size);
danw@127	1253	count = set2->files.size / sizeof (struct razor_entry);
danw@127	1254	size = count * sizeof merger->source2.file_map[0];
danw@127	1255	merger->source2.file_map = zalloc(size);
krh@79	1256
krh@79	1257	return merger;
krh@41	1258	}
krh@41	1259
krh@33	1260	static void
krh@79	1261	add_package(struct razor_merger *merger,
krh@41	1262	struct razor_package package, struct source source,
danw@108	1263	uint32_t flags)
krh@33	1264	{
krh@33	1265	char *pool;
danw@117	1266	struct list *r;
krh@41	1267	struct razor_package *p;
krh@33	1268
krh@41	1269	pool = source->set->string_pool.data;
krh@79	1270	p = array_add(&merger->set->packages, sizeof *p);
krh@79	1271	p->name = hashtable_tokenize(&merger->table, &pool[package->name]);
danw@120	1272	p->flags = flags;
krh@79	1273	p->version = hashtable_tokenize(&merger->table,
krh@79	1274	&pool[package->version]);
krh@192	1275	p->arch = hashtable_tokenize(&merger->table,
krh@192	1276	&pool[package->arch]);
danw@127	1277
krh@66	1278	p->properties = package->properties;
danw@116	1279	r = list_first(&package->properties, &source->set->property_pool);
danw@116	1280	while (r) {
danw@117	1281	source->property_map[r->data] = 1;
danw@116	1282	r = list_next(r);
krh@64	1283	}
danw@127	1284
danw@127	1285	p->files = package->files;
danw@127	1286	r = list_first(&package->files, &source->set->file_pool);
danw@127	1287	while (r) {
danw@127	1288	source->file_map[r->data] = 1;
danw@127	1289	r = list_next(r);
danw@127	1290	}
krh@41	1291	}
krh@41	1292
danw@108	1293	static uint32_t
krh@79	1294	add_property(struct razor_merger *merger,
danw@109	1295	const char *name, enum razor_version_relation relation,
danw@109	1296	const char *version, int type)
krh@41	1297	{
krh@41	1298	struct razor_property *p;
krh@41	1299
krh@79	1300	p = array_add(&merger->set->properties, sizeof *p);
danw@119	1301	p->name = hashtable_tokenize(&merger->table, name);
danw@119	1302	p->flags = 0;
danw@119	1303	p->type = type;
danw@109	1304	p->relation = relation;
krh@79	1305	p->version = hashtable_tokenize(&merger->table, version);
krh@41	1306
krh@79	1307	return p - (struct razor_property *) merger->set->properties.data;
krh@41	1308	}
krh@41	1309
krh@41	1310	static void
krh@79	1311	merge_properties(struct razor_merger *merger)
krh@41	1312	{
krh@41	1313	struct razor_property p1, p2;
krh@79	1314	struct razor_set set1, set2;
danw@108	1315	uint32_t map1, map2;
krh@41	1316	int i, j, cmp, count1, count2;
krh@41	1317	char pool1, pool2;
krh@41	1318
krh@79	1319	set1 = merger->source1.set;
krh@79	1320	set2 = merger->source2.set;
krh@79	1321	map1 = merger->source1.property_map;
krh@79	1322	map2 = merger->source2.property_map;
krh@79	1323
krh@41	1324	i = 0;
krh@41	1325	j = 0;
krh@41	1326	pool1 = set1->string_pool.data;
krh@41	1327	pool2 = set2->string_pool.data;
krh@41	1328
krh@66	1329	count1 = set1->properties.size / sizeof *p1;
krh@66	1330	count2 = set2->properties.size / sizeof *p2;
krh@41	1331	while (i < count1 \|\| j < count2) {
krh@41	1332	if (i < count1 && map1[i] == 0) {
krh@41	1333	i++;
krh@41	1334	continue;
krh@41	1335	}
krh@41	1336	if (j < count2 && map2[j] == 0) {
krh@41	1337	j++;
krh@41	1338	continue;
krh@41	1339	}
krh@66	1340	p1 = (struct razor_property *) set1->properties.data + i;
krh@66	1341	p2 = (struct razor_property *) set2->properties.data + j;
krh@41	1342	if (i < count1 && j < count2)
danw@119	1343	cmp = strcmp(&pool1[p1->name], &pool2[p2->name]);
krh@41	1344	else if (i < count1)
krh@41	1345	cmp = -1;
krh@41	1346	else
krh@41	1347	cmp = 1;
krh@41	1348	if (cmp == 0)
danw@121	1349	cmp = p1->type - p2->type;
danw@121	1350	if (cmp == 0)
danw@109	1351	cmp = p1->relation - p2->relation;
danw@109	1352	if (cmp == 0)
krh@41	1353	cmp = versioncmp(&pool1[p1->version],
krh@41	1354	&pool2[p2->version]);
krh@41	1355	if (cmp < 0) {
krh@79	1356	map1[i++] = add_property(merger,
danw@119	1357	&pool1[p1->name],
danw@109	1358	p1->relation,
krh@69	1359	&pool1[p1->version],
danw@119	1360	p1->type);
krh@41	1361	} else if (cmp > 0) {
krh@79	1362	map2[j++] = add_property(merger,
danw@119	1363	&pool2[p2->name],
danw@109	1364	p2->relation,
krh@69	1365	&pool2[p2->version],
danw@119	1366	p2->type);
krh@41	1367	} else {
krh@79	1368	map1[i++] = map2[j++] = add_property(merger,
danw@119	1369	&pool1[p1->name],
danw@109	1370	p1->relation,
krh@69	1371	&pool1[p1->version],
danw@119	1372	p1->type);
krh@41	1373	}
krh@41	1374	}
krh@41	1375	}
krh@41	1376
danw@116	1377	static void
danw@117	1378	emit_properties(struct list_head properties, struct array source_pool,
danw@108	1379	uint32_t map, struct array pool)
krh@41	1380	{
danw@117	1381	uint32_t r;
danw@117	1382	struct list p, q;
krh@41	1383
krh@41	1384	r = pool->size / sizeof *q;
danw@116	1385	p = list_first(properties, source_pool);
danw@116	1386	while (p) {
krh@41	1387	q = array_add(pool, sizeof *q);
danw@117	1388	q->data = map[p->data];
danw@117	1389	q->flags = p->flags;
danw@116	1390	p = list_next(p);
krh@33	1391	}
krh@33	1392
danw@117	1393	list_set_ptr(properties, r);
krh@41	1394	}
danw@127	1395
danw@127	1396	static uint32_t
danw@127	1397	add_file(struct razor_merger merger, const char name)
danw@127	1398	{
danw@127	1399	struct razor_entry *e;
danw@127	1400
danw@127	1401	e = array_add(&merger->set->files, sizeof *e);
danw@127	1402	e->name = hashtable_tokenize(&merger->table, name);
danw@127	1403	e->flags = 0;
danw@127	1404	e->start = 0;
danw@127	1405
danw@127	1406	return e - (struct razor_entry *)merger->set->files.data;
danw@127	1407	}
danw@127	1408
danw@129	1409	/* FIXME. Blah */
danw@127	1410	static int
danw@127	1411	fix_file_map(uint32_t *map,
danw@127	1412	struct razor_entry *files,
danw@127	1413	struct razor_entry *top)
danw@127	1414	{
danw@127	1415	uint32_t e;
danw@127	1416	int found_file = 0;
danw@127	1417
danw@127	1418	e = top->start;
danw@127	1419	do {
danw@127	1420	if (files[e].start)
danw@127	1421	fix_file_map(map, files, &files[e]);
danw@127	1422	if (map[e])
danw@127	1423	found_file = 1;
danw@127	1424	} while (!(files[e++].flags & RAZOR_ENTRY_LAST));
danw@127	1425
danw@127	1426	if (found_file)
danw@127	1427	map[top - files] = 1;
danw@127	1428	return found_file;
danw@127	1429	}
danw@127	1430
danw@127	1431	struct merge_directory {
danw@127	1432	uint32_t merged, dir1, dir2;
danw@127	1433	};
danw@127	1434
danw@127	1435	static void
danw@127	1436	merge_one_directory(struct razor_merger merger, struct merge_directory md)
danw@127	1437	{
danw@127	1438	struct razor_entry root1, root2, mroot, e1, *e2;
danw@127	1439	struct razor_set set1, set2;
danw@127	1440	struct array merge_stack;
danw@127	1441	struct merge_directory child_md, end_md;
danw@127	1442	uint32_t map1, map2, start, last;
danw@127	1443	int cmp;
danw@127	1444	char pool1, pool2;
danw@127	1445
danw@127	1446	set1 = merger->source1.set;
danw@127	1447	set2 = merger->source2.set;
danw@127	1448	map1 = merger->source1.file_map;
danw@127	1449	map2 = merger->source2.file_map;
danw@127	1450	pool1 = set1->string_pool.data;
danw@127	1451	pool2 = set2->string_pool.data;
danw@127	1452	root1 = (struct razor_entry *) set1->files.data;
danw@127	1453	root2 = (struct razor_entry *) set2->files.data;
danw@127	1454
danw@127	1455	array_init(&merge_stack);
danw@127	1456
danw@127	1457	start = merger->set->files.size / sizeof (struct razor_entry);
danw@127	1458	last = 0;
danw@127	1459	e1 = md->dir1 ? root1 + md->dir1 : NULL;
danw@127	1460	e2 = md->dir2 ? root2 + md->dir2 : NULL;
danw@127	1461	while (e1 \|\| e2) {
danw@127	1462	if (!e2 && !map1[e1 - root1]) {
danw@127	1463	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1464	e1 = NULL;
danw@127	1465	continue;
danw@127	1466	}
danw@127	1467	if (!e1 && !map2[e2 - root2]) {
danw@127	1468	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1469	e2 = NULL;
danw@127	1470	continue;
danw@127	1471	}
danw@127	1472	if (e1 && !map1[e1 - root1] &&
danw@127	1473	e2 && !map1[e2 - root2]) {
danw@127	1474	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1475	e1 = NULL;
danw@127	1476	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1477	e2 = NULL;
danw@127	1478	continue;
danw@127	1479	}
danw@127	1480
danw@127	1481	if (!e1)
danw@127	1482	cmp = 1;
danw@127	1483	else if (!e2)
danw@127	1484	cmp = -1;
danw@127	1485	else {
danw@127	1486	cmp = strcmp (&pool1[e1->name],
danw@127	1487	&pool2[e2->name]);
danw@127	1488	}
danw@127	1489
danw@127	1490	if (cmp < 0) {
danw@127	1491	if (map1[e1 - root1]) {
danw@127	1492	map1[e1 - root1] = last =
danw@127	1493	add_file(merger, &pool1[e1->name]);
danw@127	1494	if (e1->start) {
danw@127	1495	child_md = array_add(&merge_stack, sizeof (struct merge_directory));
danw@127	1496	child_md->merged = last;
danw@127	1497	child_md->dir1 = e1->start;
danw@127	1498	child_md->dir2 = 0;
danw@127	1499	}
danw@127	1500	}
danw@127	1501	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1502	e1 = NULL;
danw@127	1503	} else if (cmp > 0) {
danw@127	1504	if (map2[e2 - root2]) {
danw@127	1505	map2[e2 - root2] = last =
danw@127	1506	add_file(merger, &pool2[e2->name]);
danw@127	1507	if (e2->start) {
danw@127	1508	child_md = array_add(&merge_stack, sizeof (struct merge_directory));
danw@127	1509	child_md->merged = last;
danw@127	1510	child_md->dir1 = 0;
danw@127	1511	child_md->dir2 = e2->start;
danw@127	1512	}
danw@127	1513	}
danw@127	1514	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1515	e2 = NULL;
danw@127	1516	} else {
danw@127	1517	map1[e1 - root1] = map2[e2- root2] = last =
danw@127	1518	add_file(merger, &pool1[e1->name]);
danw@127	1519	if (e1->start \|\| e2->start) {
danw@127	1520	child_md = array_add(&merge_stack, sizeof (struct merge_directory));
danw@127	1521	child_md->merged = last;
danw@127	1522	child_md->dir1 = e1->start;
danw@127	1523	child_md->dir2 = e2->start;
danw@127	1524	}
danw@127	1525	if ((e1++)->flags & RAZOR_ENTRY_LAST)
danw@127	1526	e1 = NULL;
danw@127	1527	if ((e2++)->flags & RAZOR_ENTRY_LAST)
danw@127	1528	e2 = NULL;
danw@127	1529	}
danw@127	1530	}
danw@127	1531
danw@127	1532	mroot = (struct razor_entry *)merger->set->files.data;
danw@127	1533	if (last) {
danw@127	1534	mroot[last].flags = RAZOR_ENTRY_LAST;
danw@127	1535	mroot[md->merged].start = start;
danw@127	1536	} else
danw@127	1537	mroot[md->merged].start = 0;
danw@127	1538
danw@127	1539	end_md = merge_stack.data + merge_stack.size;
danw@127	1540	for (child_md = merge_stack.data; child_md < end_md; child_md++)
danw@127	1541	merge_one_directory(merger, child_md);
danw@127	1542	array_release(&merge_stack);
danw@127	1543	}
danw@127	1544
danw@127	1545	static void
danw@127	1546	merge_files(struct razor_merger *merger)
danw@127	1547	{
danw@129	1548	struct razor_entry *root;
danw@127	1549	struct merge_directory md;
danw@127	1550	uint32_t map1, map2;
danw@127	1551
danw@127	1552	map1 = merger->source1.file_map;
danw@127	1553	map2 = merger->source2.file_map;
danw@127	1554
danw@164	1555	md.merged = 0;
danw@129	1556
danw@129	1557	if (merger->source1.set->files.size) {
danw@129	1558	root = (struct razor_entry *) merger->source1.set->files.data;
danw@129	1559	if (root->start)
danw@129	1560	fix_file_map(map1, root, root);
danw@129	1561	md.dir1 = root->start;
danw@129	1562	} else
danw@129	1563	md.dir1 = 0;
danw@129	1564
danw@129	1565	if (merger->source2.set->files.size) {
danw@129	1566	root = (struct razor_entry *) merger->source2.set->files.data;
danw@129	1567	if (root->start)
danw@129	1568	fix_file_map(map2, root, root);
danw@129	1569	md.dir2 = root->start;
danw@129	1570	} else
danw@129	1571	md.dir2 = 0;
danw@129	1572
danw@127	1573	merge_one_directory(merger, &md);
danw@127	1574	}
danw@127	1575
danw@127	1576	static void
danw@127	1577	emit_files(struct list_head files, struct array source_pool,
danw@127	1578	uint32_t map, struct array pool)
danw@127	1579	{
danw@127	1580	uint32_t r;
danw@127	1581	struct list p, q;
danw@127	1582
danw@127	1583	r = pool->size / sizeof *q;
danw@127	1584	p = list_first(files, source_pool);
danw@127	1585	while (p) {
danw@127	1586	q = array_add(pool, sizeof *q);
danw@127	1587	q->data = map[p->data];
danw@127	1588	q->flags = p->flags;
danw@127	1589	p = list_next(p);
danw@127	1590	}
danw@127	1591
danw@127	1592	list_set_ptr(files, r);
danw@127	1593	}
danw@127	1594
krh@41	1595	/* Rebuild property->packages maps. We can't just remap these, as a
krh@41	1596	* property may have lost or gained a number of packages. Allocate an
krh@41	1597	* array per property and loop through the packages and add them to
krh@41	1598	* the arrays for their properties. */
krh@41	1599	static void
danw@127	1600	rebuild_property_package_lists(struct razor_set *set)
krh@41	1601	{
krh@66	1602	struct array pkgs, a;
krh@41	1603	struct razor_package pkg, pkg_end;
krh@41	1604	struct razor_property prop, prop_end;
danw@117	1605	struct list *r;
danw@117	1606	uint32_t *q;
krh@66	1607	int count;
krh@41	1608
krh@66	1609	count = set->properties.size / sizeof (struct razor_property);
krh@66	1610	pkgs = zalloc(count * sizeof *pkgs);
krh@41	1611	pkg_end = set->packages.data + set->packages.size;
krh@41	1612
krh@41	1613	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {
danw@128	1614	r = list_first(&pkg->properties, &set->property_pool);
danw@116	1615	while (r) {
danw@117	1616	q = array_add(&pkgs[r->data], sizeof *q);
krh@41	1617	q = pkg - (struct razor_package ) set->packages.data;
danw@116	1618	r = list_next(r);
krh@41	1619	}
krh@33	1620	}
krh@33	1621
krh@66	1622	prop_end = set->properties.data + set->properties.size;
krh@66	1623	a = pkgs;
krh@66	1624	for (prop = set->properties.data; prop < prop_end; prop++, a++) {
danw@128	1625	list_set_array(&prop->packages, &set->package_pool, a, 0);
krh@41	1626	array_release(a);
krh@41	1627	}
krh@66	1628	free(pkgs);
krh@33	1629	}
krh@33	1630
danw@127	1631	static void
danw@127	1632	rebuild_file_package_lists(struct razor_set *set)
danw@127	1633	{
danw@127	1634	struct array pkgs, a;
danw@127	1635	struct razor_package pkg, pkg_end;
danw@127	1636	struct razor_entry entry, entry_end;
danw@127	1637	struct list *r;
danw@127	1638	uint32_t *q;
danw@127	1639	int count;
danw@127	1640
danw@127	1641	count = set->files.size / sizeof (struct razor_entry);
danw@127	1642	pkgs = zalloc(count * sizeof *pkgs);
danw@127	1643	pkg_end = set->packages.data + set->packages.size;
danw@127	1644
danw@127	1645	for (pkg = set->packages.data; pkg < pkg_end; pkg++) {
danw@128	1646	r = list_first(&pkg->files, &set->file_pool);
danw@127	1647	while (r) {
danw@127	1648	q = array_add(&pkgs[r->data], sizeof *q);
danw@127	1649	q = pkg - (struct razor_package ) set->packages.data;
danw@127	1650	r = list_next(r);
danw@127	1651	}
danw@127	1652	}
danw@127	1653
danw@127	1654	entry_end = set->files.data + set->files.size;
danw@127	1655	a = pkgs;
danw@127	1656	for (entry = set->files.data; entry < entry_end; entry++, a++) {
danw@128	1657	list_set_array(&entry->packages, &set->package_pool, a, 0);
danw@127	1658	array_release(a);
danw@127	1659	}
danw@127	1660	free(pkgs);
danw@127	1661	}
danw@127	1662
danw@137	1663	static struct razor_set *
krh@79	1664	razor_merger_finish(struct razor_merger *merger)
krh@79	1665	{
krh@79	1666	struct razor_set *result;
krh@41	1667	struct razor_package p, pend;
krh@33	1668
krh@41	1669	/* As we built the package list, we filled out a bitvector of
krh@41	1670	* the properties that are referenced by the packages in the
krh@41	1671	* new set. Now we do a parallel loop through the properties
krh@41	1672	* and emit those marked in the bit vector to the new set. In
krh@41	1673	* the process, we update the bit vector to actually map from
krh@41	1674	* indices in the old property list to indices in the new
krh@41	1675	* property list for both sets. */
krh@41	1676
krh@79	1677	merge_properties(merger);
danw@127	1678	merge_files(merger);
krh@41	1679
krh@41	1680	/* Now we loop through the packages again and emit the
krh@41	1681	* property lists, remapped to point to the new properties. */
krh@41	1682
krh@79	1683	pend = merger->set->packages.data + merger->set->packages.size;
krh@79	1684	for (p = merger->set->packages.data; p < pend; p++) {
krh@41	1685	struct source *src;
krh@41	1686
danw@120	1687	if (p->flags & UPSTREAM_SOURCE)
krh@79	1688	src = &merger->source2;
krh@41	1689	else
krh@79	1690	src = &merger->source1;
krh@41	1691
danw@116	1692	emit_properties(&p->properties,
danw@116	1693	&src->set->property_pool,
danw@116	1694	src->property_map,
danw@116	1695	&merger->set->property_pool);
danw@127	1696	emit_files(&p->files,
danw@127	1697	&src->set->file_pool,
danw@127	1698	src->file_map,
danw@127	1699	&merger->set->file_pool);
danw@120	1700	p->flags &= ~UPSTREAM_SOURCE;
krh@33	1701	}
krh@33	1702
danw@127	1703	rebuild_property_package_lists(merger->set);
danw@127	1704	rebuild_file_package_lists(merger->set);
krh@41	1705
danw@129	1706	result = merger->set;
danw@129	1707	hashtable_release(&merger->table);
danw@129	1708	free(merger);
danw@129	1709
danw@129	1710	return result;
danw@129	1711	}
danw@129	1712
danw@146	1713	/* The diff order matters. We should sort the packages so that a
danw@146	1714	* REMOVE of a package comes before the INSTALL, and so that all
danw@146	1715	* requires for a package have been installed before the package.
danw@146	1716	**/
danw@146	1717
danw@146	1718	void
danw@146	1719	razor_set_diff(struct razor_set set, struct razor_set upstream,
danw@146	1720	razor_package_callback_t callback, void *data)
danw@146	1721	{
danw@146	1722	struct razor_package_iterator pi1, pi2;
danw@146	1723	struct razor_package p1, p2;
krh@192	1724	const char name1, name2, version1, version2, arch1, arch2;
danw@146	1725	int res;
danw@146	1726
danw@146	1727	pi1 = razor_package_iterator_create(set);
danw@146	1728	pi2 = razor_package_iterator_create(upstream);
danw@146	1729
krh@192	1730	razor_package_iterator_next(pi1, &p1, &name1, &version1, &arch1);
krh@192	1731	razor_package_iterator_next(pi2, &p2, &name2, &version2, &arch2);
danw@146	1732
danw@146	1733	while (p1 \|\| p2) {
danw@146	1734	if (p1 && p2) {
danw@146	1735	res = strcmp(name1, name2);
danw@146	1736	if (res == 0)
danw@146	1737	res = versioncmp(version1, version2);
danw@146	1738	} else {
danw@146	1739	res = 0;
danw@146	1740	}
danw@146	1741
danw@146	1742	if (p2 == NULL \|\| res < 0)
krh@192	1743	callback(name1, version1, NULL, arch1, data);
danw@146	1744	else if (p1 == NULL \|\| res > 0)
krh@192	1745	callback(name2, NULL, version2, arch2, data);
danw@146	1746
danw@146	1747	if (p1 != NULL && res <= 0)
danw@146	1748	razor_package_iterator_next(pi1, &p1,
krh@192	1749	&name1, &version1, &arch1);
danw@146	1750	if (p2 != NULL && res >= 0)
danw@146	1751	razor_package_iterator_next(pi2, &p2,
krh@192	1752	&name2, &version2, &arch2);
danw@146	1753	}
danw@146	1754
danw@146	1755	razor_package_iterator_destroy(pi1);
danw@146	1756	razor_package_iterator_destroy(pi2);
danw@146	1757	}
danw@146	1758
krh@190	1759	struct razor_transaction;
krh@190	1760	struct razor_transaction_package;
krh@190	1761	struct razor_transaction_resolver;
krh@190	1762
krh@190	1763	struct razor_transaction {
krh@190	1764	int package_count, errors;
krh@190	1765	struct razor_set system, upstream;
krh@191	1766
krh@191	1767	struct bitarray syspkgs, uppkgs;
krh@191	1768	struct array packages;
krh@190	1769	};
krh@190	1770
krh@190	1771	struct razor_transaction_package {
krh@190	1772	const char name, old_version, *new_version;
krh@190	1773	struct razor_package old_package, new_package;
krh@190	1774	enum razor_transaction_package_state state;
krh@190	1775
krh@190	1776	/* dep_package is the name of the package that resulted in
krh@190	1777	* this entry being created (or NULL if the user requested the
krh@190	1778	* install/remove), with the other dep_ fields providing
krh@190	1779	* additional information.
krh@190	1780	*
krh@190	1781	* For INSTALL, if dep_type is REQUIRES, then dep_package
krh@190	1782	* required something that this package provides. If dep_type
krh@190	1783	* is CONFLICTS, then dep_package is a package that conflicted
krh@190	1784	* with an older version of this package, forcing an upgrade.
krh@190	1785	*
krh@190	1786	* For REMOVE, if dep_type is REQUIRES, then dep_package is a
krh@190	1787	* package that is being removed. If dep_type is OBSOLETES,
krh@190	1788	* then dep_package is a package that obsoletes this one.
krh@190	1789	*
krh@190	1790	* For OLD_CONFLICT or NEW_CONFLICT, dep_package is an
krh@190	1791	* existing package that conflicts with this one. The
krh@190	1792	* conflicting property comes from the already-installed
krh@190	1793	* package for OLD_CONFLICT, or the to-be-installed package
krh@190	1794	* for NEW_CONFLICT.
krh@190	1795	*
krh@190	1796	* For UNSATISFIABLE, the dep_ fields are as for an INSTALL,
krh@190	1797	* but the name field will be NULL.
krh@190	1798	*/
krh@190	1799	const char *dep_package;
krh@190	1800	enum razor_property_type dep_type;
krh@190	1801	const char *dep_property;
krh@190	1802	enum razor_version_relation dep_relation;
krh@190	1803	const char *dep_version;
krh@190	1804	};
danw@141	1805
danw@144	1806	static int
danw@144	1807	package_in_set(void package, struct razor_set set)
danw@144	1808	{
danw@144	1809	return package >= set->packages.data &&
danw@144	1810	package < set->packages.data + set->packages.size;
danw@144	1811	}
danw@144	1812
danw@144	1813	static int
danw@144	1814	property_in_set(void property, struct razor_set set)
danw@144	1815	{
danw@144	1816	return property >= set->properties.data &&
danw@144	1817	property < set->properties.data + set->properties.size;
danw@144	1818	}
danw@144	1819
danw@168	1820	static struct razor_package *
krh@191	1821	property_provider_package(struct razor_transaction *trans,
danw@168	1822	struct razor_property *prop,
danw@168	1823	int installed)
danw@168	1824	{
danw@168	1825	struct razor_set *set;
danw@168	1826	struct bitarray *pkgbits;
danw@168	1827	struct razor_package *pkgs;
danw@168	1828	struct list *p;
danw@168	1829
danw@168	1830	if (installed && prop->type != RAZOR_PROPERTY_PROVIDES)
danw@168	1831	return NULL;
danw@168	1832	else if (!installed &&
danw@168	1833	prop->type != RAZOR_PROPERTY_PROVIDES &&
danw@168	1834	prop->type != RAZOR_PROPERTY_OBSOLETES)
danw@168	1835	return NULL;
danw@168	1836
danw@168	1837	if (property_in_set(prop, trans->system)) {
danw@168	1838	set = trans->system;
danw@168	1839	pkgbits = &trans->syspkgs;
danw@168	1840	} else {
danw@168	1841	set = trans->upstream;
danw@168	1842	pkgbits = &trans->uppkgs;
danw@168	1843	}
danw@168	1844	pkgs = set->packages.data;
danw@168	1845
danw@168	1846	for (p = list_first(&prop->packages, &set->package_pool); p; p = list_next(p)) {
danw@168	1847	if (bitarray_get(pkgbits, p->data) != installed)
danw@168	1848	continue;
danw@168	1849	if (prop->type == RAZOR_PROPERTY_OBSOLETES \|\|
danw@168	1850	pkgs[p->data].name == prop->name)
danw@168	1851	return &pkgs[p->data];
danw@168	1852	}
danw@168	1853	return NULL;
danw@168	1854	}
danw@168	1855
danw@144	1856	static int
danw@144	1857	compare_transaction_packages(const void one, const void two)
danw@144	1858	{
danw@160	1859	struct razor_transaction_package *tp1 = (void )one;
danw@160	1860	struct razor_transaction_package *tp2 = (void )two;
danw@160	1861
danw@160	1862	if (!(*tp1)->name)
danw@160	1863	return 1;
danw@160	1864	else if (!(*tp2)->name)
danw@160	1865	return -1;
danw@160	1866	else
danw@160	1867	return strcmp((tp1)->name, (tp2)->name);
danw@144	1868	}
danw@144	1869
danw@168	1870	/* FIXME: merge this into the other property loop in razor_transaction_satisfy */
danw@141	1871	static void
krh@191	1872	resolve_new_packages(struct razor_transaction *trans,
danw@160	1873	int start, int end)
krh@38	1874	{
danw@168	1875	struct razor_property sp, up, sp_end, up_end;
danw@168	1876	struct razor_package spkg, spkgs, upkg, upkgs;
danw@160	1877	struct razor_transaction_package **packages;
danw@144	1878	const char spool, upool;
danw@144	1879	int i;
danw@144	1880
danw@168	1881	sp_end = trans->system->properties.data + trans->system->properties.size;
danw@168	1882	spool = trans->system->string_pool.data;
danw@144	1883	spkgs = trans->system->packages.data;
danw@168	1884	up_end = trans->upstream->properties.data + trans->upstream->properties.size;
danw@168	1885	upool = trans->upstream->string_pool.data;
danw@144	1886	upkgs = trans->upstream->packages.data;
danw@168	1887
danw@168	1888	/* FIXME, check if sorting the packages directly (rather than
danw@168	1889	* sorting pointers-to-packages) still results in confusing
danw@168	1890	* descriptions.
danw@168	1891	*/
danw@160	1892	packages = calloc(end - start, sizeof *packages);
danw@160	1893	for (i = start; i < end; i++)
danw@160	1894	packages[i - start] = ((struct razor_transaction_package *)trans->packages.data) + i;
danw@160	1895	qsort(packages, end - start, sizeof *packages,
danw@160	1896	compare_transaction_packages);
danw@144	1897
danw@168	1898	sp = trans->system->properties.data;
danw@168	1899	up = trans->upstream->properties.data;
danw@160	1900	for (i = 0; i < end - start; i++) {
danw@169	1901	if (!packages[i]->name \|\|
danw@169	1902	packages[i]->state >= RAZOR_PACKAGE_FIRST_ERROR_STATE)
danw@160	1903	continue;
danw@168	1904
danw@168	1905	spkg = NULL;
danw@168	1906	while (sp < sp_end &&
danw@168	1907	strcmp(&spool[sp->name], packages[i]->name) < 0)
danw@144	1908	sp++;
danw@168	1909	while (sp < sp_end &&
danw@168	1910	strcmp(&spool[sp->name], packages[i]->name) == 0 &&
danw@168	1911	!(spkg = property_provider_package(trans, sp, 1)))
danw@168	1912	sp++;
danw@168	1913
danw@168	1914	upkg = NULL;
danw@168	1915	while (up < up_end &&
danw@168	1916	strcmp(&upool[up->name], packages[i]->name) < 0)
danw@168	1917	up++;
danw@168	1918	while (up < up_end &&
danw@168	1919	strcmp(&upool[up->name], packages[i]->name) == 0 &&
danw@168	1920	!(upkg = property_provider_package(trans, up, 0)))
danw@144	1921	up++;
danw@144	1922
danw@160	1923	if (packages[i]->state == RAZOR_PACKAGE_REMOVE \|\|
danw@160	1924	packages[i]->state == RAZOR_PACKAGE_OBSOLETED) {
danw@168	1925	if (spkg) {
danw@168	1926	packages[i]->old_package = spkg;
danw@168	1927	packages[i]->name = &spool[spkg->name];
danw@168	1928	packages[i]->old_version = &spool[spkg->version];
danw@168	1929	bitarray_set(&trans->syspkgs, spkg - spkgs, 0);
danw@169	1930	}
danw@169	1931	if (!packages[i]->old_package) {
danw@160	1932	packages[i]->name = strdup(packages[i]->name);
danw@169	1933	packages[i]->state \|= RAZOR_PACKAGE_UNAVAILABLE_FLAG;
danw@144	1934	trans->errors++;
danw@144	1935	}
danw@144	1936	} else {
danw@168	1937	if (upkg) {
danw@168	1938	packages[i]->new_package = upkg;
danw@168	1939	packages[i]->name = &upool[upkg->name];
danw@168	1940	packages[i]->new_version = &upool[upkg->version];
danw@168	1941
danw@168	1942	if (up->name != upkg->name) {
danw@168	1943	packages[i]->dep_package = &upool[upkg->name];
danw@168	1944	packages[i]->dep_type = up->type;
danw@168	1945	packages[i]->dep_property = &upool[up->name];
danw@168	1946	packages[i]->dep_relation = up->relation;
danw@168	1947	packages[i]->dep_version = &upool[up->version];
danw@168	1948	}
danw@168	1949
danw@168	1950	if (spkg) {
danw@168	1951	packages[i]->old_package = spkg;
danw@168	1952	packages[i]->old_version = &spool[spkg->version];
danw@168	1953	if (versioncmp(&spool[spkg->version], &upool[up->version]) >= 0) {
danw@160	1954	packages[i]->state = RAZOR_PACKAGE_UP_TO_DATE;
danw@144	1955	trans->errors++;
danw@144	1956	continue;
danw@144	1957	}
danw@168	1958	bitarray_set(&trans->syspkgs, spkg - spkgs, 0);
danw@144	1959	}
danw@168	1960	bitarray_set(&trans->uppkgs, upkg - upkgs, 1);
danw@169	1961	}
danw@169	1962	if (!packages[i]->new_package) {
danw@160	1963	packages[i]->name = strdup(packages[i]->name);
danw@169	1964	packages[i]->state \|= RAZOR_PACKAGE_UNAVAILABLE_FLAG;
danw@144	1965	trans->errors++;
krh@105	1966	}
krh@105	1967	}
krh@38	1968	}
krh@38	1969	}
krh@38	1970
danw@137	1971	static int
danw@137	1972	provider_satisfies_requirement(struct razor_property *provider,
danw@137	1973	const char *provider_strings,
danw@137	1974	struct razor_property *requirement,
danw@137	1975	const char *requirement_strings)
danw@137	1976	{
danw@137	1977	int cmp, len;
danw@137	1978	const char *provided = &provider_strings[provider->version];
danw@137	1979	const char *required = &requirement_strings[requirement->version];
danw@137	1980
danw@137	1981	if (!*required)
danw@137	1982	return 1;
danw@170	1983	if (!*provided) {
danw@170	1984	if (requirement->relation >= RAZOR_VERSION_EQUAL)
danw@170	1985	return 1;
danw@170	1986	else
danw@170	1987	return 0;
danw@170	1988	}
danw@137	1989
danw@137	1990	cmp = versioncmp(provided, required);
danw@137	1991
danw@137	1992	switch (requirement->relation) {
danw@137	1993	case RAZOR_VERSION_LESS:
danw@137	1994	return cmp < 0;
danw@137	1995
danw@137	1996	case RAZOR_VERSION_LESS_OR_EQUAL:
danw@137	1997	if (cmp <= 0)
danw@137	1998	return 1;
danw@137	1999	/* fall through: FIXME, make sure this is correct */
danw@137	2000
danw@137	2001	case RAZOR_VERSION_EQUAL:
danw@137	2002	if (cmp == 0)
danw@137	2003	return 1;
danw@137	2004
danw@137	2005	/* "foo == 1.1" is satisfied by "foo 1.1-2" */
danw@137	2006	len = strlen(required);
danw@137	2007	if (!strncmp(required, provided, len) && provided[len] == '-')
danw@137	2008	return 1;
danw@137	2009	return 0;
danw@137	2010
danw@137	2011	case RAZOR_VERSION_GREATER_OR_EQUAL:
danw@137	2012	return cmp >= 0;
danw@137	2013
danw@137	2014	case RAZOR_VERSION_GREATER:
danw@137	2015	return cmp > 0;
danw@137	2016	}
danw@137	2017
danw@137	2018	/* shouldn't happen */
danw@137	2019	return 0;
danw@137	2020	}
danw@137	2021
danw@142	2022	static struct razor_package *
danw@144	2023	find_package_for_file(struct razor_set set, struct bitarray pkgbits,
danw@144	2024	const char *filename, int installed)
danw@134	2025	{
danw@142	2026	struct razor_package *pkgs = set->packages.data;
danw@140	2027	struct razor_entry *entry;
danw@140	2028	struct list *p;
danw@134	2029
danw@140	2030	if (filename[0] != '/')
danw@140	2031	return 0;
danw@140	2032
danw@142	2033	entry = find_entry(set, set->files.data, filename);
danw@140	2034	if (!entry)
danw@140	2035	return 0;
danw@140	2036
danw@142	2037	for (p = list_first(&entry->packages, &set->package_pool); p; p = list_next(p)) {
danw@142	2038	if (bitarray_get(pkgbits, p->data) == installed)
danw@142	2039	return &pkgs[p->data];
danw@134	2040	}
danw@142	2041	return NULL;
danw@142	2042	}
danw@142	2043
danw@142	2044	static struct razor_package *
krh@191	2045	find_installed_package_for_file(struct razor_transaction *trans,
danw@144	2046	const char *filename)
danw@142	2047	{
danw@144	2048	struct razor_package *pkg;
danw@144	2049
danw@144	2050	pkg = find_package_for_file(trans->system, &trans->syspkgs,
danw@144	2051	filename, 1);
danw@144	2052	if (!pkg)
danw@144	2053	pkg = find_package_for_file(trans->upstream, &trans->uppkgs,
danw@144	2054	filename, 1);
danw@144	2055	return pkg;
danw@142	2056	}
danw@142	2057
danw@142	2058	static struct razor_package *
krh@191	2059	find_uninstalled_package_for_file(struct razor_transaction *trans,
danw@144	2060	const char *filename)
danw@142	2061	{
danw@144	2062	struct razor_package *pkg;
danw@144	2063
danw@144	2064	pkg = find_package_for_file(trans->upstream, &trans->uppkgs,
danw@144	2065	filename, 0);
danw@144	2066	if (!pkg)
danw@144	2067	pkg = find_package_for_file(trans->system, &trans->syspkgs,
danw@144	2068	filename, 0);
danw@144	2069	return pkg;
danw@134	2070	}
danw@134	2071
danw@154	2072	static struct razor_property *
krh@191	2073	skip_to_matching_property(struct razor_transaction *trans,
danw@154	2074	struct razor_property *match,
danw@154	2075	struct razor_property *prop)
danw@154	2076	{
danw@154	2077	struct razor_set mset, pset;
danw@154	2078	const char ppool, mpool;
danw@154	2079	struct razor_property *prop_end;
danw@154	2080
danw@154	2081	if (property_in_set(match, trans->system))
danw@154	2082	mset = trans->system;
danw@154	2083	else
danw@154	2084	mset = trans->upstream;
danw@154	2085
danw@154	2086	if (property_in_set(prop, trans->system))
danw@154	2087	pset = trans->system;
danw@154	2088	else if (property_in_set(prop, trans->upstream))
danw@154	2089	pset = trans->upstream;
danw@154	2090	else
danw@154	2091	return prop;
danw@154	2092
danw@154	2093	prop_end = pset->properties.data + pset->properties.size;
danw@154	2094	ppool = pset->string_pool.data;
danw@154	2095	mpool = mset->string_pool.data;
danw@154	2096
danw@154	2097	while (prop < prop_end &&
danw@154	2098	strcmp(&ppool[prop->name], &mpool[match->name]) < 0)
danw@154	2099	prop++;
danw@154	2100	return prop;
danw@154	2101	}
danw@154	2102
danw@140	2103	static struct razor_package *
krh@191	2104	find_package_matching(struct razor_transaction *trans, int installed,
danw@154	2105	struct razor_property *prop,
danw@144	2106	struct razor_property *req,
danw@144	2107	struct razor_set *req_set)
danw@138	2108	{
danw@144	2109	struct razor_set *set;
danw@144	2110	struct bitarray *pkgbits;
danw@144	2111	struct razor_package *pkgs;
danw@154	2112	struct razor_property props, prop_end;
danw@144	2113	enum razor_property_type match_type;
danw@144	2114	const char *pool;
danw@154	2115	const char *rpool;
danw@154	2116	int match_name = (req->type == RAZOR_PROPERTY_OBSOLETES);
danw@144	2117	int match;
danw@144	2118
danw@144	2119	if (property_in_set(prop, trans->system)) {
danw@144	2120	set = trans->system;
danw@144	2121	pkgbits = &trans->syspkgs;
danw@144	2122	} else if (property_in_set(prop, trans->upstream)) {
danw@144	2123	set = trans->upstream;
danw@144	2124	pkgbits = &trans->uppkgs;
danw@144	2125	} else
danw@144	2126	return NULL;
danw@144	2127
danw@154	2128	if (!req_set) {
danw@154	2129	if (property_in_set(req, trans->system))
danw@154	2130	req_set = trans->system;
danw@154	2131	else
danw@154	2132	req_set = trans->upstream;
danw@154	2133	}
danw@154	2134	rpool = req_set->string_pool.data;
danw@154	2135
danw@144	2136	if (req->type == RAZOR_PROPERTY_PROVIDES)
danw@144	2137	match_type = RAZOR_PROPERTY_CONFLICTS;
danw@144	2138	else
danw@144	2139	match_type = RAZOR_PROPERTY_PROVIDES;
danw@144	2140
danw@144	2141	pkgs = set->packages.data;
danw@144	2142	props = set->properties.data;
danw@144	2143	prop_end = set->properties.data + set->properties.size;
danw@144	2144	pool = set->string_pool.data;
danw@144	2145
danw@144	2146	/* Find first matching property */
danw@144	2147	while (prop < prop_end &&
danw@144	2148	strcmp(&pool[prop->name], &rpool[req->name]) < 0)
danw@144	2149	prop++;
danw@144	2150	if (prop == prop_end \|\|
danw@144	2151	strcmp(&pool[prop->name], &rpool[req->name]) > 0)
danw@144	2152	return NULL;
danw@144	2153
danw@144	2154	if (prop->type < match_type) {
danw@144	2155	while (prop < prop_end && prop->type != match_type)
danw@144	2156	prop++;
danw@144	2157	} else {
danw@144	2158	while (prop >= props && prop->type != match_type)
danw@144	2159	prop--;
danw@183	2160	while (prop > props + 1 && (prop - 1)->name == prop->name &&
danw@183	2161	(prop - 1)->type == match_type)
danw@144	2162	prop--;
danw@144	2163	}
danw@144	2164
danw@153	2165	/* Scan matching properties */
danw@144	2166	while (prop < prop_end && prop->type == match_type &&
danw@144	2167	strcmp(&pool[prop->name], &rpool[req->name]) == 0) {
danw@144	2168	if (match_type == RAZOR_PROPERTY_PROVIDES)
danw@144	2169	match = provider_satisfies_requirement(prop, pool, req, rpool);
danw@144	2170	else
danw@144	2171	match = provider_satisfies_requirement(req, rpool, prop, pool);
danw@144	2172	if (match) {
danw@140	2173	struct list *pkg;
danw@140	2174
danw@144	2175	for (pkg = list_first(&prop->packages, &set->package_pool); pkg; pkg = list_next(pkg)) {
danw@144	2176	if (bitarray_get(pkgbits, pkg->data) != installed)
danw@140	2177	continue;
danw@140	2178	if (!match_name \|\|
danw@144	2179	strcmp(&pool[pkgs[pkg->data].name],
danw@144	2180	&rpool[req->name]) == 0)
danw@144	2181	return &pkgs[pkg->data];
danw@140	2182	}
danw@140	2183	}
danw@144	2184	prop++;
danw@140	2185	}
danw@140	2186
danw@140	2187	return NULL;
danw@138	2188	}
danw@138	2189
danw@140	2190	static struct razor_package *
krh@191	2191	find_installed_package_for_property(struct razor_transaction *trans,
danw@154	2192	struct razor_property *sys_start,
danw@154	2193	struct razor_property *up_start,
danw@144	2194	struct razor_property *req)
danw@138	2195	{
danw@144	2196	struct razor_package *pkg;
danw@144	2197
danw@154	2198	pkg = find_package_matching(trans, 1, sys_start, req, NULL);
danw@144	2199	if (!pkg)
danw@154	2200	pkg = find_package_matching(trans, 1, up_start, req, NULL);
danw@144	2201	return pkg;
danw@144	2202	}
danw@144	2203
danw@144	2204	static struct razor_package *
krh@191	2205	find_uninstalled_package_for_property(struct razor_transaction *trans,
danw@154	2206	struct razor_property *sys_start,
danw@154	2207	struct razor_property *up_start,
danw@144	2208	struct razor_property *req)
danw@144	2209	{
danw@144	2210	struct razor_package *pkg;
danw@144	2211
danw@154	2212	pkg = find_package_matching(trans, 0, up_start, req, NULL);
danw@144	2213	if (!pkg)
danw@154	2214	pkg = find_package_matching(trans, 0, sys_start, req, NULL);
danw@144	2215	return pkg;
danw@140	2216	}
danw@140	2217
danw@147	2218	static struct razor_transaction_package *
krh@191	2219	find_transaction_package(struct razor_transaction trans, const char name)
danw@147	2220	{
danw@147	2221	struct razor_transaction_package *packages;
danw@147	2222	int count, i;
danw@147	2223
danw@147	2224	packages = trans->packages.data;
danw@147	2225	count = trans->packages.size / sizeof *packages;
danw@147	2226	for (i = 0; i < count; i++) {
danw@147	2227	if (packages[i].name && !strcmp(packages[i].name, name))
danw@147	2228	return &packages[i];
danw@147	2229	}
danw@147	2230	return NULL;
danw@147	2231	}
danw@147	2232
danw@160	2233	/* FIXME? */
danw@160	2234	static int
krh@191	2235	prop_is_being_installed(struct razor_transaction *trans,
danw@160	2236	struct razor_property *prop)
danw@160	2237	{
danw@160	2238	struct list *pkg;
danw@160	2239
danw@160	2240	for (pkg = list_first(&prop->packages, &trans->upstream->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2241	if (bitarray_get(&trans->uppkgs, pkg->data))
danw@160	2242	return 1;
danw@160	2243	}
danw@160	2244	return 0;
danw@160	2245	}
danw@160	2246
danw@160	2247	static int
krh@191	2248	prop_is_being_removed(struct razor_transaction *trans,
danw@160	2249	struct razor_property *prop)
danw@160	2250	{
danw@160	2251	struct list *pkg;
danw@160	2252
danw@160	2253	for (pkg = list_first(&prop->packages, &trans->system->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2254	if (bitarray_get(&trans->syspkgs, pkg->data))
danw@160	2255	return 0;
danw@160	2256	}
danw@160	2257	return 1;
danw@160	2258	}
danw@160	2259
danw@160	2260	static int
krh@191	2261	prop_is_being_updated(struct razor_transaction *trans,
danw@160	2262	struct razor_property *prop)
danw@160	2263	{
danw@160	2264	struct razor_package *packages = trans->system->packages.data;
danw@160	2265	const char *pool = trans->system->string_pool.data;
danw@160	2266	struct razor_transaction_package *tp;
danw@160	2267	struct list *pkg;
danw@160	2268
danw@160	2269	/* Assumes prop_is_being_removed returns true */
danw@160	2270
danw@160	2271	for (pkg = list_first(&prop->packages, &trans->system->package_pool); pkg; pkg = list_next(pkg)) {
danw@160	2272	tp = find_transaction_package(trans, &pool[packages[pkg->data].name]);
danw@160	2273	if (tp && tp->state == RAZOR_PACKAGE_REMOVE)
danw@160	2274	return 0;
danw@160	2275	}
danw@160	2276	return 1;
danw@160	2277	}
danw@160	2278
danw@131	2279	static void
krh@191	2280	add_transaction_package(struct razor_transaction *trans,
danw@147	2281	struct razor_package *new_package,
danw@147	2282	struct razor_package *old_package,
danw@140	2283	enum razor_transaction_package_state state,
danw@144	2284	const char *req_package,
danw@144	2285	struct razor_property *req_prop)
danw@131	2286	{
danw@147	2287	struct razor_set new_package_set, old_package_set, *req_set;
danw@160	2288	struct bitarray *reqpkgbits;
danw@147	2289	struct razor_transaction_package tp, already;
danw@140	2290	const char *pool;
danw@140	2291	struct razor_package *pkgs;
danw@140	2292	struct list *pkg;
danw@147	2293	int contradiction = 0;
danw@147	2294
danw@160	2295	if (package_in_set(new_package, trans->system))
danw@147	2296	new_package_set = trans->system;
danw@160	2297	else
danw@147	2298	new_package_set = trans->upstream;
danw@160	2299	if (package_in_set(old_package, trans->system))
danw@147	2300	old_package_set = trans->system;
danw@160	2301	else
danw@147	2302	old_package_set = trans->upstream;
danw@145	2303	if (property_in_set(req_prop, trans->system)) {
danw@145	2304	req_set = trans->system;
danw@145	2305	reqpkgbits = &trans->syspkgs;
danw@145	2306	} else {
danw@145	2307	req_set = trans->upstream;
danw@145	2308	reqpkgbits = &trans->uppkgs;
danw@145	2309	}
danw@144	2310
danw@147	2311	if (new_package) {
danw@147	2312	pool = new_package_set->string_pool.data;
danw@147	2313	already = find_transaction_package(trans, &pool[new_package->name]);
danw@147	2314	if (already) {
danw@147	2315	if (already->new_package == new_package) {
danw@147	2316	/* Already taken care of */
danw@147	2317	return;
danw@166	2318	} else if (new_package_set == trans->upstream &&
danw@166	2319	already->state == RAZOR_PACKAGE_FORCED_UPDATE) {
danw@166	2320	already->new_package = new_package;
danw@166	2321	return;
krh@209	2322	} else if (new_package_set == trans->upstream) {
krh@209	2323	return;
danw@147	2324	}
danw@166	2325
danw@147	2326	/* Oops. We lose */
danw@147	2327	if (state != RAZOR_PACKAGE_CONTRADICTION)
danw@147	2328	contradiction = 1;
danw@147	2329	}
danw@147	2330	} else if (old_package) {
danw@147	2331	pool = old_package_set->string_pool.data;
danw@147	2332	already = find_transaction_package(trans, &pool[old_package->name]);
danw@147	2333	if (already) {
danw@147	2334	if (already->old_package == old_package) {
danw@147	2335	/* Already taken care of */
danw@147	2336	return;
danw@166	2337	} else if (old_package_set == trans->system) {
danw@166	2338	already->old_package = old_package;
danw@166	2339	return;
danw@147	2340	}
danw@166	2341
danw@147	2342	/* Oops. We lose */
danw@147	2343	if (state != RAZOR_PACKAGE_CONTRADICTION)
danw@147	2344	contradiction = 1;
danw@147	2345	}
danw@147	2346	} else
danw@147	2347	state = RAZOR_PACKAGE_UNSATISFIABLE;
danw@147	2348
danw@141	2349	tp = array_add(&trans->packages, sizeof *tp);
danw@140	2350	memset(tp, 0, sizeof *tp);
danw@131	2351
danw@147	2352	if (new_package) {
danw@147	2353	pool = new_package_set->string_pool.data;
danw@147	2354	tp->new_package = new_package;
danw@147	2355	tp->name = &pool[new_package->name];
danw@147	2356	tp->new_version = &pool[new_package->version];
danw@147	2357
danw@147	2358	pkgs = new_package_set->packages.data;
danw@147	2359	}
danw@147	2360	if (old_package) {
danw@147	2361	pool = old_package_set->string_pool.data;
danw@147	2362	tp->old_package = old_package;
danw@147	2363	tp->name = &pool[old_package->name];
danw@147	2364	tp->old_version = &pool[old_package->version];
danw@147	2365
danw@147	2366	pkgs = old_package_set->packages.data;
danw@147	2367	}
danw@147	2368
danw@147	2369	tp->state = state;
danw@147	2370	if (state != RAZOR_PACKAGE_INSTALL &&
danw@154	2371	state != RAZOR_PACKAGE_FORCED_UPDATE &&
danw@154	2372	state != RAZOR_PACKAGE_REMOVE &&
danw@154	2373	state != RAZOR_PACKAGE_OBSOLETED)
danw@145	2374	trans->errors++;
danw@147	2375
danw@147	2376	if (contradiction) {
danw@147	2377	/* Do this now, after adding tp, so that it ends up
danw@147	2378	* after both the INSTALL and the REMOVE in the array.
danw@147	2379	*/
danw@147	2380	add_transaction_package(trans, new_package, old_package,
danw@147	2381	RAZOR_PACKAGE_CONTRADICTION,
danw@147	2382	NULL, NULL);
danw@145	2383	}
danw@140	2384
danw@144	2385	if (req_package)
danw@145	2386	tp->dep_package = req_package;
danw@145	2387	if (!req_prop)
danw@145	2388	return;
danw@145	2389
danw@145	2390	pool = req_set->string_pool.data;
danw@145	2391	pkgs = req_set->packages.data;
danw@145	2392	if (!req_package) {
danw@145	2393	for (pkg = list_first(&req_prop->packages, &req_set->package_pool); pkg; pkg = list_next(pkg)) {
danw@145	2394	if (bitarray_get(reqpkgbits, pkg->data))
danw@144	2395	break;
danw@144	2396	}
danw@145	2397	if (pkg)
danw@145	2398	tp->dep_package = &pool[pkgs[pkg->data].name];
danw@131	2399	}
danw@144	2400
danw@145	2401	tp->dep_type = req_prop->type;
danw@145	2402	tp->dep_property = &pool[req_prop->name];
danw@145	2403	tp->dep_relation = req_prop->relation;
danw@145	2404	tp->dep_version = &pool[req_prop->version];
danw@140	2405	}
danw@140	2406
danw@160	2407	static void
krh@191	2408	razor_transaction_satisfy(struct razor_transaction *trans)
danw@147	2409	{
danw@160	2410	struct razor_package spkgs, upkgs, *pkg;
danw@144	2411	struct razor_property sp, sprops, *sprop_end;
danw@144	2412	struct razor_property up, uprops, *uprop_end;
danw@160	2413	struct razor_property sr, ur, *first_up;
danw@160	2414	const char spool, upool, *removed_package;
danw@160	2415	struct list *reqpkg;
danw@134	2416
danw@140	2417	spkgs = trans->system->packages.data;
danw@140	2418	sprops = trans->system->properties.data;
danw@144	2419	sprop_end = trans->system->properties.data + trans->system->properties.size;
danw@145	2420	spool = trans->system->string_pool.data;
danw@140	2421	upkgs = trans->upstream->packages.data;
danw@140	2422	uprops = trans->upstream->properties.data;
danw@144	2423	uprop_end = trans->upstream->properties.data + trans->upstream->properties.size;
danw@140	2424	upool = trans->upstream->string_pool.data;
krh@33	2425
danw@144	2426	sp = sprops;
danw@160	2427	for (up = uprops; up < uprop_end; up++) {
danw@140	2428	/* Skip 'up' ahead to a property of a package which is
danw@140	2429	* to-be-installed.
danw@140	2430	*/
danw@144	2431	while (up < uprop_end &&
danw@144	2432	!prop_is_being_installed(trans, up))
danw@140	2433	up++;
danw@144	2434	if (up == uprop_end)
danw@140	2435	break;
danw@154	2436	sp = skip_to_matching_property(trans, up, sp);
krh@33	2437
danw@144	2438	switch (up->type) {
danw@140	2439	case RAZOR_PROPERTY_REQUIRES:
danw@144	2440	if (!strncmp(&upool[up->name], "rpmlib(", 7))
danw@140	2441	break;
danw@131	2442
danw@154	2443	if (find_installed_package_for_property(trans, sp, up, up) \|\|
danw@144	2444	find_installed_package_for_file(trans, &upool[up->name])) {
danw@140	2445	/* Requires something that is either installed
danw@140	2446	* or to-be-installed.
danw@140	2447	*/
danw@140	2448	break;
danw@137	2449	}
danw@137	2450
danw@140	2451	/* See if we can install a new upstream provider */
danw@154	2452	pkg = find_uninstalled_package_for_property(trans, sp, up, up);
danw@154	2453	if (!pkg)
danw@144	2454	pkg = find_uninstalled_package_for_file(trans, &upool[up->name]);
danw@160	2455	add_transaction_package(trans, pkg, NULL,
danw@144	2456	RAZOR_PACKAGE_INSTALL,
danw@144	2457	NULL, up);
danw@144	2458	break;
danw@144	2459
danw@144	2460	case RAZOR_PROPERTY_PROVIDES:
danw@144	2461	/* find_installed_package_for_property works backwards
danw@144	2462	* here, finding a conflicting installed package.
danw@144	2463	*/
danw@154	2464	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@140	2465	if (!pkg)
danw@144	2466	break;
danw@144	2467
danw@145	2468	if (package_in_set(pkg, trans->system)) {
danw@145	2469	/* pkg CONFLICTS with what 'up' PROVIDES. Try
danw@145	2470	* finding an upgrade
danw@145	2471	*/
danw@160	2472	add_transaction_package(trans, NULL, pkg,
danw@160	2473	RAZOR_PACKAGE_FORCED_UPDATE,
danw@165	2474	&upool[up->name], sp);
danw@160	2475	} else {
danw@160	2476	add_transaction_package(trans, NULL, pkg,
danw@160	2477	RAZOR_PACKAGE_CONTRADICTION,
danw@160	2478	NULL, up);
danw@144	2479	}
danw@140	2480	break;
danw@140	2481
danw@140	2482	case RAZOR_PROPERTY_CONFLICTS:
danw@154	2483	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@144	2484	if (!pkg)
danw@144	2485	break;
danw@144	2486
danw@144	2487	if (package_in_set(pkg, trans->system)) {
danw@140	2488	/* Conflicts with something already installed.
danw@140	2489	* Try to upgrade out.
danw@140	2490	*/
danw@160	2491	add_transaction_package(trans, NULL, pkg,
danw@160	2492	RAZOR_PACKAGE_FORCED_UPDATE,
danw@160	2493	NULL, up);
danw@160	2494	} else {
danw@160	2495	add_transaction_package(trans, pkg, NULL,
danw@160	2496	RAZOR_PACKAGE_CONTRADICTION,
danw@160	2497	NULL, up);
danw@140	2498	}
danw@140	2499	break;
danw@140	2500
danw@140	2501	case RAZOR_PROPERTY_OBSOLETES:
danw@154	2502	pkg = find_installed_package_for_property(trans, sp, up, up);
danw@145	2503	if (pkg) {
danw@145	2504	/* If pkg is to-be-installed, this
danw@145	2505	* will add a CONTRADICTION error as well.
danw@145	2506	*/
danw@147	2507	add_transaction_package(trans, NULL, pkg,
danw@154	2508	RAZOR_PACKAGE_OBSOLETED,
danw@144	2509	NULL, up);
danw@140	2510	}
danw@140	2511	break;
danw@140	2512
danw@140	2513	default:
danw@140	2514	/* can't happen */
danw@140	2515	break;
danw@131	2516	}
krh@37	2517	}
danw@154	2518
danw@154	2519	up = uprops;
danw@154	2520	for (sp = sprops; sp < sprop_end; sp++) {
danw@154	2521	/* Skip 'sp' ahead to a PROVIDES of a package which is
danw@154	2522	* to-be-removed.
danw@154	2523	*/
danw@154	2524	while (sp < sprop_end &&
danw@154	2525	(sp->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@154	2526	!prop_is_being_removed(trans, sp)))
danw@154	2527	sp++;
danw@154	2528	if (sp == sprop_end)
danw@154	2529	break;
danw@154	2530
danw@154	2531	removed_package = &spool[spkgs[list_first(&sp->packages, &trans->system->package_pool)->data].name];
danw@154	2532
danw@154	2533	/* Skip 'up' to match */
danw@154	2534	up = skip_to_matching_property(trans, sp, up);
danw@154	2535	ur = first_up = up;
danw@154	2536
danw@154	2537	/* If the package is just being upgraded, we may
danw@154	2538	* already be installing an identical PROVIDES, so
danw@154	2539	* check for that.
danw@154	2540	*/
danw@154	2541	while (up < uprop_end &&
danw@154	2542	strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
danw@154	2543	(up->type != RAZOR_PROPERTY_PROVIDES \|\|
danw@154	2544	sp->relation != up->relation \|\|
danw@154	2545	strcmp(&spool[sp->name], &upool[up->name]) != 0))
danw@154	2546	up++;
danw@154	2547	if (up < uprop_end &&
danw@154	2548	up->type == RAZOR_PROPERTY_PROVIDES &&
danw@154	2549	strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
danw@154	2550	sp->relation == up->relation &&
danw@154	2551	strcmp(&spool[sp->version], &upool[up->version]) == 0 &&
danw@154	2552	prop_is_being_installed(trans, up)) {
danw@154	2553	up = first_up;
danw@154	2554	continue;
danw@154	2555	}
danw@154	2556	up = first_up;
danw@154	2557
danw@154	2558	/* For all still-installed packages that require
danw@154	2559	* sp->name, see if they are satisfied by any other
danw@154	2560	* still-installed or to-be-installed property. If
danw@154	2561	* not, either remove or attempt to update the
danw@154	2562	* package, depending on why the required property has
danw@154	2563	* disappeared
danw@154	2564	*/
danw@154	2565	sr = sp;
danw@154	2566	while (sr > sprops + 1 && (sr - 1)->name == sr->name)
danw@154	2567	sr--;
danw@154	2568	for (; sr->type == RAZOR_PROPERTY_REQUIRES; sr++) {
danw@154	2569	if (prop_is_being_removed(trans, sr))
danw@154	2570	continue;
danw@154	2571	if (find_installed_package_for_property(trans, sp, up, sr))
danw@154	2572	continue;
danw@154	2573
danw@154	2574	for (reqpkg = list_first(&sr->packages, &trans->system->package_pool); reqpkg; reqpkg = list_next(reqpkg)) {
danw@154	2575	if (!bitarray_get(&trans->syspkgs, reqpkg->data))
danw@154	2576	continue;
danw@154	2577	pkg = &spkgs[reqpkg->data];
danw@154	2578	if (prop_is_being_updated(trans, sp)) {
danw@160	2579	add_transaction_package(trans, NULL, pkg,
danw@160	2580	RAZOR_PACKAGE_FORCED_UPDATE,
danw@160	2581	removed_package, NULL);
danw@154	2582	} else {
danw@154	2583	add_transaction_package(trans, NULL, pkg,
danw@154	2584	RAZOR_PACKAGE_REMOVE,
danw@154	2585	removed_package, sr);
danw@154	2586	}
danw@154	2587	}
danw@154	2588	}
danw@154	2589	}
danw@154	2590	}
danw@129	2591
krh@208	2592	void
krh@208	2593	razor_transaction_install_package(struct razor_transaction *transaction,
krh@208	2594	struct razor_package *package)
krh@208	2595	{
krh@208	2596	add_transaction_package(transaction, package, NULL,
krh@208	2597	RAZOR_PACKAGE_INSTALL, NULL, NULL);
krh@208	2598	}
krh@208	2599
krh@208	2600	void
krh@208	2601	razor_transaction_remove_package(struct razor_transaction *transaction,
krh@208	2602	struct razor_package *package)
krh@208	2603	{
krh@208	2604	add_transaction_package(transaction, NULL, package,
krh@208	2605	RAZOR_PACKAGE_REMOVE, NULL, NULL);
krh@208	2606	}
krh@208	2607
krh@208	2608	void
krh@208	2609	razor_transaction_update_all(struct razor_transaction *trans)
krh@208	2610	{
krh@208	2611	struct razor_package sp, spkgs, send, up, upkgs, uend;
krh@208	2612	const char spool, upool;
krh@208	2613
krh@208	2614	spkgs = trans->system->packages.data;
krh@208	2615	send = trans->system->packages.data + trans->system->packages.size;
krh@208	2616	spool = trans->system->string_pool.data;
krh@208	2617	up = upkgs = trans->upstream->packages.data;
krh@208	2618	uend = trans->upstream->packages.data + trans->upstream->packages.size;
krh@208	2619	upool = trans->upstream->string_pool.data;
krh@208	2620
krh@208	2621	for (sp = spkgs; sp < send; sp++) {
krh@208	2622	while (up < uend && strcmp(&spool[sp->name], &upool[up->name]) > 0)
krh@208	2623	up++;
krh@208	2624	if (strcmp(&spool[sp->name], &upool[up->name]) == 0 &&
krh@208	2625	versioncmp(&spool[sp->version], &upool[up->version]) < 0) {
krh@208	2626	add_transaction_package(trans, up, sp,
krh@208	2627	RAZOR_PACKAGE_INSTALL,
krh@208	2628	NULL, NULL);
krh@208	2629	}
krh@208	2630	}
krh@208	2631	}
krh@208	2632
danw@137	2633	struct razor_transaction *
krh@208	2634	razor_transaction_create(struct razor_set system, struct razor_set upstream)
danw@137	2635	{
krh@191	2636	struct razor_transaction *trans;
krh@208	2637	int count;
danw@137	2638
krh@191	2639	trans = zalloc(sizeof *trans);
krh@191	2640
krh@191	2641	trans->system = system;
krh@191	2642	trans->upstream = upstream ? upstream : razor_set_create();
krh@191	2643	array_init(&trans->packages);
krh@208	2644	count = trans->system->packages.size / sizeof (struct razor_package);
krh@208	2645	bitarray_init(&trans->syspkgs, count, 1);
krh@208	2646	count = trans->upstream->packages.size / sizeof (struct razor_package);
krh@208	2647	bitarray_init(&trans->uppkgs, count, 0);
krh@208	2648
krh@208	2649	return trans;
krh@208	2650	}
krh@208	2651
krh@208	2652	static void
krh@208	2653	resolve_transaction(struct razor_transaction *trans)
krh@208	2654	{
krh@208	2655	int start, end;
krh@208	2656
krh@208	2657	if (trans->package_count > 0)
krh@208	2658	/* Already did this, return. */
krh@208	2659	return;
danw@137	2660
danw@137	2661	start = 0;
krh@191	2662	end = trans->packages.size / sizeof (struct razor_transaction_package);
danw@137	2663
danw@160	2664	while (start != end) {
krh@191	2665	resolve_new_packages(trans, start, end);
krh@191	2666	if (trans->errors)
danw@160	2667	break;
danw@160	2668
krh@191	2669	razor_transaction_satisfy(trans);
danw@137	2670
danw@137	2671	start = end;
krh@191	2672	end = trans->packages.size / sizeof (struct razor_transaction_package);
danw@137	2673	}
danw@137	2674
krh@191	2675	trans->package_count = end;
danw@137	2676	}
danw@137	2677
danw@137	2678	const char * const razor_version_relations[] = {
danw@137	2679	/* same order as enum razor_version_relation */
danw@137	2680	"<", "<=", "=", ">=", ">"
danw@137	2681	};
danw@137	2682
danw@140	2683	const char * const razor_property_types[] = {
danw@140	2684	/* same order as enum razor_property_type */
danw@140	2685	"requires", "provides", "conflicts with", "obsoletes"
danw@140	2686	};
danw@140	2687
danw@169	2688	static void
danw@169	2689	print_requirement(struct razor_transaction_package *p)
danw@169	2690	{
danw@169	2691	if (p->dep_type == RAZOR_PROPERTY_CONFLICTS &&
danw@169	2692	!strcmp(p->dep_package, p->name)) {
danw@169	2693	printf(" because %s %s conflicts with %s",
danw@169	2694	p->name, p->old_version, p->dep_property);
danw@169	2695	if (*p->dep_version) {
danw@169	2696	printf(" %s %s",
danw@169	2697	razor_version_relations[p->dep_relation],
danw@169	2698	p->dep_version);
danw@169	2699	}
danw@169	2700	} else {
danw@169	2701	if (strcmp(p->name, p->dep_package) != 0)
danw@169	2702	printf(" for %s", p->dep_package);
danw@169	2703	if (*p->dep_version) {
danw@169	2704	printf(", which %s %s %s %s",
danw@169	2705	razor_property_types[p->dep_type],
danw@169	2706	p->dep_property,
danw@169	2707	razor_version_relations[p->dep_relation],
danw@169	2708	p->dep_version);
danw@169	2709	} else if (strcmp(p->dep_property, p->name) != 0) {
danw@169	2710	printf(", which %s %s",
danw@169	2711	razor_property_types[p->dep_type],
danw@169	2712	p->dep_property);
danw@169	2713	}
danw@169	2714	}
danw@169	2715	}
danw@169	2716
krh@190	2717	int
krh@210	2718	razor_transaction_resolve(struct razor_transaction *trans)
danw@137	2719	{
danw@137	2720	struct razor_transaction_package p, pend, *tps;
danw@137	2721	int errors_only = 0;
danw@137	2722
krh@208	2723	resolve_transaction(trans);
krh@208	2724
krh@191	2725	tps = trans->packages.data;
krh@191	2726	pend = trans->packages.data + trans->packages.size;
krh@191	2727	for (p = trans->packages.data; p < pend; p++) {
danw@137	2728	switch (p->state) {
danw@137	2729	case RAZOR_PACKAGE_INSTALL:
danw@137	2730	if (errors_only)
danw@137	2731	break;
danw@137	2732
danw@147	2733	printf("Installing %s %s", p->name, p->new_version);
danw@169	2734	if (p->dep_package)
danw@169	2735	print_requirement(p);
danw@137	2736	printf("\n");
danw@137	2737	break;
danw@137	2738
danw@154	2739	case RAZOR_PACKAGE_FORCED_UPDATE:
danw@154	2740	if (errors_only)
danw@154	2741	break;
danw@154	2742
danw@154	2743	printf("Updating %s to %s due to update of %s\n",
danw@154	2744	p->name, p->new_version, p->dep_package);
danw@154	2745	break;
danw@154	2746
danw@137	2747	case RAZOR_PACKAGE_REMOVE:
danw@137	2748	if (errors_only)
danw@137	2749	break;
danw@147	2750	printf("Removing %s %s", p->name, p->old_version);
danw@145	2751	if (p->dep_package) {
danw@154	2752	printf(" which required %s",
danw@154	2753	p->dep_package);
danw@162	2754	if (strcmp(p->dep_property, p->dep_package) != 0)
danw@154	2755	printf(" for %s", p->dep_property);
danw@154	2756	}
danw@154	2757	printf("\n");
danw@154	2758	break;
danw@154	2759
danw@154	2760	case RAZOR_PACKAGE_OBSOLETED:
danw@154	2761	if (errors_only)
danw@154	2762	break;
danw@154	2763	printf("Removing %s %s", p->name, p->old_version);
danw@154	2764	if (p->dep_package) {
danw@154	2765	printf(" which is obsoleted by %s",
danw@154	2766	p->dep_package);
danw@137	2767	}
danw@137	2768	printf("\n");
danw@137	2769	break;
danw@137	2770
danw@145	2771	case RAZOR_PACKAGE_INSTALL_UNAVAILABLE:
danw@169	2772	printf("Error: can't find %s", p->name);
danw@169	2773	if (p->dep_package) {
danw@169	2774	printf(" (which is required");
danw@169	2775	print_requirement(p);
danw@169	2776	printf(")");
danw@169	2777	}
danw@169	2778	printf("\n");
danw@169	2779	errors_only = 1;
danw@169	2780	break;
danw@169	2781
danw@169	2782	case RAZOR_PACKAGE_UPDATE_UNAVAILABLE:
danw@169	2783	printf("Error: can't find an updated version of %s (which must be updated due to update of %s)\n",
danw@169	2784	p->name, p->dep_package);
danw@137	2785	errors_only = 1;
danw@137	2786	break;
danw@137	2787
danw@145	2788	case RAZOR_PACKAGE_REMOVE_NOT_INSTALLED:
danw@145	2789	printf("Error: can't remove %s: not installed\n", p->name);
danw@137	2790	errors_only = 1;
danw@137	2791	break;
danw@137	2792
danw@145	2793	case RAZOR_PACKAGE_UP_TO_DATE:
danw@169	2794	printf("Error: can't update %s", p->name);
danw@169	2795	if (p->dep_package)
danw@169	2796	printf(" (which must be updated due to update of %s)", p->dep_package);
danw@169	2797	printf(": %s is most recent version\n", p->old_version);
danw@145	2798	errors_only = 1;
danw@145	2799	break;
danw@145	2800
danw@145	2801	case RAZOR_PACKAGE_CONTRADICTION:
danw@147	2802	printf("Error: package %s is marked for both installation and removal\n", p->name);
danw@145	2803	errors_only = 1;
danw@145	2804	break;
danw@145	2805
danw@145	2806	case RAZOR_PACKAGE_OLD_CONFLICT:
danw@145	2807	printf("Error: can't install %s, because installed package %s conflicts with ",
danw@145	2808	p->name, p->dep_package);
danw@145	2809	if (*p->dep_version) {
danw@145	2810	printf("%s %s %s",
danw@145	2811	p->dep_property,
danw@145	2812	razor_version_relations[p->dep_relation],
danw@145	2813	p->dep_version);
danw@145	2814	} else
danw@145	2815	printf("it");
danw@145	2816	printf("\n");
danw@145	2817
danw@145	2818	errors_only = 1;
danw@145	2819	break;
danw@145	2820
danw@145	2821	case RAZOR_PACKAGE_NEW_CONFLICT:
danw@145	2822	printf("Error: can't install %s, because it conflicts with %s",
danw@145	2823	p->name, p->dep_package);
danw@145	2824	if (*p->dep_version) {
danw@145	2825	printf(" %s %s",
danw@145	2826	razor_version_relations[p->dep_relation],
danw@145	2827	p->dep_version);
danw@145	2828	}
danw@145	2829	printf("\n");
danw@145	2830
danw@145	2831	errors_only = 1;
danw@145	2832	break;
danw@145	2833
danw@145	2834	case RAZOR_PACKAGE_UNSATISFIABLE:
danw@145	2835	printf("Error: can't find package for %s", p->dep_property);
danw@145	2836	if (*p->dep_version) {
danw@145	2837	printf(" %s %s",
danw@145	2838	razor_version_relations[p->dep_relation],
danw@145	2839	p->dep_version);
danw@145	2840	}
danw@145	2841	printf(" which is required by %s\n",
danw@145	2842	p->dep_package);
danw@140	2843	errors_only = 1;
danw@140	2844	break;
danw@140	2845
danw@137	2846	default:
danw@137	2847	/* Shouldn't actually happen */
danw@137	2848	break;
danw@137	2849	}
danw@137	2850	}
krh@190	2851
krh@190	2852	return trans->errors;
krh@190	2853	}
krh@190	2854
krh@190	2855	int
krh@190	2856	razor_transaction_unsatisfied_property(struct razor_transaction *trans,
krh@190	2857	const char *name,
krh@190	2858	enum razor_version_relation rel,
krh@190	2859	const char *version)
krh@190	2860	{
krh@190	2861	struct razor_transaction_package p, end;
krh@190	2862
krh@191	2863	end = trans->packages.data + trans->packages.size;
krh@191	2864	for (p = trans->packages.data; p < end; p++) {
krh@190	2865	if (p->state != RAZOR_PACKAGE_UNSATISFIABLE)
krh@190	2866	continue;
krh@190	2867	if (strcmp(name, p->dep_property) != 0 \|\|
krh@190	2868	rel != p->dep_relation \|\|
krh@190	2869	strcmp(version, p->dep_version) != 0)
krh@190	2870	continue;
krh@190	2871
krh@190	2872	return 1;
krh@190	2873	}
krh@190	2874
krh@190	2875	return 0;
danw@137	2876	}
danw@137	2877
danw@137	2878	struct razor_set *
krh@196	2879	razor_transaction_finish(struct razor_transaction *trans)
danw@137	2880	{
danw@137	2881	struct array install_packages, remove_packages;
danw@137	2882	struct razor_merger *merger;
danw@137	2883	struct razor_package pkg, i, iend, r, rend, s, *send;
krh@196	2884	struct razor_set *set;
danw@137	2885	struct source source1, source2;
danw@137	2886	char spool, ipool, *rpool;
danw@137	2887	uint32_t *map;
krh@191	2888	struct razor_transaction_package p, end;
krh@191	2889	int cmp;
danw@137	2890
danw@137	2891	/* FIXME */
danw@137	2892	if (trans->errors)
danw@137	2893	return NULL;
danw@137	2894
danw@137	2895	/* Sort the transaction packages into two arrays */
danw@137	2896	array_init(&install_packages);
danw@137	2897	array_init(&remove_packages);
krh@191	2898
krh@191	2899	end = trans->packages.data + trans->packages.size;
krh@191	2900	for (p = trans->packages.data; p < end; p++) {
krh@191	2901	if (p->new_package) {
danw@137	2902	pkg = array_add(&install_packages, sizeof *pkg);
krh@191	2903	pkg = p->new_package;
danw@147	2904	} else {
danw@137	2905	pkg = array_add(&remove_packages, sizeof *pkg);
krh@191	2906	pkg = p->old_package;
danw@147	2907	}
danw@137	2908	}
krh@186	2909	map = razor_qsort_with_data(install_packages.data,
krh@186	2910	install_packages.size / sizeof *pkg,
krh@186	2911	sizeof *pkg,
krh@186	2912	compare_packages,
krh@186	2913	trans->upstream);
danw@137	2914	free(map);
krh@186	2915	map = razor_qsort_with_data(remove_packages.data,
krh@186	2916	remove_packages.size / sizeof *pkg,
krh@186	2917	sizeof *pkg,
krh@186	2918	compare_packages,
krh@186	2919	trans->system);
danw@137	2920	free(map);
danw@137	2921
danw@137	2922	merger = razor_merger_create(trans->system, trans->upstream);
danw@137	2923
danw@137	2924	source1 = &merger->source1;
danw@137	2925	source2 = &merger->source2;
danw@137	2926
danw@137	2927	i = install_packages.data;
danw@137	2928	iend = install_packages.data + install_packages.size;
danw@137	2929	ipool = trans->upstream->string_pool.data;
danw@137	2930
danw@137	2931	r = remove_packages.data;
danw@137	2932	rend = remove_packages.data + remove_packages.size;
danw@137	2933	rpool = trans->system->string_pool.data;
danw@137	2934
danw@137	2935	s = trans->system->packages.data;
danw@137	2936	send = trans->system->packages.data + trans->system->packages.size;
danw@137	2937	spool = trans->system->string_pool.data;
danw@137	2938
danw@137	2939	while (s < send \|\| i < iend) {
danw@137	2940	/* Check if s is being removed */
danw@137	2941	if (s < send && r < rend &&
danw@137	2942	s->name == r->name && s->version && r->version) {
danw@137	2943	s++;
danw@137	2944	r++;
danw@137	2945	continue;
danw@137	2946	}
danw@137	2947
danw@137	2948	if (s < send && i < iend)
danw@137	2949	cmp = strcmp(&spool[s->name], &ipool[i->name]);
danw@137	2950	else if (s < send)
danw@137	2951	cmp = -1;
danw@137	2952	else
danw@137	2953	cmp = 1;
danw@137	2954	if (cmp < 0) {
danw@137	2955	add_package(merger, s, source1, 0);
danw@137	2956	s++;
danw@137	2957	} else if (cmp == 0) {
danw@137	2958	add_package(merger, i, source2, UPSTREAM_SOURCE);
danw@137	2959	s++;
danw@137	2960	i++;
danw@137	2961	} else {
danw@137	2962	add_package(merger, i, source2, UPSTREAM_SOURCE);
danw@137	2963	i++;
danw@137	2964	}
danw@137	2965	}
danw@137	2966
danw@137	2967	array_release(&install_packages);
danw@137	2968	array_release(&remove_packages);
danw@137	2969
krh@196	2970	set = razor_merger_finish(merger);
krh@196	2971	razor_transaction_destroy(trans);
krh@196	2972
krh@196	2973	return set;
danw@137	2974	}
danw@137	2975
danw@137	2976	void
danw@137	2977	razor_transaction_destroy(struct razor_transaction *trans)
danw@137	2978	{
krh@191	2979	struct razor_transaction_package p, end;
krh@191	2980
krh@191	2981	end = trans->packages.data + trans->packages.size;
krh@191	2982	for (p = trans->packages.data; p < end; p++) {
krh@191	2983	if (!p->dep_package &&
krh@191	2984	(p->state == RAZOR_PACKAGE_INSTALL_UNAVAILABLE \|\|
krh@191	2985	p->state == RAZOR_PACKAGE_REMOVE_NOT_INSTALLED))
krh@191	2986	free((char *)p->name);
danw@137	2987	}
krh@195	2988
krh@195	2989	array_release(&trans->packages);
krh@195	2990	bitarray_release(&trans->syspkgs);
krh@195	2991	bitarray_release(&trans->uppkgs);
danw@137	2992	free(trans);
danw@137	2993
danw@137	2994	/* FIXME: free upstream if it was created as an empty set */
danw@137	2995	}

author	Kristian H?gsberg <krh@jiraiya.boston.redhat.com>
	Wed Apr 09 21:14:36 2008 -0400 (2008-04-09)
changeset 212	e8f493d8ff9a
parent 210	c78f677d96b8
child 216	b97c130460a5
permissions	-rw-r--r--