mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/strcodecs/base64.c

@@ -0,0 +1,307 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-2012 Couchbase, Inc.
+ *
+ *   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
+ *
+ *       http://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.
+ */
+
+#include "strcodecs.h"
+#include <string.h>
+#include <stdlib.h>
+
+/*
+ * Function to base64 encode a text string as described in RFC 4648
+ *
+ * @author Trond Norbye
+ */
+
+/**
+ * An array of the legal charracters used for direct lookup
+ */
+static const lcb_uint8_t code[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Encode up to 3 characters to 4 output character.
+ *
+ * @param s pointer to the input stream
+ * @param d pointer to the output stream
+ * @param num the number of characters from s to encode
+ * @return 0 upon success, -1 otherwise.
+ */
+static int encode_rest(const lcb_uint8_t *s, lcb_uint8_t *d, lcb_SIZE num)
+{
+    lcb_uint32_t val = 0;
+
+    switch (num) {
+        case 2:
+            val = (lcb_uint32_t)((*s << 16) | (*(s + 1) << 8));
+            break;
+        case 1:
+            val = (lcb_uint32_t)((*s << 16));
+            break;
+        default:
+            return -1;
+    }
+
+    d[3] = '=';
+
+    if (num == 2) {
+        d[2] = code[(val >> 6) & 63];
+    } else {
+        d[2] = '=';
+    }
+
+    d[1] = code[(val >> 12) & 63];
+    d[0] = code[(val >> 18) & 63];
+
+    return 0;
+}
+
+/**
+ * Encode 3 characters to 4 output character.
+ *
+ * @param s pointer to the input stream
+ * @param d pointer to the output stream
+ */
+static int encode_triplet(const lcb_uint8_t *s, lcb_uint8_t *d)
+{
+    lcb_uint32_t val = (lcb_uint32_t)((*s << 16) | (*(s + 1) << 8) | (*(s + 2)));
+    d[3] = code[val & 63];
+    d[2] = code[(val >> 6) & 63];
+    d[1] = code[(val >> 12) & 63];
+    d[0] = code[(val >> 18) & 63];
+
+    return 0;
+}
+
+/**
+ * Base64 encode a string into an output buffer.
+ * @param src string to encode
+ * @param dst destination buffer
+ * @param sz size of destination buffer
+ * @return 0 if success, -1 if the destination buffer isn't big enough
+ */
+int lcb_base64_encode(const char *src, lcb_SIZE len, char *dst, lcb_SIZE sz)
+{
+    lcb_SIZE triplets = len / 3;
+    lcb_SIZE rest = len % 3;
+    lcb_SIZE ii;
+    const lcb_uint8_t *in = (const lcb_uint8_t *)src;
+    lcb_uint8_t *out = (lcb_uint8_t *)dst;
+
+    if (sz < (lcb_SIZE)((triplets + 1) * 4)) {
+        return -1;
+    }
+
+    for (ii = 0; ii < triplets; ++ii) {
+        if (encode_triplet(in, out) != 0) {
+            return -1;
+        }
+        in += 3;
+        out += 4;
+    }
+
+    if (rest > 0) {
+        if (encode_rest(in, out, rest) != 0) {
+            return -1;
+        }
+        out += 4;
+    }
+    *out = '\0';
+
+    return 0;
+}
+
+int lcb_base64_encode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *ndst)
+{
+    lcb_SIZE len = (nsrc / 3 + 1) * 4 + 1;
+    char *ptr = calloc(len, sizeof(char));
+    int rc = lcb_base64_encode(src, nsrc, ptr, len);
+    if (rc == 0) {
+        *ndst = strlen(ptr);
+        *dst = ptr;
+    } else {
+        free(ptr);
+    }
+    return rc;
+}
+
+void lcb_base64_encode_iov(lcb_IOV *iov, unsigned niov, unsigned nb, char **dst, int *ndst)
+{
+    lcb_SIZE nsrc = 0;
+    lcb_SIZE len;
+    char *ptr;
+    lcb_SIZE io;
+
+
+    for (io = 0; io < niov; io++) {
+        nsrc += iov[io].iov_len;
+    }
+    if (nb < nsrc) {
+        nsrc = nb;
+    }
+    len = (nsrc / 3 + 1) * 4 + 1;
+    ptr = calloc(len, sizeof(char));
+
+    {
+        lcb_SIZE triplets = nsrc / 3;
+        lcb_SIZE rest = nsrc % 3;
+        lcb_uint8_t *out = (lcb_uint8_t *)ptr;
+        lcb_SIZE iop, ii;
+        lcb_uint8_t triplet[3];
+
+        io = 0;
+        iop = 0;
+
+
+        for (ii = 0; ii < triplets; ii++) {
+            int tt;
+
+            for (tt = 0; tt < 3; tt++) {
+                if (iop >= iov[io].iov_len) {
+                    io++;
+                    iop = 0;
+                }
+                triplet[tt] = ((const lcb_uint8_t *)iov[io].iov_base)[iop++];
+            }
+            encode_triplet(triplet, out);
+            out += 4;
+        }
+
+        if (rest > 0) {
+            for (ii = 0; ii < rest; ii++) {
+                if (iop >= iov[io].iov_len) {
+                    io++;
+                    iop = 0;
+                }
+                triplet[ii] = ((const lcb_uint8_t *)iov[io].iov_base)[iop++];
+            }
+            encode_rest(triplet, out, rest);
+        }
+        *out = '\0';
+    }
+
+    *ndst = strlen(ptr);
+    *dst = ptr;
+}
+
+static int code2val(char c)
+{
+    if (c >= 'A' && c <= 'Z') {
+        return c - 'A';
+    }
+    if (c >= 'a' && c <= 'z') {
+        return c - 'a' + 26;
+    }
+    if (c >= '0' && c <= '9') {
+        return c - '0' + 52;
+    }
+    if (c == '+') {
+        return 62;
+    }
+    if (c == '/') {
+        return 63;
+    }
+    return -1;
+}
+
+lcb_SSIZE lcb_base64_decode(const char *src, lcb_SIZE nsrc, char *dst, lcb_SIZE ndst)
+{
+    lcb_SIZE offset = 0;
+    lcb_SSIZE idx = 0;
+
+    if (nsrc == 0) {
+        *dst = '\0';
+        return 0;
+    }
+
+    while (offset < nsrc) {
+        int val, ins;
+        lcb_U32 value;
+
+        if (isspace((int)*src)) {
+            ++offset;
+            ++src;
+            continue;
+        }
+
+        // We need at least 4 bytes
+        if ((offset + 4) > nsrc) {
+            return -1;
+        }
+
+        val = code2val(src[0]);
+        if (val < 0) {
+            return -1;
+        }
+        value = val << 18;
+        val = code2val(src[1]);
+        if (val < 0) {
+            return -1;
+        }
+        value |= val << 12;
+
+        ins = 3; /* number of characters to insert */
+        if (src[2] == '=') {
+            ins = 1;
+        } else {
+            value |= code2val(src[2]) << 6;
+            if (src[3] == '=') {
+                ins = 2;
+            } else {
+                value |= code2val(src[3]);
+            }
+        }
+
+        if ((lcb_SIZE)idx >= ndst) {
+            return -1;
+        }
+        dst[idx++] = (char)(value >> 16);
+        if (ins > 1) {
+            if ((lcb_SIZE)idx >= ndst) {
+                return -1;
+            }
+            dst[idx++] = (char)(value >> 8);
+            if (ins > 2) {
+                if ((lcb_SIZE)idx >= ndst) {
+                    return -1;
+                }
+                dst[idx++] = (char)(value);
+            }
+        }
+
+        src += 4;
+        offset += 4;
+    }
+    dst[idx + 1] = '\0';
+
+    return idx;
+}
+
+lcb_SSIZE lcb_base64_decode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *ndst)
+{
+    // To reduce the number of reallocations, start by reserving an
+    // output buffer of 75% of the input size (and add 3 to avoid dealing
+    // with zero)
+    lcb_SIZE len = nsrc * 3 / 4 + 3;
+    char *ptr = calloc(len, sizeof(char));
+
+    lcb_SSIZE rc = lcb_base64_decode(src, nsrc, ptr, len);
+    if (rc < 0) {
+        free(ptr);
+    } else {
+        *ndst = rc;
+        *dst = ptr;
+    }
+    return rc;
+}

data/ext/libcouchbase/src/strcodecs/strcodecs.h

@@ -0,0 +1,302 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 Couchbase, Inc.
+ *
+ *   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
+ *
+ *       http://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.
+ */
+
+#ifndef LCB_STRCODECS_H
+#define LCB_STRCODECS_H
+#include <ctype.h>
+#include <libcouchbase/couchbase.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+lcb_error_t lcb_urlencode_path(const char *path,
+                               lcb_size_t npath,
+                               char **out,
+                               lcb_size_t *nout);
+
+/**
+ * Decode a string from 'percent-encoding'
+ * @param in The input string
+ * @param[in,out] out The output buffer.
+ *                If upon entry, out is not-NULL, it is assumed to be a buffer
+ *                containing sufficient size for the percent encoding (up to
+ *                3x the size of input). Otherwise on exit this will contain
+ *                a malloc'd buffer which should be free()d when no longer
+ *                required.
+ * @param n The size of the input buffer. May be -1 if NUL-terminated
+ * @return 0 if converted successfuly, -1 on error
+ */
+int
+lcb_urldecode(const char *in, char *out, lcb_SSIZE n);
+
+/**
+ * Base64 encode a string into an output buffer.
+ * @param src string to encode
+ * @param len size of source buffer
+ * @param dst destination buffer
+ * @param sz size of destination buffer
+ * @return 0 if success, -1 if the destination buffer isn't big enough
+ */
+int lcb_base64_encode(const char *src, lcb_SIZE len, char *dst, lcb_SIZE sz);
+
+/**
+ * Base64 encode a string into an output buffer.
+ * @param src string to encode
+ * @param len size of source buffer
+ * @param dst destination buffer
+ * @param sz size of destination buffer
+ * @return 0 if success, -1 if function wasn't able to allocate enough memory
+ */
+int lcb_base64_encode2(const char *src, lcb_SIZE len, char **dst, lcb_SIZE *sz);
+
+
+lcb_SSIZE lcb_base64_decode(const char *src, lcb_SIZE nsrc, char *dst, lcb_SIZE ndst);
+lcb_SSIZE lcb_base64_decode2(const char *src, lcb_SIZE nsrc, char **dst, lcb_SIZE *ndst);
+
+void lcb_base64_encode_iov(lcb_IOV *iov, unsigned niov, unsigned nb, char **dst, int *ndst);
+
+/**
+ * Encodes a string suitable for being passed as either a key or value in an
+ * "HTTP Form" per application/x-www-form-urlencoded
+ * @param s The input string
+ * @param n The size of the input
+ * @param out The output buffer - should be at least 3x the input length
+ * @return The number of bytes actually used in the output buffer.
+ */
+size_t
+lcb_formencode(const char *s, size_t n, char *out);
+
+#ifdef __cplusplus
+}
+
+#include <string>
+namespace lcb {
+namespace strcodecs {
+template <typename Ti, typename To>
+bool urldecode(Ti first, Ti last, To out, size_t& nout) {
+    for (; first != last && *first != '\0'; ++first) {
+        if (*first == '%') {
+            char nextbuf[3] = { 0 };
+            size_t jj = 0;
+            first++;
+            nextbuf[0] = *first;
+            for (; first != last && jj < 2; ++jj) {
+                nextbuf[jj] = *first;
+                if (jj != 1) {
+                    first++;
+                }
+            }
+            if (jj != 2) {
+                return false;
+            }
+
+            unsigned octet = 0;
+            if (sscanf(nextbuf, "%2X", &octet) != 1) {
+                return false;
+            }
+
+            *out = static_cast<char>(octet);
+        } else {
+            *out = *first;
+        }
+
+        out++;
+        nout++;
+    }
+    return true;
+}
+
+inline bool
+urldecode(const char *input, char *output) {
+    const char *endp = input + strlen(input);
+    size_t nout = 0;
+    if (urldecode(input, endp, output, nout)) {
+        output[nout] = '\0';
+        return true;
+    }
+    return false;
+}
+
+inline bool
+urldecode(char *in_out) {
+    return urldecode(in_out, in_out);
+}
+
+inline bool
+urldecode(std::string& s)
+{
+    size_t n = 0;
+    if (urldecode(s.begin(), s.end(), s.begin(), n)) {
+        s.resize(n);
+        return true;
+    }
+    return false;
+}
+
+namespace priv {
+inline bool
+is_legal_urichar(char c)
+{
+    unsigned char uc = (unsigned char)c;
+    if (isalpha(uc) || isdigit(uc)) {
+        return true;
+    }
+    switch (uc) {
+    case '-':
+    case '_':
+    case '.':
+    case '~':
+    case '!':
+    case '*':
+    case '\'':
+    case '(':
+    case ')':
+    case ';':
+    case ':':
+    case '@':
+    case '&':
+    case '=':
+    case '+':
+    case '$':
+    case ',':
+    case '/':
+    case '?':
+    case '#':
+    case '[':
+    case ']':
+        return true;
+    default:
+        break;
+    }
+    return false;
+}
+
+template <typename T>
+inline bool
+is_already_escape(T first, T last) {
+    first++; // ignore '%'
+    size_t jj;
+    for (jj = 0; first != last && jj < 2; ++jj, ++first) {
+        if (!isxdigit(*first)) {
+            return false;
+        }
+    }
+    if (jj != 2) {
+        return false;
+    }
+    return true;
+}
+} // namespace: priv
+
+template <typename Ti, typename To>
+bool
+urlencode(Ti first, Ti last, To& o, bool check_encoded=true) {
+    // If re-encoding detection is enabled, this flag indicates not to
+    // re-encode
+    bool skip_encoding = false;
+
+    for (; first != last; ++first) {
+        if (!skip_encoding && check_encoded) {
+            if (*first == '%') {
+                skip_encoding = priv::is_already_escape(first, last);
+            } else if (*first == '+') {
+                skip_encoding = true;
+            }
+        }
+        if (skip_encoding || priv::is_legal_urichar(*first)) {
+            if (skip_encoding && *first != '%' && !priv::is_legal_urichar(*first)) {
+                return false;
+            }
+
+            o.insert(o.end(), first, first + 1);
+        } else {
+            unsigned int c = static_cast<unsigned char>(*first);
+            size_t numbytes;
+
+            if ((c & 0x80) == 0) {  /* ASCII character */
+                numbytes = 1;
+            } else if ((c & 0xE0) == 0xC0) {    /* 110x xxxx */
+                numbytes = 2;
+            } else if ((c & 0xF0) == 0xE0) {    /* 1110 xxxx */
+                numbytes = 3;
+            } else if ((c & 0xF8) == 0xF0) {    /* 1111 0xxx */
+                numbytes = 4;
+            } else {
+                return false;
+            }
+
+            do {
+                char buf[4];
+                sprintf(buf, "%%%02X", static_cast<unsigned char>(*first));
+                o.insert(o.end(), &buf[0], &buf[0] + 3);
+            } while (--numbytes && ++first != last);
+        }
+    }
+    return true;
+}
+template <typename Tin, typename Tout>
+bool
+urlencode(const Tin& in, Tout& out)
+{
+    return urlencode(in.begin(), in.end(), out);
+}
+
+/* See: https://url.spec.whatwg.org/#urlencoded-serializing: */
+/*
+ * 0x2A
+ * 0x2D
+ * 0x2E
+ * 0x30 to 0x39
+ * 0x41 to 0x5A
+ * 0x5F
+ * 0x61 to 0x7A
+ *  Append a code point whose value is byte to output.
+ * Otherwise
+ *  Append byte, percent encoded, to output.
+ */
+template <typename Ti, typename To>
+void
+formencode(Ti first, Ti last, To& out)
+{
+    for (; first != last; ++first) {
+        unsigned char c = *first;
+        if (isalnum(c)) {
+            out.insert(out.end(), first, first + 1);
+            continue;
+        } else if (c == ' ') {
+            char tmp = '+';
+            out.insert(out.end(), &tmp, &tmp + 1);
+        } else if (
+                (c == 0x2A || c == 0x2D || c == 0x2E) ||
+                (c >= 0x30 && c <= 0x39) ||
+                (c >= 0x41 && c <= 0x5A) ||
+                (c == 0x5F) ||
+                (c >= 0x60 && c <= 0x7A)) {
+            out.insert(out.end(), static_cast<char>(c));
+        } else {
+            char buf[3] = { 0 };
+            out.insert(out.end(), '%');
+            sprintf(buf, "%02X", c);
+            out.insert(out.end(), &buf[0], &buf[0]+2);
+        }
+    }
+}
+
+} // namespace: strcodecs
+} // namespace: lcb
+#endif
+#endif