/*

 * Copyright (C) 2008  Kristian Høgsberg <krh@redhat.com>

 * Copyright (C) 2008  Red Hat, Inc

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

 */

#define _GNU_SOURCE

#include <stdlib.h>

#include <stddef.h>

#include <stdint.h>

#include <stdio.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <ctype.h>

#include <fnmatch.h>

#include "razor.h"

#include "razor-internal.h"

#include "types.h"

struct razor_set_section {

	uint32_t type;

	uint32_t offset;

	uint32_t size;

};

struct razor_set_header {

	uint32_t magic;

	uint32_t version;

	struct razor_set_section sections[0];

};

#define RAZOR_MAGIC 0x7a7a7a7a

#define RAZOR_VERSION 1

#define RAZOR_STRING_POOL	0

#define RAZOR_PACKAGES		1

#define RAZOR_PROPERTIES	2

#define RAZOR_FILES		3

#define RAZOR_PACKAGE_POOL	4

#define RAZOR_PROPERTY_POOL	5

#define RAZOR_FILE_POOL		6

struct razor_package {

	uint name  : 24;

	uint flags : 8;

	uint32_t version;

	uint32_t arch;

	struct list_head properties;

	struct list_head files;

};

struct razor_property {

	uint name  : 24;

	uint flags : 6;

	enum razor_property_type type : 2;

	enum razor_version_relation relation : 32;

	uint32_t version;

	struct list_head packages;

};

struct razor_entry {

	uint name  : 24;

	uint flags : 8;

	uint32_t start;

	struct list_head packages;

};

#define RAZOR_ENTRY_LAST	0x80

struct razor_set {

	struct array string_pool;

 	struct array packages;

 	struct array properties;

 	struct array files;

	struct array package_pool;

 	struct array property_pool;

 	struct array file_pool;

	struct razor_set_header *header;

};

struct import_entry {

	uint32_t package;

	char *name;

};

struct import_directory {

	uint32_t name, count;

	struct array files;

	struct array packages;

	struct import_directory *last;

};

struct razor_importer {

	struct razor_set *set;

	struct hashtable table;

	struct razor_package *package;

	struct array properties;

	struct array files;

	struct array file_requires;

};

static void *

zalloc(size_t size)

{

	void *p;

	p = malloc(size);

	memset(p, 0, size);

	return p;

}

struct razor_set_section razor_sections[] = {

	{ RAZOR_STRING_POOL,	offsetof(struct razor_set, string_pool) },

	{ RAZOR_PACKAGES,	offsetof(struct razor_set, packages) },

	{ RAZOR_PROPERTIES,	offsetof(struct razor_set, properties) },

	{ RAZOR_FILES,		offsetof(struct razor_set, files) },

	{ RAZOR_PACKAGE_POOL,	offsetof(struct razor_set, package_pool) },

	{ RAZOR_PROPERTY_POOL,	offsetof(struct razor_set, property_pool) },

	{ RAZOR_FILE_POOL,	offsetof(struct razor_set, file_pool) },

};

struct razor_set *

razor_set_create(void)

{

	struct razor_set *set;

	struct razor_entry *e;

	char *empty;

	set = zalloc(sizeof *set);

	e = array_add(&set->files, sizeof *e);

	empty = array_add(&set->string_pool, 1);

	*empty = '\0';

	e->name = 0;

	e->flags = RAZOR_ENTRY_LAST;

	e->start = 0;

	list_set_empty(&e->packages);

	return set;

}

struct razor_set *

razor_set_open(const char *filename)

{

	struct razor_set *set;

	struct razor_set_section *s;

	struct stat stat;

	struct array *array;

	int fd;

	set = zalloc(sizeof *set);

	fd = open(filename, O_RDONLY);

	if (fstat(fd, &stat) < 0)

		return NULL;

	set->header = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

	if (set->header == MAP_FAILED) {

		free(set);

		return NULL;

	}

	for (s = set->header->sections; ~s->type; s++) {

		if (s->type >= ARRAY_SIZE(razor_sections))

			continue;

		if (s->type != razor_sections[s->type].type)

			continue;

		array = (void *) set + razor_sections[s->type].offset;

		array->data = (void *) set->header + s->offset;

		array->size = s->size;

		array->alloc = s->size;

	}

	close(fd);

	return set;

}

void

razor_set_destroy(struct razor_set *set)

{

	unsigned int size;

	struct array *a;

	int i;

	if (set->header) {

		for (i = 0; set->header->sections[i].type; i++)

			;

		size = set->header->sections[i].type;

		munmap(set->header, size);

	} else {

		for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {

			a = (void *) set + razor_sections[i].offset;

			free(a->data);

		}

	}

	free(set);

}

int

razor_set_write_to_fd(struct razor_set *set, int fd)

{

	char data[4096];

	struct razor_set_header *header = (struct razor_set_header *) data;

	struct array *a;

	uint32_t offset;

	int i;

	memset(data, 0, sizeof data);

	header->magic = RAZOR_MAGIC;

	header->version = RAZOR_VERSION;

	offset = sizeof data;

	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {

		if (razor_sections[i].type != i)

			continue;

		a = (void *) set + razor_sections[i].offset;

		header->sections[i].type = i;

		header->sections[i].offset = offset;

		header->sections[i].size = a->size;

		offset += ALIGN(a->size, 4096);

	}

	header->sections[i].type = ~0;

	header->sections[i].offset = 0;

	header->sections[i].size = 0;

	razor_write(fd, data, sizeof data);

	memset(data, 0, sizeof data);

	for (i = 0; i < ARRAY_SIZE(razor_sections); i++) {

		if (razor_sections[i].type != i)

			continue;

		a = (void *) set + razor_sections[i].offset;

		razor_write(fd, a->data, a->size);

		razor_write(fd, data, ALIGN(a->size, 4096) - a->size);

	}

	return 0;

}

int

razor_set_write(struct razor_set *set, const char *filename)

{

	int fd, status;

	fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);

	if (fd < 0)

		return -1;

	status = razor_set_write_to_fd(set, fd);

	if (status) {

	    close(fd);

	    return status;

	}

	return close(fd);

}

void

razor_build_evr(char *evr_buf, int size, const char *epoch,

		const char *version, const char *release)

{

	int len;

	if (!version || !*version) {

		*evr_buf = '\0';

		return;

	}

	if (epoch && *epoch && strcmp(epoch, "0") != 0) {

		len = snprintf(evr_buf, size, "%s:", epoch);

		evr_buf += len;

		size -= len;

	}

	len = snprintf(evr_buf, size, "%s", version);

	evr_buf += len;

	size -= len;

	if (release && *release)

		snprintf(evr_buf, size, "-%s", release);

}

void

razor_importer_begin_package(struct razor_importer *importer,

			     const char *name,

			     const char *version,

			     const char *arch)

{

	struct razor_package *p;

	p = array_add(&importer->set->packages, sizeof *p);

	p->name = hashtable_tokenize(&importer->table, name);

	p->flags = 0;

	p->version = hashtable_tokenize(&importer->table, version);

	p->arch = hashtable_tokenize(&importer->table, arch);

	importer->package = p;

	array_init(&importer->properties);

}

void

razor_importer_finish_package(struct razor_importer *importer)

{

	list_set_array(&importer->package->properties,

		       &importer->set->property_pool,

		       &importer->properties,

		       1);

	array_release(&importer->properties);

}

void

razor_importer_add_property(struct razor_importer *importer,

			    const char *name,

			    enum razor_version_relation relation,

			    const char *version,

			    enum razor_property_type type)

{

	struct razor_property *p;

	uint32_t *r;

	p = array_add(&importer->set->properties, sizeof *p);

	p->name = hashtable_tokenize(&importer->table, name);

	p->flags = 0;

	p->type = type;

	p->relation = relation;

	p->version = hashtable_tokenize(&importer->table, version);

	list_set_ptr(&p->packages, importer->package -

		     (struct razor_package *) importer->set->packages.data);

	r = array_add(&importer->properties, sizeof *r);

	*r = p - (struct razor_property *) importer->set->properties.data;

	if (type == RAZOR_PROPERTY_REQUIRES && *name == '/') {

		r = array_add(&importer->file_requires, sizeof *r);

		*r = p->name;

	}

}

void

razor_importer_add_file(struct razor_importer *importer, const char *name)

{

	struct import_entry *e;

	e = array_add(&importer->files, sizeof *e);

	e->package = importer->package -

		(struct razor_package *) importer->set->packages.data;

	e->name = strdup(name);

}

struct razor_importer *

razor_importer_new(void)

{

	struct razor_importer *importer;

	importer = zalloc(sizeof *importer);

	importer->set = razor_set_create();

	hashtable_init(&importer->table, &importer->set->string_pool);

	return importer;

}

/* Destroy an importer without creating the set. */

void

razor_importer_destroy(struct razor_importer *importer)

{

	/* FIXME: write this */

}

static int

versioncmp(const char *s1, const char *s2)

{

	const char *p1, *p2;

	long n1, n2;

	int res;

	n1 = strtol(s1, (char **) &p1, 10);

	n2 = strtol(s2, (char **) &p2, 10);

	/* Epoch; if one but not the other has an epoch set, default

	 * the epoch-less version to 0. */

	res = (*p1 == ':') - (*p2 == ':');

	if (res < 0) {

		n1 = 0;

		p1 = s1;

		p2++;

	} else if (res > 0) {

		p1++;

		n2 = 0;

		p2 = s2;

	}

	if (n1 != n2)

		return n1 - n2;

	while (*p1 && *p2) {

		if (*p1 != *p2)

			return *p1 - *p2;

		p1++;

		p2++;

		if (isdigit(*p1) && isdigit(*p2))

			return versioncmp(p1, p2);

	}

	return *p1 - *p2;

}

static int

compare_packages(const void *p1, const void *p2, void *data)

{

	const struct razor_package *pkg1 = p1, *pkg2 = p2;

	struct razor_set *set = data;

	char *pool = set->string_pool.data;

	/* FIXME: what if the flags are different? */

	if (pkg1->name == pkg2->name)

		return versioncmp(&pool[pkg1->version], &pool[pkg2->version]);

	else

		return strcmp(&pool[pkg1->name], &pool[pkg2->name]);

}

static int

compare_properties(const void *p1, const void *p2, void *data)

{

	const struct razor_property *prop1 = p1, *prop2 = p2;

	struct razor_set *set = data;

	char *pool = set->string_pool.data;

	if (prop1->name != prop2->name)

		return strcmp(&pool[prop1->name], &pool[prop2->name]);

	else if (prop1->type != prop2->type)

		return prop1->type - prop2->type;

	else if (prop1->relation != prop2->relation)

		return prop1->relation - prop2->relation;

	else

		return versioncmp(&pool[prop1->version], &pool[prop2->version]);

}

static uint32_t *

uniqueify_properties(struct razor_set *set)

{

	struct razor_property *rp, *up, *rp_end;

	struct array *pkgs, *p;

	struct list_head *r;

	uint32_t *map, *rmap;

	int i, count, unique;

	count = set->properties.size / sizeof(struct razor_property);

	map = razor_qsort_with_data(set->properties.data,

				    count,

				    sizeof(struct razor_property),

				    compare_properties,

				    set);

	rp_end = set->properties.data + set->properties.size;

	rmap = malloc(count * sizeof *map);

	pkgs = zalloc(count * sizeof *pkgs);

	for (rp = set->properties.data, up = rp, i = 0; rp < rp_end; rp++, i++) {

		if (rp->name != up->name || rp->type != up->type ||

		    rp->relation != up->relation || rp->version != up->version) {

			up++;

			up->name = rp->name;

			up->flags = 0;

			up->type = rp->type;

			up->relation = rp->relation;

			up->version = rp->version;

		}

		unique = up - (struct razor_property *) set->properties.data;

		rmap[map[i]] = unique;

		r = array_add(&pkgs[unique], sizeof *r);

		*r = rp->packages;

	}

	free(map);

	if (up != rp)

		up++;

	set->properties.size = (void *) up - set->properties.data;

	rp_end = up;

	for (rp = set->properties.data, p = pkgs; rp < rp_end; rp++, p++) {

		list_set_array(&rp->packages, &set->package_pool, p, 0);

		array_release(p);

	}

	free(pkgs);

	return rmap;

}

static int

compare_filenames(const void *p1, const void *p2, void *data)

{

	const struct import_entry *e1 = p1;

	const struct import_entry *e2 = p2;

	const char *n1 = e1->name;

	const char *n2 = e2->name;

	/* Need to make sure that the contents of a directory

	 * are sorted immediately after it. So "foo/bar" has to

	 * sort before "foo.conf"

	 *

	 * FIXME: this is about 60% slower than strcmp

	 */

	while (*n1 && *n2) {

		if (*n1 < *n2)

			return *n2 == '/' ? 1 : -1;

		else if (*n1 > *n2)

			return *n1 == '/' ? -1 : 1;

		n1++;

		n2++;

	}

	if (*n1)

		return 1;

	else if (*n2)

		return -1;

	else

		return 0;

}

static void

count_entries(struct import_directory *d)

{

	struct import_directory *p, *end;

	p = d->files.data;

	end = d->files.data + d->files.size;

	d->count = 0;

	while (p < end) {

		count_entries(p);

		d->count += p->count + 1;

		p++;

	}

}

static void

serialize_files(struct razor_set *set,

		struct import_directory *d, struct array *array)

{

	struct import_directory *p, *end;

	struct razor_entry *e = NULL;

	uint32_t s;

	p = d->files.data;

	end = d->files.data + d->files.size;

	s = array->size / sizeof *e + d->files.size / sizeof *p;

	while (p < end) {

		e = array_add(array, sizeof *e);

		e->name = p->name;

		e->flags = 0;

		e->start = p->count > 0 ? s : 0;

		s += p->count;

		list_set_array(&e->packages, &set->package_pool, &p->packages, 0);

		array_release(&p->packages);

		p++;

	}

	if (e != NULL)

		e->flags |= RAZOR_ENTRY_LAST;

	p = d->files.data;

	end = d->files.data + d->files.size;

	while (p < end) {

		serialize_files(set, p, array);

		p++;

	}

}

static void

remap_property_package_links(struct array *properties, uint32_t *rmap)

{

	struct razor_property *p, *end;

	end = properties->data + properties->size;

	for (p = properties->data; p < end; p++)

		list_remap_head(&p->packages, rmap);

}

static void

build_file_tree(struct razor_importer *importer)

{

	int count, i, length;

	struct import_entry *filenames;

	char *f, *end;

	uint32_t name, *r;

	char dirname[256];

	struct import_directory *d, root;

	struct razor_entry *e;

	count = importer->files.size / sizeof (struct import_entry);

	razor_qsort_with_data(importer->files.data,

			      count,

			      sizeof (struct import_entry),

			      compare_filenames,

			      NULL);

	root.name = hashtable_tokenize(&importer->table, "");

	array_init(&root.files);

	array_init(&root.packages);

	root.last = NULL;

	filenames = importer->files.data;

	for (i = 0; i < count; i++) {

		f = filenames[i].name;

		if (*f != '/')

			continue;

		f++;

		d = &root;

		while (*f) {

			end = strchr(f, '/');

			if (end == NULL)

				end = f + strlen(f);

			length = end - f;

			memcpy(dirname, f, length);

			dirname[length] ='\0';

			name = hashtable_tokenize(&importer->table, dirname);

			if (d->last == NULL || d->last->name != name) {

				d->last = array_add(&d->files, sizeof *d);

				d->last->name = name;

				d->last->last = NULL;

				array_init(&d->last->files);

				array_init(&d->last->packages);

			}

			d = d->last;

			f = end + 1;

			if (*end == '\0')

				break;

		}

		r = array_add(&d->packages, sizeof *r);

		*r = filenames[i].package;

		free(filenames[i].name);

	}

	count_entries(&root);

	e = importer->set->files.data;

	e->name = root.name;

	e->flags = RAZOR_ENTRY_LAST;

	e->start = importer->files.size ? 1 : 0;

	list_set_empty(&e->packages);

	serialize_files(importer->set, &root, &importer->set->files);

	array_release(&importer->files);

}

static struct razor_entry *

find_entry(struct razor_set *set, struct razor_entry *dir, const char *pattern);

static void

list_to_array(struct list *list, struct array *array)

{

	uint32_t *item;

	while (list) {

		 item = array_add(array, sizeof *item);

		 *item = list->data;

		 list = list_next(list);

	}

}

static int

compare_file_requires(const void *p1, const void *p2, void *data)

{

	uint32_t *f1 = (void *)p1, *f2 = (void *)p2;

	const char *pool = data;

	return strcmp(&pool[*f1], &pool[*f2]);

}

static void

find_file_provides(struct razor_importer *importer)

{

	struct razor_property *prop;

	struct razor_entry *top, *entry;

	struct razor_package *packages;

	struct array pkgprops;

	struct list *pkg;

	uint32_t *req, *req_start, *req_end;

	uint32_t *map, *newprop;

	char *pool;

	pool = importer->set->string_pool.data;

	packages = importer->set->packages.data;

	top = importer->set->files.data;

	req = req_start = importer->file_requires.data;

	req_end = importer->file_requires.data + importer->file_requires.size;

	map = razor_qsort_with_data(req, req_end - req, sizeof *req,

				    compare_file_requires, pool);

	free(map);

	for (req = req_start; req < req_end; req++) {

		if (req > req_start && req[0] == req[-1])

			continue;

		entry = find_entry(importer->set, top, &pool[*req]);

		if (!entry)

			continue;

		for (pkg = list_first(&entry->packages, &importer->set->package_pool); pkg; pkg = list_next(pkg)) {

			prop = array_add(&importer->set->properties, sizeof *prop);

			prop->name = *req;

			prop->type = RAZOR_PROPERTY_PROVIDES;

			prop->relation = RAZOR_VERSION_EQUAL;

			prop->version = hashtable_tokenize(&importer->table, "");

			list_set_ptr(&prop->packages, pkg->data);

			/* Update property list of pkg */

			array_init(&pkgprops);

			list_to_array(list_first(&packages[pkg->data].properties, &importer->set->property_pool), &pkgprops);

			newprop = array_add(&pkgprops, sizeof *newprop);

			*newprop = prop - (struct razor_property *)importer->set->properties.data;

			list_set_array(&packages[pkg->data].properties, &importer->set->property_pool, &pkgprops, 1);

			array_release(&pkgprops);

		}

	}

	array_release(&importer->file_requires);

}

static void

build_package_file_lists(struct razor_set *set, uint32_t *rmap)

{

	struct razor_package *p, *packages;

	struct array *pkgs;

	struct razor_entry *e, *end;

	struct list *r;

	uint32_t *q;

	int i, count;

	count = set->packages.size / sizeof *p;

	pkgs = zalloc(count * sizeof *pkgs);

	end = set->files.data + set->files.size;

	for (e = set->files.data; e < end; e++) {

		list_remap_head(&e->packages, rmap);

		r = list_first(&e->packages, &set->package_pool);

		while (r) {

			q = array_add(&pkgs[r->data], sizeof *q);

			*q = e - (struct razor_entry *) set->files.data;

			r = list_next(r);

		}

	}

	packages = set->packages.data;

	for (i = 0; i < count; i++) {

		list_set_array(&packages[i].files, &set->file_pool, &pkgs[i], 0);

		array_release(&pkgs[i]);

	}

	free(pkgs);

}

struct razor_set *

razor_importer_finish(struct razor_importer *importer)

{

	struct razor_set *set;

	uint32_t *map, *rmap;

	int i, count;

	build_file_tree(importer);

	find_file_provides(importer);

	map = uniqueify_properties(importer->set);

	list_remap_pool(&importer->set->property_pool, map);

	free(map);

	count = importer->set->packages.size / sizeof(struct razor_package);

	map = razor_qsort_with_data(importer->set->packages.data,

				    count,

				    sizeof(struct razor_package),

				    compare_packages,

				    importer->set);

	rmap = malloc(count * sizeof *rmap);

	for (i = 0; i < count; i++)

		rmap[map[i]] = i;

	free(map);

	list_remap_pool(&importer->set->package_pool, rmap);

	build_package_file_lists(importer->set, rmap);

	remap_property_package_links(&importer->set->properties, rmap);

	free(rmap);

	set = importer->set;

	hashtable_release(&importer->table);

	free(importer);

	return set;

}

struct razor_package_iterator {

	struct razor_set *set;

	struct razor_package *package, *end;

	struct list *index;

	int free_index;

};

static struct razor_package_iterator *

razor_package_iterator_create_with_index(struct razor_set *set,

					 struct list *index)

{

	struct razor_package_iterator *pi;

	pi = zalloc(sizeof *pi);

	pi->set = set;

	pi->index = index;

	return pi;

}

struct razor_package_iterator *

razor_package_iterator_create(struct razor_set *set)

{

	struct razor_package_iterator *pi;

	pi = zalloc(sizeof *pi);

	pi->set = set;

	pi->end = set->packages.data + set->packages.size;

	pi->package = set->packages.data;

	return pi;

}

static void

razor_package_iterator_init_for_property(struct razor_package_iterator *pi,

					 struct razor_set *set,

					 struct razor_property *property)

{

	memset(pi, 0, sizeof *pi);

	pi->set = set;

	pi->index = list_first(&property->packages, &set->package_pool);

}

struct razor_package_iterator *

razor_package_iterator_create_for_property(struct razor_set *set,

					   struct razor_property *property)

{

	struct list *index;

	index = list_first(&property->packages, &set->package_pool);

	return razor_package_iterator_create_with_index(set, index);

}

int

razor_package_iterator_next(struct razor_package_iterator *pi,

			    struct razor_package **package,

			    const char **name,

			    const char **version,

			    const char **arch)

{

	char *pool;

	int valid;

	struct razor_package *p, *packages;

	if (pi->package) {

		p = pi->package++;

		valid = p < pi->end;

	} else if (pi->index) {

		packages = pi->set->packages.data;

		p = &packages[pi->index->data];

		pi->index = list_next(pi->index);

		valid = 1;

	} else

		valid = 0;

	if (valid) {

		pool = pi->set->string_pool.data;

		*package = p;

		*name = &pool[p->name];

		*version = &pool[p->version];

		*arch = &pool[p->arch];

	} else {

		*package = NULL;

	}

	return valid;

}

void

razor_package_iterator_destroy(struct razor_package_iterator *pi)

{

	if (pi->free_index)

		free(pi->index);

	free(pi);

}

struct razor_package *

razor_set_get_package(struct razor_set *set, const char *package)

{

	struct razor_package_iterator *pi;

	struct razor_package *p;

	const char *name, *version, *arch;

	pi = razor_package_iterator_create(set);

	while (razor_package_iterator_next(pi, &p, &name, &version, &arch)) {

		if (strcmp(package, name) == 0)

			break;

	}

	razor_package_iterator_destroy(pi);

	return p;

}

struct razor_property_iterator {

	struct razor_set *set;

	struct razor_property *property, *end;

	struct list *index;

};

struct razor_property_iterator *

razor_property_iterator_create(struct razor_set *set,

			       struct razor_package *package)

{

	struct razor_property_iterator *pi;

	pi = zalloc(sizeof *pi);

	pi->set = set;

	if (package) {

		pi->index = list_first(&package->properties,

				       &set->property_pool);

	} else {

		pi->property = set->properties.data;

		pi->end = set->properties.data + set->properties.size;

	}

	return pi;

}

int

razor_property_iterator_next(struct razor_property_iterator *pi,

			     struct razor_property **property,

			     const char **name,

			     enum razor_version_relation *relation,

			     const char **version,

			     enum razor_property_type *type)

{

	char *pool;

	int valid;

	struct razor_property *p, *properties;

	if (pi->property) {

		p = pi->property++;

		valid = p < pi->end;

	} else if (pi->index) {

		properties = pi->set->properties.data;

		p = &properties[pi->index->data];

		pi->index = list_next(pi->index);

		valid = 1;

	} else

		valid = 0;

	if (valid) {

		pool = pi->set->string_pool.data;

		*property = p;

		*name = &pool[p->name];

		*relation = p->relation;

		*version = &pool[p->version];

		*type = p->type;

	} else {

		*property = NULL;

	}

	return valid;

}

void

razor_property_iterator_destroy(struct razor_property_iterator *pi)

{

	free(pi);

}

static struct razor_entry *

find_entry(struct razor_set *set, struct razor_entry *dir, const char *pattern)

{