Code Coverage: vinyl-cache/bin/vinyld/hpack/vhp_decode.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
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 2441
#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
vhd_set_state(struct vhd_decode *d, enum vhd_state_e state)
94 12715
{
95 12715
        AN(d);
96 12715
        assert(state > VHD_S__MIN && state < VHD_S__MAX);
97 12715
        d->state = state;
98 12715
        d->first = 1;
99 12715
}
100
101
static void
102
vhd_next_state(struct vhd_decode *d)
103 8873
{
104 8873
        AN(d);
105 8873
        assert(d->state + 1 < VHD_S__MAX);
106 8873
        vhd_set_state(d, d->state + 1);
107 8873
}
108
109
/* State functions */
110
static enum vhd_ret_e v_matchproto_(vhd_state_f)
111
vhd_skip(struct vhd_ctx *ctx, unsigned first)
112 2309
{
113 2309
        AN(ctx);
114 2309
        AN(first);
115 2309
        vhd_next_state(ctx->d);
116 2309
        return (VHD_AGAIN);
117 2309
}
118
119
static enum vhd_ret_e v_matchproto_(vhd_state_f)
120
vhd_goto(struct vhd_ctx *ctx, unsigned first)
121 2197
{
122 2197
        const struct vhd_state *s;
123
124 2197
        AN(ctx);
125 2197
        AN(first);
126 2197
        assert(ctx->d->state < VHD_S__MAX);
127 2197
        s = &vhd_states[ctx->d->state];
128 2197
        assert(s->arg1 < VHD_S__MAX);
129 2197
        vhd_set_state(ctx->d, s->arg1);
130 2197
        return (VHD_AGAIN);
131 2197
}
132
133
static enum vhd_ret_e v_matchproto_(vhd_state_f)
134
vhd_idle(struct vhd_ctx *ctx, unsigned first)
135 1140
{
136 1140
        uint8_t c;
137
138 1140
        AN(ctx);
139 1140
        (void)first;
140
141 1140
        while (ctx->in < ctx->in_e) {
142 888
                c = *ctx->in;
143 888
                if ((c & 0x80) == 0x80)
144 150
                        vhd_set_state(ctx->d, VHD_S_HP61_START);
145 738
                else if ((c & 0xc0) == 0x40)
146 96
                        vhd_set_state(ctx->d, VHD_S_HP621_START);
147 642
                else if ((c & 0xf0) == 0x00)
148 637
                        vhd_set_state(ctx->d, VHD_S_HP622_START);
149 5
                else if ((c & 0xf0) == 0x10)
150 5
                        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 0
                else
154 0
                        return (VHD_ERR_ARG);
155 888
                return (VHD_AGAIN);
156 888
        }
157
158 252
        return (VHD_OK);
159 1140
}
160
161
static enum vhd_ret_e v_matchproto_(vhd_state_f)
162
vhd_integer(struct vhd_ctx *ctx, unsigned first)
163 2360
{
164 2360
        const struct vhd_state *s;
165 2360
        struct vhd_int *i;
166 2360
        uint8_t c;
167 2360
        unsigned mask;
168
169 2360
        assert(UINT_MAX >= UINT32_MAX);
170
171 2360
        AN(ctx);
172 2360
        assert(ctx->d->state < VHD_S__MAX);
173 2360
        s = &vhd_states[ctx->d->state];
174 2360
        i = ctx->d->integer;
175
176 2360
        if (first) {
177 2336
                INIT_OBJ(i, VHD_INT_MAGIC);
178 2336
                i->pfx = s->arg1;
179 2336
                assert(i->pfx >= 4 && i->pfx <= 7);
180 2336
        }
181 2360
        CHECK_OBJ_NOTNULL(i, VHD_INT_MAGIC);
182
183 2443
        while (ctx->in < ctx->in_e) {
184 2419
                c = *ctx->in;
185 2419
                ctx->in++;
186 2419
                if (i->pfx) {
187 2336
                        mask = (1U << i->pfx) - 1;
188 2336
                        i->pfx = 0;
189 2336
                        i->v = c & mask;
190 2336
                        if (i->v < mask) {
191 2309
                                vhd_next_state(ctx->d);
192 2309
                                return (VHD_AGAIN);
193 2309
                        }
194 2336
                } else {
195 83
                        if ((i->m == 28 && (c & 0x78)) || i->m > 28)
196 6
                                return (VHD_ERR_INT);
197 77
                        i->v += (c & 0x7f) * ((uint32_t)1 << i->m);
198 77
                        i->m += 7;
199 77
                        if (!(c & 0x80)) {
200 21
                                vhd_next_state(ctx->d);
201 21
                                return (VHD_AGAIN);
202 21
                        }
203 77
                }
204 2419
        }
205 24
        return (VHD_MORE);
206 2360
}
207
208
static enum vhd_ret_e v_matchproto_(vhd_state_f)
209
vhd_set_max(struct vhd_ctx *ctx, unsigned first)
210 0
{
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
vhd_set_idx(struct vhd_ctx *ctx, unsigned first)
224 886
{
225 886
        AN(ctx);
226 886
        AN(first);
227 886
        CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
228 886
        ctx->d->index = ctx->d->integer->v;
229 886
        vhd_next_state(ctx->d);
230 886
        return (VHD_AGAIN);
231 886
}
232
233
static enum vhd_ret_e v_matchproto_(vhd_state_f)
234
vhd_lookup(struct vhd_ctx *ctx, unsigned first)
235 1748
{
236 1748
        const struct vhd_state *s;
237 1748
        struct vhd_lookup *lu;
238 1748
        const char *p;
239 1748
        size_t l;
240
241 1748
        AN(ctx);
242 1748
        assert(ctx->d->state < VHD_S__MAX);
243 1748
        s = &vhd_states[ctx->d->state];
244 1748
        lu = ctx->d->lookup;
245
246 1748
        if (first)
247 384
                INIT_OBJ(lu, VHD_LOOKUP_MAGIC);
248 1748
        CHECK_OBJ_NOTNULL(lu, VHD_LOOKUP_MAGIC);
249
250 1748
        switch (s->arg1) {
251 1035
        case VHD_NAME:
252 1036
        case VHD_NAME_SEC:
253 1036
                p = VHT_LookupName(ctx->tbl, ctx->d->index, &l);
254 1036
                break;
255 712
        case VHD_VALUE:
256 712
        case VHD_VALUE_SEC:
257 712
                p = VHT_LookupValue(ctx->tbl, ctx->d->index, &l);
258 712
                break;
259 0
        default:
260 0
                WRONG("vhd_lookup wrong arg1");
261 0
                break;
262 1748
        }
263 1748
        if (first && p == NULL)
264 0
                return (VHD_ERR_IDX);
265 1748
        AN(p);
266 1748
        assert(l <= UINT_MAX);
267 1748
        if (first)
268 384
                lu->l = l;
269
270 1748
        assert(lu->l <= l);
271 1748
        p += l - lu->l;
272 1748
        l = vmin_t(size_t, lu->l, ctx->out_e - ctx->out);
273 1748
        vmemcpy(ctx->out, p, l);
274 1748
        ctx->out += l;
275 1748
        lu->l -= l;
276
277 1748
        if (lu->l == 0) {
278 384
                vhd_next_state(ctx->d);
279 384
                return (s->arg1);
280 384
        }
281 1364
        assert(ctx->out == ctx->out_e);
282 1364
        return (VHD_BUF);
283 1364
}
284
285
static enum vhd_ret_e v_matchproto_(vhd_state_f)
286
vhd_new(struct vhd_ctx *ctx, unsigned first)
287 13
{
288 13
        AN(ctx);
289 13
        AN(first);
290 13
        if (ctx->tbl != NULL)
291 9
                VHT_NewEntry(ctx->tbl);
292 13
        vhd_next_state(ctx->d);
293 13
        return (VHD_AGAIN);
294 13
}
295
296
static enum vhd_ret_e v_matchproto_(vhd_state_f)
297
vhd_new_idx(struct vhd_ctx *ctx, unsigned first)
298 83
{
299 83
        AN(ctx);
300 83
        AN(first);
301 83
        if (ctx->tbl != NULL) {
302 83
                if (VHT_NewEntry_Indexed(ctx->tbl, ctx->d->index))
303 0
                        return (VHD_ERR_IDX);
304 83
        }
305 83
        vhd_next_state(ctx->d);
306 83
        return (VHD_AGAIN);
307 83
}
308
309
static enum vhd_ret_e v_matchproto_(vhd_state_f)
310
vhd_branch_zidx(struct vhd_ctx *ctx, unsigned first)
311 738
{
312 738
        const struct vhd_state *s;
313
314 738
        AN(ctx);
315 738
        (void)first;
316 738
        assert(ctx->d->state < VHD_S__MAX);
317 738
        s = &vhd_states[ctx->d->state];
318 738
        assert(s->arg1 < VHD_S__MAX);
319
320 738
        if (ctx->d->index == 0)
321 650
                vhd_set_state(ctx->d, s->arg1);
322 88
        else
323 88
                vhd_next_state(ctx->d);
324 738
        return (VHD_AGAIN);
325 738
}
326
327
static enum vhd_ret_e v_matchproto_(vhd_state_f)
328
vhd_branch_bit0(struct vhd_ctx *ctx, unsigned first)
329 1440
{
330 1440
        const struct vhd_state *s;
331
332 1440
        AN(ctx);
333 1440
        (void)first;
334 1440
        assert(ctx->d->state < VHD_S__MAX);
335 1440
        s = &vhd_states[ctx->d->state];
336 1440
        assert(s->arg1 < VHD_S__MAX);
337
338 1440
        if (ctx->in == ctx->in_e)
339 8
                return (VHD_MORE);
340
341 1432
        if (*ctx->in & 0x80)
342 67
                vhd_set_state(ctx->d, s->arg1);
343 1365
        else
344 1365
                vhd_next_state(ctx->d);
345 1432
        return (VHD_AGAIN);
346 1440
}
347
348
static enum vhd_ret_e v_matchproto_(vhd_state_f)
349
vhd_raw(struct vhd_ctx *ctx, unsigned first)
350 2170
{
351 2170
        const struct vhd_state *s;
352 2170
        struct vhd_raw *raw;
353 2170
        size_t l2;
354
355 2170
        AN(ctx);
356 2170
        assert(ctx->d->state < VHD_S__MAX);
357 2170
        s = &vhd_states[ctx->d->state];
358
359 2170
        raw = ctx->d->raw;
360 2170
        if (first) {
361 1365
                CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
362 1365
                l2 = ctx->d->integer->v;
363 1365
                INIT_OBJ(raw, VHD_RAW_MAGIC);
364 1365
                raw->l = l2;
365 1365
        }
366 2170
        CHECK_OBJ_NOTNULL(raw, VHD_RAW_MAGIC);
367
368 4283
        while (raw->l > 0) {
369 2923
                l2 = raw->l;
370 2923
                if (l2 > (ctx->in_e - ctx->in))
371 1060
                        l2 = ctx->in_e - ctx->in;
372 2923
                if (l2 == 0)
373 555
                        return (VHD_MORE);
374 2368
                if (l2 > (ctx->out_e - ctx->out))
375 510
                        l2 = ctx->out_e - ctx->out;
376 2368
                if (l2 == 0)
377 255
                        return (VHD_BUF);
378 2113
                vmemcpy(ctx->out, ctx->in, l2);
379 2113
                ctx->in += l2;
380 2113
                if (ctx->tbl != NULL && (s->arg2 & VHD_INCREMENTAL)) {
381 611
                        switch (s->arg1) {
382 31
                        case VHD_NAME:
383 31
                                VHT_AppendName(ctx->tbl, ctx->out, l2);
384 31
                                break;
385 580
                        case VHD_VALUE:
386 580
                                VHT_AppendValue(ctx->tbl, ctx->out, l2);
387 580
                                break;
388 0
                        default:
389 0
                                WRONG("vhd_raw wrong arg1");
390 0
                                break;
391 611
                        }
392 611
                }
393 2113
                ctx->out += l2;
394 2113
                raw->l -= l2;
395 2113
        }
396 1360
        vhd_next_state(ctx->d);
397 1360
        return (s->arg1);
398 2170
}
399
400
static enum vhd_ret_e v_matchproto_(vhd_state_f)
401
vhd_huffman(struct vhd_ctx *ctx, unsigned first)
402 658
{
403 658
        const struct vhd_state *s;
404 658
        struct vhd_huffman *huf;
405 658
        enum vhd_ret_e r;
406 658
        unsigned u, l;
407
408 658
        AN(ctx);
409 658
        assert(ctx->d->state < VHD_S__MAX);
410 658
        s = &vhd_states[ctx->d->state];
411
412 658
        huf = ctx->d->huffman;
413 658
        if (first) {
414 67
                CHECK_OBJ_NOTNULL(ctx->d->integer, VHD_INT_MAGIC);
415 67
                l = ctx->d->integer->v;
416 67
                INIT_OBJ(huf, VHD_HUFFMAN_MAGIC);
417 67
                huf->len = l;
418 67
        }
419 658
        CHECK_OBJ_NOTNULL(huf, VHD_HUFFMAN_MAGIC);
420
421 658
        r = VHD_OK;
422 658
        l = 0;
423 1578
        while (1) {
424 1578
                assert(huf->pos < HUFDEC_LEN);
425 1578
                assert(hufdec[huf->pos].mask > 0);
426 1578
                assert(hufdec[huf->pos].mask <= 8);
427
428 1578
                if (huf->len > 0 && huf->blen < hufdec[huf->pos].mask) {
429
                        /* Refill from input */
430 935
                        if (ctx->in == ctx->in_e) {
431 228
                                r = VHD_MORE;
432 228
                                break;
433 228
                        }
434 707
                        huf->bits = (huf->bits << 8) | *ctx->in;
435 707
                        huf->blen += 8;
436 707
                        huf->len--;
437 707
                        ctx->in++;
438 707
                }
439
440 1350
                if (huf->len == 0 && huf->pos == 0 && huf->blen <= 7 &&
441 1350
                    huf->bits == (1U << huf->blen) - 1U) {
442
                        /* End of stream */
443 55
                        r = s->arg1;
444 55
                        vhd_next_state(ctx->d);
445 55
                        break;
446 55
                }
447
448 1295
                if (ctx->out + l == ctx->out_e) {
449 367
                        r = VHD_BUF;
450 367
                        break;
451 367
                }
452
453 928
                if (huf->blen >= hufdec[huf->pos].mask)
454 904
                        u = huf->bits >> (huf->blen - hufdec[huf->pos].mask);
455 24
                else
456 24
                        u = huf->bits << (hufdec[huf->pos].mask - huf->blen);
457 928
                huf->pos += u;
458 928
                assert(huf->pos < HUFDEC_LEN);
459
460 928
                if (hufdec[huf->pos].len == 0 ||
461 928
                    hufdec[huf->pos].len > huf->blen) {
462
                        /* Invalid or incomplete code */
463 8
                        r = VHD_ERR_HUF;
464 8
                        break;
465 8
                }
466
467 920
                huf->blen -= hufdec[huf->pos].len;
468 920
                huf->bits &= (1U << huf->blen) - 1U;
469
470 920
                if (hufdec[huf->pos].jump) {
471 36
                        huf->pos += hufdec[huf->pos].jump;
472 36
                        assert(huf->pos < HUFDEC_LEN);
473 884
                } else {
474 884
                        ctx->out[l++] = hufdec[huf->pos].chr;
475 884
                        huf->pos = 0;
476 884
                }
477 920
        }
478
479 658
        if (l > 0 && ctx->tbl != NULL && (s->arg2 & VHD_INCREMENTAL)) {
480 567
                switch (s->arg1) {
481 30
                case VHD_NAME:
482 30
                        VHT_AppendName(ctx->tbl, ctx->out, l);
483 30
                        break;
484 537
                case VHD_VALUE:
485 537
                        VHT_AppendValue(ctx->tbl, ctx->out, l);
486 537
                        break;
487 0
                default:
488 0
                        WRONG("vhd_raw wrong arg1");
489 0
                        break;
490 567
                }
491 567
        }
492 658
        ctx->out += l;
493
494 658
        assert(r != VHD_OK);
495 658
        return (r);
496 658
}
497
498
/* Public interface */
499
500
const char *
501
VHD_Error(enum vhd_ret_e r)
502 39
{
503 39
        switch (r) {
504 0
#define VHD_RET(NAME, VAL, DESC)                        \
505 39
        case VHD_##NAME:                                \
506 39
                return ("VHD_" #NAME " (" DESC ")");
507 0
#include "tbl/vhd_return.h"
508 0
        default:
509 0
                return ("VHD_UNKNOWN");
510 39
        }
511 39
}
512
513
enum vhd_ret_e
514
VHD_Decode(struct vhd_decode *d, struct vht_table *tbl,
515
    const uint8_t *in, size_t inlen, size_t *p_inused,
516
    char *out, size_t outlen, size_t *p_outused)
517 4866
{
518 4866
        const struct vhd_state *s;
519 4866
        struct vhd_ctx ctx[1];
520 4866
        enum vhd_ret_e ret;
521 4866
        unsigned first;
522
523 4866
        CHECK_OBJ_NOTNULL(d, VHD_DECODE_MAGIC);
524 4866
        CHECK_OBJ_ORNULL(tbl, VHT_TABLE_MAGIC);
525 4866
        AN(in);
526 4866
        AN(p_inused);
527 4866
        AN(out);
528 4866
        AN(p_outused);
529
530 4866
        if (d->error < 0)
531 0
                return (d->error);
532
533 4866
        assert(*p_inused <= inlen);
534 4866
        assert(*p_outused <= outlen);
535
536 4866
        ctx->d = d;
537 4866
        ctx->tbl = tbl;
538 4866
        ctx->in = in + *p_inused;
539 4866
        ctx->in_e = in + inlen;
540 4866
        ctx->out = out + *p_outused;
541 4866
        ctx->out_e = out + outlen;
542
543 15742
        do {
544 15742
                first = d->first;
545 15742
                d->first = 0;
546 15742
                assert(d->state < VHD_S__MAX);
547 15742
                s = &vhd_states[d->state];
548 15742
                switch (s->func) {
549 0
#define VHD_FSM_FUNC(NAME, func)                \
550 15742
                case VHD_F_##NAME:              \
551 15742
                        ret = func(ctx, first); \
552 15742
                        break;
553 0
#include "tbl/vhd_fsm_funcs.h"
554 0
                default:
555 0
                        WRONG("Undefined vhd function");
556 0
                        break;
557 15742
                }
558 15742
        } while (ret == VHD_AGAIN);
559
560 4866
        if (ret < 0)
561 14
                d->error = ret;
562
563 4866
        assert(in + *p_inused <= ctx->in);
564 4866
        *p_inused += ctx->in - (in + *p_inused);
565 4866
        assert(out + *p_outused <= ctx->out);
566 4866
        *p_outused += ctx->out - (out + *p_outused);
567
568 4866
        return (ret);
569 4866
}
570
571
void
572
VHD_Init(struct vhd_decode *d)
573 251
{
574
575 251
        AN(d);
576 251
        assert(VHD_S__MAX <= UINT16_MAX);
577 251
        assert(HUFDEC_LEN <= UINT16_MAX);
578 251
        INIT_OBJ(d, VHD_DECODE_MAGIC);
579 251
        d->state = VHD_S_IDLE;
580 251
        d->first = 1;
581 251
}
582
583
/* Test driver */
584
585
#ifdef DECODE_TEST_DRIVER
586
587
#include <ctype.h>
588
#include <stdarg.h>
589
590
static int verbose = 0;
591
592
static size_t
593
hexbuf(uint8_t *buf, size_t buflen, const char *h)
594 104
{
595 104
        size_t l;
596 104
        uint8_t u;
597
598 104
        AN(h);
599 104
        AN(buf);
600
601 104
        l = 0;
602 5596
        for (; *h != '\0'; h++) {
603 5492
                if (l == buflen * 2)
604 0
                        WRONG("Too small buffer");
605 5492
                if (isspace(*h))
606 996
                        continue;
607 4496
                if (*h >= '0' && *h <= '9')
608 3380
                        u = *h - '0';
609 1116
                else if (*h >= 'a' && *h <= 'f')
610 1116
                        u = 0xa + *h - 'a';
611 0
                else if (*h >= 'A' && *h <= 'F')
612 0
                        u = 0xa + *h - 'A';
613 0
                else
614 0
                        WRONG("Bad input character");
615 4496
                assert(u <= 0xf);
616 4496
                if (l % 2 == 0) {
617 2248
                        u <<= 4;
618 2248
                        buf[l / 2] = u;
619 2248
                } else {
620 2248
                        buf[l / 2] |= u;
621 2248
                }
622 4496
                l++;
623 4496
        }
624 104
        AZ(l % 2);
625 104
        return (l / 2);
626 104
}
627
628
static int
629
match(const char *b, size_t l, ...)
630 72
{
631 72
        va_list ap;
632 72
        const char *e;
633 72
        const char *m;
634 72
        int r = 0;
635
636 72
        va_start(ap, l);
637 72
        e = b + l;
638 568
        while (1) {
639 568
                m = va_arg(ap, const char *);
640 568
                if (m == NULL)
641 72
                        break;
642 496
                l = vstrlen(m);
643 496
                if (e - b <= l || b[l] != '\0' || vstrncmp(b, m, l)) {
644 0
                        printf("%.*s != %s\n", (int)(e - b), b, m);
645 0
                        r = -1;
646 0
                        break;
647 496
                } else if (verbose) {
648 0
                        printf("%s == %s\n", b, m);
649 0
                }
650 496
                b += l + 1;
651 496
        }
652 72
        va_end(ap);
653 72
        return (r);
654 72
}
655
656 3417
#define M_1IN (1U << 0)
657 3417
#define M_1OUT (1U << 1)
658
659
static enum vhd_ret_e
660
decode(struct vhd_decode *d, struct vht_table *tbl, uint8_t *in, size_t in_l,
661
    char *out, size_t out_l, unsigned m)
662 104
{
663 104
        size_t in_u, out_u;
664 104
        enum vhd_ret_e r;
665
666 104
        CHECK_OBJ_NOTNULL(d, VHD_DECODE_MAGIC);
667 104
        AN(in);
668 104
        AN(out);
669
670 104
        in_u = 0;
671 104
        out_u = 0;
672
673 3401
        while (1) {
674 3401
                r = VHD_Decode(d, tbl, in,
675 3401
                    (m & M_1IN ? (in_l > in_u ? in_u + 1 : in_u) : in_l),
676 3401
                    &in_u,
677 3401
                    out,
678 3401
                    (m & M_1OUT ? (out_l > out_u ? out_u + 1 : out_u) : out_l),
679 3401
                    &out_u);
680 3401
                assert(in_u <= in_l);
681 3401
                assert(out_u <= out_l);
682 3401
                if (r < VHD_OK)
683 12
                        return (r);
684
685 3389
                switch (r) {
686 84
                case VHD_OK:
687 84
                        return (r);
688
689 814
                case VHD_MORE:
690 814
                        if (in_u == in_l)
691 8
                                return (r);
692 806
                        break;
693
694 1983
                case VHD_BUF:
695 1983
                        if (out_u == out_l)
696 0
                                return (r);
697 1983
                        break;
698
699 1983
                case VHD_NAME:
700 260
                case VHD_NAME_SEC:
701 260
                        assert(out_l - out_u > 0);
702 260
                        out[out_u++] = '\0';
703 260
                        if (verbose)
704 0
                                printf("Name%s: '%s'\n",
705 0
                                    (r == VHD_NAME_SEC ? " (sec)" : ""),
706 0
                                    out);
707 260
                        out += out_u;
708 260
                        out_l -= out_u;
709 260
                        out_u = 0;
710 260
                        break;
711
712 244
                case VHD_VALUE:
713 248
                case VHD_VALUE_SEC:
714 248
                        assert(out_l - out_u > 0);
715 248
                        out[out_u++] = '\0';
716 248
                        if (verbose)
717 0
                                printf("Value%s: '%s'\n",
718 0
                                    (r == VHD_VALUE_SEC ? " (sec)" : ""),
719 0
                                    out);
720 248
                        out += out_u;
721 248
                        out_l -= out_u;
722 248
                        out_u = 0;
723 248
                        break;
724
725 0
                default:
726 0
                        WRONG("Wrong return code");
727 0
                        break;
728 3389
                }
729 3389
        }
730
731 104
        NEEDLESS(return (VHD_OK));
732 104
}
733
734
#define CHECK_RET(r, e)                                 \
735 104
        do {                                            \
736 104
                if (verbose || r != e) {                \
737 0
                        printf("%s %s %s\n",            \
738 0
                            VHD_Error(r),               \
739 0
                            (r == e ? "==" : "!="),     \
740 0
                            VHD_Error(e));              \
741 0
                }                                       \
742 104
                assert(r == e);                         \
743 104
        } while (0)
744
745
#define CHECK_INT(d, u)                                                 \
746 12
        do {                                                            \
747 12
                CHECK_OBJ_NOTNULL(d->integer, VHD_INT_MAGIC);           \
748 12
                if (verbose || d->integer->v != u) {                    \
749 0
                        printf("%u %s %u\n", d->integer->v,             \
750 0
                            (d->integer->v == u ? "==" : "!="),         \
751 0
                            u);                                         \
752 0
                }                                                       \
753 12
                assert(d->integer->v == u);                             \
754 12
        } while (0)
755
756
static void
757
test_integer(unsigned mode)
758 4
{
759 4
        struct vhd_decode d[1];
760 4
        uint8_t in[128];
761 4
        size_t in_l;
762 4
        char out[128];
763 4
        enum vhd_ret_e r;
764
765
        /* Test single byte decoding */
766 4
        VHD_Init(d);
767 4
        vhd_set_state(d, VHD_S_TEST_INT5);
768 4
        in_l = hexbuf(in, sizeof in, "1e");
769 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
770 4
        CHECK_RET(r, VHD_OK);
771 4
        CHECK_INT(d, 30);
772
773
        /* Test multibyte decoding */
774 4
        VHD_Init(d);
775 4
        vhd_set_state(d, VHD_S_TEST_INT5);
776 4
        in_l = hexbuf(in, sizeof in, "ff 9a 0a");
777 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
778 4
        CHECK_RET(r, VHD_OK);
779 4
        CHECK_INT(d, 1337);
780
781
        /* Test max size we allow */
782 4
        VHD_Init(d);
783 4
        vhd_set_state(d, VHD_S_TEST_INT5);
784 4
        in_l = hexbuf(in, sizeof in, "1f ff ff ff ff 07");
785 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
786 4
        CHECK_RET(r, VHD_OK);
787 4
        CHECK_INT(d, 0x8000001E);
788
789
        /* Test overflow */
790 4
        VHD_Init(d);
791 4
        vhd_set_state(d, VHD_S_TEST_INT5);
792 4
        in_l = hexbuf(in, sizeof in, "1f ff ff ff ff 08");
793 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
794 4
        CHECK_RET(r, VHD_ERR_INT);
795 4
}
796
797
static void
798
test_raw(unsigned mode)
799 4
{
800 4
        struct vhd_decode d[1];
801 4
        uint8_t in[128];
802 4
        size_t in_l;
803 4
        char out[128];
804 4
        enum vhd_ret_e r;
805
806
        /* Test raw encoding */
807 4
        VHD_Init(d);
808 4
        vhd_set_state(d, VHD_S_TEST_LITERAL);
809 4
        in_l = hexbuf(in, sizeof in,
810 4
            "0a63 7573 746f 6d2d 6b65 790d 6375 7374 6f6d 2d68 6561 6465 72");
811 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
812 4
        CHECK_RET(r, VHD_OK);
813 4
        AZ(match(out, sizeof out, "custom-key", "custom-header", NULL));
814
815
        /* Test too short input */
816 4
        VHD_Init(d);
817 4
        vhd_set_state(d, VHD_S_TEST_LITERAL);
818 4
        in_l = hexbuf(in, sizeof in,
819 4
            "02");
820 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
821 4
        CHECK_RET(r, VHD_MORE);
822 4
}
823
824
static void
825
test_huffman(unsigned mode)
826 4
{
827 4
        struct vhd_decode d[1];
828 4
        uint8_t in[256];
829 4
        size_t in_l;
830 4
        char out[256];
831 4
        enum vhd_ret_e r;
832
833
        /* Decode a huffman encoded value */
834 4
        VHD_Init(d);
835 4
        in_l = hexbuf(in, sizeof in,
836 4
            "0141 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff");
837 4
        vhd_set_state(d, VHD_S_TEST_LITERAL);
838 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
839 4
        CHECK_RET(r, VHD_OK);
840 4
        AZ(match(out, sizeof out, "A", "www.example.com", NULL));
841
842
        /* Decode an incomplete input buffer */
843 4
        VHD_Init(d);
844 4
        in_l = hexbuf(in, sizeof in,
845 4
            "0141 81");
846 4
        vhd_set_state(d, VHD_S_TEST_LITERAL);
847 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
848 4
        CHECK_RET(r, VHD_MORE);
849
850
        /* Decode an incomplete huffman code */
851 4
        VHD_Init(d);
852 4
        in_l = hexbuf(in, sizeof in,
853 4
            "0141 81 fe");
854 4
        vhd_set_state(d, VHD_S_TEST_LITERAL);
855 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
856 4
        CHECK_RET(r, VHD_ERR_HUF);
857
858
        /* Decode an invalid huffman code */
859 4
        VHD_Init(d);
860 4
        in_l = hexbuf(in, sizeof in,
861 4
            "0141 84 ff ff ff ff");
862 4
        vhd_set_state(d, VHD_S_TEST_LITERAL);
863 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
864 4
        CHECK_RET(r, VHD_ERR_HUF);
865 4
}
866
867
static void
868
test_c2(unsigned mode)
869 4
{
870 4
        struct vhd_decode d[1];
871 4
        uint8_t in[256];
872 4
        size_t in_l;
873 4
        char out[256];
874 4
        enum vhd_ret_e r;
875
876
        /* See RFC 7541 Appendix C.2 */
877
878 4
        VHD_Init(d);
879
880
        /* C.2.1 */
881 4
        in_l = hexbuf(in, sizeof in,
882 4
            "400a 6375 7374 6f6d 2d6b 6579 0d63 7573"
883 4
            "746f 6d2d 6865 6164 6572");
884 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
885 4
        CHECK_RET(r, VHD_OK);
886 4
        AZ(match(out, sizeof out,
887 4
                "custom-key", "custom-header",
888 4
                NULL));
889
890
        /* C.2.2 */
891 4
        in_l = hexbuf(in, sizeof in,
892 4
            "040c 2f73 616d 706c 652f 7061 7468");
893 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
894 4
        CHECK_RET(r, VHD_OK);
895 4
        AZ(match(out, sizeof out,
896 4
                ":path", "/sample/path",
897 4
                NULL));
898
899
        /* C.2.3 */
900 4
        in_l = hexbuf(in, sizeof in,
901 4
            "1008 7061 7373 776f 7264 0673 6563 7265"
902 4
            "74");
903 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
904 4
        CHECK_RET(r, VHD_OK);
905 4
        AZ(match(out, sizeof out,
906 4
                "password", "secret",
907 4
                NULL));
908
909
        /* C.2.4 */
910 4
        in_l = hexbuf(in, sizeof in,
911 4
            "82");
912 4
        r = decode(d, NULL, in, in_l, out, sizeof out, mode);
913 4
        CHECK_RET(r, VHD_OK);
914 4
        AZ(match(out, sizeof out,
915 4
                ":method", "GET",
916 4
                NULL));
917 4
}
918
919
static void
920
test_c3(unsigned mode)
921 4
{
922 4
        struct vht_table t[1];
923 4
        struct vhd_decode d[1];
924 4
        uint8_t in[256];
925 4
        size_t in_l;
926 4
        char out[256];
927 4
        enum vhd_ret_e r;
928
929
        /* See RFC 7541 Appendix C.3 */
930
931 4
        AZ(VHT_Init(t, 4096));
932 4
        VHD_Init(d);
933
934
        /* C.3.1 */
935 4
        in_l = hexbuf(in, sizeof in,
936 4
            "8286 8441 0f77 7777 2e65 7861 6d70 6c65"
937 4
            "2e63 6f6d");
938 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
939 4
        CHECK_RET(r, VHD_OK);
940 4
        AZ(match(out, sizeof out,
941 4
                ":method", "GET",
942 4
                ":scheme", "http",
943 4
                ":path", "/",
944 4
                ":authority", "www.example.com",
945 4
                NULL));
946
947
        /* C.3.2 */
948 4
        in_l = hexbuf(in, sizeof in,
949 4
            "8286 84be 5808 6e6f 2d63 6163 6865");
950 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
951 4
        CHECK_RET(r, VHD_OK);
952 4
        AZ(match(out, sizeof out,
953 4
                ":method", "GET",
954 4
                ":scheme", "http",
955 4
                ":path", "/",
956 4
                ":authority", "www.example.com",
957 4
                "cache-control", "no-cache",
958 4
                NULL));
959
960
        /* C.3.3 */
961 4
        in_l = hexbuf(in, sizeof in,
962 4
            "8287 85bf 400a 6375 7374 6f6d 2d6b 6579"
963 4
            "0c63 7573 746f 6d2d 7661 6c75 65");
964 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
965 4
        CHECK_RET(r, VHD_OK);
966 4
        AZ(match(out, sizeof out,
967 4
                ":method", "GET",
968 4
                ":scheme", "https",
969 4
                ":path", "/index.html",
970 4
                ":authority", "www.example.com",
971 4
                "custom-key", "custom-value",
972 4
                NULL));
973
974 4
        VHT_Fini(t);
975 4
}
976
977
static void
978
test_c4(unsigned mode)
979 4
{
980 4
        struct vht_table t[1];
981 4
        struct vhd_decode d[1];
982 4
        uint8_t in[256];
983 4
        size_t in_l;
984 4
        char out[256];
985 4
        enum vhd_ret_e r;
986
987
        /* See RFC 7541 Appendix C.4 */
988
989 4
        AZ(VHT_Init(t, 4096));
990 4
        VHD_Init(d);
991
992
        /* C.4.1 */
993 4
        in_l = hexbuf(in, sizeof in,
994 4
            "8286 8441 8cf1 e3c2 e5f2 3a6b a0ab 90f4 ff");
995 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
996 4
        CHECK_RET(r, VHD_OK);
997 4
        AZ(match(out, sizeof out,
998 4
                ":method", "GET",
999 4
                ":scheme", "http",
1000 4
                ":path", "/",
1001 4
                ":authority", "www.example.com",
1002 4
                NULL));
1003
1004
        /* C.4.2 */
1005 4
        in_l = hexbuf(in, sizeof in,
1006 4
            "8286 84be 5886 a8eb 1064 9cbf");
1007 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1008 4
        CHECK_RET(r, VHD_OK);
1009 4
        AZ(match(out, sizeof out,
1010 4
                ":method", "GET",
1011 4
                ":scheme", "http",
1012 4
                ":path", "/",
1013 4
                ":authority", "www.example.com",
1014 4
                "cache-control", "no-cache",
1015 4
                NULL));
1016
1017
        /* C.4.3 */
1018 4
        in_l = hexbuf(in, sizeof in,
1019 4
            "8287 85bf 4088 25a8 49e9 5ba9 7d7f 8925"
1020 4
            "a849 e95b b8e8 b4bf");
1021 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1022 4
        CHECK_RET(r, VHD_OK);
1023 4
        AZ(match(out, sizeof out,
1024 4
                ":method", "GET",
1025 4
                ":scheme", "https",
1026 4
                ":path", "/index.html",
1027 4
                ":authority", "www.example.com",
1028 4
                "custom-key", "custom-value",
1029 4
                NULL));
1030
1031 4
        VHT_Fini(t);
1032 4
}
1033
1034
static void
1035
test_c5(unsigned mode)
1036 4
{
1037 4
        struct vht_table t[1];
1038 4
        struct vhd_decode d[1];
1039 4
        uint8_t in[256];
1040 4
        size_t in_l;
1041 4
        char out[256];
1042 4
        enum vhd_ret_e r;
1043
1044
        /* See RFC 7541 Appendix C.5 */
1045
1046 4
        AZ(VHT_Init(t, 256));
1047 4
        VHD_Init(d);
1048
1049
        /* C.5.1 */
1050 4
        in_l = hexbuf(in, sizeof in,
1051 4
            "4803 3330 3258 0770 7269 7661 7465 611d"
1052 4
            "4d6f 6e2c 2032 3120 4f63 7420 3230 3133"
1053 4
            "2032 303a 3133 3a32 3120 474d 546e 1768"
1054 4
            "7474 7073 3a2f 2f77 7777 2e65 7861 6d70"
1055 4
            "6c65 2e63 6f6d");
1056 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1057 4
        CHECK_RET(r, VHD_OK);
1058 4
        AZ(match(out, sizeof out,
1059 4
                ":status", "302",
1060 4
                "cache-control", "private",
1061 4
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
1062 4
                "location", "https://www.example.com",
1063 4
                NULL));
1064
1065
        /* C.5.2 */
1066 4
        in_l = hexbuf(in, sizeof in,
1067 4
            "4803 3330 37c1 c0bf");
1068 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1069 4
        CHECK_RET(r, VHD_OK);
1070 4
        AZ(match(out, sizeof out,
1071 4
                ":status", "307",
1072 4
                "cache-control", "private",
1073 4
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
1074 4
                "location", "https://www.example.com",
1075 4
                NULL));
1076
1077
        /* C.5.3 */
1078 4
        in_l = hexbuf(in, sizeof in,
1079 4
            "88c1 611d 4d6f 6e2c 2032 3120 4f63 7420"
1080 4
            "3230 3133 2032 303a 3133 3a32 3220 474d"
1081 4
            "54c0 5a04 677a 6970 7738 666f 6f3d 4153"
1082 4
            "444a 4b48 514b 425a 584f 5157 454f 5049"
1083 4
            "5541 5851 5745 4f49 553b 206d 6178 2d61"
1084 4
            "6765 3d33 3630 303b 2076 6572 7369 6f6e"
1085 4
            "3d31");
1086 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1087 4
        CHECK_RET(r, VHD_OK);
1088 4
        AZ(match(out, sizeof out,
1089 4
                ":status", "200",
1090 4
                "cache-control", "private",
1091 4
                "date", "Mon, 21 Oct 2013 20:13:22 GMT",
1092 4
                "location", "https://www.example.com",
1093 4
                "content-encoding", "gzip",
1094 4
                "set-cookie",
1095 4
                "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
1096 4
                NULL));
1097
1098 4
        VHT_Fini(t);
1099 4
}
1100
1101
static void
1102
test_c6(unsigned mode)
1103 4
{
1104 4
        struct vht_table t[1];
1105 4
        struct vhd_decode d[1];
1106 4
        uint8_t in[256];
1107 4
        size_t in_l;
1108 4
        char out[256];
1109 4
        enum vhd_ret_e r;
1110
1111
        /* See RFC 7541 Appendix C.6 */
1112
1113 4
        AZ(VHT_Init(t, 256));
1114 4
        VHD_Init(d);
1115
1116
        /* C.6.1 */
1117 4
        in_l = hexbuf(in, sizeof in,
1118 4
            "4882 6402 5885 aec3 771a 4b61 96d0 7abe"
1119 4
            "9410 54d4 44a8 2005 9504 0b81 66e0 82a6"
1120 4
            "2d1b ff6e 919d 29ad 1718 63c7 8f0b 97c8"
1121 4
            "e9ae 82ae 43d3");
1122 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1123 4
        CHECK_RET(r, VHD_OK);
1124 4
        AZ(match(out, sizeof out,
1125 4
                ":status", "302",
1126 4
                "cache-control", "private",
1127 4
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
1128 4
                "location", "https://www.example.com",
1129 4
                NULL));
1130
1131
        /* C.6.2 */
1132 4
        in_l = hexbuf(in, sizeof in,
1133 4
            "4883 640e ffc1 c0bf");
1134 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1135 4
        CHECK_RET(r, VHD_OK);
1136 4
        AZ(match(out, sizeof out,
1137 4
                ":status", "307",
1138 4
                "cache-control", "private",
1139 4
                "date", "Mon, 21 Oct 2013 20:13:21 GMT",
1140 4
                "location", "https://www.example.com",
1141 4
                NULL));
1142
1143
        /* C.6.3 */
1144 4
        in_l = hexbuf(in, sizeof in,
1145 4
            "88c1 6196 d07a be94 1054 d444 a820 0595"
1146 4
            "040b 8166 e084 a62d 1bff c05a 839b d9ab"
1147 4
            "77ad 94e7 821d d7f2 e6c7 b335 dfdf cd5b"
1148 4
            "3960 d5af 2708 7f36 72c1 ab27 0fb5 291f"
1149 4
            "9587 3160 65c0 03ed 4ee5 b106 3d50 07");
1150 4
        r = decode(d, t, in, in_l, out, sizeof out, mode);
1151 4
        CHECK_RET(r, VHD_OK);
1152 4
        AZ(match(out, sizeof out,
1153 4
                ":status", "200",
1154 4
                "cache-control", "private",
1155 4
                "date", "Mon, 21 Oct 2013 20:13:22 GMT",
1156 4
                "location", "https://www.example.com",
1157 4
                "content-encoding", "gzip",
1158 4
                "set-cookie",
1159 4
                "foo=ASDJKHQKBZXOQWEOPIUAXQWEOIU; max-age=3600; version=1",
1160 4
                NULL));
1161
1162 4
        VHT_Fini(t);
1163 4
}
1164
1165
#define do_test(name)                                           \
1166 8
        do {                                                    \
1167 8
                printf("Doing test: %s\n", #name);              \
1168 8
                name(0);                                        \
1169 8
                printf("Doing test: %s 1IN\n", #name);          \
1170 8
                name(M_1IN);                                    \
1171 8
                printf("Doing test: %s 1OUT\n", #name);         \
1172 8
                name(M_1OUT);                                   \
1173 8
                printf("Doing test: %s 1IN|1OUT\n", #name);     \
1174 8
                name(M_1IN|M_1OUT);                             \
1175 8
                printf("Test finished: %s\n\n", #name);         \
1176 8
        } while (0)
1177
1178
int
1179
main(int argc, char **argv)
1180 1
{
1181 1
        if (argc == 2 && !vstrcmp(argv[1], "-v"))
1182 0
                verbose = 1;
1183 1
        else if (argc != 1) {
1184 0
                fprintf(stderr, "Usage: %s [-v]\n", argv[0]);
1185 0
                return (1);
1186 0
        }
1187
1188 1
        if (verbose) {
1189 0
                printf("sizeof (struct vhd_int)=%zu\n",
1190 0
                    sizeof (struct vhd_int));
1191 0
                printf("sizeof (struct vhd_lookup)=%zu\n",
1192 0
                    sizeof (struct vhd_lookup));
1193 0
                printf("sizeof (struct vhd_raw)=%zu\n",
1194 0
                    sizeof (struct vhd_raw));
1195 0
                printf("sizeof (struct vhd_huffman)=%zu\n",
1196 0
                    sizeof (struct vhd_huffman));
1197 0
                printf("sizeof (struct vhd_decode)=%zu\n",
1198 0
                    sizeof (struct vhd_decode));
1199 0
        }
1200
1201 1
        do_test(test_integer);
1202 1
        do_test(test_raw);
1203 1
        do_test(test_huffman);
1204
1205 1
        do_test(test_c2);
1206 1
        do_test(test_c3);
1207 1
        do_test(test_c4);
1208 1
        do_test(test_c5);
1209 1
        do_test(test_c6);
1210
1211 1
        return (0);
1212 1
}
1213
1214
#endif  /* DECODE_TEST_DRIVER */