libcouchbase 0.0.1

data/ext/libcouchbase/src/jsparse/parser.h

@@ -0,0 +1,173 @@
+/**
+ *     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_VIEWROW_H_
+#define LCB_VIEWROW_H_
+
+#include <libcouchbase/couchbase.h>
+#include <libcouchbase/views.h>
+#include "contrib/jsonsl/jsonsl.h"
+#include "simplestring.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct lcbvrow_PARSER_st lcbjsp_PARSER;
+
+typedef enum {
+    LCBJSP_MODE_VIEWS,
+    LCBJSP_MODE_N1QL,
+    LCBJSP_MODE_FTS
+} lcbjsp_MODE;
+
+typedef enum {
+    /**This is a row of view data. You can parse this as JSON from your
+     * favorite decoder/converter */
+    LCBJSP_TYPE_ROW,
+
+    /**
+     * All the rows have been returned. In this case, the data is the 'meta'.
+     * This is a valid JSON payload which was returned from the server.
+     * The "rows" : [] array will be empty.
+     */
+    LCBJSP_TYPE_COMPLETE,
+
+    /**
+     * A JSON parse error occured. The payload will contain string data. This
+     * may be JSON (but this is not likely).
+     * The callback will be delivered twice. First when the error is noticed,
+     * and second at the end (instead of a COMPLETE callback)
+     */
+    LCBJSP_TYPE_ERROR
+} lcbjsp_ROWTYPE;
+
+
+typedef struct {
+    lcbjsp_ROWTYPE type; /**< The type of data encapsulated */
+    lcb_IOV docid;
+    lcb_IOV key;
+    lcb_IOV value;
+    lcb_IOV row;
+    lcb_IOV geo;
+} lcbjsp_ROW;
+
+typedef void (*lcbjsp_CALLBACK)(lcbjsp_PARSER*,const lcbjsp_ROW*);
+
+struct lcbvrow_PARSER_st {
+    jsonsl_t jsn; /**< Parser for the row itself */
+    jsonsl_t jsn_rdetails; /**< Parser for the row details */
+    jsonsl_jpr_t jpr; /**< jsonpointer match object */
+    lcb_string meta_buf; /**< String containing the skeleton (outer layer) */
+    lcb_string current_buf; /**< Scratch/read buffer */
+    lcb_string last_hk; /**< Last hashkey */
+
+    lcb_U8 mode;
+
+    /* flags. This should be an int with a bunch of constant flags */
+    lcb_U8 have_error;
+    lcb_U8 initialized;
+    lcb_U8 meta_complete;
+    unsigned rowcount;
+
+    /* absolute position offset corresponding to the first byte in current_buf */
+    size_t min_pos;
+
+    /* minimum (absolute) position to keep */
+    size_t keep_pos;
+
+    /**
+     * size of the metadata header chunk (i.e. everything until the opening
+     * bracket of "rows" [
+     */
+    size_t header_len;
+
+    /**
+     * Position of last row returned. If there are no subsequent rows, this
+     * signals the beginning of the metadata trailer
+     */
+    size_t last_row_endpos;
+
+    void *data;
+
+    /**
+     * std::string to contain parsed document ID.
+     */
+    void *cxx_data;
+
+    /* callback to invoke */
+    lcbjsp_CALLBACK callback;
+};
+
+/**
+ * Creates a new vrow context object.
+ * You must set callbacks on this object if you wish it to be useful.
+ * You must feed it data (calling vrow_feed) as well. The data may be fed
+ * in chunks and callbacks will be invoked as each row is read.
+ */
+lcbjsp_PARSER*
+lcbjsp_create(int);
+
+/**
+ * Resets the context to a pristine state. Callbacks and cookies are kept.
+ * This may be more efficient than allocating/freeing a context each time
+ * (as this can be expensive with the jsonsl structures)
+ */
+void
+lcbjsp_reset(lcbjsp_PARSER *ctx);
+
+/**
+ * Frees a vrow object created by vrow_create
+ */
+void
+lcbjsp_free(lcbjsp_PARSER *ctx);
+
+/**
+ * Feeds data into the vrow. The callback may be invoked multiple times
+ * in this function. In the context of normal lcb usage, this will typically
+ * be invoked from within an http_data_callback.
+ */
+void
+lcbjsp_feed(lcbjsp_PARSER *ctx, const char *data, size_t ndata);
+
+/**
+ * Parse the row buffer into its constituent parts. This should be called
+ * if you want to split the row into its basic 'docid', 'key' and 'value'
+ * fields
+ * @param vp The parser to use
+ * @param vr The row to parse. This assumes the row's "row" field is properly
+ * set.
+ */
+void
+lcbjsp_parse_viewrow(lcbjsp_PARSER *vp, lcbjsp_ROW *vr);
+
+/**
+ * Get the raw contents of the current buffer. This can be used to debug errors.
+ *
+ * Note that the buffer may be partial or malformed or otherwise unsuitable
+ * for structured inspection, but may help human observers debug problems.
+ *
+ * @param v The parser
+ * @param out The iov structure to contain the buffer/offset
+ */
+void
+lcbjsp_get_postmortem(const lcbjsp_PARSER *v, lcb_IOV *out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LCB_VIEWROW_H_ */

data/ext/libcouchbase/src/lcbht/lcbht.c

@@ -0,0 +1,282 @@
+/* -*- 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 "lcbht.h"
+#include "sllist-inl.h"
+#include "contrib/http_parser/http_parser.h"
+#include "settings.h"
+enum last_call_type {
+    CB_NONE,
+    CB_HDR_KEY,
+    CB_HDR_VALUE,
+    CB_HDR_DONE,
+    CB_BODY,
+    CB_MSG_DONE
+};
+
+struct lcbht_PARSER {
+    http_parser parser;
+    lcbht_RESPONSE resp; /**< Current response being processed */
+    lcb_settings *settings;
+    enum last_call_type lastcall;
+
+    /* this stuff for parse_ex() */
+    const char *last_body;
+    unsigned last_bodylen;
+    char paused;
+    char is_ex;
+};
+
+static int
+on_hdr_key(http_parser *pb, const char *s, size_t n)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_MIMEHDR *hdr;
+    lcbht_RESPONSE *resp = &p->resp;
+
+    if (p->lastcall != CB_HDR_KEY) {
+        /* new key */
+        hdr = calloc(1, sizeof *hdr);
+        sllist_append(&resp->headers, &hdr->slnode);
+        lcb_string_init(&hdr->buf_);
+    } else {
+        hdr = SLLIST_ITEM(resp->headers.last, lcbht_MIMEHDR, slnode);
+    }
+
+    /* append key data */
+    lcb_string_append(&hdr->buf_, s, n);
+    p->lastcall = CB_HDR_KEY;
+    return 0;
+}
+
+static int
+on_hdr_value(http_parser *pb, const char *s, size_t n)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_MIMEHDR *hdr;
+    lcbht_RESPONSE *resp = &p->resp;
+
+    hdr = SLLIST_ITEM(resp->headers.last, lcbht_MIMEHDR, slnode);
+    if (p->lastcall == CB_HDR_KEY) {
+        lcb_string_appendz(&hdr->buf_, ":");
+    }
+    lcb_string_append(&hdr->buf_, s, n);
+    p->lastcall = CB_HDR_VALUE;
+    return 0;
+}
+
+static int
+on_hdr_done(http_parser *pb)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_RESPONSE *resp = &p->resp;
+    sllist_iterator iter;
+    resp->state |= LCBHT_S_HTSTATUS|LCBHT_S_HEADER;
+
+    /* extract the status */
+    resp->status = pb->status_code;
+    p->lastcall = CB_HDR_DONE;
+
+    /** Iterate through all the headers and do proper formatting */
+    SLLIST_ITERFOR(&resp->headers, &iter) {
+        char *delim;
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(iter.cur, lcbht_MIMEHDR, slnode);
+
+        delim = strstr(hdr->buf_.base, ":");
+        hdr->key = hdr->buf_.base;
+
+        if (delim) {
+            *delim = '\0';
+            hdr->value = delim + 1;
+        } else {
+            hdr->value = "";
+        }
+    }
+    return 0;
+}
+
+static int
+on_body(http_parser *pb, const char *s, size_t n)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_RESPONSE *resp = &p->resp;
+    if (p->is_ex) {
+        p->last_body = s;
+        p->last_bodylen = n;
+        p->paused = 1;
+        _lcb_http_parser_pause(pb, 1);
+    } else {
+        lcb_string_append(&resp->body, s, n);
+    }
+
+    p->lastcall = CB_BODY;
+    resp->state |= LCBHT_S_BODY;
+    return 0;
+}
+
+static int
+on_msg_done(http_parser *pb)
+{
+    lcbht_pPARSER p = (void *)pb;
+    lcbht_RESPONSE *resp = &p->resp;
+    resp->state |= LCBHT_S_DONE;
+    return 0;
+}
+
+
+static struct http_parser_settings Parser_Settings = {
+        NULL, /* msg_begin */
+        NULL, /* on_url */
+        on_hdr_key,
+        on_hdr_value,
+        on_hdr_done,
+        on_body,
+        on_msg_done
+};
+
+lcbht_pPARSER
+lcbht_new(lcb_settings *settings)
+{
+    lcbht_pPARSER ret = calloc(1, sizeof *ret);
+    lcbht_reset(ret);
+    ret->settings = settings;
+    lcb_settings_ref(settings);
+    return ret;
+}
+
+void
+lcbht_free(lcbht_pPARSER parser)
+{
+    lcbht_clear_response(&parser->resp);
+    lcb_settings_unref(parser->settings);
+    free(parser);
+}
+
+lcbht_RESPSTATE
+lcbht_parse(lcbht_pPARSER parser, const void *data, unsigned ndata)
+{
+    size_t nb;
+    parser->is_ex = 0;
+    nb = _lcb_http_parser_execute(&parser->parser, &Parser_Settings, data, ndata);
+    if (nb != ndata) {
+        parser->resp.state |= LCBHT_S_ERROR;
+    }
+    return parser->resp.state;
+}
+
+lcbht_RESPSTATE
+lcbht_parse_ex(lcbht_pPARSER parser, const void *data, unsigned ndata,
+    unsigned *nused, unsigned *nbody, const char **pbody)
+{
+    size_t nb;
+    parser->is_ex = 1;
+    nb = _lcb_http_parser_execute(&parser->parser, &Parser_Settings, data, ndata);
+    if (nb != ndata) {
+        if (parser->paused) {
+            _lcb_http_parser_pause(&parser->parser, 0);
+            parser->paused = 0;
+        } else {
+            parser->resp.state |= LCBHT_S_ERROR;
+            return parser->resp.state;
+        }
+    }
+
+    *nused = nb;
+    *nbody = parser->last_bodylen;
+    *pbody = parser->last_body;
+
+    parser->last_body = NULL;
+    parser->last_bodylen = 0;
+    return parser->resp.state;
+}
+
+lcbht_RESPONSE *
+lcbht_get_response(lcbht_pPARSER parser)
+{
+    return &parser->resp;
+}
+
+int
+lcbht_can_keepalive(lcbht_pPARSER parser)
+{
+    if (!(parser->resp.state & LCBHT_S_DONE)) {
+        return 0;
+    }
+
+    if (parser->resp.state & LCBHT_S_ERROR) {
+        return 0;
+    }
+
+    return _lcb_http_should_keep_alive(&parser->parser);
+}
+
+void
+lcbht_clear_response(lcbht_RESPONSE *resp)
+{
+    sllist_iterator iter;
+    SLLIST_ITERFOR(&resp->headers, &iter) {
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(iter.cur, lcbht_MIMEHDR, slnode);
+        lcb_string_release(&hdr->buf_);
+        sllist_iter_remove(&resp->headers, &iter);
+        free(hdr);
+    }
+    lcb_string_release(&resp->body);
+    resp->state = 0;
+    resp->status = 0;
+}
+
+void
+lcbht_reset(lcbht_pPARSER parser)
+{
+    lcbht_clear_response(&parser->resp);
+    _lcb_http_parser_init(&parser->parser, HTTP_RESPONSE);
+}
+
+const char *
+lcbht_get_resphdr(const lcbht_RESPONSE *resp, const char *key)
+{
+    sllist_node *curnode;
+    SLLIST_ITERBASIC(&resp->headers, curnode) {
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(curnode, lcbht_MIMEHDR, slnode);
+        if (!strcmp(hdr->key, key)) {
+            return hdr->value;
+        }
+    }
+    return NULL;
+}
+
+char **
+lcbht_make_resphdrlist(lcbht_RESPONSE *response)
+{
+    char **ret;
+    unsigned nhdrs = 0;
+    unsigned curix = 0;
+    sllist_node *curnode;
+    SLLIST_ITERBASIC(&response->headers, curnode) {
+        nhdrs++;
+    }
+    ret = malloc(sizeof(*ret) * (nhdrs + 1) * 2);
+
+    SLLIST_ITERBASIC(&response->headers, curnode) {
+        lcbht_MIMEHDR *hdr = SLLIST_ITEM(curnode, lcbht_MIMEHDR, slnode);
+        ret[curix++] = strdup(hdr->key);
+        ret[curix++] = strdup(hdr->value);
+    }
+
+    ret[curix] = NULL;
+    return ret;
+}