base64.cc File Reference

#include "base64.h"
#include <cstdlib>
#include <climits>
#include <cstring>

Go to the source code of this file.

Macros
#define	B64(_)
#define	return_false
#define	uchar_in_range(c)   ((c) <= 255)

Functions
bool	base64_decode_alloc_ctx (struct base64_decode_context *ctx, const char *in, size_t inlen, char **out, size_t *outlen)
bool	base64_decode_ctx (struct base64_decode_context *ctx, const char *in, size_t inlen, char *out, size_t *outlen)
void	base64_decode_ctx_init (struct base64_decode_context *ctx)
void	base64_encode (const char *in, size_t inlen, char *out, size_t outlen)
size_t	base64_encode_alloc (const char *in, size_t inlen, char **out)
static bool	decode_4 (char const *in, size_t inlen, char **outp, size_t *outleft)
static char *	get_4 (struct base64_decode_context *ctx, char const **in, char const *in_end, size_t *n_non_newline)
bool	isbase64 (char ch)
static unsigned char	to_uchar (char ch)

Variables
static const signed char	b64 [0x100]

Macro Definition Documentation

#define B64

(

_

)

Definition at line 157 of file base64.cc.

#define return_false

Value:

do                                            \
    {                                           \
      *outp = out;                              \
      return false;                             \
    }                                           \
  while (false)

Definition at line 360 of file base64.cc.

Referenced by decode_4().

#define uchar_in_range

(

c

)

((c) <= 255)

Definition at line 294 of file base64.cc.

Referenced by isbase64().

Function Documentation

bool base64_decode_alloc_ctx	(	struct base64_decode_context *	ctx,
		const char *	in,
		size_t	inlen,
		char **	out,
		size_t *	outlen
	)

Definition at line 551 of file base64.cc.

References base64_decode_ctx().

{
  /* This may allocate a few bytes too many, depending on input,
     but it's not worth the extra CPU time to compute the exact size.
     The exact size is 3 * (inlen + (ctx ? ctx->i : 0)) / 4, minus 1 if the
     input ends with "=" and minus another 1 if the input ends with "==".
     Dividing before multiplying avoids the possibility of overflow.  */
  size_t needlen = 3 * (inlen / 4) + 3;

  *out = static_cast<char*>(malloc (needlen));
  if (!*out)
    return true;

  if (!base64_decode_ctx (ctx, in, inlen, *out, &needlen))
    {
      free (*out);
      *out = nullptr;
      return false;
    }

  if (outlen)
    *outlen = needlen;

  return true;
}

bool base64_decode_ctx	(	struct base64_decode_context *	ctx,
		const char *	in,
		size_t	inlen,
		char *	out,
		size_t *	outlen
	)

Definition at line 460 of file base64.cc.

References decode_4(), get_4(), base64_decode_context::i, and recoMuon::in.

Referenced by base64_decode_alloc_ctx().

{
  size_t outleft = *outlen;
  bool ignore_newlines = ctx != nullptr;
  bool flush_ctx = false;
  unsigned int ctx_i = 0;

  if (ignore_newlines)
    {
      ctx_i = ctx->i;
      flush_ctx = inlen == 0;
    }


  while (true)
    {
      size_t outleft_save = outleft;
      if (ctx_i == 0 && !flush_ctx)
        {
          while (true)
            {
              /* Save a copy of outleft, in case we need to re-parse this
                 block of four bytes.  */
              outleft_save = outleft;
              if (!decode_4 (in, inlen, &out, &outleft))
                break;

              in += 4;
              inlen -= 4;
            }
        }

      if (inlen == 0 && !flush_ctx)
        break;

      /* Handle the common case of 72-byte wrapped lines.
         This also handles any other multiple-of-4-byte wrapping.  */
      if (inlen && *in == '\n' && ignore_newlines)
        {
          ++in;
          --inlen;
          continue;
        }

      /* Restore OUT and OUTLEFT.  */
      out -= outleft_save - outleft;
      outleft = outleft_save;

      {
        char const *in_end = in + inlen;
        char const *non_nl;

        if (ignore_newlines)
          non_nl = get_4 (ctx, &in, in_end, &inlen);
        else
          non_nl = in;  /* Might have nl in this case. */

        /* If the input is empty or consists solely of newlines (0 non-newlines),
           then we're done.  Likewise if there are fewer than 4 bytes when not
           flushing context and not treating newlines as garbage.  */
        if (inlen == 0 || (inlen < 4 && !flush_ctx && ignore_newlines))
          {
            inlen = 0;
            break;
          }
        if (!decode_4 (non_nl, inlen, &out, &outleft))
          break;

        inlen = in_end - in;
      }
    }

  *outlen -= outleft;

  return inlen == 0;
}

void base64_decode_ctx_init

(

struct base64_decode_context *

ctx

)

Definition at line 308 of file base64.cc.

References base64_decode_context::i.

{
  ctx->i = 0;
}

void base64_encode	(	const char *	in,
		size_t	inlen,
		char *	out,
		size_t	outlen
	)

Definition at line 70 of file base64.cc.

References b64str, and to_uchar().

Referenced by base64_encode_alloc().

{
  static const char* b64str =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

  while (inlen && outlen)
    {
      *out++ = b64str[(to_uchar (in[0]) >> 2) & 0x3f];
      if (!--outlen)
        break;
      *out++ = b64str[((to_uchar (in[0]) << 4)
                       + (--inlen ? to_uchar (in[1]) >> 4 : 0))
                      & 0x3f];
      if (!--outlen)
        break;
      *out++ =
        (inlen
         ? b64str[((to_uchar (in[1]) << 2)
                   + (--inlen ? to_uchar (in[2]) >> 6 : 0))
                  & 0x3f]
         : '=');
      if (!--outlen)
        break;
      *out++ = inlen ? b64str[to_uchar (in[2]) & 0x3f] : '=';
      if (!--outlen)
        break;
      if (inlen)
        inlen--;
      if (inlen)
        in += 3;
    }

  if (outlen)
    *out = '\0';
}

size_t base64_encode_alloc	(	const char *	in,
		size_t	inlen,
		char **	out
	)

Definition at line 117 of file base64.cc.

References base64_encode(), and BASE64_LENGTH.

Referenced by cond::auth::Cipher::b64encrypt().

{
  size_t outlen = 1 + BASE64_LENGTH (inlen);

  /* Check for overflow in outlen computation.
   *
   * If there is no overflow, outlen >= inlen.
   *
   * If the operation (inlen + 2) overflows then it yields at most +1, so
   * outlen is 0.
   *
   * If the multiplication overflows, we lose at least half of the
   * correct value, so the result is < ((inlen + 2) / 3) * 2, which is
   * less than (inlen + 2) * 0.66667, which is less than inlen as soon as
   * (inlen > 4).
   */
  if (inlen > outlen)
    {
      *out = nullptr;
      return 0;
    }

  *out = static_cast<char*>(malloc (outlen));
  if (!*out)
    return outlen;

  base64_encode (in, inlen, *out, outlen);

  return outlen - 1;
}

static bool decode_4 ( char const *  in, size_t  inlen, char **  outp, size_t *  outleft  )

inlinestatic

Definition at line 375 of file base64.cc.

References b64, isbase64(), MillePedeFileConverter_cfg::out, return_false, and to_uchar().

Referenced by base64_decode_ctx().

{
  char *out = *outp;
  if (inlen < 2)
    return false;

  if (!isbase64 (in[0]) || !isbase64 (in[1]))
    return false;

  if (*outleft)
    {
      *out++ = ((b64[to_uchar (in[0])] << 2)
                | (b64[to_uchar (in[1])] >> 4));
      --*outleft;
    }

  if (inlen == 2)
    return_false;

  if (in[2] == '=')
    {
      if (inlen != 4)
        return_false;

      if (in[3] != '=')
        return_false;
    }
  else
    {
      if (!isbase64 (in[2]))
        return_false;

      if (*outleft)
        {
          *out++ = (((b64[to_uchar (in[1])] << 4) & 0xf0)
                    | (b64[to_uchar (in[2])] >> 2));
          --*outleft;
        }

      if (inlen == 3)
        return_false;

      if (in[3] == '=')
        {
          if (inlen != 4)
            return_false;
        }
      else
        {
          if (!isbase64 (in[3]))
            return_false;

          if (*outleft)
            {
              *out++ = (((b64[to_uchar (in[2])] << 6) & 0xc0)
                        | b64[to_uchar (in[3])]);
              --*outleft;
            }
        }
    }

  *outp = out;
  return true;
}

static char* get_4 ( struct base64_decode_context *  ctx, char const **  in, char const *  in_end, size_t *  n_non_newline  )

inlinestatic

Definition at line 321 of file base64.cc.

References base64_decode_context::buf, EnergyCorrector::c, base64_decode_context::i, recoMuon::in, AlCaHLTBitMon_ParallelJobs::p, and lumiQTWidget::t.

Referenced by base64_decode_ctx().

{
  if (ctx->i == 4)
    ctx->i = 0;

  if (ctx->i == 0)
    {
      char const *t = *in;
      if (4 <= in_end - *in && memchr (t, '\n', 4) == nullptr)
        {
          /* This is the common case: no newline.  */
          *in += 4;
          *n_non_newline = 4;
          return (char *) t;
        }
    }

  {
    /* Copy non-newline bytes into BUF.  */
    char const *p = *in;
    while (p < in_end)
      {
        char c = *p++;
        if (c != '\n')
          {
            ctx->buf[ctx->i++] = c;
            if (ctx->i == 4)
              break;
          }
      }

    *in = p;
    *n_non_newline = ctx->i;
    return ctx->buf;
  }
}

bool isbase64

(

char

ch

)

Definition at line 301 of file base64.cc.

References b64, to_uchar(), and uchar_in_range.

Referenced by decode_4().

{
  return uchar_in_range (to_uchar (ch)) && 0 <= b64[to_uchar (ch)];
}

static unsigned char to_uchar ( char  ch )

inlinestatic

Definition at line 60 of file base64.cc.

Referenced by base64_encode(), decode_4(), and isbase64().

{
  return ch;
}

Variable Documentation

const signed char b64[0x100]

static

Definition at line 224 of file base64.cc.

Referenced by decode_4(), and isbase64().