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.

71.6 KB
Raw Blame
/* rtc.c — the remote desktop's WebRTC peer (docs/REMOTE.md, "Video (WebRTC)").
 *
 * It lives in the bridge, the process that already dropped root for good (conn.c): everything here
 * runs as the user who signed in. Debian 13 packages no WebRTC library we could use (no
 * libdatachannel, no libjuice), so this is our own small peer on top of what Debian does ship:
 *   - ICE-lite (RFC 8445 §2.5): the browser is the controlling agent and checks us; we only answer
 *     checks signed with our ICE password, from addresses the remote desktop's rules allow. A second
 *     UDP socket is a plain STUN server for this connection only (the browser is told to use it), so a
 *     LAN works with no outside server. It has to be another port: browsers hand every STUN packet
 *     from their STUN server's address to the server's own request handler, ICE answers included.
 *   - ICE over TCP (RFC 6544): passive candidates on the remote desktop's own TCP port, for networks
 *     that drop UDP. lord-sessiond's root connection child reads the first framed check of such a
 *     connection, picks the bridge by the first 8 characters of its user name (our "route") and hands
 *     the socket over; everything after that, the check's integrity included, is ours.
 *   - ICE restarts: a later offer brings new credentials for both sides over the same DTLS association,
 *     so a changed or interrupted network path recovers without a new sign-in or a new peer.
 *   - DTLS 1.2 with OpenSSL (lord-sessiond already links it), we are the server; the browser's
 *     certificate must hash to the fingerprint in the offer that came over the authenticated
 *     WebSocket, or the connection ends.
 *   - SRTP with libsrtp2 (keys exported from DTLS), RTCP feedback (NACK, PLI, FIR, receiver reports).
 *   - The data channels over SCTP with usrsctp (no threads: its timers run from rtc_tick).
 *   - Optional external STUN (our public address) and TURN (a relayed candidate; the relay only ever
 *     sees DTLS and SRTP), reached over UDP, TCP or TLS (checked against the system's CAs and the
 *     server's name, or a pinned fingerprint). The TURN password never leaves this process and is never
 *     logged.
 * Every packet goes through the strict parsers in rtcwire.c first. */
#include "rtc.h"
#include "sessiond.h"

#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include <ifaddrs.h>
#include <net/if.h>
#include <netdb.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/random.h>
#include <netinet/tcp.h>
#include <poll.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>

#include <openssl/err.h>
#include <openssl/evp.h>
#include <openssl/hmac.h>
#include <openssl/ssl.h>
#include <openssl/x509.h>
#include <srtp2/srtp.h>
#include <usrsctp.h>

#define MTU 1100                /* RTP payload: fits a 1200-byte path with SRTP and a TURN header */
#define HIST 1024               /* sent video packets kept for retransmission (NACK) */
#define MAX_PATHS 8
#define MAX_DC_MSG 262144       /* what our answer advertises (a=max-message-size) */
#define CONSENT_MS 45000        /* no valid check for this long: the browser is gone (restarts can't help) */
#define CONNECT_MS 20000        /* from an offer (or a restart) until DTLS is up */
#define ANSWER_WAIT_MS 1200     /* for the external STUN/TURN answers before sending ours */
#define ANSWER_WAIT_TCP_MS 3000 /* the same with a TURN server over TCP or TLS (connect, handshake) */
#define MAX_TCP 4               /* ICE-TCP connections per peer */
#define TCP_CHECK_MS 10000      /* a new ICE-TCP connection must bring a valid check by then */
#define TCP_OUT_MAX (1u << 20)  /* queued bytes per stream; past it a packet is dropped (media is lossy) */

typedef struct { uint16_t seq, len; uint8_t b[MTU + 64]; } Hist;
typedef struct {
    uint32_t ssrc, ts_off, last_ts, packets, octets;
    uint32_t last_in;           /* the encoder's last time (ms or samples), to keep the clock going forward */
    int have_in;
    uint16_t seq;
    int pt;
    double last_ms;
    Hist *hist;
} Track;
/* tcp: 0 for UDP, else the ICE-TCP connection's slot + 1 */
typedef struct { RwAddr a; int relay, tcp, valid, nominated, proven; double last; } Path;
/* A byte stream we write packets to without blocking: an ICE-TCP connection or the TURN server's */
typedef struct { uint8_t *b; size_t len, off, cap; } OutQ;
typedef struct {
    int fd;
    RwAddr peer;
    uint8_t in[RW_TCP_FRAME_MAX + 2];
    size_t inl;
    OutQ out;
    double born;
    int checked;                /* a valid ICE check came over it */
} TcpConn;
typedef struct {
    int state;                  /* 0 off, 1 asked, 2 asked with credentials, 3 allocated, -1 failed */
    RwAddr srv, relayed, mapped;
    uint8_t tid[12], key[16];
    char realm[256];
    uint8_t nonce[256];
    size_t nlen;
    double refresh_at, perm_at, sent_at;
    int tries;
    RwAddr perm[8];
    int nperm, perm_dirty;
    /* over TCP or TLS: the stream (fd), its TLS, whether it is connected and handshaken */
    int transport, fd, up, connecting;
    char host[96];
    SSL_CTX *tctx;
    SSL *tssl;
    uint8_t in[RW_STUN_MAX];
    size_t inl;
    OutQ out;
    double started;
} Turn;

struct Rtc {
    RtcCallbacks cb;
    RtcConfig cfg;
    int fd, port, sfd, sport;          /* media socket; the built-in STUN server's socket */
    char ufrag[13], pwd[25];           /* ufrag: the route (8) + 4 random, new at each ICE restart */
    TcpConn tcp[MAX_TCP];
    unsigned restarts;
    unsigned long checks;              /* valid ICE checks since the last offer */
    /* DTLS */
    SSL_CTX *ctx;
    SSL *ssl;
    BIO *rbio;
    EVP_PKEY *key;
    X509 *cert;
    uint8_t fp[32];
    int dtls_up;
    /* the browser */
    RwOffer *of;
    int offered, codec, answered;
    double answer_due;
    RwAddr rcand[16];
    int nrcand;
    Path path[MAX_PATHS];
    int npath, sel;
    /* SRTP */
    srtp_t tx, rx;
    int srtp_up;
    /* SCTP and the data channels */
    struct socket *sctp;
    int sctp_on, dc_sid[2], dc_open[2];
    uint8_t *rasm;              /* a message being reassembled */
    size_t rasm_len;
    int rasm_sid, rasm_ppid;
    double sctp_t;
    Track v, a;
    /* congestion: the viewer's target */
    unsigned kbps, remb;        /* remb: the browser's last estimate (kbit/s) */
    double rate_at, kf_at, lost, congested_at;
    unsigned long nacks, plis, resent, dtls_rx;
    double last_sr, created, last_consent, stun_win;
    int stun_n, failed;
    /* external STUN, TURN */
    RwAddr stun_srv[RTC_MAX_STUN];
    uint8_t stun_tid[RTC_MAX_STUN][12];
    int nstun_srv;
    RwAddr srflx;
    Turn turn;
};

static int srtp_ready, sctp_ready, gcm_ok = -1;

static double now_ms(void) {
    struct timespec t;
    clock_gettime(CLOCK_MONOTONIC, &t);
    return t.tv_sec * 1e3 + t.tv_nsec / 1e6;
}

static void rnd(void *p, size_t n) { if (getrandom(p, n, 0) != (ssize_t)n) memset(p, 0x5a, n); }

static void rnd_text(char *out, size_t n) {
    static const char al[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    uint8_t b[64];
    rnd(b, n);
    for (size_t i = 0; i < n; i++) out[i] = al[b[i] % (sizeof al - 1)];
    out[n] = 0;
}

/* code: RTC_WHY_* for the browser; why: the journal's line */
static void fail(Rtc *r, const char *code, const char *why) {
    if (r->failed) return;
    r->failed = 1;
    sd_log("video: %s", why);
    if (r->cb.state) r->cb.state(r->cb.ud, RTC_FAILED, code);
}

static void hmac_sha1(const uint8_t *key, size_t klen, const uint8_t *msg, size_t n, uint8_t out[20]) {
    unsigned int l = 20;
    if (!HMAC(EVP_sha1(), key, (int)klen, msg, n, out, &l)) memset(out, 0, 20);
}

/* ---- addresses ---- */

static void to_sockaddr(const RwAddr *a, struct sockaddr_in6 *s) {
    memset(s, 0, sizeof *s);
    s->sin6_family = AF_INET6;
    s->sin6_port = htons(a->port);
    if (a->family == 4) { s->sin6_addr.s6_addr[10] = 0xff; s->sin6_addr.s6_addr[11] = 0xff; memcpy(s->sin6_addr.s6_addr + 12, a->a, 4); }
    else memcpy(s->sin6_addr.s6_addr, a->a, 16);
}

static void from_sockaddr(const struct sockaddr_in6 *s, RwAddr *a) {
    static const uint8_t mapped[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
    memset(a, 0, sizeof *a);
    a->port = ntohs(s->sin6_port);
    if (!memcmp(s->sin6_addr.s6_addr, mapped, 12)) { a->family = 4; memcpy(a->a, s->sin6_addr.s6_addr + 12, 4); }
    else { a->family = 6; memcpy(a->a, s->sin6_addr.s6_addr, 16); }
}

static int same_ip(const RwAddr *x, const RwAddr *y) { return x->family == y->family && !memcmp(x->a, y->a, x->family == 4 ? 4 : 16); }

/* host:port (a name, an IPv4 or [IPv6]) → address; the names configured in Settings are resolved
 * here, as the user, once per connection. */
static int resolve(const char *hp, RwAddr *out) {
    char host[96];
    const char *colon = strrchr(hp, ':');
    if (!colon || colon == hp || strlen(hp) >= sizeof host) return -1;
    size_t hl = (size_t)(colon - hp);
    memcpy(host, hp, hl);
    host[hl] = 0;
    if (host[0] == '[' && hl > 2 && host[hl - 1] == ']') { memmove(host, host + 1, hl - 2); host[hl - 2] = 0; }
    long port = strtol(colon + 1, NULL, 10);
    if (port < 1 || port > 65535) return -1;
    if (!rw_addr_text(host, out)) { out->port = (uint16_t)port; return 0; }
    struct addrinfo hints = { .ai_family = AF_UNSPEC, .ai_socktype = SOCK_DGRAM }, *res = NULL;
    if (getaddrinfo(host, NULL, &hints, &res) || !res) return -1;
    int ok = -1;
    for (struct addrinfo *i = res; i && ok; i = i->ai_next) {
        if (i->ai_family == AF_INET) { out->family = 4; memset(out->a, 0, 16); memcpy(out->a, &((struct sockaddr_in *)i->ai_addr)->sin_addr, 4); ok = 0; }
        else if (i->ai_family == AF_INET6) { from_sockaddr((struct sockaddr_in6 *)i->ai_addr, out); ok = 0; }
    }
    freeaddrinfo(res);
    out->port = (uint16_t)port;
    return ok;
}

/* The same rules as the WebSocket: the signed-in browser's own address, or what ipnet.c allows
 * (a manual block always wins). Through our TURN relay: anyone not blocked (the admin chose to add a
 * relay; the WebSocket itself still had to get in). */
static int src_allowed(const Rtc *r, const RwAddr *a, int relay) {
    char t[64];
    RsAddr x;
    rw_addr_format(a, t, sizeof t);
    if (rs_addr_parse(t, &x)) return 0;
    if (!r->cfg.access) return 0;
    if (relay) return rs_access_decide(r->cfg.access, RS_NET_ANY, &x, 0) == RS_ACC_OK;
    if (same_ip(a, &r->cfg.ws_peer)) return rs_access_decide(r->cfg.access, RS_NET_ANY, &x, 0) == RS_ACC_OK;
    return rs_access_decide(r->cfg.access, r->cfg.net_mode, &x, 0) == RS_ACC_OK;
}

/* ---- sending ---- */

static void raw_send(Rtc *r, const RwAddr *to, const void *p, size_t n) {
    struct sockaddr_in6 s;
    to_sockaddr(to, &s);
    if (sendto(r->fd, p, n, MSG_DONTWAIT | MSG_NOSIGNAL, (struct sockaddr *)&s, sizeof s) < 0 && errno != EAGAIN) {}
}

/* ---- byte streams (ICE-TCP, TURN over TCP/TLS) ---- */

/* Queues a whole packet (with an optional 2-byte length header) or drops it: never half of one. */
static int q_put(OutQ *q, const void *hdr, size_t hl, const void *p, size_t n) {
    if (q->len - q->off + hl + n > TCP_OUT_MAX) return -1;
    if (q->off && q->off == q->len) q->off = q->len = 0;
    if (q->len + hl + n > q->cap) {
        if (q->off) { memmove(q->b, q->b + q->off, q->len - q->off); q->len -= q->off; q->off = 0; }
        size_t cap = q->cap ? q->cap : 16384;
        while (cap < q->len + hl + n) cap *= 2;
        if (cap > q->cap) {
            uint8_t *nb = realloc(q->b, cap);
            if (!nb) return -1;
            q->b = nb;
            q->cap = cap;
        }
    }
    if (hl) memcpy(q->b + q->len, hdr, hl);
    memcpy(q->b + q->len + hl, p, n);
    q->len += hl + n;
    return 0;
}
static void q_free(OutQ *q) { free(q->b); memset(q, 0, sizeof *q); }

static void tcp_close(Rtc *r, int i, const char *why);

static void tcp_flush(Rtc *r, int i) {
    TcpConn *c = &r->tcp[i];
    while (c->fd >= 0 && c->out.off < c->out.len) {
        ssize_t w = send(c->fd, c->out.b + c->out.off, c->out.len - c->out.off, MSG_DONTWAIT | MSG_NOSIGNAL);
        if (w < 0 && errno == EINTR) continue;
        if (w < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return;
        if (w <= 0) { tcp_close(r, i, "write failed"); return; }
        c->out.off += (size_t)w;
    }
}

/* One packet over an ICE-TCP connection, framed (RFC 4571). */
static void tcp_send(Rtc *r, int slot, const void *p, size_t n) {
    if (slot < 1 || slot > MAX_TCP || n > RW_TCP_FRAME_MAX) return;
    TcpConn *c = &r->tcp[slot - 1];
    if (c->fd < 0) return;
    uint8_t h[2] = { (uint8_t)(n >> 8), (uint8_t)n };
    if (q_put(&c->out, h, 2, p, n)) return;
    tcp_flush(r, slot - 1);
}

static void turn_flush(Rtc *r) {
    Turn *t = &r->turn;
    while (t->up && t->out.off < t->out.len) {
        size_t left = t->out.len - t->out.off;
        if (t->tssl) {
            int w = SSL_write(t->tssl, t->out.b + t->out.off, left > (1u << 20) ? 1 << 20 : (int)left);
            if (w <= 0) {
                int e = SSL_get_error(t->tssl, w);
                if (e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_WANT_READ) return;
                ERR_clear_error();
                t->up = 0;
                t->state = -1;
                sd_log("video: the TURN server's TLS connection broke");
                return;
            }
            t->out.off += (size_t)w;
        } else {
            ssize_t w = send(t->fd, t->out.b + t->out.off, left, MSG_DONTWAIT | MSG_NOSIGNAL);
            if (w < 0 && errno == EINTR) continue;
            if (w < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) return;
            if (w <= 0) { t->up = 0; t->state = -1; sd_log("video: the TURN server's TCP connection broke"); return; }
            t->out.off += (size_t)w;
        }
    }
}

/* A STUN message to the TURN server: a datagram, or on its stream (queued until it's connected). */
static void turn_raw(Rtc *r, const void *p, size_t n) {
    Turn *t = &r->turn;
    if (t->transport == RW_TURN_UDP) { raw_send(r, &t->srv, p, n); return; }
    if (t->fd < 0 || q_put(&t->out, NULL, 0, p, n)) return;
    turn_flush(r);
}

/* To a peer: directly (UDP or an ICE-TCP connection) or wrapped in a TURN Send indication. */
static void send_to(Rtc *r, const RwAddr *to, int relay, int tcp, const void *p, size_t n) {
    if (tcp) { tcp_send(r, tcp, p, n); return; }
    if (!relay) { raw_send(r, to, p, n); return; }
    if (r->turn.state != 3 || n > 1400) return;
    static uint8_t b[1500];
    uint8_t tid[12];
    rnd(tid, 12);
    RwStunOut hdr;
    rw_so_init(&hdr, RW_TURN_SEND_IND, tid);
    rw_so_xaddr(&hdr, RW_ATTR_XOR_PEER, to);
    if (hdr.bad) return;
    size_t o = hdr.n, padded = (n + 3) & ~(size_t)3;
    if (o + 4 + padded > sizeof b) return;
    memcpy(b, hdr.b, o);
    b[o] = 0; b[o + 1] = 0x13; b[o + 2] = (uint8_t)(n >> 8); b[o + 3] = (uint8_t)n;
    memcpy(b + o + 4, p, n);
    memset(b + o + 4 + n, 0, padded - n);
    size_t total = o + 4 + padded;
    b[2] = (uint8_t)((total - 20) >> 8);
    b[3] = (uint8_t)(total - 20);
    turn_raw(r, b, total);
}

static Path *sel_path(Rtc *r) { return r->sel >= 0 ? &r->path[r->sel] : NULL; }

static void send_sel(Rtc *r, const void *p, size_t n) {
    Path *s = sel_path(r);
    if (s) send_to(r, &s->a, s->relay, s->tcp, p, n);
}

/* ---- DTLS: our certificate, a write BIO that sends each record as a datagram ---- */

static int bio_write(BIO *b, const char *p, int n) {
    Rtc *r = BIO_get_data(b);
    if (r && n > 0) send_sel(r, p, (size_t)n);
    return n;
}
static long bio_ctrl(BIO *b, int cmd, long num, void *ptr) {
    (void)b; (void)num; (void)ptr;
    switch (cmd) {
    case BIO_CTRL_FLUSH: return 1;
    case BIO_CTRL_DGRAM_QUERY_MTU: return 1200;
    case BIO_CTRL_DGRAM_GET_MTU_OVERHEAD: return 0;
    case BIO_CTRL_WPENDING: case BIO_CTRL_PENDING: return 0;
    default: return 0;
    }
}
static int bio_create(BIO *b) { BIO_set_init(b, 1); return 1; }
static BIO_METHOD *bio_method(void) {
    static BIO_METHOD *m;
    if (!m) {
        m = BIO_meth_new(BIO_TYPE_SOURCE_SINK | BIO_get_new_index(), "lordos-dtls");
        BIO_meth_set_write(m, bio_write);
        BIO_meth_set_ctrl(m, bio_ctrl);
        BIO_meth_set_create(m, bio_create);
    }
    return m;
}

static int accept_any(int ok, X509_STORE_CTX *c) { (void)ok; (void)c; return 1; }     /* checked by fingerprint */

static int make_cert(Rtc *r) {
    r->key = EVP_EC_gen("P-256");
    r->cert = X509_new();
    if (!r->key || !r->cert) return -1;
    uint8_t serial[8];
    rnd(serial, sizeof serial);
    serial[0] &= 0x7f;
    BIGNUM *bn = BN_bin2bn(serial, sizeof serial, NULL);
    ASN1_INTEGER *ai = bn ? BN_to_ASN1_INTEGER(bn, NULL) : NULL;
    BN_free(bn);
    if (!ai) return -1;
    X509_set_serialNumber(r->cert, ai);
    ASN1_INTEGER_free(ai);
    X509_set_version(r->cert, 2);
    X509_gmtime_adj(X509_getm_notBefore(r->cert), -86400);
    X509_gmtime_adj(X509_getm_notAfter(r->cert), 30L * 86400);
    X509_NAME *nm = X509_get_subject_name(r->cert);
    X509_NAME_add_entry_by_txt(nm, "CN", MBSTRING_ASC, (const unsigned char *)"lordos", -1, -1, 0);
    X509_set_issuer_name(r->cert, nm);
    X509_set_pubkey(r->cert, r->key);
    if (!X509_sign(r->cert, r->key, EVP_sha256())) return -1;
    unsigned int l = 32;
    if (!X509_digest(r->cert, EVP_sha256(), r->fp, &l) || l != 32) return -1;
    return 0;
}

/* libsrtp2 has AES-GCM only when built with a crypto library; Debian's is (OpenSSL), but check. */
static int srtp_gcm_works(void) {
    if (gcm_ok >= 0) return gcm_ok;
    srtp_policy_t p;
    memset(&p, 0, sizeof p);
    srtp_crypto_policy_set_aes_gcm_128_16_auth(&p.rtp);
    srtp_crypto_policy_set_aes_gcm_128_16_auth(&p.rtcp);
    uint8_t key[28] = { 1 };
    p.key = key;
    p.ssrc.type = ssrc_any_outbound;
    srtp_t s;
    gcm_ok = srtp_create(&s, &p) == srtp_err_status_ok;
    if (gcm_ok) srtp_dealloc(s);
    return gcm_ok;
}

static int dtls_init(Rtc *r) {
    if (make_cert(r)) return -1;
    r->ctx = SSL_CTX_new(DTLS_server_method());
    if (!r->ctx) return -1;
    SSL_CTX_set_min_proto_version(r->ctx, DTLS1_2_VERSION);
    SSL_CTX_set_options(r->ctx, SSL_OP_NO_QUERY_MTU | SSL_OP_NO_RENEGOTIATION | SSL_OP_NO_COMPRESSION | SSL_OP_NO_TICKET);
    if (SSL_CTX_set_cipher_list(r->ctx, "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305") != 1) return -1;
    SSL_CTX_set1_groups_list(r->ctx, "X25519:P-256:P-384");
    if (SSL_CTX_use_certificate(r->ctx, r->cert) != 1 || SSL_CTX_use_PrivateKey(r->ctx, r->key) != 1) return -1;
    SSL_CTX_set_verify(r->ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, accept_any);
    /* returns 0 on success */
    if (SSL_CTX_set_tlsext_use_srtp(r->ctx, srtp_gcm_works() ? "SRTP_AEAD_AES_128_GCM:SRTP_AES128_CM_SHA1_80" : "SRTP_AES128_CM_SHA1_80")) return -1;
    r->ssl = SSL_new(r->ctx);
    if (!r->ssl) return -1;
    r->rbio = BIO_new(BIO_s_mem());
    BIO *w = BIO_new(bio_method());
    if (!r->rbio || !w) return -1;
    BIO_set_mem_eof_return(r->rbio, -1);
    BIO_set_data(w, r);
    SSL_set_bio(r->ssl, r->rbio, w);
    SSL_set_mtu(r->ssl, 1200);
    DTLS_set_link_mtu(r->ssl, 1200);
    SSL_set_accept_state(r->ssl);
    return 0;
}

/* ---- SCTP and the data channels ---- */

static int sctp_out(void *addr, void *buf, size_t len, uint8_t tos, uint8_t set_df) {
    (void)tos; (void)set_df;
    Rtc *r = addr;
    if (r && r->dtls_up && !r->failed && len <= 1400) SSL_write(r->ssl, buf, (int)len);
    return 0;
}

static int dc_raw(Rtc *r, int sid, uint32_t ppid, const void *p, size_t n) {
    if (!r->sctp) return -1;
    struct sctp_sndinfo si;
    memset(&si, 0, sizeof si);
    si.snd_sid = (uint16_t)sid;
    si.snd_flags = SCTP_EOR;
    si.snd_ppid = htonl(ppid);
    static const uint8_t zero = 0;
    if (!n) { p = &zero; n = 1; ppid = ppid == 51 ? 56 : 57; si.snd_ppid = htonl(ppid); }
    ssize_t w = usrsctp_sendv(r->sctp, p, n, NULL, 0, &si, sizeof si, SCTP_SENDV_SNDINFO, 0);
    return w < 0 ? -1 : 0;
}

static void on_dc_message(Rtc *r, int sid, int ppid, const uint8_t *d, size_t n) {
    if (ppid == 50) {                                              /* DCEP */
        RwDcOpen op;
        if (n >= 1 && d[0] == 0x02) return;                       /* an ACK (we never open channels) */
        if (rw_dcep_open(d, n, &op)) { sd_log("video: malformed data channel open"); return; }
        int ch = !strcmp(op.label, "input") ? RTC_CH_INPUT : !strcmp(op.label, "tiles") ? RTC_CH_TILES : -1;
        if (ch < 0 || r->dc_open[ch]) { sd_log("video: refused data channel \"%s\"", op.label); return; }
        r->dc_sid[ch] = sid;
        r->dc_open[ch] = 1;
        uint8_t ack = 0x02;
        dc_raw(r, sid, 50, &ack, 1);
        if (r->cb.state) r->cb.state(r->cb.ud, RTC_DC_OPEN, op.label);
        return;
    }
    int ch = -1;
    for (int i = 0; i < 2; i++) if (r->dc_open[i] && r->dc_sid[i] == sid) ch = i;
    if (ch < 0) return;
    if (ppid == 56 || ppid == 57) { n = 0; ppid = ppid == 56 ? 51 : 53; }
    if (ppid != 51 && ppid != 53) return;
    if (r->cb.message) r->cb.message(r->cb.ud, ch, d, n, ppid == 53);
}

static int sctp_recv(struct socket *sock, union sctp_sockstore addr, void *data, size_t len, struct sctp_rcvinfo rcv, int flags, void *ulp) {
    (void)sock; (void)addr;
    Rtc *r = ulp;
    if (!data) return 1;
    if (!r || r->failed) { free(data); return 1; }
    if (flags & MSG_NOTIFICATION) {
        const union sctp_notification *nt = data;
        if (len >= sizeof nt->sn_assoc_change && nt->sn_header.sn_type == SCTP_ASSOC_CHANGE) {
            int st = nt->sn_assoc_change.sac_state;
            if (st == SCTP_COMM_LOST || st == SCTP_SHUTDOWN_COMP) fail(r, RTC_WHY_CLOSED, "the browser closed the data channels");
        }
        free(data);
        return 1;
    }
    int sid = rcv.rcv_sid, ppid = (int)ntohl(rcv.rcv_ppid);
    /* a message larger than the receive buffer comes in parts: joined up to our limit */
    if (r->rasm_len && (r->rasm_sid != sid || r->rasm_ppid != ppid)) { free(r->rasm); r->rasm = NULL; r->rasm_len = 0; }
    if (!(flags & MSG_EOR) || r->rasm_len) {
        if (r->rasm_len + len > MAX_DC_MSG) { free(data); fail(r, RTC_WHY_CLOSED, "data channel message too large"); return 1; }
        uint8_t *nb = realloc(r->rasm, r->rasm_len + len);
        if (!nb) { free(data); fail(r, RTC_WHY_SERVER, "out of memory"); return 1; }
        memcpy(nb + r->rasm_len, data, len);
        r->rasm = nb;
        r->rasm_len += len;
        r->rasm_sid = sid;
        r->rasm_ppid = ppid;
        free(data);
        if (!(flags & MSG_EOR)) return 1;
        on_dc_message(r, sid, ppid, r->rasm, r->rasm_len);
        free(r->rasm);
        r->rasm = NULL;
        r->rasm_len = 0;
        return 1;
    }
    if (len > MAX_DC_MSG) { free(data); fail(r, RTC_WHY_CLOSED, "data channel message too large"); return 1; }
    on_dc_message(r, sid, ppid, data, len);
    free(data);
    return 1;
}

static void sctp_start(Rtc *r) {
    if (!sctp_ready) {
        usrsctp_init_nothreads(0, sctp_out, NULL);
        usrsctp_sysctl_set_sctp_ecn_enable(0);
        usrsctp_sysctl_set_sctp_max_chunks_on_queue(10240);
        sctp_ready = 1;
    }
    usrsctp_register_address(r);
    r->sctp = usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP, sctp_recv, NULL, 0, r);
    if (!r->sctp) { fail(r, RTC_WHY_SERVER, "no SCTP socket"); return; }
    usrsctp_set_non_blocking(r->sctp, 1);
    struct linger lg = { 1, 0 };
    usrsctp_setsockopt(r->sctp, SOL_SOCKET, SO_LINGER, &lg, sizeof lg);
    int on = 1;
    usrsctp_setsockopt(r->sctp, IPPROTO_SCTP, SCTP_NODELAY, &on, sizeof on);
    usrsctp_setsockopt(r->sctp, IPPROTO_SCTP, SCTP_RECVRCVINFO, &on, sizeof on);
    int buf = 1 << 20;
    usrsctp_setsockopt(r->sctp, SOL_SOCKET, SO_SNDBUF, &buf, sizeof buf);
    usrsctp_setsockopt(r->sctp, SOL_SOCKET, SO_RCVBUF, &buf, sizeof buf);
    struct sctp_initmsg im = { .sinit_num_ostreams = 1024, .sinit_max_instreams = 1024 };
    usrsctp_setsockopt(r->sctp, IPPROTO_SCTP, SCTP_INITMSG, &im, sizeof im);
    struct sctp_assoc_value av = { .assoc_id = SCTP_ALL_ASSOC, .assoc_value = SCTP_ENABLE_RESET_STREAM_REQ };
    usrsctp_setsockopt(r->sctp, IPPROTO_SCTP, SCTP_ENABLE_STREAM_RESET, &av, sizeof av);
    struct sctp_event ev = { .se_assoc_id = SCTP_ALL_ASSOC, .se_on = 1, .se_type = SCTP_ASSOC_CHANGE };
    usrsctp_setsockopt(r->sctp, IPPROTO_SCTP, SCTP_EVENT, &ev, sizeof ev);
    struct sockaddr_conn sc;
    memset(&sc, 0, sizeof sc);
    sc.sconn_family = AF_CONN;
    sc.sconn_port = htons(5000);
    sc.sconn_addr = r;
    if (usrsctp_bind(r->sctp, (struct sockaddr *)&sc, sizeof sc) < 0) { fail(r, RTC_WHY_SERVER, "SCTP bind failed"); return; }
    int dm = r->of ? r->of->dm : -1;
    sc.sconn_port = htons((uint16_t)(dm >= 0 ? r->of->m[dm].sctp_port : 5000));
    if (usrsctp_connect(r->sctp, (struct sockaddr *)&sc, sizeof sc) < 0 && errno != EINPROGRESS) { fail(r, RTC_WHY_SERVER, "SCTP connect failed"); return; }
    r->sctp_on = 1;
    r->sctp_t = now_ms();
}

/* ---- DTLS up: the fingerprint, SRTP keys, then SCTP ---- */

static void dtls_up(Rtc *r) {
    X509 *peer = SSL_get1_peer_certificate(r->ssl);
    uint8_t fp[32];
    unsigned int l = 32;
    int ok = peer && X509_digest(peer, EVP_sha256(), fp, &l) && l == 32 && !CRYPTO_memcmp(fp, r->of->fp, 32);
    X509_free(peer);
    if (!ok) { fail(r, RTC_WHY_DTLS, "the browser's DTLS certificate does not match the fingerprint of the signed-in offer"); return; }
    const SRTP_PROTECTION_PROFILE *pr = SSL_get_selected_srtp_profile(r->ssl);
    if (!pr || (pr->id != SRTP_AES128_CM_SHA1_80 && pr->id != SRTP_AEAD_AES_128_GCM)) { fail(r, RTC_WHY_DTLS, "no SRTP profile"); return; }
    int gcm = pr->id == SRTP_AEAD_AES_128_GCM;
    size_t kl = 16, sl = gcm ? 12 : 14;
    uint8_t km[2 * (16 + 14)], txk[30], rxk[30];
    if (SSL_export_keying_material(r->ssl, km, 2 * (kl + sl), "EXTRACTOR-dtls_srtp", 19, NULL, 0, 0) != 1) { fail(r, RTC_WHY_DTLS, "no SRTP keys"); return; }
    /* client key, server key, client salt, server salt; we are the server */
    memcpy(txk, km + kl, kl);
    memcpy(txk + kl, km + 2 * kl + sl, sl);
    memcpy(rxk, km, kl);
    memcpy(rxk + kl, km + 2 * kl, sl);
    explicit_bzero(km, sizeof km);
    srtp_policy_t p;
    memset(&p, 0, sizeof p);
    if (gcm) { srtp_crypto_policy_set_aes_gcm_128_16_auth(&p.rtp); srtp_crypto_policy_set_aes_gcm_128_16_auth(&p.rtcp); }
    else { srtp_crypto_policy_set_rtp_default(&p.rtp); srtp_crypto_policy_set_rtcp_default(&p.rtcp); }
    p.window_size = 1024;
    p.allow_repeat_tx = 1;
    p.key = txk;
    p.ssrc.type = ssrc_any_outbound;
    int e1 = srtp_create(&r->tx, &p);
    p.key = rxk;
    p.ssrc.type = ssrc_any_inbound;
    int e2 = srtp_create(&r->rx, &p);
    explicit_bzero(txk, sizeof txk);
    explicit_bzero(rxk, sizeof rxk);
    if (e1 || e2) { fail(r, RTC_WHY_SERVER, "SRTP setup failed"); return; }
    r->srtp_up = 1;
    r->dtls_up = 1;
    Path *s = sel_path(r);
    if (s) s->proven = 1;
    char a[64] = "";
    if (s) rw_addr_format(&s->a, a, sizeof a);
    sd_log("video: connected (%s, %s, %s%s)", r->codec == RW_CODEC_H264 ? "H.264" : "VP8", gcm ? "AES-GCM" : "AES-CM", a,
           s && s->relay ? " via TURN" : s && s->tcp ? " over TCP" : "");
    if (r->of->dm >= 0) sctp_start(r);
    if (r->cb.state) r->cb.state(r->cb.ud, RTC_CONNECTED, NULL);
}

static void dtls_input(Rtc *r, const uint8_t *p, size_t n) {
    BIO_write(r->rbio, p, (int)n);
    if (!r->dtls_up) {
        int k = SSL_do_handshake(r->ssl);
        if (k == 1) dtls_up(r);
        else {
            int e = SSL_get_error(r->ssl, k);
            if (e != SSL_ERROR_WANT_READ && e != SSL_ERROR_WANT_WRITE) { ERR_clear_error(); fail(r, RTC_WHY_DTLS, "DTLS handshake failed"); return; }
        }
    }
    static uint8_t buf[65536];
    while (r->dtls_up && !r->failed) {
        int k = SSL_read(r->ssl, buf, sizeof buf);
        if (k > 0) { r->dtls_rx++; if (r->sctp_on) usrsctp_conninput(r, buf, (size_t)k, 0); continue; }
        int e = SSL_get_error(r->ssl, k);
        if (e == SSL_ERROR_ZERO_RETURN) fail(r, RTC_WHY_CLOSED, "the browser closed DTLS");
        else if (e != SSL_ERROR_WANT_READ && e != SSL_ERROR_WANT_WRITE) { ERR_clear_error(); fail(r, RTC_WHY_DTLS, "DTLS error"); }
        break;
    }
}

/* ---- RTP out ---- */

typedef struct { Rtc *r; Track *t; uint32_t ts; } PktCtx;

static void rtp_out(void *ud, const uint8_t *hdr, size_t hl, const uint8_t *data, size_t n, int marker) {
    PktCtx *c = ud;
    Rtc *r = c->r;
    Track *t = c->t;
    uint8_t b[MTU + 64 + SRTP_MAX_TRAILER_LEN];
    if (12 + hl + n > MTU + 64) return;
    b[0] = 0x80;
    b[1] = (uint8_t)((marker ? 0x80 : 0) | t->pt);
    b[2] = (uint8_t)(t->seq >> 8); b[3] = (uint8_t)t->seq;
    uint32_t ts = c->ts;
    b[4] = (uint8_t)(ts >> 24); b[5] = (uint8_t)(ts >> 16); b[6] = (uint8_t)(ts >> 8); b[7] = (uint8_t)ts;
    b[8] = (uint8_t)(t->ssrc >> 24); b[9] = (uint8_t)(t->ssrc >> 16); b[10] = (uint8_t)(t->ssrc >> 8); b[11] = (uint8_t)t->ssrc;
    if (hl) memcpy(b + 12, hdr, hl);
    memcpy(b + 12 + hl, data, n);
    int len = (int)(12 + hl + n);
    if (srtp_protect(r->tx, b, &len) != srtp_err_status_ok) return;
    send_sel(r, b, (size_t)len);
    if (t->hist && (size_t)len <= sizeof t->hist[0].b) {
        Hist *h = &t->hist[t->seq % HIST];
        h->seq = t->seq;
        h->len = (uint16_t)len;
        memcpy(h->b, b, (size_t)len);
    }
    t->packets++;
    t->octets += (uint32_t)(hl + n);
    t->seq++;
}

int rtc_media_ready(const Rtc *r) { return r && r->srtp_up && !r->failed && r->sel >= 0; }
int rtc_codec(const Rtc *r) { return r ? r->codec : 0; }

/* The session's encoder counts from its own start, and it starts again when the screen size changes
 * (or after a crash) while this peer goes on: its time going back moves the offset instead, so the
 * RTP timestamps keep going forward. Going back made the browser drop the new frames as old ones,
 * freeze and ask for keyframes over and over. */
static uint32_t track_ts(Track *t, uint32_t in, uint32_t step, uint32_t mul) {
    if (t->have_in && (int32_t)(in - t->last_in) <= 0) t->ts_off += (t->last_in - in + step) * mul;
    t->last_in = in;
    t->have_in = 1;
    return t->ts_off + in * mul;
}

void rtc_video(Rtc *r, const uint8_t *f, size_t n, uint32_t ms) {
    if (!rtc_media_ready(r) || !n) return;
    PktCtx c = { r, &r->v, track_ts(&r->v, ms, 33, 90) };
    r->v.last_ts = c.ts;
    r->v.last_ms = now_ms();
    if (r->codec == RW_CODEC_H264) rw_h264_packetize(f, n, MTU, rtp_out, &c);
    else rw_vp8_packetize(f, n, MTU, rtp_out, &c);
}

void rtc_audio(Rtc *r, const uint8_t *p, size_t n, uint32_t samples) {
    if (!rtc_media_ready(r) || !n || n > MTU || r->of->am < 0) return;
    PktCtx c = { r, &r->a, track_ts(&r->a, samples, 960, 1) };
    r->a.last_ts = c.ts;
    r->a.last_ms = now_ms();
    rtp_out(&c, NULL, 0, p, n, 0);
}

static void send_sr(Rtc *r, Track *t) {
    if (!t->packets) return;
    uint8_t b[28 + SRTP_MAX_TRAILER_LEN + 4];
    struct timespec rt;
    clock_gettime(CLOCK_REALTIME, &rt);
    uint64_t sec = (uint64_t)rt.tv_sec + 2208988800ull, frac = ((uint64_t)rt.tv_nsec << 32) / 1000000000ull;
    uint32_t ts = t->last_ts + (uint32_t)((now_ms() - t->last_ms) * (t == &r->v ? 90 : 48));
    uint32_t w[7] = { t->ssrc, (uint32_t)sec, (uint32_t)frac, ts, t->packets, t->octets, 0 };
    b[0] = 0x80; b[1] = 200; b[2] = 0; b[3] = 6;
    for (int i = 0; i < 6; i++) { uint32_t v = w[i]; b[4 + i * 4] = (uint8_t)(v >> 24); b[5 + i * 4] = (uint8_t)(v >> 16); b[6 + i * 4] = (uint8_t)(v >> 8); b[7 + i * 4] = (uint8_t)v; }
    int len = 28;
    if (srtp_protect_rtcp(r->tx, b, &len) == srtp_err_status_ok) send_sel(r, b, (size_t)len);
}

/* ---- feedback from the browser ---- */

static void set_rate(Rtc *r, double k) {
    unsigned lo = 300, hi = r->cfg.max_kbps ? r->cfg.max_kbps : 8000;
    unsigned nk = k < lo ? lo : k > hi ? hi : (unsigned)k;
    if (nk == r->kbps) return;
    unsigned old = r->kbps;
    r->kbps = nk;
    r->rate_at = now_ms();
    if (r->cb.rate && (nk > old * 1.04 || nk < old * 0.96)) r->cb.rate(r->cb.ud, nk);
}

static void on_fb(void *ud, const RwFb *f) {
    Rtc *r = ud;
    if (f->ssrc != r->v.ssrc && f->ssrc != r->a.ssrc && f->kind != RW_FB_REMB) return;
    double t = now_ms();
    switch (f->kind) {
    case RW_FB_RR:
        if (f->ssrc != r->v.ssrc) break;
        r->lost = r->lost * 0.7 + f->lost_frac / 256.0 * 0.3;
        if (f->lost_frac > 25) { r->congested_at = t; set_rate(r, r->kbps * 0.75); }
        else if (f->lost_frac > 5) { r->congested_at = t; set_rate(r, r->kbps * 0.92); }
        else if (f->lost_frac == 0 && t - r->rate_at > 1000)
            /* no loss: up fast (a LAN reaches the top in about 10 s), slowly for 5 s after congestion */
            set_rate(r, r->kbps * (t - r->congested_at > 5000 ? 1.25 : 1.06) + 50);
        break;
    case RW_FB_PLI:
    case RW_FB_FIR:
        if (f->ssrc != r->v.ssrc) break;
        r->plis++;
        if (t - r->kf_at > 300 && r->cb.keyframe) { r->kf_at = t; r->cb.keyframe(r->cb.ud); }
        break;
    case RW_FB_NACK:
        if (f->ssrc != r->v.ssrc || !r->v.hist) break;
        r->nacks++;
        for (int i = -1; i < 16; i++) {
            if (i >= 0 && !(f->blp & (1u << i))) continue;
            uint16_t seq = (uint16_t)(f->pid + (i < 0 ? 0 : i + 1));
            Hist *h = &r->v.hist[seq % HIST];
            if (h->len && h->seq == seq) { send_sel(r, h->b, h->len); r->resent++; }
        }
        break;
    case RW_FB_REMB: {
        /* The browser's estimate only grows with what it receives, so as a fixed ceiling it kept a
         * new connection at ~3 Mbit/s for minutes. It counts as congestion when it falls (the
         * browser saw the delay grow) or right after loss; then it is a ceiling. */
        unsigned b = (unsigned)(f->bitrate / 1000);
        if (r->remb && b < r->remb * 0.85) r->congested_at = t;
        if (t - r->congested_at < 5000 && b < r->kbps) set_rate(r, b);
        r->remb = b;
        break;
    }
    }
}

/* ---- ICE-lite, the built-in STUN server, external STUN and TURN ---- */

static Path *path_for(Rtc *r, const RwAddr *a, int relay, int tcp, int add) {
    for (int i = 0; i < r->npath; i++)
        if (r->path[i].relay == relay && r->path[i].tcp == tcp && rw_addr_equal(&r->path[i].a, a)) return &r->path[i];
    if (!add) return NULL;
    Path *p = NULL;
    for (int i = 0; i < r->npath && !p; i++) if (!r->path[i].a.family && i != r->sel) p = &r->path[i];     /* a dead one */
    if (!p && r->npath < MAX_PATHS) p = &r->path[r->npath++];
    if (!p) return NULL;
    memset(p, 0, sizeof *p);
    p->a = *a;
    p->relay = relay;
    p->tcp = tcp;
    return p;
}

/* The media's path went away (its TCP connection closed): another proven path, if any, takes over. */
static void reselect(Rtc *r) {
    int best = -1;
    for (int i = 0; i < r->npath; i++) {
        const Path *p = &r->path[i];
        if (!p->a.family || !p->valid || !p->proven) continue;
        if (best < 0 || (p->nominated && !r->path[best].nominated) || (p->nominated == r->path[best].nominated && p->last > r->path[best].last)) best = i;
    }
    r->sel = best;
    if (best >= 0 && r->cb.keyframe) r->cb.keyframe(r->cb.ud);
}

static void stun_answer(Rtc *r, const RwStun *s, const RwAddr *from, int relay, int tcp) {
    RwStunOut o;
    rw_so_init(&o, RW_STUN_BINDING_OK, s->tid);
    rw_so_xaddr(&o, RW_ATTR_XOR_MAPPED, from);
    rw_so_mi(&o, (const uint8_t *)r->pwd, strlen(r->pwd), hmac_sha1);
    rw_so_fingerprint(&o);
    if (!o.bad) send_to(r, from, relay, tcp, o.b, o.n);
}

/* The built-in STUN server: a plain binding request (no credentials) gets the address it came from,
 * on its own socket, at most 20 a second, only from addresses the rules allow. */
static void stun_server(Rtc *r, const uint8_t *p, size_t n, const RwAddr *from) {
    RwStun s;
    if (!rw_is_stun(p, n) || rw_stun_parse(p, n, &s) || s.type != RW_STUN_BINDING_REQ || s.username || s.mi_off) return;
    double t = now_ms();
    if (t - r->stun_win > 1000) { r->stun_win = t; r->stun_n = 0; }
    if (++r->stun_n > 20 || !src_allowed(r, from, 0)) return;
    RwStunOut o;
    rw_so_init(&o, RW_STUN_BINDING_OK, s.tid);
    rw_so_xaddr(&o, RW_ATTR_XOR_MAPPED, from);
    rw_so_fingerprint(&o);
    struct sockaddr_in6 sa;
    to_sockaddr(from, &sa);
    if (!o.bad) sendto(r->sfd, o.b, o.n, MSG_DONTWAIT | MSG_NOSIGNAL, (struct sockaddr *)&sa, sizeof sa);
}

static void ice_check(Rtc *r, const uint8_t *p, size_t n, const RwStun *s, const RwAddr *from, int relay, int tcp) {
    if (!r->offered || !s->username || !s->mi_off || !s->has_fp) return;
    char want[300];
    int wl = snprintf(want, sizeof want, "%s:%s", r->ufrag, r->of->ufrag);
    if (wl < 0 || (size_t)wl != s->ulen || memcmp(want, s->username, s->ulen)) return;
    if (!rw_stun_check_mi(p, n, s, (const uint8_t *)r->pwd, strlen(r->pwd), hmac_sha1)) return;
    if (!src_allowed(r, from, relay)) {
        static int said;
        char a[64];
        rw_addr_format(from, a, sizeof a);
        if (!said++) sd_log("video: refused ICE check from %s (Settings -> Sharing: who can connect)", a);
        return;
    }
    Path *pa = path_for(r, from, relay, tcp, 1);
    if (!pa) return;
    if (tcp) r->tcp[tcp - 1].checked = 1;
    pa->valid = 1;
    pa->last = now_ms();
    r->last_consent = pa->last;
    r->checks++;
    if (s->use_candidate && !pa->nominated) {
        for (int i = 0; i < r->npath; i++) r->path[i].nominated = 0;
        pa->nominated = 1;
        /* once DTLS is up, media only moves to a path that proved to be the browser (an authenticated
         * DTLS or SRTCP packet from it, see prove()): ICE credentials alone can't redirect the stream */
        if (!r->dtls_up || pa->proven) {
            int was = r->sel;
            r->sel = (int)(pa - r->path);
            if (r->dtls_up && was != r->sel && r->cb.keyframe) r->cb.keyframe(r->cb.ud);
        }
    }
    if (r->sel < 0 && !r->dtls_up) r->sel = (int)(pa - r->path);
    stun_answer(r, s, from, relay, tcp);
}

static void turn_send(Rtc *r, uint16_t type, int auth, const RwAddr *peers, int npeers, uint32_t lifetime) {
    Turn *t = &r->turn;
    RwStunOut o;
    rnd(t->tid, 12);
    rw_so_init(&o, type, t->tid);
    if (type == RW_TURN_ALLOCATE_REQ) { uint8_t tr[4] = { 17, 0, 0, 0 }; rw_so_attr(&o, RW_ATTR_TRANSPORT, tr, 4); }
    if (lifetime) rw_so_u32(&o, RW_ATTR_LIFETIME, lifetime);
    for (int i = 0; i < npeers; i++) rw_so_xaddr(&o, RW_ATTR_XOR_PEER, &peers[i]);
    if (auth) {
        rw_so_attr(&o, RW_ATTR_USERNAME, r->cfg.turn_user, strlen(r->cfg.turn_user));
        rw_so_attr(&o, RW_ATTR_REALM, t->realm, strlen(t->realm));
        rw_so_attr(&o, RW_ATTR_NONCE, t->nonce, t->nlen);
        rw_so_mi(&o, t->key, 16, hmac_sha1);
    }
    rw_so_fingerprint(&o);
    if (!o.bad) turn_raw(r, o.b, o.n);
    t->sent_at = now_ms();
}

/* The TURN password (first peer) or the key a previous peer derived from it: gone once used, or when
 * there will be no relay. */
static void wipe_pass(Rtc *r) {
    explicit_bzero(r->cfg.turn_key, sizeof r->cfg.turn_key);
    r->cfg.turn_has_key = 0;
    if (!r->cfg.turn_pass) return;
    explicit_bzero(r->cfg.turn_pass, strlen(r->cfg.turn_pass));
    free(r->cfg.turn_pass);
    r->cfg.turn_pass = NULL;
}

/* long-term credential key: MD5(user ":" realm ":" password) (RFC 8489 §9.2.2) */
static int turn_key(Rtc *r) {
    /* a later peer of the same bridge: the key derived by the first one, for the same realm only */
    if (!r->cfg.turn_pass && r->cfg.turn_has_key && !strcmp(r->cfg.turn_realm, r->turn.realm)) {
        memcpy(r->turn.key, r->cfg.turn_key, 16);
        wipe_pass(r);
        return 0;
    }
    if (!r->cfg.turn_pass) return -1;
    char buf[1024];
    int k = snprintf(buf, sizeof buf, "%s:%s:%s", r->cfg.turn_user, r->turn.realm, r->cfg.turn_pass);
    unsigned int l = 16;
    int ok = k > 0 && (size_t)k < sizeof buf && EVP_Digest(buf, (size_t)k, r->turn.key, &l, EVP_md5(), NULL) && l == 16;
    explicit_bzero(buf, sizeof buf);
    wipe_pass(r);
    return ok ? 0 : -1;
}

static void turn_perms(Rtc *r) {
    Turn *t = &r->turn;
    if (t->state != 3 || !t->nperm) return;
    turn_send(r, RW_TURN_PERM_REQ, 1, t->perm, t->nperm, 0);
    t->perm_at = now_ms() + 240000;
    t->perm_dirty = 0;
}

static void turn_peer(Rtc *r, const RwAddr *a) {
    Turn *t = &r->turn;
    if (!t->state || t->state < 0 || a->family == 0) return;
    for (int i = 0; i < t->nperm; i++) if (same_ip(&t->perm[i], a)) return;
    if (t->nperm >= 8) return;
    t->perm[t->nperm] = *a;
    t->perm[t->nperm].port = 0;
    t->nperm++;
    t->perm_dirty = 1;
}

static void handle_packet(Rtc *r, const uint8_t *p, size_t n, const RwAddr *from, int relay, int tcp);
static void prove(Rtc *r, Path *pa);

static void turn_input(Rtc *r, const uint8_t *p, size_t n, const RwStun *s) {
    Turn *t = &r->turn;
    if (s->type == RW_TURN_DATA_IND) {                             /* a packet from a peer, relayed */
        if (t->state == 3 && s->data && s->xor_peer.family && s->dlen <= 1400) handle_packet(r, s->data, s->dlen, &s->xor_peer, 1, 0);
        return;
    }
    if (memcmp(s->tid, t->tid, 12)) return;
    int cls = s->type & 0x0110;
    if (cls == 0x0100 && s->mi_off && !rw_stun_check_mi(p, n, s, t->key, 16, hmac_sha1)) return;   /* forged answer */
    if (cls == 0x0110 && (s->error == 401 || s->error == 438)) {
        if (!s->realm || !s->nonce || s->rlen >= sizeof t->realm || s->nlen > sizeof t->nonce || ++t->tries > 3) { t->state = -1; sd_log("video: the TURN server refused us"); return; }
        memcpy(t->realm, s->realm, s->rlen);
        t->realm[s->rlen] = 0;
        memcpy(t->nonce, s->nonce, s->nlen);
        t->nlen = s->nlen;
        if (t->state == 1 && turn_key(r)) { t->state = -1; return; }
        if (t->state <= 2) { t->state = 2; turn_send(r, RW_TURN_ALLOCATE_REQ, 1, NULL, 0, 600); }
        else if (s->type == RW_TURN_PERM_ERR) turn_perms(r);
        else turn_send(r, RW_TURN_REFRESH_REQ, 1, NULL, 0, 600);
        return;
    }
    if (s->type == RW_TURN_ALLOCATE_OK) {
        if (!s->mi_off || !s->xor_relayed.family) { t->state = -1; return; }
        t->relayed = s->xor_relayed;
        t->mapped = s->xor_mapped;
        t->state = 3;
        t->tries = 0;
        unsigned life = s->lifetime ? s->lifetime : 600;
        t->refresh_at = now_ms() + (life > 120 ? life - 60 : life / 2) * 1000.0;
        char a[64];
        rw_addr_format(&t->relayed, a, sizeof a);
        sd_log("video: TURN relay %s:%u", a, t->relayed.port);
        for (int i = 0; i < r->nrcand; i++) turn_peer(r, &r->rcand[i]);
        turn_perms(r);
    } else if (s->type == RW_TURN_REFRESH_OK) {
        unsigned life = s->lifetime ? s->lifetime : 600;
        t->refresh_at = now_ms() + (life > 120 ? life - 60 : life / 2) * 1000.0;
    } else if (cls == 0x0110) {
        sd_log("video: TURN error %d", s->error);
        if (t->state < 3) t->state = -1;
    }
}

static void handle_packet(Rtc *r, const uint8_t *p, size_t n, const RwAddr *from, int relay, int tcp) {
    if (!n || r->failed) return;
    if (rw_is_stun(p, n)) {
        RwStun s;
        if (rw_stun_parse(p, n, &s)) return;
        if (!relay && !tcp && r->turn.state && r->turn.transport == RW_TURN_UDP && rw_addr_equal(from, &r->turn.srv)) { turn_input(r, p, n, &s); return; }
        if (s.type == RW_STUN_BINDING_REQ) { ice_check(r, p, n, &s, from, relay, tcp); return; }
        if (s.type == RW_STUN_BINDING_OK && !relay && !tcp)
            for (int i = 0; i < r->nstun_srv; i++)
                if (rw_addr_equal(from, &r->stun_srv[i]) && !memcmp(s.tid, r->stun_tid[i], 12) && s.xor_mapped.family && !r->srflx.family) r->srflx = s.xor_mapped;
        return;
    }
    /* DTLS and SRTP only from an address that passed an ICE check */
    Path *pa = path_for(r, from, relay, tcp, 0);
    if (!pa || !pa->valid) return;
    if (p[0] >= 20 && p[0] <= 63) {
        if (!r->offered) return;
        if (!r->dtls_up && r->sel != (int)(pa - r->path)) r->sel = (int)(pa - r->path);
        unsigned long before = r->dtls_rx;
        dtls_input(r, p, n);
        if (r->dtls_rx != before) prove(r, pa);           /* a record that decrypted: the browser */
    } else if (p[0] >= 128 && p[0] <= 191 && n >= 8 && p[1] >= 192 && p[1] <= 223 && r->srtp_up) {
        uint8_t b[1500 + SRTP_MAX_TRAILER_LEN];
        if (n > 1500) return;
        memcpy(b, p, n);
        int len = (int)n;
        if (srtp_unprotect_rtcp(r->rx, b, &len) != srtp_err_status_ok) return;
        prove(r, pa);
        rw_rtcp_parse(b, (size_t)len, on_fb, r);
    }
}

/* An authenticated packet (DTLS application data or SRTCP) came from this path: it is the browser. If
 * the browser nominated it, the media goes there now. */
static void prove(Rtc *r, Path *pa) {
    if (!pa) return;
    int was = r->sel;
    pa->proven = 1;
    if (pa->nominated || r->sel < 0) r->sel = (int)(pa - r->path);
    if (r->dtls_up && was != r->sel && r->cb.keyframe) r->cb.keyframe(r->cb.ud);     /* a new path: a clean picture */
}

/* ---- ICE-TCP connections ---- */

static void tcp_close(Rtc *r, int i, const char *why) {
    TcpConn *c = &r->tcp[i];
    if (c->fd < 0) return;
    if (c->checked) {
        char a[64];
        rw_addr_format(&c->peer, a, sizeof a);
        sd_log("video: ICE-TCP connection from %s closed (%s)", a, why);
    }
    close(c->fd);
    c->fd = -1;
    q_free(&c->out);
    c->inl = 0;
    c->checked = 0;
    int lost_sel = 0;
    for (int k = 0; k < r->npath; k++) {
        Path *p = &r->path[k];
        if (p->tcp != i + 1) continue;
        if (k == r->sel) lost_sel = 1;
        memset(p, 0, sizeof *p);                    /* dead: path_for reuses it */
    }
    if (lost_sel) reselect(r);
}

/* lord-sessiond's root connection child hands us an ICE-TCP connection: the socket and the first
 * framed packet it read (whose check names our route). Only from root, only a TCP socket. */
static void tcp_accept(Rtc *r) {
    int u = accept4(r->cfg.ice_lfd, NULL, NULL, SOCK_CLOEXEC | SOCK_NONBLOCK);
    if (u < 0) return;
    struct ucred cr;
    socklen_t cl = sizeof cr;
    uint8_t first[RW_TCP_FRAME_MAX + 2];
    char cbuf[CMSG_SPACE(sizeof(int))];
    struct iovec iov = { first, sizeof first };
    struct msghdr mh = { .msg_iov = &iov, .msg_iovlen = 1, .msg_control = cbuf, .msg_controllen = sizeof cbuf };
    int fd = -1;
    ssize_t got = -1;
    if (!getsockopt(u, SOL_SOCKET, SO_PEERCRED, &cr, &cl) && cr.uid == 0) {
        struct pollfd pw = { u, POLLIN, 0 };
        if (poll(&pw, 1, 200) > 0) got = recvmsg(u, &mh, MSG_CMSG_CLOEXEC | MSG_DONTWAIT);
        for (struct cmsghdr *cm = got > 0 ? CMSG_FIRSTHDR(&mh) : NULL; cm; cm = CMSG_NXTHDR(&mh, cm))
            if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_RIGHTS && cm->cmsg_len == CMSG_LEN(sizeof(int))) memcpy(&fd, CMSG_DATA(cm), sizeof(int));
    }
    close(u);
    if (fd < 0) return;
    int type = 0;
    socklen_t tl = sizeof type;
    struct sockaddr_in6 sa;
    socklen_t sl = sizeof sa;
    if (got < 2 || (mh.msg_flags & MSG_TRUNC) || getsockopt(fd, SOL_SOCKET, SO_TYPE, &type, &tl) || type != SOCK_STREAM ||
        getpeername(fd, (struct sockaddr *)&sa, &sl) || sa.sin6_family != AF_INET6) { close(fd); return; }
    int slot = -1;
    double oldest = 0;
    for (int i = 0; i < MAX_TCP; i++) if (r->tcp[i].fd < 0) { slot = i; break; }
    if (slot < 0)                                   /* full: the oldest one that never brought a valid check goes */
        for (int i = 0; i < MAX_TCP; i++) if (!r->tcp[i].checked && (slot < 0 || r->tcp[i].born < oldest)) { slot = i; oldest = r->tcp[i].born; }
    if (slot < 0) { close(fd); return; }
    tcp_close(r, slot, "replaced");
    TcpConn *c = &r->tcp[slot];
    fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
    int on = 1;
    setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on);
    c->fd = fd;
    from_sockaddr(&sa, &c->peer);
    c->born = now_ms();
    memcpy(c->in, first, (size_t)got);
    c->inl = (size_t)got;
}

static void tcp_input(Rtc *r, int i) {
    TcpConn *c = &r->tcp[i];
    for (int rounds = 0; c->fd >= 0 && rounds < 64; rounds++) {
        if (c->inl < sizeof c->in) {
            ssize_t got = recv(c->fd, c->in + c->inl, sizeof c->in - c->inl, MSG_DONTWAIT);
            if (got == 0) { tcp_close(r, i, "closed by the other end"); return; }
            if (got < 0 && errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR) { tcp_close(r, i, "read failed"); return; }
            if (got > 0) c->inl += (size_t)got;
        }
        size_t used = 0, len;
        int k;
        while (c->fd >= 0 && (k = rw_tcp_frame(c->in + used, c->inl - used, &len)) == 1) {
            handle_packet(r, c->in + used + 2, len, &c->peer, 0, i + 1);
            used += 2 + len;
            if (r->failed) return;
        }
        if (c->fd < 0) return;
        if (k < 0) { tcp_close(r, i, "bad framing"); return; }
        memmove(c->in, c->in + used, c->inl - used);
        c->inl -= used;
        if (!used && c->inl < sizeof c->in) {
            /* nothing complete: wait for more (unless the kernel has more right now) */
            int pending = 0;
            if (ioctl(c->fd, FIONREAD, &pending) || pending <= 0) return;
        }
    }
}

/* ---- TURN over TCP or TLS ---- */

static void turn_stream_input(Rtc *r) {
    Turn *t = &r->turn;
    for (int rounds = 0; t->fd >= 0 && t->up && rounds < 64; rounds++) {
        ssize_t got;
        if (t->tssl) {
            int k = SSL_read(t->tssl, t->in + t->inl, (int)(sizeof t->in - t->inl));
            if (k <= 0) {
                int e = SSL_get_error(t->tssl, k);
                if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE) return;
                ERR_clear_error();
                got = 0;
            } else got = k;
        } else {
            got = recv(t->fd, t->in + t->inl, sizeof t->in - t->inl, MSG_DONTWAIT);
            if (got < 0 && (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR)) return;
        }
        if (got <= 0) { t->up = 0; t->state = -1; sd_log("video: the TURN server closed the connection"); return; }
        t->inl += (size_t)got;
        size_t used = 0, len;
        int k;
        while ((k = rw_stun_stream(t->in + used, t->inl - used, &len)) == 1) {
            RwStun s;
            if (!rw_stun_parse(t->in + used, len, &s)) turn_input(r, t->in + used, len, &s);
            used += len;
            if (r->failed || !t->up) return;
        }
        if (k < 0) { t->up = 0; t->state = -1; sd_log("video: the TURN server sent something that isn't STUN"); return; }
        memmove(t->in, t->in + used, t->inl - used);
        t->inl -= used;
    }
}

/* The TLS certificate of the TURN server: the pinned fingerprint if Settings has one, else the
 * system's CAs and the server's name (or IP address), checked by OpenSSL during the handshake. */
static int turn_cert_ok(Rtc *r) {
    Turn *t = &r->turn;
    X509 *peer = SSL_get1_peer_certificate(t->tssl);
    if (!peer) return 0;
    int ok;
    if (r->cfg.turn_has_fp) {
        uint8_t fp[32];
        unsigned int l = 32;
        ok = X509_digest(peer, EVP_sha256(), fp, &l) && l == 32 && !CRYPTO_memcmp(fp, r->cfg.turn_fp, 32);
    } else ok = SSL_get_verify_result(t->tssl) == X509_V_OK;
    X509_free(peer);
    return ok;
}

static void turn_stream_ready(Rtc *r) {
    Turn *t = &r->turn;
    if (t->connecting == 1) {
        int err = 0;
        socklen_t el = sizeof err;
        if (getsockopt(t->fd, SOL_SOCKET, SO_ERROR, &err, &el) || err) { t->state = -1; sd_log("video: could not connect to the TURN server (%s)", strerror(err)); return; }
        if (t->transport == RW_TURN_TCP) { t->connecting = 0; t->up = 1; turn_flush(r); return; }
        t->connecting = 2;
        t->tctx = SSL_CTX_new(TLS_client_method());
        if (!t->tctx) { t->state = -1; return; }
        SSL_CTX_set_min_proto_version(t->tctx, TLS1_2_VERSION);
        if (!r->cfg.turn_has_fp) {
            SSL_CTX_set_default_verify_paths(t->tctx);
            SSL_CTX_set_verify(t->tctx, SSL_VERIFY_PEER, NULL);
        } else SSL_CTX_set_verify(t->tctx, SSL_VERIFY_NONE, NULL);     /* the pin is checked after the handshake */
        t->tssl = SSL_new(t->tctx);
        if (!t->tssl) { t->state = -1; return; }
        SSL_set_fd(t->tssl, t->fd);
        SSL_set_mode(t->tssl, SSL_MODE_ENABLE_PARTIAL_WRITE | SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
        RwAddr ip;
        if (rw_addr_text(t->host, &ip)) {           /* a name: SNI and the name check */
            SSL_set_tlsext_host_name(t->tssl, t->host);
            if (!r->cfg.turn_has_fp) SSL_set1_host(t->tssl, t->host);
        } else if (!r->cfg.turn_has_fp) X509_VERIFY_PARAM_set1_ip_asc(SSL_get0_param(t->tssl), t->host);
        SSL_set_connect_state(t->tssl);
    }
    if (t->connecting == 2) {
        int k = SSL_do_handshake(t->tssl);
        if (k == 1) {
            if (!turn_cert_ok(r)) { t->state = -1; sd_log("video: the TURN server's certificate was refused (%s)", r->cfg.turn_has_fp ? "it doesn't match the pinned fingerprint" : X509_verify_cert_error_string(SSL_get_verify_result(t->tssl))); return; }
            t->connecting = 0;
            t->up = 1;
            turn_flush(r);
            return;
        }
        int e = SSL_get_error(t->tssl, k);
        if (e != SSL_ERROR_WANT_READ && e != SSL_ERROR_WANT_WRITE) {
            long v = SSL_get_verify_result(t->tssl);
            ERR_clear_error();
            t->state = -1;
            sd_log("video: TLS with the TURN server failed%s%s", v != X509_V_OK ? ": " : "", v != X509_V_OK ? X509_verify_cert_error_string(v) : "");
        }
    }
}

static void turn_stream_close(Turn *t) {
    if (t->tssl) { SSL_free(t->tssl); t->tssl = NULL; }
    if (t->tctx) { SSL_CTX_free(t->tctx); t->tctx = NULL; }
    if (t->fd >= 0) close(t->fd);
    t->fd = -1;
    t->up = t->connecting = 0;
    q_free(&t->out);
}

/* ---- life cycle ---- */

int rtc_port(const Rtc *r) { return r ? r->sport : 0; }

static void new_credentials(Rtc *r) {
    char tail[5];
    rnd_text(tail, 4);
    snprintf(r->ufrag, sizeof r->ufrag, "%.8s%s", r->cfg.route, tail);
    rnd_text(r->pwd, 24);
}

Rtc *rtc_new(const RtcConfig *cfg, const RtcCallbacks *cb) {
    Rtc *r = calloc(1, sizeof *r);
    if (!r) return NULL;
    r->cfg = *cfg;
    r->cb = *cb;
    r->sel = -1;
    r->fd = r->sfd = -1;
    r->turn.fd = -1;
    for (int i = 0; i < MAX_TCP; i++) r->tcp[i].fd = -1;
    r->created = r->last_consent = now_ms();
    r->kbps = cfg->max_kbps && cfg->max_kbps < 4000 ? cfg->max_kbps : 4000;
    if (strlen(r->cfg.route) != 8) rnd_text(r->cfg.route, 8);
    new_credentials(r);
    if (!srtp_ready) { if (srtp_init() != srtp_err_status_ok) goto bad; srtp_ready = 1; }
    if (dtls_init(r)) goto bad;
    r->fd = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
    if (r->fd < 0) goto bad;
    int off = 0, buf = 2 << 20;
    setsockopt(r->fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof off);
    setsockopt(r->fd, SOL_SOCKET, SO_SNDBUF, &buf, sizeof buf);
    setsockopt(r->fd, SOL_SOCKET, SO_RCVBUF, &buf, sizeof buf);
    struct sockaddr_in6 any = { .sin6_family = AF_INET6 };
    socklen_t sl = sizeof any;
    if (bind(r->fd, (struct sockaddr *)&any, sizeof any) || getsockname(r->fd, (struct sockaddr *)&any, &sl)) goto bad;
    r->port = ntohs(any.sin6_port);
    r->sfd = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
    if (r->sfd < 0) goto bad;
    setsockopt(r->sfd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof off);
    struct sockaddr_in6 any2 = { .sin6_family = AF_INET6 };
    sl = sizeof any2;
    if (bind(r->sfd, (struct sockaddr *)&any2, sizeof any2) || getsockname(r->sfd, (struct sockaddr *)&any2, &sl)) goto bad;
    r->sport = ntohs(any2.sin6_port);
    uint32_t ids[4];
    rnd(ids, sizeof ids);
    r->v.ssrc = ids[0] | 1;
    r->a.ssrc = ids[1] | 2;
    r->v.ts_off = ids[2];
    r->a.ts_off = ids[3];
    r->v.seq = (uint16_t)ids[2];
    r->a.seq = (uint16_t)ids[3];
    r->v.hist = calloc(HIST, sizeof(Hist));
    /* external STUN servers: our public address, if any */
    for (int i = 0; i < cfg->nstun && r->nstun_srv < RTC_MAX_STUN; i++) {
        RwAddr a;
        if (resolve(cfg->stun[i], &a)) continue;
        r->stun_srv[r->nstun_srv] = a;
        rnd(r->stun_tid[r->nstun_srv], 12);
        RwStunOut o;
        rw_so_init(&o, RW_STUN_BINDING_REQ, r->stun_tid[r->nstun_srv]);
        rw_so_fingerprint(&o);
        raw_send(r, &a, o.b, o.n);
        r->nstun_srv++;
    }
    if (cfg->turn[0] && cfg->turn_user[0] && (cfg->turn_pass || cfg->turn_has_key)) {
        Turn *t = &r->turn;
        t->transport = cfg->turn_transport;
        const char *colon = strrchr(cfg->turn, ':');
        size_t hl = colon ? (size_t)(colon - cfg->turn) : 0;
        if (hl && hl < sizeof t->host) {
            memcpy(t->host, cfg->turn, hl);
            t->host[hl] = 0;
            if (t->host[0] == '[' && hl > 2) { memmove(t->host, t->host + 1, hl - 2); t->host[hl - 2] = 0; }
        }
        if (resolve(cfg->turn, &t->srv)) sd_log("video: the TURN server's name does not resolve");
        else if (t->transport == RW_TURN_UDP) { t->state = 1; turn_send(r, RW_TURN_ALLOCATE_REQ, 0, NULL, 0, 600); }
        else {
            /* the stream is connected without blocking; the Allocate waits in its queue */
            t->fd = socket(AF_INET6, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
            struct sockaddr_in6 ts;
            to_sockaddr(&t->srv, &ts);
            if (t->fd >= 0) {
                int v6only = 0, on = 1;
                setsockopt(t->fd, IPPROTO_IPV6, IPV6_V6ONLY, &v6only, sizeof v6only);
                setsockopt(t->fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof on);
            }
            if (t->fd < 0 || (connect(t->fd, (struct sockaddr *)&ts, sizeof ts) && errno != EINPROGRESS)) {
                sd_log("video: could not connect to the TURN server");
                turn_stream_close(t);
            } else {
                t->connecting = 1;
                t->started = now_ms();
                t->state = 1;
                turn_send(r, RW_TURN_ALLOCATE_REQ, 0, NULL, 0, 600);
            }
        }
    }
    if (r->turn.state != 1) wipe_pass(r);
    return r;
bad:
    sd_log("video: could not start the WebRTC peer");
    rtc_free(r);
    return NULL;
}

void rtc_free(Rtc *r) {
    if (!r) return;
    if (r->sctp) { usrsctp_close(r->sctp); r->sctp = NULL; }
    if (r->sctp_on) usrsctp_deregister_address(r);
    if (r->tx) srtp_dealloc(r->tx);
    if (r->rx) srtp_dealloc(r->rx);
    if (r->ssl) SSL_free(r->ssl);
    if (r->ctx) SSL_CTX_free(r->ctx);
    X509_free(r->cert);
    EVP_PKEY_free(r->key);
    if (r->fd >= 0) close(r->fd);
    if (r->sfd >= 0) close(r->sfd);
    for (int i = 0; i < MAX_TCP; i++) if (r->tcp[i].fd >= 0) { close(r->tcp[i].fd); q_free(&r->tcp[i].out); }
    turn_stream_close(&r->turn);
    wipe_pass(r);
    explicit_bzero(r->turn.key, sizeof r->turn.key);
    explicit_bzero(r->pwd, sizeof r->pwd);
    free(r->v.hist);
    free(r->rasm);
    free(r->of);
    free(r);
}

/* host candidates: the address the WebSocket came in on first, then the other interfaces; each also
 * as a passive TCP candidate on the remote desktop's port (lower priority: UDP wins when it works) */
static int local_cands(Rtc *r, RwLocalCand *c, int max) {
    int n = 0;
    RwAddr seen[16];
    int ns = 0;
    if (r->cfg.ws_local.family) {
        rw_addr_format(&r->cfg.ws_local, c[n].ip, sizeof c[n].ip);
        c[n].port = (uint16_t)r->port;
        c[n].type = RW_CAND_HOST;
        c[n].prio = (126u << 24) | (65535u << 8) | 255u;
        seen[ns++] = r->cfg.ws_local;
        n++;
    }
    struct ifaddrs *ifs = NULL;
    if (!getifaddrs(&ifs)) {
        for (struct ifaddrs *i = ifs; i && n < max / 2 && ns < 16; i = i->ifa_next) {
            if (!i->ifa_addr || (i->ifa_flags & IFF_LOOPBACK) || !(i->ifa_flags & IFF_UP)) continue;
            RwAddr a = { 0 };
            if (i->ifa_addr->sa_family == AF_INET) { a.family = 4; memcpy(a.a, &((struct sockaddr_in *)i->ifa_addr)->sin_addr, 4); }
            else if (i->ifa_addr->sa_family == AF_INET6) {
                const uint8_t *b = ((struct sockaddr_in6 *)i->ifa_addr)->sin6_addr.s6_addr;
                if (b[0] == 0xfe && (b[1] & 0xc0) == 0x80) continue;         /* link-local: needs a scope */
                a.family = 6;
                memcpy(a.a, b, 16);
            } else continue;
            int dup = 0;
            for (int k = 0; k < ns; k++) if (same_ip(&seen[k], &a)) dup = 1;
            if (dup) continue;
            seen[ns++] = a;
            rw_addr_format(&a, c[n].ip, sizeof c[n].ip);
            c[n].port = (uint16_t)r->port;
            c[n].type = RW_CAND_HOST;
            c[n].prio = (126u << 24) | ((unsigned)(60000 - n * 10 - (a.family == 6 ? 5 : 0)) << 8) | 255u;
            n++;
        }
        freeifaddrs(ifs);
    }
    int nhost = n;
    if (r->cfg.ice_lfd >= 0 && r->cfg.tcp_port > 0)
        for (int i = 0; i < nhost && n < max - 2; i++) {
            c[n] = c[i];
            c[n].tcp = 1;
            c[n].port = (uint16_t)r->cfg.tcp_port;
            c[n].prio = (80u << 24) | ((unsigned)(60000 - i * 10) << 8) | 255u;
            n++;
        }
    if (r->srflx.family && n < max) {
        rw_addr_format(&r->srflx, c[n].ip, sizeof c[n].ip);
        c[n].port = r->srflx.port;
        c[n].type = RW_CAND_SRFLX;
        c[n].prio = (100u << 24) | (65535u << 8) | 255u;
        snprintf(c[n].raddr, sizeof c[n].raddr, "%s", n ? c[0].ip : "0.0.0.0");
        c[n].rport = (uint16_t)r->port;
        n++;
    }
    if (r->turn.state == 3 && n < max) {
        rw_addr_format(&r->turn.relayed, c[n].ip, sizeof c[n].ip);
        c[n].port = r->turn.relayed.port;
        c[n].type = RW_CAND_RELAY;
        c[n].prio = (2u << 24) | (65535u << 8) | 255u;
        rw_addr_format(&r->turn.mapped, c[n].raddr, sizeof c[n].raddr);
        c[n].rport = r->turn.mapped.port;
        n++;
    }
    return n;
}

static void json_escape(const char *s, char *out, size_t cap) {
    size_t o = 0;
    for (; *s && o + 7 < cap; s++) {
        unsigned char c = (unsigned char)*s;
        if (c == '"' || c == '\\') { out[o++] = '\\'; out[o++] = (char)c; }
        else if (c == '\r') { out[o++] = '\\'; out[o++] = 'r'; }
        else if (c == '\n') { out[o++] = '\\'; out[o++] = 'n'; }
        else if (c >= 0x20 && c < 0x7f) out[o++] = (char)c;
    }
    out[o] = 0;
}

static void send_answer(Rtc *r) {
    if (r->answered) return;
    r->answered = 1;
    RwLocalCand c[24];
    memset(c, 0, sizeof c);
    int nc = local_cands(r, c, 24);
    static uint32_t sid;
    if (!sid) { rnd(&sid, sizeof sid); sid &= 0x7fffffff; if (!sid) sid = 1; }
    RwAnswer an = { r->ufrag, r->pwd, r->fp, r->v.ssrc, r->a.ssrc, r->of->am >= 0, c, nc, sid, 2 + r->restarts };
    static char sdp[16384], esc[20000], msg[20100];
    int l = rw_sdp_answer(r->of, &an, sdp, sizeof sdp);
    if (l < 0) { fail(r, RTC_WHY_SERVER, "the answer does not fit"); return; }
    json_escape(sdp, esc, sizeof esc);
    snprintf(msg, sizeof msg, "{\"t\":\"rtc\",\"sdp\":\"%s\",\"codec\":\"%s\",\"p\":%d%s}", esc, r->codec == RW_CODEC_H264 ? "h264" : "vp8",
             r->cfg.peer_no, r->restarts ? ",\"restart\":1" : "");
    if (r->cb.signal) r->cb.signal(r->cb.ud, msg);
}

static void add_remote_cands(Rtc *r) {
    for (int i = 0; i < r->of->ncand && r->nrcand < 16; i++) {
        const RwCand *c = &r->of->cand[i];
        if (!c->mdns && !c->tcp && c->component == 1) { r->rcand[r->nrcand++] = c->addr; turn_peer(r, &c->addr); }
    }
    turn_perms(r);
}

/* An ICE restart (RFC 8445 §9): the same browser (the DTLS fingerprint of the signed-in offer), the same
 * sections and codec, new credentials on both sides. Paths must be checked again with them; the media
 * keeps its path until a new one is nominated and proven. */
static int restart(Rtc *r, const char *sdp, size_t n, int allow_h264) {
    RwOffer *of = malloc(sizeof *of);
    if (!of) return -1;
    int e = rw_sdp_parse_offer(sdp, n, allow_h264, of);
    int same = !e && !CRYPTO_memcmp(of->fp, r->of->fp, 32) && of->vcodec == r->of->vcodec && of->vpt == r->of->vpt &&
               of->apt == r->of->apt && of->nmedia == r->of->nmedia && (of->dm >= 0) == (r->of->dm >= 0);
    for (int i = 0; same && i < of->nmedia; i++) same = of->m[i].kind == r->of->m[i].kind && !strcmp(of->m[i].mid, r->of->m[i].mid);
    if (!same) {
        sd_log("video: refused an ICE restart (%s)", e ? "the offer doesn't parse" : "it isn't the same peer, codec or sections");
        free(of);
        return e ? e : -1;
    }
    if (!strcmp(of->ufrag, r->of->ufrag) && !strcmp(of->pwd, r->of->pwd)) {      /* not a restart: the same answer again */
        free(of);
        r->answered = 0;
        send_answer(r);
        return r->codec;
    }
    free(r->of);
    r->of = of;
    r->restarts++;
    new_credentials(r);
    for (int i = 0; i < r->npath; i++) { r->path[i].valid = 0; r->path[i].nominated = 0; }
    r->checks = 0;
    r->nrcand = 0;
    r->last_consent = r->created = now_ms();
    add_remote_cands(r);
    r->answered = 0;
    sd_log("video: ICE restart %u", r->restarts);
    send_answer(r);
    return r->codec;
}

int rtc_offer(Rtc *r, const char *sdp, size_t n, int allow_h264) {
    if (!r || r->failed) return -1;
    if (r->offered) return restart(r, sdp, n, allow_h264);
    r->of = malloc(sizeof *r->of);
    if (!r->of) return -1;
    int e = rw_sdp_parse_offer(sdp, n, allow_h264, r->of);
    if (e) { sd_log("video: refused the browser's offer (%d)", e); free(r->of); r->of = NULL; return e; }
    r->offered = 1;
    r->created = r->last_consent = now_ms();
    r->codec = r->of->vcodec;
    r->v.pt = r->of->vpt;
    r->a.pt = r->of->apt;
    add_remote_cands(r);
    int waiting = (r->nstun_srv && !r->srflx.family) || (r->turn.state > 0 && r->turn.state < 3);
    if (waiting) r->answer_due = now_ms() + (r->turn.state > 0 && r->turn.transport != RW_TURN_UDP ? ANSWER_WAIT_TCP_MS : ANSWER_WAIT_MS);
    else send_answer(r);
    return r->codec;
}

int rtc_candidate(Rtc *r, const char *c, size_t n) {
    RwCand k;
    if (!r || !r->offered) return -1;
    if (n == 0) return 0;                                           /* end of candidates */
    if (rw_cand_parse(c, n, &k)) return -1;
    if (!k.mdns && !k.tcp && k.component == 1 && r->nrcand < 16) {
        r->rcand[r->nrcand++] = k.addr;
        turn_peer(r, &k.addr);
        if (r->turn.perm_dirty) turn_perms(r);
    }
    return 0;
}

int rtc_pollfds(Rtc *r, struct pollfd *p, int max) {
    if (!r || r->fd < 0 || max < RTC_MAX_FDS || r->failed) return 0;
    int n = 0;
    p[n++] = (struct pollfd){ r->fd, POLLIN, 0 };
    p[n++] = (struct pollfd){ r->sfd, POLLIN, 0 };
    if (r->cfg.ice_lfd >= 0) p[n++] = (struct pollfd){ r->cfg.ice_lfd, POLLIN, 0 };
    for (int i = 0; i < MAX_TCP; i++)
        if (r->tcp[i].fd >= 0) p[n++] = (struct pollfd){ r->tcp[i].fd, (short)(POLLIN | (r->tcp[i].out.off < r->tcp[i].out.len ? POLLOUT : 0)), 0 };
    Turn *t = &r->turn;
    if (t->fd >= 0 && t->state >= 0) {
        short ev = POLLIN;
        if (t->connecting == 1 || t->out.off < t->out.len) ev |= POLLOUT;
        if (t->connecting == 2 && t->tssl && SSL_want_write(t->tssl)) ev |= POLLOUT;
        p[n++] = (struct pollfd){ t->fd, ev, 0 };
    }
    return n;
}

void rtc_dispatch(Rtc *r, const struct pollfd *p, int n) {
    if (!r) return;
    static uint8_t buf[2048];
    for (int f = 0; f < n && !r->failed; f++) {
        short ev = p[f].revents;
        if (!ev) continue;
        int fd = p[f].fd;
        if (fd == r->fd || fd == r->sfd) {
            if (!(ev & POLLIN)) continue;
            for (int k = 0; k < 256 && !r->failed; k++) {
                struct sockaddr_in6 s;
                socklen_t sl = sizeof s;
                ssize_t got = recvfrom(fd, buf, sizeof buf, MSG_DONTWAIT, (struct sockaddr *)&s, &sl);
                if (got < 0) break;
                if (got > 1500 || s.sin6_family != AF_INET6) continue;
                RwAddr from;
                from_sockaddr(&s, &from);
                if (fd == r->sfd) stun_server(r, buf, (size_t)got, &from);
                else handle_packet(r, buf, (size_t)got, &from, 0, 0);
            }
        } else if (fd == r->cfg.ice_lfd) {
            if (ev & POLLIN) for (int k = 0; k < 4; k++) { tcp_accept(r); struct pollfd q = { fd, POLLIN, 0 }; if (poll(&q, 1, 0) <= 0) break; }
            /* the new connection's first packet is already in its buffer */
            for (int i = 0; i < MAX_TCP; i++) if (r->tcp[i].fd >= 0 && r->tcp[i].inl && !r->tcp[i].checked) tcp_input(r, i);
        } else if (fd == r->turn.fd) {
            Turn *t = &r->turn;
            if (t->connecting) turn_stream_ready(r);
            else {
                if (ev & (POLLERR | POLLHUP)) { t->up = 0; t->state = -1; sd_log("video: the TURN server's connection closed"); continue; }
                if (ev & POLLOUT) turn_flush(r);
                if (ev & POLLIN) turn_stream_input(r);
            }
            if (t->state < 0) turn_stream_close(t);
        } else {
            for (int i = 0; i < MAX_TCP; i++) {
                if (r->tcp[i].fd != fd) continue;
                if (ev & POLLOUT) tcp_flush(r, i);
                if (r->tcp[i].fd >= 0 && (ev & (POLLIN | POLLHUP | POLLERR))) tcp_input(r, i);
            }
        }
    }
}

int rtc_timeout(Rtc *r) {
    if (!r || r->failed) return -1;
    int t = 1000;
    if (r->sctp_on) t = 10;
    if (r->answer_due && !r->answered) t = 50;
    if (r->ssl && !r->dtls_up && r->offered) {
        struct timeval tv;
        if (DTLSv1_get_timeout(r->ssl, &tv)) { int ms = (int)(tv.tv_sec * 1000 + tv.tv_usec / 1000); if (ms < t) t = ms < 1 ? 1 : ms; }
    }
    return t;
}

void rtc_tick(Rtc *r) {
    if (!r || r->failed) return;
    double t = now_ms();
    if (!r->answered && r->answer_due && (t >= r->answer_due || ((!r->nstun_srv || r->srflx.family) && (r->turn.state <= 0 || r->turn.state == 3)))) send_answer(r);
    if (r->ssl && !r->dtls_up && r->offered) DTLSv1_handle_timeout(r->ssl);
    if (r->sctp_on) {
        uint32_t el = (uint32_t)(t - r->sctp_t);
        if (el >= 1) { r->sctp_t = t; usrsctp_handle_timers(el); }
    }
    if (r->srtp_up && t - r->last_sr > 1000) { send_sr(r, &r->v); send_sr(r, &r->a); r->last_sr = t; }
    for (int i = 0; i < MAX_TCP; i++)
        if (r->tcp[i].fd >= 0 && !r->tcp[i].checked && t - r->tcp[i].born > TCP_CHECK_MS) tcp_close(r, i, "no valid ICE check");
    Turn *tu = &r->turn;
    if (tu->state == 1 || tu->state == 2) {
        if (tu->transport == RW_TURN_UDP) {
            if (t - tu->sent_at > 500) { if (++tu->tries > 6) { tu->state = -1; wipe_pass(r); sd_log("video: no answer from the TURN server"); } else turn_send(r, RW_TURN_ALLOCATE_REQ, tu->state == 2, NULL, 0, 600); }
        } else if (t - tu->started > 8000) {           /* a stream is reliable: no retransmissions, one deadline */
            tu->state = -1;
            wipe_pass(r);
            sd_log("video: no answer from the TURN server over %s", rw_turn_transport_name(tu->transport));
            turn_stream_close(tu);
        }
    } else if (tu->state == 3) {
        if (t >= tu->refresh_at) { turn_send(r, RW_TURN_REFRESH_REQ, 1, NULL, 0, 600); tu->refresh_at = t + 60000; }
        if (tu->perm_dirty || (tu->nperm && t >= tu->perm_at)) turn_perms(r);
    } else if (tu->state < 0 && tu->fd >= 0) turn_stream_close(tu);
    if (r->offered && r->dtls_up && t - r->last_consent > CONSENT_MS) fail(r, RTC_WHY_LOST, "the browser stopped answering (no ICE checks)");
    if (r->offered && !r->dtls_up && t - r->created > CONNECT_MS)
        fail(r, r->checks ? RTC_WHY_DTLS : RTC_WHY_NOROUTE, r->checks ? "no DTLS after 20 s (ICE checks arrived)" : "no connection after 20 s (no ICE check arrived over UDP or TCP)");
}

int rtc_turn_key(const Rtc *r, uint8_t key[16], char realm[256]) {
    if (!r || r->turn.state != 3) return -1;
    memcpy(key, r->turn.key, 16);
    memcpy(realm, r->turn.realm, 256);
    return 0;
}

const char *rtc_path_kind(const Rtc *r) {
    const Path *s = r && r->sel >= 0 ? &r->path[r->sel] : NULL;
    return !s ? "" : s->relay ? "relay" : s->tcp ? "tcp" : "udp";
}

int rtc_send(Rtc *r, int chan, const void *p, size_t n, int binary) {
    if (!r || r->failed || chan < 0 || chan > 1 || !r->dc_open[chan] || n > MAX_DC_MSG) return -1;
    return dc_raw(r, r->dc_sid[chan], binary ? 53 : 51, p, n);
}

int rtc_dc_open(const Rtc *r, int chan) { return r && !r->failed && chan >= 0 && chan < 2 && r->dc_open[chan]; }

void rtc_stats(const Rtc *r, char *out, size_t n) {
    if (!r) { snprintf(out, n, "-"); return; }
    snprintf(out, n, "%s %u kbps, %.1f %% lost, %lu NACK (%lu resent), %lu PLI", r->codec == RW_CODEC_H264 ? "h264" : r->codec ? "vp8" : "no codec yet", r->kbps,
             r->lost * 100, r->nacks, r->resent, r->plis);
}