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.

24.7 KB
Raw Blame
/* rsec.c — strict parsers for what the browser sends to the remote desktop (see rsec.h). */
#include "rsec.h"

#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>

/* ---- HTTP request head ---- */

static int is_tchar(unsigned char c) {
    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || (c && strchr("!#$%&'*+-.^_`|~", c));
}

/* a header value into a fixed field; -431 if it doesn't fit, -400 if repeated */
static int put_field(char *dst, size_t cap, const char *v, size_t vl, unsigned *seen, unsigned bit) {
    if (*seen & bit) return -400;
    *seen |= bit;
    if (vl >= cap) return -431;
    memcpy(dst, v, vl);
    dst[vl] = 0;
    return 0;
}

int rs_parse_head(const char *buf, size_t len, RsReq *r) {
    memset(r, 0, sizeof *r);
    r->content_length = -1;
    size_t lim = len < RS_MAX_HEAD ? len : RS_MAX_HEAD, end = 0;
    int found = 0;
    /* bytes allowed in a head: visible ASCII, space, tab, and CR only as part of CRLF */
    for (size_t i = 0; i < lim; i++) {
        unsigned char c = (unsigned char)buf[i];
        if (c == '\r') {
            if (i + 1 < lim && buf[i + 1] != '\n') return -400;
            if (i + 3 < lim && buf[i + 1] == '\n' && buf[i + 2] == '\r' && buf[i + 3] == '\n') { end = i; found = 1; break; }
            continue;
        }
        if (c == '\n') { if (!i || buf[i - 1] != '\r') return -400; continue; }
        if (c == '\t') continue;
        if (c < 0x20 || c > 0x7e) return -400;
    }
    if (!found) return len >= RS_MAX_HEAD ? -431 : RS_NEED_MORE;
    if (end == 0) return -400;                       /* no request line (leading CRLF) */

    /* request line: METHOD SP /target SP HTTP/1.x */
    const char *p = buf, *eol = memchr(buf, '\r', end + 1);
    size_t ml = 0;
    while (p + ml < eol && p[ml] >= 'A' && p[ml] <= 'Z') ml++;
    if (!ml || ml >= sizeof r->method || p[ml] != ' ') return -400;
    memcpy(r->method, p, ml);
    const char *tg = p + ml + 1, *sp = tg;
    while (sp < eol && *sp != ' ') sp++;
    if (sp == tg || sp >= eol || *tg != '/') return -400;
    size_t tl = (size_t)(sp - tg);
    if (tl > 400) return -414;
    const char *q = memchr(tg, '?', tl);
    if (memchr(tg, '#', tl) || memchr(tg, '\t', tl)) return -400;
    size_t pl = q ? (size_t)(q - tg) : tl, ql = q ? tl - pl - 1 : 0;
    if (pl >= sizeof r->path || ql >= sizeof r->query) return -414;
    memcpy(r->path, tg, pl);
    if (q) memcpy(r->query, q + 1, ql);
    const char *ver = sp + 1;
    int http11;
    if ((size_t)(eol - ver) == 8 && !memcmp(ver, "HTTP/1.1", 8)) http11 = 1;
    else if ((size_t)(eol - ver) == 8 && !memcmp(ver, "HTTP/1.0", 8)) http11 = 0;
    else return -400;

    /* header fields */
    unsigned seen = 0;
    int count = 0;
    for (const char *line = eol + 2; line < buf + end + 2;) {
        const char *le = memchr(line, '\r', (size_t)(buf + end + 2 - line));
        if (!le) return -400;
        if (le == line) break;
        if (++count > RS_MAX_HEADERS) return -431;
        if (*line == ' ' || *line == '\t') return -400;            /* obsolete line folding */
        const char *colon = memchr(line, ':', (size_t)(le - line));
        if (!colon || colon == line) return -400;
        for (const char *c = line; c < colon; c++) if (!is_tchar((unsigned char)*c)) return -400;   /* also no space before ':' */
        size_t nl = (size_t)(colon - line);
        const char *v = colon + 1, *ve = le;
        while (v < ve && (*v == ' ' || *v == '\t')) v++;
        while (ve > v && (ve[-1] == ' ' || ve[-1] == '\t')) ve--;
        size_t vl = (size_t)(ve - v);
        int rc = 0;
#define HDR(nm) (nl == sizeof(nm) - 1 && !strncasecmp(line, nm, nl))
        if (HDR("Host")) rc = put_field(r->host, sizeof r->host, v, vl, &seen, 1u << 0);
        else if (HDR("Origin")) rc = put_field(r->origin, sizeof r->origin, v, vl, &seen, 1u << 1);
        else if (HDR("Cookie")) rc = put_field(r->cookie, sizeof r->cookie, v, vl, &seen, 1u << 2);
        else if (HDR("Upgrade")) rc = put_field(r->upgrade, sizeof r->upgrade, v, vl, &seen, 1u << 3);
        else if (HDR("Connection")) rc = put_field(r->connection, sizeof r->connection, v, vl, &seen, 1u << 4);
        else if (HDR("Sec-WebSocket-Key")) rc = put_field(r->wskey, sizeof r->wskey, v, vl, &seen, 1u << 5);
        else if (HDR("Sec-WebSocket-Version")) rc = put_field(r->wsversion, sizeof r->wsversion, v, vl, &seen, 1u << 6);
        else if (HDR("Content-Type")) rc = put_field(r->ctype, sizeof r->ctype, v, vl, &seen, 1u << 7);
        else if (HDR("Sec-Fetch-Site")) rc = put_field(r->fetch_site, sizeof r->fetch_site, v, vl, &seen, 1u << 8);
        else if (HDR("Transfer-Encoding")) return -501;
        else if (HDR("Content-Length")) {
            if (seen & (1u << 9)) return -400;
            seen |= 1u << 9;
            if (!vl || vl > 9) return vl > 9 ? -413 : -400;
            long n = 0;
            for (size_t i = 0; i < vl; i++) {
                if (v[i] < '0' || v[i] > '9') return -400;
                n = n * 10 + (v[i] - '0');
            }
            if (n > RS_MAX_BODY) return -413;
            r->content_length = n;
        }
#undef HDR
        if (rc) return rc;
        line = le + 2;
    }
    if (http11 && !r->host[0]) return -400;
    r->head_len = end + 4;
    return (int)r->head_len;
}

int rs_valid_username(const char *u) {
    size_t n = u ? strlen(u) : 0;
    if (!n || n > 32 || !((u[0] >= 'a' && u[0] <= 'z') || u[0] == '_')) return 0;
    for (const char *p = u; *p; p++)
        if (!((*p >= 'a' && *p <= 'z') || (*p >= '0' && *p <= '9') || *p == '_' || *p == '-')) return 0;
    return 1;
}

static int valid_port(const char *p) {
    size_t n = strlen(p);
    if (!n || n > 5 || p[0] == '0') return 0;
    long v = 0;
    for (size_t i = 0; i < n; i++) { if (p[i] < '0' || p[i] > '9') return 0; v = v * 10 + (p[i] - '0'); }
    return v > 0 && v < 65536;
}

int rs_valid_host(const char *h) {
    size_t n = h ? strlen(h) : 0;
    if (!n || n > 260) return 0;
    char buf[264];
    memcpy(buf, h, n + 1);
    if (buf[0] == '[') {
        char *rb = strchr(buf, ']');
        if (!rb) return 0;
        *rb = 0;
        unsigned char a[16];
        if (inet_pton(AF_INET6, buf + 1, a) != 1) return 0;
        if (!rb[1]) return 1;
        return rb[1] == ':' && valid_port(rb + 2);
    }
    char *colon = strchr(buf, ':');
    if (colon) { *colon = 0; if (!valid_port(colon + 1)) return 0; }
    size_t l = strlen(buf);
    if (!l || l > 253 || buf[0] == '-' || buf[0] == '.' || buf[l - 1] == '-') return 0;
    for (size_t i = 0; i < l; i++) {
        char c = buf[i];
        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '.')) return 0;
        if (c == '.' && buf[i + 1] == '.') return 0;
    }
    return 1;
}

int rs_same_origin(const char *origin, const char *host) {
    if (!origin || !host || !rs_valid_host(host)) return 0;
    if (strncmp(origin, "https://", 8)) return 0;
    return !strcasecmp(origin + 8, host);
}

int rs_has_token(const char *list, const char *token) {
    size_t tl = strlen(token);
    for (const char *p = list; p && *p;) {
        while (*p == ' ' || *p == '\t' || *p == ',') p++;
        const char *e = p;
        while (*e && *e != ',') e++;
        const char *te = e;
        while (te > p && (te[-1] == ' ' || te[-1] == '\t')) te--;
        if ((size_t)(te - p) == tl && !strncasecmp(p, token, tl)) return 1;
        p = e;
    }
    return 0;
}

static int b64c(char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '+' || c == '/'; }

int rs_valid_wskey(const char *k) {
    if (!k || strlen(k) != 24 || k[22] != '=' || k[23] != '=') return 0;
    for (int i = 0; i < 22; i++) if (!b64c(k[i])) return 0;
    return strchr("AQgw", k[21]) != NULL;             /* the last 4 bits must be zero */
}

int rs_form_type(const char *ct) {
    static const char base[] = "application/x-www-form-urlencoded";
    if (!ct || strncasecmp(ct, base, sizeof base - 1)) return 0;
    const char *p = ct + sizeof base - 1;
    while (*p == ' ') p++;
    if (!*p) return 1;
    if (*p++ != ';') return 0;
    while (*p == ' ') p++;
    if (strncasecmp(p, "charset=", 8)) return 0;
    p += 8;
    int quoted = *p == '"';
    if (quoted) p++;
    if (strncasecmp(p, "utf-8", 5)) return 0;
    p += 5;
    if (quoted && *p++ != '"') return 0;
    while (*p == ' ') p++;
    return !*p;
}

int rs_cookie_token(const char *cookie, const char *name, char out[65]) {
    out[0] = 0;
    size_t nl = strlen(name);
    int found = 0;
    for (const char *p = cookie ? cookie : ""; *p;) {
        while (*p == ' ' || *p == ';') p++;
        const char *e = p;
        while (*e && *e != ';') e++;
        const char *eq = memchr(p, '=', (size_t)(e - p));
        if (eq && (size_t)(eq - p) == nl && !memcmp(p, name, nl)) {
            const char *v = eq + 1, *ve = e;
            while (ve > v && ve[-1] == ' ') ve--;
            if (found++ || ve - v != 64) return -2;
            for (const char *c = v; c < ve; c++) if (!((*c >= '0' && *c <= '9') || (*c >= 'a' && *c <= 'f'))) return -2;
            memcpy(out, v, 64);
            out[64] = 0;
        }
        p = e;
    }
    return found ? 0 : -1;
}

/* ---- login form ---- */

static int hexv(char c) {
    return c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
}

/* decodes v[0..vl) into out (cap bytes); returns the length, -1 malformed, -2 too long */
static long form_decode(const char *v, size_t vl, char *out, size_t cap) {
    size_t o = 0;
    for (size_t i = 0; i < vl; i++) {
        char c = v[i];
        if (c == '%') {
            if (i + 2 >= vl) return -1;
            int h = hexv(v[i + 1]), l = hexv(v[i + 2]);
            if (h < 0 || l < 0) return -1;
            c = (char)(h << 4 | l);
            i += 2;
        } else if (c == '+') c = ' ';
        if (o >= cap) return -2;
        out[o++] = c;
    }
    return (long)o;
}

void rs_log_clean(const char *in, size_t inlen, char *out, size_t n) {
    size_t o = 0;
    for (size_t i = 0; i < inlen && o + 1 < n; i++) {
        unsigned char c = (unsigned char)in[i];
        out[o++] = c >= 0x20 && c < 0x7f && c != '"' && c != '\\' ? (char)c : '?';
    }
    if (n) out[o] = 0;
}

int rs_parse_login(const char *body, size_t len, char user[33], char pass[RS_PASS_MAX + 1], size_t *passlen, char rawuser[33]) {
    user[0] = pass[0] = rawuser[0] = 0;
    *passlen = 0;
    if (len > RS_MAX_BODY) return RS_FORM_BAD;
    for (size_t i = 0; i < len; i++) {
        unsigned char c = (unsigned char)body[i];
        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || strchr("-._~*%+=&", c)) || !c) return RS_FORM_BAD;
    }
    int have_u = 0, have_p = 0;
    char ubuf[64];
    long ul = -1, pl = -1;
    for (size_t i = 0; i < len;) {
        size_t e = i;
        while (e < len && body[e] != '&') e++;
        const char *f = body + i;
        size_t fl = e - i;
        const char *eq = memchr(f, '=', fl);
        if (!eq) return RS_FORM_BAD;
        size_t kl = (size_t)(eq - f);
        if (kl == 4 && !memcmp(f, "user", 4)) {
            if (have_u++) return RS_FORM_BAD;
            ul = form_decode(eq + 1, fl - 5, ubuf, sizeof ubuf - 1);
            if (ul == -1) return RS_FORM_BAD;
        } else if (kl == 4 && !memcmp(f, "pass", 4)) {
            if (have_p++) return RS_FORM_BAD;
            pl = form_decode(eq + 1, fl - 5, pass, RS_PASS_MAX);
            if (pl == -1) return RS_FORM_BAD;
        } else return RS_FORM_BAD;
        i = e + 1;
        if (e == len - 1 && body[e] == '&') return RS_FORM_BAD;      /* trailing '&' */
    }
    if (!have_u || !have_p) { explicit_bzero(pass, RS_PASS_MAX + 1); return RS_FORM_BAD; }
    if (ul >= 0) { ubuf[ul] = 0; rs_log_clean(ubuf, (size_t)ul, rawuser, 33); }
    else rs_log_clean("(too long)", 10, rawuser, 33);
    if (ul <= 0 || ul > 32 || memchr(ubuf, 0, (size_t)ul) || !rs_valid_username(ubuf)) { explicit_bzero(pass, RS_PASS_MAX + 1); return RS_FORM_USER; }
    memcpy(user, ubuf, (size_t)ul + 1);
    if (pl <= 0 || memchr(pass, 0, (size_t)pl)) { explicit_bzero(pass, RS_PASS_MAX + 1); return RS_FORM_PASS; }
    pass[pl] = 0;
    *passlen = (size_t)pl;
    return RS_FORM_OK;
}

/* ---- WebSocket ---- */

int rs_utf8_valid(const unsigned char *p, size_t n) {
    for (size_t i = 0; i < n;) {
        unsigned char c = p[i];
        if (c < 0x80) { i++; continue; }
        size_t k;
        uint32_t cp, min;
        if ((c & 0xe0) == 0xc0) { k = 1; cp = c & 0x1f; min = 0x80; }
        else if ((c & 0xf0) == 0xe0) { k = 2; cp = c & 0x0f; min = 0x800; }
        else if ((c & 0xf8) == 0xf0) { k = 3; cp = c & 0x07; min = 0x10000; }
        else return 0;
        if (n - i <= k) return 0;
        for (size_t j = 1; j <= k; j++) {
            if ((p[i + j] & 0xc0) != 0x80) return 0;
            cp = cp << 6 | (p[i + j] & 0x3f);
        }
        if (cp < min || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) return 0;
        i += k + 1;
    }
    return 1;
}

void rs_ws_init(RsWs *w, size_t max) { memset(w, 0, sizeof *w); w->max = max; }

void rs_ws_free(RsWs *w) {
    if (w->msg) { explicit_bzero(w->msg, w->msg_cap); free(w->msg); }
    memset(w, 0, sizeof *w);
}

int rs_ws_consume(RsWs *w, unsigned char *buf, size_t n, size_t *used, RsWsOn on, void *ud) {
    size_t off = 0;
    int rc = 0;
    while (n - off >= 2) {
        unsigned char *f = buf + off;
        size_t avail = n - off;
        int fin = f[0] & 0x80, op = f[0] & 15;
        if (f[0] & 0x70) { rc = 1002; break; }                  /* no extensions were negotiated */
        if (!(f[1] & 0x80)) { rc = 1002; break; }               /* client frames are masked */
        if ((op > 2 && op < 8) || op > 10) { rc = 1002; break; }
        uint64_t len = f[1] & 127;
        size_t hl = 2;
        if (len == 126) {
            if (avail < 4) break;
            len = (uint64_t)f[2] << 8 | f[3];
            hl = 4;
            if (len < 126) { rc = 1002; break; }                /* not the shortest encoding */
        } else if (len == 127) {
            if (avail < 10) break;
            len = 0;
            for (int i = 0; i < 8; i++) len = len << 8 | f[2 + i];
            hl = 10;
            if (len >> 63 || len < 65536) { rc = 1002; break; }
        }
        int control = op >= 8;
        if (control && (!fin || len > 125)) { rc = 1002; break; }
        if (len > w->max) { rc = 1009; break; }
        if (avail - hl < 4 || avail - hl - 4 < len) break;      /* frame not complete yet */
        unsigned char *m = f + hl, *p = f + hl + 4;
        for (uint64_t i = 0; i < len; i++) p[i] ^= m[i & 3];
        off += hl + 4 + (size_t)len;
        if (control) {
            unsigned char c[126];
            memcpy(c, p, (size_t)len);
            c[len] = 0;
            on(ud, op, c, (size_t)len);
            if (op == 8) break;
            continue;
        }
        if (op == 0 && !w->frag_op) { rc = 1002; break; }       /* continuation of nothing */
        if (op != 0 && w->frag_op) { rc = 1002; break; }        /* new message inside a fragmented one */
        if (op != 0) { w->frag_op = op; w->msg_len = 0; }
        if (w->msg_len + len > w->max) { rc = 1009; break; }
        if (w->msg_len + len + 1 > w->msg_cap) {
            size_t cap = w->msg_cap ? w->msg_cap : 4096;
            while (cap < w->msg_len + len + 1) cap *= 2;
            unsigned char *nb = realloc(w->msg, cap);
            if (!nb) { rc = 1011; break; }
            w->msg = nb;
            w->msg_cap = cap;
        }
        memcpy(w->msg + w->msg_len, p, (size_t)len);
        w->msg_len += (size_t)len;
        if (!fin) continue;
        w->msg[w->msg_len] = 0;
        int mop = w->frag_op;
        w->frag_op = 0;
        if (mop == 1 && !rs_utf8_valid(w->msg, w->msg_len)) { rc = 1007; break; }
        on(ud, mop, w->msg, w->msg_len);
        w->msg_len = 0;
    }
    *used = off;
    return rc;
}

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

static void jws(const char *j, size_t n, size_t *i) { while (*i < n && (j[*i] == ' ' || j[*i] == '\t' || j[*i] == '\n' || j[*i] == '\r')) (*i)++; }

static int hex4(const char *j, size_t n, size_t i, unsigned *v) {
    if (i + 4 > n) return -1;
    *v = 0;
    for (int k = 0; k < 4; k++) { int h = hexv(j[i + k]); if (h < 0) return -1; *v = *v << 4 | (unsigned)h; }
    return 0;
}

static int put_utf8(char *sb, size_t cap, size_t *so, unsigned cp) {
    if (*so + 5 > cap) return -1;
    if (cp < 0x80) sb[(*so)++] = (char)cp;
    else if (cp < 0x800) { sb[(*so)++] = (char)(0xc0 | cp >> 6); sb[(*so)++] = (char)(0x80 | (cp & 63)); }
    else if (cp < 0x10000) { sb[(*so)++] = (char)(0xe0 | cp >> 12); sb[(*so)++] = (char)(0x80 | ((cp >> 6) & 63)); sb[(*so)++] = (char)(0x80 | (cp & 63)); }
    else { sb[(*so)++] = (char)(0xf0 | cp >> 18); sb[(*so)++] = (char)(0x80 | ((cp >> 12) & 63)); sb[(*so)++] = (char)(0x80 | ((cp >> 6) & 63)); sb[(*so)++] = (char)(0x80 | (cp & 63)); }
    return 0;
}

int rs_json_parse(const char *j, size_t n, RsJson *o, char *sb, size_t cap) {
    memset(o, 0, sizeof *o);
    size_t i = 0, so = 0;
    jws(j, n, &i);
    if (i >= n || j[i++] != '{') return -1;
    jws(j, n, &i);
    if (i < n && j[i] == '}') { i++; goto done; }
    for (;;) {
        if (o->n >= RS_JMAX) return -1;
        jws(j, n, &i);
        if (i >= n || j[i++] != '"') return -1;
        size_t ks = i;
        while (i < n && j[i] >= 'a' && j[i] <= 'z') i++;
        size_t kl = i - ks;
        if (!kl || kl > 11 || i >= n || j[i++] != '"') return -1;
        int k = o->n;
        memcpy(o->key[k], j + ks, kl);
        o->key[k][kl] = 0;
        for (int m = 0; m < k; m++) if (!strcmp(o->key[m], o->key[k])) return -1;
        jws(j, n, &i);
        if (i >= n || j[i++] != ':') return -1;
        jws(j, n, &i);
        if (i >= n) return -1;
        if (j[i] == '"') {
            i++;
            size_t start = so;
            for (;;) {
                if (i >= n) return -1;
                unsigned char c = (unsigned char)j[i];
                if (c == '"') { i++; break; }
                if (c < 0x20) return -1;
                if (c != '\\') { if (so + 2 > cap) return -1; sb[so++] = (char)c; i++; continue; }
                if (++i >= n) return -1;
                char e = j[i++];
                unsigned cp;
                switch (e) {
                case '"': cp = '"'; break;
                case '\\': cp = '\\'; break;
                case '/': cp = '/'; break;
                case 'b': cp = 8; break;
                case 'f': cp = 12; break;
                case 'n': cp = 10; break;
                case 'r': cp = 13; break;
                case 't': cp = 9; break;
                case 'u':
                    if (hex4(j, n, i, &cp)) return -1;
                    i += 4;
                    if (cp >= 0xdc00 && cp <= 0xdfff) return -1;           /* lone low surrogate */
                    if (cp >= 0xd800 && cp <= 0xdbff) {
                        unsigned lo;
                        if (i + 2 > n || j[i] != '\\' || j[i + 1] != 'u' || hex4(j, n, i + 2, &lo) || lo < 0xdc00 || lo > 0xdfff) return -1;
                        i += 6;
                        cp = 0x10000 + ((cp - 0xd800) << 10) + (lo - 0xdc00);
                    }
                    if (!cp) return -1;
                    break;
                default: return -1;
                }
                if (put_utf8(sb, cap, &so, cp)) return -1;
            }
            if (so + 1 > cap) return -1;
            sb[so] = 0;
            o->is_str[k] = 1;
            o->str[k] = sb + start;
            o->slen[k] = so - start;
            so++;
        } else {
            int neg = 0;
            if (j[i] == '-') { neg = 1; i++; }
            size_t ds = i;
            long long v = 0;
            while (i < n && j[i] >= '0' && j[i] <= '9') {
                if (i - ds >= 16) return -1;
                v = v * 10 + (j[i] - '0');
                i++;
            }
            size_t dl = i - ds;
            if (!dl || (dl > 1 && j[ds] == '0')) return -1;
            if (i < n && (j[i] == '.' || j[i] == 'e' || j[i] == 'E')) return -1;
            if (v >= (1LL << 53)) return -1;
            o->num[k] = neg ? -v : v;
        }
        o->n++;
        jws(j, n, &i);
        if (i >= n) return -1;
        if (j[i] == ',') { i++; continue; }
        if (j[i] == '}') { i++; break; }
        return -1;
    }
done:
    jws(j, n, &i);
    return i == n ? 0 : -1;
}

const char *rs_json_str(const RsJson *o, const char *key, size_t *len) {
    for (int i = 0; i < o->n; i++)
        if (o->is_str[i] && !strcmp(o->key[i], key)) { if (len) *len = o->slen[i]; return o->str[i]; }
    return NULL;
}

int rs_json_num(const RsJson *o, const char *key, long long *v) {
    for (int i = 0; i < o->n; i++)
        if (!o->is_str[i] && !strcmp(o->key[i], key)) { *v = o->num[i]; return 0; }
    return -1;
}

static long long clampll(long long v, long long lo, long long hi) { return v < lo ? lo : v > hi ? hi : v; }

int rs_browser_input(const RsJson *j, int W, int H, RsInput *in) {
    memset(in, 0, sizeof *in);
    size_t tl = 0;
    const char *t = rs_json_str(j, "t", &tl);
    long long a, b;
    size_t pl = 0;
    if (!t || tl > 6) return RS_IN_NONE;
    if (!strcmp(t, "m")) {
        if (W <= 0 || H <= 0 || rs_json_num(j, "x", &a) || rs_json_num(j, "y", &b)) return RS_IN_NONE;
        in->a = (int)clampll(a, 0, W - 1);
        in->b = (int)clampll(b, 0, H - 1);
        return in->type = RS_IN_PTR;
    }
    if (!strcmp(t, "b")) {
        if (rs_json_num(j, "b", &a) || rs_json_num(j, "d", &b) || a < 0 || a > 2) return RS_IN_NONE;
        in->a = (int)a;
        in->b = b != 0;
        return in->type = RS_IN_BTN;
    }
    if (!strcmp(t, "w")) {
        if (rs_json_num(j, "d", &a) || !a) return RS_IN_NONE;
        in->a = (int)clampll(a, -10, 10);
        return in->type = RS_IN_WHEEL;
    }
    if (!strcmp(t, "s") || !strcmp(t, "pz")) {
        int sc = t[0] == 's';
        long long v1, v2;
        if (rs_json_num(j, "p", &a) || a < 1 || a > 3) return RS_IN_NONE;
        if (rs_json_num(j, sc ? "x" : "s", &v1) || rs_json_num(j, sc ? "y" : "r", &v2)) return RS_IN_NONE;
        in->a = (int)a;
        if (sc) {
            in->v1 = (int32_t)clampll(v1, -4000LL * 256, 4000LL * 256);
            in->v2 = (int32_t)clampll(v2, -4000LL * 256, 4000LL * 256);
            return in->type = RS_IN_SCROLL;
        }
        in->v1 = (int32_t)clampll(v1, 3277, 20LL * 65536);          /* scale 0.05 .. 20 */
        in->v2 = (int32_t)clampll(v2, -360LL * 256 * 4, 360LL * 256 * 4);
        return in->type = RS_IN_PINCH;
    }
    if (!strcmp(t, "k")) {
        /* keyboard keys only (KEY_ESC .. KEY_MICMUTE): no BTN_* codes */
        if (rs_json_num(j, "c", &a) || rs_json_num(j, "d", &b) || a < 1 || a > 248) return RS_IN_NONE;
        in->a = (int)a;
        in->b = b != 0;
        return in->type = RS_IN_KEY;
    }
    if (!strcmp(t, "resize")) {
        if (rs_json_num(j, "w", &a) || rs_json_num(j, "h", &b) || a < 640 || b < 480 || a > 3840 || b > 2400) return RS_IN_NONE;
        in->a = (int)(a & ~1LL);
        in->b = (int)(b & ~1LL);
        /* optional: the browser screen's refresh rate (24..360 Hz), for the video's frame rate */
        long long hz = 0;
        if (!rs_json_num(j, "hz", &hz) && (hz < 24 || hz > 360)) return RS_IN_NONE;
        in->v1 = (int32_t)hz;
        return in->type = RS_IN_RESIZE;
    }
    if (!strcmp(t, "ping")) {
        if (rs_json_num(j, "ts", &a) || a < 0) return RS_IN_NONE;
        in->ts = a;
        return in->type = RS_IN_PING;
    }
    if (!strcmp(t, "clip")) {
        size_t l = 0;
        const char *x = rs_json_str(j, "text", &l);
        if (!x || !l || l > RS_CLIP_MAX) return RS_IN_NONE;
        in->text = x;
        in->tlen = l;
        return in->type = RS_IN_CLIP;
    }
    /* the video path's signaling (docs/REMOTE.md, "Video (WebRTC)"); the SDP and the candidate are
     * parsed strictly afterwards by rtcwire.c */
    if (!strcmp(t, "rtc")) {
        size_t l = 0;
        const char *x = rs_json_str(j, "sdp", &l);
        if (!x || l < 10 || l > RS_SDP_MAX) return RS_IN_NONE;
        if (rs_json_str(j, "p", &pl) || (!rs_json_num(j, "p", &a) && (a < 1 || a > 1000000))) return RS_IN_NONE;
        in->a = rs_json_num(j, "p", &a) ? 0 : (int)a;           /* the peer it is for (0: not said) */
        in->text = x;
        in->tlen = l;
        return in->type = RS_IN_RTC;
    }
    if (!strcmp(t, "ice")) {
        size_t l = 0;
        const char *x = rs_json_str(j, "c", &l);
        if (!x || l > 512) return RS_IN_NONE;
        if (rs_json_str(j, "p", &pl) || (!rs_json_num(j, "p", &a) && (a < 1 || a > 1000000))) return RS_IN_NONE;
        in->a = rs_json_num(j, "p", &a) ? 0 : (int)a;
        in->text = x;
        in->tlen = l;
        return in->type = RS_IN_ICE;
    }
    if (!strcmp(t, "vmode")) {
        if (rs_json_num(j, "on", &a) || (a != 0 && a != 1)) return RS_IN_NONE;
        in->a = (int)a;
        return in->type = RS_IN_VMODE;
    }
    return RS_IN_NONE;
}