base64.h

// Copyright 2020 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
 
// Functions for encoding and decoding data in Base64 as specified by RFC 3548
// and RFC 4648. See https://tools.ietf.org/html/rfc4648
#pragma once
 
#include <stdbool.h>
#include <stddef.h>
 
// C-compatible versions of a subset of the pw_base64 module.
#ifdef __cplusplus
extern "C" {
#endif  // __cplusplus
 
// Returns the size of the given number of bytes when encoded as Base64. Base64
//
// Equivalent to pw::base64::EncodedSize().
#define PW_BASE64_ENCODED_SIZE(binary_size_bytes) \
  (((size_t)binary_size_bytes + 2) / 3 * 4)  // +2 to round up to a 3-byte group
 
// Encodes the provided data in Base64 and writes the result to the buffer.
// Exactly PW_BASE64_ENCODED_SIZE(binary_size_bytes) bytes will be written. The
// output buffer *MUST* be large enough for the encoded output!
//
// Equivalent to pw::base64::Encode().
void pw_Base64Encode(const void* binary_data,
                     const size_t binary_size_bytes,
                     char* output);
 
// Evaluates to the maximum size of decoded Base64 data in bytes.
//
// Returns 0 if the size is not a multiple of 4.
//
// Equivalent to pw::base64::MaxDecodedSize().
#define PW_BASE64_MAX_DECODED_SIZE(base64_size_bytes) \
  (((base64_size_bytes % 4) == 0) ? ((size_t)base64_size_bytes) / 4 * 3 : 0)
 
// Decodes the provided Base64 data into raw binary. The output buffer *MUST* be
// at least PW_BASE64_MAX_DECODED_SIZE bytes large.
//
// Equivalent to pw::base64::Decode().
size_t pw_Base64Decode(const char* base64,
                       size_t base64_size_bytes,
                       void* output);
 
// Returns true if provided char is a valid non-padding Base64 character.
bool pw_Base64IsValidChar(char base64_char);
 
// Returns true if the provided string is valid Base64 encoded data. Accepts
// either the standard (+/) or URL-safe (-_) alphabets.
//
// Equivalent to pw::base64::IsValid().
bool pw_Base64IsValid(const char* base64_data, size_t base64_size);
 
// C++ API, which uses the C functions internally.
#ifdef __cplusplus
}  // extern "C"
 
#include <string_view>
#include <type_traits>
 
#include "pw_span/span.h"
#include "pw_string/string.h"
 
namespace pw::base64 {
 
constexpr size_t EncodedSize(size_t binary_size_bytes) {
  return PW_BASE64_ENCODED_SIZE(binary_size_bytes);
}
 
inline void Encode(span<const std::byte> binary, char* output) {
  pw_Base64Encode(binary.data(), binary.size_bytes(), output);
}
 
size_t Encode(span<const std::byte> binary, span<char> output_buffer);
 
void Encode(span<const std::byte> binary, InlineString<>& output);
 
template <size_t kMaxBinaryDataSizeBytes>
inline InlineString<EncodedSize(kMaxBinaryDataSizeBytes)> Encode(
    span<const std::byte> binary) {
  InlineString<EncodedSize(kMaxBinaryDataSizeBytes)> output;
  Encode(binary, output);
  return output;
}
 
constexpr size_t MaxDecodedSize(size_t base64_size_bytes) {
  return PW_BASE64_MAX_DECODED_SIZE(base64_size_bytes);
}
 
constexpr size_t DecodedSize(std::string_view valid_base64) {
  if ((valid_base64.size() % 4) != 0 || valid_base64.empty()) {
    return 0;
  }
  const size_t max_bytes = valid_base64.size() / 4 * 3;
  size_t padding = 0;
  if (valid_base64[valid_base64.size() - 2] == '=') {
    padding = 2;
  } else if (valid_base64[valid_base64.size() - 1] == '=') {
    padding = 1;
  }
  return max_bytes - padding;
}
 
inline size_t Decode(std::string_view base64, void* output) {
  return pw_Base64Decode(base64.data(), base64.size(), output);
}
 
size_t Decode(std::string_view base64, span<std::byte> output_buffer);
 
template <typename T>
inline void DecodeInPlace(InlineBasicString<T>& buffer) {
  static_assert(sizeof(T) == sizeof(char));
  buffer.resize(Decode(buffer, buffer.data()));
}
 
inline bool IsValid(std::string_view base64) {
  return pw_Base64IsValid(base64.data(), base64.size());
}
 
inline bool IsValidChar(char base64) { return pw_Base64IsValidChar(base64); }
 
}  // namespace pw::base64
 
#endif  // __cplusplus