flutter::Base64 Struct Reference

#include <base64.h>

Public Types
enum class	Error { kNone , kBadPadding , kBadChar }

Static Public Member Functions
static size_t	Encode (const void *src, size_t length, void *dst)
static size_t	EncodedSize (size_t srcDataLength)
static Error	Decode (const void *src, size_t srcLength, void *dst, size_t *dstLength)

Detailed Description

Definition at line 12 of file base64.h.

Member Enumeration Documentation

Error

enum class flutter::Base64::Error

strong

Enumerator
kNone
kBadPadding
kBadChar

Definition at line 14 of file base64.h.

                   {
    kNone,
    kBadPadding,
    kBadChar,
  };

Member Function Documentation

Decode()

Base64::Error flutter::Base64::Decode ( const void *  src, size_t  srcLength, void *  dst, size_t *  dstLength  )

static

Base64 decodes src into dst.

This can be called once with 'dst' nullptr to get the required size, then again with an allocated 'dst' pointer to do the actual decoding.

Parameters

dst	nullptr or a pointer to a buffer large enough to receive the result
dstLength	assigned the length dst is required to be. Must not be nullptr.

Definition at line 28 of file base64.cc.

                                                {
  const unsigned char* src = static_cast<const unsigned char*>(srcv);
  unsigned char* dst = static_cast<unsigned char*>(dstv);
 
  int i = 0;
  bool padTwo = false;
  bool padThree = false;
  char unsigned const* const end = src + srcLength;
  while (src < end) {
    unsigned char bytes[4] = {0, 0, 0, 0};
    int byte = 0;
    do {
      unsigned char srcByte = *src++;
      if (srcByte == 0) {
        *dstLength = i;
        return Error::kNone;
      }
      if (srcByte <= ' ') {
        continue;  // treat as white space
      }
      if (srcByte < '+' || srcByte > 'z') {
        return Error::kBadChar;
      }
      signed char decoded = kDecodeData[srcByte - '+'];
      bytes[byte] = decoded;
      if (decoded != DecodePad) {
        if (decoded < 0) {
          return Error::kBadChar;
        }
        byte++;
        if (*src) {
          continue;
        }
        if (byte == 0) {
          *dstLength = i;
          return Error::kNone;
        }
        if (byte == 4) {
          break;
        }
      }
      // As an optimization, if we find an equals sign
      // we assume all future bytes to read are the
      // appropriate number of padding equals signs.
      if (byte < 2) {
        return Error::kBadPadding;
      }
      padThree = true;
      if (byte == 2) {
        padTwo = true;
      }
      break;
    } while (byte < 4);
    int two = 0;
    int three = 0;
    if (dst) {
      int one = (uint8_t)(bytes[0] << 2);
      two = bytes[1];
      one |= two >> 4;
      two = (uint8_t)((two << 4) & 0xFF);
      three = bytes[2];
      two |= three >> 2;
      three = (uint8_t)((three << 6) & 0xFF);
      three |= bytes[3];
      FML_DCHECK(one < 256 && two < 256 && three < 256);
      dst[i] = (unsigned char)one;
    }
    i++;
    if (padTwo) {
      break;
    }
    if (dst) {
      dst[i] = (unsigned char)two;
    }
    i++;
    if (padThree) {
      break;
    }
    if (dst) {
      dst[i] = (unsigned char)three;
    }
    i++;
  }
  *dstLength = i;
  return Error::kNone;
}

Encode()

size_t flutter::Base64::Encode ( const void *  src, size_t  length, void *  dst  )

static

Base64 encodes src into dst.

Parameters

dst	a pointer to a buffer large enough to receive the result.

Returns

the required length of dst for encoding.

Definition at line 118 of file base64.cc.

                                                                 {
  FML_DCHECK(dstv);
  const unsigned char* src = static_cast<const unsigned char*>(srcv);
  unsigned char* dst = static_cast<unsigned char*>(dstv);
 
  const char* encode = kDefaultEncode;
  size_t remainder = length % 3;
  char unsigned const* const end = &src[length - remainder];
  while (src < end) {
    unsigned a = *src++;
    unsigned b = *src++;
    unsigned c = *src++;
    int d = c & 0x3F;
    c = (c >> 6 | b << 2) & 0x3F;
    b = (b >> 4 | a << 4) & 0x3F;
    a = a >> 2;
    // NOLINTBEGIN(clang-analyzer-core.NullDereference)
    *dst++ = encode[a];
    *dst++ = encode[b];
    *dst++ = encode[c];
    *dst++ = encode[d];
    // NOLINTEND(clang-analyzer-core.NullDereference)
  }
  if (remainder > 0) {
    int k1 = 0;
    int k2 = EncodePad;
    int a = (uint8_t)*src++;
    if (remainder == 2) {
      int b = *src++;
      k1 = b >> 4;
      k2 = (b << 2) & 0x3F;
    }
    // NOLINTBEGIN(clang-analyzer-core.NullDereference)
    *dst++ = encode[a >> 2];
    *dst++ = encode[(k1 | a << 4) & 0x3F];
    *dst++ = encode[k2];
    *dst++ = encode[EncodePad];
    // NOLINTEND(clang-analyzer-core.NullDereference)
  }
  return EncodedSize(length);
}

EncodedSize()

static size_t flutter::Base64::EncodedSize ( size_t  srcDataLength )

inlinestatic

Returns the length of the buffer that needs to be allocated to encode srcDataLength bytes.

Definition at line 33 of file base64.h.

                                                  {
    // Take the floor of division by 3 to find the number of groups that need to
    // be encoded. Each group takes 4 bytes to be represented in base64.
    return ((srcDataLength + 2) / 3) * 4;
  }

---

The documentation for this struct was generated from the following files:

• shell/common/base64.h
• shell/common/base64.cc