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