libcouchbase 0.0.1

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

@@ -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.
+ */
+
+#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
+
+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 *);
+} lcbio_TABLE;
+
+/** 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
+
+#ifdef __cplusplus
+}
+#endif
+#endif

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

@@ -0,0 +1,350 @@
+/* -*- 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__, "FIXME: Unknown iops/os error code %d. Using NETWORK_ERROR", 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_INFO, __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 = IOT_V0IO(io).socket0(
+                IOT_ARG(io), (*ai)->ai_family, (*ai)->ai_socktype,
+                (*ai)->ai_protocol);
+
+        if (ret != INVALID_SOCKET) {
+            return ret;
+        } else {
+            *connerr = IOT_ERRNO(io);
+        }
+    }
+
+    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 = IOT_V1(io).socket(
+                IOT_ARG(io), (*ai)->ai_family, (*ai)->ai_socktype,
+                (*ai)->ai_protocol);
+        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_EVENT(iot)) {
+        return IOT_V0IO(iot).is_closed(IOT_ARG(iot), sock->u.fd, flags);
+    } else {
+        return IOT_V1(iot).is_closed(IOT_ARG(iot), sock->u.sd, flags);
+    }
+}
+
+lcb_error_t
+lcbio_disable_nagle(lcbio_SOCKET *s)
+{
+    lcbio_pTABLE iot = s->io;
+    int val = 1, rv;
+    int is_supp = ((IOT_IS_EVENT(iot) && IOT_V0IO(iot).cntl)) ||
+            (!IOT_IS_EVENT(iot) && IOT_V1(iot).cntl);
+
+    if (!is_supp) {
+        return LCB_NOT_SUPPORTED;
+    }
+
+    if (IOT_IS_EVENT(iot)) {
+        rv = IOT_V0IO(iot).cntl(IOT_ARG(iot), s->u.fd, LCB_IO_CNTL_SET,
+            LCB_IO_CNTL_TCP_NODELAY, &val);
+    } else {
+        rv = IOT_V1(iot).cntl(IOT_ARG(iot), s->u.sd, LCB_IO_CNTL_SET,
+            LCB_IO_CNTL_TCP_NODELAY, &val);
+    }
+    if (rv != 0) {
+        return lcbio_mklcberr(IOT_ERRNO(iot), s->settings);
+    } else {
+        return LCB_SUCCESS;
+    }
+}
+
+void
+lcbio_connreq_cancel(lcbio_CONNREQ *req)
+{
+    if (!req->u.cs) {
+        return;
+    }
+
+    if (req->type == LCBIO_CONNREQ_POOLED) {
+        lcbio_mgr_cancel(req->u.preq);
+    } else if (req->type == LCBIO_CONNREQ_RAW) {
+        lcbio_connect_cancel(req->u.cs);
+    } else {
+        req->dtor(req->u.p_generic);
+    }
+
+    req->u.cs = NULL;
+}
+
+int
+lcbio_ssl_supported(void)
+{
+#ifdef LCB_NO_SSL
+    return 0;
+#else
+    return 1;
+#endif
+}
+
+lcbio_pSSLCTX
+lcbio_ssl_new__fallback(const char *ca, int noverify, lcb_error_t *errp,
+    lcb_settings *settings)
+{
+    (void)ca; (void)noverify; (void)settings;
+    if (errp) { *errp = LCB_CLIENT_FEATURE_UNAVAILABLE; }
+    return NULL;
+}
+
+
+#ifdef LCB_NO_SSL
+void lcbio_ssl_free(lcbio_pSSLCTX a) {
+    (void)a;
+}
+lcb_error_t lcbio_ssl_apply(lcbio_SOCKET *a, lcbio_pSSLCTX b) {
+    (void)a;(void)b;
+    return LCB_CLIENT_FEATURE_UNAVAILABLE;
+}
+int lcbio_ssl_check(lcbio_SOCKET *s) {
+    (void)s;
+    return 0;
+}
+lcb_error_t lcbio_ssl_get_error(lcbio_SOCKET *s) {
+    (void)s;
+    return LCB_SUCCESS;
+}
+void lcbio_ssl_global_init(void) {
+}
+lcb_error_t lcbio_sslify_if_needed(lcbio_SOCKET *s, lcb_settings *st) {
+    (void)s;(void)st;
+    return LCB_SUCCESS;
+}
+#endif

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

@@ -0,0 +1,203 @@
+/* -*- 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);
+
+/** Disable Nagle's algorithm on the socket */
+lcb_error_t
+lcbio_disable_nagle(lcbio_SOCKET *s);
+
+void
+lcbio__load_socknames(lcbio_SOCKET *sock);
+
+#ifdef _WIN32
+#define lcbio_syserrno GetLastError()
+#else
+#define lcbio_syserrno errno
+#endif
+
+
+/**
+ * @addtogroup lcbio
+ * @{
+ *
+ * @name Pending Requests
+ * @{
+ *
+ * The lcbio_CONNREQ structure may contain various forms of pending requests
+ * which are _cancellable_. This is useful to act as an abstraction over the
+ * various helper functions which may be employed to initiate a new connection
+ * or negotiate an existing one.
+ *
+ * The semantics of a _cancellable_ request are:
+ *
+ * <ul>
+ * <li>They represent a pending operation</li>
+ * <li>When cancelled, the pending operation is invalidated. This means that
+ * any callbacks scheduled as a result of the operation will not be invoked.
+ * </li>
+ *
+ * <li>If the pending operation has completed, the request is invalidated. This
+ * means the pointer for the request is considered invalid once the operation
+ * has completed
+ * </li>
+ * </ul>
+ */
+
+/**
+ * @brief Container object for various forms of cancellable requests.
+ */
+typedef struct {
+    int type; /**< One of the LCBIO_CONNREQ_* constants */
+    #define LCBIO_CONNREQ_RAW 1
+    #define LCBIO_CONNREQ_POOLED 2
+    #define LCBIO_CONNREQ_GENERIC 3
+    union {
+        struct lcbio_CONNSTART *cs; /**< from lcbio_connect() */
+        struct lcbio_MGRREQ *preq; /**< from lcbio_mgr_get() */
+        void *p_generic; /**< Generic pointer. Destroyed via the dtor field */
+    } u;
+    void (*dtor)(void *);
+} lcbio_CONNREQ;
+
+/** @brief Clear an existing request, setting the pointer to NULL */
+#define LCBIO_CONNREQ_CLEAR(req) (req)->u.p_generic = NULL
+
+/**
+ * @brief Initialize a connreq with an lcbio_pCONNSTART handle
+ * @param req the request to initialize
+ * @param cs the lcbio_pCONNSTART returned by lcbio_connect()
+ */
+#define LCBIO_CONNREQ_MKRAW(req, cs) do { \
+    (req)->u.cs = cs; \
+    (req)->type = LCBIO_CONNREQ_RAW; \
+} while (0);
+
+/**
+ * @brief Initialize a connreq with an lcbio_pMGRREQ
+ * @param req The request to initialize
+ * @param sreq the lcbio_pMGRREQ returned by lcbio_mgr_get()
+ */
+#define LCBIO_CONNREQ_MKPOOLED(req, sreq) do { \
+    (req)->u.preq = sreq; \
+    (req)->type = LCBIO_CONNREQ_POOLED; \
+} while (0);
+
+/**
+ * Initialize a connreq with a generic pointer.
+ * @param req The request to initialize
+ * @param p the pointer representing the request
+ * @param dtorcb a callback invoked with `p` when the request has been cancelled
+ */
+#define LCBIO_CONNREQ_MKGENERIC(req, p, dtorcb) do { \
+    (req)->u.p_generic = p; \
+    (req)->type = LCBIO_CONNREQ_GENERIC; \
+    (req)->dtor = (void (*)(void *))dtorcb; \
+} while (0);
+
+/**
+ * @brief cancels a pending request, if not yet cancelled.
+ *
+ * Cancels a pending request. If the request has already been cancelled (by
+ * calling this function), then this function does nothing
+ * @param req The request to cancel
+ */
+void
+lcbio_connreq_cancel(lcbio_CONNREQ *req);
+
+/**@}*/
+/**@}*/
+
+#ifdef __cplusplus
+}
+#endif
+#endif