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
/* vmodel.c — contents of an open vault (see vmodel.h). Everything lives in the secrets arena. */
#include "vmodel.h"
#include "smem.h"
#include "vcrypto.h"
#include "monocypher.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#define HIST_MAX 20
void vm_init(VModel *m) { memset(m, 0, sizeof *m); }
void vm_entry_free(VEntry *e) {
if (!e) return;
sm_free(e->cat); sm_free(e->title); sm_free(e->notes);
for (int i = 0; i < e->nf; i++) { sm_free(e->f[i].k); sm_free(e->f[i].t); sm_free(e->f[i].l); sm_free(e->f[i].v); }
sm_free(e->f);
for (int i = 0; i < e->ntags; i++) sm_free(e->tags[i]);
sm_free(e->tags);
for (int i = 0; i < e->natt; i++) { sm_free(e->att[i].name); sm_free(e->att[i].mime); }
sm_free(e->att);
sm_free(e->hist); sm_free(e->x); sm_free(e->fold);
sm_free(e);
}
void vm_free(VModel *m) {
for (int i = 0; i < m->n; i++) vm_entry_free(m->e[i]);
sm_free(m->e);
sm_free(m->meta); sm_free(m->cats); sm_free(m->tags);
memset(m, 0, sizeof *m);
}
void vm_new_id(char out[33]) {
uint8_t r[16];
vc_random(r, 16);
for (int i = 0; i < 16; i++) snprintf(out + 2 * i, 3, "%02x", r[i]);
}
static int valid_id(const char *s) {
if (!s || strlen(s) != 32) return 0;
for (const char *p = s; *p; p++) if (!((*p >= '0' && *p <= '9') || (*p >= 'a' && *p <= 'f'))) return 0;
return 1;
}
/* ---- folding for search: lowercase and without accents (Latin) ---- */
static const char *fold_cp(unsigned cp, char *tmp) {
/* U+00C0–U+00FF and some of Latin Extended-A */
static const char *lat1[64] = {
"a","a","a","a","a","a","ae","c","e","e","e","e","i","i","i","i",
"d","n","o","o","o","o","o","x","o","u","u","u","u","y","th","ss",
"a","a","a","a","a","a","ae","c","e","e","e","e","i","i","i","i",
"d","n","o","o","o","o","o","/","o","u","u","u","u","y","th","y" };
if (cp >= 0xc0 && cp <= 0xff) return lat1[cp - 0xc0];
if (cp >= 0x100 && cp <= 0x17f) {
static const char base[] = "aaaaaaccccccccddddeeeeeeeeeegggggggghhhhiiiiiiiiiiiijjkkkllllllllllnnnnnnnnnoooooooorrrrrrssssssssttttttuuuuuuuuuuuuwwyyyzzzzzzs";
size_t i = cp - 0x100;
if (i < sizeof base - 1) { tmp[0] = base[i]; tmp[1] = 0; return tmp; }
}
return NULL;
}
char *vm_fold(const char *s) {
if (!s) return sm_strdup("");
size_t n = strlen(s);
char *o = sm_alloc(n * 2 + 1);
if (!o) return NULL;
size_t k = 0;
for (size_t i = 0; i < n;) {
unsigned char c = (unsigned char)s[i];
if (c < 0x80) { o[k++] = (char)(c >= 'A' && c <= 'Z' ? c + 32 : c); i++; continue; }
unsigned cp = 0;
int len = 1;
if ((c & 0xe0) == 0xc0 && i + 1 < n) { cp = (unsigned)(c & 0x1f) << 6 | (s[i + 1] & 0x3f); len = 2; }
else if ((c & 0xf0) == 0xe0 && i + 2 < n) { cp = (unsigned)(c & 0x0f) << 12 | (unsigned)(s[i + 1] & 0x3f) << 6 | (s[i + 2] & 0x3f); len = 3; }
else if ((c & 0xf8) == 0xf0 && i + 3 < n) len = 4;
char tmp[2];
const char *r = cp ? fold_cp(cp, tmp) : NULL;
if (r) { size_t rl = strlen(r); memcpy(o + k, r, rl); k += rl; }
else { memcpy(o + k, s + i, (size_t)len); k += (size_t)len; }
i += (size_t)len;
}
o[k] = 0;
return o;
}
const char *vm_field(const VEntry *e, const char *key) {
for (int i = 0; i < e->nf; i++) if (e->f[i].k && !strcmp(e->f[i].k, key)) return e->f[i].v;
return NULL;
}
const char *vm_field_type(const VEntry *e, const char *type) {
for (int i = 0; i < e->nf; i++) if (e->f[i].t && !strcmp(e->f[i].t, type) && e->f[i].v && e->f[i].v[0]) return e->f[i].v;
return NULL;
}
static int hidden_type(const char *t) { return t && (!strcmp(t, "hidden") || !strcmp(t, "totp") || !strcmp(t, "pin")); }
void vm_refresh(VEntry *e) {
VjB b;
vb_init(&b);
vb_raw(&b, e->title ? e->title : "");
for (int i = 0; i < e->nf; i++) {
if (hidden_type(e->f[i].t) || !e->f[i].v) continue;
vb_raw(&b, " ");
vb_raw(&b, e->f[i].v);
}
for (int i = 0; i < e->ntags; i++) { vb_raw(&b, " #"); vb_raw(&b, e->tags[i]); }
if (e->notes) { vb_raw(&b, " "); vb_rawn(&b, e->notes, strnlen(e->notes, 400)); }
sm_free(e->fold);
e->fold = vm_fold(b.p ? b.p : "");
vb_free(&b);
const char *pw = vm_field(e, "password");
memset(e->pwhash, 0, sizeof e->pwhash);
if (pw && pw[0]) crypto_blake2b_keyed(e->pwhash, 16, (const uint8_t *)"lordos-vault:reuse", 18, (const uint8_t *)pw, strlen(pw));
}
/* ---- load ---- */
static char *raw_of(const Vj *j, int tok, const char *def) {
if (tok < 0) return sm_strdup(def);
return sm_strndup(j->s + j->t[tok].start - (j->t[tok].type == VJ_STR ? 1 : 0),
j->t[tok].end - j->t[tok].start + (j->t[tok].type == VJ_STR ? 2 : 0));
}
static int hex16(const char *s, uint8_t *out, size_t n) {
if (!s || strlen(s) != n * 2) return -1;
for (size_t i = 0; i < n; i++) { unsigned v; if (sscanf(s + 2 * i, "%2x", &v) != 1) return -1; out[i] = (uint8_t)v; }
return 0;
}
static int load_fields(VEntry *e, const Vj *j, int arr) {
int n = j->t[arr].count;
if (n > 512) return -1;
e->f = sm_alloc(sizeof(VField) * (size_t)(n ? n : 1));
if (!e->f) return -1;
for (int i = 0, k = arr + 1; i < n; i++, k = j->t[k].next) {
if (vj_type(j, k) != VJ_OBJ) continue;
VField *f = &e->f[e->nf++];
f->k = vj_gets(j, k, "k");
f->t = vj_gets(j, k, "t");
f->l = vj_gets(j, k, "l");
f->v = vj_gets(j, k, "v");
if (!f->k) f->k = sm_strdup("");
if (!f->t) f->t = sm_strdup("text");
if (!f->v) f->v = sm_strdup("");
}
return 0;
}
static int load_tags(VEntry *e, const Vj *j, int arr) {
if (vj_type(j, arr) != VJ_ARR) return 0;
int n = j->t[arr].count;
if (n > 128) n = 128;
e->tags = sm_alloc(sizeof(char *) * (size_t)(n ? n : 1));
if (!e->tags) return -1;
for (int i = 0, k = arr + 1; i < j->t[arr].count; i++, k = j->t[k].next) {
if (e->ntags >= n) break;
char *s = vj_str(j, k);
if (s && s[0]) e->tags[e->ntags++] = s; else sm_free(s);
}
return 0;
}
static int load_atts(VEntry *e, const Vj *j, int arr) {
if (vj_type(j, arr) != VJ_ARR) return 0;
int n = j->t[arr].count;
if (n > 256) return -1;
e->att = sm_alloc(sizeof(VAtt) * (size_t)(n ? n : 1));
if (!e->att) return -1;
for (int i = 0, k = arr + 1; i < n; i++, k = j->t[k].next) {
VAtt *a = &e->att[e->natt];
char buf[80];
vj_getsbuf(j, k, "id", buf, sizeof buf);
if (hex16(buf, a->id, 16)) continue;
vj_getsbuf(j, k, "nonce", buf, sizeof buf);
if (hex16(buf, a->nonce, 24)) continue;
vj_getsbuf(j, k, "mac", buf, sizeof buf);
if (hex16(buf, a->mac, 16)) continue;
a->name = vj_gets(j, k, "name");
a->mime = vj_gets(j, k, "mime");
if (!a->name) a->name = sm_strdup("file");
if (!a->mime) a->mime = sm_strdup("application/octet-stream");
a->size = (uint64_t)vj_getn(j, k, "size", 0);
e->natt++;
}
return 0;
}
static VEntry *load_entry(const Vj *j, int o) {
VEntry *e = sm_alloc(sizeof *e);
if (!e) return NULL;
vj_getsbuf(j, o, "id", e->id, sizeof e->id);
if (!valid_id(e->id)) vm_new_id(e->id);
e->cat = vj_gets(j, o, "cat");
e->title = vj_gets(j, o, "title");
e->notes = vj_gets(j, o, "notes");
if (!e->cat) e->cat = sm_strdup("general");
if (!e->title) e->title = sm_strdup("");
e->fav = vj_getb(j, o, "fav", 0);
e->arch = vj_getb(j, o, "arch", 0);
e->rotate = (int)vj_getn(j, o, "rotate", 0);
e->trash = (int64_t)vj_getn(j, o, "trash", 0);
e->created = (int64_t)vj_getn(j, o, "created", 0);
e->modified = (int64_t)vj_getn(j, o, "modified", 0);
e->pwch = (int64_t)vj_getn(j, o, "pwch", 0);
int f = vj_get(j, o, "f");
if ((vj_type(j, f) == VJ_ARR && load_fields(e, j, f)) || load_tags(e, j, vj_get(j, o, "tags")) || load_atts(e, j, vj_get(j, o, "att"))) {
vm_entry_free(e);
return NULL;
}
int h = vj_get(j, o, "hist");
e->hist = vj_type(j, h) == VJ_ARR ? raw_of(j, h, "[]") : sm_strdup("[]");
int x = vj_get(j, o, "x");
e->x = vj_type(j, x) == VJ_OBJ ? raw_of(j, x, "{}") : NULL;
vm_refresh(e);
return e;
}
static int push(VModel *m, VEntry *e) {
if (m->n == m->cap) {
int nc = m->cap ? m->cap * 2 : 64;
VEntry **ne = sm_realloc(m->e, sizeof(VEntry *) * (size_t)nc);
if (!ne) return -1;
m->e = ne;
m->cap = nc;
}
m->e[m->n++] = e;
return 0;
}
int vm_load(VModel *m, const char *json, size_t len) {
vm_init(m);
Vj j;
if (vj_parse(&j, json, len) || vj_type(&j, 0) != VJ_OBJ) { vj_free(&j); return -1; }
int v = (int)vj_getn(&j, 0, "v", 0);
if (v != 1) { vj_free(&j); return -1; }
int meta = vj_get(&j, 0, "meta"), cats = vj_get(&j, 0, "cats"), tags = vj_get(&j, 0, "tags");
m->meta = vj_type(&j, meta) == VJ_OBJ ? raw_of(&j, meta, "{}") : sm_strdup("{}");
m->cats = vj_type(&j, cats) == VJ_ARR ? raw_of(&j, cats, "[]") : sm_strdup("[]");
m->tags = vj_type(&j, tags) == VJ_ARR ? raw_of(&j, tags, "[]") : sm_strdup("[]");
int es = vj_get(&j, 0, "entries");
if (vj_type(&j, es) == VJ_ARR) {
for (int i = 0, k = es + 1; i < j.t[es].count; i++, k = j.t[k].next) {
if (vj_type(&j, k) != VJ_OBJ) continue;
VEntry *e = load_entry(&j, k);
if (!e || push(m, e)) { vm_entry_free(e); vj_free(&j); vm_free(m); return -1; }
}
}
vj_free(&j);
return 0;
}
/* ---- save ---- */
static void hexs(VjB *b, const uint8_t *p, size_t n) {
char h[130];
for (size_t i = 0; i < n && i < 64; i++) snprintf(h + 2 * i, 3, "%02x", p[i]);
h[2 * (n < 64 ? n : 64)] = 0;
vb_str(b, h);
}
static void fields_json(VjB *b, const VEntry *e, int reveal) {
vb_key(b, "f");
vb_open(b, '[');
for (int i = 0; i < e->nf; i++) {
const VField *f = &e->f[i];
vb_sep(b);
vb_open(b, '{');
vb_ks(b, "k", f->k);
vb_ks(b, "t", f->t);
if (f->l) vb_ks(b, "l", f->l);
if (reveal || !hidden_type(f->t)) vb_ks(b, "v", f->v);
else vb_kb(b, "has", f->v && f->v[0]);
vb_close(b, '}');
}
vb_close(b, ']');
}
static void tags_json(VjB *b, const VEntry *e) {
vb_key(b, "tags");
vb_open(b, '[');
for (int i = 0; i < e->ntags; i++) { vb_sep(b); vb_str(b, e->tags[i]); }
vb_close(b, ']');
}
static void atts_json(VjB *b, const VEntry *e, int full) {
vb_key(b, "att");
vb_open(b, '[');
for (int i = 0; i < e->natt; i++) {
const VAtt *a = &e->att[i];
vb_sep(b);
vb_open(b, '{');
vb_key(b, "id"); hexs(b, a->id, 16);
vb_ks(b, "name", a->name);
vb_ks(b, "mime", a->mime);
vb_kn(b, "size", (double)a->size);
if (full) { vb_key(b, "nonce"); hexs(b, a->nonce, 24); vb_key(b, "mac"); hexs(b, a->mac, 16); }
vb_close(b, '}');
}
vb_close(b, ']');
}
static void entry_common(VjB *b, const VEntry *e) {
vb_ks(b, "id", e->id);
vb_ks(b, "cat", e->cat);
vb_ks(b, "title", e->title);
if (e->notes && e->notes[0]) vb_ks(b, "notes", e->notes);
vb_kb(b, "fav", e->fav);
vb_kb(b, "arch", e->arch);
vb_kn(b, "trash", (double)e->trash);
vb_kn(b, "created", (double)e->created);
vb_kn(b, "modified", (double)e->modified);
vb_kn(b, "pwch", (double)e->pwch);
vb_kn(b, "rotate", e->rotate);
tags_json(b, e);
}
char *vm_dump(const VModel *m, size_t *len) {
VjB b;
vb_init(&b);
vb_open(&b, '{');
vb_ki(&b, "v", 1);
vb_key(&b, "meta"); vb_raw(&b, m->meta ? m->meta : "{}");
vb_key(&b, "cats"); vb_raw(&b, m->cats ? m->cats : "[]");
vb_key(&b, "tags"); vb_raw(&b, m->tags ? m->tags : "[]");
vb_key(&b, "entries");
vb_open(&b, '[');
for (int i = 0; i < m->n; i++) {
const VEntry *e = m->e[i];
vb_sep(&b);
vb_open(&b, '{');
entry_common(&b, e);
fields_json(&b, e, 1);
atts_json(&b, e, 1);
vb_key(&b, "hist"); vb_raw(&b, e->hist ? e->hist : "[]");
if (e->x) { vb_key(&b, "x"); vb_raw(&b, e->x); }
vb_close(&b, '}');
}
vb_close(&b, ']');
vb_close(&b, '}');
if (b.oom) { vb_free(&b); return NULL; }
*len = b.n;
return b.p;
}
/* ---- for the interface ---- */
/* The history keeps the hidden values; without reveal they are removed (the JSON is rewritten). */
static void hist_json(VjB *b, const char *hist, int reveal) {
if (reveal || !hist) { vb_raw(b, hist ? hist : "[]"); return; }
Vj j;
if (vj_parse(&j, hist, strlen(hist)) || vj_type(&j, 0) != VJ_ARR) { vj_free(&j); vb_raw(b, "[]"); return; }
vb_open(b, '[');
for (int i = 0, k = 1; i < j.t[0].count; i++, k = j.t[k].next) {
vb_sep(b);
vb_open(b, '{');
vb_kn(b, "t", vj_getn(&j, k, "t", 0));
char *title = vj_gets(&j, k, "title");
vb_ks(b, "title", title ? title : "");
sm_free(title);
int f = vj_get(&j, k, "f");
vb_key(b, "f");
vb_open(b, '[');
for (int a = 0, q = f + 1; vj_type(&j, f) == VJ_ARR && a < j.t[f].count; a++, q = j.t[q].next) {
char *fk = vj_gets(&j, q, "k"), *ft = vj_gets(&j, q, "t"), *fl = vj_gets(&j, q, "l"), *fv = vj_gets(&j, q, "v");
vb_sep(b);
vb_open(b, '{');
vb_ks(b, "k", fk ? fk : "");
vb_ks(b, "t", ft ? ft : "text");
if (fl) vb_ks(b, "l", fl);
if (hidden_type(ft)) vb_kb(b, "has", fv && fv[0]); else vb_ks(b, "v", fv ? fv : "");
vb_close(b, '}');
sm_free(fk); sm_free(ft); sm_free(fl); sm_free(fv);
}
vb_close(b, ']');
vb_close(b, '}');
}
vb_close(b, ']');
vj_free(&j);
}
void vm_entry_json(VjB *b, const VEntry *e, int reveal, int hist) {
vb_open(b, '{');
entry_common(b, e);
fields_json(b, e, reveal);
atts_json(b, e, 0);
if (hist) { vb_key(b, "hist"); hist_json(b, e->hist, reveal); }
if (e->x) { vb_key(b, "x"); vb_raw(b, e->x); }
vb_close(b, '}');
}
/* list subtitle: username, email, or the last 4 digits of a card */
static const char *subtitle(const VEntry *e, char *tmp, size_t n) {
const char *u = vm_field(e, "username");
if (u && u[0]) return u;
u = vm_field(e, "email");
if (u && u[0]) return u;
u = vm_field(e, "number");
if (u && u[0] && (!strcmp(e->cat, "cards"))) {
char d[32];
int k = 0;
for (const char *p = u; *p && k < 31; p++) if (*p >= '0' && *p <= '9') d[k++] = *p;
d[k] = 0;
snprintf(tmp, n, "•••• %s", k >= 4 ? d + k - 4 : d);
return tmp;
}
/* documents: the number (if it is not hidden) */
for (int i = 0; i < e->nf; i++)
if (!strcmp(e->f[i].k, "number") && !strcmp(e->f[i].t, "text") && e->f[i].v[0]) return e->f[i].v;
for (const char *key = "ssid"; key; key = !strcmp(key, "ssid") ? "host" : !strcmp(key, "host") ? "product" : !strcmp(key, "product") ? "service" : !strcmp(key, "service") ? "account" : NULL) {
u = vm_field(e, key);
if (u && u[0]) return u;
}
return "";
}
void vm_list_json(VjB *b, const VModel *m) {
vb_open(b, '[');
char tmp[64];
for (int i = 0; i < m->n; i++) {
const VEntry *e = m->e[i];
vb_sep(b);
vb_open(b, '{');
vb_ks(b, "id", e->id);
vb_ks(b, "cat", e->cat);
vb_ks(b, "title", e->title);
vb_ks(b, "sub", subtitle(e, tmp, sizeof tmp));
const char *url = vm_field(e, "url");
if (url && url[0]) vb_ks(b, "url", url);
if (e->fav) vb_kb(b, "fav", 1);
if (e->arch) vb_kb(b, "arch", 1);
if (e->trash) vb_kn(b, "trash", (double)e->trash);
vb_kn(b, "modified", (double)e->modified);
if (e->pwch) vb_kn(b, "pwch", (double)e->pwch);
if (e->rotate) vb_kn(b, "rotate", e->rotate);
if (vm_field_type(e, "totp")) vb_kb(b, "totp", 1);
if (e->natt) vb_kn(b, "natt", e->natt);
const char *exp = vm_field(e, "expiry");
if (exp && exp[0]) vb_ks(b, "exp", exp);
if (e->ntags) tags_json(b, e);
vb_close(b, '}');
}
vb_close(b, ']');
}
void vm_search_json(VjB *b, const VModel *m, const char *q, int max) {
char *fq = vm_fold(q ? q : "");
char *words[16];
int nw = 0;
for (char *p = fq; p && *p && nw < 16;) {
while (*p == ' ') p++;
if (!*p) break;
words[nw++] = p;
while (*p && *p != ' ') p++;
if (*p) *p++ = 0;
}
vb_open(b, '[');
int found = 0;
for (int i = 0; i < m->n && found < max; i++) {
const char *s = m->e[i]->fold;
if (!s) continue;
int ok = 1;
for (int w = 0; w < nw && ok; w++) if (!strstr(s, words[w])) ok = 0;
if (!ok) continue;
vb_sep(b);
vb_str(b, m->e[i]->id);
found++;
}
vb_close(b, ']');
sm_free(fq);
}
VEntry *vm_find(const VModel *m, const char *id) {
int i = vm_index(m, id);
return i >= 0 ? m->e[i] : NULL;
}
int vm_index(const VModel *m, const char *id) {
if (!id) return -1;
for (int i = 0; i < m->n; i++) if (!strcmp(m->e[i]->id, id)) return i;
return -1;
}
int vm_remove(VModel *m, const char *id) {
int i = vm_index(m, id);
if (i < 0) return -1;
vm_entry_free(m->e[i]);
memmove(m->e + i, m->e + i + 1, sizeof(VEntry *) * (size_t)(m->n - i - 1));
m->n--;
m->dirty = 1;
return 0;
}
/* ---- create/update from the interface ---- */
static int str_eq(const char *a, const char *b) { return !strcmp(a ? a : "", b ? b : ""); }
static int fields_differ(const VEntry *a, const VEntry *b) {
if (a->nf != b->nf || !str_eq(a->title, b->title)) return 1;
for (int i = 0; i < a->nf; i++)
if (!str_eq(a->f[i].k, b->f[i].k) || !str_eq(a->f[i].v, b->f[i].v) || !str_eq(a->f[i].l, b->f[i].l) || !str_eq(a->f[i].t, b->f[i].t)) return 1;
return 0;
}
static int valid_ftype(const char *t) {
static const char *ok[] = { "text", "hidden", "url", "date", "number", "file", "totp", "email", "multiline", "pin", "bool", NULL };
for (int i = 0; ok[i]; i++) if (!strcmp(t, ok[i])) return 1;
return 0;
}
/* new entry built from the JSON; old (if any) for the "keep" fields */
static VEntry *entry_from_ui(const Vj *j, int o, const VEntry *old, char *err, size_t errn) {
VEntry *e = sm_alloc(sizeof *e);
if (!e) { snprintf(err, errn, "memory"); return NULL; }
e->cat = vj_gets(j, o, "cat");
e->title = vj_gets(j, o, "title");
e->notes = vj_gets(j, o, "notes");
if (!e->cat || !e->cat[0] || strlen(e->cat) > 64) { sm_free(e->cat); e->cat = sm_strdup(old ? old->cat : "general"); }
if (!e->title) e->title = sm_strdup("");
if (strlen(e->title) > 1024 || (e->notes && strlen(e->notes) > (1u << 20))) { vm_entry_free(e); snprintf(err, errn, "too-big"); return NULL; }
e->fav = vj_getb(j, o, "fav", old ? old->fav : 0);
e->arch = vj_getb(j, o, "arch", old ? old->arch : 0);
e->rotate = (int)vj_getn(j, o, "rotate", old ? old->rotate : 0);
if (e->rotate < 0 || e->rotate > 3650) e->rotate = 0;
int f = vj_get(j, o, "f");
int nf = vj_type(j, f) == VJ_ARR ? j->t[f].count : 0;
if (nf > 256) { vm_entry_free(e); snprintf(err, errn, "too-many-fields"); return NULL; }
e->f = sm_alloc(sizeof(VField) * (size_t)(nf ? nf : 1));
if (!e->f) { vm_entry_free(e); snprintf(err, errn, "memory"); return NULL; }
for (int i = 0, k = f + 1; i < nf; i++, k = j->t[k].next) {
if (vj_type(j, k) != VJ_OBJ) continue;
VField *d = &e->f[e->nf];
d->k = vj_gets(j, k, "k");
d->t = vj_gets(j, k, "t");
d->l = vj_gets(j, k, "l");
if (!d->k || !d->k[0] || strlen(d->k) > 64) { sm_free(d->k); d->k = sm_strdup("field"); }
if (!d->t || !valid_ftype(d->t)) { sm_free(d->t); d->t = sm_strdup("text"); }
if (vj_getb(j, k, "keep", 0) && old) {
/* keep the previous value of the field with the same key (and the same position if it repeats) */
const char *pv = NULL;
int seen = 0;
for (int q = 0; q < i; q++) if (e->f[q].k && !strcmp(e->f[q].k, d->k)) seen++;
for (int q = 0; q < old->nf; q++) if (!strcmp(old->f[q].k, d->k) && seen-- == 0) { pv = old->f[q].v; break; }
d->v = sm_strdup(pv ? pv : "");
} else d->v = vj_gets(j, k, "v");
if (!d->v) d->v = sm_strdup("");
if (strlen(d->v) > (1u << 20)) { e->nf++; vm_entry_free(e); snprintf(err, errn, "too-big"); return NULL; }
e->nf++;
}
if (load_tags(e, j, vj_get(j, o, "tags"))) { vm_entry_free(e); snprintf(err, errn, "memory"); return NULL; }
int x = vj_get(j, o, "x");
if (vj_type(j, x) == VJ_OBJ) e->x = raw_of(j, x, "{}");
else if (old && old->x) e->x = sm_strdup(old->x);
return e;
}
static void add_history(VEntry *e, const VEntry *old, int64_t now) {
VjB b;
vb_init(&b);
vb_open(&b, '[');
vb_sep(&b);
vb_open(&b, '{');
vb_kn(&b, "t", (double)(old->modified ? old->modified : now));
vb_ks(&b, "title", old->title);
fields_json(&b, old, 1);
vb_close(&b, '}');
/* the previous ones, up to HIST_MAX */
Vj j;
if (old->hist && !vj_parse(&j, old->hist, strlen(old->hist)) && vj_type(&j, 0) == VJ_ARR) {
for (int i = 0, k = 1; i < j.t[0].count && i < HIST_MAX - 1; i++, k = j.t[k].next) {
vb_sep(&b);
vb_rawn(&b, j.s + j.t[k].start, j.t[k].end - j.t[k].start);
}
vj_free(&j);
}
vb_close(&b, ']');
sm_free(e->hist);
e->hist = b.oom ? sm_strdup("[]") : b.p;
if (b.oom) vb_free(&b);
}
int vm_upsert(VModel *m, const Vj *j, int tok, VEntry **out, char *err, size_t errn) {
if (vj_type(j, tok) != VJ_OBJ) { snprintf(err, errn, "bad-entry"); return -1; }
char id[40] = "";
vj_getsbuf(j, tok, "id", id, sizeof id);
int idx = id[0] ? vm_index(m, id) : -1;
if (id[0] && idx < 0 && !valid_id(id)) { snprintf(err, errn, "bad-id"); return -1; }
VEntry *old = idx >= 0 ? m->e[idx] : NULL;
VEntry *e = entry_from_ui(j, tok, old, err, errn);
if (!e) return -1;
int64_t now = (int64_t)time(NULL);
if (old) {
memcpy(e->id, old->id, sizeof e->id);
e->created = old->created;
e->trash = (int64_t)vj_getn(j, tok, "trash", (double)old->trash);
e->pwch = old->pwch;
/* attachments: kept (they are added and removed with their own requests) */
e->att = old->att; e->natt = old->natt;
VEntry *o2 = old;
o2->att = NULL; o2->natt = 0;
if (fields_differ(e, old)) {
add_history(e, old, now);
e->modified = now;
} else {
e->hist = sm_strdup(old->hist ? old->hist : "[]");
int meta_change = e->fav != old->fav || e->arch != old->arch || e->trash != old->trash || !str_eq(e->cat, old->cat) || !str_eq(e->notes, old->notes) || e->ntags != old->ntags || e->rotate != old->rotate;
for (int i = 0; !meta_change && i < e->ntags; i++) if (strcmp(e->tags[i], old->tags[i])) meta_change = 1;
e->modified = meta_change ? now : old->modified;
if (!str_eq(e->notes, old->notes)) e->modified = now;
}
if (!str_eq(vm_field(e, "password"), vm_field(old, "password"))) e->pwch = now;
vm_refresh(e);
vm_entry_free(old);
m->e[idx] = e;
} else {
if (id[0] && valid_id(id)) snprintf(e->id, sizeof e->id, "%s", id); else vm_new_id(e->id);
e->created = (int64_t)vj_getn(j, tok, "created", (double)now);
e->modified = (int64_t)vj_getn(j, tok, "modified", (double)now);
e->pwch = vm_field(e, "password") ? e->modified : 0;
e->trash = 0;
e->hist = sm_strdup("[]");
vm_refresh(e);
if (push(m, e)) { vm_entry_free(e); snprintf(err, errn, "memory"); return -1; }
}
m->dirty = 1;
if (out) *out = e;
return 0;
}