/*-

 * Copyright (c) 2014 Sebastian Freundt

 * Author: Sebastian Freundt  <devel@fresse.org>

 *

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "archive_platform.h"

__FBSDID("$FreeBSD$");

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

#include <stdio.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#endif

#ifdef HAVE_TIME_H

#include <time.h>

#endif

#include "archive.h"

#include "archive_entry.h"

#include "archive_entry_locale.h"

#include "archive_private.h"

#include "archive_random_private.h"

#include "archive_write_private.h"

struct warc_s {

	unsigned int omit_warcinfo:1;

	time_t now;

	mode_t typ;

	unsigned int rng;

	/* populated size */

	uint64_t populz;

};

static const char warcinfo[] =

    "software: libarchive/" ARCHIVE_VERSION_ONLY_STRING "\r\n"

    "format: WARC file version 1.0\r\n";

typedef enum {

	WT_NONE,

	/* warcinfo */

	WT_INFO,

	/* metadata */

	WT_META,

	/* resource */

	WT_RSRC,

	/* request, unsupported */

	WT_REQ,

	/* response, unsupported */

	WT_RSP,

	/* revisit, unsupported */

	WT_RVIS,

	/* conversion, unsupported */

	WT_CONV,

	/* continuation, unsupported at the moment */

	WT_CONT,

	/* invalid type */

	LAST_WT

} warc_type_t;

typedef struct {

	warc_type_t type;

	const char *tgturi;

	const char *recid;

	time_t rtime;

	time_t mtime;

	const char *cnttyp;

	uint64_t cntlen;

} warc_essential_hdr_t;

typedef struct {

	unsigned int u[4U];

} warc_uuid_t;

static int _warc_options(struct archive_write*, const char *key, const char *v);

static int _warc_header(struct archive_write *a, struct archive_entry *entry);

static ssize_t _warc_data(struct archive_write *a, const void *buf, size_t sz);

static int _warc_finish_entry(struct archive_write *a);

static int _warc_close(struct archive_write *a);

static int _warc_free(struct archive_write *a);

/* private routines */

static ssize_t _popul_ehdr(struct archive_string *t, size_t z, warc_essential_hdr_t);

static int _gen_uuid(warc_uuid_t *tgt);

/*

 * Set output format to ISO 28500 (aka WARC) format.

 */

int

archive_write_set_format_warc(struct archive *_a)

{

	struct archive_write *a = (struct archive_write *)_a;

	struct warc_s *w;

	archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,

	    ARCHIVE_STATE_NEW, "archive_write_set_format_warc");

	/* If another format was already registered, unregister it. */

	if (a->format_free != NULL) {

		(a->format_free)(a);

	}

	w = malloc(sizeof(*w));

	if (w == NULL) {

		archive_set_error(&a->archive, ENOMEM,

		    "Can't allocate warc data");

		return (ARCHIVE_FATAL);

	}

	/* by default we're emitting a file wide header */

	w->omit_warcinfo = 0U;

	/* obtain current time for date fields */

	w->now = time(NULL);

	/* reset file type info */

	w->typ = 0;

	/* also initialise our rng */

	w->rng = (unsigned int)w->now;

	a->format_data = w;

	a->format_name = "WARC/1.0";

	a->format_options = _warc_options;

	a->format_write_header = _warc_header;

	a->format_write_data = _warc_data;

	a->format_close = _warc_close;

	a->format_free = _warc_free;

	a->format_finish_entry = _warc_finish_entry;

	a->archive.archive_format = ARCHIVE_FORMAT_WARC;

	a->archive.archive_format_name = "WARC/1.0";

	return (ARCHIVE_OK);

}

/* archive methods */

static int

_warc_options(struct archive_write *a, const char *key, const char *val)

{

	struct warc_s *w = a->format_data;

	if (strcmp(key, "omit-warcinfo") == 0) {

		if (val == NULL || strcmp(val, "true") == 0) {

			/* great */

			w->omit_warcinfo = 1U;

			return (ARCHIVE_OK);

		}

	}

	/* Note: The "warn" return is just to inform the options

	 * supervisor that we didn't handle it.  It will generate

	 * a suitable error if no one used this option. */

	return (ARCHIVE_WARN);

}

static int

_warc_header(struct archive_write *a, struct archive_entry *entry)

{

	struct warc_s *w = a->format_data;

	struct archive_string hdr;

#define MAX_HDR_SIZE 512

	/* check whether warcinfo record needs outputting */

	if (!w->omit_warcinfo) {

		ssize_t r;

		warc_essential_hdr_t wi = {

			WT_INFO,

			/*uri*/NULL,

			/*urn*/NULL,

			/*rtm*/0,

			/*mtm*/0,

			/*cty*/"application/warc-fields",

			/*len*/sizeof(warcinfo) - 1U,

		};

		wi.rtime = w->now;

		wi.mtime = w->now;

		archive_string_init(&hdr);

		r = _popul_ehdr(&hdr, MAX_HDR_SIZE, wi);

		if (r >= 0) {

			/* jackpot! */

			/* now also use HDR buffer for the actual warcinfo */

			archive_strncat(&hdr, warcinfo, sizeof(warcinfo) -1);

			/* append end-of-record indicator */

			archive_strncat(&hdr, "\r\n\r\n", 4);

			/* write to output stream */

			__archive_write_output(a, hdr.s, archive_strlen(&hdr));

		}

		/* indicate we're done with file header writing */

		w->omit_warcinfo = 1U;

		archive_string_free(&hdr);

	}

	if (archive_entry_pathname(entry) == NULL) {

		archive_set_error(&a->archive, EINVAL,

		    "Invalid filename");

		return (ARCHIVE_WARN);

	}

	w->typ = archive_entry_filetype(entry);

	w->populz = 0U;

	if (w->typ == AE_IFREG) {

		warc_essential_hdr_t rh = {

			WT_RSRC,

			/*uri*/NULL,

			/*urn*/NULL,

			/*rtm*/0,

			/*mtm*/0,

			/*cty*/NULL,

			/*len*/0,

		};

		ssize_t r;

		rh.tgturi = archive_entry_pathname(entry);

		rh.rtime = w->now;

		rh.mtime = archive_entry_mtime(entry);

		rh.cntlen = (size_t)archive_entry_size(entry);

		archive_string_init(&hdr);

		r = _popul_ehdr(&hdr, MAX_HDR_SIZE, rh);

		if (r < 0) {

			/* don't bother */

			archive_set_error(

				&a->archive,

				ARCHIVE_ERRNO_FILE_FORMAT,

				"cannot archive file");

			return (ARCHIVE_WARN);

		}

		/* otherwise append to output stream */

		__archive_write_output(a, hdr.s, r);

		/* and let subsequent calls to _data() know about the size */

		w->populz = rh.cntlen;

		archive_string_free(&hdr);

		return (ARCHIVE_OK);

	}

	/* just resort to erroring as per Tim's advice */

	archive_set_error(

		&a->archive,

		ARCHIVE_ERRNO_FILE_FORMAT,

		"WARC can only process regular files");

	return (ARCHIVE_FAILED);

}

static ssize_t

_warc_data(struct archive_write *a, const void *buf, size_t len)

{

	struct warc_s *w = a->format_data;

	if (w->typ == AE_IFREG) {

		int rc;

		/* never write more bytes than announced */

		if (len > w->populz) {

			len = (size_t)w->populz;

		}

		/* now then, out we put the whole shebang */

		rc = __archive_write_output(a, buf, len);

		if (rc != ARCHIVE_OK) {

			return rc;

		}

	}

	return len;

}

static int

_warc_finish_entry(struct archive_write *a)

{

	static const char _eor[] = "\r\n\r\n";

	struct warc_s *w = a->format_data;

	if (w->typ == AE_IFREG) {

		int rc = __archive_write_output(a, _eor, sizeof(_eor) - 1U);

		if (rc != ARCHIVE_OK) {

			return rc;

		}

	}

	/* reset type info */

	w->typ = 0;

	return (ARCHIVE_OK);

}

static int

_warc_close(struct archive_write *a)

{

	(void)a; /* UNUSED */

	return (ARCHIVE_OK);

}

static int

_warc_free(struct archive_write *a)

{

	struct warc_s *w = a->format_data;

	free(w);

	a->format_data = NULL;

	return (ARCHIVE_OK);

}

/* private routines */

static void

xstrftime(struct archive_string *as, const char *fmt, time_t t)

{

/** like strftime(3) but for time_t objects */

	struct tm *rt;

#if defined(HAVE_GMTIME_R) || defined(HAVE__GMTIME64_S)

	struct tm timeHere;

#endif

	char strtime[100];

	size_t len;

#ifdef HAVE_GMTIME_R

	if ((rt = gmtime_r(&t, &timeHere)) == NULL)

		return;

#elif defined(HAVE__GMTIME64_S)

	_gmtime64_s(&timeHere, &t);

#else

	if ((rt = gmtime(&t)) == NULL)

		return;

#endif

	/* leave the hard yacker to our role model strftime() */

	len = strftime(strtime, sizeof(strtime)-1, fmt, rt);

	archive_strncat(as, strtime, len);

}

static ssize_t

_popul_ehdr(struct archive_string *tgt, size_t tsz, warc_essential_hdr_t hdr)

{

	static const char _ver[] = "WARC/1.0\r\n";

	static const char * const _typ[LAST_WT] = {

		NULL, "warcinfo", "metadata", "resource", NULL

	};

	char std_uuid[48U];

	if (hdr.type == WT_NONE || hdr.type > WT_RSRC) {

		/* brilliant, how exactly did we get here? */

		return -1;

	}

	archive_strcpy(tgt, _ver);

	archive_string_sprintf(tgt, "WARC-Type: %s\r\n", _typ[hdr.type]);

	if (hdr.tgturi != NULL) {

		/* check if there's a xyz:// */

		static const char _uri[] = "";

		static const char _fil[] = "file://";

		const char *u;

		char *chk = strchr(hdr.tgturi, ':');

		if (chk != NULL && chk[1U] == '/' && chk[2U] == '/') {

			/* yep, it's definitely a URI */

			u = _uri;

		} else {

			/* hm, best to prepend file:// then */

			u = _fil;

		}

		archive_string_sprintf(tgt,

			"WARC-Target-URI: %s%s\r\n", u, hdr.tgturi);

	}

	/* record time is usually when the http is sent off,

	 * just treat the archive writing as such for a moment */

	xstrftime(tgt, "WARC-Date: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.rtime);

	/* while we're at it, record the mtime */

	xstrftime(tgt, "Last-Modified: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.mtime);

	if (hdr.recid == NULL) {

		/* generate one, grrrr */

		warc_uuid_t u;

		_gen_uuid(&u);

		/* Unfortunately, archive_string_sprintf does not

		 * handle the minimum number following '%'.

		 * So we have to use snprintf function here instead

		 * of archive_string_snprintf function. */

#if defined(_WIN32) && !defined(__CYGWIN__) && !( defined(_MSC_VER) && _MSC_VER >= 1900)

#define snprintf _snprintf

#endif

		snprintf(

			std_uuid, sizeof(std_uuid),

			"<urn:uuid:%08x-%04x-%04x-%04x-%04x%08x>",

			u.u[0U],

			u.u[1U] >> 16U, u.u[1U] & 0xffffU,

			u.u[2U] >> 16U, u.u[2U] & 0xffffU,

			u.u[3U]);

		hdr.recid = std_uuid;

	}

	/* record-id is mandatory, fingers crossed we won't fail */

	archive_string_sprintf(tgt, "WARC-Record-ID: %s\r\n", hdr.recid);

	if (hdr.cnttyp != NULL) {

		archive_string_sprintf(tgt, "Content-Type: %s\r\n", hdr.cnttyp);

	}

	/* next one is mandatory */

	archive_string_sprintf(tgt, "Content-Length: %ju\r\n", (uintmax_t)hdr.cntlen);

	/**/

	archive_strncat(tgt, "\r\n", 2);

	return (archive_strlen(tgt) >= tsz)? -1: (ssize_t)archive_strlen(tgt);

}

static int

_gen_uuid(warc_uuid_t *tgt)

{

	archive_random(tgt->u, sizeof(tgt->u));

	/* obey uuid version 4 rules */

	tgt->u[1U] &= 0xffff0fffU;

	tgt->u[1U] |= 0x4000U;

	tgt->u[2U] &= 0x3fffffffU;

	tgt->u[2U] |= 0x80000000U;

	return 0;

}

/* archive_write_set_format_warc.c ends here */