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.

9.4 KB
Raw Blame
/* pulse.c — tagstruct and packets of the PulseAudio native protocol (see pulse.h).
 *
 * A "tagstruct" is a sequence of values, each one preceded by a byte saying its type
 * ('L' u32, 't' string, 'v' per-channel volume, 'P' property list...). Integers are
 * big endian. Each packet carries a 20-byte descriptor: length, channel (-1 = control),
 * 64-bit offset and flags. */
#include "pulse.h"

#include <stdlib.h>
#include <string.h>

enum {
    T_STRING = 't', T_STRING_NULL = 'N', T_U32 = 'L', T_U8 = 'B', T_U64 = 'R', T_S64 = 'r',
    T_SAMPLE_SPEC = 'a', T_ARBITRARY = 'x', T_TRUE = '1', T_FALSE = '0', T_TIMEVAL = 'T',
    T_USEC = 'U', T_CHANNEL_MAP = 'm', T_CVOLUME = 'v', T_PROPLIST = 'P', T_VOLUME = 'V',
    T_FORMAT_INFO = 'f',
};

static void put_be32(uint8_t *p, uint32_t v) { p[0] = (uint8_t)(v >> 24); p[1] = (uint8_t)(v >> 16); p[2] = (uint8_t)(v >> 8); p[3] = (uint8_t)v; }
static uint32_t get_be32(const uint8_t *p) { return (uint32_t)p[0] << 24 | (uint32_t)p[1] << 16 | (uint32_t)p[2] << 8 | p[3]; }

/* ---- writing ---- */

static uint8_t *grow(TsOut *t, size_t n) {
    if (t->err) return NULL;
    if (t->len + n > t->cap) {
        size_t cap = t->cap ? t->cap * 2 : 256;
        while (cap < t->len + n) cap *= 2;
        uint8_t *d = realloc(t->d, cap);
        if (!d) { t->err = 1; return NULL; }
        t->d = d;
        t->cap = cap;
    }
    uint8_t *p = t->d + t->len;
    t->len += n;
    return p;
}

void ts_init(TsOut *t) {
    memset(t, 0, sizeof *t);
    uint8_t *p = grow(t, PA_DESCRIPTOR_SIZE);
    if (p) memset(p, 0, PA_DESCRIPTOR_SIZE);
}

void ts_free(TsOut *t) { free(t->d); memset(t, 0, sizeof *t); }

void ts_u32(TsOut *t, uint32_t v) {
    uint8_t *p = grow(t, 5);
    if (p) { p[0] = T_U32; put_be32(p + 1, v); }
}

void ts_u8(TsOut *t, uint8_t v) {
    uint8_t *p = grow(t, 2);
    if (p) { p[0] = T_U8; p[1] = v; }
}

void ts_u64(TsOut *t, uint64_t v) {
    uint8_t *p = grow(t, 9);
    if (p) { p[0] = T_USEC; put_be32(p + 1, (uint32_t)(v >> 32)); put_be32(p + 5, (uint32_t)v); }
}

/* 'T': timeval (seconds and microseconds), requested by GET_PLAYBACK_LATENCY (lord-media). */
void ts_timeval(TsOut *t, uint32_t sec, uint32_t usec) {
    uint8_t *p = grow(t, 9);
    if (p) { p[0] = T_TIMEVAL; put_be32(p + 1, sec); put_be32(p + 5, usec); }
}

void ts_bool(TsOut *t, int v) {
    uint8_t *p = grow(t, 1);
    if (p) p[0] = v ? T_TRUE : T_FALSE;
}

void ts_str(TsOut *t, const char *s) {
    if (!s) { uint8_t *p = grow(t, 1); if (p) p[0] = T_STRING_NULL; return; }
    size_t n = strlen(s);
    uint8_t *p = grow(t, n + 2);
    if (p) { p[0] = T_STRING; memcpy(p + 1, s, n + 1); }
}

void ts_arb(TsOut *t, const void *data, uint32_t n) {
    uint8_t *p = grow(t, 5 + (size_t)n);
    if (p) { p[0] = T_ARBITRARY; put_be32(p + 1, n); if (n) memcpy(p + 5, data, n); }
}

void ts_ss(TsOut *t, uint8_t format, uint8_t channels, uint32_t rate) {
    uint8_t *p = grow(t, 7);
    if (p) { p[0] = T_SAMPLE_SPEC; p[1] = format; p[2] = channels; put_be32(p + 3, rate); }
}

void ts_cmap(TsOut *t, uint8_t n, const uint8_t *pos) {
    uint8_t *p = grow(t, 2 + (size_t)n);
    if (p) { p[0] = T_CHANNEL_MAP; p[1] = n; memcpy(p + 2, pos, n); }
}

void ts_cvol(TsOut *t, uint8_t n, const uint32_t *v) {
    uint8_t *p = grow(t, 2 + 4 * (size_t)n);
    if (!p) return;
    p[0] = T_CVOLUME;
    p[1] = n;
    for (uint8_t i = 0; i < n; i++) put_be32(p + 2 + 4 * i, v[i]);
}

void ts_proplist(TsOut *t, const char *const *kv, int pairs) {
    uint8_t *p = grow(t, 1);
    if (p) p[0] = T_PROPLIST;
    for (int i = 0; i < pairs; i++) {
        uint32_t n = (uint32_t)strlen(kv[2 * i + 1]) + 1;
        ts_str(t, kv[2 * i]);
        ts_u32(t, n);
        ts_arb(t, kv[2 * i + 1], n);
    }
    ts_str(t, NULL);
}

void ts_format_pcm(TsOut *t) {
    uint8_t *p = grow(t, 1);
    if (p) p[0] = T_FORMAT_INFO;
    ts_u8(t, 1);                        /* PA_ENCODING_PCM */
    ts_proplist(t, NULL, 0);
}

size_t ts_finish(TsOut *t) {
    if (t->err || t->len < PA_DESCRIPTOR_SIZE) return 0;
    put_be32(t->d, (uint32_t)(t->len - PA_DESCRIPTOR_SIZE));
    put_be32(t->d + 4, 0xffffffffu);
    memset(t->d + 8, 0, 12);
    return t->len;
}

uint8_t *ts_data_packet(uint32_t channel, const void *data, uint32_t n, size_t *total) {
    uint8_t *p = malloc(PA_DESCRIPTOR_SIZE + (size_t)n);
    if (!p) return NULL;
    put_be32(p, n);
    put_be32(p + 4, channel);
    memset(p + 8, 0, 12);
    memcpy(p + PA_DESCRIPTOR_SIZE, data, n);
    *total = PA_DESCRIPTOR_SIZE + (size_t)n;
    return p;
}

void pa_descriptor_read(const uint8_t *d, uint32_t *len, uint32_t *channel, uint64_t *offset, uint32_t *flags) {
    *len = get_be32(d);
    *channel = get_be32(d + 4);
    *offset = (uint64_t)get_be32(d + 8) << 32 | get_be32(d + 12);
    *flags = get_be32(d + 16);
}

/* ---- reading ---- */

void ts_in(TsIn *t, const uint8_t *d, size_t len) { t->d = d; t->len = len; t->pos = 0; t->err = 0; }
int ts_eof(const TsIn *t) { return t->pos >= t->len; }

static const uint8_t *take(TsIn *t, size_t n) {
    if (t->err || t->len - t->pos < n) { t->err = 1; return NULL; }
    const uint8_t *p = t->d + t->pos;
    t->pos += n;
    return p;
}

static int expect(TsIn *t, uint8_t tag) {
    const uint8_t *p = take(t, 1);
    if (!p) return 0;
    if (*p != tag) { t->err = 1; return 0; }
    return 1;
}

uint32_t ts_get_u32(TsIn *t) {
    if (!expect(t, T_U32)) return 0;
    const uint8_t *p = take(t, 4);
    return p ? get_be32(p) : 0;
}

uint8_t ts_get_u8(TsIn *t) {
    if (!expect(t, T_U8)) return 0;
    const uint8_t *p = take(t, 1);
    return p ? *p : 0;
}

uint64_t ts_get_u64(TsIn *t) {
    const uint8_t *tag = take(t, 1);
    if (!tag || (*tag != T_USEC && *tag != T_U64 && *tag != T_S64)) { t->err = 1; return 0; }
    const uint8_t *p = take(t, 8);
    return p ? (uint64_t)get_be32(p) << 32 | get_be32(p + 4) : 0;
}

int ts_get_bool(TsIn *t) {
    const uint8_t *p = take(t, 1);
    if (!p) return 0;
    if (*p == T_TRUE) return 1;
    if (*p != T_FALSE) t->err = 1;
    return 0;
}

const char *ts_get_str(TsIn *t) {
    const uint8_t *p = take(t, 1);
    if (!p) return NULL;
    if (*p == T_STRING_NULL) return NULL;
    if (*p != T_STRING) { t->err = 1; return NULL; }
    const uint8_t *s = t->d + t->pos, *z = memchr(s, 0, t->len - t->pos);
    if (!z) { t->err = 1; return NULL; }
    t->pos += (size_t)(z - s) + 1;
    return (const char *)s;
}

const uint8_t *ts_get_arb(TsIn *t, uint32_t *n) {
    *n = 0;
    if (!expect(t, T_ARBITRARY)) return NULL;
    const uint8_t *p = take(t, 4);
    if (!p) return NULL;
    uint32_t len = get_be32(p);
    const uint8_t *d = take(t, len);
    if (d) *n = len;
    return d;
}

void ts_get_ss(TsIn *t, uint8_t *format, uint8_t *channels, uint32_t *rate) {
    *format = *channels = 0;
    *rate = 0;
    if (!expect(t, T_SAMPLE_SPEC)) return;
    const uint8_t *p = take(t, 6);
    if (!p) return;
    *format = p[0];
    *channels = p[1];
    *rate = get_be32(p + 2);
}

uint8_t ts_get_cmap(TsIn *t, uint8_t *pos) {
    if (!expect(t, T_CHANNEL_MAP)) return 0;
    const uint8_t *p = take(t, 1);
    if (!p || *p > PA_CHANNELS_MAX) { t->err = 1; return 0; }
    uint8_t n = *p;
    const uint8_t *d = take(t, n);
    if (!d) return 0;
    memcpy(pos, d, n);
    return n;
}

uint8_t ts_get_cvol(TsIn *t, uint32_t *v) {
    if (!expect(t, T_CVOLUME)) return 0;
    const uint8_t *p = take(t, 1);
    if (!p || *p > PA_CHANNELS_MAX) { t->err = 1; return 0; }
    uint8_t n = *p;
    const uint8_t *d = take(t, 4 * (size_t)n);
    if (!d) return 0;
    for (uint8_t i = 0; i < n; i++) v[i] = get_be32(d + 4 * i);
    return n;
}

uint32_t ts_get_vol(TsIn *t) {
    if (!expect(t, T_VOLUME)) return 0;
    const uint8_t *p = take(t, 4);
    return p ? get_be32(p) : 0;
}

void ts_get_proplist(TsIn *t, TsPropFn fn, void *ud) {
    if (!expect(t, T_PROPLIST)) return;
    for (int guard = 0; guard < 4096 && !t->err; guard++) {
        const char *key = ts_get_str(t);
        if (!key || t->err) return;                 /* 'N' ends the list */
        uint32_t n = ts_get_u32(t), got = 0;
        const uint8_t *val = ts_get_arb(t, &got);
        if (t->err || got != n) { t->err = 1; return; }
        if (fn) {
            /* strings come with their 0; if not, it's copied to terminate it */
            char tmp[512];
            if (got && val[got - 1] == 0) fn(ud, key, (const char *)val, got - 1);
            else if (got < sizeof tmp) { memcpy(tmp, val, got); tmp[got] = 0; fn(ud, key, tmp, got); }
        }
    }
    t->err = 1;
}

void ts_skip_format(TsIn *t) {
    if (!expect(t, T_FORMAT_INFO)) return;
    ts_get_u8(t);
    ts_get_proplist(t, NULL, NULL);
}

void ts_skip(TsIn *t) {
    if (t->err || ts_eof(t)) { t->err = 1; return; }
    uint8_t tag = t->d[t->pos];
    uint32_t n;
    uint8_t buf[PA_CHANNELS_MAX];
    uint32_t vol[PA_CHANNELS_MAX];
    switch (tag) {
    case T_STRING: case T_STRING_NULL: ts_get_str(t); break;
    case T_U32: ts_get_u32(t); break;
    case T_U8: ts_get_u8(t); break;
    case T_U64: case T_S64: case T_USEC: ts_get_u64(t); break;
    case T_TRUE: case T_FALSE: ts_get_bool(t); break;
    case T_SAMPLE_SPEC: { uint8_t f, c; uint32_t r; ts_get_ss(t, &f, &c, &r); break; }
    case T_ARBITRARY: ts_get_arb(t, &n); break;
    case T_TIMEVAL: take(t, 9); break;
    case T_CHANNEL_MAP: ts_get_cmap(t, buf); break;
    case T_CVOLUME: ts_get_cvol(t, vol); break;
    case T_PROPLIST: ts_get_proplist(t, NULL, NULL); break;
    case T_VOLUME: ts_get_vol(t); break;
    case T_FORMAT_INFO: ts_skip_format(t); break;
    default: t->err = 1;
    }
}