libcouchbase 0.0.1

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

@@ -0,0 +1,156 @@
+/* -*- 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 "contrib/genhash/genhash.h"
+#include "list.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
+extern "C" {
+#endif
+
+/** Cancellable pool request */
+struct lcbio_MGRREQ;
+
+/** @brief Socket Pool */
+typedef struct lcbio_MGR {
+    genhash_t* ht;
+    lcb_settings *settings;
+    lcbio_pTABLE io;
+
+    /**
+     * Maximum number of microseconds for a connection to idle inside the pool
+     * before being closed
+     */
+    uint32_t tmoidle;
+    unsigned maxtotal;
+    unsigned maxidle; /**< Maximum number of idle connections, per host */
+    unsigned refcount;
+} lcbio_MGR;
+
+/**
+ * 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.
+ */
+LCB_INTERNAL_API
+lcbio_MGR*
+lcbio_mgr_create(lcb_settings *settings, lcbio_pTABLE io);
+
+/**
+ * Destroy the socket pool. Note that internally this just decrements the
+ * reference count. The object is only destroyed when its count hits zero.
+ */
+LCB_INTERNAL_API
+void
+lcbio_mgr_destroy(lcbio_MGR *);
+
+/**
+ * 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 mgr
+ * @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()
+ */
+LCB_INTERNAL_API
+struct lcbio_MGRREQ *
+lcbio_mgr_get(lcbio_MGR *mgr, lcb_host_t *dest, uint32_t timeout,
+              lcbio_CONNDONE_cb handler, void *arg);
+
+/**
+ * Cancel a pending request. The callback for the request must have not already
+ * been invoked (if it has, use sockpool_put)
+ * @param req the request to cancel
+ */
+LCB_INTERNAL_API
+void
+lcbio_mgr_cancel(struct lcbio_MGRREQ *req);
+
+/**
+ * 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.
+ */
+LCB_INTERNAL_API
+void lcbio_mgr_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
+ */
+LCB_INTERNAL_API
+void lcbio_mgr_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)`;
+ */
+LCB_INTERNAL_API
+void lcbio_mgr_detach(lcbio_SOCKET *sock);
+
+/**
+ * Dumps the connection manager state to stderr
+ */
+LCB_INTERNAL_API
+void lcbio_mgr_dump(lcbio_MGR *mgr, FILE *out);
+
+#ifdef __cplusplus
+}
+#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(lcbio_SOCKET *sock, lcbio_PROTOID id)
+{
+    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,115 @@
+/* -*- 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 */
+#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) {
+            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];
+    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) {
+            ringbuffer_consumed(buf, nw);
+        }
+    }
+    return LCBIO_COMPLETED;
+}

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

@@ -0,0 +1,149 @@
+/* -*- 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
+ */
+
+/**
+ * @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 *, int, lcb_error_t *, lcb_settings *);
+
+#ifndef LCB_NO_SSL
+/**
+ * Create a new SSL context to be used to establish SSL policy.
+ * @param cafile Optional path to CA 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 *cafile, 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