mt-libcouchbase 1.4.0

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

@@ -0,0 +1,195 @@
+/* -*- 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_MANAGER_H
+#define LCBIO_MANAGER_H
+#include "connect.h"
+#include "settings.h"
+#include "list.h"
+#include "ioutils.h"
+#include <stdio.h>
+
+
+/**
+ * @file
+ * @brief Socket pooling routines
+ *
+ * @details
+ * General purpose connection manager for LCB sockets. This object is
+ * responsible for maintaining and properly handling idle connections
+ * and pooling them (optionally).
+ */
+
+/**
+ * @ingroup lcbio
+ * @defgroup lcbio-mgr Socket Pooling
+ * @addtogroup lcbio-mgr
+ * @{
+ */
+
+#ifdef __cplusplus
+#include <map>
+
+namespace lcb {
+namespace io {
+
+/** @brief Socket Pool */
+class Pool;
+
+/** @brief Pooled connection */
+struct PoolConnInfo;
+
+/** @brief Cancellable pool request */
+struct PoolRequest;
+
+struct PoolHost;
+}
+}
+
+typedef lcb::io::Pool lcbio_MGR;
+extern "C" {
+
+#else
+/* C only */
+typedef struct lcbio_MGR_CDUMMY lcbio_MGR;
+#endif
+
+#ifdef __cplusplus
+}
+
+namespace lcb {
+namespace io {
+class Pool {
+public:
+    /**
+     * Create a socket pool controlled by the given settings and IO structure.
+     * This function will increment the refcount on both the settings and table
+     * objects.
+     */
+    Pool(lcb_settings*, lcbio_pTABLE);
+
+    /**
+     * Destroy the socket pool. Note that internally this just decrements the
+     * reference count. The object is only destroyed when its count hits zero.
+     */
+    void shutdown();
+
+    /**
+     * Request a connection from the socket pool. The semantics and prototype
+     * of this function are by design similar to lcbio_connect() as they do the
+     * same things.
+     *
+     * @param dest the host to connect to
+     * @param timeout amount of time to wait for a connection to be estblished
+     * @param handler a callback to invoke when the result is ready
+     * @param arg an argument passed to the callback
+     * @return a request handle which may be cancelled
+     * @see lcbio_connect()
+     */
+    ConnectionRequest* get(const lcb_host_t&, uint32_t, lcbio_CONNDONE_cb, void *);
+
+    /**
+     * Release a socket back into the pool. This means the socket is no longer
+     * used and shall be available for reuse for another request. To verify these
+     * constraints, the socket's reference count must be one. Once the socket
+     * has been released its reference count should not be modified.
+     */
+    static void put(lcbio_SOCKET *sock);
+
+    /**
+     * Mark a slot as available but discard the current connection. This should be
+     * done if the connection itself is "dirty", i.e. has a protocol error on it
+     * or is otherwise not suitable for reuse
+     */
+    static void discard(lcbio_SOCKET *sock);
+
+    /**
+     * Like lcbio_mgr_discard() except the source connection is left untouched. It
+     * is removed from the pool instead.
+     *
+     * Because the lcbio_MGR object itself has internal limits and thresholds on how
+     * many leased and/or open connections it can contain, when a connection receives
+     * an error it must either be discarded back to the pool (in which case the
+     * connection is cleaned up and is freed) or it must be detached (in which case
+     * the connection object itself still remains valid, but the pool does not know
+     * about it, and all its counters are restored, as with lcbio_mgr_discard()).
+     *
+     * lcbio_mgr_discard() itself is now implemented as the equivalent to:
+     *  `lcbio_mgr_detach(mgr, conn)`;
+     */
+    static void detach(lcbio_SOCKET *sock);
+
+    static bool is_from_pool(const lcbio_SOCKET *sock);
+
+    /**
+     * Dumps the connection manager state to stderr
+     */
+    void dump(FILE *) const;
+
+    inline void ref();
+    inline void unref();
+
+    struct Options {
+        Options() : maxtotal(0), maxidle(0), tmoidle(0) {
+        }
+
+        /** Maximum *total* number of connections opened by the pool. If this
+         * number is exceeded, the pool will black hole future requests until
+         * a new slot becomes available.
+         */
+        unsigned maxtotal;
+
+        /**
+         * Maximum number of idle connections to keep around
+         */
+        unsigned maxidle;
+
+        /**
+         * The amount of time the pool should wait before closing idle
+         * connections. In microseconds
+         */
+        uint32_t tmoidle;
+    };
+
+    void set_options(const Options& opts) {
+        options = opts;
+    }
+
+    Options& get_options() {
+        return options;
+    }
+
+    void toJSON(hrtime_t now, Json::Value &node);
+
+private:
+    friend struct PoolRequest;
+    friend struct PoolConnInfo;
+    friend struct PoolHost;
+
+    typedef std::map<std::string, PoolHost*> HostMap;
+    HostMap ht;
+    lcb_settings *settings;
+    lcbio_pTABLE io;
+    Options options;
+    unsigned refcount;
+};
+} // namespace io
+} // namespace lcb
+#endif
+/**@}*/
+
+#endif /* LCB_SOCKPOOL_H */

data/ext/libcouchbase/src/lcbio/protoctx.c

@@ -0,0 +1,84 @@
+/* -*- 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 "connect.h"
+
+void
+lcbio_protoctx_add(lcbio_SOCKET *sock, lcbio_PROTOCTX *ctx)
+{
+    lcb_list_append(&sock->protos, &ctx->ll);
+}
+
+lcbio_PROTOCTX *
+lcbio_protoctx_get(const lcbio_SOCKET *sock, lcbio_PROTOID id)
+{
+    const lcb_list_t *ll;
+    LCB_LIST_FOR(ll, &sock->protos) {
+        lcbio_PROTOCTX *cur = LCB_LIST_ITEM(ll, lcbio_PROTOCTX, ll);
+        if (cur->id == id) {
+            return cur;
+        }
+    }
+    return NULL;
+}
+
+
+#define DEL_BY_ID 1
+#define DEL_BY_PTR 2
+static lcbio_PROTOCTX *
+del_common(lcbio_SOCKET *sock, int mode, lcbio_PROTOID id,
+           lcbio_PROTOCTX *ctx, int dtor)
+{
+    lcb_list_t *ll, *next;
+    LCB_LIST_SAFE_FOR(ll, next, &sock->protos) {
+        lcbio_PROTOCTX *cur = LCB_LIST_ITEM(ll, lcbio_PROTOCTX, ll);
+        if (mode == DEL_BY_ID && cur->id != id) {
+            continue;
+        } else if (cur != ctx) {
+            continue;
+        }
+        lcb_list_delete(&cur->ll);
+        if (dtor) {
+            cur->dtor(cur);
+        }
+        return cur;
+    }
+    return NULL;
+}
+
+lcbio_PROTOCTX *
+lcbio_protoctx_delid(lcbio_SOCKET *s, lcbio_PROTOID id, int dtor)
+{
+    return del_common(s, DEL_BY_ID, id, NULL, dtor);
+}
+
+void
+lcbio_protoctx_delptr(lcbio_SOCKET *s, lcbio_PROTOCTX *ctx, int dtor)
+{
+    del_common(s, DEL_BY_PTR, 0, ctx, dtor);
+}
+
+void
+lcbio__protoctx_delall(lcbio_SOCKET *s)
+{
+    lcb_list_t *llcur, *llnext;
+    LCB_LIST_SAFE_FOR(llcur, llnext, &s->protos) {
+        lcbio_PROTOCTX *cur = LCB_LIST_ITEM(llcur, lcbio_PROTOCTX, ll);
+        lcb_list_delete(llcur);
+        cur->dtor(cur);
+    }
+}

data/ext/libcouchbase/src/lcbio/rw-inl.h

@@ -0,0 +1,137 @@
+/* -*- 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.
+ */
+
+/**
+ * Inline routines for reading and writing socket buffers
+ */
+#include <errno.h>
+#include <limits.h> /* For IOV_MAX */
+#include "ctx-log-inl.h"
+#include "strcodecs/strcodecs.h"
+
+#ifndef INLINE
+#ifdef _MSC_VER
+#define INLINE __inline
+#elif __GNUC__
+#define INLINE __inline__
+#else
+#define INLINE inline
+#endif /* MSC_VER */
+#endif /* !INLINE */
+
+#define RWINL_IOVSIZE 32
+#if defined(IOV_MAX) && IOV_MAX < RWINL_IOVSIZE
+#undef RWINL_IOVSIZE
+#define RWINL_IOVSIZE IOV_MAX
+#endif
+
+#ifndef USE_EAGAIN
+#define C_EAGAIN 0
+#else
+#define C_EAGAIN EAGAIN
+#endif
+
+static INLINE lcbio_IOSTATUS
+lcbio_E_rdb_slurp(lcbio_CTX *ctx, rdb_IOROPE *ior)
+{
+    lcb_ssize_t rv;
+    lcb_IOV iov[RWINL_IOVSIZE];
+    unsigned niov;
+    lcbio_TABLE *iot = ctx->io;
+    const lcb_U32 rdsize = ctx->sock->settings->read_chunk_size;
+    lcb_U32 total_nr = 0;
+
+    do {
+        niov = rdb_rdstart(ior, (nb_IOV *)iov, RWINL_IOVSIZE);
+        GT_READ:
+        rv = IOT_V0IO(iot).recvv(IOT_ARG(iot), CTX_FD(ctx), iov, niov);
+        if (rv > 0) {
+#ifdef LCB_DUMP_PACKETS
+            {
+                char *b64 = NULL;
+                int nb64 = 0;
+                lcb_base64_encode_iov((lcb_IOV *)iov, niov, rv, &b64, &nb64);
+                lcb_log(LOGARGS(ctx, TRACE), CTX_LOGFMT "pkt,rcv: size=%d, %.*s", CTX_LOGID(ctx), nb64, nb64, b64);
+                free(b64);
+            }
+#endif
+            rdb_rdend(ior, rv);
+            if (rdsize && (total_nr += rv) >= rdsize) {
+                return LCBIO_PENDING;
+            }
+        } else if (rv == -1) {
+            switch (IOT_ERRNO(iot)) {
+            case EWOULDBLOCK:
+            case C_EAGAIN:
+                return LCBIO_PENDING;
+            case EINTR:
+                goto GT_READ;
+            default:
+                ctx->sock->last_error = IOT_ERRNO(iot);
+                return LCBIO_IOERR;
+            }
+        } else {
+            return LCBIO_SHUTDOWN;
+        }
+    } while (1);
+    /* UNREACHED */
+    return LCBIO_IOERR;
+}
+
+static INLINE lcbio_IOSTATUS
+lcbio_E_rb_write(lcbio_CTX *ctx, ringbuffer_t *buf)
+{
+    lcb_IOV iov[2] = {0};
+    lcb_ssize_t nw;
+    lcbio_TABLE *iot = ctx->io;
+    while (buf->nbytes) {
+        unsigned niov;
+        ringbuffer_get_iov(buf, RINGBUFFER_READ, iov);
+#if RWINL_IOVSIZE < 2
+        niov = 1;
+#else
+        niov = iov[1].iov_len ? 2 : 1;
+#endif
+        nw = IOT_V0IO(iot).sendv(IOT_ARG(iot), CTX_FD(ctx), iov, niov);
+        if (nw == -1) {
+            switch (IOT_ERRNO(iot)) {
+            case EINTR:
+                break;
+            case EWOULDBLOCK:
+            case C_EAGAIN:
+                return LCBIO_PENDING;
+            default:
+                ctx->sock->last_error = IOT_ERRNO(iot);
+                return LCBIO_IOERR;
+            }
+        }
+        if (nw) {
+#ifdef LCB_DUMP_PACKETS
+            {
+                char *b64 = NULL;
+                int nb64 = 0;
+                lcb_base64_encode_iov((lcb_IOV *)iov, niov, nw, &b64, &nb64);
+                lcb_log(LOGARGS(ctx, TRACE), CTX_LOGFMT "pkt,snd: size=%d, %.*s", CTX_LOGID(ctx), nb64, nb64, b64);
+                free(b64);
+            }
+#endif
+            ringbuffer_consumed(buf, nw);
+            CTX_INCR_METRIC(ctx, bytes_sent, nw);
+        }
+    }
+    return LCBIO_COMPLETED;
+}

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

@@ -0,0 +1,159 @@
+/* -*- 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_SSL_H
+#define LCB_SSL_H
+#include <lcbio/connect.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file
+ * @brief SSL Socket Routines
+ */
+#ifndef LCB_NO_SSL
+#if defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L
+// OpenSSL 1.1 has changed behavior of BIO_get_mem_ptr behavior, so we cannot
+// apply reduce-memory-copy optimization, and fallback to BIO_write
+// Reference: https://github.com/openssl/openssl/commit/9fe9d0461ea
+#define LCB_CAN_OPTIMIZE_SSL_BIO 1
+#else
+#define LCB_CAN_OPTIMIZE_SSL_BIO 0
+#endif
+#endif
+
+/**
+ * @ingroup lcbio
+ * @defgroup lcbio-ssl SSL Routines
+ *
+ * @details
+ * This file contains the higher level API interfacing with _LCBIO_. It provides
+ * APIs to "patch" a socket with SSL as well as establish settings for SSL
+ * encryption.
+ *
+ * @addtogroup lcbio-ssl
+ * @{
+ */
+
+
+/** @brief Wrapper around OpenSSL's `SSL_CTX` */
+typedef struct lcbio_SSLCTX *lcbio_pSSLCTX;
+
+/**
+ * @brief Determine if SSL is supported in the current build
+ * @return true if supported, false otherwise
+ */
+int
+lcbio_ssl_supported(void);
+
+lcbio_pSSLCTX lcbio_ssl_new__fallback(const char *, const char *, const char *, int, lcb_error_t *, lcb_settings *);
+
+#ifndef LCB_NO_SSL
+/**
+ * Create a new SSL context to be used to establish SSL policy.
+ * @param tsfile Path to trusted store file
+ * @param cafile Optional path to CA file
+ * @param keyfile Path to private key file
+ * @param noverify To not attempt to verify server's certificate
+ * @param errp a pointer to contain the error code if initialization failed
+ * @param settings settings structure, used for logging.
+ *
+ * @return A new SSL context, or NULL on error.
+ */
+lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *keyfile, int noverify,
+                            lcb_error_t *errp, lcb_settings *settings);
+#else
+#define lcbio_ssl_new lcbio_ssl_new__fallback
+#endif
+
+
+/**
+ * Free the SSL context. This should be done when libcouchbase has nothing else
+ * to do with the certificate
+ * @param ctx
+ */
+void
+lcbio_ssl_free(lcbio_pSSLCTX ctx);
+
+/**
+ * Apply the SSL settings to a given socket.
+ *
+ * The socket must be newly connected and must not have already been initialized
+ * with SSL (i.e. lcbio_ssl_check() returns false).
+ *
+ * @param sock The socket to which SSL should be applied
+ * @param sctx The context returned by lcbio_ssl_new()
+ * @return
+ */
+lcb_error_t
+lcbio_ssl_apply(lcbio_SOCKET *sock, lcbio_pSSLCTX sctx);
+
+/**
+ * Checks whether the given socket is using SSL
+ * @param sock The socket to check
+ * @return true if using SSL, false if plain (or not yet applied)
+ */
+LCB_INTERNAL_API
+int
+lcbio_ssl_check(lcbio_SOCKET *sock);
+
+/**
+ * Retrieves the internal error code from the SSL object within the socket.
+ * Should only be called if lcbio_ssl_check() is true.
+ *
+ * @param sock
+ * @return An error code (if present), or LCB_SUCCESS if there is no internal
+ * error code.
+ */
+LCB_INTERNAL_API
+lcb_error_t
+lcbio_ssl_get_error(lcbio_SOCKET *sock);
+
+/**
+ * @brief
+ * Initialize any application-level globals needed for SSL support
+ * @todo There is currently nothing checking if this hasn't been called more
+ * than once.
+ */
+void
+lcbio_ssl_global_init(void);
+
+struct lcb_settings_st;
+
+/**
+ * Apply SSL to the socket if the socket should use SSL and is not already
+ * an SSL socket. This is a convenience function that:
+ *
+ * 1. Checks the settings to see if SSL is enabled
+ * 2. Checks to see if the socket already has SSL (lcbio_ssl_check())
+ * 3. Calls lcbio_ssl_apply if (1) and (2) are true.
+ *
+ * @param sock The socket to SSLify
+ * @param settings The settings structure from whence the context and policy are
+ * derived.
+ * @return
+ */
+lcb_error_t
+lcbio_sslify_if_needed(lcbio_SOCKET *sock, struct lcb_settings_st *settings);
+
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+#endif

data/ext/libcouchbase/src/lcbio/timer-cxx.h

@@ -0,0 +1,87 @@
+/*
+ *     Copyright 2016 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_TIMER_CXX
+#define LCBIO_TIMER_CXX
+
+#include <lcbio/timer-ng.h>
+#include <cstdlib>
+
+namespace lcb {
+namespace io {
+
+class SimpleTimer {
+public:
+    typedef void (Callback)(void*);
+    SimpleTimer(lcbio_pTABLE iot, void *data, Callback cb)
+        : inner(lcbio_timer_new(iot, data, cb)) {
+    }
+    ~SimpleTimer() {
+        release();
+    }
+    void release() {
+        if (inner != NULL) {
+            lcbio_timer_destroy(inner);
+            inner = NULL;
+        }
+    }
+    void signal() {
+        lcbio_async_signal(inner);
+    }
+    void cancel() {
+        lcbio_timer_disarm(inner);
+    }
+    bool is_armed() const {
+        return lcbio_timer_armed(inner);
+    }
+    void rearm(uint32_t usec) {
+        lcbio_timer_rearm(inner, usec);
+    }
+    void arm_if_disarmed(uint32_t usec) {
+        if (!is_armed()) {
+            rearm(usec);
+        }
+    }
+    void dump(FILE *fp) const {
+        lcbio_timer_dump(inner, fp);
+    }
+private:
+    lcbio_pTIMER inner;
+    SimpleTimer(const SimpleTimer&);
+};
+
+template <typename T, void (T::*M)(void)>
+class Timer : public SimpleTimer {
+public:
+    Timer(lcbio_pTABLE iot, T* ptr)
+        : SimpleTimer(iot, ptr, cb) {
+    }
+
+    ~Timer() {
+        release();
+    }
+
+private:
+    static void cb(void *arg) {
+        T *obj = reinterpret_cast<T*>(arg);
+        (obj->*M)();
+    }
+    Timer(const Timer&);
+};
+
+}
+}
+#endif