/*

 * 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 "config.h"

#include <string.h>

#include <stdio.h>

#include <stdint.h>

#include <assert.h>

#include <sys/stat.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include <expat.h>

#include <zlib.h>

#include "razor.h"

#include "import.h"

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

enum {

	YUM_STATE_BEGIN,

	YUM_STATE_PACKAGE_NAME,

	YUM_STATE_PACKAGE_ARCH,

	YUM_STATE_SUMMARY,

	YUM_STATE_DESCRIPTION,

	YUM_STATE_URL,

	YUM_STATE_LICENSE,

	YUM_STATE_CHECKSUM,

	YUM_STATE_REQUIRES,

	YUM_STATE_PROVIDES,

	YUM_STATE_OBSOLETES,

	YUM_STATE_CONFLICTS,

	YUM_STATE_FILE

};

struct yum_context {

	XML_Parser primary_parser;

	XML_Parser filelists_parser;

	XML_Parser current_parser;

	struct razor_importer *importer;

	struct import_property_context *current_property_context;

	char name[256], arch[64], summary[512], description[4096];

	char url[256], license[64], buffer[512], *p;

	char pkgid[128];

	uint32_t property_type;

	int state;

	int total, current;

};

static uint32_t

yum_to_razor_relation (const char *flags)

{

	if (flags[0] == 'L') {

		if (flags[1] == 'T')

			return RAZOR_PROPERTY_LESS;

		else

			return RAZOR_PROPERTY_LESS | RAZOR_PROPERTY_EQUAL;

	} else if (flags[0] == 'G') {

		if (flags[1] == 'T')

			return RAZOR_PROPERTY_GREATER;

		else

			return RAZOR_PROPERTY_GREATER | RAZOR_PROPERTY_EQUAL;

	} else

		return RAZOR_PROPERTY_EQUAL;

}

static void

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

{

	struct yum_context *ctx = data;

	const char *n, *epoch, *version, *release;

	char buffer[128];

	uint32_t pre, relation, flags;

	int i;

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

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

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

				ctx->total = atoi(atts[i + 1]);

		}

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

		ctx->state = YUM_STATE_PACKAGE_NAME;

		ctx->p = ctx->name;

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

		ctx->state = YUM_STATE_PACKAGE_ARCH;

		ctx->p = ctx->arch;

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

		epoch = NULL;

		version = NULL;

		release = NULL;

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

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

				epoch = atts[i + 1];

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

				version = atts[i + 1];

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

				release = atts[i + 1];

		}

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

			fprintf(stderr, "invalid version tag, "

				"missing version or  release attribute\n");

			return;

		}

		razor_build_evr(buffer, sizeof buffer, epoch, version, release);

		razor_importer_begin_package(ctx->importer,

					     ctx->name, buffer, ctx->arch);

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

		ctx->p = ctx->summary;

		ctx->state = YUM_STATE_SUMMARY;

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

		ctx->p = ctx->description;

		ctx->state = YUM_STATE_DESCRIPTION;

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

		ctx->p = ctx->url;

		ctx->state = YUM_STATE_URL;

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

		ctx->p = ctx->pkgid;

		ctx->state = YUM_STATE_CHECKSUM;

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

		ctx->p = ctx->license;

		ctx->state = YUM_STATE_LICENSE;

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

		ctx->state = YUM_STATE_REQUIRES;

		ctx->property_type = RAZOR_PROPERTY_REQUIRES;

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

		ctx->state = YUM_STATE_PROVIDES;

		ctx->property_type = RAZOR_PROPERTY_PROVIDES;

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

		ctx->state = YUM_STATE_OBSOLETES;

		ctx->property_type = RAZOR_PROPERTY_OBSOLETES;

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

		ctx->state = YUM_STATE_CONFLICTS;

		ctx->property_type = RAZOR_PROPERTY_CONFLICTS;

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

		   ctx->state != YUM_STATE_BEGIN) {

		n = NULL;

		epoch = NULL;

		version = NULL;

		release = NULL;

		relation = RAZOR_PROPERTY_EQUAL;

		pre = 0;

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

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

				n = atts[i + 1];

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

				epoch = atts[i + 1];

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

				version = atts[i + 1];

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

				release = atts[i + 1];

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

				relation = yum_to_razor_relation(atts[i + 1]);

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

				pre = RAZOR_PROPERTY_PRE;

		}

		if (n == NULL) {

			fprintf(stderr, "invalid rpm:entry, "

				"missing name or version attributes\n");

			return;

		}

		razor_build_evr(buffer, sizeof buffer, epoch, version, release);

		flags = ctx->property_type | relation | pre;

		razor_importer_add_property(ctx->importer, n, flags, buffer);

	}

}

static void

yum_primary_end_element (void *data, const char *name)

{

	struct yum_context *ctx = data;

	switch (ctx->state) {

	case YUM_STATE_PACKAGE_NAME:

	case YUM_STATE_PACKAGE_ARCH:

	case YUM_STATE_SUMMARY:

	case YUM_STATE_DESCRIPTION:

	case YUM_STATE_URL:

	case YUM_STATE_LICENSE:

	case YUM_STATE_CHECKSUM:

	case YUM_STATE_FILE:

		ctx->state = YUM_STATE_BEGIN;

		break;

	}

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

		razor_importer_add_details(ctx->importer, ctx->summary,

					   ctx->description, ctx->url,

					   ctx->license);

		XML_StopParser(ctx->current_parser, XML_TRUE);

		ctx->current_parser = ctx->filelists_parser;

		printf("\rimporting %d/%d", ++ctx->current, ctx->total);

		fflush(stdout);

	}

}

static void

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

{

	struct yum_context *ctx = data;

	switch (ctx->state) {

	case YUM_STATE_PACKAGE_NAME:

	case YUM_STATE_PACKAGE_ARCH:

	case YUM_STATE_SUMMARY:

	case YUM_STATE_DESCRIPTION:

	case YUM_STATE_URL:

	case YUM_STATE_LICENSE:

	case YUM_STATE_CHECKSUM:

	case YUM_STATE_FILE:

		memcpy(ctx->p, s, len);

		ctx->p += len;

		*ctx->p = '\0';

		break;

	}

}

static void

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

{

	struct yum_context *ctx = data;

	const char *pkg, *pkgid;

	int i;

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

		pkg = NULL;

		pkgid = NULL;

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

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

				pkg = atts[i + 1];

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

				pkgid = atts[i + 1];

		}

		if (strcmp(pkgid, ctx->pkgid) != 0)

			fprintf(stderr, "primary.xml and filelists.xml "

				"mismatch for %s: %s vs %s",

				pkg, pkgid, ctx->pkgid);

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

		ctx->state = YUM_STATE_FILE;

		ctx->p = ctx->buffer;

	}

}

static void

yum_filelists_end_element (void *data, const char *name)

{

	struct yum_context *ctx = data;

	ctx->state = YUM_STATE_BEGIN;

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

		XML_StopParser(ctx->current_parser, XML_TRUE);

		ctx->current_parser = ctx->primary_parser;

		razor_importer_finish_package(ctx->importer);

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

		razor_importer_add_file(ctx->importer, ctx->buffer);

}

#define XML_BUFFER_SIZE 4096

struct razor_stream {

	z_stream strm;

	void *in;

	size_t in_length;

};

static int razor_stream_open(struct razor_stream *rs, const char *uri,

			     struct razor_error **error)

{

	rs->strm.zalloc = Z_NULL;

	rs->strm.zfree = Z_NULL;

	rs->strm.opaque = Z_NULL;

	rs->strm.avail_in = 0;

	rs->strm.next_in = Z_NULL;

	if (inflateInit2(&rs->strm, 15 + 16) != Z_OK) {

		razor_set_error(error, RAZOR_GENERAL_ERROR,

				RAZOR_GENERAL_ERROR_FAILED, uri,

				"Failed to initialize inflator");

		return -1;

	}

	rs->in = razor_uri_get_contents(uri, &rs->in_length, 0, error);

	if (!rs->in) {

		(void)inflateEnd(&rs->strm);

		return -1;

	}

	rs->strm.avail_in = rs->in_length;

	rs->strm.next_in = rs->in;

	return 0;

}

static ssize_t

razor_stream_read(struct razor_stream *rs, unsigned char *buf, size_t len)

{

	int r;

	rs->strm.avail_out = len;

	rs->strm.next_out = buf;

	r = inflate(&rs->strm, Z_NO_FLUSH);

	assert(r != Z_STREAM_ERROR);  /* state not clobbered */

	switch (r) {

	case Z_NEED_DICT:

	case Z_DATA_ERROR:

	case Z_MEM_ERROR:

		return -1;

	}

	return len - rs->strm.avail_out;

}

static void razor_stream_close(struct razor_stream *rs)

{

	(void)inflateEnd(&rs->strm);

	(void)razor_uri_free_contents(rs->in, rs->in_length);

}

struct razor_set *

razor_set_create_from_yum(const char *yum_uri)

{

	struct yum_context ctx={0};

	char *uri;

	void *buf;

	ssize_t len;

	XML_ParsingStatus status;

	struct razor_error *error = NULL;

	struct razor_stream primary, filelists;

	ctx.importer = razor_importer_create();

	ctx.state = YUM_STATE_BEGIN;

	ctx.primary_parser = XML_ParserCreate(NULL);

	XML_SetUserData(ctx.primary_parser, &ctx);

	XML_SetElementHandler(ctx.primary_parser,

			      yum_primary_start_element,

			      yum_primary_end_element);

	XML_SetCharacterDataHandler(ctx.primary_parser,

				    yum_character_data);

	ctx.filelists_parser = XML_ParserCreate(NULL);

	XML_SetUserData(ctx.filelists_parser, &ctx);

	XML_SetElementHandler(ctx.filelists_parser,

			      yum_filelists_start_element,

			      yum_filelists_end_element);

	XML_SetCharacterDataHandler(ctx.filelists_parser,

				    yum_character_data);

	uri = razor_path_relative_to_uri(yum_uri, "repodata/primary.xml.gz",

					 &error);

	if (!uri) {

		fprintf(stderr, "%s: %s\n", yum_uri,

			razor_error_get_msg(error));

		razor_error_free(error);

		return NULL;

	}

	if (razor_stream_open(&primary, uri, &error)) {

		fprintf(stderr, "%s: %s\n", uri, razor_error_get_msg(error));

		free(uri);

		return NULL;

	}

	free(uri);

	uri = razor_path_relative_to_uri(yum_uri, "repodata/filelists.xml.gz",

					 &error);

	if (!uri) {

		razor_stream_close(&primary);

		fprintf(stderr, "%s: %s\n", yum_uri,

			razor_error_get_msg(error));

		razor_error_free(error);

		return NULL;

	}

	if (razor_stream_open(&filelists, uri, &error)) {

		razor_stream_close(&primary);

		fprintf(stderr, "%s: %s\n", uri, razor_error_get_msg(error));

		free(uri);

		return NULL;

	}

	free(uri);

	ctx.current_parser = ctx.primary_parser;

	ctx.current = 0;

	do {

		XML_GetParsingStatus(ctx.current_parser, &status);

		switch (status.parsing) {

		case XML_SUSPENDED:

			XML_ResumeParser(ctx.current_parser);

			break;

		case XML_PARSING:

		case XML_INITIALIZED:

			buf = XML_GetBuffer(ctx.current_parser,

					    XML_BUFFER_SIZE);

			if (ctx.current_parser == ctx.primary_parser)

				len = razor_stream_read(&primary, buf,

							XML_BUFFER_SIZE);

			else

				len = razor_stream_read(&filelists, buf,

							XML_BUFFER_SIZE);

			if (len < 0) {

				fprintf(stderr,

					"couldn't read input: %s\n",

					strerror(errno));

				return NULL;

			}

			XML_ParseBuffer(ctx.current_parser, len, len == 0);

			break;

		case XML_FINISHED:

			break;

		}

	} while (status.parsing != XML_FINISHED);

	XML_ParserFree(ctx.primary_parser);

	XML_ParserFree(ctx.filelists_parser);

	razor_stream_close(&primary);

	razor_stream_close(&filelists);

	printf ("\nsaving\n");

	return razor_importer_finish(ctx.importer);

}