text: /**
   * \file
   * <PRE>
   * High performance base64 encoder / decoder
   * Version 1.3 -- 17-Mar-2006
   *
   * Copyright &copy; 2005, 2006, Nick Galbreath -- nickg [at] modp [dot] com
   * All rights reserved.
   *
   * http://modp.com/release/base64
   *
   * Released under bsd license.  See modp_b64.c for details.
   * </pre>
   *
   * The default implementation is the standard b64 encoding with padding.
   * It's easy to change this to use "URL safe" characters and to remove
   * padding.  See the modp_b64.c source code for details.
   *
   */
  
  #ifndef MODP_B64
  #define MODP_B64
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  /**
   * Encode a raw binary string into base 64.
   * src contains the bytes
   * len contains the number of bytes in the src
   * dest should be allocated by the caller to contain
   *   at least modp_b64_encode_len(len) bytes (see below)
   *   This will contain the null-terminated b64 encoded result
   * returns length of the destination string plus the ending null byte
   *    i.e.  the result will be equal to strlen(dest) + 1
   *
   * Example
   * 
   * \code
   * char* src = ...;
   * int srclen = ...; //the length of number of bytes in src
   * char* dest = (char*) malloc(modp_b64_encode_len);
   * int len = modp_b64_encode(dest, src, sourcelen);
   * if (len == -1) {
   *   printf("Error\n");
   * } else {
   *   printf("b64 = %s\n", dest);
   * }
   * \endcode
   *
   */
  int modp_b64_encode(char *dest, const char *str, int len);
  
  /**
   * Decode a base64 encoded string
   *
   * src should contain exactly len bytes of b64 characters.
   *     if src contains -any- non-base characters (such as white
   *     space, -1 is returned.
   *
   * dest should be allocated by the caller to contain at least
   *    len * 3 / 4 bytes.
   *
   * Returns the length (strlen) of the output, or -1 if unable to
   * decode
   *
   * \code
   * char* src = ...;
   * int srclen = ...; // or if you don't know use strlen(src)
   * char* dest = (char*) malloc(modp_b64_decode_len(srclen));
   * int len = modp_b64_decode(dest, src, sourcelen);
   * if (len == -1) { error }
   * \endcode
   */
  int modp_b64_decode(char *dest, const char *src, int len);
  
  /**
   * Given a source string of length len, this returns the amount of
   * memory the destination string should have.
   *
   * remember, this is integer math
   * 3 bytes turn into 4 chars
   * ceiling[len / 3] * 4 + 1
   *
   * +1 is for any extra null.
   */
  #define modp_b64_encode_len(A) ((A+2)/3 * 4 + 1)
  
  /**
   * Given a base64 string of length len,
   *   this returns the amount of memory required for output string
   *  It maybe be more than the actual number of bytes written.
   * NOTE: remember this is integer math
   * this allocates a bit more memory than traditional versions of b64
   * decode  4 chars turn into 3 bytes
   * floor[len * 3/4] + 2
   */
  #define modp_b64_decode_len(A) (A / 4 * 3 + 2)
  
  /**
   * Will return the strlen of the output from encoding.
   * This may be less than the required number of bytes allocated.
   *
   * This allows you to 'deserialized' a struct
   * \code
   * char* b64encoded = "...";
   * int len = strlen(b64encoded);
   *
   * struct datastuff foo;
   * if (modp_b64_encode_strlen(sizeof(struct datastuff)) != len) {
   *    // wrong size
   *    return false;
   * } else {
   *    // safe to do;
   *    if (modp_b64_decode((char*) &foo, b64encoded, len) == -1) {
   *      // bad characters
   *      return false;
   *    }
   * }
   * // foo is filled out now
   * \endcode
   */
  #define modp_b64_encode_strlen(A) ((A + 2)/ 3 * 4)
  
  #ifdef __cplusplus
  }
  
  #include <string>
  
  inline std::string &modp_b64_encode(std::string &s) {
    std::string x(modp_b64_encode_len(s.size()), '\0');
    int d = modp_b64_encode(const_cast<char *>(x.data()), s.data(), s.size());
    x.erase(d, std::string::npos);
    s.swap(x);
    return s;
  }
  
  /**
   * base 64 decode a string (self-modifing)
   * On failure, the string is empty.
   *
   * This function is for C++ only (duh)
   *
   * \param[in,out] s the string to be decoded
   * \return a reference to the input string
   */
  inline std::string &modp_b64_decode(std::string &s) {
    std::string x(modp_b64_decode_len(s.size()), '\0');
    int d = modp_b64_decode(const_cast<char *>(x.data()), s.data(), s.size());
    if (d < 0) {
      x.clear();
    } else {
      x.erase(d, std::string::npos);
    }
    s.swap(x);
    return s;
  }
  
  #endif /* __cplusplus */
  
  #endif /* MODP_B64 */
  