ffi-hydrogen 0.1.0

data/vendor/stringencoders/src/modp_b64r.c

@@ -0,0 +1,254 @@
+/**
+ * \file modp_b64r.c
+ * <PRE>
+ * MODP_B64 - High performance base64 encoder/decoder
+ * https://github.com/client9/stringencoders
+ *
+ * Copyright &copy; 2005-2016 Nick Galbreath
+ * All rights reserved.
+ * Released under MIT license. See LICENSE for details.
+ * </PRE>
+ */
+
+/*
+ * If you are ripping this out of the library, comment out the next
+ * line and uncomment the next lines as approrpiate
+ */
+// #include "config.h"
+
+/* public header */
+#include "modp_b64r.h"
+
+/* if on motorola, sun, ibm; uncomment this */
+/* #define WORDS_BIGENDIAN 1 */
+/* else for Intel, Amd; uncomment this */
+/* #undef WORDS_BIGENDIAN */
+
+#include "modp_b64r_data.h"
+
+#define BADCHAR 0x01FFFFFF
+
+/**
+ * you can control if we use padding by commenting out this
+ * next line.  However, I highly recommend you use padding and not
+ * using it should only be for compatibility with a 3rd party.
+ * Also, 'no padding' is not tested!
+ */
+#define DOPAD 1
+
+/*
+ * if we aren't doing padding
+ * set the pad character to NULL
+ */
+#ifndef DOPAD
+#undef CHARPAD
+#define CHARPAD '\0'
+#endif
+
+size_t modp_b64r_encode(char* dest, const char* str, size_t len)
+{
+    size_t i = 0;
+    const uint8_t* s = (const uint8_t*)str;
+    uint8_t* p = (uint8_t*)dest;
+
+    /* unsigned here is important! */
+    /* uint8_t is fastest on G4, amd */
+    /* uint32_t is fastest on Intel */
+    uint32_t t1, t2, t3;
+
+    if (len > 2) {
+        for (i = 0; i < len - 2; i += 3) {
+            t1 = s[i];
+            t2 = s[i + 1];
+            t3 = s[i + 2];
+            *p++ = e0[t1];
+            *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+            *p++ = e1[((t2 & 0x0F) << 2) | ((t3 >> 6) & 0x03)];
+            *p++ = e2[t3];
+        }
+    }
+
+    switch (len - i) {
+    case 0:
+        break;
+    case 1:
+        t1 = s[i];
+        *p++ = e0[t1];
+        *p++ = e1[(t1 & 0x03) << 4];
+        *p++ = CHARPAD;
+        *p++ = CHARPAD;
+        break;
+    default: /* case 2 */
+        t1 = s[i];
+        t2 = s[i + 1];
+        *p++ = e0[t1];
+        *p++ = e1[((t1 & 0x03) << 4) | ((t2 >> 4) & 0x0F)];
+        *p++ = e2[(t2 & 0x0F) << 2];
+        *p++ = CHARPAD;
+    }
+
+    *p = '\0';
+    return (size_t)(p - (uint8_t*)dest);
+}
+
+#ifdef WORDS_BIGENDIAN /* BIG ENDIAN -- SUN / IBM / MOTOROLA */
+size_t modp_b64r_decode(char* dest, const char* src, size_t len)
+{
+    size_t i;
+    if (len == 0)
+        return 0;
+
+#ifdef DOPAD
+    /* if padding is used, then the message must be at least
+       4 chars and be a multiple of 4.
+       there can be at most 2 pad chars at the end */
+    if (len < 4 || (len % 4 != 0))
+        return -1;
+    if (src[len - 1] == CHARPAD) {
+        len--;
+        if (src[len - 1] == CHARPAD) {
+            len--;
+        }
+    }
+#endif /* DOPAD */
+
+    size_t leftover = len % 4;
+    size_t chunks = (leftover == 0) ? len / 4 - 1 : len / 4;
+
+    uint8_t* p = (uint8_t*)dest;
+    uint32_t x = 0;
+    uint32_t* destInt = (uint32_t*)p;
+    uint32_t* srcInt = (uint32_t*)src;
+    uint32_t y = *srcInt++;
+    for (i = 0; i < chunks; ++i) {
+        x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] | d2[y >> 8 & 0xff] | d3[y & 0xff];
+
+        if (x >= BADCHAR)
+            return -1;
+        *destInt = x << 8;
+        p += 3;
+        destInt = (uint32_t*)p;
+        y = *srcInt++;
+    }
+
+    switch (leftover) {
+    case 0:
+        x = d0[y >> 24 & 0xff] | d1[y >> 16 & 0xff] | d2[y >> 8 & 0xff] | d3[y & 0xff];
+        if (x >= BADCHAR)
+            return -1;
+        *p++ = ((uint8_t*)&x)[1];
+        *p++ = ((uint8_t*)&x)[2];
+        *p = ((uint8_t*)&x)[3];
+        return (chunks + 1) * 3;
+#ifndef DOPAD
+    case 1: /* with padding this is an impossible case */
+        x = d3[y >> 24];
+        *p = (uint8_t)x;
+        break;
+#endif
+    case 2:
+        x = d3[y >> 24] * 64 + d3[(y >> 16) & 0xff];
+        *p = (uint8_t)(x >> 4);
+        break;
+    default: /* case 3 */
+        x = (d3[y >> 24] * 64 + d3[(y >> 16) & 0xff]) * 64 + d3[(y >> 8) & 0xff];
+        *p++ = (uint8_t)(x >> 10);
+        *p = (uint8_t)(x >> 2);
+        break;
+    }
+
+    if (x >= BADCHAR)
+        return -1;
+    return 3 * chunks + (6 * leftover) / 8;
+}
+
+#else /* LITTLE  ENDIAN -- INTEL AND FRIENDS */
+
+size_t modp_b64r_decode(char* dest, const char* src, size_t len)
+{
+    size_t i;
+    size_t leftover;
+    size_t chunks;
+
+    uint8_t* p;
+    uint32_t x;
+    uint32_t* destInt;
+    const uint32_t* srcInt = (const uint32_t*)src;
+    uint32_t y = *srcInt++;
+
+    if (len == 0)
+        return 0;
+
+#ifdef DOPAD
+    /*
+     * if padding is used, then the message must be at least
+     * 4 chars and be a multiple of 4
+     */
+    if (len < 4 || (len % 4 != 0)) {
+        return (size_t)-1; /* error */
+    }
+    /* there can be at most 2 pad chars at the end */
+    if (src[len - 1] == CHARPAD) {
+        len--;
+        if (src[len - 1] == CHARPAD) {
+            len--;
+        }
+    }
+#endif
+
+    leftover = len % 4;
+    chunks = (leftover == 0) ? len / 4 - 1 : len / 4;
+
+    p = (uint8_t*)dest;
+    x = 0;
+    destInt = (uint32_t*)p;
+    srcInt = (const uint32_t*)src;
+    y = *srcInt++;
+    for (i = 0; i < chunks; ++i) {
+        x = d0[y & 0xff] | d1[(y >> 8) & 0xff] | d2[(y >> 16) & 0xff] | d3[(y >> 24) & 0xff];
+
+        if (x >= BADCHAR) {
+            return (size_t)-1;
+        }
+        *destInt = x;
+        p += 3;
+        destInt = (uint32_t*)p;
+        y = *srcInt++;
+    }
+
+    switch (leftover) {
+    case 0:
+        x = d0[y & 0xff] | d1[(y >> 8) & 0xff] | d2[(y >> 16) & 0xff] | d3[(y >> 24) & 0xff];
+
+        if (x >= BADCHAR) {
+            return (size_t)-1;
+        }
+        *p++ = ((uint8_t*)(&x))[0];
+        *p++ = ((uint8_t*)(&x))[1];
+        *p = ((uint8_t*)(&x))[2];
+        return (chunks + 1) * 3;
+#ifndef DOPAD
+    case 1: /* with padding this is an impossible case */
+        x = d0[y & 0xff];
+        *p = *((uint8_t*)(&x)); /* i.e. first char/byte in int */
+        break;
+#endif
+    case 2: /* case 2, 1  output byte */
+        x = d0[y & 0xff] | d1[y >> 8 & 0xff];
+        *p = *((uint8_t*)(&x)); /* i.e. first char */
+        break;
+    default: /* case 3, 2 output bytes */
+        x = d0[y & 0xff] | d1[y >> 8 & 0xff] | d2[y >> 16 & 0xff]; /* 0x3c */
+        *p++ = ((uint8_t*)(&x))[0];
+        *p = ((uint8_t*)(&x))[1];
+        break;
+    }
+
+    if (x >= BADCHAR) {
+        return (size_t)-1;
+    }
+
+    return 3 * chunks + (6 * leftover) / 8;
+}
+
+#endif /* if bigendian / else / endif */

data/vendor/stringencoders/src/modp_b64r.h

@@ -0,0 +1,242 @@
+/**
+ * \file
+ * <PRE>
+ * High performance WEB-SAFE base64 encoder / decoder
+ *
+ * Copyright &copy; 2005-2016 Nick Galbreath -- nickg [at] client9 [dot] com
+ * All rights reserved.
+ *
+ * https://github.com/client9/stringencoders/
+ *
+ * Released under MIT license.  See LICENSE for details.
+ * </pre>
+ *
+ * This uses a "URL-safe" or "WEB-safe" encoding.  THe standard
+ * base 64 encoding uses the characters '+', '/' and '=' have special
+ * restrictions when used inside a URL.
+ *
+ * This uses "+" to "-", "/" to "_", and "=" to "." as the replacement
+ * alphabet.
+ *
+ * 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 COM_MODP_STRINGENCODERS_B64R
+#define COM_MODP_STRINGENCODERS_B64R
+
+#ifdef __cplusplus
+#define BEGIN_C extern "C" {
+#define END_C }
+#else
+#define BEGIN_C
+#define END_C
+#endif
+
+BEGIN_C
+#include "modp_stdint.h"
+
+/**
+ * Encode a raw binary string into web-safe base 64.
+ * \param[out] dest should be allocated by the caller to contain
+ *   at least modp_b64w_encode_len(len) bytes (see below)
+ *   This will contain the null-terminated b64w 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_b64w_encode_len);
+ * int len = modp_b64w_encode(dest, src, sourcelen);
+ * if (len == -1) {
+ *   printf("Error\n");
+ * } else {
+ *   printf("b64w = %s\n", dest);
+ * }
+ * \endcode
+ *
+ */
+size_t modp_b64r_encode(char* dest, const char* src, size_t len);
+
+/**
+ * Decode a web-safe base64 encoded string
+ *
+ * \param[out] dest should be allocated by the caller to contain at least
+ *    len * 3 / 4 bytes.
+ * \param[in] src should contain exactly len bytes of b64r 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_b64r_decode_len(srclen));
+ * int len = modp_b64r_decode(dest, src, sourcelen);
+ * if (len == -1) { error }
+ * \endcode
+ */
+size_t modp_b64r_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_b64r_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 b64r
+ * decode  4 chars turn into 3 bytes
+ * floor[len * 3/4] + 2
+ */
+#define modp_b64r_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* b64rencoded = "...";
+ * int len = strlen(b64rencoded);
+ *
+ * struct datastuff foo;
+ * if (modp_b64r_encode_strlen(sizeof(struct datastuff)) != len) {
+ *    // wrong size
+ *    return false;
+ * } else {
+ *    // safe to do;
+ *    if (modp_b64r_decode((char*) &foo, b64rencoded, len) == -1) {
+ *      // bad characters
+ *      return false;
+ *    }
+ * }
+ * // foo is filled out now
+ * \endcode
+ */
+#define modp_b64r_encode_strlen(A) ((A + 2) / 3 * 4)
+
+END_C
+
+#ifdef __cplusplus
+#include <cstring>
+#include <string>
+
+namespace modp {
+
+/** \brief b64r 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 b64r string.  Empty if failed.
+     */
+inline std::string b64r_encode(const char* s, size_t len)
+{
+    std::string x(modp_b64r_encode_len(len), '\0');
+    size_t d = modp_b64r_encode(const_cast<char*>(x.data()), s,
+        static_cast<int>(len));
+    if (d == (size_t)-1) {
+        x.clear();
+    } else {
+        x.erase(d, std::string::npos);
+    }
+    return x;
+}
+
+/** \brief b64r encode a cstr
+     *
+     * \param[in] s the input string to encode
+     * \return a newly allocated b64r string.  Empty if failed.
+     */
+inline std::string b64r_encode(const char* s)
+{
+    return b64r_encode(s, static_cast<int>(strlen(s)));
+}
+
+/** \brief b64r encode a const std::string
+     *
+     * \param[in] s the input string to encode
+     * \return a newly allocated b64r string.  Empty if failed.
+     */
+inline std::string b64r_encode(const std::string& s)
+{
+    return b64r_encode(s.data(), s.size());
+}
+
+/** \brief self-modifing b64r encode
+     *
+     * web-safe base 64 decode a string (self-modifing)
+     * On failure, the string is empty.
+     *
+     * \param[in,out] s the string to be decoded
+     * \return a reference to the input string
+     */
+inline std::string& b64r_encode(std::string& s)
+{
+    std::string x(b64r_encode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+inline std::string b64r_decode(const char* src, size_t len)
+{
+    std::string x(modp_b64r_decode_len(len) + 1, '\0');
+    size_t d = modp_b64r_decode(const_cast<char*>(x.data()), src,
+        static_cast<int>(len));
+    if (d == (size_t)-1) {
+        x.clear();
+    } else {
+        x.erase(d, std::string::npos);
+    }
+    return x;
+}
+
+inline std::string b64r_decode(const char* src)
+{
+    return b64r_decode(src, strlen(src));
+}
+
+/**
+     * 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& b64r_decode(std::string& s)
+{
+    std::string x(b64r_decode(s.data(), s.size()));
+    s.swap(x);
+    return s;
+}
+
+inline std::string b64r_decode(const std::string& s)
+{
+    return b64r_decode(s.data(), s.size());
+}
+}
+
+#endif /* __cplusplus */
+
+#endif /* MODP_B64R */