mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/tracing/tracing-internal.h

@@ -0,0 +1,198 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018 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_TRACING_INTERNAL_H
+#define LCB_TRACING_INTERNAL_H
+
+#ifdef LCB_TRACING
+#include <libcouchbase/tracing.h>
+#include "rnd.h"
+
+#ifdef __cplusplus
+
+#include <queue>
+
+namespace lcb
+{
+namespace trace
+{
+
+class Span
+{
+  public:
+    Span(lcbtrace_TRACER *tracer, const char *opname, uint64_t start, lcbtrace_REF_TYPE ref, lcbtrace_SPAN *other);
+    ~Span();
+
+    void finish(uint64_t finish);
+    uint64_t duration()
+    {
+        return m_finish - m_start;
+    }
+
+    void add_tag(const char *name, int copy, const char *value);
+    void add_tag(const char *name, int copy, const char *value, size_t value_len);
+    void add_tag(const char *name, int copy, uint64_t value);
+    void add_tag(const char *name, int copy, double value);
+    void add_tag(const char *name, int copy, bool value);
+
+    lcbtrace_TRACER *m_tracer;
+    std::string m_opname;
+    uint64_t m_span_id;
+    uint64_t m_start;
+    uint64_t m_finish;
+    bool m_orphaned;
+    Span *m_parent;
+    sllist_root m_tags;
+};
+
+struct ReportedSpan {
+    uint64_t duration;
+    std::string payload;
+
+    bool operator<(const ReportedSpan &rhs) const
+    {
+        return duration < rhs.duration;
+    }
+};
+
+template < typename T > class FixedQueue: private std::priority_queue<T>
+{
+  public:
+    explicit FixedQueue(size_t capacity) : m_capacity(capacity) {}
+
+    void push(const T& item) {
+        std::priority_queue<T>::push(item);
+        if (this->size() > m_capacity) {
+            this->c.pop_back();
+        }
+    }
+    using std::priority_queue<T>::empty;
+    using std::priority_queue<T>::top;
+    using std::priority_queue<T>::pop;
+    using std::priority_queue<T>::size;
+  private:
+    size_t m_capacity;
+};
+
+typedef ReportedSpan QueueEntry;
+typedef FixedQueue<QueueEntry> FixedSpanQueue;
+class ThresholdLoggingTracer
+{
+    lcbtrace_TRACER *m_wrapper;
+    lcb_settings *m_settings;
+
+    FixedSpanQueue m_orphans;
+    FixedSpanQueue m_threshold;
+
+    void flush_queue(FixedSpanQueue &queue, const char *message, bool warn);
+    QueueEntry convert(lcbtrace_SPAN *span);
+
+  public:
+    ThresholdLoggingTracer(lcb_t instance);
+
+    lcbtrace_TRACER *wrap();
+    void add_orphan(lcbtrace_SPAN *span);
+    void check_threshold(lcbtrace_SPAN *span);
+
+    void flush_orphans();
+    void flush_threshold();
+    void do_flush_orphans();
+    void do_flush_threshold();
+
+    lcb::io::Timer< ThresholdLoggingTracer, &ThresholdLoggingTracer::flush_orphans > m_oflush;
+    lcb::io::Timer< ThresholdLoggingTracer, &ThresholdLoggingTracer::flush_threshold > m_tflush;
+};
+
+} // namespace trace
+} // namespace lcb
+
+extern "C" {
+#endif
+LCB_INTERNAL_API
+void lcbtrace_span_add_system_tags(lcbtrace_SPAN *span, lcb_settings *settings, const char *service);
+LCB_INTERNAL_API
+void lcbtrace_span_set_parent(lcbtrace_SPAN *span, lcbtrace_SPAN *parent);
+LCB_INTERNAL_API
+void lcbtrace_span_set_orphaned(lcbtrace_SPAN *span, int val);
+
+#define LCBTRACE_KV_START(settings, cmd, operation_name, opaque, outspan)                                              \
+    if ((settings)->tracer) {                                                                                          \
+        lcbtrace_REF ref;                                                                                              \
+        char opid[20] = {};                                                                                            \
+        snprintf(opid, sizeof(opid), "0x%x", (int)opaque);                                                             \
+        ref.type = LCBTRACE_REF_CHILD_OF;                                                                              \
+        ref.span = (cmd->_hashkey.type & LCB_KV_TRACESPAN) ? (lcbtrace_SPAN *)cmd->_hashkey.contig.bytes : NULL;       \
+        outspan = lcbtrace_span_start((settings)->tracer, operation_name, LCBTRACE_NOW, &ref);                         \
+        lcbtrace_span_add_tag_str(outspan, LCBTRACE_TAG_OPERATION_ID, opid);                                           \
+        lcbtrace_span_add_system_tags(outspan, (settings), LCBTRACE_TAG_SERVICE_KV);                                   \
+    }
+
+#define LCBTRACE_KV_COMPLETE(pipeline, request, response)                                                              \
+    do {                                                                                                               \
+        lcbtrace_SPAN *span = MCREQ_PKT_RDATA(request)->span;                                                          \
+        if (span) {                                                                                                    \
+            lcbtrace_span_add_tag_uint64(span, LCBTRACE_TAG_PEER_LATENCY, (response)->duration());                     \
+            lcb::Server *server = static_cast< lcb::Server * >(pipeline);                                              \
+            const lcb_host_t *remote = server->curhost;                                                                \
+            if (remote) {                                                                                              \
+                std::string hh;                                                                                        \
+                if (remote->ipv6) {                                                                                    \
+                    hh.append("[").append(remote->host).append("]:").append(remote->port);                             \
+                } else {                                                                                               \
+                    hh.append(remote->host).append(":").append(remote->port);                                          \
+                }                                                                                                      \
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_PEER_ADDRESS, hh.c_str());                                \
+            }                                                                                                          \
+            lcbio_CTX *ctx = server->connctx;                                                                          \
+            if (ctx) {                                                                                                 \
+                char local_id[34] = {};                                                                                \
+                snprintf(local_id, sizeof(local_id), "%016" PRIx64 "/%016" PRIx64,                                     \
+                         (lcb_U64)server->get_settings()->iid, ctx->sock->id);                                         \
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_LOCAL_ID, local_id);                                      \
+                lcbtrace_span_add_tag_str(span, LCBTRACE_TAG_LOCAL_ADDRESS,                                            \
+                                          lcbio__inet_ntop(&ctx->sock->info->sa_local).c_str());                       \
+            }                                                                                                          \
+        }                                                                                                              \
+    } while (0);
+
+#define LCBTRACE_KV_CLOSE(request)                                                                                     \
+    do {                                                                                                               \
+        lcbtrace_SPAN *span = MCREQ_PKT_RDATA(request)->span;                                                          \
+        if (span) {                                                                                                    \
+            lcbtrace_span_finish(span, LCBTRACE_NOW);                                                                  \
+            MCREQ_PKT_RDATA(request)->span = NULL;                                                                     \
+        }                                                                                                              \
+    } while (0);
+
+#define LCBTRACE_KV_FINISH(pipeline, request, response)                                                                \
+    LCBTRACE_KV_COMPLETE(pipeline, request, response)                                                                  \
+    LCBTRACE_KV_CLOSE(request)
+
+#ifdef __cplusplus
+}
+#endif
+
+#else
+
+#define LCBTRACE_KV_START(settings, cmd, operation_name, opaque, outspan)
+#define LCBTRACE_KV_COMPLETE(pipeline, request, response)
+#define LCBTRACE_KV_CLOSE(request)
+#define LCBTRACE_KV_FINISH(pipeline, request, response)
+
+#endif /* LCB_TRACING */
+
+#endif /* LCB_TRACING_INTERNAL_H */

data/ext/libcouchbase/src/utilities.c

@@ -0,0 +1,176 @@
+/* -*- 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 "internal.h"
+
+/**
+ * This file contains utility functions which don't have another place
+ * to call home
+ */
+
+extern lcb_uint64_t lcb_byteswap64(lcb_uint64_t val)
+{
+    lcb_size_t ii;
+    lcb_uint64_t ret = 0;
+    for (ii = 0; ii < sizeof(lcb_uint64_t); ii++) {
+        ret <<= 8;
+        ret |= val & 0xff;
+        val >>= 8;
+    }
+    return ret;
+}
+
+extern lcb_uint16_t lcb_byteswap16(lcb_uint16_t val)
+{
+    return ((val & 0xff) << 8) | ((val >> 8) & 0xff);
+}
+
+/**
+ * While the C standard library uses 'putenv' for environment variable
+ * manipulation, POSIX defines setenv (which works sanely) but Windows
+ * only has putenv (via the CRT interface).
+ * However Windows also has the 'GetEnvironmentVariable' etc. API - which
+ * actually uses a different interface.
+ *
+ * We prefer to use actual API calls rather than hack into a poor excuse
+ * of conformance. Since putenv requires ownership of the string, its use
+ * is discouraged (and _putenv_s isn't available in MinGW); thus the
+ * assumption that the most common APIs are GetEnvironmentVariable and
+ * SetEnvironmentVariable. We try to abstract this away from the rest of the
+ * library.
+ */
+
+#ifdef _WIN32
+int lcb_getenv_nonempty(const char *key, char *buf, lcb_size_t len)
+{
+    DWORD nvalue = GetEnvironmentVariable(key, buf, (DWORD)len);
+
+    if (nvalue == 0 || nvalue >= len) {
+        return 0;
+    }
+
+    if (!buf[0]) {
+        return 0;
+    }
+    return 1;
+}
+
+#else
+int lcb_getenv_nonempty(const char *key, char *buf, lcb_size_t len)
+{
+    const char *cur = getenv(key);
+    if (cur == NULL || *cur == '\0') {
+        return 0;
+    }
+
+    strncpy(buf, cur, len);
+    return 1;
+}
+#endif
+
+int lcb_getenv_boolean(const char *key)
+{
+    char value[4096] = { 0 };
+    int rv;
+    rv = lcb_getenv_nonempty(key, value, sizeof(value));
+    return rv != 0 && value[0] != '\0' && value[0] != '0';
+}
+
+#ifdef _WIN32
+lcb_error_t lcb_initialize_socket_subsystem(void)
+{
+    static volatile LONG initialized = 0;
+    WSADATA wsaData;
+
+    if (InterlockedCompareExchange(&initialized, 1, 0)) {
+        return LCB_SUCCESS;
+    }
+    if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0) {
+        lcb_assert("Winsock initialization error" && 0);
+    }
+    return LCB_SUCCESS;
+}
+#else
+lcb_error_t lcb_initialize_socket_subsystem(void)
+{
+    return LCB_SUCCESS;
+}
+#endif
+
+int
+lcb_getenv_nonempty_multi(char *buf, lcb_size_t nbuf, ...)
+{
+    va_list ap;
+    const char *cur;
+    int found = 0;
+
+    va_start(ap, nbuf);
+    while ((cur = va_arg(ap, const char*))) {
+        if ((found = lcb_getenv_nonempty(cur, buf, nbuf))) {
+            break;
+        }
+    }
+    va_end(ap);
+    return found;
+}
+
+int
+lcb_getenv_boolean_multi(const char *key, ...)
+{
+    va_list ap;
+    const char *cur;
+    int ret = 0;
+
+    va_start(ap, key);
+    if (lcb_getenv_boolean(key)) {
+        va_end(ap);
+        return 1;
+    }
+
+    while ((cur = va_arg(ap, const char *))) {
+        if ((ret = lcb_getenv_boolean(cur))) {
+            break;
+        }
+    }
+    va_end(ap);
+    return ret;
+}
+
+const char *
+lcb_get_tmpdir(void)
+{
+#if defined(_WIN32)
+    static char buf[MAX_PATH+1] = { 0 };
+    if (buf[0]) {
+        return buf;
+    }
+    GetTempPath(sizeof buf, buf);
+    return buf;
+#else
+    const char *ret;
+    if ((ret = getenv("TMPDIR")) != NULL) {
+        return ret;
+    } else {
+
+    #if defined(_POSIX_VERSION)
+        return "/tmp";
+    #else
+        return ".";
+    #endif
+    }
+#endif
+}

data/ext/libcouchbase/src/vbucket/CMakeLists.txt

@@ -0,0 +1,2 @@
+ADD_LIBRARY(vbucket-lcb OBJECT vbucket.c ketama.c ${SOURCE_ROOT}/contrib/cJSON/cJSON.c)
+LCB_UTIL(vbucket-lcb)

data/ext/libcouchbase/src/vbucket/aliases.h

@@ -0,0 +1,35 @@
+/* -*- 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 VB_ALIASES_H
+#define VB_ALIASES_H
+
+#define VB_NODESTR(config, index) lcbvb_get_hostport(config, index, LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_PLAIN)
+#define VB_RESTURL(config, index) lcbvb_get_hostport(config, index, LCBVB_SVCTYPE_MGMT, LCBVB_SVCMODE_PLAIN)
+#define VB_VIEWSURL(config, index) lcbvb_get_capibase(config, index, LCBVB_SVCMODE_PLAIN)
+#define VB_SSLNODESTR(config, index) lcbvb_get_hostport(config, index, LCBVB_SVCTYPE_DATA, LCBVB_SVCMODE_SSL)
+#define VB_SSLRESTURL(config, index) lcbvb_get_hostport(config, index, LCBVB_SVCTYPE_MGMT, LCBVB_SVCMODE_SSL)
+#define VB_SSLVIEWSURL(config, index) lcbvb_get_capibase(config, index, LCBVB_SVCMODE_SSL)
+#define VB_MEMDSTR(config, index, mode) lcbvb_get_hostport(config, index, LCBVB_SVCTYPE_DATA, mode)
+#define VB_MGMTSTR(config, index, mode) lcbvb_get_hostport(config, index, LCBVB_SVCTYPE_MGMT, mode)
+#define VB_CAPIURL(config, index, mode) lcbvb_get_capibase(config, index, mode)
+
+#define VB_DISTTYPE(config) (config)->dtype
+#define VB_NREPLICAS(config) (config)->nrepl
+#define VB_NSERVERS(config) (config)->nsrv
+
+#endif

data/ext/libcouchbase/src/vbucket/crc32.h

@@ -0,0 +1,83 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/* The crc32 functions and data was originally written by Spencer
+ * Garrett <srg@quick.com> and was gleaned from the PostgreSQL source
+ * tree via the files contrib/ltree/crc32.[ch] and from FreeBSD at
+ * src/usr.bin/cksum/crc32.c.
+ */
+static const uint32_t crc32tab[256] = {
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
+    0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
+    0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
+    0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
+    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
+    0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
+    0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
+    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
+    0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
+    0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
+    0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
+    0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
+    0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
+    0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
+    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
+    0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
+    0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
+    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
+    0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
+    0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
+    0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
+    0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
+    0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
+    0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
+    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
+    0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
+    0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
+    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
+    0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
+    0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
+    0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
+    0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
+    0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
+    0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
+    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
+    0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
+    0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
+    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
+    0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
+    0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
+    0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
+    0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
+    0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
+};
+
+static uint32_t hash_crc32(const char *key, size_t key_length)
+{
+    uint64_t x;
+    uint32_t crc= UINT32_MAX;
+
+    for (x= 0; x < key_length; x++)
+        crc= (crc >> 8) ^ crc32tab[(crc ^ (uint64_t)key[x]) & 0xff];
+
+    return ((~crc) >> 16) & 0x7fff;
+}

data/ext/libcouchbase/src/vbucket/hash.h

@@ -0,0 +1,30 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010 NorthScale, 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 LIBVBUCKET_HASH_H
+#define LIBVBUCKET_HASH_H 1
+
+#include "config.h"
+#include <sys/types.h>
+#include <stdio.h>
+
+uint32_t vb__hash_ketama(const char *key, size_t key_length);
+void vb__hash_md5(const char *key, size_t key_length, unsigned char *result);
+void* vb__hash_md5_update(void *ctx, const char *key, size_t key_length);
+void vb__hash_md5_final(void *ctx, unsigned char *result);
+
+#endif

data/ext/libcouchbase/src/vbucket/json-inl.h

@@ -0,0 +1,112 @@
+/* -*- 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.
+ */
+
+/**
+ * Helper routines for cJSON
+ */
+/**
+ * Utility function to retrieve a string from an object
+ * @param parent Object
+ * @param key Key for item
+ * @param[out] value
+ * @return nonzero on success, zero if not found, or not a string
+ */
+static int
+get_jstr(cJSON *parent, const char *key, char **value)
+{
+    cJSON *res = cJSON_GetObjectItem(parent, key);
+    if (res == NULL || res->type != cJSON_String) {
+        *value = NULL;
+        return 0;
+    }
+
+    *value = res->valuestring;
+    return 1;
+}
+
+/**
+ * Utility function to retrieve a sub-object from a parent object
+ * @param parent
+ * @param key
+ * @param[out] value
+ * @return nonzero on success, zero if not found or not an object
+ */
+static int
+get_jobj(cJSON *parent, const char *key, cJSON **value)
+{
+    cJSON *res = cJSON_GetObjectItem(parent, key);
+    if (res == NULL || res->type != cJSON_Object) {
+        *value = NULL;
+        return 0;
+    }
+
+    *value = res;
+    return 1;
+}
+
+/**
+ * Utility function to extract an integer from an object
+ * @param parent
+ * @param key
+ * @param[out] value
+ * @return nonzero on success, zero if not found or not a number
+ */
+static int
+get_jint(cJSON *parent, const char *key, int *value)
+{
+    cJSON *res = cJSON_GetObjectItem(parent, key);
+    if (res == NULL || res->type != cJSON_Number) {
+        *value = 0;
+        return 0;
+    }
+
+    *value = res->valueint;
+    return 1;
+}
+
+/**
+ * Convenience wrapper around get_jint() which writes its value to an unsigned
+ * int.
+ *
+ * @param parent
+ * @param key
+ * @param value
+ * @return
+ */
+static int
+get_juint(cJSON *parent, const char *key, unsigned *value)
+{
+    int tmp = 0;
+    if (!get_jint(parent, key, &tmp)) {
+        *value = 0;
+        return 0;
+    }
+    *value = tmp;
+    return 1;
+}
+
+static int
+get_jarray(cJSON *parent, const char *key, cJSON **value)
+{
+    cJSON *res = cJSON_GetObjectItem(parent, key);
+    if (res == NULL || res->type != cJSON_Array) {
+        *value = NULL;
+        return 0;
+    }
+    *value = res;
+    return 1;
+}