[mLib] / codec / baseconv.c

/* -*-c-*-
 *
 * Binary base-conversion encoding and decoding (base64, base32, etc.)
 *
 * (c) 1997 Straylight/Edgeware
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This file is part of the mLib utilities library.
 *
 * mLib is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Library General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * mLib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with mLib; if not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "alloc.h"
#include "codec.h"
#include "dstr.h"
#include "macros.h"
#include "sub.h"

#include "base64.h"
#include "base32.h"
#include "hex.h"

/*----- Important tables --------------------------------------------------*/

/* --- Magic constants --- */

#define NV -1				/* Not valid */
#define PC -2				/* Padding character */
#define NL -3				/* Newline character */
#define SP -4				/* Space character */

/* --- Base64 --- */

static const char
  encodemap_base64[] =    { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
			    "abcdefghijklmnopqrstuvwxyz"
			    "0123456789+/" },
  encodemap_file64[] =    { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
			    "abcdefghijklmnopqrstuvwxyz"
			    "0123456789+%" },
  encodemap_base64url[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
			    "abcdefghijklmnopqrstuvwxyz"
			    "0123456789-_" };

static const signed char decodemap_base64[] = {
  NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV,  /* 0x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 1x */
  SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, 62, NV, NV, NV, 63,  /* 2x */
  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NV, NV, NV, PC, NV, NV,  /* 3x */
  NV,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,  /* 4x */
  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, NV,  /* 5x */
  NV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 ,37, 38, 39, 40,  /* 6x */
  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, NV, NV, NV, NV, NV   /* 7x */
}, decodemap_file64[] = {
  NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV,  /* 0x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 1x */
  SP, NV, NV, NV, NV, 63, NV, NV, NV, NV, NV, 62, NV, NV, NV, NV,  /* 2x */
  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NV, NV, NV, PC, NV, NV,  /* 3x */
  NV,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,  /* 4x */
  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, NV,  /* 5x */
  NV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 ,37, 38, 39, 40,  /* 6x */
  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, NV, NV, NV, NV, NV   /* 7x */
}, decodemap_base64url[] = {
  NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV,  /* 0x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 1x */
  SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, 62, NV, NV,  /* 2x */
  52, 53, 54, 55, 56, 57, 58, 59, 60, 61, NV, NV, NV, PC, NV, NV,  /* 3x */
  NV,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,  /* 4x */
  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, 63,  /* 5x */
  NV, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36 ,37, 38, 39, 40,  /* 6x */
  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, NV, NV, NV, NV, NV   /* 7x */
};

/* --- Base32 --- */

static const char
  encodemap_base32[]   =    { "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567" },
  encodemap_base32hex[] =   { "0123456789ABCDEFGHIJKLMNOPQRSTUV" };

static const signed char decodemap_base32[] = {
  NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV,  /* 0x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 1x */
  SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 2x */
  NV, NV, 26, 27, 28, 29, 30, 31, NV, NV, NV, NV, NV, PC, NV, NV,  /* 3x */
  NV,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,  /* 4x */
  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, NV, NV, NV, NV, NV,  /* 5x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 6x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 7x */
}, decodemap_base32hex[] = {
  NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV,  /* 0x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 1x */
  SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 2x */
   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, NV, NV, NV, PC, NV, NV,  /* 3x */
  NV, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,  /* 4x */
  25, 26, 27, 28, 29, 30, 31, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 5x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 6x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 7x */
};

/* --- Hex --- */

static const char
  encodemap_hex[] =   { "0123456789ABCDEF" };

static const signed char decodemap_hex[] = {
  NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV,  /* 0x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 1x */
  SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 2x */
   0,  1,  2,  3,  4,  5,  6,  7,  8,  9, NV, NV, NV, NV, NV, NV,  /* 3x */
  NV, 10, 11, 12, 13, 14, 15, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 4x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 5x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 6x */
  NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV,  /* 7x */
};

/*----- Base conversion macros --------------------------------------------*/

/* --- @BASECONV@ --- *
 *
 * Arguments:	@x@ = an input digit of width @IWD@ bits
 *		@iwd@ = input digit width in bits
 *		@owd@ = output digit width in bits
 *		@put@ = function or macro to output a digit
 *
 * Use:		Inserts the bits of @x@ into an accumulator.  As digits @y@
 *		of with @owd@ become ready, @put(y)@ is invoked to emit them.
 */

#define BASECONV(x, iwd, owd, put) do {					\
  a = (a << iwd) | x;							\
  nb += iwd;								\
  while (nb >= owd) {							\
    nb -= owd;								\
    put((a >> nb) & ((1 << owd) - 1));					\
  }									\
} while (0)

/* --- @BASECONV_FLUSH@ --- *
 *
 * Arguments:	@iwd@ = input digit width in bits
 *		@owd@ = output digit width in bits
 *		@put@ = function or macro to output a digit
 *
 * Use:		Flushes remaining digits from the base-conversion shift
 *		register.  The bits in the shift register are padded on the
 *		right with zeros.  Digits of width @owd@ are emitted by
 *		invoking @put@.
 */

#define BASECONV_FLUSH(iwd, owd, put) do {				\
  if (nb) {								\
    while (nb < owd) { a <<= iwd; nb += iwd; }				\
    nb -= owd;								\
    put((a >> nb) & ((1 << owd) - 1));					\
  }									\
} while (0)

/* --- @BASECONV_PAD@ --- *
 *
 * Arguments:	@iwd@ = input digit width in bits
 *		@owd@ = output digit width in bits
 *		@pad@ = function or macro to output padding
 *
 * Use:		Invokes @pad@ sufficiently often to realign the shift
 *		register.
 */

#define BASECONV_PAD(iwd, owd, pad) do {				\
  for (;;) {								\
    while (nb >= owd) { pad; nb -= owd; }				\
    if (!nb) break;							\
    nb += iwd;								\
  }									\
} while (0)

#define NULL_PAD(iwd, owd, pad) do ; while (0)

/*----- Lists of things to make -------------------------------------------*/

#define CODECS(_)							\
  /* NAME,      CTXN,    ACC */						\
  _(base64,	base64,	acc)						\
  _(file64,	base64,	acc)						\
  _(base64url,	base64,	acc)						\
  _(base32,	base32,	accl)						\
  _(base32hex,	base32,	accl)						\
  _(hex,	hex,	acc)

#define CTXS(_)								\
  /* CTXN,	WD,	ACC */						\
  _(base64,	6,	acc)						\
  _(base32,	5,	accl)						\
  _(hex,	4,	acc)

#define base64_PADDING BASECONV_PAD
#define base64_FLAGMASK ~(CDCF_LOWERC | CDCF_IGNCASE)
#define base64_FLAGXOR 0
#define base64_OLDFLAGS CDCF_IGNJUNK

#define base32_PADDING BASECONV_PAD
#define base32_FLAGMASK ~0
#define base32_FLAGXOR 0
#define base32_OLDFLAGS CDCF_IGNJUNK

#define hex_PADDING NULL_PAD
#define hex_FLAGMASK ~0
#define hex_FLAGXOR 0
#define hex_OLDFLAGS (CDCF_IGNJUNK | CDCF_LOWERC)

/*----- Data structures ---------------------------------------------------*/

#define OBJ(ctxn, wd, acc)						\
									\
typedef struct ctxn##_codec {						\
  codec c;								\
  ctxn##_ctx ctx;							\
  const char *encodemap;						\
  const signed char *decodemap;						\
} ctxn##_codec;

CTXS(OBJ)

/*----- State packing -----------------------------------------------------*
 *
 * These macros convert between the state required by the new encoding and
 * decoding core and the old externally-visible context structures.  It's
 * unpleasant, I know; maybe we can drop the old interface later.
 */

enum {
  ST_MAIN,				/* Main decoding state */
  ST_PAD,				/* Decoding trailing padding */
  ST_END				/* Finished decoding */
};

#define STATE_UNPACK(acc)						\
  unsigned long a = (ctx->acc >> 0) & 0xffff;				\
  unsigned nb = (ctx->acc >> 16) & 0xff;				\
  unsigned st = (ctx->acc >> 24) & 0xff;				\
  unsigned f = ctx->qsz;

#define STATE_PACK(acc) do {						\
  ctx->acc = (((a & 0xffff) << 0) |					\
	      (((unsigned long)nb & 0xff) << 16) |			\
	      (((unsigned long)st & 0xff) << 24));			\
} while (0)

/*----- Main encoder and decoder ------------------------------------------*/

#define WRAP(stuff) do {						\
  if (maxln && lnlen >= maxln) {					\
    dstr_puts(d, ctx->indent);						\
    lnlen = 0;								\
  }									\
  stuff									\
  lnlen++;								\
} while (0)

#define PUTWRAP(x) WRAP({						\
  char ch = encodemap[x];						\
  if (f & CDCF_LOWERC) ch = TOLOWER(ch);				\
  DPUTC(d, ch);								\
})

#define PADWRAP WRAP({ DPUTC(d, '='); })

#define PUTRAW(x) DPUTC(d, x)

#define ENCODER(ctxn, wd, acc)						\
									\
/* --- @CTXN_doencode@ --- *						\
 *									\
 * Arguments:	@CTXN_ctx *ctx@ = pointer to a context block		\
 *		@const char *encodemap@ = pointer to encoding map	\
 *		@const unsigned char *p@ = pointer to a source buffer	\
 *		@size_t sz@ = size of the source buffer			\
 *		@dstr *d@ = pointer to destination string		\
 *									\
 * Returns:	Zero on success, or @CDCERR_@ error code.		\
 *									\
 * Use:		Main encoder function.					\
 */									\
									\
static int ctxn##_doencode(ctxn##_ctx *ctx, const char *encodemap,	\
			   const unsigned char *p, size_t sz, dstr *d)	\
{									\
  STATE_UNPACK(acc);							\
  const unsigned char *l = p + sz;					\
  unsigned lnlen = ctx->lnlen, maxln = ctx->maxline;			\
									\
  if (p) {								\
    while (p < l) BASECONV(*p++, 8, wd, PUTWRAP);			\
  } else {								\
    BASECONV_FLUSH(8, wd, PUTWRAP);					\
    if (!(f & CDCF_NOEQPAD)) ctxn##_PADDING(8, wd, PADWRAP);		\
  }									\
									\
  STATE_PACK(acc);							\
  ctx->lnlen = lnlen;							\
  return (0);								\
}									\
									\
/* --- @CTXN_dodecode@ --- *						\
 *									\
 * Arguments:	@CTXN_ctx *ctx@ = pointer to a context block		\
 *		@const signed char *decodemap@ = pointer to decode map	\
 *		@const char *p@ = pointer to a source buffer		\
 *		@size_t sz@ = size of the source buffer			\
 *		@dstr *d@ = pointer to destination string		\
 *									\
 * Returns:	Zero on success, or @CDCERR_@ error code.		\
 *									\
 * Use:		Main decoder function.					\
 */									\
									\
static int ctxn##_dodecode(ctxn##_ctx *ctx,				\
			   const signed char *decodemap,		\
			   const unsigned char *p, size_t sz, dstr *d)	\
{									\
  STATE_UNPACK(acc);							\
  const unsigned char *l = p + sz;					\
  int ch;								\
  int x;								\
									\
  if (p) {								\
    while (p < l) {							\
      ch = *p++;							\
      switch (f & (CDCF_LOWERC | CDCF_IGNCASE)) {			\
	case 0:								\
	  break;							\
	case CDCF_LOWERC:						\
	  if (ISUPPER(ch)) goto badch;					\
	default:							\
	  ch = TOUPPER(ch);						\
      }									\
      x = decodemap[ch];						\
      switch (x) {							\
	case NV:							\
	badch:								\
	  if (!(f & CDCF_IGNINVCH)) return (CDCERR_INVCH);		\
	  break;							\
	case PC:							\
	  if (f & CDCF_IGNEQMID) break;					\
	  if (f & CDCF_NOEQPAD) goto badch;				\
	  if (st == ST_MAIN &&						\
	      !(f & CDCF_IGNZPAD) && (a & ((1 << nb) - 1)))		\
	    return (CDCERR_INVZPAD);					\
	  st = ST_PAD;							\
	  if (!(f & CDCF_IGNEQPAD)) {					\
	    if (!nb) return (CDCERR_INVEQPAD);				\
	    nb = (nb + wd)%8;						\
	    st = ST_PAD;						\
	  }								\
	  break;							\
	case NL:							\
	  if (f & CDCF_IGNNEWL) break;					\
	  return (CDCERR_INVCH);					\
	case SP:							\
	  if (f & CDCF_IGNSPC) break;					\
	  return (CDCERR_INVCH);					\
	default:							\
	  if (st != ST_MAIN) return (CDCERR_INVEQPAD);			\
	  BASECONV(x, wd, 8, PUTRAW);					\
	  break;							\
      }									\
    }									\
  } else {								\
    if (st == ST_MAIN &&						\
	!(f & CDCF_IGNZPAD) && (a & ((1 << nb) - 1)))			\
      return (CDCERR_INVZPAD);						\
    if (!(f & (CDCF_IGNEQPAD | CDCF_IGNEQMID | CDCF_NOEQPAD)) && nb)	\
      return (CDCERR_INVEQPAD);						\
  }									\
									\
  STATE_PACK(acc);							\
  return (0);								\
}

CTXS(ENCODER)

/*----- Codec implementation ----------------------------------------------*/

#define OPS(ctxn, wd, acc)						\
									\
static int ctxn##_enc(codec *c, const void *p, size_t sz, dstr *d)	\
{									\
  ctxn##_codec *bc = (ctxn##_codec *)c;					\
  return (ctxn##_doencode(&bc->ctx, bc->encodemap, p, sz, d));		\
}									\
									\
static int ctxn##_dec(codec *c, const void *p, size_t sz, dstr *d)	\
{									\
  ctxn##_codec *bc = (ctxn##_codec *)c;					\
  return (ctxn##_dodecode(&bc->ctx, bc->decodemap, p, sz, d));		\
}									\
									\
static void ctxn##_destroy(codec *c)					\
{									\
  ctxn##_codec *bc = (ctxn##_codec *)c;					\
  if (bc->ctx.indent) xfree((/*unconst*/ char *)bc->ctx.indent);	\
  DESTROY(bc);								\
}									\
									\
static codec *ctxn##_docreate(unsigned flags,				\
			      const char *indent, unsigned maxline,	\
			      const codec_ops *ops,			\
			      const char *encodemap,			\
			      const signed char *decodemap)		\
{									\
  ctxn##_codec *bc = CREATE(ctxn##_codec);				\
  bc->c.ops = ops;							\
  bc->ctx.acc = 0;							\
  bc->ctx.qsz = (flags & ctxn##_FLAGMASK) ^ ctxn##_FLAGXOR;		\
  bc->ctx.lnlen = 0;							\
  bc->ctx.indent = indent ? xstrdup(indent) : 0;			\
  bc->ctx.maxline = maxline;						\
  bc->encodemap = encodemap;						\
  bc->decodemap = decodemap;						\
  return (&bc->c);							\
}

CTXS(OPS)

#define CLASS(name, ctxn, acc)						\
									\
static const codec_ops							\
  name##_encode_ops = { &name##_class, ctxn##_enc, ctxn##_destroy },	\
  name##_decode_ops = { &name##_class, ctxn##_dec, ctxn##_destroy };	\
									\
static codec *name##_encoder(unsigned flags,				\
			     const char *indent, unsigned maxline)	\
{									\
  return ctxn##_docreate(flags, indent, maxline,			\
			 &name##_encode_ops,				\
			 encodemap_##name,				\
			 decodemap_##name);				\
}									\
									\
static codec *name##_decoder(unsigned flags)				\
{									\
  return ctxn##_docreate(flags, 0, 0,					\
			 &name##_decode_ops,				\
			 encodemap_##name,				\
			 decodemap_##name);				\
}									\
									\
const codec_class name##_class =					\
  { #name, name##_encoder, name##_decoder };

CODECS(CLASS)

/*----- Compatibility veneers ---------------------------------------------*/

#define COMPAT(ctxn, wd, acc)						\
									\
void ctxn##_encode(ctxn##_ctx *ctx, const void *p, size_t sz, dstr *d)	\
  { ctxn##_doencode(ctx, encodemap_##ctxn, p, sz, d); }			\
									\
void ctxn##_decode(ctxn##_ctx *ctx, const void *p, size_t sz, dstr *d)	\
  { ctxn##_dodecode(ctx, decodemap_##ctxn, p, sz, d); }			\
									\
void ctxn##_init(ctxn##_ctx *ctx)					\
{									\
  ctx->acc = 0;								\
  ctx->qsz = (ctxn##_OLDFLAGS & ctxn##_FLAGMASK) ^ ctxn##_FLAGXOR;	\
  ctx->lnlen = 0;							\
  ctx->indent = "\n";							\
  ctx->maxline = 72;							\
}

CTXS(COMPAT)

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
236f657b MW	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"
36188114	38	#include "macros.h"
236f657b MW	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 */
09fbf4d0	52	#define SP -4 /* Space character */
236f657b MW	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[] = {
09fbf4d0	68	NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
236f657b	69	NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
09fbf4d0	70	SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, 62, NV, NV, NV, 63, /* 2x */
236f657b MW	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[] = {
09fbf4d0	77	NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
236f657b	78	NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
09fbf4d0	79	SP, NV, NV, NV, NV, 63, NV, NV, NV, NV, NV, 62, NV, NV, NV, NV, /* 2x */
236f657b MW	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[] = {
09fbf4d0	86	NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
236f657b	87	NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
09fbf4d0	88	SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, 62, NV, NV, /* 2x */
236f657b MW	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[] = {
09fbf4d0	103	NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
236f657b	104	NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
09fbf4d0	105	SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 2x */
236f657b MW	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[] = {
09fbf4d0	112	NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
236f657b	113	NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
09fbf4d0	114	SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 2x */
236f657b MW	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[] = {
09fbf4d0	128	NV, NV, NV, NV, NV, NV, NV, NV, NV, SP, NL, NV, SP, NL, NV, NV, /* 0x */
236f657b	129	NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 1x */
09fbf4d0	130	SP, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, NV, /* 2x */
236f657b MW	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]; \
36188114	283	if (f & CDCF_LOWERC) ch = TOLOWER(ch); \
236f657b MW	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: \
36188114	354	if (ISUPPER(ch)) goto badch; \
236f657b	355	default: \
36188114	356	ch = TOUPPER(ch); \
236f657b MW	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); \
09fbf4d0 MW	380	case SP: \
	381	if (f & CDCF_IGNSPC) break; \
	382	return (CDCERR_INVCH); \
236f657b	383	default: \
09fbf4d0	384	if (st != ST_MAIN) return (CDCERR_INVEQPAD); \
236f657b MW	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 -------------------------------------------------/