/* Copyright (C) 2020 C. McEnroe * * 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 . * * 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 #include #include #include #include #include #include #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) { struct Variable vars[] = { { "uid", u32(uid).s }, { "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); if (!quiet) printf("%s\n", 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); if (!quiet) printf("%s\n", 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); if (!quiet) printf("%s\n", 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]); } } static char *searchPath(const char *name, const char *type) { struct Variable vars[] = { { "name", name }, { "type", type }, {0}, }; return templateString(PATH_SEARCH, vars, escapePath); } static int numberCompare(const void *_a, const void *_b) { const struct Data *a = _a; const struct Data *b = _b; return (b->number > a->number) - (b->number < a->number); } struct Sort { size_t index; time_t updated; time_t created; }; static int sortCompare(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); } } size_t concatSearchEntries = 20; void concatSearch( const char *name, struct List threads, const struct Envelope *envelopes ) { char *path = searchPath(name, "atom"); FILE *file = fopen(path, "w"); if (!file) err(EX_CANTCREAT, "%s", path); int error = atomSearchOpen(file, name); if (error) err(EX_IOERR, "%s", path); struct List flat = {0}; listFlatten(&flat, threads); qsort(flat.ptr, flat.len, sizeof(*flat.ptr), numberCompare); for (size_t i = 0; i < flat.len && i < concatSearchEntries; ++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 = atomSearchClose(file) || fclose(file); if (error) err(EX_IOERR, "%s", path); if (!quiet) printf("%s\n", path); free(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), sortCompare); path = searchPath(name, "html"); file = fopen(path, "w"); if (!file) err(EX_CANTCREAT, "%s", path); error = htmlSearchHead(file, name); if (error) err(EX_IOERR, "%s", path); if (concatHead) { error = concatFile(file, concatHead); if (error) err(EX_IOERR, "%s", path); } error = htmlSearchOpen(file, name); 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 = htmlSearchThread(file, envelope, thread); if (error) err(EX_IOERR, "%s", path); } free(order); error = htmlSearchClose(file) || fclose(file); if (error) err(EX_IOERR, "%s", path); if (!quiet) printf("%s\n", path); free(path); }