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.

10.4 KB
Raw Blame
/* ipp.c — see ipp.h. */
#include "ipp.h"

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

#define IPP_MAX_ATTRS  20000
#define IPP_MAX_VALUES 60000
#define IPP_MAX_DEPTH  8

/* ---- encoding ---- */

static void put(IppBuf *b, const void *d, size_t n) {
    if (b->err) return;
    if (b->n + n > b->cap) {
        size_t cap = b->cap ? b->cap * 2 : 512;
        while (cap < b->n + n) cap *= 2;
        if (cap > (64u << 20)) { b->err = 1; return; }
        uint8_t *p = realloc(b->p, cap);
        if (!p) { b->err = 1; return; }
        b->p = p;
        b->cap = cap;
    }
    memcpy(b->p + b->n, d, n);
    b->n += n;
}
static void put8(IppBuf *b, uint8_t v) { put(b, &v, 1); }
static void put16(IppBuf *b, uint16_t v) { uint8_t x[2] = { (uint8_t)(v >> 8), (uint8_t)v }; put(b, x, 2); }
static void put32(IppBuf *b, uint32_t v) { uint8_t x[4] = { (uint8_t)(v >> 24), (uint8_t)(v >> 16), (uint8_t)(v >> 8), (uint8_t)v }; put(b, x, 4); }

void ipp_init(IppBuf *b, uint16_t op, uint32_t id) {
    memset(b, 0, sizeof *b);
    put8(b, 1);
    put8(b, 1);
    put16(b, op);
    put32(b, id);
}
void ipp_free(IppBuf *b) { free(b->p); memset(b, 0, sizeof *b); }
void ipp_group(IppBuf *b, uint8_t tag) { put8(b, tag); }

static void put_name(IppBuf *b, uint8_t tag, const char *name) {
    size_t n = name ? strlen(name) : 0;
    if (n > 0x7fff) { b->err = 1; return; }
    put8(b, tag);
    put16(b, (uint16_t)n);
    if (n) put(b, name, n);
}

void ipp_add_str(IppBuf *b, uint8_t tag, const char *name, const char *value) {
    size_t n = value ? strlen(value) : 0;
    if (n > 0x7fff) { b->err = 1; return; }
    put_name(b, tag, name);
    put16(b, (uint16_t)n);
    if (n) put(b, value, n);
}

void ipp_add_int(IppBuf *b, uint8_t tag, const char *name, int32_t v) {
    put_name(b, tag, name);
    put16(b, 4);
    put32(b, (uint32_t)v);
}

void ipp_add_bool(IppBuf *b, const char *name, int v) {
    put_name(b, IPP_T_BOOLEAN, name);
    put16(b, 1);
    put8(b, v ? 1 : 0);
}

void ipp_add_range(IppBuf *b, const char *name, int32_t lo, int32_t hi) {
    put_name(b, IPP_T_RANGE, name);
    put16(b, 8);
    put32(b, (uint32_t)lo);
    put32(b, (uint32_t)hi);
}

void ipp_end(IppBuf *b) { put8(b, IPP_G_END); }

void ipp_std(IppBuf *b, const char *printer_uri, const char *user) {
    ipp_group(b, IPP_G_OPERATION);
    ipp_add_str(b, IPP_T_CHARSET, "attributes-charset", "utf-8");
    ipp_add_str(b, IPP_T_LANGUAGE, "attributes-natural-language", "en");
    if (printer_uri) ipp_add_str(b, IPP_T_URI, "printer-uri", printer_uri);
    if (user) ipp_add_str(b, IPP_T_NAME, "requesting-user-name", user);
}

/* ---- decoding ---- */

typedef struct { const uint8_t *p; size_t n, i; int attrs, vals; } Rd;

static int rd16(Rd *r, uint16_t *v) { if (r->i + 2 > r->n) return -1; *v = (uint16_t)(r->p[r->i] << 8 | r->p[r->i + 1]); r->i += 2; return 0; }
static int32_t be32(const uint8_t *p) { return (int32_t)((uint32_t)p[0] << 24 | (uint32_t)p[1] << 16 | (uint32_t)p[2] << 8 | p[3]); }

static int is_text(uint8_t t) { return t >= 0x40 && t <= 0x5f; }

static void vals_free(IppVal *v);
static void attrs_free(IppAttr *a) {
    while (a) {
        IppAttr *n = a->next;
        free(a->name);
        vals_free(a->vals);
        free(a);
        a = n;
    }
}
static void vals_free(IppVal *v) {
    while (v) {
        IppVal *n = v->next;
        free(v->str);
        attrs_free(v->col);
        free(v);
        v = n;
    }
}

static char *dupn(const uint8_t *p, size_t n) {
    char *s = malloc(n + 1);
    if (!s) return NULL;
    memcpy(s, p, n);
    s[n] = 0;
    /* a 0 in the middle would cut the text: it's replaced */
    for (size_t i = 0; i < n; i++) if (!s[i]) s[i] = '?';
    return s;
}

static int read_value(Rd *r, uint8_t tag, IppVal *v, int depth);

/* Reads members of a collection up to endCollection. */
static int read_collection(Rd *r, IppVal *v, int depth) {
    if (depth > IPP_MAX_DEPTH) return -1;
    IppAttr **tail = &v->col, *cur = NULL;
    for (;;) {
        if (r->i >= r->n) return -1;
        uint8_t tag = r->p[r->i++];
        uint16_t nl, vl;
        if (rd16(r, &nl) || r->i + nl > r->n) return -1;
        r->i += nl;                                  /* in a collection the name is empty */
        if (rd16(r, &vl) || r->i + vl > r->n) return -1;
        if (tag == IPP_T_ENDCOL) { r->i += vl; return 0; }
        if (tag == IPP_T_MEMBERNAME) {
            if (++r->attrs > IPP_MAX_ATTRS) return -1;
            cur = calloc(1, sizeof *cur);
            if (!cur) return -1;
            cur->name = dupn(r->p + r->i, vl);
            r->i += vl;
            *tail = cur;
            tail = &cur->next;
            if (!cur->name) return -1;
            continue;
        }
        if (!cur) return -1;                         /* a value without a member name */
        r->i -= 2;                                   /* read_value reads the length again */
        IppVal *nv = calloc(1, sizeof *nv);
        if (!nv) return -1;
        IppVal **vt = &cur->vals;
        while (*vt) vt = &(*vt)->next;
        *vt = nv;
        cur->nvals++;
        if (read_value(r, tag, nv, depth + 1)) return -1;
    }
}

static int read_value(Rd *r, uint8_t tag, IppVal *v, int depth) {
    uint16_t vl;
    if (++r->vals > IPP_MAX_VALUES) return -1;
    if (rd16(r, &vl) || r->i + vl > r->n) return -1;
    const uint8_t *d = r->p + r->i;
    r->i += vl;
    v->tag = tag;
    v->data = d;
    v->len = vl;
    switch (tag) {
    case IPP_T_INTEGER: case IPP_T_ENUM:
        if (vl != 4) return -1;
        v->i = be32(d);
        break;
    case IPP_T_BOOLEAN:
        if (vl != 1) return -1;
        v->i = d[0] != 0;
        break;
    case IPP_T_RANGE:
        if (vl != 8) return -1;
        v->i = be32(d); v->i2 = be32(d + 4);
        break;
    case IPP_T_RESOLUTION:
        if (vl != 9) return -1;
        v->i = be32(d); v->i2 = be32(d + 4);
        break;
    case IPP_T_BEGCOL:
        return read_collection(r, v, depth);
    case IPP_T_TEXTLANG: case IPP_T_NAMELANG: {
        /* language (length + text) and the text (length + text) */
        if (vl < 4) return -1;
        size_t ll = (size_t)(d[0] << 8 | d[1]);
        if (2 + ll + 2 > vl) return -1;
        size_t tl = (size_t)(d[2 + ll] << 8 | d[3 + ll]);
        if (4 + ll + tl != vl) return -1;
        v->str = dupn(d + 4 + ll, tl);
        if (!v->str) return -1;
        break;
    }
    default:
        if (is_text(tag) || tag == IPP_T_STRING) { v->str = dupn(d, vl); if (!v->str) return -1; }
        break;
    }
    return 0;
}

int ipp_parse(const uint8_t *data, size_t len, IppMsg *m) {
    memset(m, 0, sizeof *m);
    if (!data || len < 9) return -1;
    m->major = data[0];
    m->minor = data[1];
    m->code = (uint16_t)(data[2] << 8 | data[3]);
    m->request_id = (uint32_t)be32(data + 4);
    if (m->major < 1 || m->major > 2) return -1;
    Rd r = { data, len, 8, 0, 0 };
    IppAttr **tail = &m->attrs, *cur = NULL;
    uint8_t group = 0;
    int gseq = 0;
    for (;;) {
        if (r.i >= r.n) goto bad;
        uint8_t tag = data[r.i++];
        if (tag == IPP_G_END) break;
        if (tag < 0x10) {                            /* group tag */
            if (tag == 0) goto bad;
            group = tag;
            gseq++;
            cur = NULL;
            continue;
        }
        if (!group) goto bad;
        if (tag == 0x7f) goto bad;                   /* extended tags: not used */
        uint16_t nl;
        if (rd16(&r, &nl) || r.i + nl > r.n) goto bad;
        if (nl) {
            if (++r.attrs > IPP_MAX_ATTRS) goto bad;
            cur = calloc(1, sizeof *cur);
            if (!cur) goto bad;
            *tail = cur;
            tail = &cur->next;
            cur->group = group;
            cur->gseq = gseq;
            cur->name = dupn(data + r.i, nl);
            if (!cur->name) goto bad;
            r.i += nl;
        } else if (!cur) goto bad;                   /* extra value without an attribute */
        IppVal *v = calloc(1, sizeof *v);
        if (!v) goto bad;
        IppVal **vt = &cur->vals;
        while (*vt) vt = &(*vt)->next;
        *vt = v;
        cur->nvals++;
        if (read_value(&r, tag, v, 0)) goto bad;
    }
    m->used = r.i;
    return 0;
bad:
    ipp_msg_free(m);
    return -1;
}

void ipp_msg_free(IppMsg *m) {
    attrs_free(m->attrs);
    m->attrs = NULL;
}

const IppAttr *ipp_find(const IppMsg *m, const IppAttr *from, uint8_t group, const char *name) {
    for (const IppAttr *a = from ? from->next : m->attrs; a; a = a->next)
        if ((!group || a->group == group) && !strcmp(a->name, name)) return a;
    return NULL;
}

const IppAttr *ipp_find_in(const IppAttr *start, const char *name) {
    /* forward within the same group (the attributes are in order) */
    for (const IppAttr *a = start; a && a->gseq == start->gseq; a = a->next)
        if (!strcmp(a->name, name)) return a;
    return NULL;
}

const char *ipp_str(const IppAttr *a) { return a && a->vals ? a->vals->str : NULL; }
int32_t ipp_int(const IppAttr *a, int32_t def) {
    if (!a || !a->vals) return def;
    uint8_t t = a->vals->tag;
    return t == IPP_T_INTEGER || t == IPP_T_ENUM || t == IPP_T_BOOLEAN ? a->vals->i : def;
}

const char *ipp_tag_name(uint8_t tag) {
    switch (tag) {
    case IPP_T_INTEGER: return "integer";
    case IPP_T_BOOLEAN: return "boolean";
    case IPP_T_ENUM: return "enum";
    case IPP_T_TEXT: return "text";
    case IPP_T_NAME: return "name";
    case IPP_T_KEYWORD: return "keyword";
    case IPP_T_URI: return "uri";
    case IPP_T_RANGE: return "rangeOfInteger";
    case IPP_T_BEGCOL: return "collection";
    default: return "other";
    }
}

const char *ipp_status_name(uint16_t s) {
    switch (s) {
    case 0x0000: return "successful-ok";
    case 0x0001: return "successful-ok-ignored-or-substituted-attributes";
    case 0x0002: return "successful-ok-conflicting-attributes";
    case 0x0400: return "client-error-bad-request";
    case 0x0401: return "client-error-forbidden";
    case 0x0402: return "client-error-not-authenticated";
    case 0x0403: return "client-error-not-authorized";
    case 0x0404: return "client-error-not-possible";
    case 0x0406: return "client-error-not-found";
    case 0x040a: return "client-error-document-format-not-supported";
    case 0x040b: return "client-error-attributes-or-values-not-supported";
    case 0x0500: return "server-error-internal-error";
    case 0x0501: return "server-error-operation-not-supported";
    case 0x0502: return "server-error-service-unavailable";
    case 0x0507: return "server-error-busy";
    default: return s < 0x100 ? "successful-ok" : s < 0x500 ? "client-error" : "server-error";
    }
}