razor: razor.c@5803b6151d02 (annotated)

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

author	James Bowes <jbowes@redhat.com>
	Sun Jun 08 17:11:41 2008 -0400 (2008-06-08)
changeset 224	5803b6151d02
parent 220	1fcb5c23034a
child 225	c51f49f38d18
permissions	-rw-r--r--