libcouchbase 1.2.8 → 1.3.0

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

@@ -16,12 +16,29 @@
  */
 
 /* small utility for retrieving host/port information from the CTX */
-static const char* get__ctx_hostinfo(const lcbio_CTX *ctx, int is_host)
+static const lcb_host_t *get_ctx_host(const lcbio_CTX *ctx)
 {
-    if (ctx == NULL || ctx->sock == NULL || ctx->sock->info == NULL) {
-        return is_host ? "NOHOST" : "NOPORT";
+    static lcb_host_t host = {"NOHOST", "NOPORT", 0};
+    if (!ctx) {
+        return &host;
     }
-    return is_host ? ctx->sock->info->ep.host : ctx->sock->info->ep.port;
+    if (!ctx->sock) {
+        return &host;
+    }
+    if (!ctx->sock->info) {
+        return &host;
+    }
+    return &ctx->sock->info->ep;
 }
-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); }
+
+#define CTX_LOGFMT_PRE "<" LCB_LOG_SPEC("%s%s%s:%s") "> (CTX=%p,%s"
+#define CTX_LOGFMT CTX_LOGFMT_PRE ") "
+#define CTX_LOGID(ctx)                                                  \
+    (ctx && ctx->sock && ctx->sock->settings->log_redaction) ? LCB_LOG_SD_OTAG : "", \
+        (get_ctx_host(ctx)->ipv6 ? "[" : ""),                           \
+        get_ctx_host(ctx)->host,                                        \
+        (get_ctx_host(ctx)->ipv6 ? "]" : ""),                           \
+        get_ctx_host(ctx)->port,                                        \
+        (ctx && ctx->sock && ctx->sock->settings->log_redaction)  ? LCB_LOG_SD_CTAG : "", \
+        (void *)ctx,                                                    \
+        ctx ? ctx->subsys : ""

data/ext/libcouchbase/src/dump.cc

@@ -89,6 +89,10 @@ lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags)
         } else {
             fprintf(fp, "** == NOT DUMPING PACKETS. LCB_DUMP_PKTINFO not passed\n");
         }
+        if ((flags & LCB_DUMP_METRICS) && server->metrics) {
+            fprintf(fp, "=== SERVER METRICS ===\n");
+            lcb_metrics_dumpserver(server->metrics, fp);
+        }
         fprintf(fp, "\n\n");
     }
     fprintf(fp, "=== END PIPELINE DUMP ===\n");

data/ext/libcouchbase/src/getconfig.cc

@@ -28,8 +28,7 @@ ext_callback_proxy(mc_PIPELINE *pl, mc_PACKET *req, lcb_error_t rc,
     const lcb::MemcachedResponse *res =
             reinterpret_cast<const lcb::MemcachedResponse*>(resdata);
 
-    lcb::clconfig::cccp_update(
-        rd->cookie, rc, res->body<const char*>(), res->bodylen(),
+    lcb::clconfig::cccp_update(rd->cookie, rc, res->value(), res->vallen(),
         &server->get_host());
     free(rd);
 }

data/ext/libcouchbase/src/handler.cc

@@ -149,6 +149,24 @@ map_error(lcb_t instance, int in)
         return LCB_SUBDOC_PATH_EEXISTS;
     case PROTOCOL_BINARY_RESPONSE_SUBDOC_MULTI_PATH_FAILURE:
         return LCB_SUBDOC_MULTI_FAILURE;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_INVALID_COMBO:
+        return LCB_SUBDOC_INVALID_COMBO;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_SUCCESS_DELETED:
+        return LCB_SUBDOC_SUCCESS_DELETED;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_INVALID_FLAG_COMBO:
+        return LCB_SUBDOC_XATTR_INVALID_FLAG_COMBO;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_INVALID_KEY_COMBO:
+        return LCB_SUBDOC_XATTR_INVALID_KEY_COMBO;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_UNKNOWN_MACRO:
+        return LCB_SUBDOC_XATTR_UNKNOWN_MACRO;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_UNKNOWN_VATTR:
+        return LCB_SUBDOC_XATTR_UNKNOWN_VATTR;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_XATTR_CANT_MODIFY_VATTR:
+        return LCB_SUBDOC_XATTR_CANT_MODIFY_VATTR;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_MULTI_PATH_FAILURE_DELETED:
+        return LCB_SUBDOC_MULTI_PATH_FAILURE_DELETED;
+    case PROTOCOL_BINARY_RESPONSE_SUBDOC_INVALID_XATTR_ORDER:
+        return LCB_SUBDOC_INVALID_XATTR_ORDER;
     case PROTOCOL_BINARY_RESPONSE_EINVAL:
         return LCB_EINVAL_MCD;
     case PROTOCOL_BINARY_RESPONSE_NOT_STORED:
@@ -165,6 +183,8 @@ map_error(lcb_t instance, int in)
         return LCB_NOT_SUPPORTED;
     case PROTOCOL_BINARY_RESPONSE_EACCESS:
         return LCB_NOT_AUTHORIZED;
+    case PROTOCOL_BINARY_RESPONSE_UNKNOWN_COLLECTION:
+        return LCB_EINVAL;
     default:
         if (instance != NULL) {
             return instance->callbacks.errmap(instance, in);
@@ -271,7 +291,7 @@ handle_mutation_token(lcb_t instance, const MemcachedResponse *mc_resp,
         }
     }
 
-    sbuf = mc_resp->body<const char*>();
+    sbuf = mc_resp->ext();
     vbid = mcreq_get_vbucket(req);
     stok->vbid_ = vbid;
     memcpy(&stok->uuid_, sbuf, 8);
@@ -362,19 +382,20 @@ H_get(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse* response,
     resp.rflags |= LCB_RESP_F_FINAL;
 
     if (resp.rc == LCB_SUCCESS) {
-        const protocol_binary_response_get *get =
-                reinterpret_cast<const protocol_binary_response_get*>(
-                        response->ephemeral_start());
         resp.datatype = response->datatype();
-        resp.itmflags = ntohl(get->message.body.flags);
         resp.value = response->value();
         resp.nvalue = response->vallen();
         resp.bufh = response->bufseg();
+        if (response->extlen() == sizeof(uint32_t)) {
+            memcpy(&resp.itmflags, response->ext(), sizeof(uint32_t));
+            resp.itmflags = ntohl(resp.itmflags);
+        }
     }
 
     void *freeptr = NULL;
     maybe_decompress(o, response, &resp, &freeptr);
-    TRACE_GET_END(response, &resp);
+    LCBTRACE_KV_FINISH(pipeline, request, response);
+    TRACE_GET_END(o, request, response, &resp);
     invoke_callback(request, o, &resp, LCB_CALLBACK_GET);
     free(freeptr);
 }
@@ -393,14 +414,14 @@ H_getreplica(mc_PIPELINE *pipeline, mc_PACKET *request,
     handle_error_info(response, &w);
 
     if (resp.rc == LCB_SUCCESS) {
-        const protocol_binary_response_get *get =
-                reinterpret_cast<const protocol_binary_response_get*>(
-                        response->ephemeral_start());
-        resp.itmflags = ntohl(get->message.body.flags);
         resp.datatype = response->datatype();
         resp.value = response->value();
         resp.nvalue = response->vallen();
         resp.bufh = response->bufseg();
+        if (response->extlen() == sizeof(uint32_t)) {
+            memcpy(&resp.itmflags, response->ext(), sizeof(uint32_t));
+            resp.itmflags = ntohl(resp.itmflags);
+        }
     }
 
     maybe_decompress(instance, response, &resp, &freeptr);
@@ -533,6 +554,7 @@ sdmutate_next(const MemcachedResponse *response, lcb_SDENTRY *ent, size_t *iter)
         ent->nvalue = 0;
     }
 
+    (void)buf_end;
     return 1;
     #undef ADVANCE_BUF
 }
@@ -585,7 +607,8 @@ H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, MemcachedResponse *response,
     init_resp(root, response, packet, immerr, &w.resp);
     handle_error_info(response, &w);
     handle_mutation_token(root, response, packet, &w.mt);
-    TRACE_REMOVE_END(response, &w.resp);
+    LCBTRACE_KV_FINISH(pipeline, packet, response);
+    TRACE_REMOVE_END(root, packet, response, &w.resp);
     invoke_callback(packet, root, &w.resp, LCB_CALLBACK_REMOVE);
 }
 
@@ -620,8 +643,8 @@ H_observe(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response
     ttr = ntohl(ttr);
 
     /** Actual payload sequence of (vb, nkey, key). Repeats multiple times */
-    ptr = response->body<const char *>();
-    end = ptr + response->bodylen();
+    ptr = response->value();
+    end = ptr + response->vallen();
     config = pipeline->parent->config;
 
     for (pos = 0; ptr < end; pos++) {
@@ -648,14 +671,15 @@ H_observe(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response
         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);
+        resp.ttp = ttp;
+        resp.ttr = ttr;
+        TRACE_OBSERVE_PROGRESS(root, request, response, &resp);
+        LCBTRACE_KV_FINISH(pipeline, request, response);
         if (! (request->flags & MCREQ_F_INVOKED)) {
             rd->procs->handler(pipeline, request, resp.rc, &resp);
         }
     }
-    TRACE_OBSERVE_END(response);
+    TRACE_OBSERVE_END(root, request, response);
 }
 
 static void
@@ -668,7 +692,7 @@ H_observe_seqno(mc_PIPELINE *pipeline, mc_PACKET *request,
     resp.server_index = pipeline->index;
 
     if (resp.rc == LCB_SUCCESS) {
-        const uint8_t *data = response->body<const uint8_t*>();
+        const uint8_t *data = reinterpret_cast<const uint8_t *>(response->value());
         bool is_failover = *data != 0;
 
         data++;
@@ -690,6 +714,7 @@ H_observe_seqno(mc_PIPELINE *pipeline, mc_PACKET *request,
         /* Get the server for this command. Note that since this is a successful
          * operation, the server is never a dummy */
     }
+    LCBTRACE_KV_FINISH(pipeline, request, response);
     invoke_callback(request, root, &resp, LCB_CALLBACK_OBSEQNO);
 }
 
@@ -722,10 +747,12 @@ H_store(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
     }
     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);
+    TRACE_STORE_END(root, request, response, &w.resp);
     if (request->flags & MCREQ_F_REQEXT) {
+        LCBTRACE_KV_COMPLETE(pipeline, request, response);
         request->u_rdata.exdata->procs->handler(pipeline, request, immerr, &w.resp);
     } else {
+        LCBTRACE_KV_FINISH(pipeline, request, response);
         invoke_callback(request, root, &w.resp, LCB_CALLBACK_STORE);
     }
 }
@@ -748,7 +775,8 @@ H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request,
     }
     w.resp.rflags |= LCB_RESP_F_FINAL;
     w.resp.cas = response->cas();
-    TRACE_ARITHMETIC_END(response, &w.resp);
+    LCBTRACE_KV_FINISH(pipeline, request, response);
+    TRACE_ARITHMETIC_END(root, request, response, &w.resp);
     invoke_callback(request, root, &w.resp, LCB_CALLBACK_COUNTER);
 }
 
@@ -803,9 +831,9 @@ H_version(mc_PIPELINE *pipeline, mc_PACKET *request,
 
     make_error(root, &resp, response, immerr);
 
-    if (response->bodylen()) {
-        resp.mcversion = response->body<const char *>();
-        resp.nversion = response->bodylen();
+    if (response->vallen()) {
+        resp.mcversion = response->value();
+        resp.nversion = response->vallen();
     }
 
 
@@ -835,7 +863,8 @@ H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
     init_resp(root, response, request, immerr, &resp);
     handle_error_info(response, &w);
     resp.rflags |= LCB_RESP_F_FINAL;
-    TRACE_TOUCH_END(response, &resp);
+    LCBTRACE_KV_FINISH(pipeline, request, response);
+    TRACE_TOUCH_END(root, request, response, &resp);
     invoke_callback(request, root, &resp, LCB_CALLBACK_TOUCH);
 }
 
@@ -860,7 +889,8 @@ H_unlock(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *response,
     init_resp(root, response, request, immerr, &resp);
     handle_error_info(response, &w);
     resp.rflags |= LCB_RESP_F_FINAL;
-    TRACE_UNLOCK_END(response, &resp);
+    LCBTRACE_KV_FINISH(pipeline, request, response);
+    TRACE_UNLOCK_END(root, request, response, &resp);
     invoke_callback(request, root, &resp, LCB_CALLBACK_UNLOCK);
 }
 
@@ -880,9 +910,17 @@ static void
 record_metrics(mc_PIPELINE *pipeline, mc_PACKET *req, MemcachedResponse *)
 {
     lcb_t instance = get_instance(pipeline);
+    if (
+#ifdef HAVE_DTRACE
+        1
+#else
+        instance->kv_timings
+#endif
+        ) {
+        MCREQ_PKT_RDATA(req)->dispatch = gethrtime();
+    }
     if (instance->kv_timings) {
-        lcb_histogram_record(instance->kv_timings,
-            gethrtime() - MCREQ_PKT_RDATA(req)->start);
+        lcb_histogram_record(instance->kv_timings, MCREQ_PKT_RDATA(req)->dispatch - MCREQ_PKT_RDATA(req)->start);
     }
 }
 

data/ext/libcouchbase/src/hostlist.cc

@@ -48,6 +48,7 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport)
     char *host_s;
     char *port_s;
     char *delim;
+    bool ipv6 = false;
 
     /** Parse the host properly */
     if (speclen < 0) {
@@ -64,10 +65,6 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport)
     zspec.push_back('\0');
     host_s = &zspec[0];
 
-    if (*host_s == ':') {
-        return LCB_INVALID_HOST_FORMAT;
-    }
-
     if ( (delim = strstr(host_s, "://"))) {
         host_s = delim + 3;
     }
@@ -77,6 +74,24 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport)
     }
 
     port_s = strstr(host_s, ":");
+    if (port_s != NULL && strstr(port_s + 1, ":") != NULL) {
+        ipv6 = true;
+        // treat as IPv6 address
+        if (host_s[0] == '[') {
+            host_s++;
+            char *hostend = strstr(host_s, "]");
+            if (hostend == NULL) {
+                return LCB_INVALID_HOST_FORMAT;
+            }
+            port_s = hostend + 1;
+            if (*port_s != ':' || (size_t)(port_s - host_s) >= strlen(host_s)) {
+                port_s = NULL;
+            }
+            *hostend = '\0';
+        } else {
+            port_s = NULL;
+        }
+    }
     if (port_s != NULL) {
         char *endp;
         long ll;
@@ -118,6 +133,13 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport)
         case '-':
         case '_':
             break;
+        case ':':
+        case '[':
+        case ']':
+            if (ipv6) {
+                break;
+            }
+        /* fallthrough */
         default:
             return LCB_INVALID_HOST_FORMAT;
         }
@@ -129,6 +151,7 @@ lcb_host_parse(lcb_host_t *host, const char *spec, int speclen, int deflport)
     } else {
         sprintf(host->port, "%d", deflport);
     }
+    host->ipv6 = ipv6;
 
     return LCB_SUCCESS;
 }
@@ -152,7 +175,7 @@ Hostlist::exists(const lcb_host_t& host) const
 bool
 Hostlist::exists(const char *s) const
 {
-    lcb_host_t tmp;
+    lcb_host_t tmp = {"", "", 0};
     if (lcb_host_parse(&tmp, s, -1, 1) != LCB_SUCCESS) {
         return false;
     }
@@ -189,7 +212,7 @@ Hostlist::add(const char *hostport, long len, int deflport)
     const char *curstart = ss.c_str();
     const char *delim;
     while ( (delim = strstr(curstart, ";"))) {
-        lcb_host_t curhost;
+        lcb_host_t curhost = {"", "", 0};
         size_t curlen;
 
         if (delim == curstart) {
@@ -243,7 +266,12 @@ void Hostlist::ensure_strlist() {
     }
     for (size_t ii = 0; ii < hosts.size(); ii++) {
         const lcb_host_t& host = hosts[ii];
-        std::string ss(host.host);
+        std::string ss;
+        if (host.ipv6) {
+            ss.append("[").append(host.host).append("]");
+        } else {
+            ss.append(host.host);
+        }
         ss.append(":").append(host.port);
         char *newstr = new char[ss.size() + 1];
         newstr[ss.size()] = '\0';

data/ext/libcouchbase/src/hostlist.h

@@ -28,8 +28,15 @@
 typedef struct lcb_host_st {
     char host[NI_MAXHOST + 1];
     char port[NI_MAXSERV + 1];
+    int ipv6;
 } lcb_host_t;
 
+#define LCB_HOST_FMT LCB_LOG_SPEC("%s%s%s:%s")
+#define LCB_HOST_ARG(__settings, __host)                                \
+    ((__settings && __settings->log_redaction) ? LCB_LOG_SD_OTAG : ""), \
+        ((__host)->ipv6 ? "[" : ""), (__host)->host, ((__host)->ipv6 ? "]" : ""), (__host)->port, \
+        ((__settings && __settings->log_redaction) ? LCB_LOG_SD_CTAG : "") \
+
 /**
  * Structure representing a list of hosts. This has an internal iteration
  * index which is used to cycle between 'good' and 'bad' hosts.

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

@@ -221,6 +221,7 @@ struct Request {
     std::string url; /**<Base URL: http://host:port/path?query*/
     std::string host; /**< Host, derived from URL */
     std::string port; /**< Port, derived from URL */
+    bool ipv6;
 
     std::string pending_redirect; /**< New redirected URL */
 
@@ -313,6 +314,7 @@ struct Request {
     const uint32_t user_timeout;
 
     hrtime_t start; /**< Start time */
+    lcbio_SERVICE service;
 };
 
 } // namespace: http

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

@@ -20,10 +20,13 @@
 #include "http/http.h"
 #include "http/http-priv.h"
 #include "auth-priv.h"
+#include "trace.h"
+
 using namespace lcb::http;
 
-#define LOGFMT "<%s:%s> "
-#define LOGID(req) (req)->host.c_str(), (req)->port.c_str()
+#define LOGFMT "<%s%s%s:%s> "
+#define LOGID(req) ((req)->ipv6 ? "[" : ""), (req)->host.c_str(), ((req)->ipv6 ? "]" : ""), (req)->port.c_str()
+
 #define LOGARGS(req, lvl) req->instance->settings, "http-io", LCB_LOG_##lvl, __FILE__, __LINE__
 
 static const char *method_strings[] = {
@@ -83,19 +86,35 @@ Request::finish_or_retry(lcb_error_t rc)
         finish(rc);
         return;
     }
+    struct http_parser_url next_info;
+    if (_lcb_http_parser_parse_url(nextnode, strlen(nextnode), 0, &next_info)) {
+        lcb_log(LOGARGS(this, WARN), LOGFMT "Not retrying. Invalid API endpoint", LOGID(this));
+        finish(LCB_EINVAL);
+        return;
+    }
 
     // Reassemble URL:
+    lcb_log(LOGARGS(this, DEBUG), LOGFMT "Retrying request on new node %s. Reason: 0x%02x (%s)", LOGID(this), nextnode,
+            rc, lcb_strerror(NULL, rc));
 
-    // get offset and length of host bits
-    size_t host_begin = url_info.field_data[UF_HOST].off;
-    size_t hplen =
-            url_info.field_data[UF_HOST].len +
-            url_info.field_data[UF_PORT].len + 1; // +1 for ":"
+    url.replace(url_info.field_data[UF_PORT].off, url_info.field_data[UF_PORT].len,
+                nextnode + next_info.field_data[UF_PORT].off, next_info.field_data[UF_PORT].len);
+    url.replace(url_info.field_data[UF_HOST].off, url_info.field_data[UF_HOST].len,
+                nextnode + next_info.field_data[UF_HOST].off, next_info.field_data[UF_HOST].len);
 
-    url.replace(host_begin, hplen, nextnode);
-    lcb_error_t newrc = submit();
+    lcb_error_t newrc;
+    newrc = assign_url(NULL, 0, NULL, 0);
     if (newrc != LCB_SUCCESS) {
-        lcb_log(LOGARGS(this, WARN), LOGFMT "Retry failed!", LOGID(this));
+        lcb_log(LOGARGS(this, ERR), LOGFMT "Failed to assign URL for retry request on next endpoint (%s): 0x%02x (%s)",
+                LOGID(this), nextnode, newrc, lcb_strerror(NULL, newrc));
+        finish(rc);
+        return;
+    }
+
+    newrc = submit();
+    if (newrc != LCB_SUCCESS) {
+        lcb_log(LOGARGS(this, WARN), LOGFMT "Failed to retry request on next endpoint (%s): 0x%02x (%s)", LOGID(this),
+                nextnode, newrc, lcb_strerror(NULL, newrc));
         finish(rc);
     }
 }
@@ -165,6 +184,7 @@ Request::finish(lcb_error_t error)
         return;
     }
 
+    TRACE_HTTP_END(this, error, parser->get_cur_response().status);
     status |= FINISHED;
 
     if (!(status & NOLCB)) {
@@ -199,7 +219,7 @@ lcb_error_t
 Request::submit()
 {
     lcb_error_t rc;
-    lcb_host_t reqhost;
+    lcb_host_t reqhost = {"", "", 0};
 
     // Stop any pending socket/request
     close_io();
@@ -215,6 +235,7 @@ Request::submit()
     strncpy(reqhost.port, port.c_str(), port.size());
     reqhost.host[host.size()] = '\0';
     reqhost.port[port.size()] = '\0';
+    reqhost.ipv6 = ipv6;
 
     // Add the HTTP verb (e.g. "GET ") [note, the string contains a trailing space]
     add_to_preamble(method_strings[method]);
@@ -225,7 +246,8 @@ Request::submit()
     size_t path_len = url.size() - path_off;
     preamble.insert(preamble.end(),
         url_s + path_off, url_s + path_off + path_len);
-    lcb_log(LOGARGS(this, TRACE), LOGFMT "%s %s. Body=%lu bytes", LOGID(this), method_strings[method], url.c_str(), body.size());
+    lcb_log(LOGARGS(this, TRACE), LOGFMT "%s %s. Body=%lu bytes", LOGID(this), method_strings[method], url.c_str(),
+            (unsigned long int)body.size());
 
     add_to_preamble(" HTTP/1.1\r\n");
 
@@ -258,6 +280,7 @@ Request::submit()
         }
         response_headers.clear();
         response_headers_clist.clear();
+        TRACE_HTTP_BEGIN(this);
     }
 
     return rc;
@@ -328,6 +351,7 @@ Request::assign_url(const char *base, size_t nbase, const char *path, size_t npa
 
     assign_from_urlfield(UF_HOST, host);
     assign_from_urlfield(UF_PORT, port);
+    ipv6 = host.find(':') != std::string::npos;
     return LCB_SUCCESS;
 }
 
@@ -408,23 +432,24 @@ 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)
 {
-    const char *base = NULL, *username, *password;
+    std::string username, password;
+    const char *base = NULL;
     size_t nbase = 0;
-    lcb_error_t rc;
+    lcb_error_t rc = LCB_SUCCESS;
 
     if (method > LCB_HTTP_METHOD_MAX) {
         return LCB_EINVAL;
     }
 
-    username = cmd->username;
-    password = cmd->password;
+    if (cmd->username) {
+        username = cmd->username;
+    }
+    if (cmd->password) {
+        password = cmd->password;
+    }
 
     if (reqtype == LCB_HTTP_TYPE_RAW) {
         if ((base = cmd->host) == NULL) {
@@ -434,19 +459,6 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         if (cmd->host) {
             return LCB_EINVAL;
         }
-        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) {
-                username = auth.username().c_str();
-                password = auth.password().c_str();
-            } else {
-                username = auth.username_for(LCBT_SETTING(instance, bucket)).c_str();
-                password = auth.password_for(LCBT_SETTING(instance, bucket)).c_str();
-            }
-        }
-
         base = get_api_node(rc);
         if (base == NULL || *base == '\0') {
             if (rc == LCB_SUCCESS) {
@@ -455,6 +467,34 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
                 return rc;
             }
         }
+
+        if ((cmd->cmdflags & LCB_CMDHTTP_F_NOUPASS) || instance->settings->keypath) {
+            // explicitly asked to skip Authorization header,
+            // or using SSL client certificate to authenticate
+            username.clear();
+            password.clear();
+        } else if (username.empty() && password.empty()) {
+            const Authenticator& auth = *LCBT_SETTING(instance, auth);
+            if (reqtype == LCB_HTTP_TYPE_MANAGEMENT) {
+                username = auth.username();
+                password = auth.password();
+            } else {
+                if (auth.mode() == LCBAUTH_MODE_DYNAMIC) {
+                    struct http_parser_url info = {};
+                    if (_lcb_http_parser_parse_url(base, strlen(base), 0, &info)) {
+                        lcb_log(LOGARGS(this, WARN), LOGFMT "Failed to parse API endpoint", LOGID(this));
+                        return LCB_EINTERNAL;
+                    }
+                    std::string hh(base + info.field_data[UF_HOST].off, info.field_data[UF_HOST].len);
+                    std::string pp(base + info.field_data[UF_PORT].off, info.field_data[UF_PORT].len);
+                    username = auth.username_for(hh.c_str(), pp.c_str(), LCBT_SETTING(instance, bucket));
+                    password = auth.password_for(hh.c_str(), pp.c_str(), LCBT_SETTING(instance, bucket));
+                } else {
+                    username = auth.username_for(NULL, NULL, LCBT_SETTING(instance, bucket));
+                    password = auth.password_for(NULL, NULL, LCBT_SETTING(instance, bucket));
+                }
+            }
+        }
     }
 
     if (base) {
@@ -468,7 +508,7 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
         return rc;
     }
 
-    std::string ua("libcouchbase/" LCB_VERSION_STRING);
+    std::string ua(LCB_CLIENT_ID);
     if (instance->settings->client_string) {
         ua.append(" ").append(instance->settings->client_string);
     }
@@ -479,11 +519,11 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
     }
 
     add_header("Accept", "application/json");
-    if (is_nonempty(password) && is_nonempty(username)) {
+    if (!username.empty()) {
         char auth[256];
         std::string upassbuf;
         upassbuf.append(username).append(":").append(password);
-        if (lcb_base64_encode(upassbuf.c_str(), auth, sizeof(auth)) == -1) {
+        if (lcb_base64_encode(upassbuf.c_str(), upassbuf.size(), auth, sizeof(auth)) == -1) {
             return LCB_EINVAL;
         }
         add_header("Authorization", std::string("Basic ") + auth);
@@ -491,7 +531,7 @@ Request::setup_inputs(const lcb_CMDHTTP *cmd)
 
     if (!body.empty()) {
         char lenbuf[64];
-        sprintf(lenbuf, "%ld", body.size());
+        sprintf(lenbuf, "%lu", (unsigned long int)body.size());
         add_header("Content-Length", lenbuf);
         if (cmd->content_type) {
             add_header("Content-Type", cmd->content_type);