libcouchbase 0.0.1

data/ext/libcouchbase/src/internal.h

@@ -0,0 +1,244 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2010-2013 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 LIBCOUCHBASE_INTERNAL_H
+#define LIBCOUCHBASE_INTERNAL_H 1
+
+/* System/Standard includes */
+#include "config.h"
+#include <errno.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <ctype.h>
+
+/* Global Project Dependencies/Includes */
+#include <memcached/protocol_binary.h>
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/vbucket.h>
+#include <libcouchbase/api3.h>
+#include <libcouchbase/pktfwd.h>
+
+/* Internal dependencies */
+#include <lcbio/lcbio.h>
+#include <strcodecs/strcodecs.h>
+#include "mcserver/mcserver.h"
+#include "mc/mcreq.h"
+#include "settings.h"
+
+/* lcb_t-specific includes */
+#include "retryq.h"
+#include "aspend.h"
+#include "bootstrap.h"
+
+/* n1ql cache */
+#include "n1ql/n1ql-internal.h"
+
+#include "hostlist.h"
+
+#ifdef __cplusplus
+namespace lcb {
+class Connspec;
+struct Spechost;
+}
+extern "C" {
+#endif
+
+struct lcb_string_st;
+
+struct lcb_callback_st {
+    lcb_RESPCALLBACK v3callbacks[LCB_CALLBACK__MAX];
+    lcb_get_callback get;
+    lcb_store_callback store;
+    lcb_arithmetic_callback arithmetic;
+    lcb_observe_callback observe;
+    lcb_remove_callback remove;
+    lcb_stat_callback stat;
+    lcb_version_callback version;
+    lcb_touch_callback touch;
+    lcb_flush_callback flush;
+    lcb_error_callback error;
+    lcb_http_complete_callback http_complete;
+    lcb_http_data_callback http_data;
+    lcb_unlock_callback unlock;
+    lcb_configuration_callback configuration;
+    lcb_verbosity_callback verbosity;
+    lcb_durability_callback durability;
+    lcb_errmap_callback errmap;
+    lcb_bootstrap_callback bootstrap;
+    lcb_pktfwd_callback pktfwd;
+    lcb_pktflushed_callback pktflushed;
+};
+
+struct lcb_confmon_st;
+struct lcb_BOOTSTRAP;
+struct lcb_GUESSVB_st;
+
+#ifdef __cplusplus
+#include <string>
+typedef std::string* lcb_pSCRATCHBUF;
+#else
+typedef struct lcb_SCRATCHBUF* lcb_pSCRATCHBUF;
+#endif
+
+struct lcb_st {
+    mc_CMDQUEUE cmdq; /**< Base command queue object */
+    const void *cookie; /**< User defined pointer */
+    struct lcb_confmon_st *confmon; /**< Cluster config manager */
+    hostlist_t mc_nodes; /**< List of current memcached endpoints */
+    hostlist_t ht_nodes; /**< List of current management endpoints */
+    struct clconfig_info_st *cur_configinfo; /**< Pointer to current config */
+    struct lcb_BOOTSTRAP *bootstrap; /**< Bootstrapping state */
+    struct lcb_callback_st callbacks; /**< Callback table */
+    lcb_HISTOGRAM *kv_timings; /**< Histogram object (for timing) */
+    lcb_ASPEND pendops; /**< Pending asynchronous requests */
+    int wait; /**< Are we in lcb_wait() ?*/
+    lcbio_MGR *memd_sockpool; /**< Connection pool for memcached connections */
+    lcbio_MGR *http_sockpool; /**< Connection pool for capi connections */
+    lcb_error_t last_error; /**< Seldom used. Mainly for bootstrap */
+    lcb_settings *settings; /**< User settings */
+    lcbio_pTABLE iotable; /**< IO Routine table */
+    lcb_RETRYQ *retryq; /**< Retry queue for failed operations */
+    lcb_pSCRATCHBUF scratch; /**< Generic buffer space */
+    struct lcb_GUESSVB_st *vbguess; /**< Heuristic masters for vbuckets */
+    lcb_N1QLCACHE *n1ql_cache;
+    lcb_MUTATION_TOKEN *dcpinfo; /**< Mapping of known vbucket to {uuid,seqno} info */
+    lcbio_pTIMER dtor_timer; /**< Asynchronous destruction timer */
+    int type; /**< Type of connection */
+
+    #ifdef __cplusplus
+    lcb_settings* getSettings() { return settings; }
+    lcbio_pTABLE getIOT() { return iotable; }
+    inline void add_bs_host(const char *host, int port, unsigned bstype);
+    inline void add_bs_host(const lcb::Spechost& host, int defl_http, int defl_cccp);
+    inline void populate_nodes(const lcb::Connspec&);
+    #endif
+};
+
+#define LCBT_VBCONFIG(instance) (instance)->cmdq.config
+#define LCBT_NSERVERS(instance) (instance)->cmdq.npipelines
+#define LCBT_NDATASERVERS(instance) LCBVB_NDATASERVERS(LCBT_VBCONFIG(instance))
+#define LCBT_NREPLICAS(instance) LCBVB_NREPLICAS(LCBT_VBCONFIG(instance))
+#define LCBT_GET_SERVER(instance, ix) (mc_SERVER *)(instance)->cmdq.pipelines[ix]
+#define LCBT_SETTING(instance, name) (instance)->settings->name
+
+void lcb_initialize_packet_handlers(lcb_t instance);
+
+LCB_INTERNAL_API
+void lcb_maybe_breakout(lcb_t instance);
+
+struct clconfig_info_st;
+void lcb_update_vbconfig(lcb_t instance, struct clconfig_info_st *config);
+/**
+ * Hashtable wrappers
+ */
+genhash_t *lcb_hashtable_nc_new(lcb_size_t est);
+genhash_t *lcb_hashtable_szt_new(lcb_size_t est);
+
+struct lcb_DURSET_st;
+void lcbdur_destroy(struct lcb_DURSET_st *dset);
+void lcbdur_maybe_schedfail(struct lcb_DURSET_st *dset);
+
+lcb_error_t lcb_iops_cntl_handler(int mode, lcb_t instance, int cmd, void *arg);
+
+/**
+ * These two routines define portable ways to get environment variables
+ * on various platforms.
+ *
+ * They are mainly useful for Windows compatibility.
+ */
+LCB_INTERNAL_API
+int lcb_getenv_nonempty(const char *key, char *buf, lcb_size_t len);
+LCB_INTERNAL_API
+int lcb_getenv_boolean(const char *key);
+LCB_INTERNAL_API
+int lcb_getenv_nonempty_multi(char *buf, lcb_size_t nbuf, ...);
+int lcb_getenv_boolean_multi(const char *key, ...);
+LCB_INTERNAL_API
+const char *lcb_get_tmpdir(void);
+
+/**
+ * Initialize the socket subsystem. For windows, this initializes Winsock.
+ * On Unix, this does nothing
+ */
+LCB_INTERNAL_API
+lcb_error_t lcb_initialize_socket_subsystem(void);
+
+lcb_error_t lcb_init_providers2(lcb_t obj,
+                               const struct lcb_create_st2 *e_options);
+lcb_error_t lcb_reinit3(lcb_t obj, const char *connstr);
+
+
+LCB_INTERNAL_API
+mc_SERVER *
+lcb_find_server_by_host(lcb_t instance, const lcb_host_t *host);
+
+
+LCB_INTERNAL_API
+mc_SERVER *
+lcb_find_server_by_index(lcb_t instance, int ix);
+
+LCB_INTERNAL_API
+lcb_error_t
+lcb_getconfig(lcb_t instance, const void *cookie, mc_SERVER *server);
+
+int
+lcb_should_retry(lcb_settings *settings, mc_PACKET *pkt, lcb_error_t err);
+
+lcb_error_t
+lcb__synchandler_return(lcb_t instance);
+
+lcb_RESPCALLBACK
+lcb_find_callback(lcb_t instance, lcb_CALLBACKTYPE cbtype);
+
+/* These two functions exist to allow the tests to keep the loop alive while
+ * scheduling other operations asynchronously */
+
+LCB_INTERNAL_API void lcb_loop_ref(lcb_t instance);
+LCB_INTERNAL_API void lcb_loop_unref(lcb_t instance);
+
+/* To suppress compiler warnings */
+LCB_INTERNAL_API void lcb__timer_destroy_nowarn(lcb_t instance, lcb_timer_t timer);
+
+#define SYNCMODE_INTERCEPT(o) \
+    if (LCBT_SETTING(o, syncmode) == LCB_ASYNCHRONOUS) { \
+        return LCB_SUCCESS; \
+    } else { \
+        return lcb__synchandler_return(o); \
+    }
+
+
+#define MAYBE_SCHEDLEAVE(o) \
+    if (!o->cmdq.ctxenter) { \
+        lcb_sched_leave(o); \
+    }
+
+#define LCB_SCHED_ADD(instance, pl, pkt) \
+    mcreq_sched_add(pl, pkt); \
+    MAYBE_SCHEDLEAVE(instance)
+
+void lcb_vbguess_newconfig(lcb_t instance, lcbvb_CONFIG *cfg, struct lcb_GUESSVB_st *guesses);
+int lcb_vbguess_remap(lcb_t instance, int vbid, int bad);
+#define lcb_vbguess_destroy(p) free(p)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/libcouchbase/src/iofactory.c

@@ -0,0 +1,575 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-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.
+ */
+
+#define LCB_IOPS_V12_NO_DEPRECATE 1 /* For Ruby */
+
+#include "internal.h"
+#include "plugins/io/select/select_io_opts.h"
+#include <libcouchbase/plugins/io/bsdio-inl.c>
+
+#ifdef LCB_EMBED_PLUGIN_LIBEVENT
+LIBCOUCHBASE_API lcb_error_t lcb_create_libevent_io_opts(int, lcb_io_opt_t*,void*);
+#endif
+
+typedef lcb_error_t (*create_func_t)(int version, lcb_io_opt_t *io, void *cookie);
+
+
+#ifdef _WIN32
+LIBCOUCHBASE_API
+lcb_error_t lcb_iocp_new_iops(int, lcb_io_opt_t *, void *);
+#define DEFAULT_IOPS LCB_IO_OPS_WINIOCP
+#else
+#define DEFAULT_IOPS LCB_IO_OPS_LIBEVENT
+#endif
+
+
+typedef struct {
+    /** The "base" name of the plugin */
+    const char *base;
+
+    /** Corresponding type */
+    lcb_io_ops_type_t iotype;
+
+    /** Filename */
+    const char *soname;
+
+    /** Symbol used to initialize the plugin */
+    const char *symbol;
+
+    /** Function to create the iops (if builtin) */
+    create_func_t create;
+
+    /** Static buffers if reading from the environment */
+    char s_soname[PATH_MAX];
+    char s_symbol[256];
+} plugin_info;
+
+
+#ifdef __APPLE__
+#define PLUGIN_SO(NAME) "libcouchbase_"NAME".dylib"
+#elif defined(_WIN32)
+/** Trailing period intentional. See docs for LoadLibrary */
+#if (_DEBUG && _MSC_VER)
+    #define PLUGIN_SO(NAME) "libcouchbase_"NAME"_d.dll."
+#else
+    #define PLUGIN_SO(NAME) "libcouchbase_"NAME".dll."
+#endif /* _DEBUG */
+#else
+#define PLUGIN_SO(NAME) "libcouchbase_"NAME".so"
+#endif
+
+#define PLUGIN_SYMBOL(NAME) "lcb_create_"NAME"_io_opts"
+
+#define BUILTIN_CORE(name, type, create) \
+        { name, type, NULL, NULL, create, { 0 }, { 0 } }
+
+#define BUILTIN_DL(name, type) \
+        { name, type, PLUGIN_SO(name), PLUGIN_SYMBOL(name), NULL, { 0 }, { 0 } }
+
+static plugin_info builtin_plugins[] = {
+    BUILTIN_CORE("select", LCB_IO_OPS_SELECT, lcb_create_select_io_opts),
+    BUILTIN_CORE("winsock", LCB_IO_OPS_WINSOCK, lcb_create_select_io_opts),
+
+#ifdef _WIN32
+    BUILTIN_CORE("iocp", LCB_IO_OPS_WINIOCP, lcb_iocp_new_iops),
+#endif
+
+#ifdef LCB_EMBED_PLUGIN_LIBEVENT
+    BUILTIN_CORE("libevent", LCB_IO_OPS_LIBEVENT, lcb_create_libevent_io_opts),
+#else
+    BUILTIN_DL("libevent", LCB_IO_OPS_LIBEVENT),
+#endif
+
+    BUILTIN_DL("libev", LCB_IO_OPS_LIBEV),
+    BUILTIN_DL("libuv", LCB_IO_OPS_LIBUV),
+
+    { NULL, LCB_IO_OPS_INVALID, NULL, NULL, NULL, { 0 }, { 0 } }
+};
+
+/**
+ * Checks the environment for plugin information.
+ * Returns:
+ *   1  information found and valid
+ *   0  not found
+ *   -1 error
+ */
+static int get_env_plugin_info(plugin_info *info)
+{
+
+    plugin_info *cur = NULL;
+    memset(info, 0, sizeof(*info));
+
+    if (!lcb_getenv_nonempty_multi(info->s_soname, sizeof(info->s_soname),
+        "LIBCOUCHBASE_EVENT_PLUGIN_NAME", "LCB_IOPS_NAME", NULL)) {
+        return 0;
+    }
+
+    for (cur = builtin_plugins; cur->base; cur++) {
+        if (strlen(cur->base) != strlen(info->s_soname)) {
+            continue;
+        }
+
+        if (strcmp(cur->base, info->s_soname) == 0) {
+            memcpy(info, cur, sizeof(*cur));
+            return 1;
+        }
+    }
+
+    if (!lcb_getenv_nonempty_multi(info->s_symbol, sizeof(info->s_symbol),
+        "LIBCOUCHBASE_EVENT_PLUGIN_SYMBOL", "LCB_IOPS_SYMBOL", NULL)) {
+        return -1;
+    }
+
+    info->soname = info->s_soname;
+    info->symbol = info->s_symbol;
+    return 1;
+}
+
+static plugin_info *find_plugin_info(lcb_io_ops_type_t iotype)
+{
+    plugin_info *cur;
+
+    if (iotype == LCB_IO_OPS_DEFAULT) {
+        iotype = DEFAULT_IOPS;
+    }
+
+    for (cur = builtin_plugins; cur->base; cur++) {
+        if (cur->iotype == iotype) {
+            return cur;
+        }
+    }
+    return NULL;
+}
+
+static void options_from_info(struct lcb_create_io_ops_st *opts,
+                              const plugin_info *info)
+{
+    void *cookie;
+
+    switch (opts->version) {
+    case 0:
+        cookie = opts->v.v0.cookie;
+        break;
+    case 1:
+        cookie = opts->v.v1.cookie;
+        break;
+    case 2:
+        cookie = opts->v.v2.cookie;
+        break;
+    default:
+        lcb_assert("unknown options version" && 0);
+        cookie = NULL;
+    }
+
+    if (info->create) {
+        opts->version = 2;
+        opts->v.v2.create = info->create;
+        opts->v.v2.cookie = cookie;
+        return;
+    }
+
+    opts->version = 1;
+    opts->v.v1.sofile = info->soname;
+    opts->v.v1.symbol = info->symbol;
+    opts->v.v1.cookie = cookie;
+}
+
+static lcb_error_t create_v2(lcb_io_opt_t *io,
+                             const struct lcb_create_io_ops_st *options);
+
+struct plugin_st {
+    void *dlhandle;
+    union {
+        create_func_t create;
+        void *voidptr;
+    } func;
+};
+
+#ifndef _WIN32
+static lcb_error_t get_create_func(const char *image,
+                                   const char *symbol,
+                                   struct plugin_st *plugin,
+                                   int do_warn)
+{
+    void *dlhandle = dlopen(image, RTLD_NOW | RTLD_LOCAL);
+    if (dlhandle == NULL) {
+        if (do_warn) {
+            fprintf(stderr,
+                    "[libcouchbase] dlopen of %s failed with '%s'\n",
+                    image, dlerror());
+        }
+        return LCB_DLOPEN_FAILED;
+    }
+
+    memset(plugin, 0, sizeof(*plugin));
+    plugin->func.create = NULL;
+    plugin->func.voidptr = dlsym(dlhandle, symbol);
+
+    if (plugin->func.voidptr == NULL) {
+        if (do_warn) {
+            fprintf(stderr,
+                    "[libcouchbase] dlsym (%s) -> (%s) failed: %s\n",
+                    image, symbol, dlerror());
+        }
+        dlclose(dlhandle);
+        dlhandle = NULL;
+        return LCB_DLSYM_FAILED;
+
+    } else {
+        plugin->dlhandle = dlhandle;
+    }
+    return LCB_SUCCESS;
+}
+
+static void close_dlhandle(void *handle)
+{
+    dlclose(handle);
+}
+#else
+static lcb_error_t get_create_func(const char *image,
+                                   const char *symbol,
+                                   struct plugin_st *plugin,
+                                   int do_warn)
+{
+    HMODULE hLibrary = LoadLibrary(image);
+    FARPROC hFunction;
+
+    memset(plugin, 0, sizeof(*plugin));
+
+    if (!hLibrary) {
+        if (do_warn) {
+            fprintf(stderr, "LoadLibrary of %s failed with code %d\n",
+                    image, (int)GetLastError());
+        }
+        return LCB_DLOPEN_FAILED;
+    }
+
+    hFunction = GetProcAddress(hLibrary, symbol);
+    if (!hFunction) {
+        if (do_warn) {
+            fprintf(stderr, "GetProcAddress (%s) -> (%s) failed with code %d\n",
+                    image, symbol, (int)GetLastError());
+        }
+        FreeLibrary(hLibrary);
+        return LCB_DLSYM_FAILED;
+    }
+
+    plugin->func.create = (create_func_t)hFunction;
+    plugin->dlhandle = hLibrary;
+    return LCB_SUCCESS;
+}
+
+static void close_dlhandle(void *handle)
+{
+    FreeLibrary((HMODULE)handle);
+}
+#endif
+
+static int want_dl_debug = 0; /* global variable */
+static lcb_error_t create_v1(lcb_io_opt_t *io,
+                             const struct lcb_create_io_ops_st *options);
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_destroy_io_ops(lcb_io_opt_t io)
+{
+    if (io) {
+        void *dlhandle = io->dlhandle;
+        if (io->destructor) {
+            io->destructor(io);
+        }
+        if (dlhandle) {
+            close_dlhandle(dlhandle);
+        }
+    }
+
+    return LCB_SUCCESS;
+}
+
+/**
+ * Note, the 'pi' is just a context variable to ensure the pointers copied
+ * to the options are valid. It is *not* meant to be inspected.
+ */
+static lcb_error_t generate_options(plugin_info *pi,
+                                    const struct lcb_create_io_ops_st *user,
+                                    struct lcb_create_io_ops_st *ours,
+                                    lcb_io_ops_type_t *type)
+{
+    if (user) {
+        memcpy(ours, user, sizeof(*user));
+
+    } else {
+        memset(ours, 0, sizeof(*ours));
+        ours->version = 0;
+        ours->v.v0.type = LCB_IO_OPS_DEFAULT;
+    }
+
+    if (ours->version > 0) {
+        if (type) {
+            *type = LCB_IO_OPS_INVALID;
+        }
+        /* we don't handle non-v0 options */
+        return LCB_SUCCESS;
+    }
+
+    if (ours->v.v0.type == LCB_IO_OPS_DEFAULT) {
+        int rv;
+        memset(pi, 0, sizeof(*pi));
+
+        rv = get_env_plugin_info(pi);
+        if (rv > 0) {
+            options_from_info(ours, pi);
+
+            if (type) {
+                *type = pi->iotype;
+            }
+
+        } else if (rv < 0) {
+            return LCB_BAD_ENVIRONMENT;
+
+        } else {
+            plugin_info *pip = find_plugin_info(LCB_IO_OPS_DEFAULT);
+            lcb_assert(pip);
+
+            if (type) {
+                *type = pip->iotype;
+            }
+
+            options_from_info(ours, pip);
+
+            /* if the plugin is dynamically loadable, we need to
+             * fallback to select(2) plugin in case we cannot find the
+             * create function */
+            if (ours->version == 1) {
+                struct plugin_st plugin;
+                int want_debug;
+                lcb_error_t ret;
+
+                if (lcb_getenv_boolean_multi("LIBCOUCHBASE_DLOPEN_DEBUG",
+                    "LCB_DLOPEN_DEBUG", NULL)) {
+                    want_debug = 1;
+                } else {
+                    want_debug = want_dl_debug;
+                }
+                ret = get_create_func(ours->v.v1.sofile, ours->v.v1.symbol, &plugin, want_debug);
+                if (ret != LCB_SUCCESS) {
+                    if (type) {
+                        *type = LCB_IO_OPS_SELECT;
+                    }
+                    ours->version = 2;
+                    ours->v.v2.create = lcb_create_select_io_opts;
+                    ours->v.v2.cookie = NULL;
+                }
+            }
+        }
+        return LCB_SUCCESS;
+
+    } else {
+        /** Not default, ignore environment */
+        plugin_info *pip = find_plugin_info(ours->v.v0.type);
+        if (!pip) {
+            return LCB_NOT_SUPPORTED;
+        }
+        options_from_info(ours, pip);
+        if (type) {
+            *type = pip->iotype;
+        }
+        return LCB_SUCCESS;
+    }
+}
+
+LIBCOUCHBASE_API
+lcb_error_t lcb_create_io_ops(lcb_io_opt_t *io,
+                              const struct lcb_create_io_ops_st *io_opts)
+{
+
+    struct lcb_create_io_ops_st options;
+    lcb_error_t err;
+    plugin_info pi;
+    memset(&options, 0, sizeof(options));
+
+    err = lcb_initialize_socket_subsystem();
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    err = generate_options(&pi, io_opts, &options, NULL);
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+
+    if (options.version == 1) {
+        err = create_v1(io, &options);
+    } else if (options.version == 2) {
+        err = create_v2(io, &options);
+    } else {
+        return LCB_NOT_SUPPORTED;
+    }
+
+    if (err != LCB_SUCCESS) {
+        return err;
+    }
+    /*XXX:
+     * This block of code here because the Ruby SDK relies on undocumented
+     * functionality of older versions of libcouchbase in which its send/recv
+     * functions assert that the number of IOV elements passed is always going
+     * to be 2.
+     *
+     * This works around the issue by patching the send/recv functions of
+     * the ruby implementation at load-time.
+     *
+     * This block of code will go away once the Ruby SDK is fixed and a released
+     * version has been out for enough time that it won't break common existing
+     * deployments.
+     */
+    if (io_opts && io_opts->version == 1 && io_opts->v.v1.symbol != NULL) {
+        if (strstr(io_opts->v.v1.symbol, "cb_create_ruby")) {
+            wire_lcb_bsd_impl(*io);
+        }
+    }
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t create_v1(lcb_io_opt_t *io,
+                             const struct lcb_create_io_ops_st *options)
+{
+    struct plugin_st plugin;
+    int want_debug;
+    lcb_error_t ret;
+
+    if (lcb_getenv_boolean_multi("LIBCOUCHBASE_DLOPEN_DEBUG",
+        "LCB_DLOPEN_DEBUG", NULL)) {
+        want_debug = 1;
+    } else {
+        want_debug = want_dl_debug;
+    }
+    ret = get_create_func(options->v.v1.sofile,
+                          options->v.v1.symbol, &plugin, want_debug);
+    if (ret != LCB_SUCCESS) {
+        /* try to look up the symbol in the current image */
+        lcb_error_t ret2 = get_create_func(NULL, options->v.v1.symbol, &plugin, want_debug);
+        if (ret2 != LCB_SUCCESS) {
+#ifndef _WIN32
+            char path[PATH_MAX];
+            /* try to look up the so-file in the libdir */
+            snprintf(path, PATH_MAX, "%s/%s", LCB_LIBDIR, options->v.v1.sofile);
+            ret2 = get_create_func(path, options->v.v1.symbol, &plugin, want_debug);
+#endif
+            if (ret2 != LCB_SUCCESS) {
+                /* return original error to allow caller to fix it */
+                return ret;
+            }
+        }
+    }
+
+    ret = plugin.func.create(0, io, options->v.v1.cookie);
+    if (ret != LCB_SUCCESS) {
+        if (options->v.v1.sofile != NULL) {
+            close_dlhandle(plugin.dlhandle);
+        }
+        return LCB_CLIENT_ENOMEM;
+    } else {
+        lcb_io_opt_t iop = *io;
+        iop->dlhandle = plugin.dlhandle;
+        /* check if plugin selected compatible version */
+        if (iop->version < 0 || iop->version > 3) {
+            lcb_destroy_io_ops(iop);
+            return LCB_PLUGIN_VERSION_MISMATCH;
+        }
+    }
+
+    return LCB_SUCCESS;
+}
+
+static lcb_error_t create_v2(lcb_io_opt_t *io,
+                             const struct lcb_create_io_ops_st *options)
+{
+    lcb_error_t ret;
+
+    ret = options->v.v2.create(0, io, options->v.v2.cookie);
+    if (ret != LCB_SUCCESS) {
+        return ret;
+    } else {
+        lcb_io_opt_t iop = *io;
+        /* check if plugin selected compatible version */
+        if (iop->version < 0 || iop->version > 3) {
+            lcb_destroy_io_ops(iop);
+            return LCB_PLUGIN_VERSION_MISMATCH;
+        }
+    }
+
+    return LCB_SUCCESS;
+}
+
+lcb_error_t lcb_iops_cntl_handler(int mode,
+                                  lcb_t instance, int cmd, void *arg)
+{
+    (void)instance;
+
+    switch (cmd) {
+    case LCB_CNTL_IOPS_DEFAULT_TYPES: {
+        struct lcb_create_io_ops_st options;
+        struct lcb_cntl_iops_info_st *info = arg;
+        lcb_error_t err;
+        plugin_info pi;
+
+        memset(&options, 0, sizeof(options));
+        if (mode != LCB_CNTL_GET) {
+            return LCB_NOT_SUPPORTED;
+        }
+
+        if (info->version != 0) {
+            return LCB_EINVAL;
+        }
+
+        info->v.v0.os_default = DEFAULT_IOPS;
+
+        err = generate_options(&pi,
+                               info->v.v0.options,
+                               &options,
+                               &info->v.v0.effective);
+
+        if (err != LCB_SUCCESS) {
+            return LCB_ERROR;
+        }
+
+        return LCB_SUCCESS;
+    }
+
+    case LCB_CNTL_IOPS_DLOPEN_DEBUG: {
+        int *usr = arg;
+        if (mode == LCB_CNTL_SET) {
+            want_dl_debug = *usr;
+        } else {
+            *usr = want_dl_debug;
+        }
+        return LCB_SUCCESS;
+    }
+
+    default:
+        return LCB_EINVAL;
+
+    }
+
+}
+
+/* In-library wrapper version */
+LIBCOUCHBASE_API
+void
+lcb_iops_wire_bsd_impl2(lcb_bsd_procs *procs, int version)
+{
+    wire_lcb_bsd_impl2(procs, version);
+}