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.

27.9 KB
Raw Blame
/* dbus.c — own minimal D-Bus client (see dbus.h). */
#include "dbus.h"

#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>

/* ================= signatures ================= */

static int align_of(char c) {
    switch (c) {
    case 'y': case 'g': case 'v': return 1;
    case 'n': case 'q': return 2;
    case 'b': case 'i': case 'u': case 's': case 'o': case 'a': return 4;
    case 'x': case 't': case 'd': case '(': case '{': return 8;
    default: return 0;
    }
}
static int is_basic(char c) { return c && strchr("ybnqiuxtdsog", c) != NULL; }

static int sig_one(const char *s, size_t *n, int depth, int in_array) {
    if (depth > DBUS_MAX_DEPTH) return -1;
    char c = s[0];
    if (is_basic(c) || c == 'v') { *n = 1; return 0; }
    if (c == 'a') {
        size_t k;
        if (s[1] == '{') {
            if (!is_basic(s[2])) return -1;
            if (sig_one(s + 3, &k, depth + 1, 0)) return -1;
            if (s[3 + k] != '}') return -1;
            *n = 4 + k;
            return 0;
        }
        if (sig_one(s + 1, &k, depth + 1, 1)) return -1;
        *n = 1 + k;
        return 0;
    }
    if (c == '(') {
        size_t p = 1, k;
        if (s[1] == ')') return -1;
        while (s[p] && s[p] != ')') { if (sig_one(s + p, &k, depth + 1, 0)) return -1; p += k; }
        if (s[p] != ')') return -1;
        *n = p + 1;
        return 0;
    }
    (void)in_array;
    return -1;
}

int dbus_sig_single(const char *sig, size_t *n) { return sig_one(sig, n, 0, 0); }

int dbus_sig_valid(const char *sig) {
    size_t len = strlen(sig), p = 0, k;
    if (len > 255) return 0;
    while (p < len) { if (sig_one(sig + p, &k, 0, 0)) return 0; p += k; }
    return 1;
}

int dbus_path_valid(const char *p) {
    if (!p || p[0] != '/') return 0;
    if (!p[1]) return 1;
    int prev_slash = 1;
    for (const char *s = p + 1; *s; s++) {
        char c = *s;
        if (c == '/') { if (prev_slash) return 0; prev_slash = 1; continue; }
        if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_')) return 0;
        prev_slash = 0;
    }
    return !prev_slash;
}

int dbus_name_valid(const char *n) {
    size_t len = n ? strlen(n) : 0;
    if (!len || len > 255) return 0;
    int dots = 0, start = 1;
    for (const char *s = n; *s; s++) {
        char c = *s;
        if (c == '.') { if (start) return 0; dots++; start = 1; continue; }
        int alpha = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_' || c == '-';
        if (!alpha && !(c >= '0' && c <= '9')) return 0;
        if (start && !alpha) return 0;
        start = 0;
    }
    return dots >= 1 && !start;
}

/* ================= body validation ================= */

typedef struct { const uint8_t *b; size_t len, pos; int be; } V;

static uint32_t rd32(const uint8_t *p, int be) {
    return be ? (uint32_t)p[0] << 24 | (uint32_t)p[1] << 16 | (uint32_t)p[2] << 8 | p[3]
              : (uint32_t)p[3] << 24 | (uint32_t)p[2] << 16 | (uint32_t)p[1] << 8 | p[0];
}

static int v_align(V *v, int a) {
    size_t np = (v->pos + (size_t)a - 1) & ~((size_t)a - 1);
    if (np > v->len) return -1;
    for (size_t i = v->pos; i < np; i++) if (v->b[i]) return -1;   /* zero padding */
    v->pos = np;
    return 0;
}

static int v_str(V *v, int path) {
    if (v_align(v, 4) || v->pos + 4 > v->len) return -1;
    uint32_t n = rd32(v->b + v->pos, v->be);
    v->pos += 4;
    if (n > v->len - v->pos || v->len - v->pos - n < 1) return -1;
    const uint8_t *s = v->b + v->pos;
    if (memchr(s, 0, n) || s[n]) return -1;
    if (path && !dbus_path_valid((const char *)s)) return -1;
    v->pos += n + 1;
    return 0;
}

static int v_sig(V *v, int single) {
    if (v->pos >= v->len) return -1;
    uint8_t n = v->b[v->pos++];
    if (n > v->len - v->pos || v->len - v->pos - n < 1) return -1;
    const char *s = (const char *)v->b + v->pos;
    if (memchr(s, 0, n) || s[n]) return -1;
    if (!dbus_sig_valid(s)) return -1;
    if (single) { size_t k; if (!n || sig_one(s, &k, 0, 0) || k != n) return -1; }
    v->pos += (size_t)n + 1;
    return 0;
}

static int v_type(V *v, const char *sig, size_t *used, int depth);

static int v_type(V *v, const char *sig, size_t *used, int depth) {
    if (depth > DBUS_MAX_DEPTH) return -1;
    char c = sig[0];
    size_t k;
    if (sig_one(sig, &k, 0, 0)) return -1;
    *used = k;
    switch (c) {
    case 'y': if (v->pos + 1 > v->len) return -1; v->pos++; return 0;
    case 'n': case 'q': if (v_align(v, 2) || v->pos + 2 > v->len) return -1; v->pos += 2; return 0;
    case 'b': {
        if (v_align(v, 4) || v->pos + 4 > v->len) return -1;
        uint32_t x = rd32(v->b + v->pos, v->be);
        if (x > 1) return -1;
        v->pos += 4;
        return 0;
    }
    case 'i': case 'u': if (v_align(v, 4) || v->pos + 4 > v->len) return -1; v->pos += 4; return 0;
    case 'x': case 't': case 'd': if (v_align(v, 8) || v->pos + 8 > v->len) return -1; v->pos += 8; return 0;
    case 's': return v_str(v, 0);
    case 'o': return v_str(v, 1);
    case 'g': return v_sig(v, 0);
    case 'v': {
        size_t sp = v->pos;
        if (v_sig(v, 1)) return -1;
        const char *inner = (const char *)v->b + sp + 1;
        size_t u;
        return v_type(v, inner, &u, depth + 1);
    }
    case 'a': {
        if (v_align(v, 4) || v->pos + 4 > v->len) return -1;
        uint32_t n = rd32(v->b + v->pos, v->be);
        v->pos += 4;
        if (n > 64u * 1024 * 1024) return -1;
        const char *el = sig + 1;
        if (v_align(v, align_of(el[0]))) return -1;
        if (n > v->len - v->pos) return -1;
        size_t end = v->pos + n;
        while (v->pos < end) {
            size_t u;
            if (el[0] == '{') {
                if (v_align(v, 8)) return -1;
                if (v_type(v, el + 1, &u, depth + 1)) return -1;
                size_t u2;
                if (v_type(v, el + 1 + u, &u2, depth + 1)) return -1;
            } else if (v_type(v, el, &u, depth + 1)) return -1;
            if (v->pos > end) return -1;
        }
        return 0;
    }
    case '(': {
        if (v_align(v, 8)) return -1;
        size_t p = 1;
        while (sig[p] != ')') {
            size_t u;
            if (v_type(v, sig + p, &u, depth + 1)) return -1;
            p += u;
        }
        return 0;
    }
    default: return -1;
    }
}

static int v_body(V *v, const char *sig) {
    size_t p = 0, n = strlen(sig);
    while (p < n) { size_t u; if (v_type(v, sig + p, &u, 0)) return -1; p += u; }
    return 0;
}

int dbus_body_valid(const char *sig, const uint8_t *body, size_t len, int big_endian) {
    if (!dbus_sig_valid(sig)) return 0;
    V v = { body, len, 0, big_endian };
    if (v_body(&v, sig)) return 0;
    return v.pos == len;
}

/* ================= messages ================= */

long dbus_msg_size(const uint8_t *buf, size_t len) {
    if (len < 16) return 0;
    if (buf[0] != 'l' && buf[0] != 'B') return -1;
    if (buf[3] != 1) return -1;
    int be = buf[0] == 'B';
    uint32_t body = rd32(buf + 4, be), fields = rd32(buf + 12, be);
    if (fields > 64u * 1024 * 1024 || body > DBUS_MAX_MSG) return -1;
    uint64_t total = ((16u + (uint64_t)fields + 7) & ~(uint64_t)7) + body;
    if (total > DBUS_MAX_MSG) return -1;
    return (long)total;
}

static const char *const field_sig[10] = { NULL, "o", "s", "s", "s", "u", "s", "s", "g", "u" };

int dbus_msg_parse(const uint8_t *buf, size_t len, DMsg *m) {
    memset(m, 0, sizeof *m);
    long total = dbus_msg_size(buf, len);
    if (total <= 0 || (size_t)total != len) return -1;
    int be = buf[0] == 'B';
    uint8_t type = buf[1];
    if (type < DBUS_CALL || type > DBUS_SIGNAL) return -1;
    uint32_t serial = rd32(buf + 8, be);
    if (!serial) return -1;
    m->raw = malloc(len + 1);
    if (!m->raw) return -1;
    memcpy(m->raw, buf, len);
    m->raw[len] = 0;
    m->raw_len = len;
    m->type = type;
    m->flags = buf[2];
    m->big_endian = (uint8_t)be;
    m->serial = serial;
    uint32_t flen = rd32(buf + 12, be);
    size_t hend = 16 + flen;
    /* validate a(yv) from byte 12 with the message alignment */
    V v = { m->raw, hend, 12, be };
    size_t u;
    if (v_type(&v, "a(yv)", &u, 0) || v.pos != hend) goto bad;
    /* zero padding up to 8 */
    size_t bstart = (hend + 7) & ~(size_t)7;
    for (size_t i = hend; i < bstart; i++) if (m->raw[i]) goto bad;
    /* walk the fields */
    size_t p = 16;
    uint32_t got_fds = 0;
    while (p < hend) {
        p = (p + 7) & ~(size_t)7;
        uint8_t code = m->raw[p++];
        uint8_t sl = m->raw[p];
        const char *vs = (const char *)m->raw + p + 1;
        p += 1 + (size_t)sl + 1;
        if (code >= 1 && code <= 9) {
            if (strcmp(vs, field_sig[code])) goto bad;
            if (code == 5 || code == 9) {
                p = (p + 3) & ~(size_t)3;
                uint32_t x = rd32(m->raw + p, be);
                p += 4;
                if (code == 5) m->reply_serial = x; else got_fds = x;
            } else if (code == 8) {
                uint8_t n = m->raw[p];
                m->sig = (const char *)m->raw + p + 1;
                p += 1 + (size_t)n + 1;
            } else {
                p = (p + 3) & ~(size_t)3;
                uint32_t n = rd32(m->raw + p, be);
                const char *s = (const char *)m->raw + p + 4;
                p += 4 + (size_t)n + 1;
                switch (code) {
                case 1: m->path = s; break;
                case 2: m->iface = s; break;
                case 3: m->member = s; break;
                case 4: m->error = s; break;
                case 6: m->dest = s; break;
                case 7: m->sender = s; break;
                }
            }
        } else {
            /* unknown field: skip it (already validated) */
            V w = { m->raw, hend, p, be };
            size_t k;
            if (v_type(&w, vs, &k, 1)) goto bad;
            p = w.pos;
        }
    }
    if (got_fds) goto bad;                               /* we do not accept fds */
    switch (type) {
    case DBUS_CALL: if (!m->path || !m->member) goto bad; break;
    case DBUS_RETURN: if (!m->reply_serial) goto bad; break;
    case DBUS_ERROR: if (!m->reply_serial || !m->error) goto bad; break;
    case DBUS_SIGNAL: if (!m->path || !m->iface || !m->member) goto bad; break;
    }
    if (m->iface && !dbus_name_valid(m->iface)) goto bad;
    if (m->error && !dbus_name_valid(m->error)) goto bad;
    if (m->member) {
        size_t ml = strlen(m->member);
        if (!ml || ml > 255) goto bad;
        for (const char *s = m->member; *s; s++)
            if (!((*s >= 'a' && *s <= 'z') || (*s >= 'A' && *s <= 'Z') || (*s >= '0' && *s <= '9') || *s == '_')) goto bad;
        if (m->member[0] >= '0' && m->member[0] <= '9') goto bad;
    }
    m->body = m->raw + bstart;
    m->body_len = (uint32_t)(len - bstart);
    if (!m->sig) { if (m->body_len) goto bad; m->sig = ""; }
    else if (!dbus_body_valid(m->sig, m->body, m->body_len, be)) goto bad;
    return 0;
bad:
    dbus_msg_free(m);
    return -1;
}

void dbus_msg_free(DMsg *m) {
    if (m->raw) { explicit_bzero(m->raw, m->raw_len); free(m->raw); }
    memset(m, 0, sizeof *m);
}

/* ================= typed reader ================= */

void dr_init(DRd *r, const DMsg *m) { r->b = m->body; r->len = m->body_len; r->pos = 0; r->be = m->big_endian; r->err = 0; }

static int r_align(DRd *r, int a) {
    size_t np = (r->pos + (size_t)a - 1) & ~((size_t)a - 1);
    if (np > r->len) { r->err = 1; return -1; }
    r->pos = np;
    return 0;
}
static int r_need(DRd *r, size_t n) { if (r->err || n > r->len - r->pos) { r->err = 1; return -1; } return 0; }

uint8_t dr_u8(DRd *r) { if (r_need(r, 1)) return 0; return r->b[r->pos++]; }
uint32_t dr_u32(DRd *r) {
    if (r->err || r_align(r, 4) || r_need(r, 4)) return 0;
    uint32_t x = rd32(r->b + r->pos, r->be);
    r->pos += 4;
    return x;
}
int dr_bool(DRd *r) { return dr_u32(r) != 0; }
int32_t dr_i32(DRd *r) { return (int32_t)dr_u32(r); }
uint64_t dr_u64(DRd *r) {
    if (r->err || r_align(r, 8) || r_need(r, 8)) return 0;
    uint64_t lo = rd32(r->b + r->pos + (r->be ? 4 : 0), r->be), hi = rd32(r->b + r->pos + (r->be ? 0 : 4), r->be);
    r->pos += 8;
    return hi << 32 | lo;
}
const char *dr_str(DRd *r, uint32_t *len) {
    uint32_t n = dr_u32(r);
    if (r->err || r_need(r, (size_t)n + 1)) { if (len) *len = 0; return ""; }
    const char *s = (const char *)r->b + r->pos;
    r->pos += (size_t)n + 1;
    if (len) *len = n;
    return s;
}
const char *dr_sig(DRd *r) {
    uint8_t n = dr_u8(r);
    if (r->err || r_need(r, (size_t)n + 1)) return "";
    const char *s = (const char *)r->b + r->pos;
    r->pos += (size_t)n + 1;
    return s;
}
const uint8_t *dr_bytes(DRd *r, uint32_t *len) {
    uint32_t n = dr_u32(r);
    if (r->err || r_need(r, n)) { *len = 0; return (const uint8_t *)""; }
    const uint8_t *p = r->b + r->pos;
    r->pos += n;
    *len = n;
    return p;
}
size_t dr_arr(DRd *r, int elem_align) {
    uint32_t n = dr_u32(r);
    if (r->err || r_align(r, elem_align) || r_need(r, n)) return r->pos;
    return r->pos + n;
}
int dr_more(DRd *r, size_t end) { return !r->err && r->pos < end; }
void dr_struct(DRd *r) { r_align(r, 8); }
const char *dr_variant(DRd *r) { return dr_sig(r); }
void dr_skip(DRd *r, const char *sig) {
    if (r->err) return;
    V v = { r->b, r->len, r->pos, r->be };
    size_t u;
    if (v_type(&v, sig, &u, 0)) { r->err = 1; return; }
    r->pos = v.pos;
}

/* ================= writer ================= */

void dw_init(DBuf *w) { memset(w, 0, sizeof *w); }
void dw_free(DBuf *w) { if (w->p) { explicit_bzero(w->p, w->cap); free(w->p); } memset(w, 0, sizeof *w); }

static int w_need(DBuf *w, size_t n) {
    if (w->oom) return -1;
    if (n > DBUS_MAX_MSG || w->n + n > DBUS_MAX_MSG) { w->oom = 1; return -1; }
    if (w->n + n <= w->cap) return 0;
    size_t nc = w->cap ? w->cap : 256;
    while (nc < w->n + n) nc *= 2;
    uint8_t *p = malloc(nc);
    if (!p) { w->oom = 1; return -1; }
    if (w->p) { memcpy(p, w->p, w->n); explicit_bzero(w->p, w->cap); free(w->p); }   /* no realloc: the old data is wiped */
    w->p = p;
    w->cap = nc;
    return 0;
}
static void w_put(DBuf *w, const void *p, size_t n) { if (!n || w_need(w, n)) return; memcpy(w->p + w->n, p, n); w->n += n; }

void dw_align(DBuf *w, int a) {
    size_t np = (w->n + (size_t)a - 1) & ~((size_t)a - 1);
    if (np == w->n || w_need(w, np - w->n)) return;
    memset(w->p + w->n, 0, np - w->n);
    w->n = np;
}
void dw_u8(DBuf *w, uint8_t v) { w_put(w, &v, 1); }
void dw_u32(DBuf *w, uint32_t v) {
    dw_align(w, 4);
    uint8_t b[4] = { (uint8_t)v, (uint8_t)(v >> 8), (uint8_t)(v >> 16), (uint8_t)(v >> 24) };
    w_put(w, b, 4);
}
void dw_bool(DBuf *w, int v) { dw_u32(w, v ? 1 : 0); }
void dw_i32(DBuf *w, int32_t v) { dw_u32(w, (uint32_t)v); }
void dw_u64(DBuf *w, uint64_t v) {
    dw_align(w, 8);
    uint8_t b[8];
    for (int i = 0; i < 8; i++) b[i] = (uint8_t)(v >> (8 * i));
    w_put(w, b, 8);
}
void dw_strn(DBuf *w, const char *s, size_t n) {
    dw_u32(w, (uint32_t)n);
    w_put(w, s, n);
    dw_u8(w, 0);
}
void dw_str(DBuf *w, const char *s) { dw_strn(w, s ? s : "", s ? strlen(s) : 0); }
void dw_sig(DBuf *w, const char *s) {
    size_t n = strlen(s);
    if (n > 255) { w->oom = 1; return; }
    dw_u8(w, (uint8_t)n);
    w_put(w, s, n);
    dw_u8(w, 0);
}
void dw_bytes(DBuf *w, const uint8_t *p, size_t n) { dw_u32(w, (uint32_t)n); w_put(w, p, n); }
size_t dw_arr_begin(DBuf *w, int elem_align) {
    dw_align(w, 4);
    size_t mark = w->n;
    dw_u32(w, 0);
    dw_align(w, elem_align);
    return mark << 4 | (size_t)elem_align;
}
void dw_arr_end(DBuf *w, size_t mark) {
    size_t off = mark >> 4, a = mark & 15;
    if (w->oom || off + 4 > w->n) return;
    size_t start = (off + 4 + a - 1) & ~(a - 1);
    uint32_t len = (uint32_t)(w->n - start);
    w->p[off] = (uint8_t)len; w->p[off + 1] = (uint8_t)(len >> 8); w->p[off + 2] = (uint8_t)(len >> 16); w->p[off + 3] = (uint8_t)(len >> 24);
}
void dw_struct(DBuf *w) { dw_align(w, 8); }
void dw_variant(DBuf *w, const char *sig) { dw_sig(w, sig); }

static void field_s(DBuf *w, uint8_t code, const char *sig, const char *val) {
    if (!val) return;
    dw_struct(w);
    dw_u8(w, code);
    dw_sig(w, sig);
    if (sig[0] == 'g') dw_sig(w, val); else dw_str(w, val);
}

int dbus_build(const DHdr *h, const DBuf *body, DBuf *out) {
    dw_init(out);
    uint8_t fixed[4] = { 'l', h->type, h->flags, 1 };
    w_put(out, fixed, 4);
    dw_u32(out, body ? (uint32_t)body->n : 0);
    dw_u32(out, h->serial);
    size_t mark = dw_arr_begin(out, 8);
    field_s(out, 1, "o", h->path);
    field_s(out, 2, "s", h->iface);
    field_s(out, 3, "s", h->member);
    field_s(out, 4, "s", h->error);
    if (h->reply_serial) { dw_struct(out); dw_u8(out, 5); dw_sig(out, "u"); dw_u32(out, h->reply_serial); }
    field_s(out, 6, "s", h->dest);
    field_s(out, 7, "s", h->sender);
    if (h->sig && h->sig[0]) field_s(out, 8, "g", h->sig);
    dw_arr_end(out, mark);
    dw_align(out, 8);
    if (body && body->n) w_put(out, body->p, body->n);
    if (body && body->oom) out->oom = 1;
    return out->oom ? -1 : 0;
}

/* ================= connection ================= */

int dbus_connect_session(void) {
    struct sockaddr_un a = { .sun_family = AF_UNIX };
    socklen_t alen = 0;
    const char *addr = getenv("DBUS_SESSION_BUS_ADDRESS");
    char path[sizeof a.sun_path];
    int abstract = 0;
    path[0] = 0;
    if (addr) {
        /* several addresses separated by ';': the first usable unix: one */
        const char *p = addr;
        while (p && *p && !path[0]) {
            const char *end = strchr(p, ';');
            size_t n = end ? (size_t)(end - p) : strlen(p);
            if (n > 5 && !strncmp(p, "unix:", 5)) {
                const char *kv = p + 5;
                while (kv < p + n) {
                    const char *c = memchr(kv, ',', (size_t)(p + n - kv));
                    size_t kl = c ? (size_t)(c - kv) : (size_t)(p + n - kv);
                    int isabs = kl > 9 && !strncmp(kv, "abstract=", 9);
                    if ((kl > 5 && !strncmp(kv, "path=", 5)) || isabs) {
                        const char *v = kv + (isabs ? 9 : 5);
                        size_t vl = kl - (isabs ? 9 : 5), o = 0;
                        for (size_t i = 0; i < vl && o + 1 < sizeof path; i++) {
                            if (v[i] == '%' && i + 2 < vl) { unsigned x; if (sscanf(v + i + 1, "%2x", &x) == 1) { path[o++] = (char)x; i += 2; continue; } }
                            path[o++] = v[i];
                        }
                        path[o] = 0;
                        abstract = isabs;
                        break;
                    }
                    if (!c) break;
                    kv = c + 1;
                }
            }
            p = end ? end + 1 : NULL;
        }
    }
    if (!path[0]) {
        const char *rt = getenv("XDG_RUNTIME_DIR");
        if (!rt || rt[0] != '/') return -1;
        if ((size_t)snprintf(path, sizeof path, "%s/bus", rt) >= sizeof path) return -1;
    }
    size_t pl = strlen(path);
    if (abstract) {
        if (pl + 1 > sizeof a.sun_path) return -1;
        a.sun_path[0] = 0;
        memcpy(a.sun_path + 1, path, pl);
        alen = (socklen_t)(offsetof(struct sockaddr_un, sun_path) + 1 + pl);
    } else {
        if (pl >= sizeof a.sun_path) return -1;
        memcpy(a.sun_path, path, pl + 1);
        alen = (socklen_t)sizeof a;
    }
    int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
    if (fd < 0) return -1;
    if (connect(fd, (struct sockaddr *)&a, alen)) { close(fd); return -1; }
    return fd;
}

/* System bus (BlueZ, power-profiles-daemon; Settings, see docs/SETTINGS.md):
 * DBUS_SYSTEM_BUS_ADDRESS if it is a unix:path=, else /run/dbus/system_bus_socket. */
int dbus_connect_system(void) {
    struct sockaddr_un a = { .sun_family = AF_UNIX };
    const char *addr = getenv("DBUS_SYSTEM_BUS_ADDRESS"), *path = "/run/dbus/system_bus_socket";
    char buf[sizeof a.sun_path];
    if (addr && !strncmp(addr, "unix:path=", 10)) {
        size_t n = strcspn(addr + 10, ",;");
        if (n && n < sizeof buf) { memcpy(buf, addr + 10, n); buf[n] = 0; path = buf; }
    }
    if (strlen(path) >= sizeof a.sun_path) return -1;
    memcpy(a.sun_path, path, strlen(path) + 1);
    int fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
    if (fd < 0) return -1;
    if (connect(fd, (struct sockaddr *)&a, sizeof a)) { close(fd); return -1; }
    return fd;
}

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

static int wait_fd(int fd, short ev, double deadline) {
    for (;;) {
        double left = deadline - now_ms();
        if (left <= 0) return -1;
        struct pollfd p = { fd, ev, 0 };
        int r = poll(&p, 1, (int)left + 1);
        if (r < 0 && errno == EINTR) continue;
        if (r <= 0) return -1;
        if (p.revents & (POLLERR | POLLNVAL)) return -1;
        return 0;
    }
}

static int write_all(int fd, const void *buf, size_t n, double deadline) {
    const uint8_t *p = buf;
    while (n) {
        ssize_t k = send(fd, p, n, MSG_NOSIGNAL);
        if (k < 0) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK) { if (wait_fd(fd, POLLOUT, deadline)) return -1; continue; }
            return -1;
        }
        p += k; n -= (size_t)k;
    }
    return 0;
}

/* One SASL line ("...\r\n"), one byte at a time so as not to swallow any of the binary protocol. */
static int read_line(int fd, char *out, size_t cap, double deadline) {
    size_t n = 0;
    for (;;) {
        char c;
        ssize_t k = read(fd, &c, 1);
        if (k < 0) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK) { if (wait_fd(fd, POLLIN, deadline)) return -1; continue; }
            return -1;
        }
        if (k == 0) return -1;
        if (n + 1 >= cap) return -1;
        out[n++] = c;
        if (n >= 2 && out[n - 2] == '\r' && out[n - 1] == '\n') { out[n - 2] = 0; return 0; }
    }
}

int dbus_open(DConn *c, int fd, int timeout_ms) {
    memset(c, 0, sizeof *c);
    c->fd = fd;
    if (fd < 0) return -1;
    int fl = fcntl(fd, F_GETFL);
    if (fl >= 0) fcntl(fd, F_SETFL, fl | O_NONBLOCK);
    double deadline = now_ms() + timeout_ms;
    char uid[16], hex[40], line[512];
    snprintf(uid, sizeof uid, "%u", (unsigned)getuid());
    size_t k = 0;
    for (const char *s = uid; *s; s++) k += (size_t)snprintf(hex + k, sizeof hex - k, "%02x", (unsigned char)*s);
    char msg[96];
    int ml = snprintf(msg, sizeof msg, "AUTH EXTERNAL %s\r\n", hex);
    if (write_all(fd, "", 1, deadline) || write_all(fd, msg, (size_t)ml, deadline)) return -1;
    if (read_line(fd, line, sizeof line, deadline) || strncmp(line, "OK ", 3)) return -1;
    if (write_all(fd, "BEGIN\r\n", 7, deadline)) return -1;
    DHdr h = { .type = DBUS_CALL, .path = "/org/freedesktop/DBus", .iface = "org.freedesktop.DBus", .member = "Hello", .dest = "org.freedesktop.DBus" };
    uint32_t s = dbus_send(c, &h, NULL);
    if (!s) return -1;
    DMsg m;
    double left = deadline - now_ms();
    if (dbus_wait_reply(c, s, &m, left > 0 ? (int)left : 1) != 1) { dbus_msg_free(&m); return -1; }
    DRd r;
    dr_init(&r, &m);
    if (strcmp(m.sig, "s")) { dbus_msg_free(&m); return -1; }
    snprintf(c->unique, sizeof c->unique, "%s", dr_str(&r, NULL));
    dbus_msg_free(&m);
    return 0;
}

void dbus_close(DConn *c) {
    if (c->fd >= 0) close(c->fd);
    if (c->in) { explicit_bzero(c->in, c->in_cap); free(c->in); }
    if (c->out) { explicit_bzero(c->out, c->out_cap); free(c->out); }
    memset(c, 0, sizeof *c);
    c->fd = -1;
}

int dbus_pending_out(const DConn *c) { return c->out_n > c->out_off; }

int dbus_flush(DConn *c) {
    if (c->dead) return -1;
    while (c->out_off < c->out_n) {
        ssize_t k = send(c->fd, c->out + c->out_off, c->out_n - c->out_off, MSG_NOSIGNAL | MSG_DONTWAIT);
        if (k < 0) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK) break;
            c->dead = 1;
            return -1;
        }
        c->out_off += (size_t)k;
    }
    if (c->out_off == c->out_n) { if (c->out) explicit_bzero(c->out, c->out_n); c->out_off = c->out_n = 0; }
    else if (c->out_off > c->out_cap / 2) {
        size_t rest = c->out_n - c->out_off;
        memmove(c->out, c->out + c->out_off, rest);
        explicit_bzero(c->out + rest, c->out_n - rest);
        c->out_n = rest;
        c->out_off = 0;
    }
    return 0;
}

uint32_t dbus_send(DConn *c, DHdr *h, const DBuf *body) {
    if (c->dead) return 0;
    if (!h->serial) { if (++c->serial == 0) c->serial = 1; h->serial = c->serial; }
    DBuf msg;
    if (dbus_build(h, body, &msg)) { dw_free(&msg); return 0; }
    if (c->out_n + msg.n > 64u * 1024 * 1024) { dw_free(&msg); c->dead = 1; return 0; }
    if (c->out_n + msg.n > c->out_cap) {
        size_t nc = c->out_cap ? c->out_cap : 4096;
        while (nc < c->out_n + msg.n) nc *= 2;
        uint8_t *p = malloc(nc);
        if (!p) { dw_free(&msg); return 0; }
        if (c->out) { memcpy(p, c->out, c->out_n); explicit_bzero(c->out, c->out_cap); free(c->out); }
        c->out = p;
        c->out_cap = nc;
    }
    memcpy(c->out + c->out_n, msg.p, msg.n);
    c->out_n += msg.n;
    dw_free(&msg);
    dbus_flush(c);
    return h->serial;
}

static int take(DConn *c, DMsg *m) {
    long sz = dbus_msg_size(c->in, c->in_n);
    if (sz < 0) { c->dead = 1; return -1; }
    if (sz == 0 || (size_t)sz > c->in_n) return 0;
    int r = dbus_msg_parse(c->in, (size_t)sz, m);
    size_t rest = c->in_n - (size_t)sz;
    memmove(c->in, c->in + sz, rest);
    explicit_bzero(c->in + rest, (size_t)sz);
    c->in_n = rest;
    if (r) { c->dead = 1; return -1; }       /* the bus already validates: something invalid is a serious error */
    return 1;
}

int dbus_next(DConn *c, DMsg *m) {
    memset(m, 0, sizeof *m);
    if (c->dead) return -1;
    for (;;) {
        int t = take(c, m);
        if (t) return t;
        if (c->in_cap - c->in_n < 65536) {
            if (c->in_cap > DBUS_MAX_MSG + 65536) { c->dead = 1; return -1; }
            size_t nc = c->in_cap ? c->in_cap * 2 : 65536;
            uint8_t *p = malloc(nc);
            if (!p) { c->dead = 1; return -1; }
            if (c->in) { memcpy(p, c->in, c->in_n); explicit_bzero(c->in, c->in_cap); free(c->in); }
            c->in = p;
            c->in_cap = nc;
        }
        ssize_t k = recv(c->fd, c->in + c->in_n, c->in_cap - c->in_n, MSG_DONTWAIT);
        if (k < 0) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN || errno == EWOULDBLOCK) return 0;
            c->dead = 1;
            return -1;
        }
        if (k == 0) { c->dead = 1; return -1; }
        c->in_n += (size_t)k;
    }
}

int dbus_wait_reply(DConn *c, uint32_t serial, DMsg *m, int timeout_ms) {
    double deadline = now_ms() + timeout_ms;
    for (;;) {
        dbus_flush(c);
        int r = dbus_next(c, m);
        if (r < 0) return -1;
        if (r == 1) {
            if ((m->type == DBUS_RETURN || m->type == DBUS_ERROR) && m->reply_serial == serial) return m->type == DBUS_RETURN ? 1 : 0;
            dbus_msg_free(m);
            continue;
        }
        if (wait_fd(c->fd, dbus_pending_out(c) ? POLLIN | POLLOUT : POLLIN, deadline)) return -1;
    }
}

uint32_t dbus_reply(DConn *c, const DMsg *call, const char *sig, const DBuf *body) {
    if (call->flags & DBUS_NO_REPLY) return 0;
    DHdr h = { .type = DBUS_RETURN, .reply_serial = call->serial, .dest = call->sender, .sig = sig };
    return dbus_send(c, &h, body);
}

uint32_t dbus_error(DConn *c, const DMsg *call, const char *name, const char *text) {
    if (call->flags & DBUS_NO_REPLY) return 0;
    DBuf b;
    dw_init(&b);
    dw_str(&b, text ? text : "");
    DHdr h = { .type = DBUS_ERROR, .reply_serial = call->serial, .dest = call->sender, .error = name, .sig = "s" };
    uint32_t s = dbus_send(c, &h, &b);
    dw_free(&b);
    return s;
}

uint32_t dbus_signal(DConn *c, const char *path, const char *iface, const char *member, const char *sig, const DBuf *body) {
    DHdr h = { .type = DBUS_SIGNAL, .path = path, .iface = iface, .member = member, .sig = sig };
    return dbus_send(c, &h, body);
}