libcouchbase 1.0.4 → 1.1.0

data/ext/libcouchbase/src/bootstrap.cc

@@ -53,7 +53,7 @@ void Bootstrap::config_callback(EventType event, ConfigInfo *info) {
 
     tm.cancel();
 
-    lcb_log(LOGARGS(instance, DEBUG), "Instance configured!");
+    lcb_log(LOGARGS(instance, DEBUG), "Instance configured");
 
     if (info->get_origin() != CLCONFIG_FILE) {
         /* Set the timestamp for the current config to control throttling,
@@ -88,14 +88,28 @@ void Bootstrap::config_callback(EventType event, ConfigInfo *info) {
         state = S_BOOTSTRAPPED;
         lcb_aspend_del(&instance->pendops, LCB_PENDTYPE_COUNTER, NULL);
 
-        if (instance->type == LCB_TYPE_BUCKET &&
-                LCBVB_DISTTYPE(LCBT_VBCONFIG(instance)) == LCBVB_DIST_KETAMA &&
+        if (instance->type == LCB_TYPE_BUCKET) {
+            if (LCBVB_DISTTYPE(LCBT_VBCONFIG(instance)) == LCBVB_DIST_KETAMA &&
                 instance->cur_configinfo->get_origin() != CLCONFIG_MCRAW) {
+                lcb_log(LOGARGS(instance, INFO), "Reverting to HTTP Config for memcached buckets");
+                instance->settings->bc_http_stream_time = -1;
+                instance->confmon->set_active(CLCONFIG_HTTP, true);
+                instance->confmon->set_active(CLCONFIG_CCCP, false);
+            }
 
-            lcb_log(LOGARGS(instance, INFO), "Reverting to HTTP Config for memcached buckets");
-            instance->settings->bc_http_stream_time = -1;
-            instance->confmon->set_active(CLCONFIG_HTTP, true);
-            instance->confmon->set_active(CLCONFIG_CCCP, false);
+            /* infer bucket type using distribution and capabilities set */
+            switch (LCBVB_DISTTYPE(LCBT_VBCONFIG(instance))) {
+            case LCBVB_DIST_VBUCKET:
+                if (LCBVB_CAPS(LCBT_VBCONFIG(instance)) & LCBVB_CAP_COUCHAPI) {
+                    instance->btype = LCB_BTYPE_COUCHBASE;
+                } else {
+                    instance->btype = LCB_BTYPE_EPHEMERAL;
+                }
+                break;
+            case LCBVB_DIST_KETAMA:
+                instance->btype = LCB_BTYPE_MEMCACHED;
+                break;
+            }
         }
         instance->callbacks.bootstrap(instance, LCB_SUCCESS);
 
@@ -127,7 +141,7 @@ void Bootstrap::check_bgpoll() {
 
 void Bootstrap::bgpoll() {
     lcb_log(LOGARGS(parent, TRACE), "Background-polling for new configuration");
-    bootstrap(BS_REFRESH_THROTTLE);
+    bootstrap(BS_REFRESH_ALWAYS);
     check_bgpoll();
 }
 

data/ext/libcouchbase/src/bucketconfig/bc_cccp.cc

@@ -140,7 +140,7 @@ CccpProvider::schedule_next_request(lcb_error_t err, bool can_rollover)
     lcb::Server* server = instance->find_server(*next_host);
     if (server) {
         cmdcookie = new CccpCookie(this);
-        lcb_log(LOGARGS(this, INFO), "Re-Issuing CCCP Command on server struct %p (%s:%s)", (void*)server, next_host->host, next_host->port);
+        lcb_log(LOGARGS(this, DEBUG), "Re-Issuing CCCP Command on server struct %p (%s:%s)", (void*)server, next_host->host, next_host->port);
         timer.rearm(settings().config_node_timeout);
         instance->request_config(cmdcookie, server);
 

data/ext/libcouchbase/src/bucketconfig/bc_http.cc

@@ -128,7 +128,6 @@ process_chunk(HttpProvider *http, const void *buf, unsigned nbuf)
                 /* reissue the request; but wait for it to drain */
                 lcb_log(LOGARGS(http, WARN), LOGFMT "Got 404 on config stream. Assuming terse URI not supported on cluster", LOGID(http));
                 http->try_nexturi = 1;
-                err = LCB_SUCCESS;
                 goto GT_CHECKDONE;
             }
         } else if (resp.status == 401) {

data/ext/libcouchbase/src/bucketconfig/confmon.cc

@@ -147,7 +147,7 @@ int Confmon::do_set_next(ConfigInfo *new_config, bool notify_miss)
             ca = config->vbc;
             cb = new_config->vbc;
 
-            lcb_log(LOGARGS(this, INFO), "Not applying configuration received via %s. No changes detected. A.rev=%d, B.rev=%d", provider_string(new_config->get_origin()), ca->revid, cb->revid);
+            lcb_log(LOGARGS(this, DEBUG), "Not applying configuration received via %s. No changes detected. A.rev=%d, B.rev=%d", provider_string(new_config->get_origin()), ca->revid, cb->revid);
             if (notify_miss) {
                 invoke_listeners(CLCONFIG_EVENT_GOT_ANY_CONFIG, new_config);
             }
@@ -198,6 +198,9 @@ void Confmon::provider_failed(Provider *provider, lcb_error_t reason) {
         } else {
             last_error = reason;
         }
+        if (reason == LCB_AUTH_ERROR) {
+            goto GT_ERROR;
+        }
     }
 
     if (settings->conntype == LCB_TYPE_CLUSTER && provider->type == CLCONFIG_HTTP) {
@@ -211,13 +214,7 @@ void Confmon::provider_failed(Provider *provider, lcb_error_t reason) {
     }
 
     cur_provider = next_active(cur_provider);
-
-    if (!cur_provider) {
-        LOG(this, TRACE, "Maximum provider reached. Resetting index");
-        invoke_listeners(CLCONFIG_EVENT_PROVIDERS_CYCLED, NULL);
-        cur_provider = first_active();
-        stop();
-    } else {
+    if (cur_provider) {
         uint32_t interval = 0;
         if (config) {
             /* Not first */
@@ -226,7 +223,15 @@ void Confmon::provider_failed(Provider *provider, lcb_error_t reason) {
         lcb_log(LOGARGS(this, DEBUG), "Will try next provider in %uus", interval);
         state |= CONFMON_S_ITERGRACE;
         as_start.rearm(interval);
+        return;
+    } else {
+        LOG(this, TRACE, "Maximum provider reached. Resetting index");
     }
+
+GT_ERROR:
+    invoke_listeners(CLCONFIG_EVENT_PROVIDERS_CYCLED, NULL);
+    cur_provider = first_active();
+    stop();
 }
 
 void Confmon::provider_got_config(Provider *, ConfigInfo *config_) {

data/ext/libcouchbase/src/callbacks.c

@@ -354,6 +354,8 @@ lcb_strcbtype(int cbtype)
         return "SDMUTATE";
     case LCB_CALLBACK_SDLOOKUP:
         return "SDLOOKUP";
+    case LCB_CALLBACK_NOOP:
+        return "NOOP";
     default:
         return "UNKNOWN";
     }

data/ext/libcouchbase/src/cntl.cc

@@ -1,6 +1,6 @@
 /* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2010-2012 Couchbase, Inc.
+ *     Copyright 2010-2017 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -21,6 +21,8 @@
 #include <mcserver/negotiate.h>
 #include <lcbio/ssl.h>
 
+#define LOGARGS(instance, lvl) instance->settings, "cntl", LCB_LOG_##lvl, __FILE__, __LINE__
+
 #define CNTL__MODE_SETSTRING 0x1000
 
 /* Basic definition/declaration for handlers */
@@ -157,6 +159,9 @@ HANDLER(compmode_handler) {
 HANDLER(bucketname_handler) {
     RETURN_GET_ONLY(const char*, LCBT_SETTING(instance, bucket))
 }
+HANDLER(buckettype_handler) {
+    RETURN_GET_ONLY(lcb_BTYPE, static_cast<lcb_BTYPE>(instance->btype))
+}
 HANDLER(schedflush_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, sched_implicit_flush))
 }
@@ -197,6 +202,11 @@ HANDLER(send_hello_handler) {
     RETURN_GET_SET(int, LCBT_SETTING(instance, send_hello));
 }
 HANDLER(config_poll_interval_handler) {
+    lcb_U32 *user = reinterpret_cast<lcb_U32*>(arg);
+    if (mode == LCB_CNTL_SET && *user > 0 && *user < LCB_CONFIG_POLL_INTERVAL_FLOOR) {
+        lcb_log(LOGARGS(instance, ERROR), "Interval for background poll is too low: %dus (min: %dus)", *user, LCB_CONFIG_POLL_INTERVAL_FLOOR);
+        return LCB_ECTL_BADARG;
+    }
     lcb_error_t rv = timeout_common(mode, instance, cmd, arg);
     if (rv == LCB_SUCCESS &&
             (mode == LCB_CNTL_SET || CNTL__MODE_SETSTRING) &&
@@ -614,7 +624,8 @@ static ctl_handler handlers[] = {
     select_bucket_handler, /* LCB_CNTL_SELECT_BUCKET */
     tcp_keepalive_handler, /* LCB_CNTL_TCP_KEEPALIVE */
     config_poll_interval_handler, /* LCB_CNTL_CONFIG_POLL_INTERVAL */
-    send_hello_handler /* LCB_CNTL_SEND_HELLO */
+    send_hello_handler, /* LCB_CNTL_SEND_HELLO */
+    buckettype_handler /* LCB_CNTL_BUCKETTYPE */
 };
 
 /* Union used for conversion to/from string functions */
@@ -638,7 +649,7 @@ typedef struct {
     ctl_str_cb converter;
 } cntl_OPCODESTRS;
 
-static lcb_error_t convert_timeout(const char *arg, u_STRCONVERT *u) {
+static lcb_error_t convert_timevalue(const char *arg, u_STRCONVERT *u) {
     int rv;
     unsigned long tmp;
 
@@ -673,7 +684,7 @@ static lcb_error_t convert_int(const char *arg, u_STRCONVERT *u) {
 }
 
 static lcb_error_t convert_u32(const char *arg, u_STRCONVERT *u) {
-    return convert_timeout(arg, u);
+    return convert_timevalue(arg, u);
 }
 static lcb_error_t convert_float(const char *arg, u_STRCONVERT *u) {
     double d;
@@ -729,19 +740,19 @@ static lcb_error_t convert_retrymode(const char *arg, u_STRCONVERT *u) {
 }
 
 static cntl_OPCODESTRS stropcode_map[] = {
-        {"operation_timeout", LCB_CNTL_OP_TIMEOUT, convert_timeout},
-        {"timeout", LCB_CNTL_OP_TIMEOUT, convert_timeout},
-        {"views_timeout", LCB_CNTL_VIEW_TIMEOUT, convert_timeout},
-        {"n1ql_timeout", LCB_CNTL_N1QL_TIMEOUT, convert_timeout},
-        {"durability_timeout", LCB_CNTL_DURABILITY_TIMEOUT, convert_timeout},
-        {"durability_interval", LCB_CNTL_DURABILITY_INTERVAL, convert_timeout},
-        {"http_timeout", LCB_CNTL_HTTP_TIMEOUT, convert_timeout},
+        {"operation_timeout", LCB_CNTL_OP_TIMEOUT, convert_timevalue},
+        {"timeout", LCB_CNTL_OP_TIMEOUT, convert_timevalue},
+        {"views_timeout", LCB_CNTL_VIEW_TIMEOUT, convert_timevalue},
+        {"n1ql_timeout", LCB_CNTL_N1QL_TIMEOUT, convert_timevalue},
+        {"durability_timeout", LCB_CNTL_DURABILITY_TIMEOUT, convert_timevalue},
+        {"durability_interval", LCB_CNTL_DURABILITY_INTERVAL, convert_timevalue},
+        {"http_timeout", LCB_CNTL_HTTP_TIMEOUT, convert_timevalue},
         {"randomize_nodes", LCB_CNTL_RANDOMIZE_BOOTSTRAP_HOSTS, convert_intbool},
         {"sasl_mech_force", LCB_CNTL_FORCE_SASL_MECH, convert_passthru},
         {"error_thresh_count", LCB_CNTL_CONFERRTHRESH, convert_SIZE},
-        {"error_thresh_delay", LCB_CNTL_CONFDELAY_THRESH, convert_timeout},
-        {"config_total_timeout", LCB_CNTL_CONFIGURATION_TIMEOUT, convert_timeout},
-        {"config_node_timeout", LCB_CNTL_CONFIG_NODE_TIMEOUT, convert_timeout},
+        {"error_thresh_delay", LCB_CNTL_CONFDELAY_THRESH, convert_timevalue},
+        {"config_total_timeout", LCB_CNTL_CONFIGURATION_TIMEOUT, convert_timevalue},
+        {"config_node_timeout", LCB_CNTL_CONFIG_NODE_TIMEOUT, convert_timevalue},
         {"compression", LCB_CNTL_COMPRESSION_OPTS, convert_compression},
         {"console_log_level", LCB_CNTL_CONLOGGER_LEVEL, convert_u32},
         {"config_cache", LCB_CNTL_CONFIGCACHE, convert_passthru },
@@ -752,7 +763,7 @@ static cntl_OPCODESTRS stropcode_map[] = {
         {"sync_dtor", LCB_CNTL_SYNCDESTROY, convert_intbool },
         {"_reinit_connstr", LCB_CNTL_REINIT_CONNSTR },
         {"retry_backoff", LCB_CNTL_RETRY_BACKOFF, convert_float },
-        {"retry_interval", LCB_CNTL_RETRY_INTERVAL, convert_timeout},
+        {"retry_interval", LCB_CNTL_RETRY_INTERVAL, convert_timevalue},
         {"http_poolsize", LCB_CNTL_HTTP_POOLSIZE, convert_SIZE },
         {"vbguess_persist", LCB_CNTL_VBGUESS_PERSIST, convert_intbool },
         {"unsafe_optimize", LCB_CNTL_UNSAFE_OPTIMIZE, convert_intbool },
@@ -763,13 +774,13 @@ static cntl_OPCODESTRS stropcode_map[] = {
         {"readj_ts_wait", LCB_CNTL_RESET_TIMEOUT_ON_WAIT, convert_intbool },
         {"console_log_file", LCB_CNTL_CONLOGGER_FP, NULL },
         {"client_string", LCB_CNTL_CLIENT_STRING, convert_passthru},
-        {"retry_nmv_delay", LCB_CNTL_RETRY_NMV_INTERVAL, convert_timeout},
+        {"retry_nmv_delay", LCB_CNTL_RETRY_NMV_INTERVAL, convert_timevalue},
         {"bucket_cred", LCB_CNTL_BUCKET_CRED, NULL},
         {"read_chunk_size", LCB_CNTL_READ_CHUNKSIZE, convert_u32},
         {"enable_errmap", LCB_CNTL_ENABLE_ERRMAP, convert_intbool},
         {"select_bucket", LCB_CNTL_SELECT_BUCKET, convert_intbool},
         {"tcp_keepalive", LCB_CNTL_TCP_KEEPALIVE, convert_intbool},
-        {"config_poll_interval", LCB_CNTL_CONFIG_POLL_INTERVAL, convert_timeout},
+        {"config_poll_interval", LCB_CNTL_CONFIG_POLL_INTERVAL, convert_timevalue},
         {"send_hello", LCB_CNTL_SEND_HELLO, convert_intbool},
         {NULL, -1}
 };

data/ext/libcouchbase/src/dns-srv.cc

@@ -10,14 +10,13 @@
 
 #ifdef HAVE_ARPA_NAMESER_H
 #include <arpa/nameser.h>
-#if __NAMESER < 19991006
+#if defined(__NAMESER) && __NAMESER < 19991006
 #undef HAVE_RES_SEARCH
 #endif /* __NAMESER < NNN */
 #endif /* HAVE_ARPA_NAMESER_H */
 
 #if defined(HAVE_ARPA_NAMESER_H) && defined(HAVE_RES_SEARCH)
 #define CAN_SRV_LOOKUP
-#include <cstdio>
 #include <sys/types.h>
 #include <netinet/in.h>
 #include <resolv.h>

data/ext/libcouchbase/src/dump.cc

@@ -31,7 +31,11 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
         fp = stderr;
     }
     fprintf(fp, "Dumping state for lcb_t=%p\n", (void*)instance);
+    if (instance == NULL) {
+        return;
+    }
     fprintf(fp, "Settings=%p\n", (void*)instance->settings);
+    fprintf(fp, "BucketType=%d\n", instance->btype);
 
     if (instance->cur_configinfo) {
         lcb::clconfig::ConfigInfo *cfg = instance->cur_configinfo;

data/ext/libcouchbase/src/errmap.h

@@ -14,22 +14,95 @@ namespace errmap {
 
 enum ErrorAttribute {
 #define LCB_XERRMAP_ATTRIBUTES(X) \
-    X(TEMPORARY, "temp") \
-    X(SUBDOC, "subdoc") \
-    X(RETRY_NOW, "retry-now") \
-    X(RETRY_LATER, "retry-later") \
-    X(INVALID_INPUT, "invalid-input") \
-    X(NOT_ENABLED, "support") \
-    X(AUTH, "auth") \
-    X(CONN_STATE_INVALIDATED, "conn-state-invalidated") \
-    X(CONSTRAINT_FAILURE, "item-only") \
-    X(RETRY_EXP_BACKOFF, "retry-exp-backoff") \
-    X(RETRY_LINEAR_BACKOFF, "retry-linear-backoff") \
-    X(INTERNAL, "internal") \
-    X(DCP, "dcp") \
-    X(FETCH_CONFIG, "fetch-config") \
-    X(SPECIAL_HANDLING, "special-handling") \
-    X(AUTO_RETRY, "auto-retry")
+    /**                                                                 \
+     * This error is transient. Note that this does not mean the        \
+     * error is retriable.                                              \
+     */                                                                 \
+    X(TEMPORARY, "temp")                                                \
+    /**                                                                 \
+     * The error is related to the subdocument subsystem.               \
+     */                                                                 \
+    X(SUBDOC, "subdoc")                                                 \
+    /**                                                                 \
+     * The operation may be retried immediately.                        \
+     */                                                                 \
+    X(RETRY_NOW, "retry-now")                                           \
+    /**                                                                 \
+     * The operation may be retried after some time.                    \
+     */                                                                 \
+    X(RETRY_LATER, "retry-later")                                       \
+    /**                                                                 \
+     * This attribute means that a user's input was invalid because it  \
+     * violates the semantics of the operation, or exceeds some         \
+     * predefined limit.                                                \
+     */                                                                 \
+    X(INVALID_INPUT, "invalid-input")                                   \
+    /**                                                                 \
+     * The operation is not supported, possibly because the of server   \
+     * version, bucket type, or  current user.                          \
+     */                                                                 \
+    X(NOT_ENABLED, "support")                                           \
+    /**                                                                 \
+     * The operation failed because the client failed to authenticate   \
+     * or is not authorized to perform this operation. Note that this   \
+     * error in itself does not mean the connection is invalid, unless  \
+     * conn-state-invalidated is also present.                          \
+     */                                                                 \
+    X(AUTH, "auth")                                                     \
+    /**                                                                 \
+     * The current connection is no longer valid. The client must       \
+     * reconnect to the server. Note that the presence of other         \
+     * attributes may indicate an alternate remedy to fixing the        \
+     * connection without a disconnect, but without special remedial    \
+     * action a disconnect is needed.                                   \
+     */                                                                 \
+    X(CONN_STATE_INVALIDATED, "conn-state-invalidated")                 \
+    /**                                                                 \
+     * This attribute means that the error is related to a constraint   \
+     * failure regarding the item itself, i.e. the item does not exist, \
+     * already exists, or its current value makes the current operation \
+     * impossible. Retrying the operation when the item's value or      \
+     * status has changed may succeed.                                  \
+     */                                                                 \
+    X(CONSTRAINT_FAILURE, "item-only")                                  \
+    /**                                                                 \
+     *  This is an internal error in the server.                        \
+     */                                                                 \
+    X(INTERNAL, "internal")                                             \
+    /**                                                                 \
+     * The error is related to the DCP subsystem.                       \
+     */                                                                 \
+    X(DCP, "dcp")                                                       \
+    /**                                                                 \
+     * The client's cluster map may be outdated and requires updating.  \
+     * The client should obtain a newer configuration.                  \
+     */                                                                 \
+    X(FETCH_CONFIG, "fetch-config")                                     \
+    /**                                                                 \
+     * This error code must be handled specially. If it is not handled, \
+     * the connection must be dropped.                                  \
+     */                                                                 \
+    X(SPECIAL_HANDLING, "special-handling")                             \
+    /**                                                                 \
+     * Use retry specifications from the server                         \
+     */                                                                 \
+    X(AUTO_RETRY, "auto-retry")                                         \
+    /**                                                                 \
+     * The operation was successful for those situations                \
+     * where the error code is indicating successful (i.e. subdoc       \
+     * operations carried out on a deleted document)                    \
+     */                                                                 \
+    X(SUCCESS, "success")                                               \
+    /**                                                                 \
+     * This attribute specifies that the requested item is currently    \
+     * locked.                                                          \
+     */                                                                 \
+    X(ITEM_LOCKED, "item-locked")                                       \
+    /**                                                                 \
+     * This attribute means that the error is related to operating on   \
+     * a soft-deleted document.                                         \
+     */                                                                 \
+    X(ITEM_DELETED, "item-deleted")                                     \
 
     #define X(c, s) c,
     LCB_XERRMAP_ATTRIBUTES(X)

data/ext/libcouchbase/src/handler.cc

@@ -437,6 +437,8 @@ H_subdoc(mc_PIPELINE *pipeline, mc_PACKET *request,
             response->opcode() == PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION) {
         if (w.resp.rc == LCB_SUCCESS || w.resp.rc == LCB_SUBDOC_MULTI_FAILURE) {
             w.resp.responses = response;
+        } else {
+            handle_error_info(response, &w);
         }
     } else {
         /* Single response */
@@ -446,6 +448,8 @@ H_subdoc(mc_PIPELINE *pipeline, mc_PACKET *request,
         } else if (LCB_EIFSUBDOC(w.resp.rc)) {
             w.resp.responses = response;
             w.resp.rc = LCB_SUBDOC_MULTI_FAILURE;
+        } else {
+            handle_error_info(response, &w);
         }
     }
     invoke_callback(request, o, &w.resp, cbtype);
@@ -808,6 +812,19 @@ H_version(mc_PIPELINE *pipeline, mc_PACKET *request,
     exdata->procs->handler(pipeline, request, resp.rc, &resp);
 }
 
+static void
+H_noop(mc_PIPELINE *pipeline, mc_PACKET *request,
+       MemcachedResponse *response, lcb_error_t immerr)
+{
+    lcb_t root = get_instance(pipeline);
+    lcb_RESPNOOP resp = { 0 };
+    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+
+    make_error(root, &resp, response, immerr);
+
+    exdata->procs->handler(pipeline, request, resp.rc, &resp);
+}
+
 static void
 H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
         lcb_error_t immerr)
@@ -852,7 +869,7 @@ H_config(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
          lcb_error_t immerr)
 {
     /** We just jump to the normal config handler */
-    lcb_RESPBASE dummy;
+    lcb_RESPBASE dummy = {0};
     mc_REQDATAEX *exdata = request->u_rdata.exdata;
     make_error(get_instance(pipeline), &dummy, response, immerr);
 
@@ -960,10 +977,8 @@ mcreq_dispatch_response(
     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);
@@ -1010,12 +1025,14 @@ lcb_resp_get_mutation_token(int cbtype, const lcb_RESPBASE *rb)
 }
 
 #define ERRINFO_CALLBACKS(X)                    \
-    X(GET)                                      \
-    X(STORE)                                    \
-    X(COUNTER)                                  \
-    X(TOUCH)                                    \
-    X(REMOVE)                                   \
-    X(UNLOCK)                                   \
+    X(LCB_CALLBACK_GET, lcb_RESPGET)            \
+    X(LCB_CALLBACK_STORE, lcb_RESPSTORE)        \
+    X(LCB_CALLBACK_COUNTER, lcb_RESPCOUNTER)    \
+    X(LCB_CALLBACK_TOUCH, lcb_RESPTOUCH)        \
+    X(LCB_CALLBACK_REMOVE, lcb_RESPREMOVE)      \
+    X(LCB_CALLBACK_UNLOCK, lcb_RESPUNLOCK)      \
+    X(LCB_CALLBACK_SDLOOKUP, lcb_RESPSUBDOC)    \
+    X(LCB_CALLBACK_SDMUTATE, lcb_RESPSUBDOC)    \
 
 
 LIBCOUCHBASE_API
@@ -1026,7 +1043,7 @@ lcb_resp_get_error_context(int cbtype, const lcb_RESPBASE *rb)
         return NULL;
     }
 
-#define X(NAME) if (cbtype == LCB_CALLBACK_##NAME) { return ResponsePack<lcb_RESP##NAME>::get_err_ctx(rb); }
+#define X(CBTYPE, RESP) if (cbtype == CBTYPE) { return ResponsePack<RESP>::get_err_ctx(rb); }
     ERRINFO_CALLBACKS(X);
 #undef X
     return NULL;
@@ -1040,7 +1057,7 @@ lcb_resp_get_error_ref(int cbtype, const lcb_RESPBASE *rb)
         return NULL;
     }
 
-#define X(NAME) if (cbtype == LCB_CALLBACK_##NAME) { return ResponsePack<lcb_RESP##NAME>::get_err_ref(rb); }
+#define X(CBTYPE, RESP) if (cbtype == CBTYPE) { return ResponsePack<RESP>::get_err_ref(rb); }
     ERRINFO_CALLBACKS(X);
 #undef X
     return NULL;