mt-libcouchbase 1.4.0

data/ext/libcouchbase/src/lcbio/iotable.h

@@ -0,0 +1,169 @@
+/* -*- 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_IOTABLE_H
+#define LCB_IOTABLE_H
+
+#include <libcouchbase/couchbase.h>
+
+/**
+ * @file
+ * @brief Internal I/O Table routines
+ *
+ * @details
+ * Include this file if you are actually manipulating the I/O system (i.e.
+ * creating timers, starting/stoping loops, or writing to/from a socket).
+ *
+ * This file defines the iotable layout as well as various macros associated
+ * with its use. The actual "Public" API (i.e. just for passing it around) can
+ * be found in <lcbio/connect.h>
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** Whether the underlying model is event-based */
+#define IOT_IS_EVENT(iot) ((iot)->model == LCB_IOMODEL_EVENT)
+
+/** Returns an lcb_ev_procs structure for event-based I/O */
+#define IOT_V0EV(iot) (iot)->u_io.v0.ev
+
+/** Returns an lcb_bsd_procs structure for event-based I/O */
+#define IOT_V0IO(iot) (iot)->u_io.v0.io
+
+/** Returns an lcb_completion_procs structure for completion-based I/O */
+#define IOT_V1(iot) (iot)->u_io.completion
+
+/** Error code of last I/O operation */
+#define IOT_ERRNO(iot) (iot)->p->v.v0.error
+
+/** Start the loop */
+#define IOT_START(iot) (iot)->loop.start((iot)->p)
+
+/** Stop the loop */
+#define IOT_STOP(iot) (iot)->loop.stop((iot)->p)
+
+/** First argument to IO Table */
+#define IOT_ARG(iot) (iot)->p
+
+typedef struct lcbio_TABLE {
+    lcb_io_opt_t p;
+    lcb_iomodel_t model;
+    lcb_timer_procs timer;
+    lcb_loop_procs loop;
+
+    union {
+        struct {
+            lcb_ev_procs ev;
+            lcb_bsd_procs io;
+        } v0;
+        lcb_completion_procs completion;
+    } u_io;
+    unsigned refcount;
+    void (*dtor)(void *);
+
+#ifdef __cplusplus
+    bool is_E() const { return IOT_IS_EVENT(this); }
+    bool is_C() const { return !is_E(); }
+    int get_errno() const { return IOT_ERRNO(this); }
+
+    void run_loop() { IOT_START(this); }
+    void stop_loop() { IOT_STOP(this); }
+
+    int E_connect(lcb_socket_t sock, const sockaddr* saddr, unsigned addrlen) {
+       return IOT_V0IO(this).connect0(p, sock, saddr, addrlen);
+    }
+
+    lcb_socket_t E_socket(int domain, int type, int protocol) {
+        return IOT_V0IO(this).socket0(p, domain, type, protocol);
+    }
+
+    lcb_socket_t E_socket(const addrinfo *ai) {
+        return E_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+    }
+
+    void E_close(lcb_socket_t sock) {
+        IOT_V0IO(this).close(p, sock);
+    }
+
+    void *E_event_create() {
+        return IOT_V0EV(this).create(p);
+    }
+
+    void E_event_watch(lcb_socket_t fd, void *event, short mask, void *arg,
+                       lcb_ioE_callback cb) {
+        IOT_V0EV(this).watch(p, fd, event, mask, arg, cb);
+    }
+
+     void E_event_destroy(void *event) {
+         IOT_V0EV(this).destroy(p, event);
+     }
+
+    void E_event_cancel(lcb_socket_t fd, void *event) {
+        IOT_V0EV(this).cancel(p, fd, event);
+    }
+
+    int E_check_closed(lcb_socket_t s, int flags) {
+        return IOT_V0IO(this).is_closed(p, s, flags);
+    }
+
+    int E_cntl(lcb_socket_t s, int mode, int opt, void *val) {
+        return IOT_V0IO(this).cntl(p, s, mode, opt, val);
+    }
+
+    void C_close(lcb_sockdata_t *sd) {
+        IOT_V1(this).close(p, sd);
+    }
+
+    int C_connect(lcb_sockdata_t *sd, const sockaddr *addr, unsigned addrlen,
+                  lcb_io_connect_cb callback) {
+        return IOT_V1(this).connect(p, sd, addr, addrlen, callback);
+    }
+
+    lcb_sockdata_t* C_socket(int domain, int type, int protocol) {
+        return IOT_V1(this).socket(p, domain, type, protocol);
+    }
+
+    lcb_sockdata_t* C_socket(const addrinfo *ai) {
+        return C_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
+    }
+
+    int C_check_closed(lcb_sockdata_t *sock, int flags) {
+        return IOT_V1(this).is_closed(p, sock, flags);
+    }
+
+    int C_cntl(lcb_sockdata_t *sd, int mode, int opt, void *val) {
+        return IOT_V1(this).cntl(p, sd, mode, opt, val) == 0;
+    }
+
+    bool has_cntl() {
+        if (is_E()) {
+            return IOT_V0IO(this).cntl != NULL;
+        } else {
+            return IOT_V1(this).cntl != NULL;
+        }
+    }
+#endif
+
+} lcbio_TABLE;
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/src/lcbio/ioutils.cc

@@ -0,0 +1,356 @@
+/* -*- 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 _WIN32
+#include <errno.h>
+#endif
+
+#include "connect.h"
+#include "ioutils.h"
+#include "hostlist.h"
+#include "manager.h"
+#include "iotable.h"
+#include <stdio.h>
+#include "ssl.h"
+
+lcbio_CSERR
+lcbio_mkcserr(int syserr)
+{
+    switch (syserr) {
+    case 0:
+        return LCBIO_CSERR_CONNECTED;
+
+    case EINTR:
+        return LCBIO_CSERR_INTR;
+
+    case EWOULDBLOCK:
+#ifdef USE_EAGAIN
+    case EAGAIN:
+#endif
+    case EINPROGRESS:
+    case EALREADY:
+        return LCBIO_CSERR_BUSY;
+
+
+    case EISCONN:
+        return LCBIO_CSERR_CONNECTED;
+
+#ifdef _WIN32
+    case EINVAL:
+        return LCBIO_CSERR_EINVAL;
+#endif
+    default:
+        return LCBIO_CSERR_EFAIL;
+    }
+}
+
+void
+lcbio_mksyserr(lcbio_OSERR in, lcbio_OSERR *out)
+{
+    switch (in) {
+    case EINTR:
+    case EWOULDBLOCK:
+#ifdef USE_EAGAIN
+    case EAGAIN:
+#endif
+    case EINVAL:
+    case EINPROGRESS:
+    case EISCONN:
+    case EALREADY:
+        return;
+    default:
+        *out = in;
+        break;
+    }
+}
+
+static lcb_error_t
+ioerr2lcberr(lcbio_OSERR in, const lcb_settings *settings)
+{
+    switch (in) {
+    case 0:
+        return LCB_ESOCKSHUTDOWN;
+    case ECONNREFUSED:
+        return LCB_ECONNREFUSED;
+    case ENETUNREACH:
+    case EHOSTUNREACH:
+    case EHOSTDOWN:
+        return LCB_ENETUNREACH;
+    case EMFILE:
+    case ENFILE:
+        return LCB_EFDLIMITREACHED;
+    case EADDRINUSE:
+    case EADDRNOTAVAIL:
+        return LCB_ECANTGETPORT;
+    case ECONNRESET:
+    case ECONNABORTED:
+        return LCB_ECONNRESET;
+    default:
+        lcb_log(settings, "lcbio", LCB_LOG_WARN, __FILE__, __LINE__, "OS errno %d (%s) does not have a direct client error code equivalent. Using NETWORK_ERROR", in, strerror(in));
+        return LCB_NETWORK_ERROR;
+    }
+}
+
+lcb_error_t
+lcbio_mklcberr(lcbio_OSERR in, const lcb_settings *settings)
+{
+    if (settings->detailed_neterr == 0) {
+        lcb_log(settings, "lcbio", LCB_LOG_WARN, __FILE__, __LINE__, "Translating errno=%d, lcb=0x%x to NETWORK_ERROR",
+            in, ioerr2lcberr(in, settings));
+        return LCB_NETWORK_ERROR;
+    }
+
+    return ioerr2lcberr(in, settings);
+}
+
+lcb_socket_t
+lcbio_E_ai2sock(lcbio_TABLE *io, struct addrinfo **ai, int *connerr)
+{
+    lcb_socket_t ret = INVALID_SOCKET;
+    *connerr = 0;
+
+    for (; *ai; *ai = (*ai)->ai_next) {
+        ret = io->E_socket(*ai);
+
+        if (ret != INVALID_SOCKET) {
+            return ret;
+        } else {
+            *connerr = io->get_errno();
+        }
+    }
+
+    return ret;
+}
+
+lcb_sockdata_t *
+lcbio_C_ai2sock(lcbio_TABLE *io, struct addrinfo **ai, int *connerr)
+{
+    lcb_sockdata_t *ret = NULL;
+    for (; *ai; *ai = (*ai)->ai_next) {
+        ret = io->C_socket(*ai);
+        if (ret) {
+            return ret;
+        } else {
+            *connerr = IOT_ERRNO(io);
+        }
+    }
+    return ret;
+}
+
+struct nameinfo_common {
+    char remote[NI_MAXHOST + NI_MAXSERV + 2];
+    char local[NI_MAXHOST + NI_MAXSERV + 2];
+};
+
+static int
+saddr_to_string(struct sockaddr *saddr, int len, char *buf, lcb_size_t nbuf)
+{
+    char h[NI_MAXHOST + 1];
+    char p[NI_MAXSERV + 1];
+    int rv;
+
+    rv = getnameinfo(saddr, len, h, sizeof(h), p, sizeof(p),
+                     NI_NUMERICHOST | NI_NUMERICSERV);
+    if (rv < 0) {
+        return 0;
+    }
+
+    if (snprintf(buf, nbuf, "%s;%s", h, p) < 0) {
+        return 0;
+    }
+
+    return 1;
+}
+
+void
+lcbio__load_socknames(lcbio_SOCKET *sock)
+{
+    int n_salocal, n_saremote, rv;
+    struct lcb_nameinfo_st ni;
+    lcbio_CONNINFO *info = sock->info;
+
+    n_salocal = sizeof(info->sa_local);
+    n_saremote = sizeof(info->sa_remote);
+    ni.local.name = (struct sockaddr *)&info->sa_local;
+    ni.local.len = &n_salocal;
+    ni.remote.name = (struct sockaddr *)&info->sa_remote;
+    ni.remote.len = &n_saremote;
+
+    if (!IOT_IS_EVENT(sock->io)) {
+        if (!sock->u.sd) {
+            return;
+        }
+
+        rv = IOT_V1(sock->io).nameinfo(IOT_ARG(sock->io), sock->u.sd, &ni);
+
+        if (ni.local.len == 0 || ni.remote.len == 0 || rv < 0) {
+            return;
+        }
+
+    } else {
+        socklen_t sl_tmp = sizeof(info->sa_local);
+        if (sock->u.fd == INVALID_SOCKET) {
+            return;
+        }
+
+        rv = getsockname(sock->u.fd, ni.local.name, &sl_tmp);
+        n_salocal = sl_tmp;
+        if (rv < 0) {
+            return;
+        }
+        rv = getpeername(sock->u.fd, ni.remote.name, &sl_tmp);
+        n_saremote = sl_tmp;
+        if (rv < 0) {
+            return;
+        }
+    }
+    info->naddr = n_salocal;
+}
+
+int
+lcbio_get_nameinfo(lcbio_SOCKET *sock, struct lcbio_NAMEINFO *nistrs)
+{
+    lcbio_CONNINFO *info = sock->info;
+    if (!info) {
+        return 0;
+    }
+    if (!info->naddr) {
+        return 0;
+    }
+
+    if (!saddr_to_string((struct sockaddr*)&info->sa_remote, info->naddr,
+                         nistrs->remote, sizeof(nistrs->remote))) {
+        return 0;
+    }
+
+    if (!saddr_to_string((struct sockaddr*)&info->sa_local, info->naddr,
+                         nistrs->local, sizeof(nistrs->local))) {
+        return 0;
+    }
+
+    return 1;
+}
+
+int
+lcbio_is_netclosed(lcbio_SOCKET *sock, int flags)
+{
+    lcbio_pTABLE iot = sock->io;
+
+    if (iot->is_E()) {
+        return iot->E_check_closed(sock->u.fd, flags);
+    } else {
+        return iot->C_check_closed(sock->u.sd, flags);
+    }
+}
+
+lcb_error_t
+lcbio_enable_sockopt(lcbio_SOCKET *s, int cntl) {
+    lcbio_pTABLE iot = s->io;
+    int rv;
+    int value = 1;
+
+    if (!iot->has_cntl()) {
+        return LCB_NOT_SUPPORTED;
+    }
+    if (iot->is_E()) {
+        rv = iot->E_cntl(s->u.fd, LCB_IO_CNTL_SET, cntl, &value);
+    } else {
+        rv = iot->C_cntl(s->u.sd, LCB_IO_CNTL_SET, cntl, &value);
+    }
+    if (rv != 0) {
+        return lcbio_mklcberr(IOT_ERRNO(iot), s->settings);
+    } else {
+        return LCB_SUCCESS;
+    }
+}
+
+const char *
+lcbio_strsockopt(int cntl) {
+    switch (cntl) {
+    case LCB_IO_CNTL_TCP_KEEPALIVE:
+        return "TCP_KEEPALIVE";
+    case LCB_IO_CNTL_TCP_NODELAY:
+        return "TCP_NODELAY";
+    default:
+        return "FIXME: Unknown option";
+    }
+}
+
+int
+lcbio_ssl_supported(void)
+{
+#ifdef LCB_NO_SSL
+    return 0;
+#else
+    return 1;
+#endif
+}
+
+lcbio_pSSLCTX lcbio_ssl_new__fallback(const char *, const char *, const char *, int, lcb_error_t *errp, lcb_settings *)
+{
+    if (errp) { *errp = LCB_CLIENT_FEATURE_UNAVAILABLE; }
+    return NULL;
+}
+
+
+#ifdef LCB_NO_SSL
+void lcbio_ssl_free(lcbio_pSSLCTX) {
+}
+lcb_error_t lcbio_ssl_apply(lcbio_SOCKET*, lcbio_pSSLCTX) {
+    return LCB_CLIENT_FEATURE_UNAVAILABLE;
+}
+int lcbio_ssl_check(lcbio_SOCKET*) {
+    return 0;
+}
+lcb_error_t lcbio_ssl_get_error(lcbio_SOCKET *) {
+    return LCB_SUCCESS;
+}
+void lcbio_ssl_global_init(void) {
+}
+lcb_error_t lcbio_sslify_if_needed(lcbio_SOCKET *, lcb_settings *) {
+    return LCB_SUCCESS;
+}
+#endif
+
+std::string lcbio__inet_ntop(sockaddr_storage *ss)
+{
+    char buf[4096] = {0};
+    switch(ss->ss_family) {
+    case AF_INET:
+    {
+        struct sockaddr_in *addr = (struct sockaddr_in *)ss;
+        inet_ntop(AF_INET, &(addr->sin_addr), buf, sizeof(buf));
+        size_t len = strlen(buf);
+        snprintf(buf + len, 10, ":%d", (int)ntohs(addr->sin_port));
+    }
+    break;
+
+    case AF_INET6:
+    {
+        struct sockaddr_in6 *addr = (struct sockaddr_in6 *)ss;
+        inet_ntop(AF_INET6, &(addr->sin6_addr), buf, sizeof(buf));
+        size_t len = strlen(buf);
+        snprintf(buf + len, 10, ":%d", (int)ntohs(addr->sin6_port));
+    }
+    break;
+
+    default:
+        strncpy(buf, "Unknown AF", sizeof(buf));
+    }
+
+    return std::string(buf);
+}

data/ext/libcouchbase/src/lcbio/ioutils.h

@@ -0,0 +1,144 @@
+/* -*- 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 LCBIO_UTILS_H
+#define LCBIO_UTILS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file
+ * @brief Various I/O-related utilities
+ */
+
+typedef enum {
+    LCBIO_CSERR_BUSY, /* request pending */
+    LCBIO_CSERR_INTR, /* eintr */
+    LCBIO_CSERR_EINVAL, /* einval */
+    LCBIO_CSERR_EFAIL, /* hard failure */
+    LCBIO_CSERR_CONNECTED /* connection established */
+} lcbio_CSERR;
+
+/**
+ * Convert the system errno (indicated by 'syserr')
+ * @param syserr system error code
+ * @return a status code simplifying the error
+ */
+lcbio_CSERR
+lcbio_mkcserr(int syserr);
+
+/**
+ * Assigns the target error code if it indicates a 'fatal' or 'relevant' error
+ * code.
+ *
+ * @param in Error code to inspect
+ * @param[out] out target pointer
+ */
+void
+lcbio_mksyserr(lcbio_OSERR in, lcbio_OSERR *out);
+
+/**
+ * Convert a system error code into one suitable for returning to the user
+ * @param in The code received. This can be 0, for graceful shutdown
+ * @param settings The settings for the library
+ * @return An error code.
+ */
+lcb_error_t
+lcbio_mklcberr(lcbio_OSERR in, const lcb_settings *settings);
+
+/**
+ * Traverse the addrinfo structure and return a socket.
+ * @param io the iotable structure used to create the socket
+ * @param[in,out] ai an addrinfo structure
+ * @param[out] connerr an error if a socket could not be established.
+ * @return a new socket, or INVALID_SOCKET
+ *
+ * The ai structure should be considered as an opaque iterator. This function
+ * will look at the first entry in the list and attempt to create a socket.
+ * It will traverse through each entry and break when either a socket has
+ * been successfully created, or no more addrinfo entries remain.
+ */
+lcb_socket_t
+lcbio_E_ai2sock(lcbio_pTABLE io, struct addrinfo **ai, int *connerr);
+
+lcb_sockdata_t *
+lcbio_C_ai2sock(lcbio_pTABLE io, struct addrinfo **ai, int *conerr);
+
+struct lcbio_NAMEINFO {
+    char local[NI_MAXHOST + NI_MAXSERV + 2];
+    char remote[NI_MAXHOST + NI_MAXSERV + 2];
+};
+
+int
+lcbio_get_nameinfo(lcbio_SOCKET *sock, struct lcbio_NAMEINFO *nistrs);
+
+/** Basic wrapper around the @ref lcb_ioE_chkclosed_fn family */
+int
+lcbio_is_netclosed(lcbio_SOCKET *sock, int flags);
+
+/**
+ * Enable an option on a socket
+ * @param sock The socket
+ * @param cntl The option (LCB_IO_CNTL_xxx)
+ * @return
+ */
+lcb_error_t
+lcbio_enable_sockopt(lcbio_SOCKET *sock, int cntl);
+
+const char *
+lcbio_strsockopt(int cntl);
+
+void
+lcbio__load_socknames(lcbio_SOCKET *sock);
+
+#ifdef _WIN32
+#define lcbio_syserrno GetLastError()
+#else
+#define lcbio_syserrno errno
+#endif
+
+#ifdef __cplusplus
+}
+
+std::string lcbio__inet_ntop(sockaddr_storage *ss);
+
+namespace lcb {
+namespace io {
+
+/**
+ * This interface defines a pending connection request. It may be
+ * cancelled.
+ */
+class ConnectionRequest {
+public:
+    virtual void cancel() = 0;
+    virtual ~ConnectionRequest() {}
+    static void cancel(ConnectionRequest **pp) {
+        if (*pp) {
+            (*pp)->cancel();
+            *pp = NULL;
+        }
+    }
+};
+
+}
+}
+
+#endif
+#endif

data/ext/libcouchbase/src/lcbio/lcbio.h

@@ -0,0 +1,51 @@
+/* -*- 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 LCBIO_H
+#define LCBIO_H
+#include "connect.h"
+#include "manager.h"
+#include "ioutils.h"
+#include "ctx.h"
+#endif
+
+/**
+ * @defgroup lcbio I/O
+ * @brief IO Core
+ *
+ * @details
+ *
+ * This module represents the I/O core of libcouchbase. Effort has been made
+ * so that this module in theory is usable outside of libcouchbase.
+ *
+ * # Architectural Overview
+ *
+ * The I/O core (_LCBIO_) has been designed to support different I/O models and
+ * operating environments, with the goal of being able to integrate natively
+ * into such environments with minimal performance loss. Integration is acheived
+ * through several layers. The first layer is the _IOPS_ system defined in
+ * <libcouchbase/iops.h> and defines integration APIs for different I/O models.
+ *
+ * Afterwards, this is flattened and normalized into an _IO Table_ (`lcbio_TABLE`)
+ * which serves as a context and abstraction layer for unifying those two APIs
+ * where applicable.
+ *
+ * Finally the "End-user" APIs (in this case end-user means the application which
+ * requests a TCP connection or I/O on a socket) employs the
+ * `lcbio_connect` and `lcbio_CTX` systems to provide a uniform interface, the
+ * end result being that the underlying I/O model is completely abstracted.
+ */