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
/* vjson.c — JSON in the secrets arena (see vjson.h). */
#include "vjson.h"
#include "smem.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* ================= reader ================= */
typedef struct { Vj *j; size_t p; int depth; } P;
static void ws(P *q) {
const char *s = q->j->s;
while (q->p < q->j->len && (s[q->p] == ' ' || s[q->p] == '\t' || s[q->p] == '\n' || s[q->p] == '\r')) q->p++;
}
static int tok_new(P *q, int type) {
Vj *j = q->j;
if (j->n == j->cap) {
int nc = j->cap ? j->cap * 2 : 64;
if (nc > (1 << 24)) return -1;
VjTok *t = sm_realloc(j->t, sizeof(VjTok) * (size_t)nc);
if (!t) return -1;
j->t = t;
j->cap = nc;
}
VjTok *t = &j->t[j->n];
memset(t, 0, sizeof *t);
t->type = (uint8_t)type;
t->start = (uint32_t)q->p;
return j->n++;
}
static int hexv(int c) { return c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1; }
static int parse_value(P *q);
static int parse_string(P *q) {
const char *s = q->j->s;
size_t len = q->j->len;
q->p++; /* quote */
int k = tok_new(q, VJ_STR);
if (k < 0) return -1;
while (q->p < len) {
unsigned char c = (unsigned char)s[q->p];
if (c == '"') { q->j->t[k].end = (uint32_t)q->p; q->p++; q->j->t[k].next = k + 1; return 0; }
if (c < 0x20) return -1;
if (c == '\\') {
if (q->p + 1 >= len) return -1;
char e = s[q->p + 1];
if (e == 'u') {
if (q->p + 6 > len) return -1;
for (int i = 2; i < 6; i++) if (hexv(s[q->p + i]) < 0) return -1;
q->p += 6;
continue;
}
if (!strchr("\"\\/bfnrt", e)) return -1;
q->p += 2;
continue;
}
q->p++;
}
return -1;
}
static int parse_number(P *q) {
const char *s = q->j->s;
size_t len = q->j->len, p = q->p;
int k = tok_new(q, VJ_NUM);
if (k < 0) return -1;
if (p < len && s[p] == '-') p++;
if (p >= len) return -1;
if (s[p] == '0') p++;
else if (s[p] >= '1' && s[p] <= '9') while (p < len && s[p] >= '0' && s[p] <= '9') p++;
else return -1;
if (p < len && s[p] == '.') { p++; if (p >= len || s[p] < '0' || s[p] > '9') return -1; while (p < len && s[p] >= '0' && s[p] <= '9') p++; }
if (p < len && (s[p] == 'e' || s[p] == 'E')) {
p++;
if (p < len && (s[p] == '+' || s[p] == '-')) p++;
if (p >= len || s[p] < '0' || s[p] > '9') return -1;
while (p < len && s[p] >= '0' && s[p] <= '9') p++;
}
q->j->t[k].end = (uint32_t)p;
q->j->t[k].next = k + 1;
q->p = p;
return 0;
}
static int parse_lit(P *q, const char *w, int type) {
size_t n = strlen(w);
if (q->p + n > q->j->len || memcmp(q->j->s + q->p, w, n)) return -1;
int k = tok_new(q, type);
if (k < 0) return -1;
q->p += n;
q->j->t[k].end = (uint32_t)q->p;
q->j->t[k].next = k + 1;
return 0;
}
static int parse_container(P *q, int obj) {
if (++q->depth > 64) return -1;
int k = tok_new(q, obj ? VJ_OBJ : VJ_ARR);
if (k < 0) return -1;
q->p++;
ws(q);
int count = 0;
char close = obj ? '}' : ']';
if (q->p < q->j->len && q->j->s[q->p] == close) { q->p++; goto done; }
for (;;) {
ws(q);
if (obj) {
if (q->p >= q->j->len || q->j->s[q->p] != '"') return -1;
if (parse_string(q)) return -1;
ws(q);
if (q->p >= q->j->len || q->j->s[q->p] != ':') return -1;
q->p++;
ws(q);
}
if (parse_value(q)) return -1;
count++;
ws(q);
if (q->p >= q->j->len) return -1;
char c = q->j->s[q->p++];
if (c == ',') continue;
if (c == close) break;
return -1;
}
done:
q->j->t[k].end = (uint32_t)q->p;
q->j->t[k].count = count;
q->j->t[k].next = q->j->n;
q->depth--;
return 0;
}
static int parse_value(P *q) {
ws(q);
if (q->p >= q->j->len) return -1;
char c = q->j->s[q->p];
if (c == '{') return parse_container(q, 1);
if (c == '[') return parse_container(q, 0);
if (c == '"') return parse_string(q);
if (c == 't') return parse_lit(q, "true", VJ_TRUE);
if (c == 'f') return parse_lit(q, "false", VJ_FALSE);
if (c == 'n') return parse_lit(q, "null", VJ_NULL);
return parse_number(q);
}
int vj_parse(Vj *j, const char *s, size_t len) {
memset(j, 0, sizeof *j);
j->s = s;
j->len = len;
P q = { j, 0, 0 };
if (parse_value(&q)) { vj_free(j); j->s = s; j->len = len; return -1; }
ws(&q);
if (q.p != len) { vj_free(j); return -1; }
return 0;
}
void vj_free(Vj *j) {
sm_free(j->t);
j->t = NULL;
j->n = j->cap = 0;
}
int vj_type(const Vj *j, int tok) { return tok >= 0 && tok < j->n ? j->t[tok].type : 0; }
int vj_streq(const Vj *j, int tok, const char *s) {
if (vj_type(j, tok) != VJ_STR) return 0;
const VjTok *t = &j->t[tok];
size_t n = strlen(s);
/* fast comparison if there are no escapes */
if (t->end - t->start == n && !memchr(j->s + t->start, '\\', n)) return !memcmp(j->s + t->start, s, n);
char *d = vj_str(j, tok);
int r = d && !strcmp(d, s);
sm_free(d);
return r;
}
int vj_get(const Vj *j, int obj, const char *key) {
if (vj_type(j, obj) != VJ_OBJ) return -1;
for (int k = obj + 1; k < j->t[obj].next; k = j->t[k + 1].next)
if (vj_streq(j, k, key)) return k + 1;
return -1;
}
int vj_at(const Vj *j, int arr, int i) {
if (vj_type(j, arr) != VJ_ARR || i < 0 || i >= j->t[arr].count) return -1;
int k = arr + 1;
while (i-- > 0) k = j->t[k].next;
return k;
}
static size_t put_utf8(char *d, unsigned cp) {
if (cp < 0x80) { d[0] = (char)cp; return 1; }
if (cp < 0x800) { d[0] = (char)(0xc0 | cp >> 6); d[1] = (char)(0x80 | (cp & 63)); return 2; }
if (cp < 0x10000) { d[0] = (char)(0xe0 | cp >> 12); d[1] = (char)(0x80 | ((cp >> 6) & 63)); d[2] = (char)(0x80 | (cp & 63)); return 3; }
d[0] = (char)(0xf0 | cp >> 18); d[1] = (char)(0x80 | ((cp >> 12) & 63)); d[2] = (char)(0x80 | ((cp >> 6) & 63)); d[3] = (char)(0x80 | (cp & 63));
return 4;
}
/* Unescapes s[a..b) into d (which has room for b-a bytes: it never grows). */
static size_t unescape(const char *s, size_t a, size_t b, char *d) {
size_t o = 0;
for (size_t i = a; i < b; i++) {
if (s[i] != '\\') { d[o++] = s[i]; continue; }
char e = s[++i];
switch (e) {
case 'b': d[o++] = '\b'; break;
case 'f': d[o++] = '\f'; break;
case 'n': d[o++] = '\n'; break;
case 'r': d[o++] = '\r'; break;
case 't': d[o++] = '\t'; break;
case 'u': {
unsigned cp = 0;
for (int k = 1; k <= 4; k++) cp = cp << 4 | (unsigned)hexv(s[i + k]);
i += 4;
if (cp >= 0xd800 && cp < 0xdc00 && i + 6 < b && s[i + 1] == '\\' && s[i + 2] == 'u') {
unsigned lo = 0;
for (int k = 3; k <= 6; k++) lo = lo << 4 | (unsigned)hexv(s[i + k]);
if (lo >= 0xdc00 && lo < 0xe000) { cp = 0x10000 + ((cp - 0xd800) << 10) + (lo - 0xdc00); i += 6; }
else cp = 0xfffd;
} else if (cp >= 0xd800 && cp < 0xe000) cp = 0xfffd;
if (cp == 0) cp = 0xfffd; /* no NUL inside texts */
o += put_utf8(d + o, cp);
break;
}
default: d[o++] = e; break;
}
}
return o;
}
char *vj_str(const Vj *j, int tok) {
if (vj_type(j, tok) != VJ_STR) return NULL;
const VjTok *t = &j->t[tok];
char *d = sm_alloc((size_t)(t->end - t->start) + 1);
if (!d) return NULL;
d[unescape(j->s, t->start, t->end, d)] = 0;
return d;
}
size_t vj_strbuf(const Vj *j, int tok, char *buf, size_t n) {
if (!n) return 0;
buf[0] = 0;
char *d = vj_str(j, tok);
if (!d) return 0;
size_t l = strlen(d);
if (l >= n) { /* truncate without splitting a UTF-8 character */
l = n - 1;
while (l > 0 && ((unsigned char)d[l] & 0xc0) == 0x80) l--;
}
memcpy(buf, d, l);
buf[l] = 0;
sm_free(d);
return l;
}
double vj_num(const Vj *j, int tok, double def) {
if (vj_type(j, tok) != VJ_NUM) return def;
char b[64];
size_t n = j->t[tok].end - j->t[tok].start;
if (n >= sizeof b) return def;
memcpy(b, j->s + j->t[tok].start, n);
b[n] = 0;
double v = strtod(b, NULL);
return isfinite(v) ? v : def;
}
int vj_bool(const Vj *j, int tok, int def) {
int t = vj_type(j, tok);
return t == VJ_TRUE ? 1 : t == VJ_FALSE ? 0 : def;
}
char *vj_gets(const Vj *j, int obj, const char *key) { return vj_str(j, vj_get(j, obj, key)); }
size_t vj_getsbuf(const Vj *j, int obj, const char *key, char *buf, size_t n) {
int k = vj_get(j, obj, key);
if (k < 0) { if (n) buf[0] = 0; return 0; }
return vj_strbuf(j, k, buf, n);
}
double vj_getn(const Vj *j, int obj, const char *key, double def) { return vj_num(j, vj_get(j, obj, key), def); }
int vj_getb(const Vj *j, int obj, const char *key, int def) { return vj_bool(j, vj_get(j, obj, key), def); }
/* ================= writer ================= */
void vb_init(VjB *b) { memset(b, 0, sizeof *b); b->first[0] = 1; }
void vb_free(VjB *b) { sm_free(b->p); memset(b, 0, sizeof *b); }
static int grow(VjB *b, size_t extra) {
if (b->oom) return -1;
if (b->n + extra + 1 <= b->cap) return 0;
size_t nc = b->cap ? b->cap : 256;
while (nc < b->n + extra + 1) nc *= 2;
char *p = sm_realloc(b->p, nc);
if (!p) { b->oom = 1; return -1; }
b->p = p;
b->cap = nc;
return 0;
}
void vb_rawn(VjB *b, const char *s, size_t n) {
if (grow(b, n)) return;
memcpy(b->p + b->n, s, n);
b->n += n;
b->p[b->n] = 0;
}
void vb_raw(VjB *b, const char *s) { vb_rawn(b, s, strlen(s)); }
void vb_strn(VjB *b, const char *s, size_t n) {
if (!s) { vb_raw(b, "null"); return; }
if (grow(b, n * 6 + 2)) return;
char *d = b->p + b->n;
*d++ = '"';
for (size_t i = 0; i < n; i++) {
unsigned char c = (unsigned char)s[i];
if (c == '"' || c == '\\') { *d++ = '\\'; *d++ = (char)c; }
else if (c == '\n') { *d++ = '\\'; *d++ = 'n'; }
else if (c == '\r') { *d++ = '\\'; *d++ = 'r'; }
else if (c == '\t') { *d++ = '\\'; *d++ = 't'; }
else if (c < 0x20 || c == 0x7f) { snprintf(d, 7, "\\u%04x", c); d += 6; }
else if (c >= 0x80) {
/* valid UTF-8 passes through as-is; a stray byte is replaced by U+FFFD */
int len = c >= 0xf0 && c < 0xf5 ? 4 : c >= 0xe0 ? 3 : c >= 0xc2 && c < 0xe0 ? 2 : 0;
int ok = len && i + (size_t)len <= n;
for (int k = 1; ok && k < len; k++) if (((unsigned char)s[i + k] & 0xc0) != 0x80) ok = 0;
if (ok) { memcpy(d, s + i, (size_t)len); d += len; i += (size_t)len - 1; }
else { memcpy(d, "\xef\xbf\xbd", 3); d += 3; }
} else *d++ = (char)c;
}
*d++ = '"';
b->n = (size_t)(d - b->p);
b->p[b->n] = 0;
}
void vb_str(VjB *b, const char *s) { vb_strn(b, s, s ? strlen(s) : 0); }
void vb_num(VjB *b, double v) {
char t[40];
if (!isfinite(v)) v = 0;
if (v == (double)(long long)v && fabs(v) < 9e15) snprintf(t, sizeof t, "%lld", (long long)v);
else snprintf(t, sizeof t, "%.17g", v);
vb_raw(b, t);
}
void vb_int(VjB *b, long long v) { char t[24]; snprintf(t, sizeof t, "%lld", v); vb_raw(b, t); }
void vb_sep(VjB *b) {
int d = b->depth < 63 ? b->depth : 63;
if (!b->first[d]) vb_raw(b, ",");
b->first[d] = 0;
}
void vb_open(VjB *b, char c) {
char s[2] = { c, 0 };
vb_raw(b, s);
if (b->depth < 63) b->depth++;
b->first[b->depth] = 1;
}
void vb_close(VjB *b, char c) {
char s[2] = { c, 0 };
vb_raw(b, s);
if (b->depth > 0) b->depth--;
}
void vb_key(VjB *b, const char *k) { vb_sep(b); vb_str(b, k); vb_raw(b, ":"); }
void vb_ks(VjB *b, const char *k, const char *v) { vb_key(b, k); vb_str(b, v); }
void vb_kn(VjB *b, const char *k, double v) { vb_key(b, k); vb_num(b, v); }
void vb_ki(VjB *b, const char *k, long long v) { vb_key(b, k); vb_int(b, v); }
void vb_kb(VjB *b, const char *k, int v) { vb_key(b, k); vb_raw(b, v ? "true" : "false"); }
/* ================= base64 ================= */
static const char B64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
char *b64_encode(const uint8_t *in, size_t n) {
char *o = sm_alloc((n + 2) / 3 * 4 + 1);
if (!o) return NULL;
size_t k = 0;
for (size_t i = 0; i < n; i += 3) {
uint32_t v = (uint32_t)in[i] << 16 | (i + 1 < n ? (uint32_t)in[i + 1] << 8 : 0) | (i + 2 < n ? in[i + 2] : 0);
o[k++] = B64[v >> 18 & 63];
o[k++] = B64[v >> 12 & 63];
o[k++] = i + 1 < n ? B64[v >> 6 & 63] : '=';
o[k++] = i + 2 < n ? B64[v & 63] : '=';
}
o[k] = 0;
return o;
}
uint8_t *b64_decode(const char *in, size_t n, size_t *outlen) {
uint8_t *o = sm_alloc(n / 4 * 3 + 3);
if (!o) return NULL;
uint32_t acc = 0;
int bits = 0;
size_t k = 0;
for (size_t i = 0; i < n; i++) {
char c = in[i];
int v;
if (c >= 'A' && c <= 'Z') v = c - 'A';
else if (c >= 'a' && c <= 'z') v = c - 'a' + 26;
else if (c >= '0' && c <= '9') v = c - '0' + 52;
else if (c == '+' || c == '-') v = 62;
else if (c == '/' || c == '_') v = 63;
else if (c == '=' || c == ' ' || c == '\n' || c == '\r' || c == '\t') continue;
else { sm_free(o); return NULL; }
acc = acc << 6 | (uint32_t)v;
bits += 6;
if (bits >= 8) { bits -= 8; o[k++] = (uint8_t)(acc >> bits); }
}
*outlen = k;
return o;
}