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	640	VENC_Encode_Base64(struct vsb dst, const void src, size_t len)
65		{
66	640	const uint8_t *p = src;
67		uint32_t u;
68		char w[4];
69
70	640	AN(dst);
71	640	AN(src);
72	4280	for (; len >= 3; len -= 3, p += 3) {
73	3640	u = (p[0] << 16) \| (p[1] << 8) \| p[2];
74	3640	w[3] = base64_enc[u & 0x3f];
75	3640	u >>= 6;
76	3640	w[2] = base64_enc[u & 0x3f];
77	3640	u >>= 6;
78	3640	w[1] = base64_enc[u & 0x3f];
79	3640	u >>= 6;
80	3640	w[0] = base64_enc[u & 0x3f];
81	3640	if (VSB_bcat(dst, w, sizeof w))
82	0	break;
83	3640	}
84	640	if (len) {
85	640	memset(w, '=', sizeof w);
86	640	u = (p[0] << 16);
87	640	if (len == 2)
88	520	u \|= (p[1] << 8);
89	640	w[0] = base64_enc[(u >> 18) & 0x3f];
90	640	w[1] = base64_enc[(u >> 12) & 0x3f];
91	640	if (len == 2)
92	520	w[2] = base64_enc[(u >> 6) & 0x3f];
93	640	VSB_bcat(dst, w, sizeof w);
94	640	}
95	640	}
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	840	venc_decode_base64(struct venc_state ves, const char b, const char *e)
128		{
129		unsigned i;
130
131	840	AN(ves);
132	840	AN(ves->vsb);
133	840	AN(ves->tbl);
134
135	840	AN(b);
136	840	if (e == NULL)
137	0	e = strchr(b, '\0');
138	840	assert(e >= b);
139
140	10880	for (; b < e; b++) {
141	10480	i = ves->tbl[(const uint8_t)b];
142	10480	if (i == BV)
143	280	return (b);
144	10200	if (*b == '=' && ves->n < 2)
145	120	return (b);
146	10080	else if (*b == '=')
147	400	ves->f++;
148	9680	else if (ves->f)
149	0	return (b - 1);
150	10080	if (ves->f && ves->w)
151	40	return (b - 1);
152	10040	switch(++ves->n) {
153		case 1:
154	2640	ves->w = i << 2;
155	2640	break;
156		case 2:
157	2560	ves->w \|= i >> 4;
158	2560	VSB_putc(ves->vsb, ves->w);
159	2560	ves->w = i << 4;
160	2560	break;
161		case 3:
162	2440	ves->w \|= i >> 2;
163	2440	if (!ves->f)
164	2320	VSB_putc(ves->vsb, ves->w);
165	2440	ves->w = i << 6;
166	2440	break;
167		case 4:
168	2400	ves->w \|= i;
169	2400	if (!ves->f)
170	2160	VSB_putc(ves->vsb, ves->w);
171	2400	ves->w = 0;
172	2400	ves->n = 0;
173	2400	break;
174		default:
175	0	WRONG("Wrong turn in venc_decode_base64()");
176	0	}
177	10040	}
178	400	return (NULL);
179	840	}
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	840	VENC_Decode_Base64(struct vsb dst, const char b, const char *e)
190		{
191		struct venc_state ves;
192		const char *rv;
193
194	840	memset(&ves, 0, sizeof ves);
195	840	ves.vsb = dst;
196	840	ves.tbl = base64_dec;
197
198	840	rv = venc_decode_base64(&ves, b, e);
199	840	if (rv)
200	440	return (rv);
201	400	if (ves.n)
202	0	return (e);
203	400	return (NULL);
204	840	}