mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/settings.c

@@ -0,0 +1,125 @@
+/* -*- 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.
+ */
+
+#include "settings.h"
+#include <lcbio/ssl.h>
+#include <rdb/rope.h>
+
+LCB_INTERNAL_API
+void lcb_default_settings(lcb_settings *settings)
+{
+    settings->ipv6 = LCB_IPV6_DISABLED;
+    settings->operation_timeout = LCB_DEFAULT_TIMEOUT;
+    settings->config_timeout = LCB_DEFAULT_CONFIGURATION_TIMEOUT;
+    settings->config_node_timeout = LCB_DEFAULT_NODECONFIG_TIMEOUT;
+    settings->views_timeout = LCB_DEFAULT_VIEW_TIMEOUT;
+    settings->n1ql_timeout = LCB_DEFAULT_N1QL_TIMEOUT;
+    settings->durability_timeout = LCB_DEFAULT_DURABILITY_TIMEOUT;
+    settings->durability_interval = LCB_DEFAULT_DURABILITY_INTERVAL;
+    settings->http_timeout = LCB_DEFAULT_HTTP_TIMEOUT;
+    settings->weird_things_threshold = LCB_DEFAULT_CONFIG_ERRORS_THRESHOLD;
+    settings->weird_things_delay = LCB_DEFAULT_CONFIG_ERRORS_DELAY;
+    settings->max_redir = LCB_DEFAULT_CONFIG_MAXIMUM_REDIRECTS;
+    settings->grace_next_cycle = LCB_DEFAULT_CLCONFIG_GRACE_CYCLE;
+    settings->grace_next_provider = LCB_DEFAULT_CLCONFIG_GRACE_NEXT;
+    settings->bc_http_stream_time = LCB_DEFAULT_BC_HTTP_DISCONNTMO;
+    settings->retry_interval = LCB_DEFAULT_RETRY_INTERVAL;
+    settings->retry_backoff = LCB_DEFAULT_RETRY_BACKOFF;
+    settings->sslopts = 0;
+    settings->retry[LCB_RETRY_ON_SOCKERR] = LCB_DEFAULT_NETRETRY;
+    settings->retry[LCB_RETRY_ON_TOPOCHANGE] = LCB_DEFAULT_TOPORETRY;
+    settings->retry[LCB_RETRY_ON_VBMAPERR] = LCB_DEFAULT_NMVRETRY;
+    settings->retry[LCB_RETRY_ON_MISSINGNODE] = 0;
+    settings->bc_http_urltype = LCB_DEFAULT_HTCONFIG_URLTYPE;
+    settings->compressopts = LCB_DEFAULT_COMPRESSOPTS;
+    settings->compress_min_size = LCB_DEFAULT_COMPRESS_MIN_SIZE;
+    settings->compress_min_ratio = LCB_DEFAULT_COMPRESS_MIN_RATIO;
+    settings->allocator_factory = rdb_bigalloc_new;
+    settings->syncmode = LCB_ASYNCHRONOUS;
+    settings->detailed_neterr = 0;
+    settings->refresh_on_hterr = 1;
+    settings->sched_implicit_flush = 1;
+    settings->fetch_mutation_tokens = 0;
+    settings->dur_mutation_tokens = 1;
+    settings->nmv_retry_imm = LCB_DEFAULT_NVM_RETRY_IMM;
+    settings->tcp_nodelay = LCB_DEFAULT_TCP_NODELAY;
+    settings->retry_nmv_interval = LCB_DEFAULT_RETRY_NMV_INTERVAL;
+    settings->vb_noguess = LCB_DEFAULT_VB_NOGUESS;
+    settings->vb_noremap = LCB_DEFAULT_VB_NOREMAP;
+    settings->select_bucket = LCB_DEFAULT_SELECT_BUCKET;
+    settings->tcp_keepalive = LCB_DEFAULT_TCP_KEEPALIVE;
+    settings->send_hello = 1;
+    settings->config_poll_interval = LCB_DEFAULT_CONFIG_POLL_INTERVAL;
+    settings->use_errmap = 1;
+    settings->use_collections = 0;
+    settings->log_redaction = 0;
+    settings->use_tracing = 1;
+    settings->network = NULL;
+#ifdef LCB_TRACING
+    settings->tracer_orphaned_queue_flush_interval = LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL;
+    settings->tracer_orphaned_queue_size = LCBTRACE_DEFAULT_ORPHANED_QUEUE_SIZE;
+    settings->tracer_threshold_queue_flush_interval = LCBTRACE_DEFAULT_THRESHOLD_QUEUE_FLUSH_INTERVAL;
+    settings->tracer_threshold_queue_size = LCBTRACE_DEFAULT_THRESHOLD_QUEUE_SIZE;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_KV] =  LCBTRACE_DEFAULT_THRESHOLD_KV;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_N1QL] =  LCBTRACE_DEFAULT_THRESHOLD_N1QL;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_VIEW] =  LCBTRACE_DEFAULT_THRESHOLD_VIEW;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_FTS] =  LCBTRACE_DEFAULT_THRESHOLD_FTS;
+    settings->tracer_threshold[LCBTRACE_THRESHOLD_ANALYTICS] =  LCBTRACE_DEFAULT_THRESHOLD_ANALYTICS;
+#endif
+    settings->wait_for_config = 0;
+}
+
+LCB_INTERNAL_API
+lcb_settings *
+lcb_settings_new(void)
+{
+    lcb_settings *settings = calloc(1, sizeof(*settings));
+    lcb_default_settings(settings);
+    settings->refcount = 1;
+    settings->auth = lcbauth_new();
+    settings->errmap = lcb_errmap_new();
+    return settings;
+}
+
+LCB_INTERNAL_API
+void
+lcb_settings_unref(lcb_settings *settings)
+{
+    if (--settings->refcount) {
+        return;
+    }
+    free(settings->bucket);
+    free(settings->sasl_mech_force);
+    free(settings->certpath);
+    free(settings->keypath);
+    free(settings->client_string);
+    free(settings->network);
+
+    lcbauth_unref(settings->auth);
+    lcb_errmap_free(settings->errmap);
+
+    if (settings->ssl_ctx) {
+        lcbio_ssl_free(settings->ssl_ctx);
+    }
+    if (settings->metrics) {
+        lcb_metrics_destroy(settings->metrics);
+    }
+    if (settings->dtorcb) {
+        settings->dtorcb(settings->dtorarg);
+    }
+    free(settings);
+}

data/ext/libcouchbase/src/settings.h

@@ -0,0 +1,273 @@
+/* -*- 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_SETTINGS_H
+#define LCB_SETTINGS_H
+
+/**
+ * Handy macros for converting between different time resolutions
+ */
+
+/** Convert seconds to millis */
+#define LCB_S2MS(s) (((lcb_uint32_t)s) * 1000)
+
+/** Convert seconds to microseconds */
+#define LCB_S2US(s) (((lcb_uint32_t)s) * 1000000)
+
+/** Convert seconds to nanoseconds */
+#define LCB_S2NS(s) (((hrtime_t)s) * 1000000000)
+
+/** Convert nanoseconds to microseconds */
+#define LCB_NS2US(s) ((s) / 1000)
+
+#define LCB_MS2US(s) ((s) * 1000)
+
+/** Convert microseconds to nanoseconds */
+#define LCB_US2NS(s) (((hrtime_t)s) * 1000)
+/** Convert milliseconds to nanoseconds */
+#define LCB_MS2NS(s) (((hrtime_t)s) * 1000000)
+
+
+#define LCB_DEFAULT_TIMEOUT LCB_MS2US(2500)
+
+/** 5 seconds for total bootstrap */
+#define LCB_DEFAULT_CONFIGURATION_TIMEOUT LCB_MS2US(5000)
+
+/** 2 seconds per node */
+#define LCB_DEFAULT_NODECONFIG_TIMEOUT LCB_MS2US(2000)
+
+#define LCB_DEFAULT_VIEW_TIMEOUT LCB_MS2US(75000)
+#define LCB_DEFAULT_N1QL_TIMEOUT LCB_MS2US(75000)
+#define LCB_DEFAULT_DURABILITY_TIMEOUT LCB_MS2US(5000)
+#define LCB_DEFAULT_DURABILITY_INTERVAL LCB_MS2US(100)
+#define LCB_DEFAULT_HTTP_TIMEOUT LCB_MS2US(75000)
+#define LCB_DEFAULT_CONFIG_MAXIMUM_REDIRECTS 3
+#define LCB_DEFAULT_CONFIG_ERRORS_THRESHOLD 100
+
+/* 10 milliseconds */
+#define LCB_DEFAULT_CONFIG_ERRORS_DELAY LCB_MS2US(10)
+
+/* 1 second */
+#define LCB_DEFAULT_CLCONFIG_GRACE_CYCLE LCB_MS2US(1000)
+
+/* 100 ms */
+#define LCB_DEFAULT_CLCONFIG_GRACE_NEXT LCB_MS2US(100)
+
+/* Infinite (i.e. compat mode) */
+#define LCB_DEFAULT_BC_HTTP_DISCONNTMO -1
+
+/* 10ms */
+#define LCB_DEFAULT_RETRY_INTERVAL LCB_MS2US(10)
+
+/* 1.5x */
+#define LCB_DEFAULT_RETRY_BACKOFF 1.5
+
+#define LCB_DEFAULT_TOPORETRY LCB_RETRY_CMDS_ALL
+#define LCB_DEFAULT_NETRETRY LCB_RETRY_CMDS_ALL
+#define LCB_DEFAULT_NMVRETRY LCB_RETRY_CMDS_ALL
+#define LCB_DEFAULT_HTCONFIG_URLTYPE LCB_HTCONFIG_URLTYPE_TRYALL
+#define LCB_DEFAULT_COMPRESSOPTS LCB_COMPRESS_INOUT
+
+/* in bytes */
+#define LCB_DEFAULT_COMPRESS_MIN_SIZE 32
+/* compressed_bytes / original_bytes */
+#define LCB_DEFAULT_COMPRESS_MIN_RATIO 0.83
+
+#define LCB_DEFAULT_NVM_RETRY_IMM 1
+#define LCB_DEFAULT_RETRY_NMV_INTERVAL LCB_MS2US(100)
+#define LCB_DEFAULT_VB_NOGUESS 1
+#define LCB_DEFAULT_VB_NOREMAP 0
+#define LCB_DEFAULT_TCP_NODELAY 1
+#define LCB_DEFAULT_SELECT_BUCKET 1
+#define LCB_DEFAULT_TCP_KEEPALIVE 1
+/* 2.5 s */
+#define LCB_DEFAULT_CONFIG_POLL_INTERVAL LCB_MS2US(2500)
+/* 50 ms */
+#define LCB_CONFIG_POLL_INTERVAL_FLOOR LCB_MS2US(50)
+
+#define LCBTRACE_DEFAULT_ORPHANED_QUEUE_FLUSH_INTERVAL LCB_MS2US(10000)
+#define LCBTRACE_DEFAULT_ORPHANED_QUEUE_SIZE 128
+#define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_FLUSH_INTERVAL LCB_MS2US(10000)
+#define LCBTRACE_DEFAULT_THRESHOLD_QUEUE_SIZE 128
+#define LCBTRACE_DEFAULT_THRESHOLD_KV  LCB_MS2US(500)
+#define LCBTRACE_DEFAULT_THRESHOLD_N1QL LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_THRESHOLD_VIEW LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_THRESHOLD_FTS LCB_MS2US(1000)
+#define LCBTRACE_DEFAULT_THRESHOLD_ANALYTICS LCB_MS2US(1000)
+
+#include "config.h"
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/metrics.h>
+#include "errmap.h"
+
+#ifdef LCB_TRACING
+#include <libcouchbase/tracing.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct lcb_logprocs_st;
+struct lcbio_SSLCTX;
+struct rdb_ALLOCATOR;
+struct lcb_METRICS_st;
+
+/**
+ * Stateless setting structure.
+ * Specifically this contains the 'environment' of the instance for things
+ * which are intended to be passed around to other objects.
+ */
+typedef struct lcb_settings_st {
+    /* TODO: [SDK3] change to uint64_t as per RFC. logging API exposes it as unsigned int currently */
+    lcb_U32 iid;
+    lcb_U8 compressopts;
+    lcb_U8 syncmode;
+    lcb_U32 read_chunk_size;
+    lcb_U32 operation_timeout;
+    lcb_U32 views_timeout;
+    lcb_U32 http_timeout;
+    lcb_U32 n1ql_timeout;
+    lcb_U32 durability_timeout;
+    lcb_U32 durability_interval;
+    lcb_U32 config_timeout;
+    lcb_U32 config_node_timeout;
+    lcb_U32 retry_interval;
+    lcb_U32 weird_things_threshold;
+    lcb_U32 weird_things_delay;
+
+    /** Grace period to wait between querying providers */
+    lcb_U32 grace_next_provider;
+
+    /** Grace period to wait between retrying from the beginning */
+    lcb_U32 grace_next_cycle;
+
+    /**For bc_http, the amount of type to keep the stream open, for future
+     * updates. */
+    lcb_U32 bc_http_stream_time;
+
+    /** Time to wait in between background config polls. 0 disables this */
+    lcb_U32 config_poll_interval;
+
+    unsigned bc_http_urltype : 4;
+
+    /** Don't guess next vbucket server. Mainly for testing */
+    unsigned vb_noguess : 1;
+    /** Whether lcb_destroy is synchronous. This mode will run the I/O event
+     * loop as much as possible until no outstanding events remain.*/
+    unsigned syncdtor : 1;
+    unsigned detailed_neterr : 1;
+    unsigned randomize_bootstrap_nodes : 1;
+    unsigned conntype : 1;
+    unsigned refresh_on_hterr : 1;
+    unsigned sched_implicit_flush : 1;
+    unsigned nmv_retry_imm : 1;
+    unsigned keep_guess_vbs : 1;
+    unsigned fetch_mutation_tokens : 1;
+    unsigned dur_mutation_tokens : 1;
+    unsigned sslopts : 3;
+    unsigned ipv6 : 2;
+    unsigned tcp_nodelay : 1;
+    unsigned readj_ts_wait : 1;
+    unsigned use_errmap : 1;
+    unsigned select_bucket : 1;
+    unsigned tcp_keepalive : 1;
+    unsigned send_hello : 1;
+    unsigned use_collections : 1;
+    unsigned log_redaction : 1;
+    unsigned use_tracing : 1;
+    /** Do not use remap vbuckets (do not use fast forward map, or any other heuristics) */
+    unsigned vb_noremap : 1;
+    /** Do not wait for GET_CLUSTER_CONFIG request to finish in lcb_wait(),
+     * when it is the only request in retry queue */
+    unsigned wait_for_config : 1;
+
+    short max_redir;
+    unsigned refcount;
+
+    uint8_t retry[LCB_RETRY_ON_MAX];
+    float retry_backoff;
+
+    char *bucket;
+    char *sasl_mech_force;
+    char *truststorepath;
+    char *certpath;
+    char *keypath;
+    lcb_AUTHENTICATOR *auth;
+    struct rdb_ALLOCATOR* (*allocator_factory)(void);
+    struct lcbio_SSLCTX *ssl_ctx;
+    struct lcb_logprocs_st *logger;
+    void (*dtorcb)(const void *);
+    void *dtorarg;
+    char *client_string;
+    lcb_pERRMAP errmap;
+    lcb_U32 retry_nmv_interval;
+    struct lcb_METRICS_st *metrics;
+#ifdef LCB_TRACING
+    lcbtrace_TRACER *tracer;
+    lcb_U32 tracer_orphaned_queue_flush_interval;
+    lcb_U32 tracer_orphaned_queue_size;
+    lcb_U32 tracer_threshold_queue_flush_interval;
+    lcb_U32 tracer_threshold_queue_size;
+    lcb_U32 tracer_threshold[LCBTRACE_THRESHOLD__MAX];
+#endif
+    lcb_U32 compress_min_size;
+    float compress_min_ratio;
+    char *network; /** network resolution, AKA "Multi Network Configurations" */
+} lcb_settings;
+
+LCB_INTERNAL_API
+void lcb_default_settings(lcb_settings *settings);
+
+LCB_INTERNAL_API
+lcb_settings *
+lcb_settings_new(void);
+
+LCB_INTERNAL_API
+void
+lcb_settings_unref(lcb_settings *);
+
+#define lcb_settings_ref(settings) ((void)(settings)->refcount++)
+#define lcb_settings_ref2(settings) ((settings)->refcount++, settings)
+
+/**
+ * Metric functionality. Defined in metrics.h, but retains a global-like
+ * setting similar to lcb_settings
+ */
+void
+lcb_metrics_dumpio(const lcb_IOMETRICS *metrics, FILE *fp);
+
+void
+lcb_metrics_dumpserver(const lcb_SERVERMETRICS *metrics, FILE *fp);
+
+lcb_METRICS *
+lcb_metrics_new(void);
+
+void
+lcb_metrics_destroy(lcb_METRICS *metrics);
+
+lcb_SERVERMETRICS *
+lcb_metrics_getserver(lcb_METRICS *metrics,
+    const char *host, const char *port, int create);
+
+void
+lcb_metrics_reset_pipeline_gauges(lcb_SERVERMETRICS *metrics);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/src/sllist-inl.h

@@ -0,0 +1,197 @@
+/* -*- 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.
+ */
+
+#include "sllist.h"
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#ifndef INLINE
+#ifdef _MSC_VER
+#define INLINE __inline
+#elif __GNUC__
+#define INLINE __inline__
+#else
+#define INLINE inline
+#endif /* MSC_VER */
+#endif /* !INLINE */
+
+
+static INLINE int
+sllist_contains(sllist_root *list, sllist_node *item)
+{
+    sllist_node *ll;
+    SLLIST_FOREACH(list, ll) {
+        if (item == ll) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static INLINE unsigned
+sllist_get_size(sllist_root *list)
+{
+    unsigned ret = 0;
+    sllist_node *ll;
+    SLLIST_FOREACH(list, ll) {
+        ret++;
+    }
+    return ret;
+}
+
+/* #define SLLIST_DEBUG */
+
+#ifdef SLLIST_DEBUG
+#define slist_sanity_insert(l, n) assert(!slist_contains(l, n))
+#else
+#define slist_sanity_insert(l, n)
+#endif
+
+static INLINE void
+slist_iter_init_at(sllist_node *node, sllist_iterator *iter)
+{
+    iter->cur = node->next;
+    iter->prev = node;
+    iter->removed = 0;
+
+    if (iter->cur) {
+        iter->next = iter->cur->next;
+    } else {
+        iter->next = NULL;
+    }
+}
+
+static INLINE void
+slist_iter_init(sllist_root *list, sllist_iterator *iter)
+{
+    slist_iter_init_at(&list->first_prev, iter);
+}
+
+static INLINE void
+slist_iter_incr(sllist_root *list, sllist_iterator *iter)
+{
+    if (!iter->removed) {
+        iter->prev = iter->prev->next;
+    } else {
+        iter->removed = 0;
+    }
+
+    if ((iter->cur = iter->next)) {
+        iter->next = iter->cur->next;
+    } else {
+        iter->next = NULL;
+    }
+
+    assert(iter->cur != iter->prev);
+
+    (void)list;
+}
+
+static INLINE void
+sllist_iter_remove(sllist_root *list, sllist_iterator *iter)
+{
+    iter->prev->next = iter->next;
+
+    /** GCC strict aliasing. Yay. */
+    if (iter->prev->next == NULL && iter->prev == &list->first_prev) {
+        list->last = NULL;
+    } else if (iter->cur == list->last && iter->next == NULL) {
+        /* removing the last item */
+        list->last = iter->prev;
+    }
+    iter->removed = 1;
+}
+
+static INLINE void
+sllist_remove_head(sllist_root *list)
+{
+    if (!SLLIST_FIRST(list)) {
+        return;
+    }
+
+    SLLIST_FIRST(list) = SLLIST_FIRST(list)->next;
+
+    if (!SLLIST_FIRST(list)) {
+        list->last = NULL;
+    }
+}
+
+static INLINE void
+sllist_remove(sllist_root *list, sllist_node *item)
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(list, &iter) {
+        if (iter.cur == item) {
+            sllist_iter_remove(list, &iter);
+            return;
+        }
+    }
+    fprintf(stderr, "SLLIST: Requested to remove item %p which is not in %p\n", (void*)list, (void*)item);
+    assert(0);
+}
+
+static INLINE void
+sllist_append(sllist_root *list, sllist_node *item)
+{
+    if (SLLIST_IS_EMPTY(list)) {
+        SLLIST_FIRST(list) = list->last = item;
+        item->next = NULL;
+    } else {
+        slist_sanity_insert(list, item);
+        list->last->next = item;
+        list->last = item;
+    }
+    item->next = NULL;
+}
+
+static INLINE void
+sllist_prepend(sllist_root *list, sllist_node *item)
+{
+    if (SLLIST_IS_EMPTY(list)) {
+        SLLIST_FIRST(list) = list->last = item;
+    } else {
+        slist_sanity_insert(list, item);
+        item->next = SLLIST_FIRST(list);
+        SLLIST_FIRST(list) = item;
+    }
+}
+
+static void
+sllist_insert(sllist_root *list, sllist_node *prev, sllist_node *item)
+{
+    item->next = prev->next;
+    prev->next = item;
+    if (item->next == NULL) {
+        list->last = item;
+    }
+}
+
+static INLINE void
+sllist_insert_sorted(sllist_root *list, sllist_node *item,
+                     int (*compar)(sllist_node*, sllist_node*))
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(list, &iter) {
+        int rv = compar(item, iter.cur);
+        /** if the item we have is before the current, prepend it here */
+        if (rv <= 0) {
+            sllist_insert(list, iter.prev, item);
+            return;
+        }
+    }
+    sllist_append(list, item);
+}

data/ext/libcouchbase/src/sllist.h

@@ -0,0 +1,76 @@
+/* -*- 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_SLIST_H
+#define LCB_SLIST_H
+
+struct slist_node_st;
+typedef struct slist_node_st {
+    struct slist_node_st *next;
+} sllist_node;
+
+typedef struct {
+    sllist_node first_prev;
+    sllist_node *last;
+} sllist_root;
+
+/**
+ * Indicates whether the list is empty or not
+ */
+#define SLLIST_FIRST(list) (list)->first_prev.next
+#define SLLIST_LAST(list) (list)->last
+
+#define SLLIST_IS_EMPTY(list) (SLLIST_LAST(list) == NULL)
+#define SLLIST_IS_ONE(list) (SLLIST_FIRST(list) && SLLIST_FIRST(list) == SLLIST_LAST(list))
+
+/**
+ * Iterator for list. This can be used as the 'for' statement; as such this
+ * macro should look like such:
+ *
+ *  slist_node *ii;
+ *  SLIST_FOREACH(list, ii) {
+ *      my_item *item = LCB_LIST_ITEM(my_item, ii, slnode);
+ *  }
+ *
+ *  @param list the list to iterate
+ *  @param pos a local variable to use as the iterator
+ */
+#define SLLIST_FOREACH(list, pos) \
+    for (pos = SLLIST_FIRST(list); pos; pos = pos->next)
+
+
+typedef struct sllist_iterator_st {
+    sllist_node *cur;
+    sllist_node *prev;
+    sllist_node *next;
+    int removed;
+} sllist_iterator;
+
+#define sllist_iter_end(list, iter) ((iter)->cur == NULL)
+
+#define SLLIST_ITEM(ptr, type, member) \
+        ((type *) (void *) ((char *)(ptr) - offsetof(type, member)))
+
+#define SLLIST_ITERFOR(list, iter) \
+    for (slist_iter_init(list, iter); \
+            !sllist_iter_end(list, iter); \
+            slist_iter_incr(list, iter))
+
+#define SLLIST_ITERBASIC(list, elem) \
+        for (elem = SLLIST_FIRST(list); elem; elem = elem->next)
+
+#endif

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

@@ -0,0 +1,11 @@
+IF(OPENSSL_FOUND AND (NOT LCB_NO_SSL))
+    INCLUDE_DIRECTORIES(${OPENSSL_INCLUDE_DIR})
+    ADD_DEFINITIONS(${OPENSSL_DEFINITIONS})
+    ADD_LIBRARY(lcbssl OBJECT ssl_e.c ssl_c.c ssl_common.c)
+    SET(lcb_ssl_libs ${OPENSSL_LIBRARIES} PARENT_SCOPE)
+    SET(lcb_ssl_objs $<TARGET_OBJECTS:lcbssl> PARENT_SCOPE)
+    LCB_UTIL(lcbssl)
+ELSE()
+    SET(LCB_NO_SSL ON PARENT_SCOPE)
+    SET(lcb_ssl_libs "" PARENT_SCOPE)
+ENDIF()