GCOV - Varnish Cache


/*-
 * Copyright (c) 2016 Varnish Software AS
 * All rights reserved.
 *
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
 * Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.com>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 */

#include "config.h"

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

#include "vdef.h"
#include "vas.h"
#include "miniobj.h"

#include "hpack/vhp.h"

#include "vhp_hufdec.h"

struct vhd_ctx {
        struct vhd_decode *d;
        struct vht_table *tbl;
        const uint8_t *in;
        const uint8_t *in_e;
        char *out;
        char *out_e;
};

typedef enum vhd_ret_e vhd_state_f(struct vhd_ctx *ctx, unsigned first);

/* Function flags */
#define VHD_INCREMENTAL (1U << 0)

/* Functions */
enum vhd_func_e {
#define VHD_FSM_FUNC(NAME, func)                \
        VHD_F_##NAME,
#include "tbl/vhd_fsm_funcs.h"
        VHD_F__MAX,
};
#define VHD_FSM_FUNC(NAME, func)                \
        static vhd_state_f func;
#include "tbl/vhd_fsm_funcs.h"

/* States */
enum vhd_state_e {
        VHD_S__MIN = -1,
#define VHD_FSM(STATE, FUNC, arg1, arg2)        \
        VHD_S_##STATE,
#include "tbl/vhd_fsm.h"
        VHD_S__MAX,
};
static const struct vhd_state {
        const char              *name;
        enum vhd_func_e         func;
        unsigned                arg1;
        unsigned                arg2;
} vhd_states[VHD_S__MAX] = {
#define VHD_FSM(STATE, FUNC, arg1, arg2)        \
        [VHD_S_##STATE] = { #STATE, VHD_F_##FUNC, arg1, arg2 },
#include "tbl/vhd_fsm.h"
};

/* Utility functions */
static void
vhd_set_state(struct vhd_decode *d, enum vhd_state_e state)
{
        AN(d);
        assert(state > VHD_S__MIN && state < VHD_S__MAX);
        d->state = state;
        d->first = 1;
}

static void
vhd_next_state(struct vhd_decode *d)
{
        AN(d);
        assert(d->state + 1 < VHD_S__MAX);
        vhd_set_state(d, d->state + 1);
}

/* State functions */
static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_skip(struct vhd_ctx *ctx, unsigned first)
{
        AN(ctx);
        AN(first);
        vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_goto(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;

        AN(ctx);
        AN(first);
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];
        assert(s->arg1 < VHD_S__MAX);
        vhd_set_state(ctx->d, s->arg1);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_idle(struct vhd_ctx *ctx, unsigned first)
{
        uint8_t c;

        AN(ctx);
        (void)first;

        while (ctx->in < ctx->in_e) {
                c = *ctx->in;
                if ((c & 0x80) == 0x80)
                        vhd_set_state(ctx->d, VHD_S_HP61_START);
                else if ((c & 0xc0) == 0x40)
                        vhd_set_state(ctx->d, VHD_S_HP621_START);
                else if ((c & 0xf0) == 0x00)
                        vhd_set_state(ctx->d, VHD_S_HP622_START);
                else if ((c & 0xf0) == 0x10)
                        vhd_set_state(ctx->d, VHD_S_HP623_START);
                else if ((c & 0xe0) == 0x20)
                        vhd_set_state(ctx->d, VHD_S_HP63_START);
                else
                        return (VHD_ERR_ARG);
                return (VHD_AGAIN);
        }

        return (VHD_OK);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_integer(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;
        struct vhd_int *i;
        uint8_t c;
        unsigned mask;

        assert(UINT_MAX >= UINT32_MAX);

        AN(ctx);
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];
        i = ctx->d->integer;

        if (first) {
                INIT_OBJ(i, VHD_INT_MAGIC);
                i->pfx = s->arg1;
                assert(i->pfx >= 4 && i->pfx <= 7);
        }
        CHECK_OBJ_NOTNULL(i, VHD_INT_MAGIC);

        while (ctx->in < ctx->in_e) {
                c = *ctx->in;
                ctx->in++;
                if (i->pfx) {
                        mask = (1U << i->pfx) - 1;
                        i->pfx = 0;
                        i->v = c & mask;
                        if (i->v < mask) {
                                vhd_next_state(ctx->d);
                                return (VHD_AGAIN);
                        }
                } else {
                        if ((i->m == 28 && (c & 0x78)) || i->m > 28)
                                return (VHD_ERR_INT);
                        i->v += (c & 0x7f) * ((uint32_t)1 << i->m);
                        i->m += 7;
                        if (!(c & 0x80)) {
                                vhd_next_state(ctx->d);
                                return (VHD_AGAIN);
                        }
                }
        }
        return (VHD_MORE);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_set_max(struct vhd_ctx *ctx, unsigned first)
{
        AN(ctx);
        AN(first);
        CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
        if (ctx->tbl == NULL)
                return (VHD_ERR_UPD);
        if (VHT_SetMaxTableSize(ctx->tbl, ctx->d->integer->v))
                return (VHD_ERR_UPD);
        vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_set_idx(struct vhd_ctx *ctx, unsigned first)
{
        AN(ctx);
        AN(first);
        CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
        ctx->d->index = ctx->d->integer->v;
        vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_lookup(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;
        struct vhd_lookup *lu;
        const char *p;
        size_t l;

        AN(ctx);
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];
        lu = ctx->d->lookup;

        if (first)
                INIT_OBJ(lu, VHD_LOOKUP_MAGIC);
        CHECK_OBJ_NOTNULL(lu, VHD_LOOKUP_MAGIC);

        switch (s->arg1) {
        case VHD_NAME:
        case VHD_NAME_SEC:
                p = VHT_LookupName(ctx->tbl, ctx->d->index, &l);
                break;
        case VHD_VALUE:
        case VHD_VALUE_SEC:
                p = VHT_LookupValue(ctx->tbl, ctx->d->index, &l);
                break;
        default:
                WRONG("vhd_lookup wrong arg1");
                break;
        }
        if (first && p == NULL)
                return (VHD_ERR_IDX);
        AN(p);
        assert(l <= UINT_MAX);
        if (first)
                lu->l = l;

        assert(lu->l <= l);
        p += l - lu->l;
        l = vmin_t(size_t, lu->l, ctx->out_e - ctx->out);
        memcpy(ctx->out, p, l);
        ctx->out += l;
        lu->l -= l;

        if (lu->l == 0) {
                vhd_next_state(ctx->d);
                return (s->arg1);
        }
        assert(ctx->out == ctx->out_e);
        return (VHD_BUF);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_new(struct vhd_ctx *ctx, unsigned first)
{
        AN(ctx);
        AN(first);
        if (ctx->tbl != NULL)
                VHT_NewEntry(ctx->tbl);
        vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_new_idx(struct vhd_ctx *ctx, unsigned first)
{
        AN(ctx);
        AN(first);
        if (ctx->tbl != NULL) {
                if (VHT_NewEntry_Indexed(ctx->tbl, ctx->d->index))
                        return (VHD_ERR_IDX);
        }
        vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_branch_zidx(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;

        AN(ctx);
        (void)first;
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];
        assert(s->arg1 < VHD_S__MAX);

        if (ctx->d->index == 0)
                vhd_set_state(ctx->d, s->arg1);
        else
                vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_branch_bit0(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;

        AN(ctx);
        (void)first;
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];
        assert(s->arg1 < VHD_S__MAX);

        if (ctx->in == ctx->in_e)
                return (VHD_MORE);

        if (*ctx->in & 0x80)
                vhd_set_state(ctx->d, s->arg1);
        else
                vhd_next_state(ctx->d);
        return (VHD_AGAIN);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_raw(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;
        struct vhd_raw *raw;
        size_t l2;

        AN(ctx);
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];

        raw = ctx->d->raw;
        if (first) {
                CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
                l2 = ctx->d->integer->v;
                INIT_OBJ(raw, VHD_RAW_MAGIC);
                raw->l = l2;
        }
        CHECK_OBJ_NOTNULL(raw, VHD_RAW_MAGIC);

        while (raw->l > 0) {
                l2 = raw->l;
                if (l2 > (ctx->in_e - ctx->in))
                        l2 = ctx->in_e - ctx->in;
                if (l2 == 0)
                        return (VHD_MORE);
                if (l2 > (ctx->out_e - ctx->out))
                        l2 = ctx->out_e - ctx->out;
                if (l2 == 0)
                        return (VHD_BUF);
                memcpy(ctx->out, ctx->in, l2);
                ctx->in += l2;
                if (ctx->tbl != NULL && (s->arg2 & VHD_INCREMENTAL)) {
                        switch (s->arg1) {
                        case VHD_NAME:
                                VHT_AppendName(ctx->tbl, ctx->out, l2);
                                break;
                        case VHD_VALUE:
                                VHT_AppendValue(ctx->tbl, ctx->out, l2);
                                break;
                        default:
                                WRONG("vhd_raw wrong arg1");
                                break;
                        }
                }
                ctx->out += l2;
                raw->l -= l2;
        }
        vhd_next_state(ctx->d);
        return (s->arg1);
}

static enum vhd_ret_e v_matchproto_(vhd_state_f)
vhd_huffman(struct vhd_ctx *ctx, unsigned first)
{
        const struct vhd_state *s;
        struct vhd_huffman *huf;
        enum vhd_ret_e r;
        unsigned u, l;

        AN(ctx);
        assert(ctx->d->state < VHD_S__MAX);
        s = &vhd_states[ctx->d->state];

        huf = ctx->d->huffman;
        if (first) {
                CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
                l = ctx->d->integer->v;
                INIT_OBJ(huf, VHD_HUFFMAN_MAGIC);
                huf->len = l;
        }
        CHECK_OBJ_NOTNULL(huf, VHD_HUFFMAN_MAGIC);

        r = VHD_OK;
        l = 0;
        while (1) {
                assert(huf->pos < HUFDEC_LEN);
                assert(hufdec[huf->pos].mask > 0);
                assert(hufdec[huf->pos].mask <= 8);

                if (huf->len > 0 && huf->blen < hufdec[huf->pos].mask) {
                        /* Refill from input */
                        if (ctx->in == ctx->in_e) {
                                r = VHD_MORE;
                                break;
                        }
                        huf->bits = (huf->bits << 8) | *ctx->in;
                        huf->blen += 8;
                        huf->len--;
                        ctx->in++;
                }

                if (huf->len == 0 && huf->pos == 0 && huf->blen <= 7 &&
                    huf->bits == (1U << huf->blen) - 1U) {
                        /* End of stream */
                        r = s->arg1;
                        vhd_next_state(ctx->d);
                        break;
                }

                if (ctx->out + l == ctx->out_e) {
                        r = VHD_BUF;
                        break;
                }

                if (huf->blen >= hufdec[huf->pos].mask)
                        u = huf->bits >> (huf->blen - hufdec[huf->pos].mask);
                else
                        u = huf->bits << (hufdec[huf->pos].mask - huf->blen);
                huf->pos += u;
                assert(huf->pos < HUFDEC_LEN);

                if (hufdec[huf->pos].len == 0 ||
                    hufdec[huf->pos].len > huf->blen) {
                        /* Invalid or incomplete code */
                        r = VHD_ERR_HUF;
                        break;
                }

                huf->blen -= hufdec[huf->pos].len;
                huf->bits &= (1U << huf->blen) - 1U;

                if (hufdec[huf->pos].jump) {
                        huf->pos += hufdec[huf->pos].jump;
                        assert(huf->pos < HUFDEC_LEN);
                } else {
                        ctx->out[l++] = hufdec[huf->pos].chr;
                        huf->pos = 0;
                }
        }

        if (l > 0 && ctx->tbl != NULL && (s->arg2 & VHD_INCREMENTAL)) {
                switch (s->arg1) {
                case VHD_NAME:
                        VHT_AppendName(ctx->tbl, ctx->out, l);
                        break;
                case VHD_VALUE:
                        VHT_AppendValue(ctx->tbl, ctx->out, l);
                        break;
                default:
                        WRONG("vhd_raw wrong arg1");
                        break;
                }
        }
        ctx->out += l;

        assert(r != VHD_OK);
        return (r);
}

/* Public interface */

const char *
VHD_Error(enum vhd_ret_e r)
{
        switch (r) {
#define VHD_RET(NAME, VAL, DESC)                        \
        case VHD_##NAME:                                \
                return ("VHD_" #NAME " (" DESC ")");
#include "tbl/vhd_return.h"
        default:
                return ("VHD_UNKNOWN");
        }
}

enum vhd_ret_e
VHD_Decode(struct vhd_decode *d, struct vht_table *tbl,
    const uint8_t *in, size_t inlen, size_t *p_inused,
    char *out, size_t outlen, size_t *p_outused)
{
        const struct vhd_state *s;
        struct vhd_ctx ctx[1];
        enum vhd_ret_e ret;
        unsigned first;

        CHECK_OBJ_NOTNULL(d, VHD_DECODE_MAGIC);
        CHECK_OBJ_ORNULL(tbl, VHT_TABLE_MAGIC);
        AN(in);
        AN(p_inused);
        AN(out);
        AN(p_outused);

        if (d->error < 0)
                return (d->error);

        assert(*p_inused <= inlen);
        assert(*p_outused <= outlen);

        ctx->d = d;
        ctx->tbl = tbl;
        ctx->in = in + *p_inused;
        ctx->in_e = in + inlen;
        ctx->out = out + *p_outused;
        ctx->out_e = out + outlen;

        do {
                first = d->first;
                d->first = 0;
                assert(d->state < VHD_S__MAX);
                s = &vhd_states[d->state];
                switch (s->func) {
#define VHD_FSM_FUNC(NAME, func)                \
                case VHD_F_##NAME:              \
                        ret = func(ctx, first); \
                        break;
#include "tbl/vhd_fsm_funcs.h"
                default:
                        WRONG("Undefined vhd function");
                        break;
                }
        } while (ret == VHD_AGAIN);

        if (ret < 0)
                d->error = ret;

        assert(in + *p_inused <= ctx->in);
        *p_inused += ctx->in - (in + *p_inused);
        assert(out + *p_outused <= ctx->out);
        *p_outused += ctx->out - (out + *p_outused);

        return (ret);
}

void
VHD_Init(struct vhd_decode *d)
{

        AN(d);
        assert(VHD_S__MAX <= UINT16_MAX);
        assert(HUFDEC_LEN <= UINT16_MAX);
        INIT_OBJ(d, VHD_DECODE_MAGIC);
        d->state = VHD_S_IDLE;
        d->first = 1;
}

/* Test driver */

#ifdef DECODE_TEST_DRIVER

#include <ctype.h>
#include <stdarg.h>

static int verbose = 0;

static size_t
hexbuf(uint8_t *buf, size_t buflen, const char *h)
{
        size_t l;
        uint8_t u;

        AN(h);
        AN(buf);

        l = 0;
        for (; *h != '\0'; h++) {
                if (l == buflen * 2)
                        WRONG("Too small buffer");
                if (isspace(*h))
                        continue;
                if (*h >= '0' && *h <= '9')
                        u = *h - '0';
                else if (*h >= 'a' && *h <= 'f')
                        u = 0xa + *h - 'a';
                else if (*h >= 'A' && *h <= 'F')
                        u = 0xa + *h - 'A';
                else
                        WRONG("Bad input character");
                assert(u <= 0xf);
                if (l % 2 == 0) {
                        u <<= 4;
                        buf[l / 2] = u;
                } else {
                        buf[l / 2] |= u;
                }
                l++;
        }
        AZ(l % 2);
        return (l / 2);
}

static int
match(const char *b, size_t l, ...)
{
        va_list ap;
        const char *e;
        const char *m;
        int r = 0;

        va_start(ap, l);
        e = b + l;
        while (1) {
                m = va_arg(ap, const char *);
                if (m == NULL)
                        break;
                l = strlen(m);
                if (e - b <= l || b[l] != '\0' || strncmp(b, m, l)) {
                        printf("%.*s != %s\n", (int)(e - b), b, m);
                        r = -1;
                        break;
                } else if (verbose) {
                        printf("%s == %s\n", b, m);
                }
                b += l + 1;
        }
        va_end(ap);
        return (r);
}

#define M_1IN (1U << 0)
#define M_1OUT (1U << 1)

static enum vhd_ret_e
decode(struct vhd_decode *d, struct vht_table *tbl, uint8_t *in, size_t in_l,
    char *out, size_t out_l, unsigned m)
{
        size_t in_u, out_u;
        enum vhd_ret_e r;

        CHECK_OBJ_NOTNULL(d, VHD_DECODE_MAGIC);
        AN(in);
        AN(out);

        in_u = 0;
        out_u = 0;

        while (1) {
                r = VHD_Decode(d, tbl, in,
                    (m & M_1IN ? (in_l > in_u ? in_u + 1 : in_u) : in_l),
                    &in_u,
                    out,
                    (m & M_1OUT ? (out_l > out_u ? out_u + 1 : out_u) : out_l),
                    &out_u);
                assert(in_u <= in_l);
                assert(out_u <= out_l);
                if (r < VHD_OK)
                        return (r);

                switch (r) {
                case VHD_OK:
                        return (r);

                case VHD_MORE:
                        if (in_u == in_l)
                                return (r);
                        break;

                case VHD_BUF:
                        if (out_u == out_l)
                                return (r);
                        break;

                case VHD_NAME:
                case VHD_NAME_SEC:
                        assert(out_l - out_u > 0);
                        out[out_u++] = '\0';
                        if (verbose)
                                printf("Name%s: '%s'\n",
                                    (r == VHD_NAME_SEC ? " (sec)" : ""),
                                    out);
                        out += out_u;
                        out_l -= out_u;
                        out_u = 0;
                        break;

                case VHD_VALUE:
                case VHD_VALUE_SEC:
                        assert(out_l - out_u > 0);
                        out[out_u++] = '\0';
                        if (verbose)
                                printf("Value%s: '%s'\n",
                                    (r == VHD_VALUE_SEC ? " (sec)" : ""),
                                    out);
                        out += out_u;
                        out_l -= out_u;
                        out_u = 0;
                        break;

                default:
                        WRONG("Wrong return code");
                        break;
                }
        }

        NEEDLESS(return (VHD_OK));
}

#define CHECK_RET(r, e)                                 \
        do {                                            \
                if (verbose || r != e) {                \
                        printf("%s %s %s\n",            \
                            VHD_Error(r),               \
                            (r == e ? "==" : "!="),     \
                            VHD_Error(e));              \
                }                                       \
                assert(r == e);                         \
        } while (0)

#define CHECK_INT(d, u)                                                 \
        do {                                                            \
                CHECK_OBJ_NOTNULL(d->integer, VHD_INT_MAGIC);           \
                if (verbose || d->integer->v != u) {                    \
                        printf("%u %s %u\n", d->integer->v,             \
                            (d->integer->v == u ? "==" : "!="),         \
                            u);                                         \
                }                                                       \
                assert(d->integer->v == u);                             \
        } while (0)

static void
test_integer(unsigned mode)
{
        struct vhd_decode d[1];
        uint8_t in[128];
        size_t in_l;
        char out[128];
        enum vhd_ret_e r;

        /* Test single byte decoding */
        VHD_Init(d);
        vhd_set_state(d, VHD_S_TEST_INT5);
        in_l = hexbuf(in, sizeof in, "1e");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        CHECK_INT(d, 30);

        /* Test multibyte decoding */
        VHD_Init(d);
        vhd_set_state(d, VHD_S_TEST_INT5);
        in_l = hexbuf(in, sizeof in, "ff 9a 0a");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        CHECK_INT(d, 1337);

        /* Test max size we allow */
        VHD_Init(d);
        vhd_set_state(d, VHD_S_TEST_INT5);
        in_l = hexbuf(in, sizeof in, "1f ff ff ff ff 07");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        CHECK_INT(d, 0x8000001E);

        /* Test overflow */
        VHD_Init(d);
        vhd_set_state(d, VHD_S_TEST_INT5);
        in_l = hexbuf(in, sizeof in, "1f ff ff ff ff 08");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_ERR_INT);
}

static void
test_raw(unsigned mode)
{
        struct vhd_decode d[1];
        uint8_t in[128];
        size_t in_l;
        char out[128];
        enum vhd_ret_e r;

        /* Test raw encoding */
        VHD_Init(d);
        vhd_set_state(d, VHD_S_TEST_LITERAL);
        in_l = hexbuf(in, sizeof in,
            "0a63 7573 746f 6d2d 6b65 790d 6375 7374 6f6d 2d68 6561 6465 72");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out, "custom-key", "custom-header", NULL));

        /* Test too short input */
        VHD_Init(d);
        vhd_set_state(d, VHD_S_TEST_LITERAL);
        in_l = hexbuf(in, sizeof in,
            "02");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_MORE);
}

static void
test_huffman(unsigned mode)
{
        struct vhd_decode d[1];
        uint8_t in[256];
        size_t in_l;
        char out[256];
        enum vhd_ret_e r;

        /* Decode a huffman encoded value */
        VHD_Init(d);
        in_l = hexbuf(in, sizeof in,
            "0141 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff");
        vhd_set_state(d, VHD_S_TEST_LITERAL);
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out, "A", "www.example.com", NULL));

        /* Decode an incomplete input buffer */
        VHD_Init(d);
        in_l = hexbuf(in, sizeof in,
            "0141 81");
        vhd_set_state(d, VHD_S_TEST_LITERAL);
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_MORE);

        /* Decode an incomplete huffman code */
        VHD_Init(d);
        in_l = hexbuf(in, sizeof in,
            "0141 81 fe");
        vhd_set_state(d, VHD_S_TEST_LITERAL);
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_ERR_HUF);

        /* Decode an invalid huffman code */
        VHD_Init(d);
        in_l = hexbuf(in, sizeof in,
            "0141 84 ff ff ff ff");
        vhd_set_state(d, VHD_S_TEST_LITERAL);
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_ERR_HUF);
}

static void
test_c2(unsigned mode)
{
        struct vhd_decode d[1];
        uint8_t in[256];
        size_t in_l;
        char out[256];
        enum vhd_ret_e r;

        /* See RFC 7541 Appendix C.2 */

        VHD_Init(d);

        /* C.2.1 */
        in_l = hexbuf(in, sizeof in,
            "400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
            "746f 6d2d 6865 6164 6572");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                "custom-key", "custom-header",
                NULL));

        /* C.2.2 */
        in_l = hexbuf(in, sizeof in,
            "040c 2f73 616d 706c 652f 7061 7468");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":path", "/sample/path",
                NULL));

        /* C.2.3 */
        in_l = hexbuf(in, sizeof in,
            "1008 7061 7373 776f 7264 0673 6563 7265"
            "74");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                "password", "secret",
                NULL));

        /* C.2.4 */
        in_l = hexbuf(in, sizeof in,
            "82");
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                NULL));
}

static void
test_c3(unsigned mode)
{
        struct vht_table t[1];
        struct vhd_decode d[1];
        uint8_t in[256];
        size_t in_l;
        char out[256];
        enum vhd_ret_e r;

        /* See RFC 7541 Appendix C.3 */

        AZ(VHT_Init(t, 4096));
        VHD_Init(d);

        /* C.3.1 */
        in_l = hexbuf(in, sizeof in,
            "8286 8441 0f77 7777 2e65 7861 6d70 6c65"
            "2e63 6f6d");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                ":scheme", "http",
                ":path", "/",
                ":authority", "www.example.com",
                NULL));

        /* C.3.2 */
        in_l = hexbuf(in, sizeof in,
            "8286 84be 5808 6e6f 2d63 6163 6865");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                ":scheme", "http",
                ":path", "/",
                ":authority", "www.example.com",
                "cache-control", "no-cache",
                NULL));

        /* C.3.3 */
        in_l = hexbuf(in, sizeof in,
            "8287 85bf 400a 6375 7374 6f6d 2d6b 6579"
            "0c63 7573 746f 6d2d 7661 6c75 65");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                ":scheme", "https",
                ":path", "/index.html",
                ":authority", "www.example.com",
                "custom-key", "custom-value",
                NULL));

        VHT_Fini(t);
}

static void
test_c4(unsigned mode)
{
        struct vht_table t[1];
        struct vhd_decode d[1];
        uint8_t in[256];
        size_t in_l;
        char out[256];
        enum vhd_ret_e r;

        /* See RFC 7541 Appendix C.4 */

        AZ(VHT_Init(t, 4096));
        VHD_Init(d);

        /* C.4.1 */
        in_l = hexbuf(in, sizeof in,
            "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                ":scheme", "http",
                ":path", "/",
                ":authority", "www.example.com",
                NULL));

        /* C.4.2 */
        in_l = hexbuf(in, sizeof in,
            "8286 84be 5886 a8eb 1064 9cbf");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                ":scheme", "http",
                ":path", "/",
                ":authority", "www.example.com",
                "cache-control", "no-cache",
                NULL));

        /* C.4.3 */
        in_l = hexbuf(in, sizeof in,
            "8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925"
            "a849 e95b b8e8 b4bf");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":method", "GET",
                ":scheme", "https",
                ":path", "/index.html",
                ":authority", "www.example.com",
                "custom-key", "custom-value",
                NULL));

        VHT_Fini(t);
}

static void
test_c5(unsigned mode)
{
        struct vht_table t[1];
        struct vhd_decode d[1];
        uint8_t in[256];
        size_t in_l;
        char out[256];
        enum vhd_ret_e r;

        /* See RFC 7541 Appendix C.5 */

        AZ(VHT_Init(t, 256));
        VHD_Init(d);

        /* C.5.1 */
        in_l = hexbuf(in, sizeof in,
            "4803 3330 3258 0770 7269 7661 7465 611d"
            "4d6f 6e2c 2032 3120 4f63 7420 3230 3133"
            "2032 303a 3133 3a32 3120 474d 546e 1768"
            "7474 7073 3a2f 2f77 7777 2e65 7861 6d70"
            "6c65 2e63 6f6d");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":status", "302",
                "cache-control", "private",
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
                "location", "https://www.example.com",
                NULL));

        /* C.5.2 */
        in_l = hexbuf(in, sizeof in,
            "4803 3330 37c1 c0bf");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":status", "307",
                "cache-control", "private",
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
                "location", "https://www.example.com",
                NULL));

        /* C.5.3 */
        in_l = hexbuf(in, sizeof in,
            "88c1 611d 4d6f 6e2c 2032 3120 4f63 7420"
            "3230 3133 2032 303a 3133 3a32 3220 474d"
            "54c0 5a04 677a 6970 7738 666f 6f3d 4153"
            "444a 4b48 514b 425a 584f 5157 454f 5049"
            "5541 5851 5745 4f49 553b 206d 6178 2d61"
            "6765 3d33 3630 303b 2076 6572 7369 6f6e"
            "3d31");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":status", "200",
                "cache-control", "private",
                "date", "Mon, 21 Oct 2013 20:13:22 GMT",
                "location", "https://www.example.com",
                "content-encoding", "gzip",
                "set-cookie",
                "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
                NULL));

        VHT_Fini(t);
}

static void
test_c6(unsigned mode)
{
        struct vht_table t[1];
        struct vhd_decode d[1];
        uint8_t in[256];
        size_t in_l;
        char out[256];
        enum vhd_ret_e r;

        /* See RFC 7541 Appendix C.6 */

        AZ(VHT_Init(t, 256));
        VHD_Init(d);

        /* C.6.1 */
        in_l = hexbuf(in, sizeof in,
            "4882 6402 5885 aec3 771a 4b61 96d0 7abe"
            "9410 54d4 44a8 2005 9504 0b81 66e0 82a6"
            "2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8"
            "e9ae 82ae 43d3");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":status", "302",
                "cache-control", "private",
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
                "location", "https://www.example.com",
                NULL));

        /* C.6.2 */
        in_l = hexbuf(in, sizeof in,
            "4883 640e ffc1 c0bf");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":status", "307",
                "cache-control", "private",
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
                "location", "https://www.example.com",
                NULL));

        /* C.6.3 */
        in_l = hexbuf(in, sizeof in,
            "88c1 6196 d07a be94 1054 d444 a820 0595"
            "040b 8166 e084 a62d 1bff c05a 839b d9ab"
            "77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b"
            "3960 d5af 2708 7f36 72c1 ab27 0fb5 291f"
            "9587 3160 65c0 03ed 4ee5 b106 3d50 07");
        r = decode(d, t, in, in_l, out, sizeof out, mode);
        CHECK_RET(r, VHD_OK);
        AZ(match(out, sizeof out,
                ":status", "200",
                "cache-control", "private",
                "date", "Mon, 21 Oct 2013 20:13:22 GMT",
                "location", "https://www.example.com",
                "content-encoding", "gzip",
                "set-cookie",
                "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
                NULL));

        VHT_Fini(t);
}

#define do_test(name)                                           \
        do {                                                    \
                printf("Doing test: %s\n", #name);              \
                name(0);                                        \
                printf("Doing test: %s 1IN\n", #name);          \
                name(M_1IN);                                    \
                printf("Doing test: %s 1OUT\n", #name);         \
                name(M_1OUT);                                   \
                printf("Doing test: %s 1IN|1OUT\n", #name);     \
                name(M_1IN|M_1OUT);                             \
                printf("Test finished: %s\n\n", #name);         \
        } while (0)

int
main(int argc, char **argv)
{
        if (argc == 2 && !strcmp(argv[1], "-v"))
                verbose = 1;
        else if (argc != 1) {
                fprintf(stderr, "Usage: %s [-v]\n", argv[0]);
                return (1);
        }

        if (verbose) {
                printf("sizeof (struct vhd_int)=%zu\n",
                    sizeof (struct vhd_int));
                printf("sizeof (struct vhd_lookup)=%zu\n",
                    sizeof (struct vhd_lookup));
                printf("sizeof (struct vhd_raw)=%zu\n",
                    sizeof (struct vhd_raw));
                printf("sizeof (struct vhd_huffman)=%zu\n",
                    sizeof (struct vhd_huffman));
                printf("sizeof (struct vhd_decode)=%zu\n",
                    sizeof (struct vhd_decode));
        }

        do_test(test_integer);
        do_test(test_raw);
        do_test(test_huffman);

        do_test(test_c2);
        do_test(test_c3);
        do_test(test_c4);
        do_test(test_c5);
        do_test(test_c6);

        return (0);
}

#endif  /* DECODE_TEST_DRIVER */

		varnish-cache/bin/varnishd/hpack/vhp_decode.c
0		/*-
1		* Copyright (c) 2016 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Martin Blix Grydeland <martin@varnish-software.com>
5		* Author: Dridi Boukelmoune <dridi.boukelmoune@gmail.com>
6		*
7		* SPDX-License-Identifier: BSD-2-Clause
8		*
9		* Redistribution and use in source and binary forms, with or without
10		* modification, are permitted provided that the following conditions
11		* are met:
12		* 1. Redistributions of source code must retain the above copyright
13		* notice, this list of conditions and the following disclaimer.
14		* 2. Redistributions in binary form must reproduce the above copyright
15		* notice, this list of conditions and the following disclaimer in the
16		* documentation and/or other materials provided with the distribution.
17		*
18		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28		* SUCH DAMAGE.
29		*
30		*/
31
32		#include "config.h"
33
34		#include <stdio.h>
35		#include <string.h>
36		#include <limits.h>
37		#include <stdlib.h>
38
39		#include "vdef.h"
40		#include "vas.h"
41		#include "miniobj.h"
42
43		#include "hpack/vhp.h"
44
45		#include "vhp_hufdec.h"
46
47		struct vhd_ctx {
48		struct vhd_decode *d;
49		struct vht_table *tbl;
50		const uint8_t *in;
51		const uint8_t *in_e;
52		char *out;
53		char *out_e;
54		};
55
56		typedef enum vhd_ret_e vhd_state_f(struct vhd_ctx *ctx, unsigned first);
57
58		/* Function flags */
59		#define VHD_INCREMENTAL (1U << 0)
60
61		/* Functions */
62		enum vhd_func_e {
63		#define VHD_FSM_FUNC(NAME, func) \
64		VHD_F_##NAME,
65		#include "tbl/vhd_fsm_funcs.h"
66		VHD_F__MAX,
67		};
68		#define VHD_FSM_FUNC(NAME, func) \
69		static vhd_state_f func;
70		#include "tbl/vhd_fsm_funcs.h"
71
72		/* States */
73		enum vhd_state_e {
74		VHD_S__MIN = -1,
75		#define VHD_FSM(STATE, FUNC, arg1, arg2) \
76		VHD_S_##STATE,
77		#include "tbl/vhd_fsm.h"
78		VHD_S__MAX,
79		};
80		static const struct vhd_state {
81		const char *name;
82		enum vhd_func_e func;
83		unsigned arg1;
84		unsigned arg2;
85		} vhd_states[VHD_S__MAX] = {
86		#define VHD_FSM(STATE, FUNC, arg1, arg2) \
87		[VHD_S_##STATE] = { #STATE, VHD_F_##FUNC, arg1, arg2 },
88		#include "tbl/vhd_fsm.h"
89		};
90
91		/* Utility functions */
92		static void
93	440360	vhd_set_state(struct vhd_decode *d, enum vhd_state_e state)
94		{
95	440360	AN(d);
96	440360	assert(state > VHD_S__MIN && state < VHD_S__MAX);
97	440360	d->state = state;
98	440360	d->first = 1;
99	440360	}
100
101		static void
102	307920	vhd_next_state(struct vhd_decode *d)
103		{
104	307920	AN(d);
105	307920	assert(d->state + 1 < VHD_S__MAX);
106	307920	vhd_set_state(d, d->state + 1);
107	307920	}
108
109		/* State functions */
110		static enum vhd_ret_e v_matchproto_(vhd_state_f)
111	79600	vhd_skip(struct vhd_ctx *ctx, unsigned first)
112		{
113	79600	AN(ctx);
114	79600	AN(first);
115	79600	vhd_next_state(ctx->d);
116	79600	return (VHD_AGAIN);
117		}
118
119		static enum vhd_ret_e v_matchproto_(vhd_state_f)
120	75200	vhd_goto(struct vhd_ctx *ctx, unsigned first)
121		{
122		const struct vhd_state *s;
123
124	75200	AN(ctx);
125	75200	AN(first);
126	75200	assert(ctx->d->state < VHD_S__MAX);
127	75200	s = &vhd_states[ctx->d->state];
128	75200	assert(s->arg1 < VHD_S__MAX);
129	75200	vhd_set_state(ctx->d, s->arg1);
130	75200	return (VHD_AGAIN);
131		}
132
133		static enum vhd_ret_e v_matchproto_(vhd_state_f)
134	40160	vhd_idle(struct vhd_ctx *ctx, unsigned first)
135		{
136		uint8_t c;
137
138	40160	AN(ctx);
139	40160	(void)first;
140
141	40160	while (ctx->in < ctx->in_e) {
142	31240	c = *ctx->in;
143	31240	if ((c & 0x80) == 0x80)
144	6000	vhd_set_state(ctx->d, VHD_S_HP61_START);
145	25240	else if ((c & 0xc0) == 0x40)
146	3840	vhd_set_state(ctx->d, VHD_S_HP621_START);
147	21400	else if ((c & 0xf0) == 0x00)
148	21200	vhd_set_state(ctx->d, VHD_S_HP622_START);
149	200	else if ((c & 0xf0) == 0x10)
150	200	vhd_set_state(ctx->d, VHD_S_HP623_START);
151	0	else if ((c & 0xe0) == 0x20)
152	0	vhd_set_state(ctx->d, VHD_S_HP63_START);
153		else
154	0	return (VHD_ERR_ARG);
155	31240	return (VHD_AGAIN);
156		}
157
158	8920	return (VHD_OK);
159	40160	}
160
161		static enum vhd_ret_e v_matchproto_(vhd_state_f)
162	81560	vhd_integer(struct vhd_ctx *ctx, unsigned first)
163		{
164		const struct vhd_state *s;
165		struct vhd_int *i;
166		uint8_t c;
167		unsigned mask;
168
169	81560	assert(UINT_MAX >= UINT32_MAX);
170
171	81560	AN(ctx);
172	81560	assert(ctx->d->state < VHD_S__MAX);
173	81560	s = &vhd_states[ctx->d->state];
174	81560	i = ctx->d->integer;
175
176	81560	if (first) {
177	80600	INIT_OBJ(i, VHD_INT_MAGIC);
178	80600	i->pfx = s->arg1;
179	80600	assert(i->pfx >= 4 && i->pfx <= 7);
180	80600	}
181	81560	CHECK_OBJ_NOTNULL(i, VHD_INT_MAGIC);
182
183	84880	while (ctx->in < ctx->in_e) {
184	83920	c = *ctx->in;
185	83920	ctx->in++;
186	83920	if (i->pfx) {
187	80600	mask = (1U << i->pfx) - 1;
188	80600	i->pfx = 0;
189	80600	i->v = c & mask;
190	80600	if (i->v < mask) {
191	79520	vhd_next_state(ctx->d);
192	79520	return (VHD_AGAIN);
193		}
194	1080	} else {
195	3320	if ((i->m == 28 && (c & 0x78)) \|\| i->m > 28)
196	240	return (VHD_ERR_INT);
197	3080	i->v += (c & 0x7f) * ((uint32_t)1 << i->m);
198	3080	i->m += 7;
199	3080	if (!(c & 0x80)) {
200	840	vhd_next_state(ctx->d);
201	840	return (VHD_AGAIN);
202		}
203		}
204		}
205	960	return (VHD_MORE);
206	81560	}
207
208		static enum vhd_ret_e v_matchproto_(vhd_state_f)
209	0	vhd_set_max(struct vhd_ctx *ctx, unsigned first)
210		{
211	0	AN(ctx);
212	0	AN(first);
213	0	CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
214	0	if (ctx->tbl == NULL)
215	0	return (VHD_ERR_UPD);
216	0	if (VHT_SetMaxTableSize(ctx->tbl, ctx->d->integer->v))
217	0	return (VHD_ERR_UPD);
218	0	vhd_next_state(ctx->d);
219	0	return (VHD_AGAIN);
220	0	}
221
222		static enum vhd_ret_e v_matchproto_(vhd_state_f)
223	31160	vhd_set_idx(struct vhd_ctx *ctx, unsigned first)
224		{
225	31160	AN(ctx);
226	31160	AN(first);
227	31160	CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
228	31160	ctx->d->index = ctx->d->integer->v;
229	31160	vhd_next_state(ctx->d);
230	31160	return (VHD_AGAIN);
231		}
232
233		static enum vhd_ret_e v_matchproto_(vhd_state_f)
234	69920	vhd_lookup(struct vhd_ctx *ctx, unsigned first)
235		{
236		const struct vhd_state *s;
237		struct vhd_lookup *lu;
238		const char *p;
239		size_t l;
240
241	69920	AN(ctx);
242	69920	assert(ctx->d->state < VHD_S__MAX);
243	69920	s = &vhd_states[ctx->d->state];
244	69920	lu = ctx->d->lookup;
245
246	69920	if (first)
247	15360	INIT_OBJ(lu, VHD_LOOKUP_MAGIC);
248	69920	CHECK_OBJ_NOTNULL(lu, VHD_LOOKUP_MAGIC);
249
250	69920	switch (s->arg1) {
251		case VHD_NAME:
252		case VHD_NAME_SEC:
253	41440	p = VHT_LookupName(ctx->tbl, ctx->d->index, &l);
254	41440	break;
255		case VHD_VALUE:
256		case VHD_VALUE_SEC:
257	28480	p = VHT_LookupValue(ctx->tbl, ctx->d->index, &l);
258	28480	break;
259		default:
260	0	WRONG("vhd_lookup wrong arg1");
261	0	break;
262		}
263	69920	if (first && p == NULL)
264	0	return (VHD_ERR_IDX);
265	69920	AN(p);
266	69920	assert(l <= UINT_MAX);
267	69920	if (first)
268	15360	lu->l = l;
269
270	69920	assert(lu->l <= l);
271	69920	p += l - lu->l;
272	69920	l = vmin_t(size_t, lu->l, ctx->out_e - ctx->out);
273	69920	memcpy(ctx->out, p, l);
274	69920	ctx->out += l;
275	69920	lu->l -= l;
276
277	69920	if (lu->l == 0) {
278	15360	vhd_next_state(ctx->d);
279	15360	return (s->arg1);
280		}
281	54560	assert(ctx->out == ctx->out_e);
282	54560	return (VHD_BUF);
283	69920	}
284
285		static enum vhd_ret_e v_matchproto_(vhd_state_f)
286	520	vhd_new(struct vhd_ctx *ctx, unsigned first)
287		{
288	520	AN(ctx);
289	520	AN(first);
290	520	if (ctx->tbl != NULL)
291	360	VHT_NewEntry(ctx->tbl);
292	520	vhd_next_state(ctx->d);
293	520	return (VHD_AGAIN);
294		}
295
296		static enum vhd_ret_e v_matchproto_(vhd_state_f)
297	3320	vhd_new_idx(struct vhd_ctx *ctx, unsigned first)
298		{
299	3320	AN(ctx);
300	3320	AN(first);
301	3320	if (ctx->tbl != NULL) {
302	3320	if (VHT_NewEntry_Indexed(ctx->tbl, ctx->d->index))
303	0	return (VHD_ERR_IDX);
304	3320	}
305	3320	vhd_next_state(ctx->d);
306	3320	return (VHD_AGAIN);
307	3320	}
308
309		static enum vhd_ret_e v_matchproto_(vhd_state_f)
310	25240	vhd_branch_zidx(struct vhd_ctx *ctx, unsigned first)
311		{
312		const struct vhd_state *s;
313
314	25240	AN(ctx);
315	25240	(void)first;
316	25240	assert(ctx->d->state < VHD_S__MAX);
317	25240	s = &vhd_states[ctx->d->state];
318	25240	assert(s->arg1 < VHD_S__MAX);
319
320	25240	if (ctx->d->index == 0)
321	21720	vhd_set_state(ctx->d, s->arg1);
322		else
323	3520	vhd_next_state(ctx->d);
324	25240	return (VHD_AGAIN);
325		}
326
327		static enum vhd_ret_e v_matchproto_(vhd_state_f)
328	49040	vhd_branch_bit0(struct vhd_ctx *ctx, unsigned first)
329		{
330		const struct vhd_state *s;
331
332	49040	AN(ctx);
333	49040	(void)first;
334	49040	assert(ctx->d->state < VHD_S__MAX);
335	49040	s = &vhd_states[ctx->d->state];
336	49040	assert(s->arg1 < VHD_S__MAX);
337
338	49040	if (ctx->in == ctx->in_e)
339	320	return (VHD_MORE);
340
341	48720	if (*ctx->in & 0x80)
342	2680	vhd_set_state(ctx->d, s->arg1);
343		else
344	46040	vhd_next_state(ctx->d);
345	48720	return (VHD_AGAIN);
346	49040	}
347
348		static enum vhd_ret_e v_matchproto_(vhd_state_f)
349	78160	vhd_raw(struct vhd_ctx *ctx, unsigned first)
350		{
351		const struct vhd_state *s;
352		struct vhd_raw *raw;
353		size_t l2;
354
355	78160	AN(ctx);
356	78160	assert(ctx->d->state < VHD_S__MAX);
357	78160	s = &vhd_states[ctx->d->state];
358
359	78160	raw = ctx->d->raw;
360	78160	if (first) {
361	46040	CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
362	46040	l2 = ctx->d->integer->v;
363	46040	INIT_OBJ(raw, VHD_RAW_MAGIC);
364	46040	raw->l = l2;
365	46040	}
366	78160	CHECK_OBJ_NOTNULL(raw, VHD_RAW_MAGIC);
367
368	154040	while (raw->l > 0) {
369	108200	l2 = raw->l;
370	108200	if (l2 > (ctx->in_e - ctx->in))
371	42400	l2 = ctx->in_e - ctx->in;
372	108200	if (l2 == 0)
373	22200	return (VHD_MORE);
374	86000	if (l2 > (ctx->out_e - ctx->out))
375	20240	l2 = ctx->out_e - ctx->out;
376	86000	if (l2 == 0)
377	10120	return (VHD_BUF);
378	75880	memcpy(ctx->out, ctx->in, l2);
379	75880	ctx->in += l2;
380	75880	if (ctx->tbl != NULL && (s->arg2 & VHD_INCREMENTAL)) {
381	24440	switch (s->arg1) {
382		case VHD_NAME:
383	1240	VHT_AppendName(ctx->tbl, ctx->out, l2);
384	1240	break;
385		case VHD_VALUE:
386	23200	VHT_AppendValue(ctx->tbl, ctx->out, l2);
387	23200	break;
388		default:
389	0	WRONG("vhd_raw wrong arg1");
390	0	break;
391		}
392	24440	}
393	75880	ctx->out += l2;
394	75880	raw->l -= l2;
395		}
396	45840	vhd_next_state(ctx->d);
397	45840	return (s->arg1);
398	78160	}
399
400		static enum vhd_ret_e v_matchproto_(vhd_state_f)
401	26320	vhd_huffman(struct vhd_ctx *ctx, unsigned first)
402		{
403		const struct vhd_state *s;
404		struct vhd_huffman *huf;
405		enum vhd_ret_e r;
406		unsigned u, l;
407
408	26320	AN(ctx);
409	26320	assert(ctx->d->state < VHD_S__MAX);
410	26320	s = &vhd_states[ctx->d->state];
411
412	26320	huf = ctx->d->huffman;
413	26320	if (first) {
414	2680	CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
415	2680	l = ctx->d->integer->v;
416	2680	INIT_OBJ(huf, VHD_HUFFMAN_MAGIC);
417	2680	huf->len = l;
418	2680	}
419	26320	CHECK_OBJ_NOTNULL(huf, VHD_HUFFMAN_MAGIC);
420
421	26320	r = VHD_OK;
422	26320	l = 0;
423	63120	while (1) {
424	63120	assert(huf->pos < HUFDEC_LEN);
425	63120	assert(hufdec[huf->pos].mask > 0);
426	63120	assert(hufdec[huf->pos].mask <= 8);
427
428	63120	if (huf->len > 0 && huf->blen < hufdec[huf->pos].mask) {
429		/* Refill from input */
430	37400	if (ctx->in == ctx->in_e) {
431	9120	r = VHD_MORE;
432	9120	break;
433		}
434	28280	huf->bits = (huf->bits << 8) \| *ctx->in;
435	28280	huf->blen += 8;
436	28280	huf->len--;
437	28280	ctx->in++;
438	28280	}
439
440	54000	if (huf->len == 0 && huf->pos == 0 && huf->blen <= 7 &&
441	3400	huf->bits == (1U << huf->blen) - 1U) {
442		/* End of stream */
443	2200	r = s->arg1;
444	2200	vhd_next_state(ctx->d);
445	2200	break;
446		}
447
448	51800	if (ctx->out + l == ctx->out_e) {
449	14680	r = VHD_BUF;
450	14680	break;
451		}
452
453	37120	if (huf->blen >= hufdec[huf->pos].mask)
454	36160	u = huf->bits >> (huf->blen - hufdec[huf->pos].mask);
455		else
456	960	u = huf->bits << (hufdec[huf->pos].mask - huf->blen);
457	37120	huf->pos += u;
458	37120	assert(huf->pos < HUFDEC_LEN);
459
460	37120	if (hufdec[huf->pos].len == 0 \|\|
461	36960	hufdec[huf->pos].len > huf->blen) {
462		/* Invalid or incomplete code */
463	320	r = VHD_ERR_HUF;
464	320	break;
465		}
466
467	36800	huf->blen -= hufdec[huf->pos].len;
468	36800	huf->bits &= (1U << huf->blen) - 1U;
469
470	36800	if (hufdec[huf->pos].jump) {
471	1440	huf->pos += hufdec[huf->pos].jump;
472	1440	assert(huf->pos < HUFDEC_LEN);
473	1440	} else {
474	35360	ctx->out[l++] = hufdec[huf->pos].chr;
475	35360	huf->pos = 0;
476		}
477		}
478
479	26320	if (l > 0 && ctx->tbl != NULL && (s->arg2 & VHD_INCREMENTAL)) {
480	22680	switch (s->arg1) {
481		case VHD_NAME:
482	1200	VHT_AppendName(ctx->tbl, ctx->out, l);
483	1200	break;
484		case VHD_VALUE:
485	21480	VHT_AppendValue(ctx->tbl, ctx->out, l);
486	21480	break;
487		default:
488	0	WRONG("vhd_raw wrong arg1");
489	0	break;
490		}
491	22680	}
492	26320	ctx->out += l;
493
494	26320	assert(r != VHD_OK);
495	26320	return (r);
496		}
497
498		/* Public interface */
499