couchbase 3.2.0 → 3.2.4

package/deps/lcb/src/capi/cmd_subdoc.hh

@@ -114,6 +114,12 @@ struct subdoc_spec_options {
  * This structure is provided in an array to the lcb_CMDSUBDOC::specs field.
  */
 struct subdoc_spec {
+    bool is_lookup() const
+    {
+        return opcode_ == subdoc_opcode::get || opcode_ == subdoc_opcode::get_count ||
+               opcode_ == subdoc_opcode::get_fulldoc || opcode_ == subdoc_opcode::exist;
+    }
+
     subdoc_opcode opcode() const
     {
         return opcode_;
@@ -216,11 +222,23 @@ struct lcb_SUBDOCSPECS_ {
         return specs_;
     }
 
+    bool is_lookup() const
+    {
+        return specs_.empty() || specs_[0].is_lookup();
+    }
+
   private:
     std::vector<subdoc_spec> specs_{};
 };
 
 struct lcb_CMDSUBDOC_ {
+    const std::string &operation_name() const
+    {
+        static std::string lookup_in_name = LCBTRACE_OP_LOOKUPIN;
+        static std::string mutate_in_name = LCBTRACE_OP_MUTATEIN;
+        return specs_.is_lookup() ? lookup_in_name : mutate_in_name;
+    }
+
     const subdoc_options &options() const
     {
         return options_;
@@ -421,6 +439,22 @@ struct lcb_CMDSUBDOC_ {
         return preserve_expiry_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -434,6 +468,7 @@ struct lcb_CMDSUBDOC_ {
     subdoc_options options_{};
     lcb_SUBDOCSPECS_ specs_{};
     bool preserve_expiry_{false};
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_touch.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDTOUCH_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_TOUCH;
+        return name;
+    }
+
     lcb_STATUS expiry(std::uint32_t expiry)
     {
         expiry_ = expiry;
@@ -126,6 +132,22 @@ struct lcb_CMDTOUCH_ {
         return cookie_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -134,6 +156,7 @@ struct lcb_CMDTOUCH_ {
     lcbtrace_SPAN *parent_span_{nullptr};
     void *cookie_{nullptr};
     std::string key_{};
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_unlock.hh

@@ -28,6 +28,12 @@
  * @private
  */
 struct lcb_CMDUNLOCK_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_UNLOCK;
+        return name;
+    }
+
     lcb_STATUS cas(std::uint64_t cas)
     {
         if (cas == 0) {
@@ -129,6 +135,22 @@ struct lcb_CMDUNLOCK_ {
         return cookie_;
     }
 
+    lcb_STATUS on_behalf_of(std::string user)
+    {
+        impostor_ = std::move(user);
+        return LCB_SUCCESS;
+    }
+
+    bool want_impersonation() const
+    {
+        return !impostor_.empty();
+    }
+
+    const std::string &impostor() const
+    {
+        return impostor_;
+    }
+
   private:
     lcb::collection_qualifier collection_{};
     std::chrono::microseconds timeout_{0};
@@ -137,6 +159,7 @@ struct lcb_CMDUNLOCK_ {
     void *cookie_{nullptr};
     std::string key_{};
     std::uint64_t cas_{};
+    std::string impostor_{};
 };
 
 /**

package/deps/lcb/src/capi/cmd_view.hh

@@ -47,6 +47,12 @@ struct lcb_VIEW_ERROR_CONTEXT_ {
 
 /** @private */
 struct lcb_CMDVIEW_ {
+    static const std::string &operation_name()
+    {
+        static std::string name = LCBTRACE_OP_VIEW;
+        return name;
+    }
+
     bool view_or_design_document_empty() const
     {
         return view_name_.empty() || design_document_name_.empty();

package/deps/lcb/src/capi/collection_qualifier.hh

@@ -135,8 +135,8 @@ struct collection_qualifier {
         return true;
     }
 
-    std::string scope_{};
-    std::string collection_{};
+    std::string scope_{"_default"};
+    std::string collection_{"_default"};
     std::string spec_{};
     std::uint32_t resolved_collection_id_{0};
     bool resolved_{false};

package/deps/lcb/src/cntl.cc

@@ -21,6 +21,7 @@
 #include <lcbio/iotable.h>
 #include <mcserver/negotiate.h>
 #include <lcbio/ssl.h>
+#include "n1ql/query_utils.hh"
 
 #define LOGARGS(instance, lvl) instance->settings, "cntl", LCB_LOG_##lvl, __FILE__, __LINE__
 
@@ -238,7 +239,35 @@ HANDLER(select_bucket_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, select
 
 HANDLER(log_redaction_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, log_redaction))}
 
-HANDLER(enable_tracing_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, use_tracing))}
+HANDLER(enable_tracing_handler)
+{
+    if (mode == LCB_CNTL_GET) {
+        RETURN_GET_ONLY(int, instance->settings->use_tracing)
+    } else if (mode == LCB_CNTL_SET) {
+        if (arg == nullptr) {
+            return LCB_ERR_INVALID_ARGUMENT;
+        }
+        int enabled = *(static_cast<int *>(arg));
+        if (enabled) {
+            if (instance->settings->use_tracing) {
+                /* do nothing */
+                return LCB_SUCCESS;
+            }
+            instance->settings->tracer = lcbtrace_new(instance, LCBTRACE_F_THRESHOLD);
+            instance->settings->use_tracing = true;
+            return LCB_SUCCESS;
+        } else {
+            if (instance->settings->use_tracing) {
+                lcbtrace_destroy(instance->settings->tracer);
+                instance->settings->tracer = nullptr;
+                instance->settings->use_tracing = false;
+            }
+            return LCB_SUCCESS;
+        }
+    } else {
+        return LCB_ERR_CONTROL_UNSUPPORTED_MODE;
+    }
+}
 
 HANDLER(enable_errmap_handler){RETURN_GET_SET(int, LCBT_SETTING(instance, use_errmap))}
 
@@ -354,7 +383,7 @@ HANDLER(force_sasl_mech_handler)
         free(instance->settings->sasl_mech_force);
         if (arg) {
             const char *s = reinterpret_cast<const char *>(arg);
-            instance->settings->sasl_mech_force = strdup(s);
+            instance->settings->sasl_mech_force = lcb_strdup(s);
             for (char *p = instance->settings->sasl_mech_force; *p != '\0'; p++) {
                 if (*p == ',') {
                     *p = ' ';
@@ -553,7 +582,7 @@ HANDLER(client_string_handler)
         free(LCBT_SETTING(instance, client_string));
         LCBT_SETTING(instance, client_string) = nullptr;
         if (val) {
-            char *p, *buf = strdup(val);
+            char *p, *buf = lcb_strdup(val);
             for (p = buf; *p != '\0'; p++) {
                 switch (*p) {
                     case '\n':
@@ -709,7 +738,7 @@ HANDLER(network_handler)
         free(LCBT_SETTING(instance, network));
         LCBT_SETTING(instance, network) = nullptr;
         if (val) {
-            LCBT_SETTING(instance, network) = strdup(val);
+            LCBT_SETTING(instance, network) = lcb_strdup(val);
         }
     } else {
         *(const char **)arg = LCBT_SETTING(instance, network);
@@ -858,14 +887,19 @@ typedef struct {
 
 static lcb_STATUS convert_timevalue(const char *arg, u_STRCONVERT *u)
 {
-    double dtmp;
-    char *end = nullptr;
-    errno = 0;
-    dtmp = std::strtod(arg, &end);
-    if (errno == ERANGE || end == arg) {
-        return LCB_ERR_CONTROL_INVALID_ARGUMENT;
+    try {
+        auto tmo_ns = lcb_parse_golang_duration(arg);
+        u->u32 = static_cast<std::uint32_t>(std::chrono::duration_cast<std::chrono::microseconds>(tmo_ns).count());
+    } catch (const lcb_duration_parse_error &) {
+        double dtmp;
+        char *end = nullptr;
+        errno = 0;
+        dtmp = std::strtod(arg, &end);
+        if (errno == ERANGE || end == arg) {
+            return LCB_ERR_CONTROL_INVALID_ARGUMENT;
+        }
+        u->u32 = static_cast<std::uint32_t>(dtmp * (double)1000000);
     }
-    u->u32 = static_cast<std::uint32_t>(dtmp * (double)1000000);
     return LCB_SUCCESS;
 }
 

package/deps/lcb/src/crypto.cc

@@ -221,7 +221,7 @@ lcb_STATUS lcbcrypto_encrypt_fields(lcb_INSTANCE *instance, lcbcrypto_CMDENCRYPT
     }
     if (changed) {
         std::string doc = Json::FastWriter().write(jdoc);
-        cmd->out = strdup(doc.c_str());
+        cmd->out = lcb_strdup(doc.c_str());
         cmd->nout = strlen(cmd->out);
     }
     return LCB_SUCCESS;
@@ -383,7 +383,7 @@ lcb_STATUS lcbcrypto_decrypt_fields(lcb_INSTANCE *instance, lcbcrypto_CMDDECRYPT
     }
     if (changed) {
         std::string doc = Json::FastWriter().write(jdoc);
-        cmd->out = strdup(doc.c_str());
+        cmd->out = lcb_strdup(doc.c_str());
         cmd->nout = strlen(cmd->out);
     }
     return LCB_SUCCESS;

package/deps/lcb/src/dns-srv.cc

@@ -105,9 +105,11 @@ lcb_STATUS lcb::dnssrv_query(const char *addr, Hostlist &hs)
     }
 
     for (cur = root; cur; cur = cur->pNext) {
-        // Use the ASCII version of the DNS lookup structure
-        const DNS_SRV_DATAA *srv = &cur->Data.SRV;
-        hs.add(srv->pNameTarget, srv->wPort);
+        if(cur->wType == DNS_TYPE_SRV) {
+            // Use the ASCII version of the DNS lookup structure
+            const DNS_SRV_DATAA *srv = &cur->Data.SRV;
+            hs.add(srv->pNameTarget, srv->wPort);
+        }
     }
     DnsRecordListFree(root, DnsFreeRecordList);
     return LCB_SUCCESS;

package/deps/lcb/src/errmap.cc

@@ -131,8 +131,7 @@ ErrorMap::ParseStatus ErrorMap::parse(const char *s, size_t n, std::string &errm
         return PARSE_ERROR;
     }
 
-    Json::Value::const_iterator ii = errsJson.begin();
-    for (; ii != errsJson.end(); ++ii) {
+    for (Json::Value::const_iterator ii = errsJson.begin(); ii != errsJson.end(); ++ii) {
         // Key is the version in hex
         unsigned ec = 0;
         if (sscanf(ii.key().asCString(), "%x", &ec) != 1) {
@@ -155,14 +154,11 @@ ErrorMap::ParseStatus ErrorMap::parse(const char *s, size_t n, std::string &errm
             return PARSE_ERROR;
         }
 
-        Json::Value::const_iterator jj = attrs.begin();
-        for (; jj != attrs.end(); ++jj) {
-            ErrorAttribute attr = getAttribute(jj->asString());
-            if (attr == INVALID_ATTRIBUTE) {
-                errmsg = "unknown attribute received";
-                return UNKNOWN_VERSION;
+        for (const auto &jj : attrs) {
+            ErrorAttribute attr = getAttribute(jj.asString());
+            if (attr != INVALID_ATTRIBUTE) {
+                error.attributes.insert(attr);
             }
-            error.attributes.insert(attr);
         }
         if (error.hasAttribute(AUTO_RETRY)) {
             const Json::Value &retryJson = errorJson["retry"];

package/deps/lcb/src/errmap.h

@@ -124,7 +124,11 @@ enum ErrorAttribute {
      * This attribute means that the error is related to operating on                                                  \
      * a soft-deleted document.                                                                                        \
      */                                                                                                                \
-    X(ITEM_DELETED, "item-deleted")
+    X(ITEM_DELETED, "item-deleted")                                                                                    \
+    /**                                                                                                                \
+     * The error is related to rate limitation for the client (version 2)                                              \
+     */                                                                                                                \
+    X(ITEM_RATE_LIMIT, "rate-limit")
 
 #define X(c, s) c,
     LCB_XERRMAP_ATTRIBUTES(X)
@@ -221,7 +225,7 @@ struct Error {
     uint16_t code;
     std::string shortname;
     std::string description;
-    std::set< ErrorAttribute > attributes;
+    std::set<ErrorAttribute> attributes;
     SpecWrapper retry;
 
     Error() : code(-1) {}
@@ -280,7 +284,7 @@ class ErrorMap
   private:
     static const uint32_t MAX_VERSION;
     ErrorMap(const ErrorMap &);
-    typedef std::map< uint16_t, Error > MapType;
+    typedef std::map<uint16_t, Error> MapType;
     MapType errors;
     uint32_t revision{0};
     uint32_t version{0};

package/deps/lcb/src/handler.cc

@@ -157,6 +157,13 @@ lcb_STATUS lcb_map_error(lcb_INSTANCE *instance, int in)
             return LCB_ERR_DURABILITY_AMBIGUOUS;
         case PROTOCOL_BINARY_RESPONSE_LOCKED:
             return LCB_ERR_DOCUMENT_LOCKED;
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_INGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_NETWORK_EGRESS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_CONNECTIONS:
+        case PROTOCOL_BINARY_RATE_LIMITED_MAX_COMMANDS:
+            return LCB_ERR_RATE_LIMITED;
+        case PROTOCOL_BINARY_SCOPE_SIZE_LIMIT_EXCEEDED:
+            return LCB_ERR_QUOTA_LIMITED;
         default:
             if (instance != nullptr) {
                 return instance->callbacks.errmap(instance, in);
@@ -269,20 +276,19 @@ void init_resp(lcb_INSTANCE *instance, mc_PIPELINE *pipeline, const MemcachedRes
         resp->ctx.key.assign(key, key_len);
     }
 
-    auto *server = static_cast<lcb::Server *>(pipeline);
+    const auto *server = static_cast<lcb::Server *>(pipeline);
     const lcb_host_t *remote = server->curhost;
     if (remote) {
-        std::stringstream ss;
+        resp->ctx.endpoint.reserve(sizeof(remote->host) + sizeof(remote->port) + 3);
         if (remote->ipv6) {
-            ss << '[';
+            resp->ctx.endpoint.append("[");
         }
-        ss << remote->host;
+        resp->ctx.endpoint.append(remote->host);
         if (remote->ipv6) {
-            ss << ']';
+            resp->ctx.endpoint.append("]");
         }
-        ss << ':';
-        ss << remote->port;
-        resp->ctx.endpoint = ss.str();
+        resp->ctx.endpoint.append(":");
+        resp->ctx.endpoint.append(remote->port);
     }
 }
 
@@ -421,7 +427,7 @@ static void H_get(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse *
 
     void *freeptr = nullptr;
     maybe_decompress(o, response, &resp, &freeptr);
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_GET_END(o, request, response, &resp);
     record_kv_op_latency("get", o, request);
     if (request->flags & MCREQ_F_REQEXT) {
@@ -455,7 +461,7 @@ static void H_exists(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRespons
             resp.seqno = lcb_ntohll(resp.seqno);
         }
     }
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_EXISTS_END(root, request, response, &resp);
     record_kv_op_latency("exists", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_EXISTS);
@@ -555,7 +561,7 @@ static void H_subdoc(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRespons
             handle_error_info(response, resp);
         }
     }
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
 
     if (cbtype == LCB_CALLBACK_SDLOOKUP) {
         record_kv_op_latency("lookup_in", o, request);
@@ -689,7 +695,7 @@ static void H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, MemcachedResponse
     init_resp(root, pipeline, response, packet, immerr, &resp);
     handle_error_info(response, resp);
     handle_mutation_token(root, response, packet, &resp.mt);
-    LCBTRACE_KV_FINISH(pipeline, packet, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, packet, response);
     TRACE_REMOVE_END(root, packet, response, &resp);
     record_kv_op_latency("remove", root, packet);
     invoke_callback(packet, root, &resp, LCB_CALLBACK_REMOVE);
@@ -797,7 +803,7 @@ static void H_observe_seqno(mc_PIPELINE *pipeline, mc_PACKET *request, Memcached
         /* 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, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     invoke_callback(request, root, &resp, LCB_CALLBACK_OBSEQNO);
 }
 
@@ -829,7 +835,7 @@ static void H_store(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse
     resp.rflags |= LCB_RESP_F_EXTDATA | LCB_RESP_F_FINAL;
     handle_mutation_token(root, response, request, &resp.mt);
     TRACE_STORE_END(root, request, response, &resp);
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     record_kv_op_latency_store(root, request, &resp);
     if (request->flags & MCREQ_F_REQEXT) {
         request->u_rdata.exdata->procs->handler(pipeline, request, LCB_CALLBACK_STORE, immerr, &resp);
@@ -854,7 +860,7 @@ static void H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRes
     }
     resp.rflags |= LCB_RESP_F_FINAL;
     resp.ctx.cas = response->cas();
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_ARITHMETIC_END(root, request, response, &resp);
     record_kv_op_latency("arithmetic", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_COUNTER);
@@ -941,7 +947,7 @@ static void H_noop(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse
 {
     lcb_INSTANCE *root = get_instance(pipeline);
     lcb_RESPNOOP resp{};
-    mc_REQDATAEX *exdata = request->u_rdata.exdata;
+    const mc_REQDATAEX *exdata = request->u_rdata.exdata;
 
     make_error(root, &resp, response, immerr, request);
 
@@ -955,7 +961,7 @@ static void H_touch(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedResponse
     init_resp(root, pipeline, response, request, immerr, &resp);
     handle_error_info(response, resp);
     resp.rflags |= LCB_RESP_F_FINAL;
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_TOUCH_END(root, request, response, &resp);
     record_kv_op_latency("touch", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_TOUCH);
@@ -968,7 +974,7 @@ static void H_unlock(mc_PIPELINE *pipeline, mc_PACKET *request, MemcachedRespons
     init_resp(root, pipeline, response, request, immerr, &resp);
     handle_error_info(response, resp);
     resp.rflags |= LCB_RESP_F_FINAL;
-    LCBTRACE_KV_FINISH(pipeline, request, resp, response->duration());
+    lcb::trace::finish_kv_span(pipeline, request, response);
     TRACE_UNLOCK_END(root, request, response, &resp);
     record_kv_op_latency("unlock", root, request);
     invoke_callback(request, root, &resp, LCB_CALLBACK_UNLOCK);

package/deps/lcb/src/hostlist.h

@@ -134,8 +134,8 @@ struct Hostlist {
         return hosts[ix_];
     }
 
-    std::vector<lcb_host_t> hosts;
-    std::vector<const char *> hoststrs;
+    std::vector< lcb_host_t > hosts;
+    std::vector< const char * > hoststrs;
 };
 } // namespace lcb
 typedef lcb::Hostlist *hostlist_t;

package/deps/lcb/src/http/http-priv.h

@@ -36,8 +36,8 @@ namespace http
 
 // Simple object for header key and value
 struct Header {
-    std::string key;
-    std::string value;
+    std::string key{};
+    std::string value{};
     Header(const std::string &key_, const std::string &value_) : key(key_), value(value_) {}
 };
 

package/deps/lcb/src/http/http.cc

@@ -81,14 +81,14 @@ LIBCOUCHBASE_API int lcb_resphttp_is_final(const lcb_RESPHTTP *resp)
 
 LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_create(lcb_CMDHTTP **cmd, lcb_HTTP_TYPE type)
 {
-    *cmd = (lcb_CMDHTTP *)calloc(1, sizeof(lcb_CMDHTTP));
+    *cmd = new lcb_CMDHTTP{};
     (*cmd)->type = type;
     return LCB_SUCCESS;
 }
 
 LIBCOUCHBASE_API lcb_STATUS lcb_cmdhttp_destroy(lcb_CMDHTTP *cmd)
 {
-    free(cmd);
+    delete cmd;
     return LCB_SUCCESS;
 }
 
@@ -729,6 +729,9 @@ Request::Request(lcb_INSTANCE *instance_, const void *cookie, const lcb_CMDHTTP
       callback(lcb_find_callback(instance, LCB_CALLBACK_HTTP)), io(instance->iotable), ioctx(nullptr), timer(nullptr),
       parser(nullptr), user_timeout(cmd->cmdflags & LCB_CMDHTTP_F_CASTMO ? cmd->cas : 0)
 {
+    for (const auto &pair : cmd->headers_) {
+        request_headers.emplace_back(Header(pair.first, pair.second));
+    }
 }
 
 Request::~Request()

package/deps/lcb/src/instance.cc

@@ -322,12 +322,12 @@ static lcb_STATUS setup_ssl(lcb_INSTANCE *obj, const Connspec &params)
 
     if (lcb_getenv_nonempty("LCB_SSL_CACERT", optbuf, sizeof optbuf)) {
         lcb_log(LOGARGS(obj, INFO), "SSL CA certificate %s specified on environment", optbuf);
-        settings->certpath = strdup(optbuf);
+        settings->certpath = lcb_strdup(optbuf);
     }
 
     if (lcb_getenv_nonempty("LCB_SSL_KEY", optbuf, sizeof optbuf)) {
         lcb_log(LOGARGS(obj, INFO), "SSL key %s specified on environment", optbuf);
-        settings->keypath = strdup(optbuf);
+        settings->keypath = lcb_strdup(optbuf);
     }
 
     if (lcb_getenv_nonempty("LCB_SSL_MODE", optbuf, sizeof optbuf)) {
@@ -343,15 +343,15 @@ static lcb_STATUS setup_ssl(lcb_INSTANCE *obj, const Connspec &params)
     }
 
     if (settings->truststorepath == nullptr && !params.truststorepath().empty()) {
-        settings->truststorepath = strdup(params.truststorepath().c_str());
+        settings->truststorepath = lcb_strdup(params.truststorepath().c_str());
     }
 
     if (settings->certpath == nullptr && !params.certpath().empty()) {
-        settings->certpath = strdup(params.certpath().c_str());
+        settings->certpath = lcb_strdup(params.certpath().c_str());
     }
 
     if (settings->keypath == nullptr && !params.keypath().empty()) {
-        settings->keypath = strdup(params.keypath().c_str());
+        settings->keypath = lcb_strdup(params.keypath().c_str());
     }
 
     if (env_policy == -1) {
@@ -484,10 +484,10 @@ lcb_STATUS lcb_create(lcb_INSTANCE **instance, const lcb_CREATEOPTS *options)
 
     if (spec.bucket().empty()) {
         if (type == LCB_TYPE_BUCKET) {
-            settings->bucket = strdup("default");
+            settings->bucket = lcb_strdup("default");
         }
     } else {
-        settings->bucket = strdup(spec.bucket().c_str());
+        settings->bucket = lcb_strdup(spec.bucket().c_str());
     }
 
     if (!spec.username().empty()) {
@@ -635,6 +635,7 @@ static void do_pool_shutdown(io::Pool *pool)
 LIBCOUCHBASE_API
 void lcb_destroy(lcb_INSTANCE *instance)
 {
+    instance->destroying = 1;
 #define DESTROY(fn, fld)                                                                                               \
     if (instance->fld) {                                                                                               \
         fn(instance->fld);                                                                                             \
@@ -665,10 +666,10 @@ void lcb_destroy(lcb_INSTANCE *instance)
     }
 
     if ((pendq = po->items[LCB_PENDTYPE_HTTP])) {
-        for (it = pendq->begin(); it != pendq->end(); ++it) {
-            auto *htreq = reinterpret_cast<http::Request *>(*it);
-            htreq->block_callback();
-            htreq->finish(LCB_ERR_GENERIC);
+        std::vector<void *> requests(pendq->begin(), pendq->end());
+        for (void *request : requests) {
+            auto *htreq = reinterpret_cast<http::Request *>(request);
+            htreq->finish(LCB_ERR_REQUEST_CANCELED);
         }
     }
 
@@ -717,6 +718,14 @@ void lcb_destroy(lcb_INSTANCE *instance)
         } while (!sd.stopped);
     }
 
+    // Once we are done destroying the instance, we need to manually disconnect
+    // the logger from the settings since further work may proceed in the background
+    // with some forms of IO backend, but once lcb_destroy is invoked, the logger
+    // may no longer be valid from the application side.
+    if (instance->settings && instance->settings->logger) {
+        instance->settings->logger = nullptr;
+    }
+
     DESTROY(lcbio_table_unref, iotable)
     DESTROY(lcb_settings_unref, settings)
     DESTROY(lcb_histogram_destroy, kv_timings)

package/deps/lcb/src/internal.h

@@ -17,6 +17,10 @@
 #ifndef LIBCOUCHBASE_INTERNAL_H
 #define LIBCOUCHBASE_INTERNAL_H 1
 
+#ifndef NOMINMAX
+#define NOMINMAX
+#endif
+
 /* System/Standard includes */
 #include "config.h"
 #include <errno.h>
@@ -55,6 +59,7 @@
 #include "tracing/tracing-internal.h"
 
 #include "hostlist.h"
+#include "utilities.h"
 
 #ifdef __cplusplus
 #include <functional>
@@ -132,6 +137,7 @@ struct lcb_st {
     lcbio_pTIMER dtor_timer;     /**< Asynchronous destruction timer */
     lcb_BTYPE btype;             /**< Type of the bucket */
     lcb_COLLCACHE *collcache;    /**< Collection cache */
+    int destroying;              /**< Are we in lcb_destroy() ?*/
 
 #ifdef __cplusplus
     typedef std::map<std::string, lcbcrypto_PROVIDER *> lcb_ProviderMap;
@@ -179,6 +185,9 @@ struct lcb_st {
      */
     inline lcb_STATUS bootstrap(unsigned options)
     {
+        if (destroying) {
+            return LCB_ERR_REQUEST_CANCELED;
+        }
         if (!bs_state) {
             bs_state = new lcb::Bootstrap(this);
         }