mt-libcouchbase 1.4.0

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);
+}