GCOV - Varnish Cache


/*-
 * Copyright 2015-2017,2026 UPLEX - Nils Goroll Systemoptimierung
 * All rights reserved.
 *
 * Authors: Nils Goroll <nils.goroll@uplex.de>
 *          Geoffrey Simmons <geoffrey.simmons@uplex.de>
 *
 * 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 <string.h>

#include "cache/cache.h"

#include "vcc_blob_if.h"
#include "vmod_blob.h"

#define VMOD_BLOB_TYPE 0xfade4faa

struct vmod_blob_blob {
        unsigned magic;
#define VMOD_BLOB_MAGIC 0xfade4fa9
        struct vrt_blob blob;
        void *freeptr;
        char *encoding[__MAX_ENCODING][2];
        pthread_mutex_t lock;
};

#define B64_FUNCS                                  \
                .decode_l       = base64_decode_l, \
                .decode         = base64_decode,   \
                .encode         = base64_encode

static const struct vmod_blob_fptr {
        len_f           *const decode_l;
        decode_f        *const decode;
        len_f           *const encode_l;
        encode_f        *const encode;
} func[__MAX_ENCODING] = {
        [IDENTITY] = {
                .decode_l       = id_decode_l,
                .decode         = id_decode,
                .encode_l       = id_encode_l,
                .encode         = id_encode
        },
        [BASE64] = {
                B64_FUNCS,
                .encode_l       = base64_encode_l
        },
        [BASE64URL] = {
                B64_FUNCS,
                .encode_l       = base64_encode_l
        },
        [BASE64URLNOPAD] = {
                B64_FUNCS,
                .encode_l       = base64nopad_encode_l
        },
        [BASE64CF] = {
                B64_FUNCS,
                .encode_l       = base64_encode_l
        },
        [HEX] = {
                .decode_l       = hex_decode_l,
                .decode         = hex_decode,
                .encode_l       = hex_encode_l,
                .encode         = hex_encode
        },
        [URL] = {
                .decode_l       = url_decode_l,
                .decode         = url_decode,
                .encode_l       = url_encode_l,
                .encode         = url_encode
        },
};

#undef B64_FUNCS

#define ERR(ctx, msg) \
        VRT_fail((ctx), "vmod blob error: " msg)

#define VERR(ctx, fmt, ...) \
        VRT_fail((ctx), "vmod blob error: " fmt, __VA_ARGS__)

#define ERRINVAL(ctx, enc) \
        VERR((ctx), "cannot decode, illegal encoding beginning with \"%s\"", \
             (enc))

#define VERRNOMEM(ctx, fmt, ...) \
        VERR((ctx), fmt ", out of space", __VA_ARGS__)

#define ERRNOMEM(ctx, msg) \
        ERR((ctx), msg ", out of space")

static char empty[1] = { '\0' };

static enum encoding
parse_encoding(VCL_ENUM e)
{
#define VMODENUM(n)                             \
        do {                                    \
                if (e == VENUM(n)) return (n);  \
        } while (0);
#include "vmod_blob_tbl_encodings.h"
        WRONG("illegal encoding enum");
}

static enum case_e
parse_case(VCL_ENUM e)
{
#define VMODENUM(n)                             \
        do {                                    \
                if (e == VENUM(n)) return (n);  \
        } while (0);
#include "vmod_blob_tbl_case.h"
        WRONG("illegal case enum");
}


static inline size_t
decode_l(enum encoding dec, VCL_STRANDS s)
{
        size_t len = 0;

        AENC(dec);

        CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);
        for (int i = 0; i < s->n; i++)
                if (s->p[i] != NULL && *s->p[i] != '\0')
                        len += vstrlen(s->p[i]);

        return (func[dec].decode_l(len));
}

static void
err_decode(VRT_CTX, const char *enc)
{
        switch (errno) {
        case EINVAL:
                ERRINVAL(ctx, enc);
                break;
        case ENOMEM:
                ERRNOMEM(ctx, "cannot decode");
                break;
        default:
                WRONG("invalid errno");
        }
}

static inline int
encodes_hex(enum encoding enc)
{
        return (enc == HEX || enc == URL);
}

/* Require case DEFAULT for all encodings besides HEX and URL. */

static inline int
check_enc_case(VRT_CTX, VCL_ENUM encs, VCL_ENUM case_s, enum encoding enc,
    enum case_e kase)
{
        if (!encodes_hex(enc) && kase != DEFAULT) {
                VERR(ctx, "case %s is illegal with encoding %s", case_s, encs);
                return (0);
        }
        return (1);
}

/* Objects */

VCL_VOID v_matchproto_(td_blob_blob__init)
vmod_blob__init(VRT_CTX, struct vmod_blob_blob **blobp, const char *vcl_name,
    VCL_ENUM decs, VCL_STRANDS strings)
{
        struct vmod_blob_blob *b;
        enum encoding dec = parse_encoding(decs);
        void *buf;
        ssize_t len;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(blobp);
        AZ(*blobp);
        AN(vcl_name);
        AENC(dec);
        CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);

        ALLOC_OBJ(b, VMOD_BLOB_MAGIC);
        AN(b);
        *blobp = b;
        AZ(pthread_mutex_init(&b->lock, NULL));

        b->blob.magic = VRT_BLOB_MAGIC;
        b->blob.type = VMOD_BLOB_TYPE;

        len = decode_l(dec, strings);
        if (len == 0)
                return;

        assert(len > 0);

        buf = malloc(len);
        if (buf == NULL) {
                VERRNOMEM(ctx, "cannot create blob %s", vcl_name);
                return;
        }

        errno = 0;
        len = func[dec].decode(dec, buf, len, -1, strings, NULL);

        if (len == -1) {
                assert(errno == EINVAL);
                free(buf);
                VERR(ctx, "cannot create blob %s, illegal encoding beginning "
                    "with \"%s\"", vcl_name, strings->p[0]);
                return;
        }
        if (len == 0) {
                free(buf);
                memcpy(&b->blob, vrt_null_blob, sizeof b->blob);
                return;
        }
        b->blob.len = len;
        b->blob.blob = b->freeptr = buf;
}

VCL_BLOB v_matchproto_(td_blob_blob_get)
vmod_blob_get(VRT_CTX, struct vmod_blob_blob *b)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(b, VMOD_BLOB_MAGIC);
        CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
        return (&b->blob);
}

VCL_STRING v_matchproto_(td_blob_blob_encode)
vmod_blob_encode(VRT_CTX, struct vmod_blob_blob *b, VCL_ENUM encs,
    VCL_ENUM case_s)
{
        enum encoding enc = parse_encoding(encs);
        AENC(enc);
        enum case_e kase = parse_case(case_s);

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(b, VMOD_BLOB_MAGIC);
        CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);

        if (!check_enc_case(ctx, encs, case_s, enc, kase))
                return (NULL);
        if (b->blob.len == 0)
                return ("");
        if (kase == DEFAULT)
                kase = LOWER;

        if (b->encoding[enc][kase] == NULL) {
                PTOK(pthread_mutex_lock(&b->lock));
                if (b->encoding[enc][kase] == NULL) {
                        ssize_t len = func[enc].encode_l(b->blob.len);

                        assert(len >= 0);
                        if (len == 0)
                                b->encoding[enc][kase] = empty;
                        else {
                                b->encoding[enc][kase] = malloc(len);
                                if (b->encoding[enc][kase] == NULL)
                                        ERRNOMEM(ctx, "cannot encode");
                                else {
                                        char *s = b->encoding[enc][kase];
                                        len =
                                                func[enc].encode(
                                                        enc, kase, s, len,
                                                        b->blob.blob,
                                                        b->blob.len);
                                        assert(len >= 0);
                                        if (len == 0) {
                                                free(s);
                                                b->encoding[enc][kase] = empty;
                                        }
                                        else
                                                s[len] = '\0';
                                }
                        }
                }
                PTOK(pthread_mutex_unlock(&b->lock));
        }
        return (b->encoding[enc][kase]);
}

VCL_VOID v_matchproto_(td_blob_blob__fini)
vmod_blob__fini(struct vmod_blob_blob **blobp)
{
        struct vmod_blob_blob *b;
        char *s;
        int i, j;

        TAKE_OBJ_NOTNULL(b, blobp, VMOD_BLOB_MAGIC);
        CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);

        if (b->freeptr != NULL) {
                free(b->freeptr);
                b->blob.blob = NULL;
        }

        for (i = 0; i < __MAX_ENCODING; i++)
                for (j = 0; j < 2; j++) {
                        s = b->encoding[i][j];
                        if (s != NULL && s != empty) {
                                free(s);
                                b->encoding[i][j] = NULL;
                        }
                }

        PTOK(pthread_mutex_destroy(&b->lock));
        FREE_OBJ(b);
}

/* Functions */

VCL_BLOB v_matchproto_(td_blob_decode)
vmod_decode(VRT_CTX, VCL_ENUM decs, VCL_INT length, VCL_STRANDS strings)
{
        enum encoding dec = parse_encoding(decs);
        char *buf;
        ssize_t len;
        unsigned space;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AENC(dec);
        CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);

        space = WS_ReserveAll(ctx->ws);
        buf = WS_Reservation(ctx->ws);

        if (length <= 0)
                length = -1;
        errno = 0;
        len = func[dec].decode(dec, buf, space, length, strings, NULL);

        if (len == -1) {
                err_decode(ctx, strings->p[0]);
                WS_Release(ctx->ws, 0);
                return (NULL);
        }
        if (len == 0) {
                WS_Release(ctx->ws, 0);
                return (vrt_null_blob);
        }
        WS_Release(ctx->ws, len);

        assert(len > 0);

        return (VRT_blob(ctx, "blob.decode", buf, len, VMOD_BLOB_TYPE));
}

static VCL_STRING
encode(VRT_CTX, enum encoding enc, enum case_e kase, VCL_BLOB b)
{
        ssize_t len;
        char *buf;
        unsigned space;

        AENC(enc);

        if (b == NULL)
                return (NULL);

        CHECK_OBJ(b, VRT_BLOB_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
        space = WS_ReserveAll(ctx->ws);
        buf = WS_Reservation(ctx->ws);

        len = func[enc].encode(enc, kase, buf, space, b->blob, b->len);

        if (len == -1) {
                ERRNOMEM(ctx, "cannot encode");
                WS_Release(ctx->ws, 0);
                return (NULL);
        }
        if (len == 0) {
                WS_Release(ctx->ws, 0);
                return ("");
        }
        buf[len] = '\0';
        WS_Release(ctx->ws, len + 1);
        return (buf);
}

VCL_STRING v_matchproto_(td_blob_encode)
vmod_encode(VRT_CTX, VCL_ENUM encs, VCL_ENUM case_s, VCL_BLOB b)
{
        enum encoding enc = parse_encoding(encs);
        enum case_e kase = parse_case(case_s);

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (!check_enc_case(ctx, encs, case_s, enc, kase))
                return (NULL);
        return (encode(ctx, enc, kase, b));
}

/*
 * Remove the first len bytes from strands
 *
 * to VRT?
 */
static void
strands_consume(struct strands *strings, size_t consume)
{
        const char *s;
        size_t len;
        int i;

        CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);

        for (i = 0; i < strings->n; i++) {
                s = strings->p[i];
                if (s == NULL || *s == '\0')
                        continue;
                len = vstrlen(s);
                if (consume >= len) {
                        strings->p[i] = NULL;
                        consume -= len;
                        continue;
                }
                strings->p[i] += consume;
                break;
        }

        // i is at first string still needed
        assert(i >= 0);
        assert(i <= strings->n);
        if (i == strings->n) {
                memset(strings->p, 0, strings->n * sizeof *strings->p);
                strings->n = 0;
                return;
        }
        len = (unsigned)strings->n - i;
        vmemmove(strings->p, strings->p + i, len * sizeof *strings->p);
        strings->n -= i;
}

VCL_STRING v_matchproto_(td_blob_transcode)
vmod_transcode(VRT_CTX, VCL_ENUM decs, VCL_ENUM encs, VCL_ENUM case_s,
               VCL_INT length, VCL_STRANDS stringsa)
{
        enum encoding dec = parse_encoding(decs);
        enum encoding enc = parse_encoding(encs);
        enum case_e kase = parse_case(case_s);
        VCL_STRING r;
        // 32K are safe because PCRE. Needs to be a multiple of three for base64
        // For bughunt, set to 3
        const size_t bufmax = (32 * 1024) - 2;
        size_t buflen;
        ssize_t len;
        char *out;
        unsigned space;
        size_t consumed;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
        CHECK_OBJ_NOTNULL(stringsa, STRANDS_MAGIC);

        // copy stringsa into strings on stack
        const char *p[stringsa->n];
        vmemcpy(p, stringsa->p, stringsa->n * sizeof *p);
        struct strands *strings = &(struct strands){.magic=STRANDS_MAGIC, .n=stringsa->n, .p=p};

        assert(bufmax % 3 == 0); //lint !e778 constant

        AENC(dec);
        AENC(enc);

        if (!check_enc_case(ctx, encs, case_s, enc, kase))
                return (NULL);

        /*
         * Allocate space for the decoded blob on the stack
         * ignoring the limitation imposed by n
         */
        buflen = decode_l(dec, strings);
        if (buflen == 0)
                return ("");

        if (buflen > bufmax)
                buflen = bufmax;

        char buf[buflen];

        if (length <= 0)
                length = -1;

        if (length == -1 && enc == dec && !encodes_hex(enc)) {
                /* test if decodes OK, and if so, return input
                 * basically the same loop as below, but without the encode step
                 */
                while (strings->n) {
                        errno = 0;
                        len = func[dec].decode(dec, buf, buflen, length, strings, &consumed);

                        if (len < 0 && errno != ENOMEM) {
                                err_decode(ctx, strings->p[0]);
                                return (NULL);
                        }

                        strands_consume(strings, consumed);
                }
                return (VRT_STRANDS_string(ctx, stringsa));
        }

        space = WS_ReserveAll(ctx->ws);
        r = out = WS_Reservation(ctx->ws);

        while (strings->n && length != 0) {
                errno = 0;

                len = func[dec].decode(dec, buf, buflen, length, strings, &consumed);
                if (len < 0 && errno != ENOMEM) {
                        err_decode(ctx, strings->p[0]);
                        WS_Release(ctx->ws, 0);
                        return (NULL);
                }
                if (len < 0)
                        len = buflen;

                strands_consume(strings, consumed);

                if (length > 0) {
                        assert(consumed <= (typeof(consumed))length);
                        length -= consumed;
                }

                if (len == 0)
                        continue;
                AN(consumed);

                errno = 0;
                len = func[enc].encode(enc, kase, out, space, buf, len);

                if (len == -1) {
                        ERRNOMEM(ctx, "cannot encode");
                        WS_Release(ctx->ws, 0);
                        return (NULL);
                }
                assert(len >= 0);
                assert((size_t)len <= space);

                out += len;
                space -= len;
        }

        // _encode_l ensures
        assert(space > 0);
        *out++ = '\0';
        WS_ReleaseP(ctx->ws, out);
        return (r);
}

VCL_BOOL v_matchproto_(td_blob_same)
vmod_same(VRT_CTX, VCL_BLOB b1, VCL_BLOB b2)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (b1 == b2)
                return (1);
        if (b1 == NULL || b2 == NULL)
                return (0);
        CHECK_OBJ(b1, VRT_BLOB_MAGIC);
        CHECK_OBJ(b2, VRT_BLOB_MAGIC);
        return (b1->len == b2->len && b1->blob == b2->blob);
}

VCL_BOOL v_matchproto_(td_blob_equal)
vmod_equal(VRT_CTX, VCL_BLOB b1, VCL_BLOB b2)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (b1 == b2)
                return (1);
        if (b1 == NULL || b2 == NULL)
                return (0);
        CHECK_OBJ(b1, VRT_BLOB_MAGIC);
        CHECK_OBJ(b2, VRT_BLOB_MAGIC);
        if (b1->len != b2->len)
                return (0);
        if (b1->blob == b2->blob)
                return (1);
        if (b1->blob == NULL || b2->blob == NULL)
                return (0);
        return (memcmp(b1->blob, b2->blob, b1->len) == 0);
}

VCL_INT v_matchproto_(td_blob_length)
vmod_length(VRT_CTX, VCL_BLOB b)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        if (b == NULL)
                return (0);
        CHECK_OBJ(b, VRT_BLOB_MAGIC);
        return (b->len);
}

VCL_BLOB v_matchproto_(td_blob_sub)
vmod_sub(VRT_CTX, VCL_BLOB b, VCL_BYTES n, VCL_BYTES off)
{

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);

        CHECK_OBJ_ORNULL(b, VRT_BLOB_MAGIC);
        if (b == NULL || b->len == 0 || b->blob == NULL) {
                ERR(ctx, "blob is empty in blob.sub()");
                return (NULL);
        }

        assert(b->len > 0);

        // XXX check for > SIZE_MAX ?
        if (off < 0 || n < 0) {
                ERR(ctx, "size or offset negative in blob.sub()");
                return (NULL);
        }

        if ((size_t)off > b->len || (size_t)n > b->len ||
            (size_t)off + (size_t)n > b->len) {
                VERR(ctx, "size %jd from offset %jd requires more bytes than "
                    "blob length %zd in blob.sub()",
                    (intmax_t)n, (intmax_t)off, b->len);
                return (NULL);
        }

        return (VRT_blob(ctx, "blob.sub",
            (const char *)b->blob + off, n, b->type));
}

		vinyl-cache/vmod/vmod_blob.c
0		/*-
1		* Copyright 2015-2017,2026 UPLEX - Nils Goroll Systemoptimierung
2		* All rights reserved.
3		*
4	14175	* Authors: Nils Goroll <nils.goroll@uplex.de>
5	37169	* Geoffrey Simmons <geoffrey.simmons@uplex.de>
6	31688	*
7	19949	* SPDX-License-Identifier: BSD-2-Clause
8	18479	*
9	18437	* Redistribution and use in source and binary forms, with or without
10	12432	* modification, are permitted provided that the following conditions are met:
11	5292	* 1. Redistributions of source code must retain the above copyright notice,
12		* this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright notice,
14		* this list of conditions and the following disclaimer in the documentation
15		* and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
18		* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19		* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20		* DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
21		* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22		* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23		* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24		* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25		* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26		* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27		*
28		*/
29
30		#include "config.h"
31		#include <string.h>
32
33		#include "cache/cache.h"
34
35		#include "vcc_blob_if.h"
36		#include "vmod_blob.h"
37
38		#define VMOD_BLOB_TYPE 0xfade4faa
39
40		struct vmod_blob_blob {
41		unsigned magic;
42		#define VMOD_BLOB_MAGIC 0xfade4fa9
43		struct vrt_blob blob;
44		void *freeptr;
45		char *encoding[__MAX_ENCODING][2];
46		pthread_mutex_t lock;
47		};
48
49		#define B64_FUNCS \
50		.decode_l = base64_decode_l, \
51		.decode = base64_decode, \
52		.encode = base64_encode
53
54		static const struct vmod_blob_fptr {
55		len_f *const decode_l;
56		decode_f *const decode;
57		len_f *const encode_l;
58		encode_f *const encode;
59		} func[__MAX_ENCODING] = {
60		[IDENTITY] = {
61		.decode_l = id_decode_l,
62		.decode = id_decode,
63		.encode_l = id_encode_l,
64		.encode = id_encode
65		},
66		[BASE64] = {
67		B64_FUNCS,
68		.encode_l = base64_encode_l
69		},
70		[BASE64URL] = {
71		B64_FUNCS,
72		.encode_l = base64_encode_l
73		},
74		[BASE64URLNOPAD] = {
75		B64_FUNCS,
76		.encode_l = base64nopad_encode_l
77		},
78		[BASE64CF] = {
79		B64_FUNCS,
80		.encode_l = base64_encode_l
81		},
82		[HEX] = {
83		.decode_l = hex_decode_l,
84		.decode = hex_decode,
85		.encode_l = hex_encode_l,
86		.encode = hex_encode
87		},
88		[URL] = {
89		.decode_l = url_decode_l,
90		.decode = url_decode,
91		.encode_l = url_encode_l,
92		.encode = url_encode
93		},
94		};
95
96		#undef B64_FUNCS
97
98		#define ERR(ctx, msg) \
99		VRT_fail((ctx), "vmod blob error: " msg)
100
101		#define VERR(ctx, fmt, ...) \
102		VRT_fail((ctx), "vmod blob error: " fmt, __VA_ARGS__)
103
104		#define ERRINVAL(ctx, enc) \
105		VERR((ctx), "cannot decode, illegal encoding beginning with \"%s\"", \
106		(enc))
107
108		#define VERRNOMEM(ctx, fmt, ...) \
109		VERR((ctx), fmt ", out of space", __VA_ARGS__)
110
111		#define ERRNOMEM(ctx, msg) \
112		ERR((ctx), msg ", out of space")
113
114		static char empty[1] = { '\0' };
115
116		static enum encoding
117	24800	parse_encoding(VCL_ENUM e)
118		{
119		#define VMODENUM(n) \
120		do { \
121		if (e == VENUM(n)) return (n); \
122		} while (0);
123		#include "vmod_blob_tbl_encodings.h"
124	0	WRONG("illegal encoding enum");
125		}
126
127		static enum case_e
128	14175	parse_case(VCL_ENUM e)
129		{
130		#define VMODENUM(n) \
131		do { \
132		if (e == VENUM(n)) return (n); \
133		} while (0);
134		#include "vmod_blob_tbl_case.h"
135	0	WRONG("illegal case enum");
136		}
137
138
139		static inline size_t
140	4977	decode_l(enum encoding dec, VCL_STRANDS s)
141		{
142	4977	size_t len = 0;
143
144	4977	AENC(dec);
145
146	4977	CHECK_OBJ_NOTNULL(s, STRANDS_MAGIC);
147	11403	for (int i = 0; i < s->n; i++)
148	12222	if (s->p[i] != NULL && *s->p[i] != '\0')
149	5796	len += vstrlen(s->p[i]);
150
151	4977	return (func[dec].decode_l(len));
152		}
153
154		static void
155	882	err_decode(VRT_CTX, const char *enc)
156		{
157	882	switch (errno) {
158		case EINVAL:
159	798	ERRINVAL(ctx, enc);
160	798	break;
161		case ENOMEM:
162	84	ERRNOMEM(ctx, "cannot decode");
163	84	break;
164		default:
165	0	WRONG("invalid errno");
166	0	}
167	882	}
168
169		static inline int
170	14826	encodes_hex(enum encoding enc)
171		{
172	14826	return (enc == HEX \|\| enc == URL);
173		}
174
175		/* Require case DEFAULT for all encodings besides HEX and URL. */
176
177		static inline int
178	14175	check_enc_case(VRT_CTX, VCL_ENUM encs, VCL_ENUM case_s, enum encoding enc,
179		enum case_e kase)
180		{
181	14175	if (!encodes_hex(enc) && kase != DEFAULT) {
182	336	VERR(ctx, "case %s is illegal with encoding %s", case_s, encs);
183	336	return (0);
184		}
185	13839	return (1);
186	14175	}
187
188		/* Objects */
189
190		VCL_VOID v_matchproto_(td_blob_blob__init)
191	1050	vmod_blob__init(VRT_CTX, struct vmod_blob_blob *blobp, const char vcl_name,
192		VCL_ENUM decs, VCL_STRANDS strings)
193		{
194		struct vmod_blob_blob *b;
195	1050	enum encoding dec = parse_encoding(decs);
196		void *buf;
197		ssize_t len;
198
199	1050	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
200	1050	AN(blobp);
201	1050	AZ(*blobp);
202	1050	AN(vcl_name);
203	1050	AENC(dec);
204	1050	CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
205
206	1050	ALLOC_OBJ(b, VMOD_BLOB_MAGIC);
207	1050	AN(b);
208	1050	*blobp = b;
209	1050	AZ(pthread_mutex_init(&b->lock, NULL));
210
211	1050	b->blob.magic = VRT_BLOB_MAGIC;
212	1050	b->blob.type = VMOD_BLOB_TYPE;
213
214	1050	len = decode_l(dec, strings);
215	1050	if (len == 0)
216	168	return;
217
218	882	assert(len > 0);
219
220	882	buf = malloc(len);
221	882	if (buf == NULL) {
222	0	VERRNOMEM(ctx, "cannot create blob %s", vcl_name);
223	0	return;
224		}
225
226	882	errno = 0;
227	882	len = func[dec].decode(dec, buf, len, -1, strings, NULL);
228
229	882	if (len == -1) {
230	168	assert(errno == EINVAL);
231	168	free(buf);
232	168	VERR(ctx, "cannot create blob %s, illegal encoding beginning "
233		"with \"%s\"", vcl_name, strings->p[0]);
234	168	return;
235		}
236	714	if (len == 0) {
237	0	free(buf);
238	0	memcpy(&b->blob, vrt_null_blob, sizeof b->blob);
239	0	return;
240		}
241	714	b->blob.len = len;
242	714	b->blob.blob = b->freeptr = buf;
243	1050	}
244
245		VCL_BLOB v_matchproto_(td_blob_blob_get)
246	2247	vmod_blob_get(VRT_CTX, struct vmod_blob_blob *b)
247		{
248	2247	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
249	2247	CHECK_OBJ_NOTNULL(b, VMOD_BLOB_MAGIC);
250	2247	CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
251	2247	return (&b->blob);
252		}
253
254		VCL_STRING v_matchproto_(td_blob_blob_encode)
255	3717	vmod_blob_encode(VRT_CTX, struct vmod_blob_blob *b, VCL_ENUM encs,
256		VCL_ENUM case_s)
257		{
258	3717	enum encoding enc = parse_encoding(encs);
259	3717	AENC(enc);
260	3717	enum case_e kase = parse_case(case_s);
261
262	3717	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
263	3717	CHECK_OBJ_NOTNULL(b, VMOD_BLOB_MAGIC);
264	3717	CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
265
266	3717	if (!check_enc_case(ctx, encs, case_s, enc, kase))
267	168	return (NULL);
268	3549	if (b->blob.len == 0)
269	420	return ("");
270	3129	if (kase == DEFAULT)
271	1911	kase = LOWER;
272
273	3129	if (b->encoding[enc][kase] == NULL) {
274	1281	PTOK(pthread_mutex_lock(&b->lock));
275	1281	if (b->encoding[enc][kase] == NULL) {
276	1281	ssize_t len = func[enc].encode_l(b->blob.len);
277
278	1281	assert(len >= 0);
279	1281	if (len == 0)
280	0	b->encoding[enc][kase] = empty;
281		else {
282	1281	b->encoding[enc][kase] = malloc(len);
283	1281	if (b->encoding[enc][kase] == NULL)
284	0	ERRNOMEM(ctx, "cannot encode");
285		else {
286	1281	char *s = b->encoding[enc][kase];
287	1281	len =
288	2562	func[enc].encode(
289	1281	enc, kase, s, len,
290	1281	b->blob.blob,
291	1281	b->blob.len);
292	1281	assert(len >= 0);
293	1281	if (len == 0) {
294	0	free(s);
295	0	b->encoding[enc][kase] = empty;
296	0	}
297		else
298	1281	s[len] = '\0';
299		}
300		}
301	1281	}
302	1281	PTOK(pthread_mutex_unlock(&b->lock));
303	1281	}
304	3129	return (b->encoding[enc][kase]);
305	3717	}
306
307		VCL_VOID v_matchproto_(td_blob_blob__fini)
308	525	vmod_blob__fini(struct vmod_blob_blob **blobp)
309		{
310		struct vmod_blob_blob *b;
311		char *s;
312		int i, j;
313
314	525	TAKE_OBJ_NOTNULL(b, blobp, VMOD_BLOB_MAGIC);
315	525	CHECK_OBJ(&b->blob, VRT_BLOB_MAGIC);
316
317	525	if (b->freeptr != NULL) {
318	294	free(b->freeptr);
319	294	b->blob.blob = NULL;
320	294	}
321
322	4725	for (i = 0; i < __MAX_ENCODING; i++)
323	12600	for (j = 0; j < 2; j++) {
324	8400	s = b->encoding[i][j];
325	8400	if (s != NULL && s != empty) {
326	420	free(s);
327	420	b->encoding[i][j] = NULL;
328	420	}
329	12600	}
330
331	525	PTOK(pthread_mutex_destroy(&b->lock));
332	525	FREE_OBJ(b);
333	525	}
334
335		/* Functions */
336
337		VCL_BLOB v_matchproto_(td_blob_decode)
338	5649	vmod_decode(VRT_CTX, VCL_ENUM decs, VCL_INT length, VCL_STRANDS strings)
339		{
340	5649	enum encoding dec = parse_encoding(decs);
341		char *buf;
342		ssize_t len;
343		unsigned space;
344
345	5649	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
346	5649	AENC(dec);
347	5649	CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
348	5649	CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
349
350	5649	space = WS_ReserveAll(ctx->ws);
351	5649	buf = WS_Reservation(ctx->ws);
352
353	5649	if (length <= 0)
354	3948	length = -1;
355	5649	errno = 0;
356	5649	len = func[dec].decode(dec, buf, space, length, strings, NULL);
357
358	5649	if (len == -1) {
359	441	err_decode(ctx, strings->p[0]);
360	441	WS_Release(ctx->ws, 0);
361	441	return (NULL);
362		}
363	5208	if (len == 0) {
364	903	WS_Release(ctx->ws, 0);
365	903	return (vrt_null_blob);
366		}
367	4305	WS_Release(ctx->ws, len);
368
369	4305	assert(len > 0);
370
371	4305	return (VRT_blob(ctx, "blob.decode", buf, len, VMOD_BLOB_TYPE));
372	5649	}
373
374		static VCL_STRING
375	6362	encode(VRT_CTX, enum encoding enc, enum case_e kase, VCL_BLOB b)
376		{
377		ssize_t len;
378		char *buf;
379		unsigned space;
380
381	6362	AENC(enc);
382
383	6362	if (b == NULL)
384	567	return (NULL);
385
386	5795	CHECK_OBJ(b, VRT_BLOB_MAGIC);
387	5795	CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
388	5795	space = WS_ReserveAll(ctx->ws);
389	5795	buf = WS_Reservation(ctx->ws);
390
391	5795	len = func[enc].encode(enc, kase, buf, space, b->blob, b->len);
392
393	5795	if (len == -1) {
394	105	ERRNOMEM(ctx, "cannot encode");
395	105	WS_Release(ctx->ws, 0);
396	105	return (NULL);
397		}
398	5690	if (len == 0) {
399	756	WS_Release(ctx->ws, 0);
400	756	return ("");
401		}
402	4934	buf[len] = '\0';
403	4934	WS_Release(ctx->ws, len + 1);
404	4934	return (buf);
405	6362	}
406
407		VCL_STRING v_matchproto_(td_blob_encode)
408	6531	vmod_encode(VRT_CTX, VCL_ENUM encs, VCL_ENUM case_s, VCL_BLOB b)
409		{
410	6531	enum encoding enc = parse_encoding(encs);
411	6531	enum case_e kase = parse_case(case_s);
412
413	6531	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
414	6531	if (!check_enc_case(ctx, encs, case_s, enc, kase))
415	168	return (NULL);
416	6363	return (encode(ctx, enc, kase, b));
417	6531	}
418
419		/*
420		* Remove the first len bytes from strands
421		*
422		* to VRT?
423		*/
424		static void
425	3549	strands_consume(struct strands *strings, size_t consume)
426		{
427		const char *s;
428		size_t len;
429		int i;
430
431	3549	CHECK_OBJ_NOTNULL(strings, STRANDS_MAGIC);
432
433	6300	for (i = 0; i < strings->n; i++) {
434	4431	s = strings->p[i];
435	4431	if (s == NULL \|\| *s == '\0')
436	378	continue;
437	4053	len = vstrlen(s);
438	4053	if (consume >= len) {
439	2373	strings->p[i] = NULL;
440	2373	consume -= len;
441	2373	continue;
442		}
443	1680	strings->p[i] += consume;
444	1680	break;
445		}
446
447		// i is at first string still needed
448	3549	assert(i >= 0);
449	3549	assert(i <= strings->n);
450	3549	if (i == strings->n) {
451	1869	memset(strings->p, 0, strings->n * sizeof *strings->p);
452	1869	strings->n = 0;
453	1869	return;
454		}
455	1680	len = (unsigned)strings->n - i;
456	1680	vmemmove(strings->p, strings->p + i, len * sizeof *strings->p);
457	1680	strings->n -= i;
458	3549	}
459
460		VCL_STRING v_matchproto_(td_blob_transcode)
461	3927	vmod_transcode(VRT_CTX, VCL_ENUM decs, VCL_ENUM encs, VCL_ENUM case_s,
462		VCL_INT length, VCL_STRANDS stringsa)
463		{
464	3927	enum encoding dec = parse_encoding(decs);
465	3927	enum encoding enc = parse_encoding(encs);
466	3927	enum case_e kase = parse_case(case_s);
467		VCL_STRING r;
468		// 32K are safe because PCRE. Needs to be a multiple of three for base64
469		// For bughunt, set to 3
470	3927	const size_t bufmax = (32 * 1024) - 2;
471		size_t buflen;
472		ssize_t len;
473		char *out;
474		unsigned space;
475		size_t consumed;
476
477	3927	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
478	3927	CHECK_OBJ_NOTNULL(ctx->ws, WS_MAGIC);
479	3927	CHECK_OBJ_NOTNULL(stringsa, STRANDS_MAGIC);
480
481		// copy stringsa into strings on stack
482	3927	const char *p[stringsa->n];
483	3927	vmemcpy(p, stringsa->p, stringsa->n * sizeof *p);
484	3927	struct strands *strings = &(struct strands){.magic=STRANDS_MAGIC, .n=stringsa->n, .p=p};
485
486	3927	assert(bufmax % 3 == 0); //lint !e778 constant
487
488	3927	AENC(dec);
489	3927	AENC(enc);
490
491	3927	if (!check_enc_case(ctx, encs, case_s, enc, kase))
492	0	return (NULL);
493
494		/*
495		* Allocate space for the decoded blob on the stack
496		* ignoring the limitation imposed by n
497		*/
498	3927	buflen = decode_l(dec, strings);
499	3927	if (buflen == 0)