path: root/notemap.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 <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sysexits.h>
#include <time.h>
#include <unistd.h>

#ifdef __APPLE__
#include <sys/random.h>
#endif

#ifdef DECLARE_RPP
#define RPP_STDIN 1
char * readpassphrase(const char *prompt, char *buf, size_t bufsiz, int flags);
#else
#include <readpassphrase.h>
#endif

#include "imap.h"

#ifndef DIG_PATH
#define DIG_PATH "dig"
#endif

typedef unsigned char byte;

static void lookup(const char **host, const char **port, const char *domain) {
	static char buf[1024];
	snprintf(buf, sizeof(buf), "_imaps._tcp.%s", domain);

	int rw[2];
	int error = pipe(rw);
	if (error) err(EX_OSERR, "pipe");

	pid_t pid = fork();
	if (pid < 0) err(EX_OSERR, "fork");

	if (!pid) {
		close(rw[0]);
		dup2(rw[1], STDOUT_FILENO);
		dup2(rw[1], STDERR_FILENO);
		close(rw[1]);
#ifdef DRILL_PATH
		execlp(DRILL_PATH, "drill", buf, "SRV", NULL);
		err(EX_CONFIG, "%s", DRILL_PATH);
#else
		execlp(DIG_PATH, "dig", "-t", "SRV", "-q", buf, "+short", NULL);
		err(EX_CONFIG, "%s", DIG_PATH);
#endif
	}

	int status;
	pid = wait(&status);
	if (pid < 0) err(EX_OSERR, "wait");

	close(rw[1]);
	FILE *pipe = fdopen(rw[0], "r");
	if (!pipe) err(EX_IOERR, "fdopen");

	fgets(buf, sizeof(buf), pipe);
	if (ferror(pipe)) err(EX_IOERR, "fgets");

	if (!WIFEXITED(status) || WEXITSTATUS(status)) {
		fprintf(stderr, "%s", buf);
		exit(WEXITSTATUS(status));
	}

	char *ptr = buf;
#ifdef DRILL_PATH
	for (;;) {
		char *line = fgets(buf, sizeof(buf), pipe);
		if (!line || !strcmp(line, ";; ANSWER SECTION:\n")) break;
	}
	fgets(buf, sizeof(buf), pipe);
	if (ferror(pipe)) err(EX_IOERR, "fgets");
	ptr = strrchr(buf, '\t');
	ptr = (ptr ? ptr + 1 : buf);
#endif
	fclose(pipe);

	char *dot = strrchr(ptr, '.');
	if (dot) *dot = '\0';
	strsep(&ptr, " \n"); // priority
	strsep(&ptr, " \n"); // weight
	*port = strsep(&ptr, " \n");
	*host = strsep(&ptr, " \n");
	if (!*host) {
		*host = domain;
		*port = "imaps";
	}
}

static const char *uuidGen(void) {
	byte uuid[16];
	int error = getentropy(uuid, sizeof(uuid));
	if (error) err(EX_OSERR, "getentropy");

	uuid[6] &= 0x0F;
	uuid[6] |= 0x40;
	uuid[8] &= 0x3F;
	uuid[8] |= 0x80;

	static char str[sizeof("00000000-0000-0000-0000-000000000000")];
	snprintf(
		str, sizeof(str),
		"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
		uuid[0], uuid[1], uuid[2], uuid[3],
		uuid[4], uuid[5], uuid[6], uuid[7],
		uuid[8], uuid[9], uuid[10], uuid[11],
		uuid[12], uuid[13], uuid[14], uuid[15]
	);
	return str;
}

static bool uuidCheck(const char *uuid) {
	if (strlen(uuid) != 36) return false;
	if (strspn(uuid, "0123456789abcdef-") != 36) return false;
	return true;
}

#define DATE_FORMAT "%a, %e %b %Y %H:%M:%S %z"

static char *format(const char *from, const char *uuid, const char *path) {
	FILE *note = fopen(path, "r");
	if (!note) err(EX_NOINPUT, "%s", path);

	struct stat status;
	int error = fstat(fileno(note), &status);
	if (error) err(EX_IOERR, "%s", path);

	char date[sizeof("Mon, 00 Jan 0000 00:00:00 -0000")];
	strftime(
		date, sizeof(date), DATE_FORMAT,
		localtime(&status.st_mtime)
	);

	char *buf;
	size_t buflen;
	FILE *msg = open_memstream(&buf, &buflen);
	if (!msg) err(EX_OSERR, "open_memstream");

	fprintf(
		msg,
		"From: <%s>\r\n"
		"Date: %s\r\n"
		"X-Universally-Unique-Identifier: %s\r\n"
		"X-Uniform-Type-Identifier: com.apple.mail-note\r\n"
		"X-Mailer: notemap\r\n"
		"MIME-Version: 1.0\r\n"
		"Content-Type: text/plain; charset=\"utf-8\"\r\n"
		"Content-Transfer-Encoding: quoted-printable\r\n"
		"Subject: =?utf-8?Q?",
		from, date, uuid
	);
	for (const char *ch = path; *ch; ++ch) {
		if ((uint8_t)*ch & 0x80) {
			fprintf(msg, "=%02hhX", (uint8_t)*ch);
		} else if (*ch == ' ') {
			fprintf(msg, "_");
		} else {
			fprintf(msg, "%c", *ch);
		}
	}
	fprintf(msg, "?=\r\n\r\n");

	int ch;
	int len = 0;
	bool ws = false;
	while (EOF != (ch = fgetc(note))) {
		if (len == 75 && ch != '\n') {
			fprintf(msg, "=\r\n");
			len = 0;
		}
		if (ch == '\n') {
			fprintf(msg, "%s\r\n", (ws ? "=\r\n" : ""));
			len = 0;
		} else if (ch == '\t' || (ch >= ' ' && ch <= '~' && ch != '=')) {
			fprintf(msg, "%c", ch);
			len++;
		} else {
			fprintf(msg, "=%02X", ch);
			len += 3;
		}
		ws = (ch == '\t' || ch == ' ');
	}
	if (ferror(note)) err(EX_IOERR, "%s", path);
	fclose(note);

	error = fclose(msg);
	if (error) err(EX_IOERR, "fclose");

	return buf;
}

int main(int argc, char *argv[]) {
	const char *path = ".notemap";
	bool add = false;
	bool force = false;

	const char *user = NULL;
	const char *host = NULL;
	const char *port = "imaps";
	const char *mailbox = "Notes";
	int rppFlags = 0;

	int opt;
	while (0 < (opt = getopt(argc, argv, "M:afh:m:p:u:vw"))) {
		switch (opt) {
			break; case 'M': mailbox = optarg;
			break; case 'a': add = true;
			break; case 'f': force = true;
			break; case 'h': host = optarg;
			break; case 'm': path = optarg;
			break; case 'p': port = optarg;
			break; case 'u': user = optarg;
			break; case 'v': imapVerbose = true;
			break; case 'w': rppFlags |= RPP_STDIN;
			break; default:  return EX_USAGE;
		}
	}
	if (!user) errx(EX_USAGE, "username required");
	argv += optind;
	argc -= optind;
	
	if (!host) {
		const char *domain = strchr(user, '@');
		if (!domain) errx(EX_USAGE, "no domain in username");
		lookup(&host, &port, &domain[1]);
	}

	char buf[1024];
	char *pass = readpassphrase(
		(rppFlags & RPP_STDIN ? "" : "Password: "),
		buf, sizeof(buf), rppFlags
	);
	if (!pass) err(EX_UNAVAILABLE, "readpassphrase");

	if (add) {
		FILE *map = fopen(path, "a");
		if (!map) err(EX_CANTCREAT, "%s", path);
		for (int i = 0; i < argc; ++i) {
			if (access(argv[i], R_OK)) err(EX_NOINPUT, "%s", argv[i]);
			fprintf(map, "%s %s\n", uuidGen(), argv[i]);
			if (ferror(map)) err(EX_IOERR, "%s", path);
		}
		int error = fclose(map);
		if (error) err(EX_IOERR, "%s", path);
	}

	FILE *map = fopen(path, "r");
	if (!map) err(EX_NOINPUT, "%s", path);

	size_t cap = 0;
	char *entry = NULL;
	char *uuid = NULL;
	char *note = NULL;
	uint32_t seq = 0;
	char *message = NULL;

	enum Atom login = 0;
	enum Atom next = atom("next");
	enum Atom create = atom("create");
	enum Atom replace = atom("replace");

	struct IMAP imap = imapOpen(host, port);
	for (
		struct Resp resp;
		resp = imapResp(&imap), resp.resp != AtomBye;
		respFree(resp)
	) {
		if (resp.resp == AtomNo || resp.resp == AtomBad) {
			errx(EX_CONFIG, "%s: %s", Atoms[resp.resp], resp.text);
		}

		if (!login) {
			login = atom("login");
			fprintf(
				imap.w, "%s LOGIN \"%s\" \"%s\"\r\n",
				Atoms[login], user, pass
			);
		}

		if (resp.tag == login) {
			fprintf(imap.w, "%s SELECT \"%s\"\r\n", Atoms[next], mailbox);
		}

		ssize_t len;
		if (resp.tag == next) {
next:
			len = getline(&entry, &cap, map);
			if (ferror(map)) err(EX_IOERR, "%s", path);
			if (len < 1) {
				fprintf(imap.w, "ayy LOGOUT\r\n");
				continue;
			}
			if (entry[len - 1] == '\n') entry[len - 1] = '\0';

			note = entry;
			uuid = strsep(&note, " ");
			if (!note || !uuid || !uuidCheck(uuid)) {
				errx(EX_CONFIG, "invalid map entry: %s", entry);
			}

			if (argc) {
				int i;
				for (i = 0; i < argc; ++i) {
					if (!argv[i]) continue;
					if (strcmp(argv[i], note)) continue;
					argv[i] = NULL;
					break;
				}
				if (i == argc) goto next;
			}

			fprintf(
				imap.w,
				"%s SEARCH HEADER X-Universally-Unique-Identifier \"%s\"\r\n",
				Atoms[AtomSearch], uuid
			);
			continue;
		}

		if (resp.resp == AtomSearch) {
			if (resp.data.len > 1) {
				errx(EX_CONFIG, "multiple messages matching %s", uuid);
			}
			if (resp.data.len) {
				seq = dataCheck(resp.data.ptr[0], Number).number;
				fprintf(
					imap.w, "%s FETCH %" PRIu32 " ENVELOPE\r\n",
					Atoms[AtomFetch], seq
				);
			} else {
				message = format(user, uuid, note);
				fprintf(
					imap.w, "%s APPEND %s (\\Seen) {%zu}\r\n",
					Atoms[create], mailbox, strlen(message)
				);
			}
		}
		
		if (resp.resp == AtomFetch) {
			if (!resp.data.len) errx(EX_PROTOCOL, "missing fetch data");
			struct List items = dataCheck(resp.data.ptr[0], List).list;
			if (items.len < 2) errx(EX_PROTOCOL, "missing fetch data items");
			enum Atom item = dataCheck(items.ptr[0], Atom).atom;
			if (item != AtomEnvelope) continue;

			struct List envelope = dataCheck(items.ptr[1], List).list;
			if (envelope.len < 1) errx(EX_PROTOCOL, "missing envelope date");

			struct tm date = {0};
			char *rest = strptime(
				dataCheck(envelope.ptr[0], String).string, DATE_FORMAT, &date
			);
			if (!rest) errx(EX_PROTOCOL, "invalid envelope date format");

			struct stat status;
			int error = stat(note, &status);
			if (error) err(EX_NOINPUT, "%s", note);

			if (!force && status.st_mtime < mktime(&date)) {
				errx(
					EX_TEMPFAIL,
					"%s: note modified in mailbox; use -f to overwrite",
					note
				);
			} else if (status.st_mtime == mktime(&date)) {
				goto next;
			}

			message = format(user, uuid, note);
			fprintf(
				imap.w, "%s APPEND %s (\\Seen) {%zu}\r\n",
				Atoms[replace], mailbox, strlen(message)
			);
		}

		if (resp.tag == AtomContinue) {
			fprintf(imap.w, "%s\r\n", message);
			free(message);
		}

		if (resp.tag == create) {
			printf("+ %s\n", note);
			goto next;
		}

		if (resp.tag == replace) {
			printf("~ %s\n", note);
			fprintf(
				imap.w, "%s STORE %" PRIu32 " +FLAGS (\\Deleted)\r\n",
				Atoms[next], seq
			);
		}
	}
	fclose(imap.r);
	fclose(imap.w);

	int ret = EX_OK;
	for (int i = 0; i < argc; ++i) {
		if (!argv[i]) continue;
		warnx("%s: unmapped note; use -a to add", argv[i]);
		ret = EX_CONFIG;
	}
	return ret;
}