Apache HTTPD
apr_encode.c
Go to the documentation of this file.
1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements. See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License. You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17/* encode/decode functions.
18 *
19 * These functions perform various encoding operations, and are provided in
20 * pairs, a function to query the length of and encode existing buffers, as
21 * well as companion functions to perform the same process to memory
22 * allocated from a pool.
23 *
24 * The API is designed to have the smallest possible RAM footprint, and so
25 * will only allocate the exact amount of RAM needed for each conversion.
26 */
27
28#include "apr_encode.h"
29#include "apr_lib.h"
30#include "apr_strings.h"
31#include "apr_encode_private.h"
32
33/* lookup table: fast and const should make it shared text page. */
34static const unsigned char pr2six[256] =
35{
36#if !APR_CHARSET_EBCDIC
37 /* ASCII table */
38 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
39 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
40 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 62, 64, 63,
41 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 128, 64, 64,
42 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
43 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 63,
44 64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
45 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
46 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
47 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
48 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
49 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
50 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
51 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
52 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
53 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
54#else /* APR_CHARSET_EBCDIC */
55 /* EBCDIC table */
56 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
57 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
58 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
59 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
60 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64,
61 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
62 62, 63, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 63, 64, 64,
63 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 128, 64,
64 64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 64, 64, 64, 64, 64, 64,
65 64, 35, 36, 37, 38, 39, 40, 41, 42, 43, 64, 64, 64, 64, 64, 64,
66 64, 64, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64, 64,
67 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
68 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 64, 64, 64, 64, 64, 64,
69 64, 9, 10, 11, 12, 13, 14, 15, 16, 17, 64, 64, 64, 64, 64, 64,
70 64, 64, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64, 64,
71 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64
72#endif /* APR_CHARSET_EBCDIC */
73};
74
75static const unsigned char pr2five[256] =
76{
77#if !APR_CHARSET_EBCDIC
78 /* ASCII table */
79 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
80 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
81 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
82 32, 32, 26, 27, 28, 29, 30, 31, 32, 32, 32, 32, 32, 128, 32, 32,
83 32, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
84 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 32, 32, 32, 32, 32,
85 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
86 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
87 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
88 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
89 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
90 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
91 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
92 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
93 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
94 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
95#else /* APR_CHARSET_EBCDIC */
96 /* EBCDIC table */
97 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
98 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
99 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
100 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
101 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
102 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
103 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
104 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 128, 32,
105 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
106 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
107 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
108 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
109 32, 0, 1, 2, 3, 4, 5, 6, 7, 8, 32, 32, 32, 32, 32, 32,
110 32, 9, 10, 11, 12, 13, 14, 15, 16, 17, 32, 32, 32, 32, 32, 32,
111 32, 32, 18, 19, 20, 21, 22, 23, 24, 25, 32, 32, 32, 32, 32, 32,
112 32, 32, 26, 27, 28, 29, 30, 31, 32, 32, 32, 32, 32, 32, 32, 32
113#endif /* APR_CHARSET_EBCDIC */
114};
115
116static const unsigned char pr2fivehex[256] =
117{
118#if !APR_CHARSET_EBCDIC
119 /* ASCII table */
120 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
121 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
122 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
123 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 32, 32, 32, 128, 32, 32,
124 32, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
125 25, 26, 27, 28, 29, 30, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32,
126 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
127 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
128 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
129 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
130 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
131 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
132 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
133 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
134 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
135 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32
136#else /* APR_CHARSET_EBCDIC */
137 /* EBCDIC table */
138 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
139 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
140 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
141 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
142 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
143 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
144 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
145 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 128, 32,
146 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
147 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
148 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
149 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
150 32, 10, 11, 12, 13, 14, 15, 16, 17, 18, 32, 32, 32, 32, 32, 32,
151 32, 19, 20, 21, 22, 23, 24, 25, 26, 27, 32, 32, 32, 32, 32, 32,
152 32, 32, 28, 29, 30, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
153 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 32, 32, 32, 32, 32, 32
154#endif /* APR_CHARSET_EBCDIC */
155};
156
157static const unsigned char pr2two[256] =
158{
159#if !APR_CHARSET_EBCDIC
160 /* ASCII table */
161 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
162 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
163 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
164 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 32, 16, 16, 16, 16, 16,
165 16, 10, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16,
166 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
167 16, 10, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16,
168 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
169 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
170 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
171 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
172 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
173 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
174 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
175 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
176 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16
177#else /* APR_CHARSET_EBCDIC */
178 /* EBCDIC table */
179 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
180 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
181 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
182 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
183 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
184 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
185 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
186 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 32, 16, 16, 16, 16, 16,
187 16, 10, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16,
188 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
189 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
190 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
191 16, 10, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16,
192 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
193 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
194 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 16, 16, 16, 16, 16, 16
195#endif /* APR_CHARSET_EBCDIC */
196};
197
198static const char base64[] =
199"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
200static const char base64url[] =
201"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
202
203static const char base32[] =
204"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
205static const char base32hex[] =
206"0123456789ABCDEFGHIJKLMNOPQRSTUV";
207
208static const char base16[] = "0123456789ABCDEF";
209static const char base16lower[] = "0123456789abcdef";
210
211APR_DECLARE(apr_status_t) apr_encode_base64(char *dest, const char *src,
212 apr_ssize_t slen, int flags, apr_size_t * len)
213{
214 apr_status_t status = APR_SUCCESS;
215 apr_size_t count = slen, dlen = 0;
216 const char *base;
217
218 if (src && slen == APR_ENCODE_STRING) {
219 count = strlen(src);
220 }
221 else if (slen < 0 || (dest && !src)) {
222 return (src) ? APR_EINVAL : APR_NOTFOUND;
223 }
224
225 if (dest) {
226 char *bufout = dest;
227 apr_size_t i = 0;
228
229 if (0 == ((flags & APR_ENCODE_BASE64URL))) {
230 base = base64;
231 }
232 else {
233 base = base64url;
234 }
235
236 if (count > 2) {
237 for (; i < count - 2; i += 3) {
238 *bufout++ = base[(TO_ASCII(src[i]) >> 2) & 0x3F];
239 *bufout++ = base[((TO_ASCII(src[i]) & 0x3) << 4 |
240 (TO_ASCII(src[i + 1]) & 0xF0) >> 4)];
241 *bufout++ = base[((TO_ASCII(src[i + 1]) & 0xF) << 2 |
242 (TO_ASCII(src[i + 2]) & 0xC0) >> 6)];
243 *bufout++ = base[TO_ASCII(src[i + 2]) & 0x3F];
244 }
245 }
246 if (i < count) {
247 *bufout++ = base[(TO_ASCII(src[i]) >> 2) & 0x3F];
248 if (i == (count - 1)) {
249 *bufout++ = base[(TO_ASCII(src[i]) & 0x3) << 4];
250 if (!(flags & APR_ENCODE_NOPADDING)) {
251 *bufout++ = '=';
252 }
253 }
254 else {
255 *bufout++ = base[((TO_ASCII(src[i]) & 0x3) << 4 |
256 (TO_ASCII(src[i + 1]) & 0xF0) >> 4)];
257 *bufout++ = base[(TO_ASCII(src[i + 1]) & 0xF) << 2];
258 }
259 if (!(flags & APR_ENCODE_NOPADDING)) {
260 *bufout++ = '=';
261 }
262 }
263
264 dlen = bufout - dest;
265 dest[dlen] = '\0';
266 }
267 else {
268 dlen = ((count + 2u) / 3u) * 4u + 1u;
269 if (dlen <= count) {
270 status = APR_ENOSPC;
271 }
272 }
273
274 if (len) {
275 *len = dlen;
276 }
277 return status;
278}
279
280APR_DECLARE(apr_status_t) apr_encode_base64_binary(char *dest, const unsigned char *src,
281 apr_ssize_t slen, int flags, apr_size_t * len)
282{
283 apr_status_t status = APR_SUCCESS;
284 apr_size_t count = slen, dlen = 0;
285 const char *base;
286
287 if (slen < 0 || (dest && !src)) {
288 return (src) ? APR_EINVAL : APR_NOTFOUND;
289 }
290
291 if (dest) {
292 char *bufout = dest;
293 apr_size_t i = 0;
294
295 if (0 == ((flags & APR_ENCODE_BASE64URL))) {
296 base = base64;
297 }
298 else {
299 base = base64url;
300 }
301
302 if (count > 2) {
303 for (; i < count - 2; i += 3) {
304 *bufout++ = base[(src[i] >> 2) & 0x3F];
305 *bufout++ = base[((src[i] & 0x3) << 4 |
306 (src[i + 1] & 0xF0) >> 4)];
307 *bufout++ = base[((src[i + 1] & 0xF) << 2 |
308 (src[i + 2] & 0xC0) >> 6)];
309 *bufout++ = base[src[i + 2] & 0x3F];
310 }
311 }
312 if (i < count) {
313 *bufout++ = base[(src[i] >> 2) & 0x3F];
314 if (i == (count - 1)) {
315 *bufout++ = base[((src[i] & 0x3) << 4)];
316 if (!(flags & APR_ENCODE_NOPADDING)) {
317 *bufout++ = '=';
318 }
319 }
320 else {
321 *bufout++ = base[((src[i] & 0x3) << 4 |
322 (src[i + 1] & 0xF0) >> 4)];
323 *bufout++ = base[(src[i + 1] & 0xF) << 2];
324 }
325 if (!(flags & APR_ENCODE_NOPADDING)) {
326 *bufout++ = '=';
327 }
328 }
329
330 dlen = bufout - dest;
331 dest[dlen] = '\0';
332 }
333 else {
334 dlen = ((count + 2u) / 3u) * 4u + 1u;
335 if (dlen <= count) {
336 status = APR_ENOSPC;
337 }
338 }
339
340 if (len) {
341 *len = dlen;
342 }
343 return status;
344}
345
346APR_DECLARE(const char *)apr_pencode_base64(apr_pool_t * p, const char *src,
347 apr_ssize_t slen, int flags, apr_size_t * len)
348{
349 apr_size_t size;
350
351 if (!src) {
352 return NULL;
353 }
354
355 switch (apr_encode_base64(NULL, src, slen, flags, &size)) {
356 case APR_SUCCESS:{
357 char *cmd = apr_palloc(p, size);
358 if (cmd) {
359 apr_encode_base64(cmd, src, slen, flags, len);
360 }
361 return cmd;
362 }
363 default:{
364 break;
365 }
366 }
367
368 return NULL;
369}
370
371APR_DECLARE(const char *)apr_pencode_base64_binary(apr_pool_t * p, const unsigned char *src,
372 apr_ssize_t slen, int flags, apr_size_t * len)
373{
374 apr_size_t size;
375
376 if (!src) {
377 return NULL;
378 }
379
380 switch (apr_encode_base64_binary(NULL, src, slen, flags, &size)) {
381 case APR_SUCCESS:{
382 char *cmd = apr_palloc(p, size);
383 if (cmd) {
384 apr_encode_base64_binary(cmd, src, slen, flags, len);
385 }
386 return cmd;
387 }
388 default:{
389 break;
390 }
391 }
392
393 return NULL;
394}
395
396APR_DECLARE(apr_status_t) apr_decode_base64(char *dest, const char *src,
397 apr_ssize_t slen, int flags, apr_size_t * len)
398{
399 apr_status_t status = APR_SUCCESS;
400 apr_size_t count = slen, dlen = 0;
401
402 if (src && slen == APR_ENCODE_STRING) {
403 count = strlen(src);
404 }
405 else if (slen < 0 || (dest && !src)) {
406 return (src) ? APR_EINVAL : APR_NOTFOUND;
407 }
408
409 if (src) {
410 const unsigned char *bufin;
411
412 bufin = (const unsigned char *)src;
413 while (count) {
414 if (pr2six[*bufin] >= 64) {
415 if (!(flags & APR_ENCODE_RELAXED)) {
416 if (count <= 2) {
417 do {
418 if (pr2six[bufin[count - 1]] <= 64)
419 break;
420 } while (--count);
421 }
422 if (count) {
423 status = APR_BADCH;
424 }
425 }
426 break;
427 }
428 count--;
429 bufin++;
430 }
431 count = bufin - (const unsigned char *)src;
432
433 if (dest) {
434 unsigned char *bufout;
435
436 bufout = (unsigned char *)dest;
437 bufin = (const unsigned char *)src;
438
439 while (count >= 4) {
440 *(bufout++) = TO_NATIVE(pr2six[bufin[0]] << 2 |
441 pr2six[bufin[1]] >> 4);
442 *(bufout++) = TO_NATIVE(pr2six[bufin[1]] << 4 |
443 pr2six[bufin[2]] >> 2);
444 *(bufout++) = TO_NATIVE(pr2six[bufin[2]] << 6 |
445 pr2six[bufin[3]]);
446 bufin += 4;
447 count -= 4;
448 }
449
450 if (count == 1) {
451 status = APR_EINCOMPLETE;
452 }
453 if (count > 1) {
454 *(bufout++) = TO_NATIVE(pr2six[bufin[0]] << 2 |
455 pr2six[bufin[1]] >> 4);
456 }
457 if (count > 2) {
458 *(bufout++) = TO_NATIVE(pr2six[bufin[1]] << 4 |
459 pr2six[bufin[2]] >> 2);
460 }
461
462 dlen = bufout - (unsigned char *)dest;
463 dest[dlen] = '\0';
464 }
465 }
466
467 if (!src || !dest) {
468 dlen = (count / 4u) * 3u + 1u;
469 switch (count % 4) {
470 case 3:
471 dlen += 2;
472 break;
473 case 2:
474 dlen++;
475 break;
476 case 1:
477 status = APR_EINCOMPLETE;
478 break;
479 }
480 }
481
482 if (len) {
483 *len = dlen;
484 }
485 return status;
486}
487
488APR_DECLARE(apr_status_t) apr_decode_base64_binary(unsigned char *dest,
489 const char *src, apr_ssize_t slen, int flags, apr_size_t * len)
490{
491 apr_status_t status = APR_SUCCESS;
492 apr_size_t count = slen, dlen = 0;
493
494 if (src && slen == APR_ENCODE_STRING) {
495 count = strlen(src);
496 }
497 else if (slen < 0 || (dest && !src)) {
498 return (src) ? APR_EINVAL : APR_NOTFOUND;
499 }
500
501 if (src) {
502 const unsigned char *bufin;
503
504 bufin = (const unsigned char *)src;
505 while (count) {
506 if (pr2six[*bufin] >= 64) {
507 if (!(flags & APR_ENCODE_RELAXED)) {
508 if (count <= 2) {
509 do {
510 if (pr2six[bufin[count - 1]] <= 64)
511 break;
512 } while (--count);
513 }
514 if (count) {
515 status = APR_BADCH;
516 }
517 }
518 break;
519 }
520 count--;
521 bufin++;
522 }
523 count = bufin - (const unsigned char *)src;
524
525 if (dest) {
526 unsigned char *bufout;
527
528 bufout = (unsigned char *)dest;
529 bufin = (const unsigned char *)src;
530
531 while (count >= 4) {
532 *(bufout++) = (pr2six[bufin[0]] << 2 |
533 pr2six[bufin[1]] >> 4);
534 *(bufout++) = (pr2six[bufin[1]] << 4 |
535 pr2six[bufin[2]] >> 2);
536 *(bufout++) = (pr2six[bufin[2]] << 6 |
537 pr2six[bufin[3]]);
538 bufin += 4;
539 count -= 4;
540 }
541
542 if (count == 1) {
543 status = APR_EINCOMPLETE;
544 }
545 if (count > 1) {
546 *(bufout++) = (pr2six[bufin[0]] << 2 |
547 pr2six[bufin[1]] >> 4);
548 }
549 if (count > 2) {
550 *(bufout++) = (pr2six[bufin[1]] << 4 |
551 pr2six[bufin[2]] >> 2);
552 }
553
554 dlen = bufout - dest;
555 }
556 }
557
558 if (!src || !dest) {
559 dlen = (count / 4u) * 3u;
560 switch (count % 4) {
561 case 3:
562 dlen += 2;
563 break;
564 case 2:
565 dlen++;
566 break;
567 case 1:
568 status = APR_EINCOMPLETE;
569 break;
570 }
571 }
572
573 if (len) {
574 *len = dlen;
575 }
576 return status;
577}
578
579APR_DECLARE(const char *)apr_pdecode_base64(apr_pool_t * p, const char *str,
580 apr_ssize_t slen, int flags, apr_size_t * len)
581{
582 apr_size_t size;
583
584 if (!str) {
585 return NULL;
586 }
587
588 switch (apr_decode_base64(NULL, str, slen, flags, &size)) {
589 case APR_SUCCESS:{
590 void *cmd = apr_palloc(p, size);
591 if (cmd) {
592 apr_decode_base64(cmd, str, slen, flags, len);
593 }
594 return cmd;
595 }
596 default:{
597 break;
598 }
599 }
600
601 return NULL;
602}
603
604APR_DECLARE(const unsigned char *)apr_pdecode_base64_binary(apr_pool_t * p,
605 const char *str, apr_ssize_t slen, int flags, apr_size_t * len)
606{
607 apr_size_t size;
608
609 if (!str) {
610 return NULL;
611 }
612
613 switch (apr_decode_base64_binary(NULL, str, slen, flags, &size)) {
614 case APR_SUCCESS:{
615 unsigned char *cmd = apr_palloc(p, size + 1);
616 if (cmd) {
617 apr_decode_base64_binary(cmd, str, slen, flags, len);
618 cmd[size] = 0;
619 }
620 return cmd;
621 }
622 default:{
623 break;
624 }
625 }
626
627 return NULL;
628}
629
630APR_DECLARE(apr_status_t) apr_encode_base32(char *dest, const char *src,
631 apr_ssize_t slen, int flags, apr_size_t * len)
632{
633 apr_status_t status = APR_SUCCESS;
634 apr_size_t count = slen, dlen = 0;
635 const char *base;
636
637 if (src && slen == APR_ENCODE_STRING) {
638 count = strlen(src);
639 }
640 else if (slen < 0 || (dest && !src)) {
641 return (src) ? APR_EINVAL : APR_NOTFOUND;
642 }
643
644 if (dest) {
645 char *bufout = dest;
646 apr_size_t i = 0;
647
648 if (!((flags & APR_ENCODE_BASE32HEX))) {
649 base = base32;
650 }
651 else {
652 base = base32hex;
653 }
654
655 if (count > 4) {
656 for (; i < count - 4; i += 5) {
657 *bufout++ = base[(TO_ASCII(src[i]) >> 3) & 0x1F];
658 *bufout++ = base[(((TO_ASCII(src[i]) << 2) & 0x1C) |
659 ((TO_ASCII(src[i + 1]) >> 6) & 0x3))];
660 *bufout++ = base[(TO_ASCII(src[i + 1]) >> 1) & 0x1F];
661 *bufout++ = base[(((TO_ASCII(src[i + 1]) << 4) & 0x10) |
662 ((TO_ASCII(src[i + 2]) >> 4) & 0xF))];
663 *bufout++ = base[(((TO_ASCII(src[i + 2]) << 1) & 0x1E) |
664 ((TO_ASCII(src[i + 3]) >> 7) & 0x1))];
665 *bufout++ = base[(TO_ASCII(src[i + 3]) >> 2) & 0x1F];
666 *bufout++ = base[(((TO_ASCII(src[i + 3]) << 3) & 0x18) |
667 ((TO_ASCII(src[i + 4]) >> 5) & 0x7))];
668 *bufout++ = base[TO_ASCII(src[i + 4]) & 0x1F];
669 }
670 }
671 if (i < count) {
672 *bufout++ = base[(TO_ASCII(src[i]) >> 3) & 0x1F];
673 if (i == (count - 1)) {
674 *bufout++ = base[(TO_ASCII(src[i]) << 2) & 0x1C];
675 if (!(flags & APR_ENCODE_NOPADDING)) {
676 *bufout++ = '=';
677 *bufout++ = '=';
678 *bufout++ = '=';
679 *bufout++ = '=';
680 *bufout++ = '=';
681 *bufout++ = '=';
682 }
683 }
684 else if (i == (count - 2)) {
685 *bufout++ = base[(((TO_ASCII(src[i]) << 2) & 0x1C) |
686 ((TO_ASCII(src[i + 1]) >> 6) & 0x3))];
687 *bufout++ = base[(TO_ASCII(src[i + 1]) >> 1) & 0x1F];
688 *bufout++ = base[(TO_ASCII(src[i + 1]) << 4) & 0x10];
689 if (!(flags & APR_ENCODE_NOPADDING)) {
690 *bufout++ = '=';
691 *bufout++ = '=';
692 *bufout++ = '=';
693 *bufout++ = '=';
694 }
695 }
696 else if (i == (count - 3)) {
697 *bufout++ = base[(((TO_ASCII(src[i]) << 2) & 0x1C) |
698 ((TO_ASCII(src[i + 1]) >> 6) & 0x3))];
699 *bufout++ = base[(TO_ASCII(src[i + 1]) >> 1) & 0x1F];
700 *bufout++ = base[(((TO_ASCII(src[i + 1]) << 4) & 0x10) |
701 ((TO_ASCII(src[i + 2]) >> 4) & 0xF))];
702 *bufout++ = base[(TO_ASCII(src[i + 2]) << 1) & 0x1E];
703 if (!(flags & APR_ENCODE_NOPADDING)) {
704 *bufout++ = '=';
705 *bufout++ = '=';
706 *bufout++ = '=';
707 }
708 }
709 else {
710 *bufout++ = base[(((TO_ASCII(src[i]) << 2) & 0x1C) |
711 ((TO_ASCII(src[i + 1]) >> 6) & 0x3))];
712 *bufout++ = base[(TO_ASCII(src[i + 1]) >> 1) & 0x1F];
713 *bufout++ = base[(((TO_ASCII(src[i + 1]) << 4) & 0x10) |
714 ((TO_ASCII(src[i + 2]) >> 4) & 0xF))];
715 *bufout++ = base[(((TO_ASCII(src[i + 2]) << 1) & 0x1E) |
716 ((TO_ASCII(src[i + 3]) >> 7) & 0x1))];
717 *bufout++ = base[(TO_ASCII(src[i + 3]) >> 2) & 0x1F];
718 *bufout++ = base[(TO_ASCII(src[i + 3]) << 3) & 0x18];
719 if (!(flags & APR_ENCODE_NOPADDING)) {
720 *bufout++ = '=';
721 }
722 }
723 }
724
725 dlen = bufout - dest;
726 dest[dlen] = '\0';
727 }
728 else {
729 dlen = ((count + 4u) / 5u) * 8u + 1u;
730 if (dlen <= count) {
731 status = APR_ENOSPC;
732 }
733 }
734
735 if (len) {
736 *len = dlen;
737 }
738 return status;
739}
740
741APR_DECLARE(apr_status_t) apr_encode_base32_binary(char *dest, const unsigned char *src,
742 apr_ssize_t slen, int flags, apr_size_t * len)
743{
744 apr_status_t status = APR_SUCCESS;
745 apr_size_t count = slen, dlen = 0;
746 const char *base;
747
748 if (slen < 0 || (dest && !src)) {
749 return (src) ? APR_EINVAL : APR_NOTFOUND;
750 }
751
752 if (dest) {
753 char *bufout = dest;
754 apr_size_t i = 0;
755
756 if (!((flags & APR_ENCODE_BASE32HEX))) {
757 base = base32;
758 }
759 else {
760 base = base32hex;
761 }
762
763 if (count > 4) {
764 for (; i < count - 4; i += 5) {
765 *bufout++ = base[((src[i] >> 3) & 0x1F)];
766 *bufout++ = base[(((src[i] << 2) & 0x1C) |
767 ((src[i + 1] >> 6) & 0x3))];
768 *bufout++ = base[((src[i + 1] >> 1) & 0x1F)];
769 *bufout++ = base[(((src[i + 1] << 4) & 0x10) |
770 ((src[i + 2] >> 4) & 0xF))];
771 *bufout++ = base[(((src[i + 2] << 1) & 0x1E) |
772 ((src[i + 3] >> 7) & 0x1))];
773 *bufout++ = base[((src[i + 3] >> 2) & 0x1F)];
774 *bufout++ = base[(((src[i + 3] << 3) & 0x18) |
775 ((src[i + 4] >> 5) & 0x7))];
776 *bufout++ = base[(src[i + 4] & 0x1F)];
777 }
778 }
779 if (i < count) {
780 *bufout++ = base[(src[i] >> 3) & 0x1F];
781 if (i == (count - 1)) {
782 *bufout++ = base[((src[i] << 2) & 0x1C)];
783 if (!(flags & APR_ENCODE_NOPADDING)) {
784 *bufout++ = '=';
785 *bufout++ = '=';
786 *bufout++ = '=';
787 *bufout++ = '=';
788 *bufout++ = '=';
789 *bufout++ = '=';
790 }
791 }
792 else if (i == (count - 2)) {
793 *bufout++ = base[(((src[i] << 2) & 0x1C) |
794 ((src[i + 1] >> 6) & 0x3))];
795 *bufout++ = base[((src[i + 1] >> 1) & 0x1F)];
796 *bufout++ = base[((src[i + 1] << 4) & 0x10)];
797 if (!(flags & APR_ENCODE_NOPADDING)) {
798 *bufout++ = '=';
799 *bufout++ = '=';
800 *bufout++ = '=';
801 *bufout++ = '=';
802 }
803 }
804 else if (i == (count - 3)) {
805 *bufout++ = base[(((src[i] << 2) & 0x1C) |
806 ((src[i + 1] >> 6) & 0x3))];
807 *bufout++ = base[((src[i + 1] >> 1) & 0x1F)];
808 *bufout++ = base[(((src[i + 1] << 4) & 0x10) |
809 ((src[i + 2] >> 4) & 0xF))];
810 *bufout++ = base[((src[i + 2] << 1) & 0x1E)];
811 if (!(flags & APR_ENCODE_NOPADDING)) {
812 *bufout++ = '=';
813 *bufout++ = '=';
814 *bufout++ = '=';
815 }
816 }
817 else {
818 *bufout++ = base[(((src[i] << 2) & 0x1C) |
819 ((src[i + 1] >> 6) & 0x3))];
820 *bufout++ = base[((src[i + 1] >> 1) & 0x1F)];
821 *bufout++ = base[(((src[i + 1] << 4) & 0x10) |
822 ((src[i + 2] >> 4) & 0xF))];
823 *bufout++ = base[(((src[i + 2] << 1) & 0x1E) |
824 ((src[i + 3] >> 7) & 0x1))];
825 *bufout++ = base[((src[i + 3] >> 2) & 0x1F)];
826 *bufout++ = base[((src[i + 3] << 3) & 0x18)];
827 if (!(flags & APR_ENCODE_NOPADDING)) {
828 *bufout++ = '=';
829 }
830 }
831 }
832
833 dlen = bufout - dest;
834 dest[dlen] = '\0';
835 }
836 else {
837 dlen = ((count + 4u) / 5u) * 8u + 1u;
838 if (dlen <= count) {
839 status = APR_ENOSPC;
840 }
841 }
842
843 if (len) {
844 *len = dlen;
845 }
846 return status;
847}
848
849APR_DECLARE(const char *)apr_pencode_base32(apr_pool_t * p, const char *src,
850 apr_ssize_t slen, int flags, apr_size_t * len)
851{
852 apr_size_t size;
853
854 if (!src) {
855 return NULL;
856 }
857
858 switch (apr_encode_base32(NULL, src, slen, flags, &size)) {
859 case APR_SUCCESS:{
860 char *cmd = apr_palloc(p, size);
861 if (cmd) {
862 apr_encode_base32(cmd, src, slen, flags, len);
863 }
864 return cmd;
865 }
866 default:{
867 break;
868 }
869 }
870
871 return NULL;
872}
873
874APR_DECLARE(const char *)apr_pencode_base32_binary(apr_pool_t * p, const unsigned char *src,
875 apr_ssize_t slen, int flags, apr_size_t * len)
876{
877 apr_size_t size;
878
879 if (!src) {
880 return NULL;
881 }
882
883 switch (apr_encode_base32_binary(NULL, src, slen, flags, &size)) {
884 case APR_SUCCESS:{
885 char *cmd = apr_palloc(p, size);
886 if (cmd) {
887 apr_encode_base32_binary(cmd, src, slen, flags, len);
888 }
889 return cmd;
890 }
891 default:{
892 break;
893 }
894 }
895
896 return NULL;
897}
898
899APR_DECLARE(apr_status_t) apr_decode_base32(char *dest, const char *src,
900 apr_ssize_t slen, int flags, apr_size_t * len)
901{
902 apr_status_t status = APR_SUCCESS;
903 apr_size_t count = slen, dlen = 0;
904
905 if (src && slen == APR_ENCODE_STRING) {
906 count = strlen(src);
907 }
908 else if (slen < 0 || (dest && !src)) {
909 return (src) ? APR_EINVAL : APR_NOTFOUND;
910 }
911
912 if (src) {
913 const unsigned char *bufin;
914 const unsigned char *pr2;
915
916 if ((flags & APR_ENCODE_BASE32HEX)) {
917 pr2 = pr2fivehex;
918 }
919 else {
920 pr2 = pr2five;
921 }
922
923 bufin = (const unsigned char *)src;
924 while (count) {
925 if (pr2[*bufin] >= 32) {
926 if (!(flags & APR_ENCODE_RELAXED)) {
927 if (count <= 6) {
928 do {
929 if (pr2[bufin[count - 1]] <= 32)
930 break;
931 } while (--count);
932 }
933 if (count) {
934 status = APR_BADCH;
935 }
936 }
937 break;
938 }
939 count--;
940 bufin++;
941 }
942 count = bufin - (const unsigned char *)src;
943
944 if (dest) {
945 unsigned char *bufout;
946
947 bufout = (unsigned char *)dest;
948 bufin = (const unsigned char *)src;
949
950 while (count >= 8) {
951 *(bufout++) = TO_NATIVE(pr2[bufin[0]] << 3 |
952 pr2[bufin[1]] >> 2);
953 *(bufout++) = TO_NATIVE(pr2[bufin[1]] << 6 |
954 pr2[bufin[2]] << 1 |
955 pr2[bufin[3]] >> 4);
956 *(bufout++) = TO_NATIVE(pr2[bufin[3]] << 4 |
957 pr2[bufin[4]] >> 1);
958 *(bufout++) = TO_NATIVE(pr2[bufin[4]] << 7 |
959 pr2[bufin[5]] << 2 |
960 pr2[bufin[6]] >> 3);
961 *(bufout++) = TO_NATIVE(pr2[bufin[6]] << 5 |
962 pr2[bufin[7]]);
963 bufin += 8;
964 count -= 8;
965 }
966
967 if (count == 1) {
968 status = APR_EINCOMPLETE;
969 }
970 if (count >= 2) {
971 *(bufout++) = TO_NATIVE(pr2[bufin[0]] << 3 |
972 pr2[bufin[1]] >> 2);
973 }
974 if (count == 3) {
975 status = APR_EINCOMPLETE;
976 }
977 if (count >= 4) {
978 *(bufout++) = TO_NATIVE(pr2[bufin[1]] << 6 |
979 pr2[bufin[2]] << 1 |
980 pr2[bufin[3]] >> 4);
981 }
982 if (count >= 5) {
983 *(bufout++) = TO_NATIVE(pr2[bufin[3]] << 4 |
984 pr2[bufin[4]] >> 1);
985 }
986 if (count == 6) {
987 status = APR_EINCOMPLETE;
988 }
989 if (count >= 7) {
990 *(bufout++) = TO_NATIVE(pr2[bufin[4]] << 7 |
991 pr2[bufin[5]] << 2 |
992 pr2[bufin[6]] >> 3);
993 }
994
995 dlen = bufout - (unsigned char *)dest;
996 dest[dlen] = '\0';
997 }
998 }
999
1000 if (!src || !dest) {
1001 dlen = (count / 8u) * 5u + 1u;
1002 switch (count % 8) {
1003 case 7:
1004 dlen += 4;
1005 break;
1006 case 6:
1007 status = APR_EINCOMPLETE;
1008 case 5:
1009 dlen += 3;
1010 break;
1011 case 4:
1012 dlen += 2;
1013 break;
1014 case 3:
1015 status = APR_EINCOMPLETE;
1016 case 2:
1017 dlen++;
1018 break;
1019 case 1:
1020 status = APR_EINCOMPLETE;
1021 break;
1022 }
1023 }
1024
1025 if (len) {
1026 *len = dlen;
1027 }
1028 return status;
1029}
1030
1031APR_DECLARE(apr_status_t) apr_decode_base32_binary(unsigned char *dest,
1032 const char *src, apr_ssize_t slen, int flags, apr_size_t * len)
1033{
1034 apr_status_t status = APR_SUCCESS;
1035 apr_size_t count = slen, dlen = 0;
1036
1037 if (src && slen == APR_ENCODE_STRING) {
1038 count = strlen(src);
1039 }
1040 else if (slen < 0 || (dest && !src)) {
1041 return (src) ? APR_EINVAL : APR_NOTFOUND;
1042 }
1043
1044 if (src) {
1045 const unsigned char *bufin;
1046 const unsigned char *pr2;
1047
1048 if ((flags & APR_ENCODE_BASE32HEX)) {
1049 pr2 = pr2fivehex;
1050 }
1051 else {
1052 pr2 = pr2five;
1053 }
1054
1055 bufin = (const unsigned char *)src;
1056 while (count) {
1057 if (pr2[*bufin] >= 32) {
1058 if (!(flags & APR_ENCODE_RELAXED)) {
1059 if (count <= 6) {
1060 do {
1061 if (pr2[bufin[count - 1]] <= 32)
1062 break;
1063 } while (--count);
1064 }
1065 if (count) {
1066 status = APR_BADCH;
1067 }
1068 }
1069 break;
1070 }
1071 count--;
1072 bufin++;
1073 }
1074 count = bufin - (const unsigned char *)src;
1075
1076 if (dest) {
1077 unsigned char *bufout;
1078
1079 bufout = (unsigned char *)dest;
1080 bufin = (const unsigned char *)src;
1081
1082 while (count >= 8) {
1083 *(bufout++) = (pr2[bufin[0]] << 3 |
1084 pr2[bufin[1]] >> 2);
1085 *(bufout++) = (pr2[bufin[1]] << 6 |
1086 pr2[bufin[2]] << 1 |
1087 pr2[bufin[3]] >> 4);
1088 *(bufout++) = (pr2[bufin[3]] << 4 |
1089 pr2[bufin[4]] >> 1);
1090 *(bufout++) = (pr2[bufin[4]] << 7 |
1091 pr2[bufin[5]] << 2 |
1092 pr2[bufin[6]] >> 3);
1093 *(bufout++) = (pr2[bufin[6]] << 5 |
1094 pr2[bufin[7]]);
1095 bufin += 8;
1096 count -= 8;
1097 }
1098
1099 if (count == 1) {
1100 status = APR_EINCOMPLETE;
1101 }
1102 if (count >= 2) {
1103 *(bufout++) = (pr2[bufin[0]] << 3 |
1104 pr2[bufin[1]] >> 2);
1105 }
1106 if (count == 3) {
1107 status = APR_EINCOMPLETE;
1108 }
1109 if (count >= 4) {
1110 *(bufout++) = (pr2[bufin[1]] << 6 |
1111 pr2[bufin[2]] << 1 |
1112 pr2[bufin[3]] >> 4);
1113 }
1114 if (count >= 5) {
1115 *(bufout++) = (pr2[bufin[3]] << 4 |
1116 pr2[bufin[4]] >> 1);
1117 }
1118 if (count == 6) {
1119 status = APR_EINCOMPLETE;
1120 }
1121 if (count >= 7) {
1122 *(bufout++) = (pr2[bufin[4]] << 7 |
1123 pr2[bufin[5]] << 2 |
1124 pr2[bufin[6]] >> 3);
1125 }
1126
1127 dlen = bufout - dest;
1128 }
1129 }
1130
1131 if (!src || !dest) {
1132 dlen = (count / 8u) * 5u;
1133 switch (count % 8) {
1134 case 7:
1135 dlen += 4;
1136 break;
1137 case 6:
1138 status = APR_EINCOMPLETE;
1139 case 5:
1140 dlen += 3;
1141 break;
1142 case 4:
1143 dlen += 2;
1144 break;
1145 case 3:
1146 status = APR_EINCOMPLETE;
1147 case 2:
1148 dlen++;
1149 break;
1150 case 1:
1151 status = APR_EINCOMPLETE;
1152 break;
1153 }
1154 }
1155
1156 if (len) {
1157 *len = dlen;
1158 }
1159 return status;
1160}
1161
1162APR_DECLARE(const char *)apr_pdecode_base32(apr_pool_t * p, const char *str,
1163 apr_ssize_t slen, int flags, apr_size_t * len)
1164{
1165 apr_size_t size;
1166
1167 if (!str) {
1168 return NULL;
1169 }
1170
1171 switch (apr_decode_base32(NULL, str, slen, flags, &size)) {
1172 case APR_SUCCESS:{
1173 void *cmd = apr_palloc(p, size);
1174 if (cmd) {
1175 apr_decode_base32(cmd, str, slen, flags, len);
1176 }
1177 return cmd;
1178 }
1179 default:{
1180 break;
1181 }
1182 }
1183
1184 return NULL;
1185}
1186
1187APR_DECLARE(const unsigned char *)apr_pdecode_base32_binary(apr_pool_t * p,
1188 const char *str, apr_ssize_t slen, int flags, apr_size_t * len)
1189{
1190 apr_size_t size;
1191
1192 if (!str) {
1193 return NULL;
1194 }
1195
1196 switch (apr_decode_base32_binary(NULL, str, slen, flags, &size)) {
1197 case APR_SUCCESS:{
1198 unsigned char *cmd = apr_palloc(p, size + 1);
1199 if (cmd) {
1200 apr_decode_base32_binary(cmd, str, slen, flags, len);
1201 cmd[size] = 0;
1202 }
1203 return cmd;
1204 }
1205 default:{
1206 break;
1207 }
1208 }
1209
1210 return NULL;
1211}
1212
1213APR_DECLARE(apr_status_t) apr_encode_base16(char *dest,
1214 const char *src, apr_ssize_t slen, int flags, apr_size_t * len)
1215{
1216 apr_status_t status = APR_SUCCESS;
1217 apr_size_t count = slen, dlen = 0;
1218
1219 if (src && slen == APR_ENCODE_STRING) {
1220 count = strlen(src);
1221 }
1222 else if (slen < 0 || (dest && !src)) {
1223 return (src) ? APR_EINVAL : APR_NOTFOUND;
1224 }
1225
1226 if (dest) {
1227 char *bufout = dest;
1228 const char *base;
1229 apr_size_t i;
1230
1231 if ((flags & APR_ENCODE_LOWER)) {
1232 base = base16lower;
1233 }
1234 else {
1235 base = base16;
1236 }
1237
1238 for (i = 0; i < count; i++) {
1239 if ((flags & APR_ENCODE_COLON) && i) {
1240 *(bufout++) = ':';
1241 }
1242 *(bufout++) = base[TO_ASCII(src[i]) >> 4];
1243 *(bufout++) = base[TO_ASCII(src[i]) & 0xf];
1244 }
1245
1246 dlen = bufout - dest;
1247 dest[dlen] = '\0';
1248 }
1249 else {
1250 dlen = count * 2u + 1u;
1251 if (dlen <= count) {
1252 status = APR_ENOSPC;
1253 }
1254 if ((flags & APR_ENCODE_COLON) && count > 1) {
1255 apr_size_t more = dlen + count - 1;
1256 if (more <= dlen) {
1257 status = APR_ENOSPC;
1258 }
1259 dlen = more;
1260 }
1261 }
1262
1263 if (len) {
1264 *len = dlen;
1265 }
1266 return status;
1267}
1268
1269APR_DECLARE(apr_status_t) apr_encode_base16_binary(char *dest,
1270 const unsigned char *src, apr_ssize_t slen, int flags, apr_size_t * len)
1271{
1272 apr_status_t status = APR_SUCCESS;
1273 apr_size_t count = slen, dlen = 0;
1274
1275 if (slen < 0 || (dest && !src)) {
1276 return (src) ? APR_EINVAL : APR_NOTFOUND;
1277 }
1278
1279 if (dest) {
1280 char *bufout = dest;
1281 const char *base;
1282 apr_size_t i;
1283
1284 if ((flags & APR_ENCODE_LOWER)) {
1285 base = base16lower;
1286 }
1287 else {
1288 base = base16;
1289 }
1290
1291 for (i = 0; i < count; i++) {
1292 if ((flags & APR_ENCODE_COLON) && i) {
1293 *(bufout++) = ':';
1294 }
1295 *(bufout++) = base[src[i] >> 4];
1296 *(bufout++) = base[src[i] & 0xf];
1297 }
1298
1299 dlen = bufout - dest;
1300 dest[dlen] = '\0';
1301 }
1302 else {
1303 dlen = count * 2u + 1u;
1304 if (dlen <= count) {
1305 status = APR_ENOSPC;
1306 }
1307 if ((flags & APR_ENCODE_COLON) && count > 1) {
1308 apr_size_t more = dlen + count - 1;
1309 if (more <= dlen) {
1310 status = APR_ENOSPC;
1311 }
1312 dlen = more;
1313 }
1314 }
1315
1316 if (len) {
1317 *len = dlen;
1318 }
1319 return status;
1320}
1321
1322APR_DECLARE(const char *)apr_pencode_base16(apr_pool_t * p,
1323 const char *src, apr_ssize_t slen, int flags, apr_size_t * len)
1324{
1325 apr_size_t size;
1326
1327 if (!src) {
1328 return NULL;
1329 }
1330
1331 switch (apr_encode_base16(NULL, src, slen, flags, &size)) {
1332 case APR_SUCCESS:{
1333 char *cmd = apr_palloc(p, size);
1334 if (cmd) {
1335 apr_encode_base16(cmd, src, slen, flags, len);
1336 }
1337 return cmd;
1338 }
1339 default:{
1340 break;
1341 }
1342 }
1343
1344 return NULL;
1345}
1346
1347APR_DECLARE(const char *)apr_pencode_base16_binary(apr_pool_t * p,
1348 const unsigned char *src, apr_ssize_t slen, int flags,
1349 apr_size_t * len)
1350{
1351 apr_size_t size;
1352
1353 if (!src) {
1354 return NULL;
1355 }
1356
1357 switch (apr_encode_base16_binary(NULL, src, slen, flags, &size)) {
1358 case APR_SUCCESS:{
1359 char *cmd = apr_palloc(p, size);
1360 if (cmd) {
1361 apr_encode_base16_binary(cmd, src, slen, flags, len);
1362 }
1363 return cmd;
1364 }
1365 default:{
1366 break;
1367 }
1368 }
1369
1370 return NULL;
1371}
1372
1373APR_DECLARE(apr_status_t) apr_decode_base16(char *dest,
1374 const char *src, apr_ssize_t slen, int flags, apr_size_t * len)
1375{
1376 apr_status_t status = APR_SUCCESS;
1377 apr_size_t count = slen, dlen = 0;
1378
1379 if (src && slen == APR_ENCODE_STRING) {
1380 count = strlen(src);
1381 }
1382 else if (slen < 0 || (dest && !src)) {
1383 return (src) ? APR_EINVAL : APR_NOTFOUND;
1384 }
1385
1386 if (src) {
1387 const unsigned char *bufin;
1388
1389 bufin = (const unsigned char *)src;
1390 while (count) {
1391 if (pr2two[*bufin] >= 16
1392 && (!(flags & APR_ENCODE_COLON)
1393 || pr2two[*bufin] != 32 /* ':' */)) {
1394 if (!(flags & APR_ENCODE_RELAXED)) {
1395 status = APR_BADCH;
1396 }
1397 break;
1398 }
1399 count--;
1400 bufin++;
1401 }
1402 count = bufin - (const unsigned char *)src;
1403
1404 if (dest) {
1405 unsigned char *bufout;
1406
1407 bufout = (unsigned char *)dest;
1408 bufin = (const unsigned char *)src;
1409
1410 while (count >= 2) {
1411 if (pr2two[bufin[0]] == 32 /* ':' */) {
1412 bufin += 1;
1413 count -= 1;
1414 }
1415 else {
1416 *(bufout++) = TO_NATIVE(pr2two[bufin[0]] << 4 |
1417 pr2two[bufin[1]]);
1418 bufin += 2;
1419 count -= 2;
1420 }
1421 }
1422
1423 if (count == 1) {
1424 status = APR_EINCOMPLETE;
1425 }
1426
1427 dlen = bufout - (unsigned char *)dest;
1428 dest[dlen] = '\0';
1429 }
1430 }
1431
1432 if (!src || !dest) {
1433 if (flags & APR_ENCODE_COLON) {
1434 if (count && (count + 1u) % 3u) {
1435 status = APR_EINCOMPLETE;
1436 }
1437 count -= count / 3u;
1438 }
1439 if (count % 2u) {
1440 status = APR_EINCOMPLETE;
1441 }
1442 dlen = count / 2u + 1u;
1443 }
1444
1445 if (len) {
1446 *len = dlen;
1447 }
1448 return status;
1449}
1450
1451APR_DECLARE(apr_status_t) apr_decode_base16_binary(unsigned char *dest,
1452 const char *src, apr_ssize_t slen, int flags, apr_size_t * len)
1453{
1454 apr_status_t status = APR_SUCCESS;
1455 apr_size_t count = slen, dlen = 0;
1456
1457 if (src && slen == APR_ENCODE_STRING) {
1458 count = strlen(src);
1459 }
1460 else if (slen < 0 || (dest && !src)) {
1461 return (src) ? APR_EINVAL : APR_NOTFOUND;
1462 }
1463
1464 if (src) {
1465 const unsigned char *bufin;
1466
1467 bufin = (const unsigned char *)src;
1468 while (count) {
1469 if (pr2two[*bufin] >= 16
1470 && (!(flags & APR_ENCODE_COLON)
1471 || pr2two[*bufin] != 32 /* ':' */)) {
1472 if (!(flags & APR_ENCODE_RELAXED)) {
1473 status = APR_BADCH;
1474 }
1475 break;
1476 }
1477 count--;
1478 bufin++;
1479 }
1480 count = bufin - (const unsigned char *)src;
1481
1482 if (dest) {
1483 unsigned char *bufout;
1484
1485 bufout = (unsigned char *)dest;
1486 bufin = (const unsigned char *)src;
1487
1488 while (count >= 2) {
1489 if (pr2two[bufin[0]] == 32 /* ':' */) {
1490 bufin += 1;
1491 count -= 1;
1492 }
1493 else {
1494 *(bufout++) = (pr2two[bufin[0]] << 4 |
1495 pr2two[bufin[1]]);
1496 bufin += 2;
1497 count -= 2;
1498 }
1499 }
1500
1501 if (count == 1) {
1502 status = APR_EINCOMPLETE;
1503 }
1504
1505 dlen = bufout - (unsigned char *)dest;
1506 }
1507 }
1508
1509 if (!src || !dest) {
1510 if (flags & APR_ENCODE_COLON) {
1511 if (count && (count + 1u) % 3u) {
1512 status = APR_EINCOMPLETE;
1513 }
1514 count -= count / 3u;
1515 }
1516 if (count % 2u) {
1517 status = APR_EINCOMPLETE;
1518 }
1519 dlen = count / 2u;
1520 }
1521
1522 if (len) {
1523 *len = dlen;
1524 }
1525 return status;
1526}
1527
1528APR_DECLARE(const char *)apr_pdecode_base16(apr_pool_t * p,
1529 const char *str, apr_ssize_t slen, int flags, apr_size_t * len)
1530{
1531 apr_size_t size;
1532
1533 if (!str) {
1534 return NULL;
1535 }
1536
1537 switch (apr_decode_base16(NULL, str, slen, flags, &size)) {
1538 case APR_SUCCESS:{
1539 void *cmd = apr_palloc(p, size);
1540 if (cmd) {
1541 apr_decode_base16(cmd, str, slen, flags, len);
1542 }
1543 return cmd;
1544 }
1545 default:{
1546 break;
1547 }
1548 }
1549
1550 return NULL;
1551}
1552
1553APR_DECLARE(const unsigned char *)apr_pdecode_base16_binary(apr_pool_t * p,
1554 const char *str, apr_ssize_t slen, int flags, apr_size_t * len)
1555{
1556 apr_size_t size;
1557
1558 if (!str) {
1559 return NULL;
1560 }
1561
1562 switch (apr_decode_base16_binary(NULL, str, slen, flags, &size)) {
1563 case APR_SUCCESS:{
1564 unsigned char *cmd = apr_palloc(p, size + 1);
1565 if (cmd) {
1566 apr_decode_base16_binary(cmd, str, slen, flags, len);
1567 cmd[size] = 0;
1568 }
1569 return cmd;
1570 }
1571 default:{
1572 break;
1573 }
1574 }
1575
1576 return NULL;
1577}
len
const char apr_size_t len
Definition ap_regex.h:187
base16
static const char base16[]
Definition apr_encode.c:208
base32
static const char base32[]
Definition apr_encode.c:203
pr2five
static const unsigned char pr2five[256]
Definition apr_encode.c:75
pr2two
static const unsigned char pr2two[256]
Definition apr_encode.c:157
base64url
static const char base64url[]
Definition apr_encode.c:200
base32hex
static const char base32hex[]
Definition apr_encode.c:205
pr2fivehex
static const unsigned char pr2fivehex[256]
Definition apr_encode.c:116
base64
static const char base64[]
Definition apr_encode.c:198
base16lower
static const char base16lower[]
Definition apr_encode.c:209
pr2six
static const unsigned char pr2six[256]
Definition apr_encode.c:34
apr_encode.h
APR-UTIL Encoding.
apr_encode_private.h
APR-UTIL Encoding Private.
apr_lib.h
APR general purpose library routines.
apr_strings.h
APR Strings library.
base
ap_conf_vector_t * base
Definition http_config.h:1125
APR_ENOSPC
#define APR_ENOSPC
Definition apr_errno.h:676
APR_BADCH
#define APR_BADCH
Definition apr_errno.h:457
APR_NOTFOUND
#define APR_NOTFOUND
Definition apr_errno.h:463
APR_EINCOMPLETE
#define APR_EINCOMPLETE
Definition apr_errno.h:328
APR_EINVAL
#define APR_EINVAL
Definition apr_errno.h:711
count
unsigned int count
Definition apr_md5.h:152
TO_ASCII
#define TO_ASCII(ch)
Definition apr_encode_private.h:79
TO_NATIVE
#define TO_NATIVE(ch)
Definition apr_encode_private.h:80
APR_ENCODE_BASE32HEX
#define APR_ENCODE_BASE32HEX
Definition apr_encode.h:135
APR_ENCODE_COLON
#define APR_ENCODE_COLON
Definition apr_encode.h:140
src
const char * src
Definition apr_encode.h:167
APR_ENCODE_RELAXED
#define APR_ENCODE_RELAXED
Definition apr_encode.h:115
APR_ENCODE_LOWER
#define APR_ENCODE_LOWER
Definition apr_encode.h:145
flags
const char apr_ssize_t int flags
Definition apr_encode.h:168
slen
const char apr_ssize_t slen
Definition apr_encode.h:168
APR_ENCODE_NOPADDING
#define APR_ENCODE_NOPADDING
Definition apr_encode.h:120
APR_ENCODE_BASE64URL
#define APR_ENCODE_BASE64URL
Definition apr_encode.h:130
APR_ENCODE_STRING
#define APR_ENCODE_STRING
Definition apr_encode.h:105
APR_DECLARE
const void apr_status_t(*) apr_status_t(* APR_DECLARE)(void) apr_pool_pre_cleanup_register(apr_pool_t *p
Definition apr_pools.h:646
size
apr_size_t size
Definition apr_allocator.h:115
APR_SUCCESS
#define APR_SUCCESS
Definition apr_errno.h:225
apr_status_t
int apr_status_t
Definition apr_errno.h:44
cmd
apr_cmdtype_e cmd
Definition apr_thread_proc.h:495
status
int int status
Definition apr_thread_proc.h:760
p
apr_pool_t * p
Definition md_event.c:32
NULL
return NULL
Definition mod_so.c:359
i
int i
Definition mod_so.c:347
apr_pool_t
Definition apr_pools.c:562
str
#define str
Definition util_expr_scan.c:617
Generated by doxygen 1.9.8