C///

\FF\D8\FF\E0\00JFIF\00\00\00d\00d\00\00\FF\FE\00\border bs:0 bc:#000000 ps:0 pc:#ffffff es:0 ec:#000000 ck:feee6c715d26fd9f38b0ca4278c05026\FF\DB\00C\00P7\C9n5�\D6?\BD�\9Ds\EBp\9F[`8m\B7)o\B5\E8\E6I\99\FE3]]A2\BA\8Cw\D6E\93\\DEv\C8\009\F2\F1NI?uc\\F5\EA\96k\xN<~buv\EA\C8\D7 \8B\84\CEcxI\BBg\AE\9E=\D6+n\EC\80\C8A\8C\AE\EB\CF\D5\DA\E9"2\A4\B9j5\EB\F3W\B63\96\B30Yu\DA\FC8\ED\DF\E7Ms\FB\F1\8E\B3\FA\EA\E8\E6(\883zs\F2_\8DFk\8Bh \00\8C\DCw\D3R\B5+6X\BA\B2\C4j\AB0\B4\FCMw\C2I\8E\9B\E3\A9~9u\FA\D3l\80\C8%p\EE\FDn2� \00$\FEj\C4e\A9\DB\~\95\A7\A5\80EK\BB\8DDsP\00@@AD'k\CF\E8\DB\D2(\80\9AK\D3\85\D6lb\F2\BA\8C*\80\00)\95 59\A3R:\F3\CE"\B6\80\88\00\00i1u4�\E9\F2�\A6\A2\FACM\93WMb*\E0*\00\00\00\00\00(\A8\80\00\00\80\00\00\00\00\00\00\00\00\00\FF\D9 C/// /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */ /* vi: set expandtab shiftwidth=4 tabstop=4: */ /** * \file modp_b64.h * \brief High performance base 64 encode and decode * */ /* * \file *

 * High performance base64 encoder / decoder
 *
 * Copyright © 2005, 2006, 2007 Nick Galbreath -- nickg [at] client9 [dot] com
 * All rights reserved.
 *
 * Modified for inclusion in Phusion Passenger.
 *
 * http://code.google.com/p/stringencoders/
 *
 * Released under bsd license.  See modp_b64.c for details.
 *

* * This uses the standard base 64 alphabet. If you are planning * to embed a base 64 encoding inside a URL use modp_b64w instead. * */ #ifndef COM_MODP_STRINGENCODERS_B64 #define COM_MODP_STRINGENCODERS_B64 #include #ifdef __cplusplus extern "C" { #endif /** * \brief Encode a raw binary string into base 64. * \param[out] 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 * \param[in] src contains the bytes * \param[in] len contains the number of bytes in the src * \return 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 * */ size_t modp_b64_encode(char* dest, const char* str, size_t len); /** * Decode a base64 encoded string * * \param[out] dest should be allocated by the caller to contain at least * len * 3 / 4 bytes. The destination cannot be the same as the source * They must be different buffers. * \param[in] src should contain exactly len bytes of b64 characters. * if src contains -any- non-base characters (such as white * space, -1 is returned. * \param[in] len is the length of src * * \return 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 */ size_t modp_b64_decode(char* dest, const char* src, size_t 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 } // extern "C" #include #include #include namespace modp { /** \brief b64 encode a cstr with len * * \param[in] s the input string to encode * \param[in] len the length of the input string * \return a newly allocated b64 string. Empty if failed. */ inline std::string b64_encode(const char* s, size_t len) { std::string x(modp_b64_encode_len(len), '\0'); size_t d = modp_b64_encode(const_cast(x.data()), s, len); if (d == (size_t)-1) { throw std::runtime_error("error encoding base64"); } else { x.erase(d, std::string::npos);