#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <fcntl.h>

#include <unistd.h>

#include <arpa/inet.h>

#include <rpm/rpmlib.h>

#include "razor.h"

#define	RPM_LEAD_SIZE 96

struct rpm_lead {

	unsigned char magic[4];

	unsigned char major;

	unsigned char minor;

	short type;

	short archnum;

	char name[66];

	short osnum;

	short signature_type;

	char reserved[16];

};

struct rpm_header {

	unsigned char magic[4];

	unsigned char reserved[4];

	int nindex;

	int hsize;

};

struct rpm_header_index {

	int tag;

	int type;

	int offset;

	int count;

};

struct properties {

	struct rpm_header_index *name;

	struct rpm_header_index *version;

	struct rpm_header_index *flags;

};

struct rpm {

	struct rpm_header *signature;

	struct rpm_header *header;

	struct rpm_header_index *name;

	struct rpm_header_index *version;

	struct rpm_header_index *release;

	struct rpm_header_index *dirnames;

	struct rpm_header_index *dirindexes;

	struct rpm_header_index *basenames;

	struct properties provides;

	struct properties requires;

	struct properties obsoletes;

	struct properties conflicts;

	const char *pool;

	void *map;

	size_t size;

};

#define ALIGN(value, base) (((value) + (base - 1)) & ~((base) - 1))

static void

import_properties(struct razor_importer *importer,

		  struct properties *properties,

		  const char *pool, unsigned long type)

{

	const char *name, *version;

	int i, count;

	/* assert: count is the same for all arrays */

	if (properties->name == NULL)

		return;

	count = ntohl(properties->name->count);

	name = pool + ntohl(properties->name->offset);

	version = pool + ntohl(properties->version->offset);

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

		razor_importer_add_property(importer, name, version, type);

		name += strlen(name) + 1;

		version += strlen(version) + 1;

	}

}

static void

import_files(struct razor_importer *importer, struct rpm *rpm)

{

	const char *name, **dir;

	unsigned long *index;

	int i, count;

	char buffer[256];

	/* assert: count is the same for all arrays */

	if (rpm->dirnames == NULL)

		return;

	count = ntohl(rpm->dirnames->count);

	dir = calloc(count, sizeof *dir);

	name = rpm->pool + ntohl(rpm->dirnames->offset);

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

		dir[i] = name;

		name += strlen(name) + 1;

	}

	count = ntohl(rpm->basenames->count);

	index = (unsigned long *) (rpm->pool + ntohl(rpm->dirindexes->offset));

	name = rpm->pool + ntohl(rpm->basenames->offset);

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

		snprintf(buffer, sizeof buffer,

			 "%s%s", dir[ntohl(*index)], name);

		razor_importer_add_file(importer, buffer);

		name += strlen(name) + 1;

		index++;

	}

}

static int

razor_rpm_open(struct rpm *rpm, const char *filename)

{

	struct rpm_header_index *base, *index;

	struct stat buf;

	int fd, nindex, hsize, i;

	memset(rpm, 0, sizeof *rpm);

	if (stat(filename, &buf) < 0) {

		fprintf(stderr, "no such file %s (%m)\n", filename);

		return -1;

	}

	fd = open(filename, O_RDONLY);

	if (fd < 0) {

		fprintf(stderr, "couldn't open %s\n", filename);

		return -1;

	}

	rpm->size = buf.st_size;

	rpm->map = mmap(NULL, rpm->size, PROT_READ, MAP_PRIVATE, fd, 0);

	if (rpm->map == MAP_FAILED) {

		fprintf(stderr, "couldn't mmap %s\n", filename);

		return -1;

	}

	close(fd);

	rpm->signature = rpm->map + RPM_LEAD_SIZE;

	nindex = ntohl(rpm->signature->nindex);

	hsize = ntohl(rpm->signature->hsize);

	rpm->header = (void *) (rpm->signature + 1) +

		ALIGN(nindex * sizeof *index + hsize, 8);

	nindex = ntohl(rpm->header->nindex);

	base = (struct rpm_header_index *) (rpm->header + 1);

	rpm->pool = (void *) base + nindex * sizeof *index;

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

		index = base + i;

		switch (ntohl(index->tag)) {

		case RPMTAG_NAME:

			rpm->name = index;

			break;

		case RPMTAG_VERSION:

			rpm->version = index;

			break;

		case RPMTAG_RELEASE:

			rpm->release = index;

			break;

		case RPMTAG_REQUIRENAME:

			rpm->requires.name = index;

			break;

		case RPMTAG_REQUIREVERSION:

			rpm->requires.version = index;

			break;

		case RPMTAG_REQUIREFLAGS:

			rpm->requires.flags = index;

			break;

		case RPMTAG_PROVIDENAME:

			rpm->provides.name = index;

			break;

		case RPMTAG_PROVIDEVERSION:

			rpm->provides.version = index;

			break;

		case RPMTAG_PROVIDEFLAGS:

			rpm->provides.flags = index;

			break;

		case RPMTAG_OBSOLETENAME:

			rpm->obsoletes.name = index;

			break;

		case RPMTAG_OBSOLETEVERSION:

			rpm->obsoletes.version = index;

			break;

		case RPMTAG_OBSOLETEFLAGS:

			rpm->obsoletes.flags = index;

			break;

		case RPMTAG_CONFLICTNAME:

			rpm->conflicts.name = index;

			break;

		case RPMTAG_CONFLICTVERSION:

			rpm->conflicts.version = index;

			break;

		case RPMTAG_CONFLICTFLAGS:

			rpm->conflicts.flags = index;

			break;

		case RPMTAG_DIRINDEXES:

			rpm->dirindexes = index;

			break;

		case RPMTAG_BASENAMES:

			rpm->basenames = index;

			break;

		case RPMTAG_DIRNAMES:

			rpm->dirnames = index;

			break;

		}

	}

	return 0;

}

static int

razor_rpm_close(struct rpm *rpm)

{

	return munmap(rpm->map, rpm->size);

}

int

razor_importer_add_rpm(struct razor_importer *importer, const char *filename)

{

	struct rpm rpm;

	if (razor_rpm_open(&rpm, filename) < 0) {

		fprintf(stderr, "failed to open rpm %s (%m)\n", filename);

		return -1;

	}

	razor_importer_begin_package(importer,

				     rpm.pool + ntohl(rpm.name->offset),

				     rpm.pool + ntohl(rpm.version->offset));

	import_properties(importer, &rpm.requires,

			  rpm.pool, RAZOR_PROPERTY_REQUIRES);

	import_properties(importer, &rpm.provides,

			  rpm.pool, RAZOR_PROPERTY_PROVIDES);

	import_properties(importer, &rpm.conflicts,

			  rpm.pool, RAZOR_PROPERTY_CONFLICTS);

	import_properties(importer, &rpm.obsoletes,

			  rpm.pool, RAZOR_PROPERTY_OBSOLETES);

	import_files(importer, &rpm);

	razor_importer_finish_package(importer);

	razor_rpm_close(&rpm);

	return 0;

}