~mdw / mLib / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
utils/macros.h: Add <ctype.h> and `foocmp' helper macros.
[mLib] / codec / baseconv.c
1 /* -*-c-*-
2 *
3 * Binary base-conversion encoding and decoding (base64, base32, etc.)
4 *
5 * (c) 1997 Straylight/Edgeware
6 */
7
8 /*----- Licensing notice --------------------------------------------------*
9 *
10 * This file is part of the mLib utilities library.
11 *
12 * mLib is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU Library General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
16 *
17 * mLib is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Library General Public License for more details.
21 *
22 * You should have received a copy of the GNU Library General Public
23 * License along with mLib; if not, write to the Free
24 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
25 * MA 02111-1307, USA.
26 */
27
28 /*----- Header files ------------------------------------------------------*/
29
30 #include <ctype.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #include "alloc.h"
36 #include "codec.h"
37 #include "dstr.h"
38 #include "macros.h"
39 #include "sub.h"
40
41 #include "base64.h"
42 #include "base32.h"
43 #include "hex.h"
44
45 /*----- Important tables --------------------------------------------------*/
46
47 /* --- Magic constants --- */
48
49 #define NV -1 /* Not valid */
50 #define PC -2 /* Padding character */
51 #define NL -3 /* Newline character */
52 #define SP -4 /* Space character */
53
54 /* --- Base64 --- */
55
56 static const char
57 encodemap_base64[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
58 "abcdefghijklmnopqrstuvwxyz"
59 "0123456789+/" },
60 encodemap_file64[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
61 "abcdefghijklmnopqrstuvwxyz"
62 "0123456789+%" },
63 encodemap_base64url[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
64 "abcdefghijklmnopqrstuvwxyz"
65 "0123456789-_" };
66
67 static const signed char decodemap_base64[] = {
68 NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
69 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
70 SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, 62, NV, NV, NV, 63, /* 2x */
71 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NV, NV, NV, PC, NV, NV, /* 3x */
72 NV, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 4x */
73 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, NV, /* 5x */
74 NV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 ,37, 38, 39, 40, /* 6x */
75 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, NV, NV, NV, NV, NV /* 7x */
76 }, decodemap_file64[] = {
77 NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
78 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
79 SP, NV, NV, NV, NV, 63, NV, NV, NV, NV, NV, 62, NV, NV, NV, NV, /* 2x */
80 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NV, NV, NV, PC, NV, NV, /* 3x */
81 NV, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 4x */
82 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, NV, /* 5x */
83 NV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 ,37, 38, 39, 40, /* 6x */
84 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, NV, NV, NV, NV, NV /* 7x */
85 }, decodemap_base64url[] = {
86 NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
87 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
88 SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, 62, NV, NV, /* 2x */
89 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NV, NV, NV, PC, NV, NV, /* 3x */
90 NV, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 4x */
91 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, 63, /* 5x */
92 NV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 ,37, 38, 39, 40, /* 6x */
93 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, NV, NV, NV, NV, NV /* 7x */
94 };
95
96 /* --- Base32 --- */
97
98 static const char
99 encodemap_base32[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567" },
100 encodemap_base32hex[] = { "0123456789ABCDEFGHIJKLMNOPQRSTUV" };
101
102 static const signed char decodemap_base32[] = {
103 NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
104 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
105 SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 2x */
106 NV, NV, 26, 27, 28, 29, 30, 31, NV, NV, NV, NV, NV, PC, NV, NV, /* 3x */
107 NV, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 4x */
108 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, NV, /* 5x */
109 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 6x */
110 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 7x */
111 }, decodemap_base32hex[] = {
112 NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
113 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
114 SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 2x */
115 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, NV, NV, NV, PC, NV, NV, /* 3x */
116 NV, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, /* 4x */
117 25, 26, 27, 28, 29, 30, 31, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 5x */
118 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 6x */
119 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 7x */
120 };
121
122 /* --- Hex --- */
123
124 static const char
125 encodemap_hex[] = { "0123456789ABCDEF" };
126
127 static const signed char decodemap_hex[] = {
128 NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
129 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
130 SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 2x */
131 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, NV, NV, NV, NV, NV, NV, /* 3x */
132 NV, 10, 11, 12, 13, 14, 15, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 4x */
133 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 5x */
134 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 6x */
135 NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 7x */
136 };
137
138 /*----- Base conversion macros --------------------------------------------*/
139
140 /* --- @BASECONV@ --- *
141 *
142 * Arguments: @x@ = an input digit of width @IWD@ bits
143 * @iwd@ = input digit width in bits
144 * @owd@ = output digit width in bits
145 * @put@ = function or macro to output a digit
146 *
147 * Use: Inserts the bits of @x@ into an accumulator. As digits @y@
148 * of with @owd@ become ready, @put(y)@ is invoked to emit them.
149 */
150
151 #define BASECONV(x, iwd, owd, put) do { \
152 a = (a << iwd) | x; \
153 nb += iwd; \
154 while (nb >= owd) { \
155 nb -= owd; \
156 put((a >> nb) & ((1 << owd) - 1)); \
157 } \
158 } while (0)
159
160 /* --- @BASECONV_FLUSH@ --- *
161 *
162 * Arguments: @iwd@ = input digit width in bits
163 * @owd@ = output digit width in bits
164 * @put@ = function or macro to output a digit
165 *
166 * Use: Flushes remaining digits from the base-conversion shift
167 * register. The bits in the shift register are padded on the
168 * right with zeros. Digits of width @owd@ are emitted by
169 * invoking @put@.
170 */
171
172 #define BASECONV_FLUSH(iwd, owd, put) do { \
173 if (nb) { \
174 while (nb < owd) { a <<= iwd; nb += iwd; } \
175 nb -= owd; \
176 put((a >> nb) & ((1 << owd) - 1)); \
177 } \
178 } while (0)
179
180 /* --- @BASECONV_PAD@ --- *
181 *
182 * Arguments: @iwd@ = input digit width in bits
183 * @owd@ = output digit width in bits
184 * @pad@ = function or macro to output padding
185 *
186 * Use: Invokes @pad@ sufficiently often to realign the shift
187 * register.
188 */
189
190 #define BASECONV_PAD(iwd, owd, pad) do { \
191 for (;;) { \
192 while (nb >= owd) { pad; nb -= owd; } \
193 if (!nb) break; \
194 nb += iwd; \
195 } \
196 } while (0)
197
198 #define NULL_PAD(iwd, owd, pad) do ; while (0)
199
200 /*----- Lists of things to make -------------------------------------------*/
201
202 #define CODECS(_) \
203 /* NAME, CTXN, ACC */ \
204 _(base64, base64, acc) \
205 _(file64, base64, acc) \
206 _(base64url, base64, acc) \
207 _(base32, base32, accl) \
208 _(base32hex, base32, accl) \
209 _(hex, hex, acc)
210
211 #define CTXS(_) \
212 /* CTXN, WD, ACC */ \
213 _(base64, 6, acc) \
214 _(base32, 5, accl) \
215 _(hex, 4, acc)
216
217 #define base64_PADDING BASECONV_PAD
218 #define base64_FLAGMASK ~(CDCF_LOWERC | CDCF_IGNCASE)
219 #define base64_FLAGXOR 0
220 #define base64_OLDFLAGS CDCF_IGNJUNK
221
222 #define base32_PADDING BASECONV_PAD
223 #define base32_FLAGMASK ~0
224 #define base32_FLAGXOR 0
225 #define base32_OLDFLAGS CDCF_IGNJUNK
226
227 #define hex_PADDING NULL_PAD
228 #define hex_FLAGMASK ~0
229 #define hex_FLAGXOR 0
230 #define hex_OLDFLAGS (CDCF_IGNJUNK | CDCF_LOWERC)
231
232 /*----- Data structures ---------------------------------------------------*/
233
234 #define OBJ(ctxn, wd, acc) \
235 \
236 typedef struct ctxn##_codec { \
237 codec c; \
238 ctxn##_ctx ctx; \
239 const char *encodemap; \
240 const signed char *decodemap; \
241 } ctxn##_codec;
242
243 CTXS(OBJ)
244
245 /*----- State packing -----------------------------------------------------*
246 *
247 * These macros convert between the state required by the new encoding and
248 * decoding core and the old externally-visible context structures. It's
249 * unpleasant, I know; maybe we can drop the old interface later.
250 */
251
252 enum {
253 ST_MAIN, /* Main decoding state */
254 ST_PAD, /* Decoding trailing padding */
255 ST_END /* Finished decoding */
256 };
257
258 #define STATE_UNPACK(acc) \
259 unsigned long a = (ctx->acc >> 0) & 0xffff; \
260 unsigned nb = (ctx->acc >> 16) & 0xff; \
261 unsigned st = (ctx->acc >> 24) & 0xff; \
262 unsigned f = ctx->qsz;
263
264 #define STATE_PACK(acc) do { \
265 ctx->acc = (((a & 0xffff) << 0) | \
266 (((unsigned long)nb & 0xff) << 16) | \
267 (((unsigned long)st & 0xff) << 24)); \
268 } while (0)
269
270 /*----- Main encoder and decoder ------------------------------------------*/
271
272 #define WRAP(stuff) do { \
273 if (maxln && lnlen >= maxln) { \
274 dstr_puts(d, ctx->indent); \
275 lnlen = 0; \
276 } \
277 stuff \
278 lnlen++; \
279 } while (0)
280
281 #define PUTWRAP(x) WRAP({ \
282 char ch = encodemap[x]; \
283 if (f & CDCF_LOWERC) ch = TOLOWER(ch); \
284 DPUTC(d, ch); \
285 })
286
287 #define PADWRAP WRAP({ DPUTC(d, '='); })
288
289 #define PUTRAW(x) DPUTC(d, x)
290
291 #define ENCODER(ctxn, wd, acc) \
292 \
293 /* --- @CTXN_doencode@ --- * \
294 * \
295 * Arguments: @CTXN_ctx *ctx@ = pointer to a context block \
296 * @const char *encodemap@ = pointer to encoding map \
297 * @const unsigned char *p@ = pointer to a source buffer \
298 * @size_t sz@ = size of the source buffer \
299 * @dstr *d@ = pointer to destination string \
300 * \
301 * Returns: Zero on success, or @CDCERR_@ error code. \
302 * \
303 * Use: Main encoder function. \
304 */ \
305 \
306 static int ctxn##_doencode(ctxn##_ctx *ctx, const char *encodemap, \
307 const unsigned char *p, size_t sz, dstr *d) \
308 { \
309 STATE_UNPACK(acc); \
310 const unsigned char *l = p + sz; \
311 unsigned lnlen = ctx->lnlen, maxln = ctx->maxline; \
312 \
313 if (p) { \
314 while (p < l) BASECONV(*p++, 8, wd, PUTWRAP); \
315 } else { \
316 BASECONV_FLUSH(8, wd, PUTWRAP); \
317 if (!(f & CDCF_NOEQPAD)) ctxn##_PADDING(8, wd, PADWRAP); \
318 } \
319 \
320 STATE_PACK(acc); \
321 ctx->lnlen = lnlen; \
322 return (0); \
323 } \
324 \
325 /* --- @CTXN_dodecode@ --- * \
326 * \
327 * Arguments: @CTXN_ctx *ctx@ = pointer to a context block \
328 * @const signed char *decodemap@ = pointer to decode map \
329 * @const char *p@ = pointer to a source buffer \
330 * @size_t sz@ = size of the source buffer \
331 * @dstr *d@ = pointer to destination string \
332 * \
333 * Returns: Zero on success, or @CDCERR_@ error code. \
334 * \
335 * Use: Main decoder function. \
336 */ \
337 \
338 static int ctxn##_dodecode(ctxn##_ctx *ctx, \
339 const signed char *decodemap, \
340 const unsigned char *p, size_t sz, dstr *d) \
341 { \
342 STATE_UNPACK(acc); \
343 const unsigned char *l = p + sz; \
344 int ch; \
345 int x; \
346 \
347 if (p) { \
348 while (p < l) { \
349 ch = *p++; \
350 switch (f & (CDCF_LOWERC | CDCF_IGNCASE)) { \
351 case 0: \
352 break; \
353 case CDCF_LOWERC: \
354 if (ISUPPER(ch)) goto badch; \
355 default: \
356 ch = TOUPPER(ch); \
357 } \
358 x = decodemap[ch]; \
359 switch (x) { \
360 case NV: \
361 badch: \
362 if (!(f & CDCF_IGNINVCH)) return (CDCERR_INVCH); \
363 break; \
364 case PC: \
365 if (f & CDCF_IGNEQMID) break; \
366 if (f & CDCF_NOEQPAD) goto badch; \
367 if (st == ST_MAIN && \
368 !(f & CDCF_IGNZPAD) && (a & ((1 << nb) - 1))) \
369 return (CDCERR_INVZPAD); \
370 st = ST_PAD; \
371 if (!(f & CDCF_IGNEQPAD)) { \
372 if (!nb) return (CDCERR_INVEQPAD); \
373 nb = (nb + wd)%8; \
374 st = ST_PAD; \
375 } \
376 break; \
377 case NL: \
378 if (f & CDCF_IGNNEWL) break; \
379 return (CDCERR_INVCH); \
380 case SP: \
381 if (f & CDCF_IGNSPC) break; \
382 return (CDCERR_INVCH); \
383 default: \
384 if (st != ST_MAIN) return (CDCERR_INVEQPAD); \
385 BASECONV(x, wd, 8, PUTRAW); \
386 break; \
387 } \
388 } \
389 } else { \
390 if (st == ST_MAIN && \
391 !(f & CDCF_IGNZPAD) && (a & ((1 << nb) - 1))) \
392 return (CDCERR_INVZPAD); \
393 if (!(f & (CDCF_IGNEQPAD | CDCF_IGNEQMID | CDCF_NOEQPAD)) && nb) \
394 return (CDCERR_INVEQPAD); \
395 } \
396 \
397 STATE_PACK(acc); \
398 return (0); \
399 }
400
401 CTXS(ENCODER)
402
403 /*----- Codec implementation ----------------------------------------------*/
404
405 #define OPS(ctxn, wd, acc) \
406 \
407 static int ctxn##_enc(codec *c, const void *p, size_t sz, dstr *d) \
408 { \
409 ctxn##_codec *bc = (ctxn##_codec *)c; \
410 return (ctxn##_doencode(&bc->ctx, bc->encodemap, p, sz, d)); \
411 } \
412 \
413 static int ctxn##_dec(codec *c, const void *p, size_t sz, dstr *d) \
414 { \
415 ctxn##_codec *bc = (ctxn##_codec *)c; \
416 return (ctxn##_dodecode(&bc->ctx, bc->decodemap, p, sz, d)); \
417 } \
418 \
419 static void ctxn##_destroy(codec *c) \
420 { \
421 ctxn##_codec *bc = (ctxn##_codec *)c; \
422 if (bc->ctx.indent) xfree((/*unconst*/ char *)bc->ctx.indent); \
423 DESTROY(bc); \
424 } \
425 \
426 static codec *ctxn##_docreate(unsigned flags, \
427 const char *indent, unsigned maxline, \
428 const codec_ops *ops, \
429 const char *encodemap, \
430 const signed char *decodemap) \
431 { \
432 ctxn##_codec *bc = CREATE(ctxn##_codec); \
433 bc->c.ops = ops; \
434 bc->ctx.acc = 0; \
435 bc->ctx.qsz = (flags & ctxn##_FLAGMASK) ^ ctxn##_FLAGXOR; \
436 bc->ctx.lnlen = 0; \
437 bc->ctx.indent = indent ? xstrdup(indent) : 0; \
438 bc->ctx.maxline = maxline; \
439 bc->encodemap = encodemap; \
440 bc->decodemap = decodemap; \
441 return (&bc->c); \
442 }
443
444 CTXS(OPS)
445
446 #define CLASS(name, ctxn, acc) \
447 \
448 static const codec_ops \
449 name##_encode_ops = { &name##_class, ctxn##_enc, ctxn##_destroy }, \
450 name##_decode_ops = { &name##_class, ctxn##_dec, ctxn##_destroy }; \
451 \
452 static codec *name##_encoder(unsigned flags, \
453 const char *indent, unsigned maxline) \
454 { \
455 return ctxn##_docreate(flags, indent, maxline, \
456 &name##_encode_ops, \
457 encodemap_##name, \
458 decodemap_##name); \
459 } \
460 \
461 static codec *name##_decoder(unsigned flags) \
462 { \
463 return ctxn##_docreate(flags, 0, 0, \
464 &name##_decode_ops, \
465 encodemap_##name, \
466 decodemap_##name); \
467 } \
468 \
469 const codec_class name##_class = \
470 { #name, name##_encoder, name##_decoder };
471
472 CODECS(CLASS)
473
474 /*----- Compatibility veneers ---------------------------------------------*/
475
476 #define COMPAT(ctxn, wd, acc) \
477 \
478 void ctxn##_encode(ctxn##_ctx *ctx, const void *p, size_t sz, dstr *d) \
479 { ctxn##_doencode(ctx, encodemap_##ctxn, p, sz, d); } \
480 \
481 void ctxn##_decode(ctxn##_ctx *ctx, const void *p, size_t sz, dstr *d) \
482 { ctxn##_dodecode(ctx, decodemap_##ctxn, p, sz, d); } \
483 \
484 void ctxn##_init(ctxn##_ctx *ctx) \
485 { \
486 ctx->acc = 0; \
487 ctx->qsz = (ctxn##_OLDFLAGS & ctxn##_FLAGMASK) ^ ctxn##_FLAGXOR; \
488 ctx->lnlen = 0; \
489 ctx->indent = "\n"; \
490 ctx->maxline = 72; \
491 }
492
493 CTXS(COMPAT)
494
495 /*----- That's all, folks -------------------------------------------------*/
mLib utilities library