libcouchbase 0.3.3 → 1.0.0

data/ext/libcouchbase/src/http/http.cc

@@ -19,6 +19,7 @@
 #include "bucketconfig/clconfig.h"
 #include "http/http.h"
 #include "http/http-priv.h"
+#include "auth-priv.h"
 using namespace lcb::http;
 
 #define LOGFMT "<%s:%s> "
@@ -43,7 +44,7 @@ Request::decref()
     close_io();
 
     if (parser) {
-        lcbht_free(parser);
+        delete parser;
     }
 
     if (timer) {
@@ -103,7 +104,6 @@ void
 Request::maybe_refresh_config(lcb_error_t err)
 {
     int htstatus_ok;
-    lcbht_RESPONSE *resp;
     if (!parser) {
         return;
     }
@@ -112,25 +112,25 @@ Request::maybe_refresh_config(lcb_error_t err)
         return;
     }
 
-    resp = lcbht_get_response(parser);
-    htstatus_ok = resp->status >= 200 && resp->status < 299;
+    const lcb::htparse::Response& resp = parser->get_cur_response();
+    htstatus_ok = resp.status >= 200 && resp.status < 299;
 
     if (err != LCB_SUCCESS && (err == LCB_ESOCKSHUTDOWN && htstatus_ok) == 0) {
         /* ignore graceful close */
-        lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
+        instance->bootstrap(BS_REFRESH_ALWAYS);
         return;
     }
 
     if (htstatus_ok) {
         return;
     }
-    lcb_bootstrap_common(instance, LCB_BS_REFRESH_ALWAYS);
+    instance->bootstrap(BS_REFRESH_ALWAYS);
 }
 
 void
 Request::init_resp(lcb_RESPHTTP *res)
 {
-    const lcbht_RESPONSE *htres = lcbht_get_response(parser);
+    const lcb::htparse::Response& htres = parser->get_cur_response();
 
     res->cookie = const_cast<void*>(command_cookie);
     res->key = url.c_str() + url_info.field_data[UF_PATH].off;
@@ -139,9 +139,7 @@ Request::init_resp(lcb_RESPHTTP *res)
     if (!response_headers.empty()) {
         res->headers = &response_headers_clist[0];
     }
-    if (htres) {
-        res->htstatus = htres->status;
-    }
+    res->htstatus = htres.status;
 }
 
 void
@@ -254,9 +252,9 @@ Request::submit()
         // Only wipe old parser/response information if current I/O request
         // was a success
         if (parser) {
-            lcbht_reset(parser);
+            parser->reset();
         } else {
-            parser = lcbht_new(instance->settings);
+            parser = new lcb::htparse::Parser(instance->settings);
         }
         response_headers.clear();
         response_headers_clist.clear();
@@ -408,6 +406,10 @@ Request::get_api_node(lcb_error_t &rc)
     return lcbvb_get_resturl(vbc, ix, svc, mode);
 }
 
+static bool is_nonempty(const char *s) {
+    return s != NULL && *s != '\0';
+}
+
 lcb_error_t
 Request::setup_inputs(const lcb_CMDHTTP *cmd)
 {
@@ -433,11 +435,13 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         if (cmd->cmdflags & LCB_CMDHTTP_F_NOUPASS) {
             username = password = NULL;
         } else if (username == NULL && password == NULL) {
+            const Authenticator& auth = *LCBT_SETTING(instance, auth);
             if (reqtype == LCB_HTTP_TYPE_MANAGEMENT) {
-                lcbauth_get_upass(LCBT_SETTING(instance, auth), &username, &password);
+                username = auth.username().c_str();
+                password = auth.password().c_str();
             } else {
-                username = LCBT_SETTING(instance, bucket);
-                password = lcbauth_get_bpass(LCBT_SETTING(instance, auth), username);
+                username = auth.username_for(LCBT_SETTING(instance, bucket)).c_str();
+                password = auth.password_for(LCBT_SETTING(instance, bucket)).c_str();
             }
         }
 
@@ -462,13 +466,18 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         return rc;
     }
 
-    add_header("User-Agent", "libcouchbase/" LCB_VERSION_STRING);
-    if (instance->http_sockpool->maxidle == 0 || !is_data_request()) {
+    std::string ua("libcouchbase/" LCB_VERSION_STRING);
+    if (instance->settings->client_string) {
+        ua.append(" ").append(instance->settings->client_string);
+    }
+    add_header("User-Agent", ua);
+
+    if (instance->http_sockpool->get_options().maxidle == 0 || !is_data_request()) {
         add_header("Connection", "close");
     }
 
     add_header("Accept", "application/json");
-    if (password && username) {
+    if (is_nonempty(password) && is_nonempty(username)) {
         char auth[256];
         std::string upassbuf;
         upassbuf.append(username).append(":").append(password);
@@ -613,23 +622,6 @@ Request::cancel()
     finish(LCB_SUCCESS);
 }
 
-// Wrappers
-void lcb_htreq_setcb(lcb_http_request_t req, lcb_RESPCALLBACK callback) {
-    req->callback = callback;
-}
-void lcb_htreq_block_callback(lcb_http_request_t req) {
-    req->block_callback();
-}
-void lcb_htreq_pause(lcb_http_request_t req) {
-    req->pause();
-}
-void lcb_htreq_resume(lcb_http_request_t req) {
-    req->resume();
-}
-void lcb_htreq_finish(lcb_t, lcb_http_request_t req, lcb_error_t rc) {
-    req->finish(rc);
-}
-
 LIBCOUCHBASE_API
 void
 lcb_cancel_http_request(lcb_t, lcb_http_request_t req)

data/ext/libcouchbase/src/http/http.h

@@ -1,34 +1 @@
-#ifndef LCB_HTTPAPI_H
-#define LCB_HTTPAPI_H
-
-/* This file contains the internal API for HTTP requests. This allows us to
- * change the internals without exposing the object structure to the rest
- * of the library
- */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-void
-lcb_htreq_setcb(lcb_http_request_t, lcb_RESPCALLBACK);
-
-void
-lcb_htreq_pause(lcb_http_request_t);
-
-void
-lcb_htreq_resume(lcb_http_request_t);
-
-void
-lcb_htreq_finish(lcb_t, lcb_http_request_t, lcb_error_t);
-
-/* Prevents the callback from being invoked. This is different than a full
- * destruction of the object. This is only called in lcb_destroy() to
- * prevent dereferencing the instance itself.
- */
-void
-lcb_htreq_block_callback(lcb_http_request_t);
-#ifdef __cplusplus
-}
-#endif
-#endif
+#include "http-priv.h"

data/ext/libcouchbase/src/http/http_io.cc

@@ -30,19 +30,13 @@ using namespace lcb::http;
 #define LOGARGS(req, lvl) req->instance->settings, "http-io", LCB_LOG_##lvl, __FILE__, __LINE__
 
 void
-Request::assign_response_headers(const lcbht_RESPONSE *resp)
+Request::assign_response_headers(const lcb::htparse::Response& resp)
 {
-    response_headers.clear();
+    response_headers.assign(resp.headers.begin(), resp.headers.end());
     response_headers_clist.clear();
 
-    sllist_node *curnode;
-    SLLIST_ITERBASIC(&resp->headers, curnode) {
-        lcbht_MIMEHDR *hdr = SLLIST_ITEM(curnode, lcbht_MIMEHDR, slnode);
-        response_headers.push_back(Header(hdr->key, hdr->value));
-    }
-
-    std::vector<Header>::const_iterator ii = response_headers.begin();
-    for (; ii != response_headers.end(); ++ii) {
+    std::vector<lcb::htparse::MimeHeader>::const_iterator ii;
+    for (ii = response_headers.begin(); ii != response_headers.end(); ++ii) {
         response_headers_clist.push_back(ii->key.c_str());
         response_headers_clist.push_back(ii->value.c_str());
     }
@@ -53,29 +47,30 @@ int
 Request::handle_parse_chunked(const char *buf, unsigned nbuf)
 {
     int parse_state, oldstate, diff;
-    lcbht_RESPONSE *res = lcbht_get_response(parser);
+    using lcb::htparse::Parser;
+    lcb::htparse::Response& res = parser->get_cur_response();
 
     do {
         const char *rbody;
         unsigned nused = -1, nbody = -1;
-        oldstate = res->state;
+        oldstate = res.state;
 
-        parse_state = lcbht_parse_ex(parser, buf, nbuf, &nused, &nbody, &rbody);
+        parse_state = parser->parse_ex(buf, nbuf, &nused, &nbody, &rbody);
         diff = oldstate ^ parse_state;
 
         /* Got headers now for the first time */
-        if (diff & LCBHT_S_HEADER) {
+        if (diff & Parser::S_HEADER) {
             assign_response_headers(res);
-            if (res->status >=  300 && res->status <= 400) {
-                const char *redir = lcbht_get_resphdr(res, "Location");
+            if (res.status >=  300 && res.status <= 400) {
+                const char *redir = res.get_header_value("Location");
                 if (redir != NULL) {
                     pending_redirect.assign(redir);
-                    return LCBHT_S_DONE;
+                    return Parser::S_DONE;
                 }
             }
         }
 
-        if (parse_state & LCBHT_S_ERROR) {
+        if (parse_state & Parser::S_ERROR) {
             /* nothing to do here */
             return parse_state;
         }
@@ -91,22 +86,22 @@ Request::handle_parse_chunked(const char *buf, unsigned nbuf)
                 callback(instance, LCB_CALLBACK_HTTP, (const lcb_RESPBASE *)&htresp);
 
             } else {
-                lcb_string_append(&res->body, rbody, nbody);
+                res.body.append(rbody, nbody);
             }
         }
 
         buf += nused;
         nbuf -= nused;
-    } while ((parse_state & LCBHT_S_DONE) == 0 && is_ongoing() && nbuf);
+    } while ((parse_state & Parser::S_DONE) == 0 && is_ongoing() && nbuf);
 
-    if ( (parse_state & LCBHT_S_DONE) && is_ongoing()) {
+    if ( (parse_state & Parser::S_DONE) && is_ongoing()) {
         lcb_RESPHTTP resp = { 0 };
         if (chunked) {
             buf = NULL;
             nbuf = 0;
         } else {
-            buf = res->body.base;
-            nbuf = res->body.nused;
+            buf = res.body.c_str();
+            nbuf = res.body.size();
         }
 
         init_resp(&resp);
@@ -143,7 +138,8 @@ io_read(lcbio_CTX *ctx, unsigned nr)
         nbuf = lcbio_ctx_risize(&iter);
         parse_state = req->handle_parse_chunked(buf, nbuf);
 
-        if ((parse_state & LCBHT_S_ERROR) || req->has_pending_redirect()) {
+        if ((parse_state & lcb::htparse::Parser::S_ERROR) ||
+                req->has_pending_redirect()) {
             rv = -1;
             break;
         } else if (!req->is_ongoing()) {
@@ -156,7 +152,7 @@ io_read(lcbio_CTX *ctx, unsigned nr)
         // parse error or redirect
         lcb_error_t err;
         if (req->has_pending_redirect()) {
-            lcb_bootstrap_common(instance, LCB_BS_REFRESH_THROTTLE);
+            instance->bootstrap(lcb::BS_REFRESH_THROTTLE);
             // Transfer control to redirect function()
             lcb_log(LOGARGS(req, DEBUG), LOGFMT "Attempting redirect to %s", LOGID(req), req->pending_redirect.c_str());
             req->redirect();
@@ -224,8 +220,7 @@ on_connected(lcbio_SOCKET *sock, void *arg, lcb_error_t err, lcbio_OSERR syserr)
     Request *req = reinterpret_cast<Request*>(arg);
     lcbio_CTXPROCS procs;
     lcb_settings *settings = req->instance->settings;
-
-    LCBIO_CONNREQ_CLEAR(&req->creq);
+    req->creq = NULL;
 
     if (err != LCB_SUCCESS) {
         lcb_log(LOGARGS(req, ERR), "Connection to failed with Err=0x%x", err);
@@ -252,15 +247,12 @@ lcb_error_t
 Request::start_io(lcb_host_t& dest)
 {
     lcbio_MGR *pool = instance->http_sockpool;
-    lcbio_pMGRREQ poolreq;
 
-    poolreq = lcbio_mgr_get(pool, &dest, timeout(), on_connected, this);
-    if (!poolreq) {
+    creq = pool->get(dest, timeout(), on_connected, this);
+    if (!creq) {
         return LCB_CONNECT_ERROR;
     }
 
-    LCBIO_CONNREQ_MKPOOLED(&creq, poolreq);
-
     if (!timer) {
         timer = lcbio_timer_new(io, this, request_timed_out);
     }
@@ -279,16 +271,16 @@ pool_close_cb(lcbio_SOCKET *sock, int reusable, void *arg)
 
     lcbio_ref(sock);
     if (reusable && close_ok) {
-        lcbio_mgr_put(sock);
+        lcb::io::Pool::put(sock);
     } else {
-        lcbio_mgr_discard(sock);
+        lcb::io::Pool::discard(sock);
     }
 }
 
 void
 Request::close_io()
 {
-    lcbio_connreq_cancel(&creq);
+    lcb::io::ConnectionRequest::cancel(&creq);
 
     if (!ioctx) {
         return;
@@ -297,7 +289,7 @@ Request::close_io()
     int can_ka;
 
     if (parser && is_data_request()) {
-        can_ka = lcbht_can_keepalive(parser);
+        can_ka = parser->can_keepalive();
     } else {
         can_ka = 0;
     }

data/ext/libcouchbase/src/instance.cc

@@ -116,17 +116,57 @@ lcb_st::populate_nodes(const Connspec& spec)
     }
 }
 
+lcb_error_t
+lcb_st::process_dns_srv(Connspec& spec)
+{
+    if (!spec.can_dnssrv()) {
+        return LCB_SUCCESS;
+    }
+    if (spec.hosts().empty()) {
+        lcb_log(LOGARGS(this, ERR), "Cannot use DNS SRV without a hostname");
+        return spec.is_explicit_dnssrv() ? LCB_EINVAL : LCB_SUCCESS;
+    }
+
+    const Spechost& host = spec.hosts().front();
+    lcb_error_t rc = LCB_ERROR;
+    Hostlist* hl = dnssrv_getbslist(host.hostname.c_str(), host.isSSL(), rc);
+
+    if (hl == NULL) {
+        lcb_log(LOGARGS(this, INFO), "DNS SRV lookup failed: %s. Ignore this if not relying on DNS SRV records", lcb_strerror(this, rc));
+        if (spec.is_explicit_dnssrv()) {
+            return rc;
+        } else {
+            return LCB_SUCCESS;
+        }
+    }
+
+    spec.clear_hosts();
+    for (size_t ii = 0; ii < hl->size(); ++ii) {
+        const lcb_host_t& src = (*hl)[ii];
+        Spechost sh;
+        sh.hostname = src.host;
+        sh.port = std::atoi(src.port);
+        sh.type = spec.default_port();
+        spec.add_host(sh);
+        lcb_log(LOGARGS(this, INFO), "Found host %s:%d via DNS SRV", sh.hostname.c_str(), sh.port);
+    }
+    delete hl;
+
+    return LCB_SUCCESS;
+}
+
 static lcb_error_t
 init_providers(lcb_t obj, const Connspec &spec)
 {
-    clconfig_provider *http, *cccp, *mcraw;
-    http = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_HTTP);
-    cccp = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_CCCP);
-    mcraw = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_MCRAW);
+    using namespace lcb::clconfig;
+    Provider *http, *cccp, *mcraw;
+    http = obj->confmon->get_provider(CLCONFIG_HTTP);
+    cccp = obj->confmon->get_provider(CLCONFIG_CCCP);
+    mcraw = obj->confmon->get_provider(CLCONFIG_MCRAW);
 
     if (spec.default_port() == LCB_CONFIG_MCCOMPAT_PORT) {
-        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_MCRAW, 1);
-        mcraw->configure_nodes(mcraw, obj->mc_nodes);
+        obj->confmon->set_active(CLCONFIG_MCRAW, true);
+        mcraw->configure_nodes(*obj->mc_nodes);
         return LCB_SUCCESS;
     }
 
@@ -155,26 +195,34 @@ init_providers(lcb_t obj, const Connspec &spec)
         if (spec.is_bs_file()) {
             /* If the 'file_only' provider is set, just assume something else
              * will provide us with the config, and forget about it. */
-            clconfig_provider *prov = lcb_confmon_get_provider(obj->confmon, LCB_CLCONFIG_FILE);
+            Provider *prov = obj->confmon->get_provider(CLCONFIG_FILE);
             if (prov && prov->enabled) {
                 return LCB_SUCCESS;
             }
         }
-        return LCB_BAD_ENVIRONMENT;
+        if (obj->type == LCB_TYPE_CLUSTER) {
+            /* Cluster-level connection always falls back to static config */
+            Provider *cladmin;
+            cladmin = obj->confmon->get_provider(CLCONFIG_CLADMIN);
+            cladmin->enable();
+            cladmin->configure_nodes(*obj->ht_nodes);
+        } else {
+            return LCB_BAD_ENVIRONMENT;
+        }
     }
 
     if (http_enabled) {
-        lcb_clconfig_http_enable(http);
-        lcb_clconfig_http_set_nodes(http, obj->ht_nodes);
+        http->enable();
+        http->configure_nodes(*obj->ht_nodes);
     } else {
-        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_HTTP, 0);
+        obj->confmon->set_active(CLCONFIG_HTTP, false);
     }
 
     if (cccp_enabled && obj->type != LCB_TYPE_CLUSTER) {
-        lcb_clconfig_cccp_enable(cccp, obj);
-        lcb_clconfig_cccp_set_nodes(cccp, obj->mc_nodes);
+        cccp->enable(obj);
+        cccp->configure_nodes(*obj->mc_nodes);
     } else {
-        lcb_confmon_set_provider_active(obj->confmon, LCB_CLCONFIG_CCCP, 0);
+        obj->confmon->set_active(CLCONFIG_CCCP, false);
     }
     return LCB_SUCCESS;
 }
@@ -345,10 +393,20 @@ lcb_error_t lcb_create(lcb_t *instance,
     /* initialize the settings */
     obj->type = type;
     obj->settings = settings;
+    obj->settings->conntype = type;
 
     settings->bucket = strdup(spec.bucket().c_str());
-    if ((err = settings->auth->init(spec.username(), spec.bucket(),
-        spec.password(), type)) != LCB_SUCCESS) {
+
+    if (!spec.username().empty()) {
+        settings->auth->set_mode(LCBAUTH_MODE_RBAC);
+        err = settings->auth->add(spec.username(), spec.password(),
+                                  LCBAUTH_F_CLUSTER);
+    } else {
+        settings->auth->set_mode(LCBAUTH_MODE_CLASSIC);
+        err = settings->auth->add(spec.bucket(), spec.password(),
+                                  LCBAUTH_F_BUCKET);
+    }
+    if (err != LCB_SUCCESS) {
         goto GT_DONE;
     }
 
@@ -373,13 +431,19 @@ lcb_error_t lcb_create(lcb_t *instance,
 
     obj->cmdq.cqdata = obj;
     obj->iotable = lcbio_table_new(io_priv);
-    obj->memd_sockpool = lcbio_mgr_create(settings, obj->iotable);
-    obj->http_sockpool = lcbio_mgr_create(settings, obj->iotable);
-    obj->memd_sockpool->maxidle = 1;
-    obj->memd_sockpool->tmoidle = 10000000;
-    obj->http_sockpool->maxidle = 1;
-    obj->http_sockpool->tmoidle = 10000000;
-    obj->confmon = lcb_confmon_create(settings, obj->iotable);
+    obj->memd_sockpool = new io::Pool(settings, obj->iotable);
+    obj->http_sockpool = new io::Pool(settings, obj->iotable);
+
+    {
+        // Needs its own scope because there are prior GOTOs
+        io::Pool::Options pool_opts;
+        pool_opts.maxidle = 1;
+        pool_opts.tmoidle = LCB_MS2US(10000); // 10 seconds
+        obj->memd_sockpool->set_options(pool_opts);
+        obj->http_sockpool->set_options(pool_opts);
+    }
+
+    obj->confmon = new clconfig::Confmon(settings, obj->iotable);
     obj->ht_nodes = new Hostlist();
     obj->mc_nodes = new Hostlist();
     obj->retryq = new RetryQueue(&obj->cmdq, obj->iotable, obj->settings);
@@ -398,8 +462,15 @@ lcb_error_t lcb_create(lcb_t *instance,
         goto GT_DONE;
     }
 
+    if ((err = obj->process_dns_srv(spec)) != LCB_SUCCESS) {
+        goto GT_DONE;
+    }
+
     obj->populate_nodes(spec);
-    err = init_providers(obj, spec);
+    if ((err = init_providers(obj, spec)) != LCB_SUCCESS) {
+        goto GT_DONE;
+    }
+
     if (err != LCB_SUCCESS) {
         lcb_destroy(obj);
         return err;
@@ -437,6 +508,8 @@ extern "C" {
 void lcbdur_destroy(void*);
 }
 
+static void do_pool_shutdown(io::Pool *pool) { pool->shutdown(); }
+
 LIBCOUCHBASE_API
 void lcb_destroy(lcb_t instance)
 {
@@ -446,10 +519,12 @@ void lcb_destroy(lcb_t instance)
     lcb_ASPEND_SETTYPE::iterator it;
     lcb_ASPEND_SETTYPE *pendq;
 
-    DESTROY(lcb_clconfig_decref, cur_configinfo);
+    if (instance->cur_configinfo) {
+        instance->cur_configinfo->decref();
+        instance->cur_configinfo = NULL;
+    }
     instance->cmdq.config = NULL;
-
-    lcb_bootstrap_destroy(instance);
+    DESTROY(delete, bs_state);
     DESTROY(delete, ht_nodes);
     DESTROY(delete, mc_nodes);
 
@@ -473,16 +548,16 @@ void lcb_destroy(lcb_t instance)
 
     if ((pendq = po->items[LCB_PENDTYPE_HTTP])) {
         for (it = pendq->begin(); it != pendq->end(); ++it) {
-            lcb_http_request_t htreq = reinterpret_cast<lcb_http_request_t>(*it);
-            lcb_htreq_block_callback(htreq);
-            lcb_htreq_finish(instance, htreq, LCB_ERROR);
+            http::Request *htreq = reinterpret_cast<http::Request*>(*it);
+            htreq->block_callback();
+            htreq->finish(LCB_ERROR);
         }
     }
 
     DESTROY(delete, retryq);
-    DESTROY(lcb_confmon_destroy, confmon);
-    DESTROY(lcbio_mgr_destroy, memd_sockpool);
-    DESTROY(lcbio_mgr_destroy, http_sockpool);
+    DESTROY(delete, confmon);
+    DESTROY(do_pool_shutdown, memd_sockpool);
+    DESTROY(do_pool_shutdown, http_sockpool);
     DESTROY(lcb_vbguess_destroy, vbguess);
     DESTROY(lcb_n1qlcache_destroy, n1ql_cache);
 
@@ -534,10 +609,23 @@ lcb_destroy_async(lcb_t instance, const void *arg)
     lcbio_async_signal(instance->dtor_timer);
 }
 
+lcb::Server *
+lcb_st::find_server(const lcb_host_t& host) const
+{
+    unsigned ii;
+    for (ii = 0; ii < cmdq.npipelines; ii++) {
+        lcb::Server *server = static_cast<lcb::Server*>(cmdq.pipelines[ii]);
+        if (lcb_host_equals(&server->get_host(), &host)) {
+            return server;
+        }
+    }
+    return NULL;
+}
+
 LIBCOUCHBASE_API
 lcb_error_t lcb_connect(lcb_t instance)
 {
-    lcb_error_t err = lcb_bootstrap_common(instance, LCB_BS_REFRESH_INITIAL);
+    lcb_error_t err = instance->bootstrap(BS_REFRESH_INITIAL);
     if (err == LCB_SUCCESS) {
         SYNCMODE_INTERCEPT(instance);
     } else {
@@ -718,6 +806,15 @@ const char *lcb_strerror(lcb_t instance, lcb_error_t error)
     return "Unknown error";
 }
 
+LCB_INTERNAL_API
+const char *lcb_strerror_short(lcb_error_t error)
+{
+#define X(c, v, t, s) if (error == c) { return #c " (" #v ")"; }
+    LCB_XERR(X)
+#undef X
+    return "<FIXME: Not an LCB error>";
+}
+
 LIBCOUCHBASE_API
 int lcb_get_errtype(lcb_error_t err)
 {