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', 'q', 'r', '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);
}

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