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

author	James Bowes <jbowes@redhat.com>
	Sun Jun 08 18:29:24 2008 -0400 (2008-06-08)
changeset 225	c51f49f38d18
parent 224	5803b6151d02
child 227	6a47b5fc2791
permissions	-rw-r--r--