GCOV - Varnish Cache


/*-
 * Copyright (c) 2020 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * 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 <stdint.h>
#include <string.h>
#include <sys/types.h>

#include "vdef.h"
#include "vas.h"
#include "vrt.h"
#include "venc.h"

#include "vsb.h"

/*
 * Yes: Cumbersome.  But if "..." syntax is used, C adds a NUL
 */

static const char base64_enc[64] = {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
    'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
    'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
    'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
    'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
    'o', 'p', 'r', 'q', 's', 't', 'u', 'v',
    'w', 'x', 'y', 'z', '0', '1', '2', '3',
    '4', '5', '6', '7', '8', '9', '+', '/'
};

/*
 * Encode base64 (RFC4648 section 4) into VSB.
 */

void
VENC_Encode_Base64(struct vsb *dst, const void *src, size_t len)
{
        const uint8_t *p = src;
        uint32_t u;
        char w[4];

        AN(dst);
        AN(src);
        for (; len >= 3; len -= 3, p += 3) {
                u = (p[0] << 16) | (p[1] << 8) | p[2];
                w[3] = base64_enc[u & 0x3f];
                u >>= 6;
                w[2] = base64_enc[u & 0x3f];
                u >>= 6;
                w[1] = base64_enc[u & 0x3f];
                u >>= 6;
                w[0] = base64_enc[u & 0x3f];
                if (VSB_bcat(dst, w, sizeof w))
                        break;
        }
        if (len) {
                memset(w, '=', sizeof w);
                u = (p[0] << 16);
                if (len == 2)
                    u |= (p[1] << 8);
                w[0] = base64_enc[(u >> 18) & 0x3f];
                w[1] = base64_enc[(u >> 12) & 0x3f];
                if (len == 2)
                        w[2] = base64_enc[(u >> 6) & 0x3f];
                VSB_bcat(dst, w, sizeof w);
        }
}

#define BV 64

static const uint8_t base64_dec[256] = {
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, 62, BV, BV, BV, 63,
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, BV, BV, BV,  0, BV, BV,
    BV,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, BV, BV, BV, BV, BV,
    BV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
    BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV
};

struct venc_state {
        unsigned                n;
        unsigned                f;
        uint8_t                 w;
        struct vsb              *vsb;
        const uint8_t           *tbl;
};

static const char *
venc_decode_base64(struct venc_state *ves, const char *b, const char *e)
{
        unsigned i;

        AN(ves);
        AN(ves->vsb);
        AN(ves->tbl);

        AN(b);
        if (e == NULL)
                e = strchr(b, '\0');
        assert(e >= b);

        for (; b < e; b++) {
                i = ves->tbl[*(const uint8_t*)b];
                if (i == BV)
                        return (b);
                if (*b == '=' && ves->n < 2)
                        return (b);
                else if (*b == '=')
                        ves->f++;
                else if (ves->f)
                        return (b - 1);
                if (ves->f && ves->w)
                        return (b - 1);
                switch(++ves->n) {
                case 1:
                        ves->w = i << 2;
                        break;
                case 2:
                        ves->w |= i >> 4;
                        VSB_putc(ves->vsb, ves->w);
                        ves->w = i << 4;
                        break;
                case 3:
                        ves->w |= i >> 2;
                        if (!ves->f)
                                VSB_putc(ves->vsb, ves->w);
                        ves->w = i << 6;
                        break;
                case 4:
                        ves->w |= i;
                        if (!ves->f)
                                VSB_putc(ves->vsb, ves->w);
                        ves->w = 0;
                        ves->n = 0;
                        break;
                default:
                        WRONG("Wrong turn in venc_decode_base64()");
                }
        }
        return (NULL);
}

/*
 * Decode base64 (RFC4648 section 4) into VSB.
 *
 * Returns NULL on success.
 * Returns pointer to offending input character on failure.
 */

const char *
VENC_Decode_Base64(struct vsb *dst, const char *b, const char *e)
{
        struct venc_state ves;
        const char *rv;

        memset(&ves, 0, sizeof ves);
        ves.vsb = dst;
        ves.tbl = base64_dec;

        rv = venc_decode_base64(&ves, b, e);
        if (rv)
                return (rv);
        if (ves.n)
                return (e);
        return (NULL);
}

		varnish-cache/lib/libvarnish/venc.c
0		/*-
1		* Copyright (c) 2020 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*
29		*/
30
31		#include "config.h"
32
33		#include <stdint.h>
34		#include <string.h>
35		#include <sys/types.h>
36
37		#include "vdef.h"
38		#include "vas.h"
39		#include "vrt.h"
40		#include "venc.h"
41
42		#include "vsb.h"
43
44		/*
45		* Yes: Cumbersome. But if "..." syntax is used, C adds a NUL
46		*/
47
48		static const char base64_enc[64] = {
49		'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
50		'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
51		'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
52		'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
53		'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
54		'o', 'p', 'r', 'q', 's', 't', 'u', 'v',
55		'w', 'x', 'y', 'z', '0', '1', '2', '3',
56		'4', '5', '6', '7', '8', '9', '+', '/'
57		};
58
59		/*
60		* Encode base64 (RFC4648 section 4) into VSB.
61		*/
62
63		void
64	272	VENC_Encode_Base64(struct vsb dst, const void src, size_t len)
65		{
66	272	const uint8_t *p = src;
67		uint32_t u;
68		char w[4];
69
70	272	AN(dst);
71	272	AN(src);
72	1819	for (; len >= 3; len -= 3, p += 3) {
73	1547	u = (p[0] << 16) \| (p[1] << 8) \| p[2];
74	1547	w[3] = base64_enc[u & 0x3f];
75	1547	u >>= 6;
76	1547	w[2] = base64_enc[u & 0x3f];
77	1547	u >>= 6;
78	1547	w[1] = base64_enc[u & 0x3f];
79	1547	u >>= 6;
80	1547	w[0] = base64_enc[u & 0x3f];
81	1547	if (VSB_bcat(dst, w, sizeof w))
82	0	break;
83	1547	}
84	272	if (len) {
85	272	memset(w, '=', sizeof w);
86	272	u = (p[0] << 16);
87	272	if (len == 2)
88	221	u \|= (p[1] << 8);
89	272	w[0] = base64_enc[(u >> 18) & 0x3f];
90	272	w[1] = base64_enc[(u >> 12) & 0x3f];
91	272	if (len == 2)
92	221	w[2] = base64_enc[(u >> 6) & 0x3f];
93	272	VSB_bcat(dst, w, sizeof w);
94	272	}
95	272	}
96
97		#define BV 64
98
99		static const uint8_t base64_dec[256] = {
100		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
101		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
102		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, 62, BV, BV, BV, 63,
103		52, 53, 54, 55, 56, 57, 58, 59, 60, 61, BV, BV, BV, 0, BV, BV,
104		BV, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
105		15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, BV, BV, BV, BV, BV,
106		BV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
107		41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, BV, BV, BV, BV, BV,
108		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
109		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
110		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
111		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
112		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
113		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
114		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV,
115		BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV, BV
116		};
117
118		struct venc_state {
119		unsigned n;
120		unsigned f;
121		uint8_t w;
122		struct vsb *vsb;
123		const uint8_t *tbl;
124		};
125
126		static const char *
127	357	venc_decode_base64(struct venc_state ves, const char b, const char *e)
128		{
129		unsigned i;
130
131	357	AN(ves);
132	357	AN(ves->vsb);
133	357	AN(ves->tbl);
134
135	357	AN(b);
136	357	if (e == NULL)
137	0	e = strchr(b, '\0');
138	357	assert(e >= b);
139
140	4624	for (; b < e; b++) {
141	4454	i = ves->tbl[(const uint8_t)b];
142	4454	if (i == BV)
143	119	return (b);
144	4335	if (*b == '=' && ves->n < 2)
145	51	return (b);
146	4284	else if (*b == '=')
147	170	ves->f++;
148	4114	else if (ves->f)
149	0	return (b - 1);
150	4284	if (ves->f && ves->w)
151	17	return (b - 1);
152	4267	switch(++ves->n) {
153		case 1:
154	1122	ves->w = i << 2;
155	1122	break;
156		case 2:
157	1088	ves->w \|= i >> 4;
158	1088	VSB_putc(ves->vsb, ves->w);
159	1088	ves->w = i << 4;
160	1088	break;
161		case 3:
162	1037	ves->w \|= i >> 2;
163	1037	if (!ves->f)
164	986	VSB_putc(ves->vsb, ves->w);
165	1037	ves->w = i << 6;
166	1037	break;
167		case 4:
168	1020	ves->w \|= i;
169	1020	if (!ves->f)
170	918	VSB_putc(ves->vsb, ves->w);
171	1020	ves->w = 0;
172	1020	ves->n = 0;
173	1020	break;
174		default:
175	0	WRONG("Wrong turn in venc_decode_base64()");
176	0	}
177	4267	}
178	170	return (NULL);
179	357	}
180
181		/*
182		* Decode base64 (RFC4648 section 4) into VSB.
183		*
184		* Returns NULL on success.
185		* Returns pointer to offending input character on failure.
186		*/
187
188		const char *
189	357	VENC_Decode_Base64(struct vsb dst, const char b, const char *e)
190		{
191		struct venc_state ves;
192		const char *rv;
193
194	357	memset(&ves, 0, sizeof ves);
195	357	ves.vsb = dst;
196	357	ves.tbl = base64_dec;
197
198	357	rv = venc_decode_base64(&ves, b, e);
199	357	if (rv)
200	187	return (rv);
201	170	if (ves.n)
202	0	return (e);
203	170	return (NULL);
204	357	}