#define _GNU_SOURCE

 #include <string.h>

 #include <stdio.h>

 #include <sys/stat.h>

 #include <sys/mman.h>

 #include <unistd.h>

 #include <fcntl.h>

 #include <errno.h>

 #include <expat.h>

 #include "sha1.h"

 #include "razor.h"

 static void

 parse_package(struct import_context *ctx, const char **atts, void *data)

 {

 	const char *name = NULL, *version = NULL;

 	int i;

 	for (i = 0; atts[i]; i += 2) {

 		if (strcmp(atts[i], "name") == 0)

 			name = atts[i + 1];

 		else if (strcmp(atts[i], "version") == 0)

 			version = atts[i + 1];

 	}

 	if (name == NULL || version == NULL) {

 		fprintf(stderr, "invalid package tag, "

 			"missing name or version attributes\n");

 		return;

 	}

 	import_context_add_package(ctx, name, version);

 }

 static void

 parse_property(struct import_context *ctx, const char **atts, void *data)

 {

 	const char *name = NULL, *version = NULL;

 	int i;

 	for (i = 0; atts[i]; i += 2) {

 		if (strcmp(atts[i], "name") == 0)

 			name = atts[i + 1];

 		if (strcmp(atts[i], "version") == 0)

 			version = atts[i + 1];

 	}

 	if (name == NULL) {

 		fprintf(stderr, "invalid tag, missing name attribute\n");

 		return;

 	}

 	import_context_add_property(ctx, data, name, version);

 }

 static void

 start_element(void *data, const char *name, const char **atts)

 {

 	struct import_context *ctx = data;

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

 		parse_package(ctx, atts, NULL);

 	else if (strcmp(name, "requires") == 0)

 		parse_property(ctx, atts, &ctx->requires);

 	else if (strcmp(name, "provides") == 0)

 		parse_property(ctx, atts, &ctx->provides);

 }

 static void

 end_element (void *data, const char *name)

 {

 	struct import_context *ctx = data;

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

 		import_context_finish_package(ctx);

 }

 static int

 import_rzr_file(struct import_context *ctx, const char *filename)

 {

 	SHA_CTX sha1;

 	XML_Parser parser;

 	int fd;

 	void *p;

 	struct stat stat;

 	unsigned char hash[20];

 	fd = open(filename, O_RDONLY);

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

 		return -1;

 	p = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);

 	if (p == MAP_FAILED)

 		return -1;

 	parser = XML_ParserCreate(NULL);

 	XML_SetUserData(parser, ctx);

 	XML_SetElementHandler(parser, start_element, end_element);

 	if (XML_Parse(parser, p, stat.st_size, 1) == XML_STATUS_ERROR) {

 		fprintf(stderr,

 			"%s at line %d, %s\n",

 			XML_ErrorString(XML_GetErrorCode(parser)),

 			XML_GetCurrentLineNumber(parser),

 			filename);

 		return 1;

 	}

 	XML_ParserFree(parser);

 	SHA1_Init(&sha1);

 	SHA1_Update(&sha1, p, stat.st_size);

 	SHA1_Final(hash, &sha1);

 	close(fd);

 	munmap(p, stat.st_size);

 	return 0;

 }

 struct razor_set *

 razor_import_rzr_files(int count, const char *files[])

 {

 	struct import_context ctx;

 	int i;

 	razor_prepare_import(&ctx);

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

 		if (import_rzr_file(&ctx, files[i]) < 0) {

 			fprintf(stderr, "failed to import %s\n", files[i]);

 			exit(-1);

 		}

 	}

 	return razor_finish_import(&ctx);

 }

 /* Import a yum filelist as a razor package set. */

 enum {

 	YUM_STATE_BEGIN,

 	YUM_STATE_PACKAGE_NAME

 };

 struct yum_context {

 	struct import_context ctx;

 	struct import_property_context *current_property_context;

 	char *name;

 	int state;

 };

 static void

 yum_start_element(void *data, const char *name, const char **atts)

 {

 	struct yum_context *ctx = data;

 	const char *n, *version;

 	int i;

 	if (strcmp(name, "name") == 0) {

 		ctx->state = YUM_STATE_PACKAGE_NAME;

 	} else if (strcmp(name, "version") == 0) {

 		version = NULL;

 		for (i = 0; atts[i]; i += 2) {

 			if (strcmp(atts[i], "ver") == 0)

 				version = atts[i + 1];

 		}

 		import_context_add_package(&ctx->ctx, ctx->name, version);

 	} else if (strcmp(name, "rpm:requires") == 0) {

 		ctx->current_property_context = &ctx->ctx.requires;

 	} else if (strcmp(name, "rpm:provides") == 0) {

 		ctx->current_property_context = &ctx->ctx.provides;

 	} else if (strcmp(name, "rpm:entry") == 0 &&

 		   ctx->current_property_context != NULL) {

 		n = NULL;

 		version = NULL;

 		for (i = 0; atts[i]; i += 2) {

 			if (strcmp(atts[i], "name") == 0)

 				n = atts[i + 1];

 			else if (strcmp(atts[i], "ver") == 0)

 				version = atts[i + 1];

 		}

 		if (n == NULL) {

 			fprintf(stderr, "invalid rpm:entry, "

 				"missing name or version attributes\n");

 			return;

 		}

 		import_context_add_property(&ctx->ctx,

 					    ctx->current_property_context,

 					    n, version);

 	}

 }

 static void

 yum_end_element (void *data, const char *name)

 {

 	struct yum_context *ctx = data;

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

 		free(ctx->name);

 		import_context_finish_package(&ctx->ctx);

 	} else if (strcmp(name, "name") == 0) {

 		ctx->state = 0;

 	} else if (strcmp(name, "rpm:requires") == 0) {

 		ctx->current_property_context = NULL;

 	} else if (strcmp(name, "rpm:provides") == 0) {

 		ctx->current_property_context = NULL;

 	}

 }

 static void

 yum_character_data (void *data, const XML_Char *s, int len)

 {

 	struct yum_context *ctx = data;

 	if (ctx->state == YUM_STATE_PACKAGE_NAME)

 		ctx->name = strndup(s, len);

 }

 struct razor_set *

 razor_set_create_from_yum_filelist(int fd)

 {

 	struct yum_context ctx;

 	XML_Parser parser;

 	char buf[4096];

 	int len;

 	razor_prepare_import(&ctx.ctx);

 	parser = XML_ParserCreate(NULL);

 	XML_SetUserData(parser, &ctx);

 	XML_SetElementHandler(parser, yum_start_element, yum_end_element);

 	XML_SetCharacterDataHandler(parser, yum_character_data);

 	while (1) {

 		len = read(fd, buf, sizeof buf);

 		if (len < 0) {

 			fprintf(stderr,

 				"couldn't read input: %s\n", strerror(errno));

 			return NULL;

 		} else if (len == 0)

 			break;

 		if (XML_Parse(parser, buf, len, 0) == XML_STATUS_ERROR) {

 			fprintf(stderr,

 				"%s at line %d\n",

 				XML_ErrorString(XML_GetErrorCode(parser)),

 				XML_GetCurrentLineNumber(parser));

 			return NULL;

 		}

 	}

 	XML_ParserFree(parser);

 	return razor_finish_import(&ctx.ctx);

 }