path: root/concat.c

/* Copyright (C) 2020  C. McEnroe <june@causal.agency>
 *
 * 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 3 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, see <https://www.gnu.org/licenses/>.
 *
 * Additional permission under GNU GPL version 3 section 7:
 *
 * If you modify this Program, or any covered work, by linking or
 * combining it with OpenSSL (or a modified version of that library),
 * containing parts covered by the terms of the OpenSSL License and the
 * original SSLeay license, the licensors of this Program grant you
 * additional permission to convey the resulting work. Corresponding
 * Source for a non-source form of such a combination shall include the
 * source code for the parts of OpenSSL used as well as that of the
 * covered work.
 */

#include <err.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sysexits.h>

#include "archive.h"
#include "imap.h"

static uint32_t threadRoot(struct List thread) {
	if (!thread.len) errx(EX_PROTOCOL, "empty thread");
	while (thread.ptr[0].type == List) {
		thread = thread.ptr[0].list;
		if (!thread.len) errx(EX_PROTOCOL, "empty subthread");
	}
	return dataCheck(thread.ptr[0], Number).number;
}

void concatFetch(FILE *imap, enum Atom tag, struct List threads) {
	fprintf(imap, "%s UID FETCH ", Atoms[tag]);
	for (size_t i = 0; i < threads.len; ++i) {
		uint32_t root = threadRoot(dataCheck(threads.ptr[i], List).list);
		fprintf(imap, "%s%" PRIu32, (i ? "," : ""), root);
	}
	fprintf(imap, " (UID ENVELOPE)\r\n");
}

void concatData(
	struct List threads, struct Envelope *envelopes, struct List items
) {
	uint32_t uid = 0;
	struct List envelope = {0};
	for (size_t i = 0; i + 1 < items.len; i += 2) {
		enum Atom name = dataCheck(items.ptr[i], Atom).atom;
		struct Data data = items.ptr[i + 1];
		switch (name) {
			break; case AtomUID: uid = dataCheck(data, Number).number;
			break; case AtomEnvelope: envelope = dataCheck(data, List).list;
			break; default:;
		}
	}
	if (!uid) errx(EX_PROTOCOL, "missing UID data item");
	if (!envelope.len) errx(EX_PROTOCOL, "missing ENVELOPE data item");

	for (size_t i = 0; i < threads.len; ++i) {
		struct List thread = dataCheck(threads.ptr[i], List).list;
		if (threadRoot(thread) == uid) {
			parseEnvelope(&envelopes[i], envelope);
			return;
		}
	}
	errx(EX_TEMPFAIL, "no thread with root UID %" PRIu32, uid);
}

static char *uidPath(uint32_t uid, const char *type) {
	char str[32];
	snprintf(str, sizeof(str), "%" PRIu32, uid);
	struct Variable vars[] = {
		{ "uid", str },
		{ "type", type },
		{0},
	};
	return templateString(PATH_UID, vars, escapePath);
}

static time_t uidNewest(struct List uids, const char *type) {
	time_t newest = 0;
	for (size_t i = 0; i < uids.len; ++i) {
		char *path = uidPath(dataCheck(uids.ptr[i], Number).number, type);
		struct stat status;
		int error = stat(path, &status);
		if (error) err(EX_DATAERR, "%s", path);
		if (status.st_mtime > newest) newest = status.st_mtime;
		free(path);
	}
	return newest;
}

static int concatFile(FILE *dst, const char *path) {
	char buf[4096];
	FILE *src = fopen(path, "r");
	if (!src) err(EX_DATAERR, "%s", path);
	for (size_t len; (len = fread(buf, 1, sizeof(buf), src));) {
		size_t n = fwrite(buf, len, 1, dst);
		if (!n) return -1;
	}
	fclose(src);
	return 0;
}

static int concatHTML(FILE *file, struct List thread) {
	int error;
	for (size_t i = 0; i < thread.len; ++i) {
		if (thread.ptr[i].type == List) {
			error = 0
				|| htmlSubthreadOpen(file, thread.ptr[i].list)
				|| concatHTML(file, thread.ptr[i].list)
				|| htmlSubthreadClose(file);
		} else {
			uint32_t uid = dataCheck(thread.ptr[i], Number).number;
			char *path = uidPath(uid, "html");
			error = concatFile(file, path);
			free(path);
		}
		if (error) return error;
	}
	return 0;
}

static char *threadPath(const char *messageID, const char *type) {
	struct Variable vars[] = {
		{ "messageID", messageID },
		{ "type", type },
		{0},
	};
	return templateString(PATH_THREAD, vars, escapePath);
}

const char *concatHead;

static void concatThread(struct List thread, const struct Envelope *envelope) {
	struct List flat = {0};
	listFlatten(&flat, thread);

	int error;
	FILE *file;
	char *path;
	struct stat status;

	path = threadPath(envelope->messageID, "mbox");
	error = stat(path, &status);
	if (error || status.st_mtime < uidNewest(flat, "mbox")) {
		file = fopen(path, "w");
		if (!file) err(EX_CANTCREAT, "%s", path);

		for (size_t i = 0; i < flat.len; ++i) {
			uint32_t uid = dataCheck(flat.ptr[i], Number).number;
			char *src = uidPath(uid, "mbox");
			error = concatFile(file, src);
			if (error) err(EX_IOERR, "%s", path);
			free(src);
		}

		error = fclose(file);
		if (error) err(EX_IOERR, "%s", path);
	}
	free(path);

	path = threadPath(envelope->messageID, "atom");
	error = stat(path, &status);
	if (error || status.st_mtime < uidNewest(flat, "atom")) {
		FILE *file = fopen(path, "w");
		if (!file) err(EX_CANTCREAT, "%s", path);

		error = atomThreadOpen(file, envelope);
		if (error) err(EX_IOERR, "%s", path);

		for (size_t i = 0; i < flat.len; ++i) {
			uint32_t uid = dataCheck(flat.ptr[i], Number).number;
			char *src = uidPath(uid, "atom");
			error = concatFile(file, src);
			if (error) err(EX_IOERR, "%s", path);
			free(src);
		}

		error = atomThreadClose(file) || fclose(file);
		if (error) err(EX_IOERR, "%s", path);
	}
	free(path);

	path = threadPath(envelope->messageID, "html");
	error = stat(path, &status);
	if (error || status.st_mtime < uidNewest(flat, "html")) {
		FILE *file = fopen(path, "w");
		if (!file) err(EX_CANTCREAT, "%s", path);

		error = htmlThreadHead(file, envelope);
		if (error) err(EX_IOERR, "%s", path);

		if (concatHead) {
			error = concatFile(file, concatHead);
			if (error) err(EX_IOERR, "%s", path);
		}

		error = 0
			|| htmlThreadOpen(file, envelope)
			|| concatHTML(file, thread)
			|| htmlThreadClose(file)
			|| fclose(file);
		if (error) err(EX_IOERR, "%s", path);
	}
	free(path);

	listFree(flat);
}

void concatThreads(struct List threads, const struct Envelope *envelopes) {
	for (size_t i = 0; i < threads.len; ++i) {
		concatThread(dataCheck(threads.ptr[i], List).list, &envelopes[i]);
	}
}

struct Sort {
	size_t index;
	time_t updated;
	time_t created;
};

static int compar(const void *_a, const void *_b) {
	const struct Sort *a = _a;
	const struct Sort *b = _b;
	if (a->updated == b->updated) {
		return (a->created > b->created) - (a->created < b->created);
	} else {
		return (a->updated > b->updated) - (a->updated < b->updated);
	}
}

void concatIndex(struct List threads, const struct Envelope *envelopes) {
	const char *path = "index.atom";
	FILE *file = fopen(path, "w");
	if (!file) err(EX_CANTCREAT, "%s", path);

	int error = atomIndexOpen(file);
	if (error) err(EX_IOERR, "%s", path);

	struct List flat = {0};
	listFlatten(&flat, threads);
	for (size_t i = flat.len - 1; i < flat.len; --i) {
		uint32_t uid = dataCheck(flat.ptr[i], Number).number;
		char *src = uidPath(uid, "atom");
		error = concatFile(file, src);
		if (error) err(EX_IOERR, "%s", path);
		free(src);
	}
	listFree(flat);

	error = atomIndexClose(file) || fclose(file);
	if (error) err(EX_IOERR, "%s", path);

	struct Sort *order = calloc(threads.len, sizeof(*order));
	if (!order) err(EX_OSERR, "calloc");

	for (size_t i = 0; i < threads.len; ++i) {
		struct stat status;
		char *path = threadPath(envelopes[i].messageID, "html");
		int error = stat(path, &status);
		if (error) err(EX_DATAERR, "%s", path);
		free(path);

		order[i].index = i;
		order[i].created = envelopes[i].time;
		order[i].updated = status.st_mtime;
	}
	qsort(order, threads.len, sizeof(*order), compar);

	path = "index.html";
	file = fopen(path, "w");
	if (!file) err(EX_CANTCREAT, "%s", path);

	error = htmlIndexHead(file);
	if (error) err(EX_IOERR, "%s", path);

	if (concatHead) {
		error = concatFile(file, concatHead);
		if (error) err(EX_IOERR, "%s", path);
	}

	error = htmlIndexOpen(file);
	if (error) err(EX_IOERR, "%s", path);

	for (size_t i = threads.len - 1; i < threads.len; --i) {
		const struct Envelope *envelope = &envelopes[order[i].index];
		struct List thread = dataCheck(threads.ptr[order[i].index], List).list;
		error = htmlIndexThread(file, envelope, thread);
		if (error) err(EX_IOERR, "%s", path);
	}
	free(order);

	error = htmlIndexClose(file) || fclose(file);
	if (error) err(EX_IOERR, "%s", path);
}