LordOS — a free, fast and secure GNU/Linux distribution based on Debian, with its own desktop environment: display server and Wayland compositor in C, a React UI engine on QuickJS, and private native apps.
C cdebiandesktop-environmentebpffirewalllandlocklinuxlinux-distributionopen-sourceprivacyquickjsraspberry-pi-5reactsecuritywaylandwayland-compositor
/* imap.c — IMAP4rev1 client and the per-account worker of lord-maild (see maild.h).
*
* Per account: connect (implicit TLS on 993, or STARTTLS on 143), authenticate (AUTHENTICATE
* PLAIN or LOGIN with an app password; XOAUTH2 is prepared but disabled until the user registers
* a client ID, see docs/MAIL.md), list folders (SPECIAL-USE), sync each folder into the cache
* (UIDVALIDITY, UID SEARCH, header + preview fetch in chunks, newest first; CONDSTORE for cheap
* flag updates), then wait in IDLE on the inbox for new mail. Jobs from the UI (open a message,
* flags, move, delete, drafts) interrupt the IDLE through an eventfd. */
#include "maild.h"
#include "imapp.h"
#include "imapio.h"
#include "mime.h"
#include <ctype.h>
#include <errno.h>
#include <poll.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>
#define LINE_MAX_BYTES ((size_t)16 << 20)
#define CHUNK 250
typedef struct {
Account *a;
Conn *c;
int tag;
char caps[4096];
int idle, condstore, move, uidplus, literalplus, special_use, sasl_ir, auth_plain;
char selected[512];
uint32_t exists;
char text[512]; /* text of the last tagged reply */
char code[128]; /* [CODE] of the last tagged reply */
} Imap;
static int has_cap(const Imap *im, const char *cap) {
size_t n = strlen(cap);
for (const char *p = im->caps; (p = strcasestr(p, cap)); p += n)
if ((p == im->caps || p[-1] == ' ') && (p[n] == ' ' || p[n] == 0 || p[n] == '\r' || p[n] == '\n')) return 1;
return 0;
}
static void parse_caps(Imap *im, const char *line) {
const char *c = strcasestr(line, "CAPABILITY");
if (!c) return;
c += 10;
snprintf(im->caps, sizeof im->caps, "%s", c);
for (char *p = im->caps; *p; p++) if (*p == ']' || *p == '\r' || *p == '\n') { *p = 0; break; }
im->idle = has_cap(im, "IDLE");
im->condstore = has_cap(im, "CONDSTORE") || has_cap(im, "QRESYNC");
im->move = has_cap(im, "MOVE");
im->uidplus = has_cap(im, "UIDPLUS");
im->literalplus = has_cap(im, "LITERAL+");
im->special_use = has_cap(im, "SPECIAL-USE");
im->sasl_ir = has_cap(im, "SASL-IR");
im->auth_plain = has_cap(im, "AUTH=PLAIN");
}
/* One complete response (line + literals) as raw bytes. NULL on I/O error. */
static char *read_raw(Imap *im, size_t *len) {
char err[96];
char *r = imap_read_response(im->c, len, LINE_MAX_BYTES, (size_t)64 << 20, err, sizeof err);
if (!r) snprintf(im->text, sizeof im->text, "%s", err);
return r;
}
typedef void (*Untagged)(Imap *im, IResp *r, void *u);
/* Waits for the tagged reply of `tag`, handing untagged responses to cb. 0 OK, 1 NO, 2 BAD, -1 I/O. */
static int wait_tag(Imap *im, int tag, Untagged cb, void *u) {
char want[16];
snprintf(want, sizeof want, "A%04d", tag);
for (;;) {
size_t len;
char *raw = read_raw(im, &len);
if (!raw) return -1;
IResp r;
if (imap_parse(raw, len, &r)) { dbg("unparsable IMAP response: %.120s", raw); free(raw); continue; }
if (!strcmp(r.tag, "*")) {
if (iv_is(r.first, "CAPABILITY") || (r.first && r.first->type == IV_ATOM && r.first->n > 12 && !strncasecmp(r.first->s, "[CAPABILITY", 11))) parse_caps(im, raw);
if (r.first && r.first->next && iv_is(r.first->next, "EXISTS")) im->exists = (uint32_t)iv_num(r.first, 0);
if (cb) cb(im, &r, u);
} else if (!strcmp(r.tag, want)) {
int st = iv_is(r.first, "OK") ? 0 : iv_is(r.first, "NO") ? 1 : 2;
/* keep the human text and a response code */
const char *t = raw + strlen(want) + 1;
snprintf(im->text, sizeof im->text, "%s", t);
for (char *p = im->text; *p; p++) if (*p == '\r' || *p == '\n') { *p = 0; break; }
im->code[0] = 0;
IVal *c = r.first ? r.first->next : NULL;
if (c && c->type == IV_ATOM && c->n && c->s[0] == '[') snprintf(im->code, sizeof im->code, "%.*s", (int)(c->n < 127 ? c->n : 127), c->s);
if (strcasestr(raw, "[CAPABILITY")) parse_caps(im, raw);
imap_resp_free(&r);
free(raw);
return st;
}
imap_resp_free(&r);
free(raw);
}
}
static int cmd(Imap *im, Untagged cb, void *u, const char *fmt, ...) __attribute__((format(printf, 4, 5)));
static int cmd(Imap *im, Untagged cb, void *u, const char *fmt, ...) {
int tag = ++im->tag;
char head[16];
snprintf(head, sizeof head, "A%04d ", tag);
va_list ap;
va_start(ap, fmt);
char small[8192];
int k = vsnprintf(small, sizeof small, fmt, ap);
va_end(ap);
if (k < 0 || (size_t)k >= sizeof small) return -1;
dbg("%s> %.*s", im->a->id, strncasecmp(small, "LOGIN", 5) && strncasecmp(small, "AUTHENTICATE", 12) ? k : 12, small);
if (conn_write(im->c, head, strlen(head)) || conn_write(im->c, small, (size_t)k) || conn_write(im->c, "\r\n", 2)) return -1;
return wait_tag(im, tag, cb, u);
}
static void imap_close(Imap *im) {
if (im->c) { conn_printf(im->c, "A%04d LOGOUT\r\n", ++im->tag); conn_close(im->c); }
im->c = NULL;
im->selected[0] = 0;
}
/* ---- connect + login ---- */
static void need_auth(Account *a) {
if (a->need_auth_sent) return;
a->need_auth_sent = 1;
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"ev\":\"need-auth\",\"acct\":"); jb_str(&b, a->id);
jb_raw(&b, ",\"user\":"); jb_str(&b, a->user);
jb_raw(&b, "}");
send_event(&b);
}
static int imap_open(Imap *im, char *err, size_t ecap) {
Account *a = im->a;
memset((char *)im + sizeof(Account *), 0, sizeof *im - sizeof(Account *));
pthread_mutex_lock(&G);
char *pw = a->password ? strdup(a->password) : NULL;
pthread_mutex_unlock(&G);
if (!strcmp(a->auth, "oauth2")) { free(pw); snprintf(err, ecap, "oauth-disabled"); return -2; }
if (!pw) { need_auth(a); snprintf(err, ecap, "no-password"); return -2; }
TlsInfo ti;
char why[64];
im->c = open_conn(a->id, 0, a->imap.host, a->imap.port, a->imap.sec == SEC_SSL, a->pin_imap, &ti, why, sizeof why);
if (!im->c) { free(pw); snprintf(err, ecap, "%s", why); return !strcmp(why, "cert") ? -3 : -1; }
size_t len;
char *greet = read_raw(im, &len);
if (!greet) { free(pw); snprintf(err, ecap, "greeting"); imap_close(im); return -1; }
parse_caps(im, greet);
free(greet);
if (a->imap.sec == SEC_STARTTLS) {
if (!im->caps[0]) cmd(im, NULL, NULL, "CAPABILITY");
if (!has_cap(im, "STARTTLS") || cmd(im, NULL, NULL, "STARTTLS")) { free(pw); snprintf(err, ecap, "no-starttls"); imap_close(im); return -1; }
if (conn_tls(im->c, a->pin_imap, &ti)) {
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"ev\":\"cert\",\"acct\":"); jb_str(&b, a->id);
jb_raw(&b, ",\"host\":"); jb_str(&b, a->imap.host);
jb_printf(&b, ",\"port\":%d,\"reason\":", a->imap.port); jb_str(&b, ti.reason);
jb_raw(&b, ",\"subject\":"); jb_str(&b, ti.subject);
jb_raw(&b, ",\"issuer\":"); jb_str(&b, ti.issuer);
jb_raw(&b, ",\"sha256\":"); jb_str(&b, ti.sha256);
jb_raw(&b, "}");
if (ti.code) send_event(&b); else jb_free(&b);
free(pw);
snprintf(err, ecap, "%s", ti.code ? "cert" : "tls");
conn_close(im->c);
im->c = NULL;
return ti.code ? -3 : -1;
}
im->caps[0] = 0;
} else if (a->imap.sec == SEC_NONE) {
/* never send a password in the clear */
free(pw);
snprintf(err, ecap, "insecure");
imap_close(im);
return -1;
}
if (!im->caps[0] || !strcasestr(im->caps, "AUTH")) cmd(im, NULL, NULL, "CAPABILITY");
int r;
if (im->auth_plain) {
size_t ul = strlen(a->user), pl = strlen(pw);
unsigned char *raw = malloc(ul + pl + 3);
if (!raw) { free(pw); imap_close(im); return -1; }
raw[0] = 0;
memcpy(raw + 1, a->user, ul);
raw[1 + ul] = 0;
memcpy(raw + 2 + ul, pw, pl);
size_t el;
char *e = b64_encode(raw, ul + pl + 2, 0, &el);
explicit_bzero(raw, ul + pl + 2);
free(raw);
if (!e) { free(pw); imap_close(im); return -1; }
if (im->sasl_ir) r = cmd(im, NULL, NULL, "AUTHENTICATE PLAIN %s", e);
else {
int tag = ++im->tag;
conn_printf(im->c, "A%04d AUTHENTICATE PLAIN\r\n", tag);
size_t ll;
char *plus = read_raw(im, &ll);
if (plus && plus[0] == '+') { conn_write(im->c, e, el); conn_write(im->c, "\r\n", 2); }
free(plus);
r = wait_tag(im, tag, NULL, NULL);
}
explicit_bzero(e, el);
free(e);
} else {
int l1, l2;
char *qu = imap_quote(a->user, im->literalplus, &l1), *qp = imap_quote(pw, im->literalplus, &l2);
if ((l1 || l2) && !im->literalplus) r = 2; /* non-ASCII without LITERAL+: use PLAIN */
else r = qu && qp ? cmd(im, NULL, NULL, "LOGIN %s %s", qu, qp) : -1;
if (qp) { explicit_bzero(qp, strlen(qp)); free(qp); }
free(qu);
}
explicit_bzero(pw, strlen(pw));
free(pw);
if (r) {
SNPF(err, ecap, r < 0 ? "io" : "auth: %s", im->text);
imap_close(im);
if (r > 0) {
/* wrong password: ask again (from the keyring prompt) */
pthread_mutex_lock(&G);
if (a->password) { explicit_bzero(a->password, strlen(a->password)); free(a->password); a->password = NULL; }
pthread_mutex_unlock(&G);
a->need_auth_sent = 0;
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"ev\":\"auth-failed\",\"acct\":"); jb_str(&b, a->id);
jb_raw(&b, ",\"detail\":"); jb_str(&b, im->text);
jb_raw(&b, "}");
send_event(&b);
return -2;
}
return -1;
}
if (!strcasestr(im->caps, "IMAP4")) cmd(im, NULL, NULL, "CAPABILITY");
if (im->condstore && has_cap(im, "ENABLE")) cmd(im, NULL, NULL, "ENABLE CONDSTORE");
return 0;
}
/* ---- folders ---- */
typedef struct { Account *a; char seen[512][160]; int nseen; int gmail; } ListCtx;
static void on_list(Imap *im, IResp *r, void *u) {
ListCtx *lc = u;
if (!iv_is(r->first, "LIST") && !iv_is(r->first, "XLIST")) return;
IVal *flags = iv_at(r->first, 1), *delim = iv_at(r->first, 2), *name = iv_at(r->first, 3);
if (!flags || flags->type != IV_LIST || !name) return;
char fl[512] = "", nm[512], d[8];
size_t o = 0;
for (IVal *k = flags->kid; k; k = k->next) { o += (size_t)snprintf(fl + o, sizeof fl - o, "%.*s ", (int)k->n, k->s); if (o >= sizeof fl) break; }
iv_copy(name, nm, sizeof nm);
iv_copy(delim, d, sizeof d);
if (!nm[0]) return;
if (!strncasecmp(nm, "[Gmail]", 7) || !strncasecmp(nm, "[Google Mail]", 13)) lc->gmail = 1;
pthread_mutex_lock(&G);
Folder *f = store_folder(im->a, !strcasecmp(nm, "INBOX") ? "INBOX" : nm, 1);
if (f) {
char disp[512];
imap_utf7_decode(f->name, disp, sizeof disp);
/* show the last level ("[Gmail]/Sent Mail" → "Sent Mail") */
const char *last = d[0] ? strrchr(disp, d[0]) : NULL;
snprintf(f->display, sizeof f->display, "%s", !strcasecmp(f->name, "INBOX") ? "INBOX" : last ? last + 1 : disp);
snprintf(f->special, sizeof f->special, "%s", special_of(f->name, fl));
f->delim = d[0];
f->noselect = strcasestr(fl, "\\Noselect") || strcasestr(fl, "\\NonExistent");
}
pthread_mutex_unlock(&G);
if (lc->nseen < 512) SNPF(lc->seen[lc->nseen++], sizeof lc->seen[0], "%s", !strcasecmp(nm, "INBOX") ? "INBOX" : nm);
}
static int sync_folder_list(Imap *im) {
ListCtx *lc = calloc(1, sizeof *lc);
if (!lc) return -1;
lc->a = im->a;
int r = im->special_use ? cmd(im, on_list, lc, "LIST \"\" \"*\" RETURN (SPECIAL-USE)") : cmd(im, on_list, lc, "LIST \"\" \"*\"");
if (r == 0) {
pthread_mutex_lock(&G);
FolderList *fl = store_folders(im->a);
for (int i = 0; fl && i < fl->n; i++) {
int found = 0;
for (int k = 0; k < lc->nseen; k++) if (!strcmp(lc->seen[k], fl->f[i]->name)) { found = 1; break; }
if (!found && lc->nseen < 512) { store_clear(im->a, fl->f[i]); free(fl->f[i]->msgs); free(fl->f[i]); fl->f[i] = fl->f[--fl->n]; i--; }
}
/* Gmail files sent mail itself */
if (lc->gmail) im->a->sent_saved = 1;
store_save_folders(im->a);
pthread_mutex_unlock(&G);
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"ev\":\"folders\",\"acct\":"); jb_str(&b, im->a->id); jb_raw(&b, "}");
send_event(&b);
}
free(lc);
return r;
}
/* ---- messages ---- */
static uint32_t parse_flags(const IVal *list) {
uint32_t f = 0;
for (const IVal *k = list && list->type == IV_LIST ? list->kid : NULL; k; k = k->next) {
if (iv_is(k, "\\Seen")) f |= F_SEEN;
else if (iv_is(k, "\\Flagged")) f |= F_FLAGGED;
else if (iv_is(k, "\\Answered")) f |= F_ANSWERED;
else if (iv_is(k, "\\Deleted")) f |= F_DELETED;
else if (iv_is(k, "\\Draft")) f |= F_DRAFT;
else if (iv_is(k, "$Forwarded") || iv_is(k, "Forwarded")) f |= F_FORWARDED;
else if (iv_is(k, "$Junk") || iv_is(k, "Junk")) f |= F_JUNK;
else if (k->type == IV_ATOM && k->n == 7 && !strncasecmp(k->s, "$label", 6) && k->s[6] >= '1' && k->s[6] <= '6') f |= F_LABEL1 << (k->s[6] - '1');
}
return f;
}
static time_t internaldate(const IVal *v) {
char d[64];
iv_copy(v, d, sizeof d);
for (char *p = d; *p; p++) if (*p == '-' && p - d < 12) *p = ' ';
return mime_date(d);
}
typedef struct { Account *a; Folder *f; uint32_t old_uidnext; int added, fresh; JBuf news; int nnews; } FetchCtx;
static void addr_list_text(const char *raw, char *out, size_t cap) {
char dec[2048];
out[0] = 0;
MimeAddr ad[24];
int n = mime_addrs(raw, ad, 24);
size_t o = 0;
for (int i = 0; i < n && o + 4 < cap; i++) {
mime_decode_words(ad[i].name, dec, sizeof dec);
o += (size_t)snprintf(out + o, cap - o, "%s%s <%s>", i ? ", " : "", dec[0] ? dec : "", ad[i].email);
}
if (o >= cap) out[cap - 1] = 0;
}
static void on_fetch(Imap *im, IResp *r, void *u) {
(void)im;
FetchCtx *fc = u;
if (!r->first || !iv_is(r->first->next, "FETCH")) return;
IVal *list = r->first->next->next;
if (!list || list->type != IV_LIST) return;
uint32_t uid = (uint32_t)iv_num(imap_fetch_item(list, "UID"), 0);
if (!uid) return;
IVal *hdr = imap_fetch_item(list, "BODY[HEADER");
IVal *flags = imap_fetch_item(list, "FLAGS");
IVal *ms = imap_fetch_item(list, "MODSEQ");
(void)ms;
if (!hdr) {
/* flags only */
pthread_mutex_lock(&G);
Msg *m = store_msg(fc->f, uid);
if (m && flags) {
uint32_t nf = (m->flags & ~(uint32_t)(F_SEEN | F_FLAGGED | F_ANSWERED | F_DELETED | F_DRAFT | F_FORWARDED | F_JUNK | F_LABELS)) | parse_flags(flags);
if (nf != m->flags) {
if ((nf ^ m->flags) & F_SEEN) fc->f->unread += (nf & F_SEEN) ? -1 : 1;
m->flags = nf;
fc->f->dirty = 1;
fc->f->version++;
fc->added++;
}
}
pthread_mutex_unlock(&G);
return;
}
IVal *text = imap_fetch_item(list, "BODY[TEXT]");
const char *h = hdr->type == IV_STR ? hdr->s : "";
size_t hl = hdr->type == IV_STR ? hdr->n : 0;
char v[4096], dec[2048];
Msg m;
memset(&m, 0, sizeof m);
m.uid = uid;
m.flags = parse_flags(flags);
m.size = (uint32_t)iv_num(imap_fetch_item(list, "RFC822.SIZE"), 0);
char from_name[512] = "", from_email[512] = "", to[1024] = "", cc[1024] = "", subject[1024] = "", msgid[512] = "", irt[512] = "";
if (mime_header(h, hl, "From", v, sizeof v)) {
MimeAddr ad[1];
if (mime_addrs(v, ad, 1) == 1) { snprintf(from_name, sizeof from_name, "%s", ad[0].name); snprintf(from_email, sizeof from_email, "%s", ad[0].email); }
}
if (mime_header(h, hl, "To", v, sizeof v)) addr_list_text(v, to, sizeof to);
if (mime_header(h, hl, "Cc", v, sizeof v)) addr_list_text(v, cc, sizeof cc);
if (mime_header(h, hl, "Subject", v, sizeof v)) { mime_decode_words(v, dec, sizeof dec); SNPF(subject, sizeof subject, "%s", dec); }
mime_header(h, hl, "Message-ID", msgid, sizeof msgid);
mime_header(h, hl, "In-Reply-To", irt, sizeof irt);
char *refs = mime_header_dup(h, hl, "References");
if (refs && strlen(refs) > 2000) {
/* keep the root and the last few ids */
char *last = refs + strlen(refs) - 1200;
char *lt = strchr(last, '<');
char *e = strchr(refs, '>');
if (lt && e && e < lt) { size_t a1 = (size_t)(e - refs + 1); memmove(refs + a1 + 1, lt, strlen(lt) + 1); refs[a1] = ' '; }
}
m.date = mime_header(h, hl, "Date", v, sizeof v) ? mime_date(v) : 0;
if (!m.date) m.date = internaldate(imap_fetch_item(list, "INTERNALDATE"));
if (!m.date) m.date = time(NULL);
char preview[400] = "";
int att = 0;
msg_preview(h, hl, text && text->type == IV_STR ? text->s : "", text && text->type == IV_STR ? text->n : 0, preview, sizeof preview, &att);
m.att = (uint16_t)att;
m.from_name = from_name; m.from_email = from_email; m.to = to; m.cc = cc; m.subject = subject;
m.msgid = msgid; m.inreplyto = irt; m.refs = refs ? refs : (char *)""; m.preview = preview;
pthread_mutex_lock(&G);
int is_new = !store_msg(fc->f, uid);
store_add(fc->a, fc->f, &m);
fc->added++;
pthread_mutex_unlock(&G);
/* new mail notification: new since the last sync, unread, recent */
if (is_new && fc->fresh && uid >= fc->old_uidnext && !(m.flags & F_SEEN) && m.date > time(NULL) - 86400 && fc->nnews < 5) {
if (fc->nnews) jb_raw(&fc->news, ",");
jb_raw(&fc->news, "{\"from\":"); jb_str(&fc->news, from_name[0] ? from_name : from_email);
jb_raw(&fc->news, ",\"subject\":"); jb_str(&fc->news, subject);
jb_raw(&fc->news, ",\"preview\":"); jb_str(&fc->news, preview);
jb_printf(&fc->news, ",\"uid\":%u}", uid);
fc->nnews++;
} else if (is_new && fc->fresh && uid >= fc->old_uidnext && !(m.flags & F_SEEN)) fc->nnews++;
free(refs);
}
typedef struct { uint32_t *u; size_t n, cap; } Uids;
static void on_search(Imap *im, IResp *r, void *u) {
(void)im;
Uids *s = u;
if (!iv_is(r->first, "SEARCH") && !iv_is(r->first, "ESEARCH")) return;
for (IVal *k = r->first->next; k; k = k->next) {
if (k->type == IV_ATOM && iv_is(k, "ALL") && k->next) { /* ESEARCH ... ALL 1:5,7 */
char set[1 << 16];
iv_copy(k->next, set, sizeof set);
uint32_t tmp[8192];
size_t c = imap_parse_uidset(set, tmp, 8192);
for (size_t i = 0; i < c; i++) { if (s->n == s->cap) { s->cap = s->cap ? s->cap * 2 : 1024; uint32_t *nu = realloc(s->u, s->cap * sizeof *nu); if (!nu) return; s->u = nu; } s->u[s->n++] = tmp[i]; }
break;
}
long long x = iv_num(k, -1);
if (x <= 0 || x > 4294967295LL) continue;
if (s->n == s->cap) { s->cap = s->cap ? s->cap * 2 : 1024; uint32_t *nu = realloc(s->u, s->cap * sizeof *nu); if (!nu) return; s->u = nu; }
s->u[s->n++] = (uint32_t)x;
}
}
static int cmp_u32(const void *a, const void *b) { uint32_t x = *(const uint32_t *)a, y = *(const uint32_t *)b; return x < y ? -1 : x > y; }
typedef struct { uint32_t uidvalidity, uidnext; uint64_t hms; int nomodseq; } SelInfo;
static void on_select(Imap *im, IResp *r, void *u) {
(void)im;
SelInfo *si = u;
unsigned long long v;
if (imap_code_num(r, "UIDVALIDITY", &v)) si->uidvalidity = (uint32_t)v;
if (imap_code_num(r, "UIDNEXT", &v)) si->uidnext = (uint32_t)v;
if (imap_code_num(r, "HIGHESTMODSEQ", &v)) si->hms = v;
for (IVal *k = r->first; k; k = k->next) if (k->type == IV_ATOM && k->n >= 9 && !strncasecmp(k->s, "[NOMODSEQ", 9)) si->nomodseq = 1;
}
static int select_folder(Imap *im, const char *name, SelInfo *si, int readonly) {
SelInfo tmp;
if (!si) si = &tmp;
memset(si, 0, sizeof *si);
if (!strcmp(im->selected, name) && si == &tmp) return 0;
int lit;
char *q = imap_quote(name, im->literalplus, &lit);
if (!q) return -1;
im->exists = 0;
int r = cmd(im, on_select, si, "%s %s%s", readonly ? "EXAMINE" : "SELECT", q, im->condstore ? " (CONDSTORE)" : "");
free(q);
if (r == 0) snprintf(im->selected, sizeof im->selected, "%s", name);
else im->selected[0] = 0;
return r;
}
static void folder_event(Account *a, Folder *f, const char *ev) {
JBuf b;
jb_init(&b);
jb_printf(&b, "{\"ev\":\"%s\",\"acct\":", ev);
jb_str(&b, a->id);
jb_raw(&b, ",\"folder\":");
jb_str(&b, f->name);
jb_printf(&b, ",\"total\":%d,\"unread\":%d}", f->n, f->unread);
send_event(&b);
}
static int sync_folder(Imap *im, Folder *f) {
Account *a = im->a;
if (f->noselect) return 0;
SelInfo si;
int r = select_folder(im, f->name, &si, 0);
if (r) return r < 0 ? -1 : 0;
pthread_mutex_lock(&G);
uint32_t old_next = f->uidnext;
int known = f->uidvalidity != 0;
if (f->uidvalidity && si.uidvalidity && f->uidvalidity != si.uidvalidity) { store_clear(a, f); known = 0; }
if (si.uidvalidity) f->uidvalidity = si.uidvalidity;
int unchanged = f->synced && si.uidnext && f->uidnext == si.uidnext && si.hms && f->modseq == si.hms && (uint32_t)f->n == im->exists;
int cached = f->n;
pthread_mutex_unlock(&G);
if (unchanged) return 0;
/* which uids exist on the server */
Uids s = { 0 };
if (im->exists) {
if (cmd(im, on_search, &s, "UID SEARCH ALL")) { free(s.u); return -1; }
qsort(s.u, s.n, sizeof *s.u, cmp_u32);
}
/* gone from the server */
pthread_mutex_lock(&G);
for (int i = f->n - 1; i >= 0; i--) {
uint32_t u = f->msgs[i].uid;
if (!bsearch(&u, s.u, s.n, sizeof *s.u, cmp_u32)) store_remove(a, f, u);
}
/* new ones, newest first */
uint32_t *want = malloc((s.n ? s.n : 1) * sizeof *want);
size_t nw = 0;
for (size_t i = s.n; want && i-- > 0;) if (!store_msg(f, s.u[i])) want[nw++] = s.u[i];
pthread_mutex_unlock(&G);
FetchCtx fc;
memset(&fc, 0, sizeof fc);
fc.a = a; fc.f = f; fc.old_uidnext = old_next; fc.fresh = known && !strcmp(f->special, "inbox");
jb_init(&fc.news);
int rc = 0;
for (size_t off = 0; want && off < nw && !a->stop; off += CHUNK) {
size_t n = nw - off < CHUNK ? nw - off : CHUNK;
uint32_t chunk[CHUNK];
for (size_t i = 0; i < n; i++) chunk[i] = want[off + n - 1 - i]; /* ascending for a compact set */
char set[CHUNK * 12];
imap_uidset(chunk, n, set, sizeof set);
rc = cmd(im, on_fetch, &fc, "UID FETCH %s (UID FLAGS INTERNALDATE RFC822.SIZE BODY.PEEK[HEADER.FIELDS (FROM TO CC SUBJECT DATE MESSAGE-ID IN-REPLY-TO "
"REFERENCES CONTENT-TYPE CONTENT-TRANSFER-ENCODING)] BODY.PEEK[TEXT]<0.2048>)", set);
if (rc < 0) break;
pthread_mutex_lock(&G);
store_save(a, f);
pthread_mutex_unlock(&G);
folder_event(a, f, "changed");
/* a waiting job (opening a message) goes first */
pthread_mutex_lock(&a->qmu);
int urgent = a->jobs && a->jobs->prio >= 5;
pthread_mutex_unlock(&a->qmu);
if (urgent) break;
}
int complete = !want || fc.added >= (int)nw || rc < 0 ? (rc >= 0) : 0;
free(want);
/* flags of what we already had */
if (rc >= 0 && cached) {
if (im->condstore && f->modseq && si.hms && !si.nomodseq)
rc = cmd(im, on_fetch, &fc, "UID FETCH 1:* (UID FLAGS) (CHANGEDSINCE %llu)", (unsigned long long)f->modseq);
else if (s.n <= 6000) rc = cmd(im, on_fetch, &fc, "UID FETCH 1:* (UID FLAGS)");
else {
char set[64];
snprintf(set, sizeof set, "%u:*", s.u[s.n - 2000]);
rc = cmd(im, on_fetch, &fc, "UID FETCH %s (UID FLAGS)", set);
}
}
free(s.u);
pthread_mutex_lock(&G);
if (rc >= 0 && complete) {
if (si.uidnext) f->uidnext = si.uidnext;
if (si.hms) f->modseq = si.hms;
f->synced = 1;
}
f->dirty = 1;
store_save(a, f);
pthread_mutex_unlock(&G);
folder_event(a, f, "changed");
if (fc.nnews) {
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"ev\":\"new\",\"acct\":"); jb_str(&b, a->id);
jb_raw(&b, ",\"name\":"); jb_str(&b, a->name[0] ? a->name : a->email);
jb_raw(&b, ",\"folder\":"); jb_str(&b, f->name);
jb_printf(&b, ",\"count\":%d,\"msgs\":[", fc.nnews);
if (fc.news.p) jb_raw(&b, fc.news.p);
jb_raw(&b, "]}");
send_event(&b);
}
jb_free(&fc.news);
return rc < 0 ? -1 : 0;
}
/* ---- bodies ---- */
typedef struct { char *raw; size_t len; } BodyCtx;
static void on_body(Imap *im, IResp *r, void *u) {
(void)im;
BodyCtx *bc = u;
if (!r->first || !iv_is(r->first->next, "FETCH")) return;
IVal *list = r->first->next->next;
IVal *b = imap_fetch_item(list, "BODY[]");
if (b && b->type == IV_STR && !bc->raw) { bc->raw = malloc(b->n + 1); if (bc->raw) { memcpy(bc->raw, b->s, b->n); bc->raw[b->n] = 0; bc->len = b->n; } }
}
static int fetch_body(Imap *im, Folder *f, uint32_t uid) {
if (select_folder(im, f->name, NULL, 0)) return -1;
BodyCtx bc = { 0 };
int r = cmd(im, on_body, &bc, "UID FETCH %u (BODY.PEEK[])", uid);
if (r || !bc.raw) { free(bc.raw); return r < 0 ? -1 : 1; }
char rel[800];
store_body_path(im->a, f, uid, rel, sizeof rel);
int ok = fs_write(rel, bc.raw, bc.len) == 0;
char *text = msg_body_text(bc.raw, bc.len);
if (text) {
char tr[800];
snprintf(tr, sizeof tr, "%s/f/%s/t/%u", im->a->id, f->dir, uid);
size_t tl = strlen(text) > 16000 ? 16000 : strlen(text);
fs_write(tr, text, tl);
}
pthread_mutex_lock(&G);
Msg *m = store_msg(f, uid);
if (m && ok) {
m->body = 1;
if (text) { text[strlen(text) > 16000 ? 16000 : strlen(text)] = 0; store_msg_text(m, text); store_reindex(im->a, f, m); }
f->dirty = 1;
}
store_save(im->a, f);
pthread_mutex_unlock(&G);
free(text);
free(bc.raw);
return ok ? 0 : -1;
}
/* ---- jobs ---- */
static const char *flag_atom(const char *n) {
static const struct { const char *n, *a; } t[] = {
{ "seen", "\\Seen" }, { "flagged", "\\Flagged" }, { "answered", "\\Answered" }, { "forwarded", "$Forwarded" }, { "junk", "$Junk" },
{ "label1", "$label1" }, { "label2", "$label2" }, { "label3", "$label3" }, { "label4", "$label4" }, { "label5", "$label5" }, { "label6", "$label6" },
};
for (size_t i = 0; i < sizeof t / sizeof t[0]; i++) if (!strcmp(n, t[i].n)) return t[i].a;
return NULL;
}
static void flags_text(const JVal *arr, char *out, size_t cap) {
size_t o = 0;
out[0] = 0;
for (const JVal *x = arr && arr->type == J_ARR ? arr->kid : NULL; x; x = x->next) {
const char *a = x->type == J_STR ? flag_atom(x->str) : NULL;
if (a && o + strlen(a) + 2 < cap) o += (size_t)snprintf(out + o, cap - o, "%s%s", o ? " " : "", a);
}
}
static Folder *special_folder(Account *a, const char *sp) {
FolderList *fl = store_folders(a);
for (int i = 0; fl && i < fl->n; i++) if (!strcmp(fl->f[i]->special, sp)) return fl->f[i];
return NULL;
}
static int do_expunge(Imap *im, const char *set) {
return im->uidplus ? cmd(im, NULL, NULL, "UID EXPUNGE %s", set) : cmd(im, NULL, NULL, "EXPUNGE");
}
static void reply_ok(uint32_t req, const char *extra) {
if (!req) return;
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"ok\":true");
if (extra) jb_raw(&b, extra);
jb_raw(&b, "}");
reply_done(req, &b);
}
static int run_move(Imap *im, Job *j, const char *dest) {
Account *a = im->a;
pthread_mutex_lock(&G);
Folder *f = store_folder(a, j->folder, 0);
pthread_mutex_unlock(&G);
if (!f) return 1;
qsort(j->uids, (size_t)j->nuids, sizeof *j->uids, cmp_u32);
char *set = malloc((size_t)j->nuids * 12 + 16);
if (!set) return -1;
imap_uidset(j->uids, (size_t)j->nuids, set, (size_t)j->nuids * 12 + 16);
if (select_folder(im, f->name, NULL, 0)) { free(set); return -1; }
int r;
if (dest) {
int lit;
char *q = imap_quote(dest, im->literalplus, &lit);
if (!q) { free(set); return -1; }
if (im->move) r = cmd(im, NULL, NULL, "UID MOVE %s %s", set, q);
else {
r = cmd(im, NULL, NULL, "UID COPY %s %s", set, q);
if (!r) r = cmd(im, NULL, NULL, "UID STORE %s +FLAGS.SILENT (\\Deleted)", set);
if (!r) r = do_expunge(im, set);
}
free(q);
} else {
r = cmd(im, NULL, NULL, "UID STORE %s +FLAGS.SILENT (\\Deleted)", set);
if (!r) r = do_expunge(im, set);
}
free(set);
if (r == 0) {
pthread_mutex_lock(&G);
for (int i = 0; i < j->nuids; i++) store_remove(a, f, j->uids[i]);
store_save(a, f);
Folder *df = dest ? store_folder(a, dest, 0) : NULL;
pthread_mutex_unlock(&G);
folder_event(a, f, "changed");
if (df) sync_folder(im, df);
}
return r;
}
static void run_job(Imap *im, Job *j) {
Account *a = im->a;
JDoc d;
int have = j->arg && !json_parse(j->arg, j->arglen, &d, NULL, 0);
const JVal *args = have ? d.root : NULL;
int r = 0;
switch (j->kind) {
case J_SYNC_ALL: {
r = sync_folder_list(im);
if (r < 0) break;
/* inbox first, then the rest (the "all mail" archive only when opened) */
pthread_mutex_lock(&G);
FolderList *fl = store_folders(a);
int n = fl ? fl->n : 0;
char (*names)[512] = n ? malloc((size_t)n * 512) : NULL;
int k = 0;
for (int pass = 0; names && pass < 2; pass++)
for (int i = 0; i < n; i++) {
Folder *f = fl->f[i];
int inbox = !strcmp(f->special, "inbox");
if ((pass == 0) != inbox || !strcmp(f->special, "all") || f->noselect) continue;
snprintf(names[k++], 512, "%s", f->name);
}
pthread_mutex_unlock(&G);
for (int i = 0; i < k && !a->stop; i++) {
pthread_mutex_lock(&G);
Folder *f = store_folder(a, names[i], 0);
pthread_mutex_unlock(&G);
if (f && sync_folder(im, f) < 0) { r = -1; break; }
/* let urgent jobs through between folders */
pthread_mutex_lock(&a->qmu);
Job *urgent = a->jobs && a->jobs->prio >= 5 ? a->jobs : NULL;
if (urgent) a->jobs = urgent->next;
pthread_mutex_unlock(&a->qmu);
if (urgent) { run_job(im, urgent); job_free(urgent); }
}
free(names);
if (r >= 0) {
a->last_sync = time(NULL);
a->initial_done = 1;
/* download the newest bodies of the inbox for offline reading and full-text search */
pthread_mutex_lock(&G);
Folder *in = store_folder(a, "INBOX", 0);
uint32_t pre[40];
int np = 0;
for (int i = in ? in->n - 1 : -1; i >= 0 && np < 40; i--) if (!in->msgs[i].body && in->msgs[i].size < (2u << 20)) pre[np++] = in->msgs[i].uid;
pthread_mutex_unlock(&G);
for (int i = 0; i < np; i++) { Job *pj = job_new(J_FETCH_BODY, 0, 0); if (pj) { snprintf(pj->folder, sizeof pj->folder, "INBOX"); pj->uid = pre[i]; job_push(a, pj); } }
}
break;
}
case J_SYNC_FOLDER: {
pthread_mutex_lock(&G);
Folder *f = store_folder(a, j->folder, 0);
pthread_mutex_unlock(&G);
if (f) r = sync_folder(im, f);
break;
}
case J_FETCH_BODY: {
pthread_mutex_lock(&G);
Folder *f = store_folder(a, j->folder, 0);
Msg *m = f ? store_msg(f, j->uid) : NULL;
int have_body = m && m->body;
pthread_mutex_unlock(&G);
if (!f || !m) { if (j->req) reply_err(j->req, "not-found", ""); break; }
if (!have_body) r = fetch_body(im, f, j->uid);
if (j->req) {
if (r == 0) msg_open_cached(j->req, a, f, j->uid);
else reply_err(j->req, r < 0 ? "offline" : "not-found", im->text);
}
if (r > 0) r = 0;
break;
}
case J_FLAGS: {
pthread_mutex_lock(&G);
Folder *f = store_folder(a, j->folder, 0);
pthread_mutex_unlock(&G);
if (!f) { if (j->req) reply_err(j->req, "no-folder", ""); break; }
char add[256], rem[256];
flags_text(json_get(args, "add"), add, sizeof add);
flags_text(json_get(args, "remove"), rem, sizeof rem);
qsort(j->uids, (size_t)j->nuids, sizeof *j->uids, cmp_u32);
char *set = malloc((size_t)j->nuids * 12 + 16);
if (!set) break;
imap_uidset(j->uids, (size_t)j->nuids, set, (size_t)j->nuids * 12 + 16);
r = select_folder(im, f->name, NULL, 0);
if (!r && add[0]) r = cmd(im, NULL, NULL, "UID STORE %s +FLAGS.SILENT (%s)", set, add);
if (!r && rem[0]) r = cmd(im, NULL, NULL, "UID STORE %s -FLAGS.SILENT (%s)", set, rem);
free(set);
if (r > 0) { if (j->req) reply_err(j->req, "server", im->text); r = 0; break; }
if (!r) reply_ok(j->req, NULL);
break;
}
case J_MOVE: {
const char *to = json_str(args, "to");
if (!to) { reply_err(j->req, "no-target", ""); break; }
r = run_move(im, j, to);
if (r > 0) { reply_err(j->req, "server", im->text); r = 0; } else if (!r) reply_ok(j->req, NULL);
break;
}
case J_DELETE: {
pthread_mutex_lock(&G);
Folder *f = store_folder(a, j->folder, 0);
Folder *trash = special_folder(a, "trash");
char tname[512] = "";
if (trash && trash != f) snprintf(tname, sizeof tname, "%s", trash->name);
pthread_mutex_unlock(&G);
r = run_move(im, j, tname[0] && !json_bool(args, "permanent", 0) ? tname : NULL);
if (r > 0) { reply_err(j->req, "server", im->text); r = 0; } else if (!r) reply_ok(j->req, NULL);
break;
}
case J_CREATE_FOLDER: {
char enc[600];
imap_utf7_encode(j->folder, enc, sizeof enc);
int lit;
char *q = imap_quote(enc, im->literalplus, &lit);
r = q ? cmd(im, NULL, NULL, "CREATE %s", q) : -1;
if (!r) cmd(im, NULL, NULL, "SUBSCRIBE %s", q);
free(q);
if (!r) { sync_folder_list(im); reply_ok(j->req, NULL); }
else if (r > 0) { reply_err(j->req, "server", im->text); r = 0; }
break;
}
case J_APPEND_DRAFT: {
/* a draft (from the UI) or a sent copy (from the sender): append the raw message */
char msgid[300] = "", err[200] = "";
size_t ml = 0;
char *msg = NULL;
const char *target = "drafts";
if (args && json_get(args, "raw")) { target = json_str(args, "target") ? json_str(args, "target") : "sent"; }
if (args && json_str(args, "raw")) { msg = strdup(json_str(args, "raw")); ml = msg ? strlen(msg) : 0; }
else msg = compose_message(a, args, j->fds, j->nfds, &ml, msgid, sizeof msgid, err, sizeof err);
if (!msg) { reply_err(j->req, "compose", err); break; }
pthread_mutex_lock(&G);
Folder *dest = special_folder(a, target);
char dname[512] = "";
if (dest) snprintf(dname, sizeof dname, "%s", dest->name);
pthread_mutex_unlock(&G);
if (!dname[0]) snprintf(dname, sizeof dname, "%s", !strcmp(target, "drafts") ? "Drafts" : "Sent");
int lit;
char *q = imap_quote(dname, im->literalplus, &lit);
int tag = ++im->tag;
const char *fl = !strcmp(target, "drafts") ? "(\\Draft \\Seen)" : "(\\Seen)";
if (im->literalplus) conn_printf(im->c, "A%04d APPEND %s %s {%zu+}\r\n", tag, q ? q : "\"Drafts\"", fl, ml);
else {
conn_printf(im->c, "A%04d APPEND %s %s {%zu}\r\n", tag, q ? q : "\"Drafts\"", fl, ml);
size_t ll;
char *plus = read_raw(im, &ll);
int go = plus && plus[0] == '+';
free(plus);
if (!go) { free(q); free(msg); r = wait_tag(im, tag, NULL, NULL); reply_err(j->req, "append", im->text); break; }
}
conn_write(im->c, msg, ml);
conn_write(im->c, "\r\n", 2);
r = wait_tag(im, tag, NULL, NULL);
free(q);
free(msg);
if (r == 0) {
unsigned long long nu = 0;
const char *ap = strcasestr(im->code, "APPENDUID");
if (ap) { unsigned long long v1; if (sscanf(ap, "APPENDUID %llu %llu", &v1, &nu) != 2) nu = 0; }
/* replace the previous version of a draft */
double old = json_num(args, "replace", 0);
if (old >= 1 && old < 4294967296.0) {
Job tmp = { 0 };
uint32_t u = (uint32_t)old;
tmp.uids = &u; tmp.nuids = 1;
snprintf(tmp.folder, sizeof tmp.folder, "%s", dname);
run_move(im, &tmp, NULL);
tmp.uids = NULL;
}
pthread_mutex_lock(&G);
Folder *df = store_folder(a, dname, 0);
pthread_mutex_unlock(&G);
if (df) sync_folder(im, df);
char extra[64];
snprintf(extra, sizeof extra, ",\"uid\":%llu", nu);
reply_ok(j->req, extra);
} else if (r > 0) { reply_err(j->req, "append", im->text); r = 0; }
break;
}
default: break;
}
if (r < 0 && j->req && j->kind != J_FETCH_BODY) reply_err(j->req, "offline", im->c ? conn_error(im->c) : "connection lost");
if (have) json_free(&d);
}
/* ---- the worker ---- */
static int idle_wait(Imap *im, int *need_sync) {
Account *a = im->a;
*need_sync = 0;
if (strcmp(im->selected, "INBOX") && select_folder(im, "INBOX", NULL, 0)) return -1;
if (!im->idle) {
int w = conn_wait(im->c, a->wake, 5 * 60 * 1000);
if (w < 0) return -1;
if (w == 1) { size_t l; char *x = read_raw(im, &l); if (!x) return -1; free(x); }
*need_sync = w != 2;
return 0;
}
int tag = ++im->tag;
if (conn_printf(im->c, "A%04d IDLE\r\n", tag)) return -1;
size_t len;
char *plus = read_raw(im, &len);
if (!plus) return -1;
int ok = plus[0] == '+';
free(plus);
if (!ok) return wait_tag(im, tag, NULL, NULL) < 0 ? -1 : 0;
acct_status(a, "idle", "");
for (;;) {
int w = conn_wait(im->c, a->wake, 25 * 60 * 1000);
if (w < 0) return -1;
if (w == 1) {
char *x = read_raw(im, &len);
if (!x) return -1;
if (strcasestr(x, "EXISTS") || strcasestr(x, "EXPUNGE") || strcasestr(x, "FETCH")) *need_sync = 1;
int bye = !strncasecmp(x, "* BYE", 5);
free(x);
if (bye) return -1;
if (!*need_sync) continue;
}
break; /* new mail, a job, or the 25-minute refresh */
}
if (conn_write(im->c, "DONE\r\n", 6)) return -1;
return wait_tag(im, tag, NULL, NULL) < 0 ? -1 : 0;
}
void *mail_worker(void *arg) {
Account *a = arg;
Imap im;
memset(&im, 0, sizeof im);
im.a = a;
int backoff = 5;
Job *first = job_new(J_SYNC_ALL, 0, 1);
if (first) job_push(a, first);
time_t last_full = 0;
while (!a->stop) {
if (!im.c) {
char err[200];
acct_status(a, "connecting", "");
int r = imap_open(&im, err, sizeof err);
if (r) {
acct_status(a, r == -2 ? "auth" : r == -3 ? "cert" : "offline", err);
/* fail the queued requests that need the server, keep the rest */
Job *j;
while ((j = job_pop(a))) { if (j->req) { if (j->kind == J_FETCH_BODY) reply_err(j->req, "offline", err); else reply_err(j->req, r == -2 ? "auth" : "offline", err); } job_free(j); }
struct pollfd p = { a->wake, POLLIN, 0 };
poll(&p, 1, r == -2 || r == -3 ? -1 : backoff * 1000); /* auth/cert: until something changes */
uint64_t v;
if (read(a->wake, &v, sizeof v) < 0) { /* timeout */ }
if (r == -1 && backoff < 300) backoff *= 2;
/* offline: try again after the back-off; no password or a bad certificate: wait
* until the user does something (a new password or config wakes us up) */
if (r == -1 && !a->jobs) { Job *s = job_new(J_SYNC_ALL, 0, 1); if (s) { pthread_mutex_lock(&a->qmu); s->next = a->jobs; a->jobs = s; pthread_mutex_unlock(&a->qmu); } }
continue;
}
backoff = 5;
acct_status(a, "sync", "");
last_full = time(NULL);
}
uint64_t v;
if (read(a->wake, &v, sizeof v) < 0) { /* nothing signalled */ }
Job *j = job_pop(a);
if (j) {
if (j->kind == J_SYNC_ALL) acct_status(a, "sync", "");
run_job(&im, j);
job_free(j);
if (im.c && conn_error(im.c)[0] && (strstr(conn_error(im.c), "closed") || strstr(conn_error(im.c), "timeout") || strstr(conn_error(im.c), "write"))) {
conn_close(im.c); im.c = NULL;
acct_status(a, "offline", "connection lost");
}
continue;
}
if (time(NULL) - last_full > 15 * 60) { Job *s = job_new(J_SYNC_ALL, 0, 1); if (s) job_push(a, s); last_full = time(NULL); continue; }
int need_sync;
if (idle_wait(&im, &need_sync)) { conn_close(im.c); im.c = NULL; continue; }
if (need_sync) {
pthread_mutex_lock(&G);
Folder *in = store_folder(a, "INBOX", 0);
pthread_mutex_unlock(&G);
if (in && sync_folder(&im, in) < 0) { conn_close(im.c); im.c = NULL; }
}
}
if (im.c) imap_close(&im);
return NULL;
}
int imap_append_sent(Account *a, const char *msg, size_t len) {
/* the sender hands the copy to the account's worker */
JBuf b;
jb_init(&b);
jb_raw(&b, "{\"raw\":");
jb_strn(&b, msg, len);
jb_raw(&b, ",\"target\":\"sent\"}");
if (b.oom) { jb_free(&b); return -1; }
Job *j = job_new(J_APPEND_DRAFT, 0, 6);
if (!j) { jb_free(&b); return -1; }
j->arg = b.p;
j->arglen = b.n;
job_push(a, j);
return 0;
}