varnish-cache/vmod/vmod_blob_url.c
1
/*-
2
 * Copyright 2015-2016 UPLEX - Nils Goroll Systemoptimierung
3
 * All rights reserved.
4
 *
5
 * Authors: Nils Goroll <nils.goroll@uplex.de>
6
 *          Geoffrey Simmons <geoffrey.simmons@uplex.de>
7
 *
8
 * SPDX-License-Identifier: BSD-2-Clause
9
 *
10
 * Redistribution and use in source and binary forms, with or without
11
 * modification, are permitted provided that the following conditions are met:
12
 * 1. Redistributions of source code must retain the above copyright notice,
13
 *    this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright notice,
15
 *    this list of conditions and the following disclaimer in the documentation
16
 *    and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY
19
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21
 * DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY
22
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
27
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
 *
29
 */
30
31
#include "config.h"
32
33
#include "vdef.h"
34
#include "vrt.h"
35
#include "vas.h"
36
37
#include "vmod_blob.h"
38
39
/* Decoder states */
40
enum state_e {
41
        NORMAL,
42
        PERCENT,  /* just read '%' */
43
        FIRSTNIB, /* just read the first nibble after '%' */
44
};
45
46
size_t
47 280
url_encode_l(size_t l)
48
{
49 280
        return ((l * 3) + 1);
50
}
51
52
size_t
53 1340
url_decode_l(size_t l)
54
{
55 1340
        return (l);
56
}
57
58
/*
59
 * Bitmap of unreserved characters according to RFC 3986 section 2.3
60
 * (locale-independent and cacheline friendly)
61
 */
62
static const uint8_t unreserved[] = {
63
        0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0xff, 0x03,
64
        0xfe, 0xff, 0xff, 0x87, 0xfe, 0xff, 0xff, 0x47,
65
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
66
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
67
};
68
69
static inline int
70 192020
isunreserved(const uint8_t c)
71
{
72 192020
        return (unreserved[c >> 3] & (1 << (c & 7)));
73
}
74
75
static inline int
76 264560
isoutofrange(const uint8_t c)
77
{
78 264560
        return (c < '0' || c > 'f');
79
}
80
81
ssize_t
82 1860
url_encode(const enum encoding enc, const enum case_e kase,
83
    blob_dest_t buf, blob_len_t buflen,
84
    blob_src_t in, blob_len_t inlen)
85
{
86 1860
        char *p = buf;
87 1860
        const char * const end = buf + buflen;
88 1860
        const char *alphabet = hex_alphabet[0];
89
        size_t i;
90
91 1860
        AN(buf);
92 1860
        assert(enc == URL);
93 1860
        if (in == NULL || inlen == 0)
94 60
                return (0);
95
96 1800
        if (kase == UPPER)
97 640
                alphabet = hex_alphabet[1];
98
99 193820
        for (i = 0; i < inlen; i++) {
100 192020
                if (isunreserved(in[i])) {
101 65320
                        if (p == end)
102 0
                                return (-1);
103 65320
                        *p++ = in[i];
104 65320
                }
105
                else {
106 126700
                        if (p + 3 > end)
107 0
                                return (-1);
108 126700
                        *p++ = '%';
109 126700
                        *p++ = alphabet[(in[i] & 0xf0) >> 4];
110 126700
                        *p++ = alphabet[in[i] & 0x0f];
111
                }
112 192020
        }
113
114 1800
        return (p - buf);
115 1860
}
116
117
ssize_t
118 2340
url_decode(const enum encoding dec, blob_dest_t buf,
119
    blob_len_t buflen, ssize_t n, VCL_STRANDS strings)
120
{
121 2340
        char *dest = buf;
122 2340
        const char * const end = buf + buflen;
123
        const char *s;
124 2340
        size_t len = SIZE_MAX;
125 2340
        uint8_t nib = 0, nib2;
126 2340
        enum state_e state = NORMAL;
127
        int i;
128
129 2340
        AN(buf);
130 2340
        AN(strings);
131 2340
        assert(dec == URL);
132
133 2340
        if (n >= 0)
134 1060
                len = n;
135
136 5360
        for (i = 0; len > 0 && i < strings->n; i++) {
137 3160
                s = strings->p[i];
138
139 3160
                if (s == NULL || *s == '\0')
140 640
                        continue;
141 468740
                while (*s && len) {
142 466360
                        switch (state) {
143
                        case NORMAL:
144 201800
                                if (*s == '%')
145 132460
                                        state = PERCENT;
146
                                else {
147 69340
                                        if (dest == end) {
148 20
                                                errno = ENOMEM;
149 20
                                                return (-1);
150
                                        }
151 69320
                                        *dest++ = *s;
152
                                }
153 201780
                                break;
154
                        case PERCENT:
155 132360
                                if (isoutofrange(*s) ||
156 132300
                                    (nib = hex_nibble[*s - '0']) == ILL) {
157 60
                                        errno = EINVAL;
158 60
                                        return (-1);
159
                                }
160 132300
                                state = FIRSTNIB;
161 132300
                                break;
162
                        case FIRSTNIB:
163 132200
                                if (dest == end) {
164 0
                                        errno = ENOMEM;
165 0
                                        return (-1);
166
                                }
167 132200
                                if (isoutofrange(*s) ||
168 132140
                                    (nib2 = hex_nibble[*s - '0']) == ILL) {
169 60
                                        errno = EINVAL;
170 60
                                        return (-1);
171
                                }
172 132140
                                *dest++ = (nib << 4) | nib2;
173 132140
                                nib = 0;
174 132140
                                state = NORMAL;
175 132140
                                break;
176
                        default:
177 0
                                WRONG("illegal URL decode state");
178 0
                        }
179 466220
                        s++;
180 466220
                        len--;
181
                }
182 2380
        }
183 2200
        if (state != NORMAL) {
184 200
                errno = EINVAL;
185 200
                return (-1);
186
        }
187 2000
        assert(dest <= end);
188 2000
        return (dest - buf);
189 2340
}