Skip to content

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.

47.4 KB
Raw Blame
/* ical.c — see ical.h. */
#include "ical.h"
#include "../ui/tzif.h"

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>

/* Bounded integer from untrusted text (strtol with range and end checks; never atoi).
 * Leading sign allowed; parsing stops at the first non-digit (reported in *end if given). */
static int bnum(const char *s, long lo, long hi, long dflt, const char **end) {
    char *e;
    errno = 0;
    long v = strtol(s ? s : "", &e, 10);
    if (end) *end = e;
    if (!s || e == s || errno == ERANGE || v < lo || v > hi) return (int)dflt;
    return (int)v;
}

/* ---- content lines ---- */

static IcComp *comp_new(const char *name, IcComp *parent) {
    IcComp *c = calloc(1, sizeof *c);
    if (!c) return NULL;
    snprintf(c->name, sizeof c->name, "%s", name);
    for (char *p = c->name; *p; p++) *p = (char)toupper((unsigned char)*p);
    c->parent = parent;
    if (parent) { if (parent->last) parent->last->next = c; else parent->kid = c; parent->last = c; }
    return c;
}

void ic_free(IcComp *root) {
    IcComp *n = root;
    while (n) {
        if (n->kid) { IcComp *k = n->kid; n->kid = NULL; n = k; continue; }
        IcComp *next = n->next, *parent = n->parent;
        int last = n == root;
        for (int i = 0; i < n->nprops; i++) { free(n->props[i].params); free(n->props[i].value); }
        free(n->props);
        free(n);
        if (last) break;
        n = next ? next : parent;
    }
}

static int add_prop(IcComp *c, const char *line, size_t n, long *total) {
    if (++*total > IC_MAX_PROPS * 50) return -1;
    if (c->nprops >= IC_MAX_PROPS) return 0;
    /* name[;params]:value (':' inside a quoted parameter does not count) */
    size_t i = 0;
    while (i < n && line[i] != ';' && line[i] != ':') i++;
    if (i == n || i == 0) return 0;
    size_t name_end = i;
    size_t params_start = i, colon = i;
    if (line[i] == ';') {
        int q = 0;
        for (colon = i; colon < n; colon++) { if (line[colon] == '"') q = !q; else if (line[colon] == ':' && !q) break; }
        if (colon >= n) return 0;
        params_start = i + 1;
    }
    if (c->nprops == c->capprops) {
        int nc = c->capprops ? c->capprops * 2 : 16;
        IcProp *np = realloc(c->props, (size_t)nc * sizeof *np);
        if (!np) return -1;
        c->props = np;
        c->capprops = nc;
    }
    IcProp *p = &c->props[c->nprops];
    memset(p, 0, sizeof *p);
    /* group prefix ("item1.EMAIL") */
    const char *nm = line;
    size_t nl = name_end;
    const char *dot = memchr(line, '.', name_end);
    if (dot) {
        size_t gl = (size_t)(dot - line);
        if (gl >= sizeof p->group) gl = sizeof p->group - 1;
        memcpy(p->group, line, gl);
        nm = dot + 1;
        nl = name_end - (size_t)(nm - line);
    }
    if (nl >= sizeof p->name) nl = sizeof p->name - 1;
    for (size_t k = 0; k < nl; k++) p->name[k] = (char)toupper((unsigned char)nm[k]);
    p->name[nl] = 0;
    size_t pl = colon > params_start ? colon - params_start : 0;
    p->params = malloc(pl + 1);
    p->value = malloc(n - colon);
    if (!p->params || !p->value) { free(p->params); free(p->value); return -1; }
    memcpy(p->params, line + params_start, pl);
    p->params[pl] = 0;
    memcpy(p->value, line + colon + 1, n - colon - 1);
    p->value[n - colon - 1] = 0;
    c->nprops++;
    return 0;
}

IcComp *ic_parse(const char *s, size_t len, const char **err) {
    IcComp *root = comp_new("", NULL);
    if (!root) { if (err) *err = "memory"; return NULL; }
    IcComp *cur = root;
    int depth = 0;
    long lines = 0, total = 0;
    char *logical = NULL;
    size_t ll = 0, lcap = 0;
    size_t i = 0;
    const char *e = NULL;
    if (len >= 3 && (unsigned char)s[0] == 0xef && (unsigned char)s[1] == 0xbb && (unsigned char)s[2] == 0xbf) i = 3;
    for (;;) {
        /* next physical line */
        int have = i < len;
        size_t a = i, b = i;
        if (have) {
            while (b < len && s[b] != '\n') b++;
            i = b < len ? b + 1 : len;
            if (b > a && s[b - 1] == '\r') b--;
            if (++lines > IC_MAX_LINES) { e = "too many lines"; goto fail; }
        }
        int cont = have && b > a && (s[a] == ' ' || s[a] == '\t');
        /* vCard 2.1: quoted-printable soft line break ("=" at the end) */
        int qp = 0;
        if (have && !cont && ll && logical[ll - 1] == '=') {
            size_t cl = 0;
            while (cl < ll && logical[cl] != ':') cl++;
            for (size_t k = 0; k + 16 <= cl; k++) if (!strncasecmp(logical + k, "QUOTED-PRINTABLE", 16)) { qp = 1; break; }
        }
        if (cont || qp) {
            size_t skip = cont ? 1 : 0;
            size_t add = b - a - skip;
            if (qp) ll--;          /* drop the "=" */
            if (ll + add + 1 > lcap) { size_t nc = (ll + add + 1) * 2; char *nl = realloc(logical, nc); if (!nl) { e = "memory"; goto fail; } logical = nl; lcap = nc; }
            memcpy(logical + ll, s + a + skip, add);
            ll += add;
            continue;
        }
        /* the previous logical line is complete */
        if (ll) {
            if (ll >= 6 && !strncasecmp(logical, "BEGIN:", 6)) {
                if (depth >= IC_MAX_DEPTH) { e = "too deep"; goto fail; }
                char nm[24];
                size_t n = ll - 6;
                while (n && (logical[6 + n - 1] == ' ')) n--;
                if (n >= sizeof nm) n = sizeof nm - 1;
                memcpy(nm, logical + 6, n);
                nm[n] = 0;
                IcComp *c = comp_new(nm, cur);
                if (!c) { e = "memory"; goto fail; }
                cur = c;
                depth++;
            } else if (ll >= 4 && !strncasecmp(logical, "END:", 4)) {
                char nm[24];
                size_t n = ll - 4;
                while (n && logical[4 + n - 1] == ' ') n--;
                if (n >= sizeof nm) n = sizeof nm - 1;
                memcpy(nm, logical + 4, n);
                nm[n] = 0;
                /* close up to the matching component (tolerates missing END lines) */
                IcComp *m = cur;
                while (m && m != root && strcasecmp(m->name, nm)) m = m->parent;
                if (m && m != root) {
                    while (cur != m) { cur = cur->parent; depth--; }
                    cur = cur->parent;
                    depth--;
                }
            } else if (add_prop(cur, logical, ll, &total)) { e = "too many properties"; goto fail; }
        }
        ll = 0;
        if (!have) break;
        size_t add = b - a;
        if (add + 1 > lcap) { size_t nc = (add + 1) * 2; char *nl = realloc(logical, nc); if (!nl) { e = "memory"; goto fail; } logical = nl; lcap = nc; }
        memcpy(logical, s + a, add);
        ll = add;
    }
    free(logical);
    if (err) *err = NULL;
    return root;
fail:
    free(logical);
    ic_free(root);
    if (err) *err = e;
    return NULL;
}

IcProp *ic_prop(const IcComp *c, const char *name) {
    for (int i = 0; c && i < c->nprops; i++) if (!strcmp(c->props[i].name, name)) return &c->props[i];
    return NULL;
}

IcProp *ic_prop_next(const IcComp *c, const IcProp *after, const char *name) {
    if (!c) return NULL;
    int start = after ? (int)(after - c->props) + 1 : 0;
    for (int i = start; i < c->nprops; i++) if (!strcmp(c->props[i].name, name)) return &c->props[i];
    return NULL;
}

int ic_param(const IcProp *p, const char *name, char *out, size_t cap) {
    if (cap) out[0] = 0;
    if (!p || !p->params) return 0;
    size_t nl = strlen(name);
    const char *s = p->params;
    while (*s) {
        const char *a = s;
        while (*s && *s != '=' && *s != ';') s++;
        size_t kl = (size_t)(s - a);
        int match = kl == nl && !strncasecmp(a, name, nl);
        /* vCard 2.1: bare parameters ("TEL;WORK;VOICE:") count as TYPE */
        if (*s != '=') {
            if (!strcasecmp(name, "TYPE") && kl && cap) {
                size_t cur = strlen(out);
                if (cur + kl + 2 < cap) { if (cur) out[cur++] = ','; memcpy(out + cur, a, kl); out[cur + kl] = 0; }
                if (*s == ';') s++;
                continue;
            }
            if (*s == ';') s++;
            continue;
        }
        s++;
        size_t o = match && cap ? strlen(out) : 0;
        if (match && o && o + 1 < cap) out[o++] = ',';
        int q = 0;
        while (*s && (q || *s != ';')) {
            if (*s == '"') { q = !q; s++; continue; }
            if (match && cap && o + 1 < cap) out[o++] = *s;
            s++;
        }
        if (match && cap) { out[o] = 0; if (strcasecmp(name, "TYPE")) return 1; }
        if (*s == ';') s++;
    }
    return cap && out[0];
}

void ic_unescape(const char *in, char *out, size_t cap) {
    if (!cap) return;
    size_t o = 0;
    for (; in && *in && o + 1 < cap; in++) {
        if (*in == '\\' && in[1]) {
            in++;
            if (*in == 'n' || *in == 'N') out[o++] = '\n';
            else out[o++] = *in;
        } else out[o++] = *in;
    }
    out[o] = 0;
    /* do not cut a UTF-8 character */
    while (o && ((unsigned char)out[o - 1] & 0xc0) == 0x80 && o + 1 >= cap) out[--o] = 0;
}

char *ic_unescape_dup(const char *in) {
    size_t n = in ? strlen(in) : 0;
    char *o = malloc(n + 1);
    if (o) ic_unescape(in ? in : "", o, n + 1);
    return o;
}

char *ic_escape(const char *in) {
    size_t n = in ? strlen(in) : 0;
    char *o = malloc(n * 2 + 1);
    if (!o) return NULL;
    size_t k = 0;
    for (size_t i = 0; i < n; i++) {
        char c = in[i];
        if (c == '\r') continue;
        if (c == '\n') { o[k++] = '\\'; o[k++] = 'n'; continue; }
        if (c == '\\' || c == ',' || c == ';') o[k++] = '\\';
        o[k++] = c;
    }
    o[k] = 0;
    return o;
}

void ic_line(JBuf *b, const char *line) {
    size_t n = strlen(line), col = 0;
    for (size_t i = 0; i < n;) {
        size_t k = 1;
        unsigned char c = (unsigned char)line[i];
        if (c >= 0xf0) k = 4; else if (c >= 0xe0) k = 3; else if (c >= 0xc0) k = 2;
        if (i + k > n) k = n - i;
        if (col + k > 75) { jb_raw(b, "\r\n "); col = 1; }
        {
            char t[5];
            memcpy(t, line + i, k);
            t[k] = 0;
            jb_raw(b, t);
        }
        col += k;
        i += k;
    }
    jb_raw(b, "\r\n");
}

/* ---- time ---- */

int64_t ic_days_from_civil(int64_t y, int m, int d) {
    y -= m <= 2;
    int64_t era = (y >= 0 ? y : y - 399) / 400;
    int64_t yoe = y - era * 400;
    int64_t doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
    int64_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
    return era * 146097 + doe - 719468;
}

void ic_civil_from_days(int64_t z, int *y, int *m, int *d) {
    z += 719468;
    int64_t era = (z >= 0 ? z : z - 146096) / 146097;
    int64_t doe = z - era * 146097;
    int64_t yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
    int64_t yy = yoe + era * 400;
    int64_t doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
    int64_t mp = (5 * doy + 2) / 153;
    int dd = (int)(doy - (153 * mp + 2) / 5 + 1);
    int mm = (int)(mp < 10 ? mp + 3 : mp - 9);
    *y = (int)(yy + (mm <= 2));
    *m = mm;
    *d = dd;
}

static char local_zone[64] = "UTC";
void ic_set_local_zone(const char *z) { if (z && tz_zone_valid(z)) snprintf(local_zone, sizeof local_zone, "%s", z); }
const char *ic_local_zone(void) { return local_zone; }

typedef struct { char name[64]; uint8_t *buf; size_t n; int bad; } ZoneCache;
static ZoneCache zones[24];

static const struct { const char *win, *iana; } winzones[] = {
    { "Pacific Standard Time", "America/Los_Angeles" }, { "Mountain Standard Time", "America/Denver" }, { "Central Standard Time", "America/Chicago" },
    { "Eastern Standard Time", "America/New_York" }, { "GMT Standard Time", "Europe/London" }, { "Greenwich Standard Time", "Atlantic/Reykjavik" },
    { "W. Europe Standard Time", "Europe/Berlin" }, { "Romance Standard Time", "Europe/Paris" }, { "Central Europe Standard Time", "Europe/Budapest" },
    { "Central European Standard Time", "Europe/Warsaw" }, { "E. Europe Standard Time", "Europe/Chisinau" }, { "FLE Standard Time", "Europe/Kiev" },
    { "GTB Standard Time", "Europe/Bucharest" }, { "Russian Standard Time", "Europe/Moscow" }, { "Argentina Standard Time", "America/Argentina/Buenos_Aires" },
    { "E. South America Standard Time", "America/Sao_Paulo" }, { "SA Pacific Standard Time", "America/Bogota" }, { "Pacific SA Standard Time", "America/Santiago" },
    { "Central America Standard Time", "America/Guatemala" }, { "Central Standard Time (Mexico)", "America/Mexico_City" }, { "Mexico Standard Time", "America/Mexico_City" },
    { "Venezuela Standard Time", "America/Caracas" }, { "Montevideo Standard Time", "America/Montevideo" }, { "SA Western Standard Time", "America/La_Paz" },
    { "Paraguay Standard Time", "America/Asuncion" }, { "Tokyo Standard Time", "Asia/Tokyo" }, { "China Standard Time", "Asia/Shanghai" },
    { "India Standard Time", "Asia/Kolkata" }, { "AUS Eastern Standard Time", "Australia/Sydney" }, { "Arabian Standard Time", "Asia/Dubai" },
    { "Israel Standard Time", "Asia/Jerusalem" }, { "Korea Standard Time", "Asia/Seoul" }, { "Singapore Standard Time", "Asia/Singapore" },
    { "UTC", "UTC" }, { "Coordinated Universal Time", "UTC" }, { "Atlantic Standard Time", "America/Halifax" }, { "Hawaiian Standard Time", "Pacific/Honolulu" },
    { "Alaskan Standard Time", "America/Anchorage" }, { "US Mountain Standard Time", "America/Phoenix" }, { "SE Asia Standard Time", "Asia/Bangkok" },
    { "New Zealand Standard Time", "Pacific/Auckland" }, { "South Africa Standard Time", "Africa/Johannesburg" }, { "Turkey Standard Time", "Europe/Istanbul" },
};

static ZoneCache *zone_load(const char *zone) {
    char z[64];
    if (!zone || !*zone) zone = local_zone;
    snprintf(z, sizeof z, "%s", zone);
    for (size_t i = 0; i < sizeof winzones / sizeof winzones[0]; i++) if (!strcasecmp(z, winzones[i].win)) { snprintf(z, sizeof z, "%s", winzones[i].iana); break; }
    /* "/mozilla.org/20050126_1/Europe/Madrid", "/freeassociation.sourceforge.net/Tzfile/Europe/Madrid" */
    if (z[0] == '/') {
        char *last = strrchr(z, '/'), *prev = NULL;
        if (last) { *last = 0; prev = strrchr(z, '/'); *last = '/'; }
        if (prev) memmove(z, prev + 1, strlen(prev + 1) + 1);
        else if (last) memmove(z, last + 1, strlen(last + 1) + 1);
    }
    if (!strcasecmp(z, "Z") || !strcasecmp(z, "GMT") || !strcasecmp(z, "Etc/UTC")) snprintf(z, sizeof z, "UTC");
    for (size_t i = 0; i < sizeof zones / sizeof zones[0]; i++) if (zones[i].name[0] && !strcmp(zones[i].name, z)) return zones[i].bad ? NULL : &zones[i];
    size_t slot = 0;
    for (; slot < sizeof zones / sizeof zones[0]; slot++) if (!zones[slot].name[0]) break;
    if (slot == sizeof zones / sizeof zones[0]) { slot = 0; free(zones[0].buf); memset(&zones[0], 0, sizeof zones[0]); }
    ZoneCache *c = &zones[slot];
    snprintf(c->name, sizeof c->name, "%s", z);
    c->bad = 1;
    if (!tz_zone_valid(z)) return NULL;
    char path[160];
    snprintf(path, sizeof path, "/usr/share/zoneinfo/%s", z);
    int fd = open(path, O_RDONLY | O_CLOEXEC);
    if (fd < 0) return NULL;
    struct stat st;
    if (fstat(fd, &st) || !S_ISREG(st.st_mode) || st.st_size <= 0 || st.st_size > (1 << 20)) { close(fd); return NULL; }
    c->buf = malloc((size_t)st.st_size);
    if (!c->buf) { close(fd); return NULL; }
    ssize_t r = read(fd, c->buf, (size_t)st.st_size);
    close(fd);
    if (r != st.st_size) { free(c->buf); c->buf = NULL; return NULL; }
    c->n = (size_t)r;
    c->bad = 0;
    return c;
}

int32_t ic_zone_offset(const char *zone, int64_t t) {
    ZoneCache *c = zone_load(zone);
    if (!c) c = zone_load(local_zone);
    if (!c) return 0;
    TzInfo ti;
    if (tzif_lookup(c->buf, c->n, t, &ti)) return 0;
    return ti.utoff;
}

int64_t ic_wall_to_utc(int64_t wall, const char *zone) {
    int32_t o1 = ic_zone_offset(zone, wall);
    int64_t t = wall - o1;
    int32_t o2 = ic_zone_offset(zone, t);
    if (o2 != o1) t = wall - o2;
    return t;
}

static int digits(const char *s, int n, int *out) {
    int v = 0;
    for (int i = 0; i < n; i++) { if (!isdigit((unsigned char)s[i])) return 0; v = v * 10 + (s[i] - '0'); }
    *out = v;
    return 1;
}

/* "20251018", "20251018T103000", "20251018T103000Z"; returns wall/UTC seconds */
static int parse_dt(const char *v, int64_t *t, int *allday, int *utc) {
    while (*v == ' ') v++;
    int y, mo, d, h = 0, mi = 0, s = 0;
    size_t n = strlen(v);
    if (n >= 10 && v[4] == '-' && v[7] == '-') {         /* vCard: 1990-05-17 */
        if (!digits(v, 4, &y) || !digits(v + 5, 2, &mo) || !digits(v + 8, 2, &d)) return 0;
        *allday = 1; *utc = 0;
        *t = ic_days_from_civil(y, mo, d) * 86400;
        return mo >= 1 && mo <= 12 && d >= 1 && d <= 31;
    }
    if (n < 8 || !digits(v, 4, &y) || !digits(v + 4, 2, &mo) || !digits(v + 6, 2, &d)) return 0;
    if (mo < 1 || mo > 12 || d < 1 || d > 31) return 0;
    *allday = 1;
    *utc = 0;
    if (n >= 15 && (v[8] == 'T' || v[8] == 't')) {
        if (!digits(v + 9, 2, &h) || !digits(v + 11, 2, &mi) || !digits(v + 13, 2, &s)) return 0;
        if (h > 23 || mi > 59 || s > 60) return 0;
        *allday = 0;
        *utc = n >= 16 && (v[15] == 'Z' || v[15] == 'z');
    }
    *t = ic_days_from_civil(y, mo, d) * 86400 + h * 3600 + mi * 60 + s;
    return 1;
}

int ic_time(const IcProp *p, int64_t *t, int *allday, char *tzid, size_t tzcap) {
    if (tzcap) tzid[0] = 0;
    if (!p || !p->value) return 0;
    char vt[32] = "";
    ic_param(p, "VALUE", vt, sizeof vt);
    int utc = 0;
    int64_t w;
    if (!parse_dt(p->value, &w, allday, &utc)) return 0;
    if (!strcasecmp(vt, "DATE")) *allday = 1;
    if (*allday) { *t = ic_wall_to_utc(w - w % 86400, NULL); return 1; }
    if (utc) { *t = w; return 1; }
    char z[64] = "";
    ic_param(p, "TZID", z, sizeof z);
    if (tzcap) snprintf(tzid, tzcap, "%s", z);
    *t = ic_wall_to_utc(w, z[0] ? z : NULL);
    return 1;
}

/* ISO 8601 duration ("-PT15M", "P1DT2H", "P2W") in seconds. */
static int parse_dur(const char *v, long long *out) {
    while (*v == ' ') v++;
    int neg = 0;
    if (*v == '-') { neg = 1; v++; } else if (*v == '+') v++;
    if (*v != 'P' && *v != 'p') return 0;
    v++;
    long long tot = 0;
    int time = 0, any = 0;
    while (*v) {
        if (*v == 'T' || *v == 't') { time = 1; v++; continue; }
        if (!isdigit((unsigned char)*v)) return 0;
        long long x = 0;
        while (isdigit((unsigned char)*v)) { x = x * 10 + (*v - '0'); if (x > 100000000) return 0; v++; }
        char u = (char)toupper((unsigned char)*v);
        if (!u) return 0;
        v++;
        any = 1;
        if (tot > 100000000000LL) return 0;
        if (u == 'W') tot += x * 604800;
        else if (u == 'D') tot += x * 86400;
        else if (u == 'H' && time) tot += x * 3600;
        else if (u == 'M' && time) tot += x * 60;
        else if (u == 'S' && time) tot += x;
        else return 0;
    }
    if (!any || tot > 100000000000LL) return 0;
    *out = neg ? -tot : tot;
    return 1;
}

/* ---- events ---- */

static void text_prop(const IcComp *c, const char *name, char *out, size_t cap) {
    IcProp *p = ic_prop(c, name);
    if (cap) out[0] = 0;
    if (p) ic_unescape(p->value, out, cap);
}

static void mailto(const char *v, char *out, size_t cap) {
    while (*v == ' ') v++;
    if (!strncasecmp(v, "mailto:", 7)) v += 7;
    snprintf(out, cap, "%s", v);
    for (char *p = out; *p; p++) *p = (char)tolower((unsigned char)*p);
}

static void fill_event(const IcComp *c, IcEvent *e) {
    memset(e, 0, sizeof *e);
    e->is_todo = !strcmp(c->name, "VTODO");
    text_prop(c, "UID", e->uid, sizeof e->uid);
    text_prop(c, "SUMMARY", e->summary, sizeof e->summary);
    text_prop(c, "LOCATION", e->location, sizeof e->location);
    text_prop(c, "URL", e->url, sizeof e->url);
    text_prop(c, "STATUS", e->status, sizeof e->status);
    for (char *p = e->status; *p; p++) *p = (char)toupper((unsigned char)*p);
    text_prop(c, "CATEGORIES", e->categories, sizeof e->categories);
    IcProp *d = ic_prop(c, "DESCRIPTION");
    e->description = ic_unescape_dup(d ? d->value : "");
    IcProp *rr = ic_prop(c, "RRULE");
    if (rr) snprintf(e->rrule, sizeof e->rrule, "%s", rr->value);
    IcProp *seq = ic_prop(c, "SEQUENCE");
    if (seq) e->sequence = bnum(seq->value, 0, 1000000000, 0, NULL);
    int ad;
    char tz[64];
    int64_t t;
    if (ic_time(ic_prop(c, "DTSTAMP"), &t, &ad, tz, sizeof tz)) e->dtstamp = t;
    if (ic_time(ic_prop(c, "LAST-MODIFIED"), &t, &ad, tz, sizeof tz)) e->modified = t;
    IcProp *ds = ic_prop(c, "DTSTART");
    if (ic_time(ds, &e->start, &e->allday, e->tzid, sizeof e->tzid)) {
        if (e->allday) {
            int64_t w; int u, a2;
            if (parse_dt(ds->value, &w, &a2, &u)) e->sdate = (int)(w / 86400);
        }
    }
    IcProp *de = ic_prop(c, e->is_todo ? "DUE" : "DTEND");
    if (e->is_todo) {
        if (de && ic_time(de, &e->due, &e->due_allday, tz, sizeof tz)) { /* ok */ }
        if (!ds) { e->start = e->due; e->allday = e->due_allday; }
    }
    if (!e->is_todo && de && ic_time(de, &e->end, &ad, tz, sizeof tz)) {
        if (e->allday) { int64_t w; int u, a2; if (parse_dt(de->value, &w, &a2, &u)) e->edate = (int)(w / 86400); }
    } else if (!e->is_todo) {
        long long dur = 0;
        IcProp *du = ic_prop(c, "DURATION");
        if (du && parse_dur(du->value, &dur) && dur >= 0) e->end = e->start + dur;
        else e->end = e->start + (e->allday ? 86400 : 0);
        if (e->allday) e->edate = e->sdate + (int)((e->end - e->start + 86399) / 86400);
    }
    if (e->allday && e->edate <= e->sdate) e->edate = e->sdate + 1;
    if (e->end < e->start) e->end = e->start;
    IcProp *rid = ic_prop(c, "RECURRENCE-ID");
    if (rid) ic_time(rid, &e->recurrence_id, &ad, tz, sizeof tz);
    for (IcProp *x = ic_prop(c, "EXDATE"); x; x = ic_prop_next(c, x, "EXDATE")) {
        /* comma separated, with the same parameters */
        char *v = x->value;
        while (*v && e->nexdate < 64) {
            char one[40];
            size_t n = strcspn(v, ",");
            if (n < sizeof one) {
                memcpy(one, v, n);
                one[n] = 0;
                IcProp tmp = *x;
                tmp.value = one;
                int64_t et;
                if (ic_time(&tmp, &et, &ad, tz, sizeof tz)) e->exdate[e->nexdate++] = et;
            }
            v += n;
            if (*v == ',') v++;
        }
    }
    IcProp *org = ic_prop(c, "ORGANIZER");
    if (org) { mailto(org->value, e->organizer, sizeof e->organizer); char cn[160]; if (ic_param(org, "CN", cn, sizeof cn)) snprintf(e->organizer_name, sizeof e->organizer_name, "%s", cn); }
    for (IcProp *a = ic_prop(c, "ATTENDEE"); a && e->natt < IC_MAX_ATT; a = ic_prop_next(c, a, "ATTENDEE")) {
        IcAttendee *na = realloc(e->att, (size_t)(e->natt + 1) * sizeof *na);
        if (!na) break;
        e->att = na;
        IcAttendee *x = &e->att[e->natt++];
        memset(x, 0, sizeof *x);
        mailto(a->value, x->email, sizeof x->email);
        ic_param(a, "CN", x->name, sizeof x->name);
        if (!ic_param(a, "PARTSTAT", x->partstat, sizeof x->partstat)) snprintf(x->partstat, sizeof x->partstat, "NEEDS-ACTION");
        for (char *p = x->partstat; *p; p++) *p = (char)toupper((unsigned char)*p);
        ic_param(a, "ROLE", x->role, sizeof x->role);
        char rs[16];
        x->rsvp = ic_param(a, "RSVP", rs, sizeof rs) && !strcasecmp(rs, "TRUE");
    }
    IcProp *pr = ic_prop(c, "PRIORITY");
    if (pr) e->priority = bnum(pr->value, 0, 9, 0, NULL);
    IcProp *co = ic_prop(c, "COMPLETED");
    if (co) ic_time(co, &e->completed, &ad, tz, sizeof tz);
    if (!e->completed && !strcmp(e->status, "COMPLETED")) e->completed = e->modified ? e->modified : 1;
    IcProp *fl = ic_prop(c, "X-LORDOS-FLAGGED");
    if (fl) e->flagged = bnum(fl->value, 0, 1, 0, NULL) != 0;
    IcProp *rel = ic_prop(c, "RELATED-TO");
    if (rel) ic_unescape(rel->value, e->parent_uid, sizeof e->parent_uid);
    /* alarms */
    for (IcComp *k = c->kid; k && e->nalarms < 8; k = k->next) {
        if (strcmp(k->name, "VALARM")) continue;
        IcProp *tr = ic_prop(k, "TRIGGER");
        if (!tr) continue;
        char vt[24] = "";
        ic_param(tr, "VALUE", vt, sizeof vt);
        long long dur;
        if (!strcasecmp(vt, "DATE-TIME")) {
            int64_t at;
            if (ic_time(tr, &at, &ad, tz, sizeof tz)) { int64_t ref = e->is_todo && e->due ? e->due : e->start; int64_t m = (ref - at) / 60; e->alarms[e->nalarms++] = (int)(m < -5000000 ? -5000000 : m > 5000000 ? 5000000 : m); }
        } else if (parse_dur(tr->value, &dur)) {
            char rel2[16] = "";
            ic_param(tr, "RELATED", rel2, sizeof rel2);
            long long before = -dur;
            if (!strcasecmp(rel2, "END") && !e->is_todo) before -= (e->end - e->start);
            long long m = before / 60;
            e->alarms[e->nalarms++] = (int)(m < -5000000 ? -5000000 : m > 5000000 ? 5000000 : m);
        }
    }
}

int ical_events(const char *text, size_t len, IcEvent **out, char *method, size_t mcap) {
    *out = NULL;
    if (mcap) method[0] = 0;
    const char *err;
    IcComp *root = ic_parse(text, len, &err);
    if (!root) return -1;
    int n = 0, cap = 0;
    IcEvent *ev = NULL;
    for (IcComp *cal = root->kid; cal; cal = cal->next) {
        if (strcmp(cal->name, "VCALENDAR")) continue;
        IcProp *m = ic_prop(cal, "METHOD");
        if (m && mcap && !method[0]) { snprintf(method, mcap, "%s", m->value); for (char *p = method; *p; p++) *p = (char)toupper((unsigned char)*p); }
        for (IcComp *c = cal->kid; c; c = c->next) {
            if (strcmp(c->name, "VEVENT") && strcmp(c->name, "VTODO")) continue;
            if (n == cap) {
                int nc = cap ? cap * 2 : 4;
                IcEvent *ne = realloc(ev, (size_t)nc * sizeof *ne);
                if (!ne) break;
                ev = ne; cap = nc;
            }
            fill_event(c, &ev[n++]);
            if (n >= 20000) break;
        }
    }
    ic_free(root);
    *out = ev;
    return n;
}

void ical_events_free(IcEvent *ev, int n) {
    for (int i = 0; i < n; i++) { free(ev[i].description); free(ev[i].att); }
    free(ev);
}

/* ---- recurrence ---- */

typedef struct {
    int freq;               /* 'D','W','M','Y' */
    int interval, count;
    int64_t until;
    int byday[16], byday_n[16], nbyday;     /* weekday 0=MO..6=SU, ordinal (0 = every) */
    int bymonthday[16], nbmd;
    int bymonth[12], nbm;
} Rule;

static int wd_index(const char *s) {
    static const char *w[] = { "MO", "TU", "WE", "TH", "FR", "SA", "SU" };
    for (int i = 0; i < 7; i++) if (!strncasecmp(s, w[i], 2)) return i;
    return -1;
}

static int parse_rule(const char *r, Rule *o) {
    memset(o, 0, sizeof *o);
    o->interval = 1;
    char buf[512];
    snprintf(buf, sizeof buf, "%s", r);
    for (char *save = NULL, *part = strtok_r(buf, ";", &save); part; part = strtok_r(NULL, ";", &save)) {
        char *eq = strchr(part, '=');
        if (!eq) continue;
        *eq = 0;
        char *k = part, *v = eq + 1;
        if (!strcasecmp(k, "FREQ")) o->freq = !strcasecmp(v, "DAILY") ? 'D' : !strcasecmp(v, "WEEKLY") ? 'W' : !strcasecmp(v, "MONTHLY") ? 'M' : !strcasecmp(v, "YEARLY") ? 'Y' : 0;
        else if (!strcasecmp(k, "INTERVAL")) o->interval = bnum(v, 1, 1000, 1, NULL);
        else if (!strcasecmp(k, "COUNT")) o->count = bnum(v, 0, 100000, 0, NULL);
        else if (!strcasecmp(k, "UNTIL")) {
            int64_t t; int ad, utc;
            if (parse_dt(v, &t, &ad, &utc)) o->until = ad ? ic_wall_to_utc(t + 86399, NULL) : utc ? t : ic_wall_to_utc(t, NULL);
        } else if (!strcasecmp(k, "BYDAY")) {
            int maxd = (int)(sizeof o->byday / sizeof o->byday[0]);
            for (char *s2 = NULL, *d = strtok_r(v, ",", &s2); d && o->nbyday < maxd; d = strtok_r(NULL, ",", &s2)) {
                int ord = 0;
                if (*d == '+' || *d == '-' || isdigit((unsigned char)*d)) {
                    const char *e;
                    ord = bnum(d, -53, 53, 99, &e);           /* RFC 5545: ±1..53 */
                    if (ord == 99 || ord == 0) continue;
                    d = (char *)e;
                }
                int w = wd_index(d);
                if (w < 0) continue;
                o->byday[o->nbyday] = w;
                o->byday_n[o->nbyday] = ord;
                o->nbyday++;
            }
        } else if (!strcasecmp(k, "BYMONTHDAY")) {
            for (char *s2 = NULL, *d = strtok_r(v, ",", &s2); d && o->nbmd < 16; d = strtok_r(NULL, ",", &s2)) { int x = bnum(d, -31, 31, 0, NULL); if (x) o->bymonthday[o->nbmd++] = x; }
        } else if (!strcasecmp(k, "BYMONTH")) {
            for (char *s2 = NULL, *d = strtok_r(v, ",", &s2); d && o->nbm < 12; d = strtok_r(NULL, ",", &s2)) { int x = bnum(d, 1, 12, 0, NULL); if (x) o->bymonth[o->nbm++] = x; }
        }
    }
    return o->freq != 0;
}

static int weekday_of(int64_t days) { int64_t w = (days + 3) % 7; if (w < 0) w += 7; return (int)w; }   /* 1970-01-01 = Thursday → 0=MO */
static int month_len(int y, int m) { static const int ml[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; return m == 2 && ((y % 4 == 0 && y % 100) || y % 400 == 0) ? 29 : ml[m - 1]; }

static int in_list(const int *l, int n, int v) { for (int i = 0; i < n; i++) if (l[i] == v) return 1; return 0; }

/* days of a month that match the rule (ascending); returns count */
static int month_days(const Rule *r, int y, int m, int dflt_day, int64_t *out) {
    int ml = month_len(y, m), n = 0;
    int64_t first = ic_days_from_civil(y, m, 1);
    int pick[32] = { 0 };
    if (r->nbmd) {
        for (int i = 0; i < r->nbmd; i++) { int d = r->bymonthday[i] > 0 ? r->bymonthday[i] : ml + r->bymonthday[i] + 1; if (d >= 1 && d <= ml) pick[d] = 1; }
    } else if (r->nbyday) {
        for (int i = 0; i < r->nbyday; i++) {
            int w = r->byday[i], ord = r->byday_n[i];
            int fw = weekday_of(first);
            int d1 = 1 + (w - fw + 7) % 7;        /* first such weekday */
            if (ord < -53 || ord > 53) continue;           /* already bounded by parse_rule */
            if (!ord) { for (int d = d1; d >= 1 && d <= ml; d += 7) pick[d] = 1; }
            else if (ord > 0) { int d = d1 + (ord - 1) * 7; if (d >= 1 && d <= ml) pick[d] = 1; }
            else { int last = d1; while (last + 7 <= ml) last += 7; int d = last + (ord + 1) * 7; if (d >= 1 && d <= ml) pick[d] = 1; }
        }
    } else if (dflt_day >= 1 && dflt_day <= ml) pick[dflt_day] = 1;
    for (int d = 1; d <= ml; d++) if (pick[d]) out[n++] = first + d - 1;
    return n;
}

int ical_expand(const IcEvent *ev, int64_t from, int64_t to, int max, void (*fn)(void *u, int64_t start), void *u) {
    int64_t dur = ev->end - ev->start;
    int nout = 0;
    const char *zone = ev->allday ? NULL : (ev->tzid[0] ? ev->tzid : NULL);
#define EMIT(t) do { int64_t _t = (t); int _ex = 0; for (int _k = 0; _k < ev->nexdate; _k++) if (ev->exdate[_k] == _t || (ev->allday && (ev->exdate[_k] - _t) / 86400 == 0 && llabs(ev->exdate[_k] - _t) < 86400)) _ex = 1; \
        if (!_ex && _t < to && (_t + (dur > 0 ? dur : 1)) > from) { if (fn) fn(u, _t); nout++; } } while (0)
    Rule r;
    if (!ev->rrule[0] || ev->recurrence_id || !parse_rule(ev->rrule, &r)) { EMIT(ev->start); return nout; }
    int64_t wall0 = ev->start + ic_zone_offset(zone, ev->start);
    int64_t day0 = wall0 >= 0 ? wall0 / 86400 : (wall0 - 86399) / 86400;
    int64_t tod = wall0 - day0 * 86400;
    if (ev->allday) { day0 = ev->sdate; tod = 0; }
    int y0, m0, d0;
    ic_civil_from_days(day0, &y0, &m0, &d0);
    int seen = 0;
    int64_t cand[400];
    for (long period = 0; period < 50000 && nout < max; period++) {
        int nc = 0;
        if (r.freq == 'D') {
            int64_t d = day0 + period * r.interval;
            int y, m, dd;
            ic_civil_from_days(d, &y, &m, &dd);
            if ((!r.nbm || in_list(r.bymonth, r.nbm, m)) && (!r.nbyday || in_list(r.byday, r.nbyday, weekday_of(d))) &&
                (!r.nbmd || in_list(r.bymonthday, r.nbmd, dd))) cand[nc++] = d;
        } else if (r.freq == 'W') {
            int64_t wk = day0 - weekday_of(day0) + period * 7 * r.interval;
            for (int w = 0; w < 7; w++) {
                int64_t d = wk + w;
                if (r.nbyday ? in_list(r.byday, r.nbyday, w) : w == weekday_of(day0)) {
                    int y, m, dd;
                    ic_civil_from_days(d, &y, &m, &dd);
                    if (!r.nbm || in_list(r.bymonth, r.nbm, m)) cand[nc++] = d;
                }
            }
        } else if (r.freq == 'M') {
            long mi = (long)y0 * 12 + (m0 - 1) + period * r.interval;
            int y = (int)(mi / 12), m = (int)(mi % 12) + 1;
            if (!r.nbm || in_list(r.bymonth, r.nbm, m)) nc = month_days(&r, y, m, d0, cand);
        } else {
            int y = y0 + (int)(period * r.interval);
            if (y > 9999) break;
            if (r.nbm) { for (int k = 0; k < r.nbm && nc + 31 <= (int)(sizeof cand / sizeof cand[0]); k++) nc += month_days(&r, y, r.bymonth[k], d0, cand + nc); }
            else nc = month_days(&r, y, m0, d0, cand);
        }
        /* candidates are in ascending order per period (yearly months may not be: sort) */
        for (int a = 1; a < nc; a++) for (int b = a; b > 0 && cand[b] < cand[b - 1]; b--) { int64_t t = cand[b]; cand[b] = cand[b - 1]; cand[b - 1] = t; }
        int stop = 0;
        for (int k = 0; k < nc; k++) {
            if (cand[k] < day0) continue;
            int64_t start = ev->allday ? ic_wall_to_utc(cand[k] * 86400, NULL) : ic_wall_to_utc(cand[k] * 86400 + tod, zone);
            if (cand[k] == day0) start = ev->start;
            if (r.until && start > r.until) { stop = 1; break; }
            if (r.count && seen >= r.count) { stop = 1; break; }
            seen++;
            if (start >= to) { stop = 1; break; }
            EMIT(start);
            if (nout >= max) { stop = 1; break; }
        }
        if (stop) break;
        /* nothing can match anymore? (e.g. BYMONTHDAY=31 forever is fine; guard by the period cap) */
    }
#undef EMIT
    return nout;
}

/* ---- JSON ---- */

static void date_str(int days, char *out, size_t cap) {
    int y, m, d;
    ic_civil_from_days(days, &y, &m, &d);
    snprintf(out, cap, "%04d-%02d-%02d", y, m, d);
}

void ical_event_json(JBuf *b, const IcEvent *e, int64_t occ) {
    int64_t start = occ ? occ : e->start;
    int64_t end = start + (e->end - e->start);
    jb_raw(b, "{\"uid\":"); jb_str(b, e->uid);
    jb_raw(b, ",\"title\":"); jb_str(b, e->summary);
    if (e->location[0]) { jb_raw(b, ",\"loc\":"); jb_str(b, e->location); }
    if (e->description && e->description[0]) { jb_raw(b, ",\"notes\":"); jb_str(b, e->description); }
    if (e->url[0]) { jb_raw(b, ",\"url\":"); jb_str(b, e->url); }
    if (e->status[0]) { jb_raw(b, ",\"status\":"); jb_str(b, e->status); }
    if (e->categories[0]) { jb_raw(b, ",\"cats\":"); jb_str(b, e->categories); }
    jb_printf(b, ",\"start\":%lld,\"end\":%lld,\"allDay\":%s", (long long)start * 1000, (long long)end * 1000, e->allday ? "true" : "false");
    if (e->allday) {
        char ds[16], de[16];
        int sd = e->sdate, ed = e->edate;
        if (occ) { int64_t w = occ + ic_zone_offset(NULL, occ); int nd = (int)(w >= 0 ? w / 86400 : (w - 86399) / 86400); ed = nd + (ed - sd); sd = nd; }
        date_str(sd, ds, sizeof ds);
        date_str(ed, de, sizeof de);
        jb_raw(b, ",\"sdate\":"); jb_str(b, ds);
        jb_raw(b, ",\"edate\":"); jb_str(b, de);
    }
    if (e->tzid[0]) { jb_raw(b, ",\"tz\":"); jb_str(b, e->tzid); }
    if (e->rrule[0]) { jb_raw(b, ",\"rrule\":"); jb_str(b, e->rrule); }
    if (occ) jb_printf(b, ",\"occ\":%lld", (long long)occ * 1000);
    if (e->recurrence_id) jb_printf(b, ",\"rid\":%lld", (long long)e->recurrence_id * 1000);
    jb_raw(b, ",\"alarms\":[");
    for (int i = 0; i < e->nalarms; i++) jb_printf(b, "%s%d", i ? "," : "", e->alarms[i]);
    jb_raw(b, "]");
    if (e->organizer[0]) { jb_raw(b, ",\"org\":{\"email\":"); jb_str(b, e->organizer); jb_raw(b, ",\"name\":"); jb_str(b, e->organizer_name); jb_raw(b, "}"); }
    if (e->natt) {
        jb_raw(b, ",\"att\":[");
        for (int i = 0; i < e->natt; i++) {
            if (i) jb_raw(b, ",");
            jb_raw(b, "{\"email\":"); jb_str(b, e->att[i].email);
            jb_raw(b, ",\"name\":"); jb_str(b, e->att[i].name);
            jb_raw(b, ",\"ps\":"); jb_str(b, e->att[i].partstat);
            if (e->att[i].role[0]) { jb_raw(b, ",\"role\":"); jb_str(b, e->att[i].role); }
            jb_raw(b, "}");
        }
        jb_raw(b, "]");
    }
    jb_printf(b, ",\"seq\":%d", e->sequence);
    if (e->is_todo) {
        jb_raw(b, ",\"todo\":true");
        if (e->due) {
            jb_printf(b, ",\"due\":%lld,\"dueAllDay\":%s", (long long)e->due * 1000, e->due_allday ? "true" : "false");
            if (e->due_allday) { char ds[16]; int64_t w = e->due + ic_zone_offset(NULL, e->due); date_str((int)(w / 86400), ds, sizeof ds); jb_raw(b, ",\"dueDate\":"); jb_str(b, ds); }
        } else jb_raw(b, ",\"due\":null");
        jb_printf(b, ",\"prio\":%d,\"done\":%s,\"flag\":%s", e->priority, e->completed ? "true" : "false", e->flagged ? "true" : "false");
        if (e->completed > 1) jb_printf(b, ",\"doneAt\":%lld", (long long)e->completed * 1000);
        if (e->parent_uid[0]) { jb_raw(b, ",\"parent\":"); jb_str(b, e->parent_uid); }
    }
    jb_raw(b, "}");
}

/* ---- building ---- */

static void fmt_utc(int64_t t, char *out, size_t cap) {
    int64_t days = t >= 0 ? t / 86400 : (t - 86399) / 86400;
    int64_t s = t - days * 86400;
    int y, m, d;
    ic_civil_from_days(days, &y, &m, &d);
    snprintf(out, cap, "%04d%02d%02dT%02d%02d%02dZ", y, m, d, (int)(s / 3600), (int)(s / 60 % 60), (int)(s % 60));
}

static void fmt_wall(int64_t t, const char *zone, char *out, size_t cap) {
    int64_t w = t + ic_zone_offset(zone, t);
    int64_t days = w >= 0 ? w / 86400 : (w - 86399) / 86400;
    int64_t s = w - days * 86400;
    int y, m, d;
    ic_civil_from_days(days, &y, &m, &d);
    snprintf(out, cap, "%04d%02d%02dT%02d%02d%02d", y, m, d, (int)(s / 3600), (int)(s / 60 % 60), (int)(s % 60));
}

static void fmt_date(int64_t t, char *out, size_t cap) {
    int64_t w = t + ic_zone_offset(NULL, t);
    int y, m, d;
    ic_civil_from_days(w >= 0 ? w / 86400 : (w - 86399) / 86400, &y, &m, &d);
    snprintf(out, cap, "%04d%02d%02d", y, m, d);
}

static void kv(JBuf *b, const char *k, const char *v) {
    if (!v || !*v) return;
    char *e = ic_escape(v);
    if (!e) return;
    size_t n = strlen(k) + strlen(e) + 2;
    char *line = malloc(n);
    if (line) { snprintf(line, n, "%s:%s", k, e); ic_line(b, line); free(line); }
    free(e);
}

static int safe_rrule(const char *r) {
    for (; *r; r++) if (!isalnum((unsigned char)*r) && !strchr("=;,:+-", *r)) return 0;
    return 1;
}

static void safe_param(const char *in, char *out, size_t cap) {
    /* parameter values: no quotes, no control characters */
    size_t o = 0;
    for (; in && *in && o + 1 < cap; in++) if ((unsigned char)*in >= 0x20 && *in != '"') out[o++] = *in;
    out[o] = 0;
}

/* VTIMEZONE from the zone's TZif footer (POSIX rule "CET-1CEST,M3.5.0,M10.5.0/3"). 0 if done. */
static int vtimezone(JBuf *b, const char *zone) {
    ZoneCache *c = zone_load(zone);
    if (!c || c->n < 2) return -1;
    /* footer: "\n<rule>\n" at the end */
    size_t e = c->n - 1;
    if (c->buf[e] != '\n') return -1;
    size_t s = e;
    while (s > 0 && c->buf[s - 1] != '\n') s--;
    char rule[80];
    size_t rl = e - s;
    if (!rl || rl >= sizeof rule) return -1;
    memcpy(rule, c->buf + s, rl);
    rule[rl] = 0;
    /* std name, offset [dst name [offset], start, end] */
    const char *p = rule;
    char stdn[16], dstn[16] = "";
    int i = 0;
    if (*p == '<') { p++; while (*p && *p != '>' && i < 15) stdn[i++] = *p++; if (*p == '>') p++; }
    else while (isalpha((unsigned char)*p) && i < 15) stdn[i++] = *p++;
    stdn[i] = 0;
    int sign = 1, hh = 0, mm = 0;
    if (*p == '-') { sign = -1; p++; } else if (*p == '+') p++;
    if (!isdigit((unsigned char)*p)) return -1;
    hh = (int)strtol(p, (char **)&p, 10);
    if (*p == ':') { p++; mm = (int)strtol(p, (char **)&p, 10); }
    int stdoff = -sign * (hh * 3600 + mm * 60);             /* POSIX sign is inverted */
    int dstoff = stdoff + 3600;
    int has_dst = 0;
    int sm = 0, sw = 0, sd = 0, em = 0, ew = 0, ed = 0;
    if (*p) {
        i = 0;
        if (*p == '<') { p++; while (*p && *p != '>' && i < 15) dstn[i++] = *p++; if (*p == '>') p++; }
        else while (isalpha((unsigned char)*p) && i < 15) dstn[i++] = *p++;
        dstn[i] = 0;
        if (*p && *p != ',') {
            int sg = 1;
            if (*p == '-') { sg = -1; p++; } else if (*p == '+') p++;
            int h2 = (int)strtol(p, (char **)&p, 10), m2 = 0;
            if (*p == ':') { p++; m2 = (int)strtol(p, (char **)&p, 10); }
            dstoff = -sg * (h2 * 3600 + m2 * 60);
        }
        if (sscanf(p, ",M%d.%d.%d", &sm, &sw, &sd) == 3) {
            const char *q = strchr(p + 1, ',');
            if (q && sscanf(q, ",M%d.%d.%d", &em, &ew, &ed) == 3) has_dst = 1;
        }
        if (!has_dst) return -1;
    }
    char line[160], zq[80];
    safe_param(zone, zq, sizeof zq);
    jb_raw(b, "BEGIN:VTIMEZONE\r\n");
    snprintf(line, sizeof line, "TZID:%s", zq);
    ic_line(b, line);
    static const char *wd[] = { "SU", "MO", "TU", "WE", "TH", "FR", "SA" };
#define OFF(o) ((o) < 0 ? '-' : '+'), abs(o) / 3600, abs(o) / 60 % 60
    if (!has_dst) {
        jb_raw(b, "BEGIN:STANDARD\r\nDTSTART:19700101T000000\r\n");
        jb_printf(b, "TZOFFSETFROM:%c%02d%02d\r\nTZOFFSETTO:%c%02d%02d\r\n", OFF(stdoff), OFF(stdoff));
        if (stdn[0]) jb_printf(b, "TZNAME:%s\r\n", stdn);
        jb_raw(b, "END:STANDARD\r\n");
    } else {
        int sord = sw == 5 ? -1 : sw, eord = ew == 5 ? -1 : ew;
        jb_raw(b, "BEGIN:DAYLIGHT\r\nDTSTART:19700301T020000\r\n");
        jb_printf(b, "TZOFFSETFROM:%c%02d%02d\r\nTZOFFSETTO:%c%02d%02d\r\n", OFF(stdoff), OFF(dstoff));
        jb_printf(b, "RRULE:FREQ=YEARLY;BYMONTH=%d;BYDAY=%d%s\r\n", sm, sord, wd[sd % 7]);
        if (dstn[0]) jb_printf(b, "TZNAME:%s\r\n", dstn);
        jb_raw(b, "END:DAYLIGHT\r\nBEGIN:STANDARD\r\nDTSTART:19701001T020000\r\n");
        jb_printf(b, "TZOFFSETFROM:%c%02d%02d\r\nTZOFFSETTO:%c%02d%02d\r\n", OFF(dstoff), OFF(stdoff));
        jb_printf(b, "RRULE:FREQ=YEARLY;BYMONTH=%d;BYDAY=%d%s\r\n", em, eord, wd[ed % 7]);
        if (stdn[0]) jb_printf(b, "TZNAME:%s\r\n", stdn);
        jb_raw(b, "END:STANDARD\r\n");
    }
#undef OFF
    jb_raw(b, "END:VTIMEZONE\r\n");
    return 0;
}

static void time_line(JBuf *b, const char *name, int64_t t, int allday, const char *tz) {
    char v[40], line[200];
    if (allday) { fmt_date(t, v, sizeof v); snprintf(line, sizeof line, "%s;VALUE=DATE:%s", name, v); }
    else if (tz && *tz) { char zq[80]; safe_param(tz, zq, sizeof zq); fmt_wall(t, tz, v, sizeof v); snprintf(line, sizeof line, "%s;TZID=%s:%s", name, zq, v); }
    else { fmt_utc(t, v, sizeof v); snprintf(line, sizeof line, "%s:%s", name, v); }
    ic_line(b, line);
}

static void person_line(JBuf *b, const char *prop, const char *email, const char *name, const char *ps, const char *role, int rsvp) {
    char cn[200] = "", line[700];
    safe_param(name, cn, sizeof cn);
    char e[300];
    safe_param(email, e, sizeof e);
    size_t o = (size_t)snprintf(line, sizeof line, "%s", prop);
    if (cn[0]) o += (size_t)snprintf(line + o, sizeof line - o, ";CN=\"%s\"", cn);
    if (role && *role) o += (size_t)snprintf(line + o, sizeof line - o, ";ROLE=%s", role);
    if (ps && *ps) o += (size_t)snprintf(line + o, sizeof line - o, ";PARTSTAT=%s", ps);
    if (rsvp) o += (size_t)snprintf(line + o, sizeof line - o, ";RSVP=TRUE");
    if (o < sizeof line) snprintf(line + o, sizeof line - o, ":mailto:%s", e);
    ic_line(b, line);
}

char *ical_build(const IcBuild *x, size_t *olen) {
    JBuf b;
    jb_init(&b);
    jb_raw(&b, "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//LordOS//Calendar 1.0//EN\r\nCALSCALE:GREGORIAN\r\n");
    if (x->method && *x->method) jb_printf(&b, "METHOD:%s\r\n", x->method);
    const char *tz = x->tzid && *x->tzid && tz_zone_valid(x->tzid) ? x->tzid : NULL;
    if (tz && !x->allday && (!x->is_todo || x->start)) { if (vtimezone(&b, tz)) tz = NULL; }
    jb_raw(&b, x->is_todo ? "BEGIN:VTODO\r\n" : "BEGIN:VEVENT\r\n");
    kv(&b, "UID", x->uid);
    char now[40];
    fmt_utc((int64_t)time(NULL), now, sizeof now);
    jb_printf(&b, "DTSTAMP:%s\r\nLAST-MODIFIED:%s\r\n", now, now);
    jb_printf(&b, "SEQUENCE:%d\r\n", x->sequence);
    if (!x->is_todo || x->start) time_line(&b, "DTSTART", x->start, x->allday, tz);
    if (!x->is_todo) {
        int64_t end = x->end > x->start ? x->end : x->start + (x->allday ? 86400 : 3600);
        time_line(&b, "DTEND", end, x->allday, tz);
    }
    kv(&b, "SUMMARY", x->summary);
    kv(&b, "LOCATION", x->location);
    kv(&b, "DESCRIPTION", x->description);
    if (x->url && *x->url) { char line[600]; char u[520]; safe_param(x->url, u, sizeof u); snprintf(line, sizeof line, "URL:%s", u); ic_line(&b, line); }
    /* a to-do's STATUS follows "completed" (below): one STATUS only (RFC 5545) */
    if (!x->is_todo && x->status && *x->status) { char st[32]; safe_param(x->status, st, sizeof st); jb_printf(&b, "STATUS:%s\r\n", st); }
    kv(&b, "CATEGORIES", x->categories);
    if (x->rrule && *x->rrule && safe_rrule(x->rrule)) { char line[600]; snprintf(line, sizeof line, "RRULE:%s", x->rrule); ic_line(&b, line); }
    for (int i = 0; i < x->nexdate; i++) time_line(&b, "EXDATE", x->exdate[i], x->allday, tz);
    if (x->organizer && *x->organizer) person_line(&b, "ORGANIZER", x->organizer, x->organizer_name, NULL, NULL, 0);
    for (int i = 0; i < x->natt; i++) person_line(&b, "ATTENDEE", x->att[i].email, x->att[i].name, x->att[i].partstat[0] ? x->att[i].partstat : "NEEDS-ACTION",
                                                  x->att[i].role[0] ? x->att[i].role : "REQ-PARTICIPANT", x->att[i].rsvp);
    if (x->is_todo) {
        if (x->due) time_line(&b, "DUE", x->due, x->due_allday, NULL);
        if (x->priority > 0 && x->priority <= 9) jb_printf(&b, "PRIORITY:%d\r\n", x->priority);
        if (x->completed) {
            char c[40];
            fmt_utc(x->completed > 1 ? x->completed : (int64_t)time(NULL), c, sizeof c);
            jb_printf(&b, "STATUS:COMPLETED\r\nCOMPLETED:%s\r\nPERCENT-COMPLETE:100\r\n", c);
        } else jb_raw(&b, "STATUS:NEEDS-ACTION\r\n");
        if (x->flagged) jb_raw(&b, "X-LORDOS-FLAGGED:1\r\n");
        kv(&b, "RELATED-TO", x->parent_uid);
    }
    for (int i = 0; i < x->nalarms && i < 8; i++) {
        int m = x->alarms[i];
        jb_raw(&b, "BEGIN:VALARM\r\nACTION:DISPLAY\r\n");
        kv(&b, "DESCRIPTION", x->summary && *x->summary ? x->summary : "Reminder");
        if (m >= 0) jb_printf(&b, "TRIGGER:-PT%dM\r\n", m);
        else jb_printf(&b, "TRIGGER:PT%dM\r\n", -m);
        jb_raw(&b, "END:VALARM\r\n");
    }
    jb_raw(&b, x->is_todo ? "END:VTODO\r\n" : "END:VEVENT\r\n");
    jb_raw(&b, "END:VCALENDAR\r\n");
    if (b.oom) { jb_free(&b); return NULL; }
    if (olen) *olen = b.n;
    return b.p;
}

char *ical_reply(const IcEvent *ev, const char *attendee, const char *name, const char *partstat, size_t *olen) {
    IcAttendee me;
    memset(&me, 0, sizeof me);
    snprintf(me.email, sizeof me.email, "%s", attendee);
    if (name) snprintf(me.name, sizeof me.name, "%s", name);
    snprintf(me.partstat, sizeof me.partstat, "%s", partstat);
    for (int i = 0; i < ev->natt; i++) if (!strcasecmp(ev->att[i].email, attendee)) { if (!name || !*name) snprintf(me.name, sizeof me.name, "%s", ev->att[i].name); snprintf(me.role, sizeof me.role, "%s", ev->att[i].role); }
    IcBuild b = { 0 };
    b.uid = ev->uid; b.summary = ev->summary; b.location = ev->location;
    b.start = ev->start; b.end = ev->end; b.allday = ev->allday;
    b.organizer = ev->organizer; b.organizer_name = ev->organizer_name;
    b.att = &me; b.natt = 1;
    b.sequence = ev->sequence;
    b.method = "REPLY";
    b.rrule = ev->rrule;
    return ical_build(&b, olen);
}