libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/src/simplestring.h

@@ -0,0 +1,228 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2013 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_STRING_H
+#define LCB_STRING_H
+
+#include <libcouchbase/couchbase.h>
+#include <stdarg.h>
+
+#include "config.h"
+#include "assert.h"
+#include "ringbuffer.h"
+
+/**
+ * Simple string type.
+ *
+ * This structure is designed mainly for ease of use when dealing with actual
+ * "string" data - i.e. data which must be null-terminated and contiguous.
+ *
+ * This won't replace the ringbuffer structure as this string's removal and
+ * copying operations are comparatively expensive.
+ *
+ * Note that all API functions which update the position of the buffer ALSO
+ * add a trailing NUL byte at the end.
+ */
+typedef struct lcb_string_st {
+    /** Buffer that's allocated */
+    char *base;
+
+    /** Number of bytes allocated */
+    lcb_size_t nalloc;
+
+    /** Number of bytes used */
+    lcb_size_t nused;
+#ifdef __cplusplus
+    typedef char *iterator;
+    typedef const char *const_iterator;
+
+    iterator begin() { return base; };
+    iterator end() { return base + nused; }
+    const_iterator begin() const { return base; }
+    const_iterator end() const { return base + nused; }
+    size_t size() const { return nused; }
+    size_t capacity() const { return nalloc; }
+    const char *c_str() const { return base; }
+
+    inline void insert(iterator p, const char *first, const char *last);
+#endif
+} lcb_string;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int lcb_string_init(lcb_string *str);
+
+/**
+ * Free any storage associated with the string. The string's state will be
+ * empty as if string_init() had just been called.
+ */
+void lcb_string_release(lcb_string *str);
+
+/**
+ * Clear the contents of the string, but don't free the underlying buffer
+ */
+void lcb_string_clear(lcb_string *str);
+
+
+/**
+ * Indicate that bytes have been added to the string. This is used in conjunction
+ * with reserve(). As such, the number of bytes added should not exceed the
+ * number of bytes passed to reserver.
+ *
+ * @param str the string
+ * @param nbytes the number of bytes added
+ */
+void lcb_string_added(lcb_string *str, lcb_size_t nbytes);
+
+/**
+ * Reserve an amount of free bytes within the string. When this is done,
+ * up to @c size bytes may be added to the string starting at @c base+str->nbytes
+ */
+int lcb_string_reserve(lcb_string *str, lcb_size_t size);
+
+
+/**
+ * Adds data to the string.
+ * @param str the string to append to
+ * @param data the data to copy
+ * @param size the size of data to copy
+ */
+int lcb_string_append(lcb_string *str, const void *data, lcb_size_t size);
+
+/**
+ * Adds a C-style string
+ * @param str the target lcb_string
+ * @param zstr a NUL-terminated string to add
+ */
+int lcb_string_appendz(lcb_string *str, const char *zstr);
+
+
+/**
+ * Appends a list of pointer-length pairs. Useful if you need to concatenate
+ * many small buffers
+ * @param str The string to append to. This should be followed by a list of
+ * `pointer, size` arguments (where `size` is `size_t`). If the length is
+ * `-1` then `strlen(pointer)` will be called to determine the length.
+ *
+ * A terminal `NULL` should be placed at the end of the argument list
+ *
+ * @return 0 if appended, nonzero on memory error
+ */
+int lcb_string_appendv(lcb_string *str, ...);
+
+/**
+ * Adds a string from a ringbuffer structure. This copies the contents
+ * of the ringbuffer into a string.
+ * @param str the target string
+ * @param rb the source ringbuffer
+ * @param rbadvance whether to advance the ringbuffer's read head
+ */
+int lcb_string_rbappend(lcb_string *str, ringbuffer_t *rb, int rbadvance);
+
+/**
+ * Removes bytes from the end of the string. The resultant string will be
+ * NUL-terminated
+ * @param str the string to operate on
+ * @param to_remove the number of bytes to trim from the end
+ */
+void lcb_string_erase_end(lcb_string *str, lcb_size_t to_remove);
+
+
+/**
+ * Removes bytes from the beginning of the string. The resultant string will
+ * be NUL-terminated.
+ * @param str the string to operate on
+ * @param to_remove the number of bytes to remove from the beginning of
+ * the string.
+ */
+void lcb_string_erase_beginning(lcb_string *str, lcb_size_t to_remove);
+
+/**
+ * Transfers ownership of the underlying buffer contained within the structure
+ * 'to' to the structure 'from', as such, 'from' becomes a newly initialized
+ * empty string structure and 'to' contains the existing buffer.
+ *
+ * @param from the string which contains the existing buffer
+ * @param to a new string structure which contains no buffer. It will receive
+ * from's buffer
+ */
+void lcb_string_transfer(lcb_string *from, lcb_string *to);
+
+/**
+ * Inserts a string at a given position
+ * @param str the string object
+ * @param at position at which to insert
+ * @param src the string to insert
+ * @param len length of string to insert
+ */
+int lcb_string_insert(lcb_string *str, size_t at, const char *src, size_t len);
+
+#define lcb_string_tail(str) ((str)->base + (str)->nused)
+
+#ifdef __cplusplus
+}
+
+#include <stdexcept>
+#include <new>
+void
+lcb_string_st::insert(iterator p, const char *first, const char *last) {
+    size_t at = p - base;
+    size_t n = last - first;
+    if (lcb_string_insert(this, at, first, n) != 0) {
+        throw std::bad_alloc();
+    }
+}
+
+namespace lcb {
+class AutoString : public lcb_string_st {
+public:
+    AutoString() {
+        lcb_string_init(this);
+    }
+    ~AutoString() {
+        lcb_string_release(this);
+    }
+
+    char *take(size_t& len, size_t& cap) {
+        char *ret = base;
+        len = nused;
+        cap = nalloc;
+
+        base = NULL;
+        nalloc = 0;
+        nused = 0;
+        return ret;
+    }
+    char *take(size_t& len) {
+        size_t dummy;
+        return take(len, dummy);
+    }
+    char *take() {
+        size_t dummy;
+        return take(dummy, dummy);
+    }
+
+private:
+    AutoString(lcb_string_st&);
+    AutoString(const lcb_string_st&);
+};
+}
+
+#endif /** __cplusplus */
+#endif /* LCB_STRING_H */

data/ext/libcouchbase/src/ssl/ssl_c.c

@@ -137,7 +137,6 @@ async_write(void *arg)
 {
     lcbio_CSSL *cs = arg;
     appdata_encode(cs);
-    schedule_wants(cs);
     appdata_free_flushed(cs);
 }
 

data/ext/libcouchbase/src/ssl/ssl_common.c

@@ -156,9 +156,7 @@ iotssl_log_errors(lcbio_XSSL *xs)
         if (ERR_GET_LIB(curerr) == ERR_LIB_SSL) {
             switch (ERR_GET_REASON(curerr)) {
             case SSL_R_CERTIFICATE_VERIFY_FAILED:
-#ifdef SSL_R_MISSING_VERIFY_MESSAGE
             case SSL_R_MISSING_VERIFY_MESSAGE:
-#endif
                 xs->errcode = LCB_SSL_CANTVERIFY;
                 break;
 

data/ext/libcouchbase/src/ssl/ssl_e.c

@@ -16,6 +16,7 @@
  */
 
 #include "ssl_iot_common.h"
+#include "simplestring.h"
 #include <openssl/err.h>
 /**
  * Event-Style SSL Wrapping.

data/ext/libcouchbase/src/ssobuf.h

@@ -0,0 +1,82 @@
+/*
+ *     Copyright 2015 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.
+ */
+
+/**
+ * Implementation of dynamic arrays or strings suitable for one or more than
+ * one element. If only a single element is used, extra memory is not allocated
+ * via malloc.
+ */
+
+#include "simplestring.h"
+
+#define LCB_SSOBUF_DECLARE(T) \
+    struct { \
+        unsigned count; \
+        union { \
+            lcb_string alloc; \
+            T single; \
+        } u;\
+    } \
+
+#define LCB_SSOBUF_ALLOC(p, o, T) do { \
+    if ((o)->count == 0) { /* Only allocate a single element */ \
+        *(p) = &(o)->u.single; \
+        (o)->count++; \
+    } else if ((o)->count == 1) { /* Switch over to malloc */ \
+        T ssobuf__tmp = (o)->u.single; \
+        (o)->u.alloc.nused = 0; \
+        (o)->u.alloc.nalloc = 0; \
+        (o)->u.alloc.base = NULL; \
+        if (-1 == lcb_string_reserve(&(o)->u.alloc, sizeof(T) * 2)) { \
+            *(p) = NULL; \
+        } else { \
+            memcpy((o)->u.alloc.base, &ssobuf__tmp, sizeof(T)); \
+            lcb_string_added(&(o)->u.alloc, sizeof(T)); \
+            *(p) = (T*) ((o)->u.alloc.base + (o)->u.alloc.nused); \
+            lcb_string_added(&(o)->u.alloc, sizeof(T)); \
+        } \
+        (o)->count++; \
+    } else if (-1 == lcb_string_reserve(&(o)->u.alloc, sizeof(T))) { \
+        *(p) = NULL; \
+    } else { \
+        *(p) = (T*) ((o)->u.alloc.base + (o)->u.alloc.nused); \
+        lcb_string_added(&(o)->u.alloc, sizeof(T)); \
+        (o)->count++; \
+    } \
+} while (0);
+
+#define LCB_SSOBUF_ALLOC_N(p, o, T, n) do { \
+    if (n == 1) { \
+        LCB_SSOBUF_ALLOC(p, o, T); \
+    } else if (n > 1) { \
+        if (-1 == lcb_string_reserve(&(o)->u.alloc, sizeof(T) * (n) )) { \
+            *(p) = NULL; \
+        } else { \
+            lcb_string_added(&(o)->u.alloc, sizeof(T) * (n) ); \
+            *(p) = (T*)(o)->u.alloc.base; \
+            (o)->count = n; \
+        } \
+    } \
+} while (0);
+
+#define LCB_SSOBUF_CLEAN(o) do { \
+    if ((o)->count > 1) { \
+        lcb_string_release(&(o)->u.alloc); \
+    } \
+} while (0);
+
+#define LCB_SSOBUF_ARRAY(o, t) \
+    ((o)->count > 1 ? ((t*)(o)->u.alloc.base) : &(o)->u.single)

data/ext/libcouchbase/src/trace.h

@@ -40,11 +40,11 @@
 
 #define TRACE_BEGIN_COMMON(TGT, req, cmd,  ...) \
     TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-    (const char *)((cmd)->key.contig.bytes), (cmd)->key.contig.nbytes, ## __VA_ARGS__)
+    (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes, ## __VA_ARGS__)
 
 #define TRACE_BEGIN_SIMPLE(TGT, req, cmd) \
     TGT((req)->request.opaque, ntohs((req)->request.vbucket), (req)->request.opcode, \
-        (const char *)(cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
+        (cmd)->key.contig.bytes, (cmd)->key.contig.nbytes)
 
 #define TRACE_END_COMMON(TGT, mcresp, resp, ...) \
     TGT(mcresp->opaque(), 0, mcresp->opcode(), (resp)->rc, (const char *)(resp)->key, (resp)->nkey, \
@@ -58,7 +58,7 @@
 
 #define TRACE_GET_END(mcresp, resp) \
     TRACE(TRACE_END_COMMON(LIBCOUCHBASE_GET_END, mcresp, resp, \
-        (const char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
+        (char*)(resp)->value, (resp)->nvalue, (resp)->itmflags, (resp)->cas, \
         mcresp->datatype()))
 
 #define TRACE_UNLOCK_BEGIN(req, cmd) TRACE(TRACE_BEGIN_SIMPLE(LIBCOUCHBASE_UNLOCK_BEGIN, req, cmd))
@@ -66,7 +66,7 @@
 
 #define TRACE_STORE_BEGIN(req, cmd) \
     TRACE(TRACE_BEGIN_COMMON(LIBCOUCHBASE_STORE_BEGIN, req, cmd, \
-        (const char *)( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
+        ( (cmd)->value.vtype == LCB_KV_IOV ? NULL : (cmd)->value.u_buf.contig.bytes ),\
         ( (cmd)->value.vtype == LCB_KV_IOV ? 0 : (cmd)->value.u_buf.contig.nbytes ),\
         (cmd)->flags, (cmd)->cas, (req)->request.datatype, (cmd)->exptime))
 

data/ext/libcouchbase/src/vbucket/vbucket.c

@@ -26,6 +26,7 @@
 #include "json-inl.h"
 #include "hash.h"
 #include "crc32.h"
+#include "simplestring.h"
 
 #define STRINGIFY_(X) #X
 #define STRINGIFY(X) STRINGIFY_(X)

data/ext/libcouchbase/src/views/{docreq.cc → docreq.c}

@@ -2,53 +2,56 @@
 #include "internal.h"
 #include "sllist-inl.h"
 
-using namespace lcb::docreq;
-
 static void docreq_handler(void *arg);
-static void invoke_pending(Queue*);
+static void invoke_pending(lcb_DOCQUEUE*);
 static void doc_callback(lcb_t,int, const lcb_RESPBASE *);
 
 #define MAX_PENDING_DOCREQ 10
 #define MIN_SCHED_SIZE 5
 #define DOCQ_DELAY_US 200000
 
-Queue::Queue(lcb_t instance_)
-    : instance(instance_),
-      parent(NULL),
-      timer(lcbio_timer_new(instance->iotable, this, docreq_handler)),
-      cb_ready(NULL), cb_throttle(NULL),
-      n_awaiting_schedule(0),
-      n_awaiting_response(0),
-      max_pending_response(MAX_PENDING_DOCREQ),
-      min_batch_size(MIN_SCHED_SIZE),
-      cancelled(false),
-      refcount(1)
-      {
-
-    memset(&pending_gets, 0, sizeof pending_gets);
-    memset(&cb_queue, 0, sizeof cb_queue);
+#define DOCQ_REF(q) (q)->refcount++
+#define DOCQ_UNREF(q) if (!--(q)->refcount) { docq_free(q); }
+
+lcb_DOCQUEUE *
+lcbdocq_create(lcb_t instance)
+{
+    lcb_DOCQUEUE *q = calloc(1, sizeof *q);
+    q->timer = lcbio_timer_new(instance->iotable, q, docreq_handler);
+    q->refcount = 1;
+    q->instance = instance;
+    q->max_pending_response = MAX_PENDING_DOCREQ;
+    q->min_batch_size = MIN_SCHED_SIZE;
+    return q;
 }
 
-Queue::~Queue() {
-    cancel();
-    lcbio_timer_destroy(timer);
+static void
+docq_free(lcb_DOCQUEUE *q)
+{
+    lcbdocq_cancel(q);
+    lcbio_timer_destroy(q->timer);
+    free(q);
 }
 
-void Queue::unref() {
-    if (!--refcount) {
-        delete this;
-    }
+void
+lcbdocq_unref(lcb_DOCQUEUE *q)
+{
+    DOCQ_UNREF(q);
 }
 
-void Queue::cancel() {
-    cancelled = true;
+void
+lcbdocq_cancel(lcb_DOCQUEUE *q)
+{
+    if (!q->cancelled) {
+        q->cancelled = 1;
+    }
 }
 
 /* Calling this function ensures that the request will be scheduled in due
  * time. This may be done at the next event loop iteration, or after a delay
  * depending on how many items are actually found within the queue. */
 static void
-docq_poke(Queue *q)
+docq_poke(lcb_DOCQUEUE *q)
 {
     if (q->n_awaiting_response < q->max_pending_response) {
         if (q->n_awaiting_schedule > q->min_batch_size) {
@@ -62,26 +65,27 @@ docq_poke(Queue *q)
     }
 }
 
-void Queue::add(DocRequest *req)
+void
+lcbdocq_add(lcb_DOCQUEUE *q, lcb_DOCQREQ *req)
 {
-    sllist_append(&pending_gets, &req->slnode);
-    n_awaiting_schedule++;
-    req->parent = this;
+    sllist_append(&q->pending_gets, &req->slnode);
+    q->n_awaiting_schedule++;
+    req->parent = q;
     req->ready = 0;
-    ref();
-    docq_poke(this);
+    DOCQ_REF(q);
+    docq_poke(q);
 }
 
 static void
 docreq_handler(void *arg)
 {
-    Queue *q = reinterpret_cast<Queue*>(arg);
+    lcb_DOCQUEUE *q = arg;
     sllist_iterator iter;
     lcb_t instance = q->instance;
 
     lcb_sched_enter(instance);
     SLLIST_ITERFOR(&q->pending_gets, &iter) {
-        DocRequest *cont = SLLIST_ITEM(iter.cur, DocRequest, slnode);
+        lcb_DOCQREQ *cont = SLLIST_ITEM(iter.cur, lcb_DOCQREQ, slnode);
 
         if (q->n_awaiting_response > q->max_pending_response) {
             lcbio_timer_rearm(q->timer, DOCQ_DELAY_US);
@@ -132,12 +136,13 @@ docreq_handler(void *arg)
 /* Invokes the callback on all requests which are ready, until a request which
  * is not yet ready is reached. */
 static void
-invoke_pending(Queue *q)
+invoke_pending(lcb_DOCQUEUE *q)
 {
     sllist_iterator iter = { NULL };
-    q->ref();
+
+    DOCQ_REF(q);
     SLLIST_ITERFOR(&q->cb_queue, &iter) {
-        DocRequest *dreq = SLLIST_ITEM(iter.cur, DocRequest, slnode);
+        lcb_DOCQREQ *dreq = SLLIST_ITEM(iter.cur, lcb_DOCQREQ, slnode);
         void *bufh = NULL;
 
         if (dreq->ready == 0) {
@@ -152,21 +157,21 @@ invoke_pending(Queue *q)
 
         q->cb_ready(q, dreq);
         if (bufh) {
-            lcb_backbuf_unref(reinterpret_cast<lcb_BACKBUF>(bufh));
+            lcb_backbuf_unref(bufh);
         }
-        q->unref();
+        DOCQ_UNREF(q);
     }
-    q->unref();
+    DOCQ_UNREF(q);
 }
 
 static void
-doc_callback(lcb_t, int, const lcb_RESPBASE *rb)
+doc_callback(lcb_t instance, int cbtype, const lcb_RESPBASE *rb)
 {
     const lcb_RESPGET *rg = (const lcb_RESPGET *)rb;
-    DocRequest *dreq = reinterpret_cast<DocRequest*>(rb->cookie);
-    Queue *q = dreq->parent;
+    lcb_DOCQREQ *dreq = rb->cookie;
+    lcb_DOCQUEUE *q = dreq->parent;
 
-    q->ref();
+    DOCQ_REF(q);
 
     q->n_awaiting_response--;
     dreq->docresp = *rg;
@@ -177,12 +182,13 @@ doc_callback(lcb_t, int, const lcb_RESPBASE *rb)
     /* Reference the response data, since we might not be invoking this right
      * away */
     if (rg->rc == LCB_SUCCESS) {
-        lcb_backbuf_ref(reinterpret_cast<lcb_BACKBUF>(dreq->docresp.bufh));
+        lcb_backbuf_ref(dreq->docresp.bufh);
     }
 
     /* Ensure the invoke_pending doesn't destroy us */
     invoke_pending(q);
     docq_poke(q);
 
-    q->unref();
+    DOCQ_UNREF(q);
+    (void)instance; (void)cbtype;
 }