libcouchbase 0.0.1

data/ext/libcouchbase/src/connspec.h

@@ -0,0 +1,105 @@
+/* -*- 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_CONNSPEC_H
+#define LCB_CONNSPEC_H
+
+#include <libcouchbase/couchbase.h>
+#include "config.h"
+#include <string>
+#include <vector>
+#include <set>
+
+namespace lcb {
+struct Spechost {
+    Spechost() : port(0), type(0) {}
+    lcb_U16 port;
+    short type;
+    std::string hostname;
+    bool isSSL() const { return type == LCB_CONFIG_MCD_SSL_PORT || type == LCB_CONFIG_HTTP_SSL_PORT; }
+    bool isHTTPS() const { return type == LCB_CONFIG_HTTP_SSL_PORT; }
+    bool isHTTP() const { return type == LCB_CONFIG_HTTP_PORT; }
+    bool isMCD() const { return type == LCB_CONFIG_MCD_PORT; }
+    bool isMCDS() const { return type == LCB_CONFIG_MCD_SSL_PORT; }
+    bool isTypeless() const { return type == 0 ; }
+
+    bool isAnyMcd() const {
+        return isMCD() || isMCDS() || type == LCB_CONFIG_MCCOMPAT_PORT;
+    }
+    bool isAnyHttp() const {
+        return isHTTP() || isHTTPS();
+    }
+};
+
+#define LCB_CONNSPEC_F_FILEONLY (1<<4)
+
+class LCB_CLASS_EXPORT Connspec {
+public:
+    typedef std::vector<std::pair<std::string,std::string> > Options;
+    Connspec() : m_sslopts(0), m_implicit_port(0), m_loglevel(0), m_flags(0) {}
+
+    lcb_error_t parse(const char *connstr, const char **errmsg = NULL);
+    lcb_error_t load(const lcb_create_st&);
+
+    bool has_bsmode(int mode) const {
+        return m_transports.find(mode) != m_transports.end();
+    }
+    bool is_bs_udef() const {
+        return !m_transports.empty() || (m_flags & LCB_CONNSPEC_F_FILEONLY);
+    }
+    bool is_bs_http() const { return has_bsmode(LCB_CONFIG_TRANSPORT_HTTP); }
+    bool is_bs_cccp() const { return has_bsmode(LCB_CONFIG_TRANSPORT_CCCP); }
+    bool is_bs_file() const { return m_flags & LCB_CONNSPEC_F_FILEONLY; }
+    uint16_t default_port() const { return m_implicit_port; }
+    const std::vector<Spechost>& hosts() const { return m_hosts; }
+    const std::string& bucket() const { return m_bucket; }
+    const std::string& username() const { return m_username; }
+    const std::string& password() const { return m_password; }
+    const std::string& certpath() const { return m_certpath; }
+    unsigned sslopts() const { return m_sslopts; }
+    const Options& options() const { return m_ctlopts; }
+    unsigned loglevel() const { return m_loglevel; }
+    const std::string& connstr() const { return m_connstr; }
+private:
+    Options m_ctlopts;
+    std::string m_bucket;
+    std::string m_username;
+    std::string m_password;
+    std::string m_certpath;
+    std::string m_connstr;
+    unsigned m_sslopts; /**< SSL Options */
+    std::vector<Spechost> m_hosts;
+    lcb_U16 m_implicit_port; /**< Implicit port, based on scheme */
+    int m_loglevel; /* cached loglevel */
+
+    inline lcb_error_t parse_options(
+        const char *options, const char *optend, const char **errmsg);
+    inline lcb_error_t parse_hosts(
+        const char *hostbegin, const char *hostend, const char **errmsg);
+
+    std::set<int> m_transports;
+    unsigned m_flags; /**< Internal flags */
+};
+
+#define LCB_SPECSCHEME_RAW "couchbase+explicit://"
+#define LCB_SPECSCHEME_MCD "couchbase://"
+#define LCB_SPECSCHEME_MCD_SSL "couchbases://"
+#define LCB_SPECSCHEME_HTTP "http://"
+#define LCB_SPECSCHEME_HTTP_SSL "https-internal://"
+#define LCB_SPECSCHEME_MCCOMPAT "memcached://"
+} // namespace
+#endif

data/ext/libcouchbase/src/ctx-log-inl.h

@@ -0,0 +1,27 @@
+/* -*- 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.
+ */
+
+/* small utility for retrieving host/port information from the CTX */
+static const char* get__ctx_hostinfo(const lcbio_CTX *ctx, int is_host)
+{
+    if (ctx == NULL || ctx->sock == NULL || ctx->sock->info == NULL) {
+        return is_host ? "NOHOST" : "NOPORT";
+    }
+    return is_host ? ctx->sock->info->ep.host : ctx->sock->info->ep.port;
+}
+static const char *get_ctx_host(const lcbio_CTX *ctx) { return get__ctx_hostinfo(ctx, 1); }
+static const char *get_ctx_port(const lcbio_CTX *ctx) { return get__ctx_hostinfo(ctx, 0); }

data/ext/libcouchbase/src/dump.c

@@ -0,0 +1,98 @@
+/* -*- 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 "internal.h"
+#include "bucketconfig/clconfig.h"
+#include "list.h"
+#include "mc/mcreq.h"
+#include "retryq.h"
+
+LIBCOUCHBASE_API
+void
+lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
+{
+    unsigned ii;
+
+    if (!fp) {
+        fp = stderr;
+    }
+    fprintf(fp, "Dumping state for lcb_t=%p\n", (void*)instance);
+    fprintf(fp, "Settings=%p\n", (void*)instance->settings);
+
+    if (instance->cur_configinfo) {
+        clconfig_info *cfg = instance->cur_configinfo;
+        fprintf(fp, "Current VBC=%p\n", (void*)cfg->vbc);
+        fprintf(fp, "Config RevID=%d\n", cfg->vbc->revid);
+        if (flags & LCB_DUMP_VBCONFIG) {
+            char *cfgdump = lcbvb_save_json(cfg->vbc);
+            fprintf(fp, "=== CLUSTER CONFIG BEGIN ===\n");
+            fprintf(fp, "%s", cfgdump);
+            free(cfgdump);
+            fprintf(fp, "\n");
+            fprintf(fp, "=== CLUSTER CONFIG END ===\n");
+        } else {
+            fprintf(fp, "=== NOT DUMPING CLUSTER CONFIG. LCB_DUMP_VBCONFIG not passed\n");
+        }
+    } else {
+        fprintf(fp, "NO CLUSTER CONFIG\n");
+    }
+    fprintf(fp,"Retry queue has items: %s\n", lcb_retryq_empty(instance->retryq) ? "No" : "Yes");
+    if (flags & LCB_DUMP_PKTINFO) {
+        fprintf(fp, "=== BEGIN RETRY QUEUE DUMP ===\n");
+        lcb_retryq_dump(instance->retryq, fp, NULL);
+        fprintf(fp, "=== END RETRY QUEUE DUMP ===\n");
+    } else {
+        fprintf(fp, "=== NOT DUMPING PACKET INFO. LCB_DUMP_PKTINFO not passed\n");
+    }
+
+    fprintf(fp, "=== BEGIN PIPELINE DUMP ===\n");
+    for (ii = 0; ii < instance->cmdq.npipelines; ii++) {
+        mc_SERVER *server;
+        mc_PIPELINE *pl = instance->cmdq.pipelines[ii];
+
+        server = (mc_SERVER *)pl;
+        fprintf(fp, "** [%u] SERVER %s:%s\n", ii, server->curhost->host, server->curhost->port);
+        if (server->connctx) {
+            fprintf(fp, "** == BEGIN SOCKET INFO\n");
+            lcbio_ctx_dump(server->connctx, fp);
+            fprintf(fp, "** == END SOCKET INFO\n");
+        } else if (server->connreq.u.p_generic) {
+            fprintf(fp, "** == STILL CONNECTING\n");
+        } else {
+            fprintf(fp, "** == NOT CONNECTED\n");
+        }
+        if (flags & LCB_DUMP_BUFINFO) {
+            fprintf(fp, "** == DUMPING NETBUF INFO (For packet network data)\n");
+            netbuf_dump_status(&pl->nbmgr, fp);
+            fprintf(fp, "** == DUMPING NETBUF INFO (For packet structures)\n");
+            netbuf_dump_status(&pl->reqpool, fp);
+        } else {
+            fprintf(fp, "** == NOT DUMPING NETBUF INFO. LCB_DUMP_BUFINFO not passed\n");
+        }
+        if (flags & LCB_DUMP_PKTINFO) {
+            mcreq_dump_chain(pl, fp, NULL);
+        } else {
+            fprintf(fp, "** == NOT DUMPING PACKETS. LCB_DUMP_PKTINFO not passed\n");
+        }
+        fprintf(fp, "\n\n");
+    }
+    fprintf(fp, "=== END PIPELINE DUMP ===\n");
+
+    fprintf(fp, "=== BEGIN CONFMON DUMP ===\n");
+    lcb_confmon_dump(instance->confmon, fp);
+    fprintf(fp, "=== END CONFMON DUMP ===\n");
+}

data/ext/libcouchbase/src/getconfig.c

@@ -0,0 +1,100 @@
+/* -*- 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 "internal.h"
+#include <bucketconfig/clconfig.h>
+LCB_INTERNAL_API
+mc_SERVER *
+lcb_find_server_by_host(lcb_t instance, const lcb_host_t *host)
+{
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    unsigned ii;
+    for (ii = 0; ii < cq->npipelines; ii++) {
+        mc_SERVER *server = (mc_SERVER *)cq->pipelines[ii];
+        if (lcb_host_equals(server->curhost, host)) {
+            return server;
+        }
+    }
+    return NULL;
+}
+
+LCB_INTERNAL_API
+mc_SERVER *
+lcb_find_server_by_index(lcb_t instance, int ix)
+{
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    if (ix < 0 || ix >= (int)cq->npipelines) {
+        return NULL;
+    }
+    return (mc_SERVER *)cq->pipelines[ix];
+}
+
+static void
+ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
+                   const void  *resdata)
+{
+    mc_SERVER *server = (mc_SERVER *)pl;
+    mc_REQDATAEX *rd = req->u_rdata.exdata;
+    const packet_info *res = resdata;
+
+    lcb_cccp_update2(rd->cookie, rc, res->payload, PACKET_NBODY(res),
+                     server->curhost);
+    free(rd);
+}
+
+static mc_REQDATAPROCS procs = { ext_callback_proxy };
+
+LCB_INTERNAL_API
+lcb_error_t
+lcb_getconfig(lcb_t instance, const void *cookie, mc_SERVER *server)
+{
+    lcb_error_t err;
+    mc_CMDQUEUE *cq = &instance->cmdq;
+    mc_PIPELINE *pipeline = (mc_PIPELINE *)server;
+    mc_PACKET *packet;
+    mc_REQDATAEX *rd;
+
+    protocol_binary_request_header hdr;
+    packet = mcreq_allocate_packet(pipeline);
+    if (!packet) {
+        return LCB_CLIENT_ENOMEM;
+    }
+
+    err = mcreq_reserve_header(pipeline, packet, 24);
+    if (err != LCB_SUCCESS) {
+        mcreq_release_packet(pipeline, packet);
+        return err;
+    }
+
+    rd = calloc(1, sizeof(*rd));
+    rd->procs = &procs;
+    rd->cookie = cookie;
+    rd->start = gethrtime();
+    packet->u_rdata.exdata = rd;
+    packet->flags |= MCREQ_F_REQEXT;
+
+    memset(&hdr, 0, sizeof(hdr));
+    hdr.request.opaque = packet->opaque;
+    hdr.request.magic = PROTOCOL_BINARY_REQ;
+    hdr.request.opcode = PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG;
+    memcpy(SPAN_BUFFER(&packet->kh_span), hdr.bytes, sizeof(hdr.bytes));
+
+    mcreq_sched_enter(cq);
+    mcreq_sched_add(pipeline, packet);
+    mcreq_sched_leave(cq, 1);
+    return LCB_SUCCESS;
+}

data/ext/libcouchbase/src/gethrtime.c

@@ -0,0 +1,109 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2011-2012 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 "config.h"
+#include "settings.h"
+#include <libcouchbase/couchbase.h>
+
+#ifndef HAVE_GETHRTIME
+
+#include <stdlib.h>
+#include <time.h>
+#if defined(__MACH__) && defined(__APPLE__)
+#include <mach/mach_time.h>
+#endif
+
+#ifdef __linux__
+#undef HAVE_CLOCK_GETTIME
+#define HAVE_CLOCK_GETTIME 1
+#endif
+
+#define CLOCK_START_OFFSET (LCB_S2NS(3600 * 24))
+
+hrtime_t gethrtime(void)
+{
+#ifdef __APPLE__
+
+    /* Most things expect a pretty large timestamp - even though a smaller one
+     * may be perfectly valid. Initialize the default with an offset of one day,
+     * in nanoseconds
+     */
+
+    /* Use the various mach stuff:
+     * https://developer.apple.com/library/mac/qa/qa1398/_index.html */
+
+    static uint64_t start = 0;
+    uint64_t now ;
+    static mach_timebase_info_data_t tmbi;
+
+    if (start == 0) {
+        start = mach_absolute_time();
+        mach_timebase_info(&tmbi);
+    }
+
+    now = mach_absolute_time();
+    return ((now - start) * tmbi.numer / tmbi.denom) + CLOCK_START_OFFSET;
+
+#elif defined(HAVE_CLOCK_GETTIME)
+    struct timespec tm;
+    lcb_assert(clock_gettime(CLOCK_MONOTONIC, &tm) != -1);
+    return (((hrtime_t)tm.tv_sec) * 1000000000) + (hrtime_t)tm.tv_nsec;
+#elif defined(HAVE_GETTIMEOFDAY)
+
+    hrtime_t ret;
+    struct timeval tv;
+    if (gettimeofday(&tv, NULL) == -1) {
+        return -1;
+    }
+
+    ret = (hrtime_t)tv.tv_sec * 1000000000;
+    ret += (hrtime_t)tv.tv_usec * 1000;
+    return ret;
+#elif defined(HAVE_QUERYPERFORMANCECOUNTER)
+    double ret;
+    // To fix the potential race condition for the local static variable,
+    // gethrtime should be called in a global static variable first.
+    // It will guarantee the local static variable will be initialized
+    // before any thread calls the function.
+    static LARGE_INTEGER pf = { 0 };
+    static double freq;
+    LARGE_INTEGER currtime;
+
+    if (pf.QuadPart == 0) {
+        lcb_assert(QueryPerformanceFrequency(&pf));
+        lcb_assert(pf.QuadPart != 0);
+        freq = 1.0e9 / (double)pf.QuadPart;
+    }
+
+    QueryPerformanceCounter(&currtime);
+
+    ret = (double)currtime.QuadPart * freq ;
+    return (hrtime_t)ret + CLOCK_START_OFFSET;
+#else
+#error "I don't know how to build a highres clock..."
+#endif
+}
+#endif /* HAVE_GETHRTIME */
+
+/* Symbol usable so other subsystems can get the same idea of time the library
+ * has. This will also allow us to stop shipping the 'gethrtime' file around.
+ */
+
+LCB_INTERNAL_API
+lcb_U64 lcb_nstime(void) {
+    return gethrtime();
+}

data/ext/libcouchbase/src/handler.c

@@ -0,0 +1,922 @@
+/* -*- 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 "internal.h"
+#include "packetutils.h"
+#include "mc/mcreq.h"
+#include "mc/compress.h"
+#include "trace.h"
+
+/** Define a compound response structure for use with mutation tokens */
+#define MK_RESPACK(dstname, srcname) \
+    typedef struct { srcname resp; lcb_MUTATION_TOKEN mt; } dstname
+MK_RESPACK(respack_STORE, lcb_RESPSTORE);
+MK_RESPACK(respack_COUNTER, lcb_RESPCOUNTER);
+MK_RESPACK(respack_REMOVE, lcb_RESPREMOVE);
+MK_RESPACK(respack_SUBDOC, lcb_RESPSUBDOC);
+
+LIBCOUCHBASE_API
+lcb_error_t
+lcb_errmap_default(lcb_t instance, lcb_uint16_t in)
+{
+    (void)instance;
+
+    switch (in) {
+    case PROTOCOL_BINARY_RESPONSE_NOT_MY_VBUCKET:
+        return LCB_ETIMEDOUT;
+    case PROTOCOL_BINARY_RESPONSE_AUTH_CONTINUE:
+        return LCB_AUTH_CONTINUE;
+    case PROTOCOL_BINARY_RESPONSE_EBUSY:
+        return LCB_EBUSY;
+    case PROTOCOL_BINARY_RESPONSE_ETMPFAIL:
+        return LCB_ETMPFAIL;
+
+    case PROTOCOL_BINARY_RESPONSE_EINTERNAL:
+    default:
+        fprintf(stderr, "COUCHBASE: Unhandled memcached status=0x%x\n", in);
+        return LCB_UNKNOWN_MEMCACHED_ERROR;
+    }
+}
+
+static lcb_error_t
+map_error(lcb_t instance, int in)
+{
+    (void)instance;
+    switch (in) {
+    case PROTOCOL_BINARY_RESPONSE_SUCCESS:
+        return LCB_SUCCESS;
+    case PROTOCOL_BINARY_RESPONSE_KEY_ENOENT:
+        return LCB_KEY_ENOENT;
+    case PROTOCOL_BINARY_RESPONSE_E2BIG:
+        return LCB_E2BIG;
+    case PROTOCOL_BINARY_RESPONSE_ENOMEM:
+        return LCB_ENOMEM;
+    case PROTOCOL_BINARY_RESPONSE_KEY_EEXISTS:
+        return LCB_KEY_EEXISTS;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_ENOENT:
+        return LCB_SUBDOC_PATH_ENOENT;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_MISMATCH:
+        return LCB_SUBDOC_PATH_MISMATCH;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_EINVAL:
+        return LCB_SUBDOC_PATH_EINVAL;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_E2BIG:
+        return LCB_SUBDOC_PATH_E2BIG;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_DOC_E2DEEP:
+        return LCB_SUBDOC_DOC_E2DEEP;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_VALUE_ETOODEEP:
+        return LCB_SUBDOC_VALUE_E2DEEP;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_VALUE_CANTINSERT:
+        return LCB_SUBDOC_VALUE_CANTINSERT;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_DOC_NOTJSON:
+        return LCB_SUBDOC_DOC_NOTJSON;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_NUM_ERANGE:
+        return LCB_SUBDOC_NUM_ERANGE;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_DELTA_ERANGE:
+        return LCB_SUBDOC_BAD_DELTA;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_PATH_EEXISTS:
+        return LCB_SUBDOC_PATH_EEXISTS;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_MULTI_PATH_FAILURE:
+        return LCB_SUBDOC_MULTI_FAILURE;
+    case PROTOCOL_BINARY_RESPONSE_EINVAL:
+        return LCB_EINVAL_MCD;
+    case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
+        return LCB_NOT_STORED;
+    case PROTOCOL_BINARY_RESPONSE_DELTA_BADVAL:
+        return LCB_DELTA_BADVAL;
+    case PROTOCOL_BINARY_RESPONSE_AUTH_ERROR:
+        return LCB_AUTH_ERROR;
+    case PROTOCOL_BINARY_RESPONSE_ERANGE:
+        return LCB_ERANGE;
+    case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COMMAND:
+        return LCB_UNKNOWN_COMMAND;
+    case PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED:
+        return LCB_NOT_SUPPORTED;
+    default:
+        if (instance != NULL) {
+            return instance->callbacks.errmap(instance, in);
+        } else {
+            return lcb_errmap_default(NULL, in);
+        }
+    }
+}
+
+static lcb_RESPCALLBACK
+find_callback(lcb_t instance, lcb_CALLBACKTYPE type)
+{
+    lcb_RESPCALLBACK cb = instance->callbacks.v3callbacks[type];
+    if (!cb) {
+        cb = lcb_find_callback(instance, type);
+    }
+    return cb;
+}
+
+
+/**
+ * This file contains the mapping of various protocol response codes for
+ * a given command. Each handler receives the following parameters:
+ *
+ * @param pipeline the pipeline (or "Server") upon which the request was sent
+ * (and response was received)
+ *
+ * @param request the original request (including associated data). The request
+ *  may be used to determine additional information about it, such as the
+ *  user-defined "Cookie", number of related requests remaining, and more.
+ *
+ * @param response the response which was received. This is an opaque
+ *  representation of a memcached response packet
+ *
+ * @param immerr in the case of an abnormal failure (i.e. network failure) the
+ *  handler will be invoked with this callback set to a non-success value. The
+ *  'info' structure will still contain a valid (albeit empty and cryptic)
+ *  header. If the user depends on special data being found in the payload then
+ *  the handler must check that this variable is set to LCB_SUCCESS before
+ *  continuing. Also note that a negative reply may also be present within
+ *  the response itself; however this is not the purpose of this parameter.
+ *
+ * @return request status
+ *  The return value should indicate whether outstanding responses remain
+ *  to be received for this request, or if this request is deemed to be
+ *  satisfied.
+ */
+
+#define MK_ERROR(root, resp, response, imm) do { \
+    if (imm) { \
+        (resp)->rc = imm; \
+        (resp)->rflags |= LCB_RESP_F_CLIENTGEN; \
+    } else if (PACKET_STATUS(response) == PROTOCOL_BINARY_RESPONSE_SUCCESS) { \
+        (resp)->rc = LCB_SUCCESS; \
+    } else { \
+        (resp)->rc = map_error(root, PACKET_STATUS(response)); \
+    } \
+}  while (0);
+
+static void
+init_resp3(lcb_t instance, const packet_info *mc_resp, const mc_PACKET *req,
+    lcb_error_t immerr, lcb_RESPBASE *resp)
+{
+    MK_ERROR(instance, resp, mc_resp, immerr);
+    resp->cas = PACKET_CAS(mc_resp);
+    resp->cookie = (void *)MCREQ_PKT_COOKIE(req);
+    mcreq_get_key(req, &resp->key, &resp->nkey);
+}
+
+/**
+ * Handles the propagation and population of the 'mutation token' information.
+ * @param mc_resp The response packet
+ * @param req The request packet (used to get the vBucket)
+ * @param tgt Pointer to mutation token which should be populated.
+ */
+static void
+handle_mutation_token(lcb_t instance, const packet_info *mc_resp,
+    const mc_PACKET *req, lcb_MUTATION_TOKEN *stok)
+{
+    const char *sbuf;
+    uint16_t vbid;
+
+    if (PACKET_EXTLEN(mc_resp) == 0) {
+        return; /* No extras */
+    }
+
+    if (!instance->dcpinfo && LCBT_SETTING(instance, dur_mutation_tokens)) {
+        size_t nvb = LCBT_VBCONFIG(instance)->nvb;
+        if (nvb) {
+            instance->dcpinfo = calloc(nvb, sizeof(*instance->dcpinfo));
+        }
+    }
+
+    sbuf = PACKET_BODY(mc_resp);
+    vbid = mcreq_get_vbucket(req);
+    stok->vbid_ = vbid;
+    memcpy(&stok->uuid_, sbuf, 8);
+    memcpy(&stok->seqno_, sbuf + 8, 8);
+
+    stok->uuid_ = lcb_ntohll(stok->uuid_);
+    stok->seqno_ = lcb_ntohll(stok->seqno_);
+
+    if (instance->dcpinfo) {
+        instance->dcpinfo[vbid] = *stok;
+    }
+}
+
+#define MK_RESPKEY3(resp, req) do { \
+    mcreq_get_key(req, &(resp)->key, &(resp)->nkey); \
+} while (0);
+
+
+static void
+invoke_callback3(const mc_PACKET *pkt,
+    lcb_t instance,lcb_CALLBACKTYPE cbtype, lcb_RESPBASE * resp)
+{
+    if (!(pkt->flags & MCREQ_F_INVOKED)) {
+        resp->cookie = (void *)MCREQ_PKT_COOKIE(pkt);
+        if ((pkt->flags & MCREQ_F_PRIVCALLBACK) == 0) {
+            find_callback(instance, cbtype)(instance, cbtype, resp);
+        } else {
+            (*(lcb_RESPCALLBACK*)resp->cookie)(instance, cbtype, resp);
+        }
+    }
+}
+#define INVOKE_CALLBACK3(req, res_, instance, type) { \
+    invoke_callback3(req, instance, type, (lcb_RESPBASE *)res_); \
+}
+
+/**
+ * Optionally decompress an incoming payload.
+ * @param o The instance
+ * @param resp The response received
+ * @param[out] bytes pointer to the final payload
+ * @param[out] nbytes pointer to the size of the final payload
+ * @param[out] freeptr pointer to free. This should be initialized to `NULL`.
+ * If temporary dynamic storage is required this will be set to the allocated
+ * pointer upon return. Otherwise it will be set to NULL. In any case it must
+ */
+static void
+maybe_decompress(lcb_t o,
+    const packet_info *respkt, lcb_RESPGET *rescmd, void **freeptr)
+{
+    lcb_U8 dtype = 0;
+    if (!PACKET_NVALUE(respkt)) {
+        return;
+    }
+
+    if (PACKET_DATATYPE(respkt) & PROTOCOL_BINARY_DATATYPE_JSON) {
+        dtype = LCB_VALUE_F_JSON;
+    }
+
+    if (PACKET_DATATYPE(respkt) & PROTOCOL_BINARY_DATATYPE_COMPRESSED) {
+        if (LCBT_SETTING(o, compressopts) & LCB_COMPRESS_IN) {
+            /* if we inflate, we don't set the flag */
+            mcreq_inflate_value(
+                PACKET_VALUE(respkt), PACKET_NVALUE(respkt),
+                &rescmd->value, &rescmd->nvalue, freeptr);
+
+        } else {
+            /* user doesn't want inflation. signal it's compressed */
+            dtype |= LCB_VALUE_F_SNAPPYCOMP;
+        }
+    }
+    rescmd->datatype = dtype;
+}
+
+static void
+H_get(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+      lcb_error_t immerr)
+{
+    lcb_t o;
+    lcb_RESPGET resp = { 0 };
+    void *freeptr = NULL;
+
+    o = pipeline->parent->cqdata;
+    init_resp3(o, response, request, immerr, (lcb_RESPBASE *)&resp);
+    resp.rflags |= LCB_RESP_F_FINAL;
+
+    if (resp.rc == LCB_SUCCESS) {
+        const protocol_binary_response_getq *getq =
+                PACKET_EPHEMERAL_START(response);
+        resp.datatype = PACKET_DATATYPE(response);
+        resp.itmflags = ntohl(getq->message.body.flags);
+        resp.value = PACKET_VALUE(response);
+        resp.nvalue = PACKET_NVALUE(response);
+        resp.bufh = response->bufh;
+    }
+
+    maybe_decompress(o, response, &resp, &freeptr);
+    TRACE_GET_END(response, &resp);
+    INVOKE_CALLBACK3(request, &resp, o, LCB_CALLBACK_GET);
+    free(freeptr);
+}
+
+static void
+H_getreplica(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+             lcb_error_t immerr)
+{
+    lcb_RESPGET resp = { 0 };
+    lcb_t instance = pipeline->parent->cqdata;
+    void *freeptr = NULL;
+    mc_REQDATAEX *rd = request->u_rdata.exdata;
+
+    init_resp3(instance, response, request, immerr, (lcb_RESPBASE *)&resp);
+
+    if (resp.rc == LCB_SUCCESS) {
+        const protocol_binary_response_get *get = PACKET_EPHEMERAL_START(response);
+        resp.itmflags = ntohl(get->message.body.flags);
+        resp.datatype = PACKET_DATATYPE(response);
+        resp.value = PACKET_VALUE(response);
+        resp.nvalue = PACKET_NVALUE(response);
+        resp.bufh = response->bufh;
+    }
+
+    maybe_decompress(instance, response, &resp, &freeptr);
+    rd->procs->handler(pipeline, request, resp.rc, &resp);
+    free(freeptr);
+}
+
+static void
+H_subdoc(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+    lcb_error_t immerr)
+{
+    lcb_t o;
+    respack_SUBDOC w = { { 0 } };
+    int cbtype;
+    o = pipeline->parent->cqdata;
+    init_resp3(o, response, request, immerr, (lcb_RESPBASE *)&w.resp);
+    w.resp.rflags |= LCB_RESP_F_FINAL;
+
+    /* For mutations, add the mutation token */
+    switch (PACKET_OPCODE(response)) {
+    case PROTOCOL_BINARY_CMD_SUBDOC_GET:
+    case PROTOCOL_BINARY_CMD_SUBDOC_EXISTS:
+    case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP:
+        cbtype = LCB_CALLBACK_SDLOOKUP;
+        break;
+
+    default:
+        handle_mutation_token(o, response, request, &w.mt);
+        w.resp.rflags |= LCB_RESP_F_EXTDATA;
+        cbtype = LCB_CALLBACK_SDMUTATE;
+        break;
+    }
+
+    if (PACKET_OPCODE(response) == PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP ||
+            PACKET_OPCODE(response) == PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION) {
+        if (w.resp.rc == LCB_SUCCESS || w.resp.rc == LCB_SUBDOC_MULTI_FAILURE) {
+            w.resp.responses = response;
+        }
+    } else {
+        /* Single response */
+        w.resp.rflags |= LCB_RESP_F_SDSINGLE;
+        if (w.resp.rc == LCB_SUCCESS) {
+            w.resp.responses = response;
+        } else if (LCB_EIFSUBDOC(w.resp.rc)) {
+            w.resp.responses = response;
+            w.resp.rc = LCB_SUBDOC_MULTI_FAILURE;
+        }
+    }
+    INVOKE_CALLBACK3(request, &w.resp, o, cbtype);
+}
+
+static int
+sdlookup_next(const packet_info *response, lcb_SDENTRY *ent, size_t *iter)
+{
+    const char *buf;
+    lcb_U16 rc;
+    lcb_U32 vlen;
+
+    if (*iter == PACKET_NVALUE(response)) {
+        return 0;
+    }
+
+    buf = PACKET_VALUE(response);
+    buf += *iter;
+
+    memcpy(&rc, buf, 2);
+    memcpy(&vlen, buf + 2, 4);
+
+    rc = ntohs(rc);
+    vlen = ntohl(vlen);
+
+    ent->status = map_error(NULL, rc);
+    ent->nvalue = vlen;
+
+    if (ent->status == LCB_SUCCESS) {
+        ent->value = buf + 6;
+    } else {
+        ent->value = NULL;
+        ent->nvalue = 0;
+    }
+
+    *iter += (6 + vlen);
+    return 1;
+}
+
+static int
+sdmutate_next(const packet_info *response, lcb_SDENTRY *ent, size_t *iter)
+{
+    const char *buf, *buf_end;
+    lcb_U16 rc;
+    lcb_U32 vlen;
+
+    if (*iter == PACKET_NVALUE(response)) {
+        return 0;
+    }
+
+    buf_end = (const char *)PACKET_VALUE(response) + PACKET_NVALUE(response);
+    buf = ((const char *)(PACKET_VALUE(response))) + *iter;
+
+    #define ADVANCE_BUF(sz) \
+        buf += sz; \
+        *iter += sz; \
+        assert(buf <= buf_end); \
+
+    /* Index */
+    ent->index = *(lcb_U8*)buf;
+    ADVANCE_BUF(1);
+
+    /* Status */
+    memcpy(&rc, buf, 2);
+    ADVANCE_BUF(2);
+
+    rc = ntohs(rc);
+    ent->status = map_error(NULL, rc);
+
+    if (rc == PROTOCOL_BINARY_RESPONSE_SUCCESS) {
+        memcpy(&vlen, buf, 4);
+        ADVANCE_BUF(4);
+
+        vlen = ntohl(vlen);
+        ent->nvalue = vlen;
+        ent->value = buf;
+        ADVANCE_BUF(vlen);
+
+    } else {
+        ent->value = NULL;
+        ent->nvalue = 0;
+    }
+
+    return 1;
+    #undef ADVANCE_BUF
+}
+
+LIBCOUCHBASE_API
+int
+lcb_sdresult_next(const lcb_RESPSUBDOC *resp, lcb_SDENTRY *ent, size_t *iter)
+{
+    size_t iter_s = 0;
+    const packet_info *response = (const packet_info*)resp->responses;
+    if (!response) {
+        return 0;
+    }
+    if (!iter) {
+        /* Single response */
+        iter = &iter_s;
+    }
+
+    switch (PACKET_OPCODE(response)) {
+    case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP:
+        return sdlookup_next(response, ent, iter);
+    case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION:
+        return sdmutate_next(response, ent, iter);
+    default:
+        if (*iter) {
+            return 0;
+        }
+        *iter = 1;
+
+        if (resp->rc == LCB_SUCCESS || resp->rc == LCB_SUBDOC_MULTI_FAILURE) {
+            ent->status = map_error(NULL, PACKET_STATUS(response));
+            ent->value = PACKET_VALUE(response);
+            ent->nvalue = PACKET_NVALUE(response);
+            ent->index = 0;
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+}
+
+static void
+H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, packet_info *response,
+         lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    respack_REMOVE w = { { 0 } };
+    w.resp.rflags |= LCB_RESP_F_EXTDATA | LCB_RESP_F_FINAL;
+    init_resp3(root, response, packet, immerr, (lcb_RESPBASE *)&w.resp);
+    handle_mutation_token(root, response, packet, &w.mt);
+    TRACE_REMOVE_END(response, &w.resp);
+    INVOKE_CALLBACK3(packet, &w.resp, root, LCB_CALLBACK_REMOVE);
+}
+
+static void
+H_observe(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+          lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    uint32_t ttp;
+    uint32_t ttr;
+    lcb_size_t pos;
+    lcbvb_CONFIG* config;
+    const char *end, *ptr;
+    mc_REQDATAEX *rd = request->u_rdata.exdata;
+    lcb_RESPOBSERVE resp = { 0 };
+    MK_ERROR(root, &resp, response, immerr);
+
+    if (resp.rc != LCB_SUCCESS) {
+        if (! (request->flags & MCREQ_F_INVOKED)) {
+            rd->procs->handler(pipeline, request, resp.rc, NULL);
+        }
+        return;
+    }
+
+    /** The CAS field is split into TTP/TTR values */
+    ptr = (char *)&response->res.response.cas;
+    memcpy(&ttp, ptr, sizeof(ttp));
+    memcpy(&ttr, ptr + sizeof(ttp), sizeof(ttp));
+
+    ttp = ntohl(ttp);
+    ttr = ntohl(ttr);
+
+    /** Actual payload sequence of (vb, nkey, key). Repeats multiple times */
+    ptr = response->payload;
+    end = (char *)ptr + PACKET_NBODY(response);
+    config = pipeline->parent->config;
+
+    for (pos = 0; ptr < end; pos++) {
+        lcb_cas_t cas;
+        lcb_uint8_t obs;
+        lcb_uint16_t nkey, vb;
+        const char *key;
+
+        memcpy(&vb, ptr, sizeof(vb));
+        vb = ntohs(vb);
+        ptr += sizeof(vb);
+        memcpy(&nkey, ptr, sizeof(nkey));
+        nkey = ntohs(nkey);
+        ptr += sizeof(nkey);
+        key = (const char *)ptr;
+        ptr += nkey;
+        obs = *((lcb_uint8_t *)ptr);
+        ptr += sizeof(obs);
+        memcpy(&cas, ptr, sizeof(cas));
+        ptr += sizeof(cas);
+
+        resp.key = key;
+        resp.nkey = nkey;
+        resp.cas = lcb_ntohll(cas);
+        resp.status = obs;
+        resp.ismaster = pipeline->index == lcbvb_vbmaster(config, vb);
+        resp.ttp = 0;
+        resp.ttr = 0;
+        TRACE_OBSERVE_PROGRESS(response, &resp);
+        if (! (request->flags & MCREQ_F_INVOKED)) {
+            rd->procs->handler(pipeline, request, resp.rc, &resp);
+        }
+    }
+    TRACE_OBSERVE_END(response);
+}
+
+static void
+H_observe_seqno(mc_PIPELINE *pipeline, mc_PACKET *request,
+    packet_info *response, lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPOBSEQNO resp = { 0 };
+    init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&resp);
+
+    resp.server_index = pipeline->index;
+
+    if (resp.rc == LCB_SUCCESS) {
+        const lcb_U8 *data = PACKET_BODY(response);
+        int is_failover = *data != 0;
+
+        data++;
+        #define COPY_ADV(dstfld, n, conv_fn) \
+                memcpy(&resp.dstfld, data, n); \
+                data += n; \
+                resp.dstfld = conv_fn(resp.dstfld);
+
+        COPY_ADV(vbid, 2, ntohs);
+        COPY_ADV(cur_uuid, 8, lcb_ntohll);
+        COPY_ADV(persisted_seqno, 8, lcb_ntohll);
+        COPY_ADV(mem_seqno, 8, lcb_ntohll);
+        if (is_failover) {
+            COPY_ADV(old_uuid, 8, lcb_ntohll);
+            COPY_ADV(old_seqno, 8, lcb_ntohll);
+        }
+        #undef COPY_ADV
+
+        /* Get the server for this command. Note that since this is a successful
+         * operation, the server is never a dummy */
+    }
+    INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_OBSEQNO);
+}
+
+static void
+H_store(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+        lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    respack_STORE w = { { 0 } };
+    lcb_U8 opcode;
+    init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&w.resp);
+    if (!immerr) {
+        opcode = PACKET_OPCODE(response);
+    } else {
+        protocol_binary_request_header hdr;
+        mcreq_read_hdr(request, &hdr);
+        opcode = hdr.request.opcode;
+    }
+    if (opcode == PROTOCOL_BINARY_CMD_ADD) {
+        w.resp.op = LCB_ADD;
+    } else if (opcode == PROTOCOL_BINARY_CMD_REPLACE) {
+        w.resp.op = LCB_REPLACE;
+    } else if (opcode == PROTOCOL_BINARY_CMD_APPEND) {
+        w.resp.op = LCB_APPEND;
+    } else if (opcode == PROTOCOL_BINARY_CMD_PREPEND) {
+        w.resp.op = LCB_PREPEND;
+    } else if (opcode == PROTOCOL_BINARY_CMD_SET) {
+        w.resp.op = LCB_SET;
+    }
+    w.resp.rflags |= LCB_RESP_F_EXTDATA | LCB_RESP_F_FINAL;
+    handle_mutation_token(root, response, request, &w.mt);
+    TRACE_STORE_END(response, &w.resp);
+    if (request->flags & MCREQ_F_REQEXT) {
+        request->u_rdata.exdata->procs->handler(pipeline, request, immerr, &w.resp);
+    } else {
+        INVOKE_CALLBACK3(request, &w.resp, root, LCB_CALLBACK_STORE);
+    }
+}
+
+static void
+H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+             lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    respack_COUNTER w = { { 0 } };
+    init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&w.resp);
+
+    if (w.resp.rc == LCB_SUCCESS) {
+        memcpy(&w.resp.value, PACKET_VALUE(response), sizeof(w.resp.value));
+        w.resp.value = lcb_ntohll(w.resp.value);
+        w.resp.rflags |= LCB_RESP_F_EXTDATA;
+        handle_mutation_token(root, response, request, &w.mt);
+    }
+    w.resp.rflags |= LCB_RESP_F_FINAL;
+    w.resp.cas = PACKET_CAS(response);
+    TRACE_ARITHMETIC_END(response, &w.resp);
+    INVOKE_CALLBACK3(request, &w.resp, root, LCB_CALLBACK_COUNTER);
+}
+
+static void
+H_stats(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+        lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPSTATS resp = { 0 };
+    mc_REQDATAEX *exdata;
+
+    MK_ERROR(root, &resp, response, immerr);
+    resp.version = 0;
+
+    exdata = request->u_rdata.exdata;
+    if (resp.rc != LCB_SUCCESS || PACKET_NKEY(response) == 0) {
+        /* Call the handler without a response, this indicates that this server
+         * has finished responding */
+        exdata->procs->handler(pipeline, request, resp.rc, NULL);
+        return;
+    }
+
+    if ((resp.nkey = PACKET_NKEY(response))) {
+        resp.key = PACKET_KEY(response);
+        if ((resp.value = PACKET_VALUE(response))) {
+            resp.nvalue = PACKET_NVALUE(response);
+        }
+    }
+
+    exdata->procs->handler(pipeline, request, resp.rc, &resp);
+}
+
+static void
+H_verbosity(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+            lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPBASE dummy = { 0 };
+    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+    MK_ERROR(root, &dummy, response, immerr);
+
+    exdata->procs->handler(pipeline, request, dummy.rc, NULL);
+}
+
+static void
+H_version(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+          lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPMCVERSION resp = { 0 };
+    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+
+    MK_ERROR(root, &resp, response, immerr);
+
+    if (PACKET_NBODY(response)) {
+        resp.mcversion = response->payload;
+        resp.nversion = PACKET_NBODY(response);
+    }
+
+
+    exdata->procs->handler(pipeline, request, resp.rc, &resp);
+}
+
+static void
+H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+        lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPTOUCH resp = { 0 };
+    init_resp3(root, response, request, immerr, &resp);
+    resp.rflags |= LCB_RESP_F_FINAL;
+    TRACE_TOUCH_END(response, &resp);
+    INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_TOUCH);
+}
+
+static void
+H_flush(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+        lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPFLUSH resp = { 0 };
+    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+    MK_ERROR(root, &resp, response, immerr);
+    exdata->procs->handler(pipeline, request, resp.rc, &resp);
+}
+
+static void
+H_unlock(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+         lcb_error_t immerr)
+{
+    lcb_t root = pipeline->parent->cqdata;
+    lcb_RESPUNLOCK resp = { 0 };
+    init_resp3(root, response, request, immerr, &resp);
+    resp.rflags |= LCB_RESP_F_FINAL;
+    TRACE_UNLOCK_END(response, &resp);
+    INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_UNLOCK);
+}
+
+static void
+H_config(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
+         lcb_error_t immerr)
+{
+    /** We just jump to the normal config handler */
+    lcb_RESPBASE dummy;
+    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+    MK_ERROR(pipeline->parent->cqdata, &dummy, response, immerr);
+
+    exdata->procs->handler(pipeline, request, dummy.rc, response);
+}
+
+static void
+record_metrics(mc_PIPELINE *pipeline, mc_PACKET *req, packet_info *res)
+{
+    lcb_t instance = pipeline->parent->cqdata;
+    if (instance->kv_timings) {
+        lcb_histogram_record(instance->kv_timings,
+            gethrtime() - MCREQ_PKT_RDATA(req)->start);
+    }
+    (void)res;
+}
+
+static void
+dispatch_ufwd_error(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t immerr)
+{
+    lcb_PKTFWDRESP resp = { 0 };
+    lcb_t instance = ((mc_SERVER*)pipeline)->instance;
+    assert(immerr != LCB_SUCCESS);
+    resp.version = 0;
+    instance->callbacks.pktfwd(instance, MCREQ_PKT_COOKIE(req), immerr, &resp);
+}
+
+int
+mcreq_dispatch_response(
+        mc_PIPELINE *pipeline, mc_PACKET *req, packet_info *res,
+        lcb_error_t immerr)
+{
+    record_metrics(pipeline, req, res);
+
+    if (req->flags & MCREQ_F_UFWD) {
+        dispatch_ufwd_error(pipeline, req, immerr);
+        return 0;
+    }
+
+
+#define INVOKE_OP(handler) \
+    handler(pipeline, req, res, immerr); \
+    return 0; \
+    break;
+
+    switch (PACKET_OPCODE(res)) {
+    case PROTOCOL_BINARY_CMD_GETQ:
+    case PROTOCOL_BINARY_CMD_GATQ:
+    case PROTOCOL_BINARY_CMD_GET:
+    case PROTOCOL_BINARY_CMD_GAT:
+    case PROTOCOL_BINARY_CMD_GET_LOCKED:
+        INVOKE_OP(H_get);
+
+    case PROTOCOL_BINARY_CMD_ADD:
+    case PROTOCOL_BINARY_CMD_REPLACE:
+    case PROTOCOL_BINARY_CMD_SET:
+    case PROTOCOL_BINARY_CMD_APPEND:
+    case PROTOCOL_BINARY_CMD_PREPEND:
+        INVOKE_OP(H_store);
+
+    case PROTOCOL_BINARY_CMD_INCREMENT:
+    case PROTOCOL_BINARY_CMD_DECREMENT:
+        INVOKE_OP(H_arithmetic);
+
+    case PROTOCOL_BINARY_CMD_SUBDOC_GET:
+    case PROTOCOL_BINARY_CMD_SUBDOC_EXISTS:
+    case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_ADD_UNIQUE:
+    case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_PUSH_FIRST:
+    case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_PUSH_LAST:
+    case PROTOCOL_BINARY_CMD_SUBDOC_ARRAY_INSERT:
+    case PROTOCOL_BINARY_CMD_SUBDOC_DICT_ADD:
+    case PROTOCOL_BINARY_CMD_SUBDOC_DICT_UPSERT:
+    case PROTOCOL_BINARY_CMD_SUBDOC_REPLACE:
+    case PROTOCOL_BINARY_CMD_SUBDOC_DELETE:
+    case PROTOCOL_BINARY_CMD_SUBDOC_COUNTER:
+    case PROTOCOL_BINARY_CMD_SUBDOC_GET_COUNT:
+    case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP:
+    case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION:
+        INVOKE_OP(H_subdoc);
+
+    case PROTOCOL_BINARY_CMD_OBSERVE:
+        INVOKE_OP(H_observe);
+
+    case PROTOCOL_BINARY_CMD_GET_REPLICA:
+        INVOKE_OP(H_getreplica);
+
+    case PROTOCOL_BINARY_CMD_UNLOCK_KEY:
+        INVOKE_OP(H_unlock);
+
+    case PROTOCOL_BINARY_CMD_DELETE:
+        INVOKE_OP(H_delete);
+
+    case PROTOCOL_BINARY_CMD_TOUCH:
+        INVOKE_OP(H_touch);
+
+    case PROTOCOL_BINARY_CMD_OBSERVE_SEQNO:
+        INVOKE_OP(H_observe_seqno);
+
+    case PROTOCOL_BINARY_CMD_STAT:
+        INVOKE_OP(H_stats);
+
+    case PROTOCOL_BINARY_CMD_FLUSH:
+        INVOKE_OP(H_flush);
+
+    case PROTOCOL_BINARY_CMD_VERSION:
+        INVOKE_OP(H_version);
+
+    case PROTOCOL_BINARY_CMD_VERBOSITY:
+        INVOKE_OP(H_verbosity);
+
+#if 0
+    case PROTOCOL_BINARY_CMD_NOOP:
+        INVOKE_OP(H_noop);
+#endif
+
+    case PROTOCOL_BINARY_CMD_GET_CLUSTER_CONFIG:
+        INVOKE_OP(H_config);
+
+    default:
+        fprintf(stderr, "COUCHBASE: Received unknown opcode=0x%x\n", PACKET_OPCODE(res));
+        return -1;
+    }
+}
+
+const lcb_MUTATION_TOKEN *
+lcb_resp_get_mutation_token(int cbtype, const lcb_RESPBASE *rb)
+{
+    const lcb_MUTATION_TOKEN *ss = NULL;
+    if ((rb->rflags & LCB_RESP_F_EXTDATA) == 0) {
+        return NULL;
+    }
+
+    switch (cbtype) {
+    case LCB_CALLBACK_STORE:
+        ss = &((const respack_STORE*)rb)->mt;
+        break;
+
+    case LCB_CALLBACK_COUNTER:
+        ss = &((const respack_COUNTER*)rb)->mt;
+        break;
+
+    case LCB_CALLBACK_REMOVE:
+        ss = &((const respack_REMOVE*)rb)->mt;
+        break;
+
+    case LCB_CALLBACK_SDMUTATE:
+        ss = &((const respack_SUBDOC*)rb)->mt;
+        break;
+
+    default:
+        return NULL;
+    }
+
+    if (ss->uuid_ == 0 && ss->seqno_ == 0) {
+        return NULL;
+    }
+    return ss;
+}