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

author	James Bowes <jbowes@redhat.com>
	Sun Jun 15 11:21:24 2008 -0400 (2008-06-15)
changeset 228	8b9849d1e5b0
parent 227	6a47b5fc2791
child 229	cae6308aa5b1
permissions	-rw-r--r--