couchbase 3.2.0 → 3.2.4

package/deps/lcb/src/operations/get_replica.cc

@@ -19,7 +19,6 @@
 
 #include "internal.h"
 #include "collections.h"
-#include "trace.h"
 #include "defer.h"
 
 #include "capi/cmd_get.hh"
@@ -140,6 +139,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_key(lcb_CMDGETREPLICA *cmd, const
     return cmd->key(std::string(key, key_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of(lcb_CMDGETREPLICA *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 struct RGetCookie : mc_REQDATAEX {
     RGetCookie(void *cookie, lcb_INSTANCE *instance, get_replica_mode, int vb);
     void decref()
@@ -248,7 +252,7 @@ static lcb_STATUS get_replica_validate(lcb_INSTANCE *instance, const lcb_CMDGETR
 
     mc_CMDQUEUE *cq = &instance->cmdq;
     int vbid, ixtmp;
-    unsigned r0, r1 = 0;
+    unsigned r0 = 0, r1 = 0;
 
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
     mcreq_map_key(cq, &keybuf, MCREQ_PKT_BASESIZE, &vbid, &ixtmp);
@@ -299,8 +303,8 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
      */
     mc_CMDQUEUE *cq = &instance->cmdq;
     int vbid, ixtmp;
-    protocol_binary_request_header req;
-    unsigned r0, r1 = 0;
+    protocol_binary_request_header req{};
+    unsigned r0 = 0, r1 = 0;
 
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
     mcreq_map_key(cq, &keybuf, MCREQ_PKT_BASESIZE, &vbid, &ixtmp);
@@ -351,14 +355,24 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
     rck->deadline =
         rck->start + cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
 
+    std::vector<std::uint8_t> framing_extras;
+    if (cmd->want_impersonation()) {
+        lcb_STATUS err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+    }
+
     /* Initialize the packet */
-    req.request.magic = PROTOCOL_BINARY_REQ;
+    req.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
     req.request.opcode = PROTOCOL_BINARY_CMD_GET_REPLICA;
     req.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
     req.request.vbucket = htons(static_cast<std::uint16_t>(vbid));
     req.request.cas = 0;
     req.request.extlen = 0;
 
+    auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
+
     rck->r_cur = r0;
     do {
         int curix;
@@ -380,13 +394,16 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
         pkt->u_rdata.exdata = rck;
         pkt->flags |= MCREQ_F_REQEXT;
 
-        mcreq_reserve_key(pl, pkt, sizeof(req.bytes), &keybuf, cmd->collection().collection_id());
+        mcreq_reserve_key(pl, pkt, sizeof(req.bytes) + ffextlen, &keybuf, cmd->collection().collection_id());
         size_t nkey = pkt->kh_span.size - MCREQ_PKT_BASESIZE + pkt->extlen;
         req.request.keylen = htons((uint16_t)nkey);
         req.request.bodylen = htonl((uint32_t)nkey);
         req.request.opaque = pkt->opaque;
         rck->remaining++;
         mcreq_write_hdr(pkt, &req);
+        if (!framing_extras.empty()) {
+            memcpy(SPAN_BUFFER(&pkt->kh_span) + sizeof(req.bytes), framing_extras.data(), framing_extras.size());
+        }
         mcreq_sched_add(pl, pkt);
     } while (++r0 < r1);
 
@@ -394,8 +411,8 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
         req.request.opcode = PROTOCOL_BINARY_CMD_GET;
         mc_PIPELINE *pl;
         mc_PACKET *pkt;
-        lcb_STATUS err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &req, 0, 0, &pkt, &pl,
-                                            MCREQ_BASICPACKET_F_FALLBACKOK);
+        lcb_STATUS err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &req, 0, ffextlen, &pkt,
+                                            &pl, MCREQ_BASICPACKET_F_FALLBACKOK);
         if (err != LCB_SUCCESS) {
             delete rck;
             return err;
@@ -405,6 +422,9 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
         pkt->flags |= MCREQ_F_REQEXT;
         rck->remaining++;
         mcreq_write_hdr(pkt, &req);
+        if (!framing_extras.empty()) {
+            memcpy(SPAN_BUFFER(&pkt->kh_span) + sizeof(req.bytes), framing_extras.data(), framing_extras.size());
+        }
         mcreq_sched_add(pl, pkt);
     }
 

package/deps/lcb/src/operations/observe.cc

@@ -129,7 +129,7 @@ static void handle_observe_callback(mc_PIPELINE *pl, mc_PACKET *pkt, lcb_CALLBAC
     opc->remaining--;
     if (opc->remaining == 0) {
         TRACE_OBSERVE_END(instance, pkt);
-        LCBTRACE_KV_FINISH(pl, pkt, resp, 0);
+        lcb::trace::finish_kv_span(pl, pkt, nullptr);
         delete opc;
     }
 }

package/deps/lcb/src/operations/ping.cc

@@ -426,7 +426,7 @@ static void handle_ping(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_CALLBACK_TYPE
             } else {
                 hh.append(remote.host).append(":").append(remote.port);
             }
-            svc.server = strdup(hh.c_str());
+            svc.server = lcb_strdup(hh.c_str());
         }
         svc.type = LCB_PING_SERVICE_KV;
         svc.latency = gethrtime() - MCREQ_PKT_RDATA(req)->start;
@@ -445,9 +445,9 @@ static void handle_ping(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_CALLBACK_TYPE
         lcbio_CTX *ctx = server->connctx;
         if (ctx) {
             char id[20] = {0};
-            svc.local = strdup(ctx->sock->info->ep_local);
+            svc.local = lcb_strdup(ctx->sock->info->ep_local_host_and_port);
             snprintf(id, sizeof(id), "%p", (void *)ctx->sock);
-            svc.id = strdup(id);
+            svc.id = lcb_strdup(id);
         }
         svc.scope = server->get_instance()->get_bucketname();
 
@@ -477,7 +477,7 @@ static void handle_http(lcb_INSTANCE *instance, lcb_PING_SERVICE type, const lcb
         } else {
             hh = std::string(htreq->host) + ":" + std::string(htreq->port);
         }
-        svc.server = strdup(hh.c_str());
+        svc.server = lcb_strdup(hh.c_str());
         svc.latency = gethrtime() - htreq->start;
         svc.rc = resp->ctx.rc;
         switch (resp->ctx.rc) {
@@ -495,8 +495,8 @@ static void handle_http(lcb_INSTANCE *instance, lcb_PING_SERVICE type, const lcb
         if (ctx) {
             char id[20] = {0};
             snprintf(id, sizeof(id), "%p", (void *)ctx->sock);
-            svc.id = strdup(id);
-            svc.local = strdup(ctx->sock->info->ep_local);
+            svc.id = lcb_strdup(id);
+            svc.local = lcb_strdup(ctx->sock->info->ep_local_host_and_port);
         }
         ck->responses.push_back(svc);
     }
@@ -759,7 +759,7 @@ lcb_STATUS lcb_diag(lcb_INSTANCE *instance, void *cookie, const lcb_CMDDIAG *cmd
             }
             if (ctx->sock) {
                 if (ctx->sock->info) {
-                    endpoint["local"] = ctx->sock->info->ep_local;
+                    endpoint["local"] = ctx->sock->info->ep_local_host_and_port;
                 }
                 endpoint["last_activity_us"] =
                     (Json::Value::UInt64)(now > ctx->sock->atime ? now - ctx->sock->atime : 0);
@@ -790,7 +790,7 @@ lcb_STATUS lcb_diag(lcb_INSTANCE *instance, void *cookie, const lcb_CMDDIAG *cmd
                     }
                     if (ctx->sock) {
                         if (ctx->sock->info) {
-                            endpoint["local"] = ctx->sock->info->ep_local;
+                            endpoint["local"] = ctx->sock->info->ep_local_host_and_port;
                         }
                         endpoint["last_activity_us"] =
                             (Json::Value::UInt64)(now > ctx->sock->atime ? now - ctx->sock->atime : 0);

package/deps/lcb/src/operations/pktfwd.cc

@@ -66,7 +66,8 @@ lcb_STATUS lcb_pktfwd3(lcb_INSTANCE *instance, const void *cookie, const lcb_CMD
     /* set the cookie */
     packet->u_rdata.reqdata.cookie = cookie;
     packet->u_rdata.reqdata.start = gethrtime();
-    packet->u_rdata.reqdata.deadline = packet->u_rdata.reqdata.start + LCB_US2NS(LCBT_SETTING(instance, operation_timeout));
+    packet->u_rdata.reqdata.deadline =
+        packet->u_rdata.reqdata.start + LCB_US2NS(LCBT_SETTING(instance, operation_timeout));
     return err;
 }
 

package/deps/lcb/src/operations/remove.cc

@@ -112,6 +112,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_durability(lcb_CMDREMOVE *cmd, lcb_DUR
     return cmd->durability_level(level);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of(lcb_CMDREMOVE *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 static lcb_STATUS remove_validate(lcb_INSTANCE *instance, const lcb_CMDREMOVE *cmd)
 {
     if (cmd->key().empty()) {
@@ -132,37 +137,45 @@ static lcb_STATUS remove_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
     mc_CMDQUEUE *cq = &instance->cmdq;
     mc_PIPELINE *pl;
     mc_PACKET *pkt;
-    protocol_binary_request_delete req{};
-    protocol_binary_request_header *hdr = &req.message.header;
     int new_durability_supported = LCBT_SUPPORT_SYNCREPLICATION(instance);
-    lcb_U8 ffextlen = 0;
-    size_t hsize;
     lcb_STATUS err;
 
-    hdr->request.magic = PROTOCOL_BINARY_REQ;
+    protocol_binary_request_header hdr{};
+
+    std::vector<std::uint8_t> framing_extras;
     if (new_durability_supported && cmd->has_durability_requirements()) {
-        hdr->request.magic = PROTOCOL_BINARY_AREQ;
-        ffextlen = 4;
+        auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
+        std::uint8_t frame_id = 0x01;
+        std::uint8_t frame_size = durability_timeout > 0 ? 3 : 1;
+        framing_extras.emplace_back(frame_id << 4U | frame_size);
+        framing_extras.emplace_back(cmd->durability_level());
+        if (durability_timeout > 0) {
+            framing_extras.emplace_back(durability_timeout >> 8U);
+            framing_extras.emplace_back(durability_timeout & 0xff);
+        }
+    }
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
     }
 
+    hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
+    auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
+
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
-    err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), hdr, 0, ffextlen, &pkt, &pl,
+    err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &hdr, 0, ffextlen, &pkt, &pl,
                              MCREQ_BASICPACKET_F_FALLBACKOK);
     if (err != LCB_SUCCESS) {
         return err;
     }
-    hsize = hdr->request.extlen + sizeof(*hdr) + ffextlen;
 
-    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr->request.opcode = PROTOCOL_BINARY_CMD_DELETE;
-    hdr->request.cas = lcb_htonll(cmd->cas());
-    hdr->request.opaque = pkt->opaque;
-    hdr->request.bodylen = htonl(ffextlen + hdr->request.extlen + mcreq_get_key_size(hdr));
-    if (new_durability_supported && cmd->has_durability_requirements()) {
-        req.message.body.alt.meta = (1u << 4u) | 3u;
-        req.message.body.alt.level = cmd->durability_level();
-        req.message.body.alt.timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
-    }
+    hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr.request.opcode = PROTOCOL_BINARY_CMD_DELETE;
+    hdr.request.cas = lcb_htonll(cmd->cas());
+    hdr.request.opaque = pkt->opaque;
+    hdr.request.bodylen = htonl(ffextlen + hdr.request.extlen + mcreq_get_key_size(&hdr));
 
     pkt->flags |= MCREQ_F_REPLACE_SEMANTICS;
     pkt->u_rdata.reqdata.cookie = cmd->cookie();
@@ -170,9 +183,13 @@ static lcb_STATUS remove_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
     pkt->u_rdata.reqdata.deadline =
         pkt->u_rdata.reqdata.start +
         cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
-    memcpy(SPAN_BUFFER(&pkt->kh_span), hdr->bytes, hsize);
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_REMOVE, pkt->u_rdata.reqdata.span);
-    TRACE_REMOVE_BEGIN(instance, hdr, cmd);
+    memcpy(SPAN_BUFFER(&pkt->kh_span), &hdr, sizeof(hdr));
+    std::size_t offset = sizeof(hdr);
+    if (!framing_extras.empty()) {
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
+    }
+    pkt->u_rdata.reqdata.span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
+    TRACE_REMOVE_BEGIN(instance, &hdr, cmd);
     LCB_SCHED_ADD(instance, pl, pkt)
     return LCB_SUCCESS;
 }

package/deps/lcb/src/operations/store.cc

@@ -229,6 +229,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_durability_observe(lcb_CMDSTORE *cmd, i
     return cmd->durability_poll(persist_to, replicate_to);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of(lcb_CMDSTORE *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 struct DurStoreCtx : mc_REQDATAEX {
     lcb_INSTANCE *instance;
     lcb_U16 persist_to;
@@ -375,19 +380,27 @@ static lcb_STATUS store_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
 
     std::vector<std::uint8_t> framing_extras;
     if (new_durability_supported && cmd->has_sync_durability_requirements()) {
+        auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
         std::uint8_t frame_id = 0x01;
-        std::uint8_t frame_size = 0x04;
+        std::uint8_t frame_size = durability_timeout > 0 ? 3 : 1;
         framing_extras.emplace_back(frame_id << 4U | frame_size);
         framing_extras.emplace_back(cmd->durability_level());
-        auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
-        framing_extras.emplace_back(durability_timeout >> 8U);
-        framing_extras.emplace_back(durability_timeout & 0xff);
+        if (durability_timeout > 0) {
+            framing_extras.emplace_back(durability_timeout >> 8U);
+            framing_extras.emplace_back(durability_timeout & 0xff);
+        }
     }
     if (cmd->should_preserve_expiry()) {
         std::uint8_t frame_id = 0x05;
         std::uint8_t frame_size = 0x00;
         framing_extras.emplace_back(frame_id << 4U | frame_size);
     }
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+    }
     auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
     hdr.request.magic = (ffextlen == 0) ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
     hdr.request.opcode = cmd->opcode();
@@ -472,7 +485,7 @@ static lcb_STATUS store_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
     if (cmd->is_replace_semantics()) {
         packet->flags |= MCREQ_F_REPLACE_SEMANTICS;
     }
-    LCBTRACE_KVSTORE_START(instance->settings, packet->opaque, cmd, cmd->operation_name(), rdata->span);
+    rdata->span = lcb::trace::start_kv_span_with_durability(instance->settings, packet, cmd);
     LCB_SCHED_ADD(instance, pipeline, packet)
 
     TRACE_STORE_BEGIN(instance, &hdr, cmd);

package/deps/lcb/src/operations/subdoc.cc

@@ -404,6 +404,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_create_as_deleted(lcb_CMDSUBDOC *cmd,
     return cmd->create_as_deleted(flag);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of(lcb_CMDSUBDOC *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 namespace SubdocCmdTraits
 {
 enum Options {
@@ -772,13 +777,15 @@ static lcb_STATUS subdoc_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         hdr.request.opcode = PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION;
 
         if (new_durability_supported && cmd->has_durability_requirements()) {
+            auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
             std::uint8_t frame_id = 0x01;
-            std::uint8_t frame_size = 0x04;
+            std::uint8_t frame_size = durability_timeout > 0 ? 3 : 1;
             framing_extras.emplace_back(frame_id << 4U | frame_size);
             framing_extras.emplace_back(cmd->durability_level());
-            auto durability_timeout = htons(lcb_durability_timeout(instance, cmd->timeout_in_microseconds()));
-            framing_extras.emplace_back(durability_timeout >> 8U);
-            framing_extras.emplace_back(durability_timeout & 0xff);
+            if (durability_timeout > 0) {
+                framing_extras.emplace_back(durability_timeout >> 8U);
+                framing_extras.emplace_back(durability_timeout & 0xff);
+            }
         }
         if (cmd->should_preserve_expiry()) {
             std::uint8_t frame_id = 0x05;
@@ -786,6 +793,12 @@ static lcb_STATUS subdoc_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
             framing_extras.emplace_back(frame_id << 4U | frame_size);
         }
     }
+    if (cmd->want_impersonation()) {
+        rc = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (rc != LCB_SUCCESS) {
+            return rc;
+        }
+    }
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
     auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
 
@@ -840,8 +853,7 @@ static lcb_STATUS subdoc_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         MCREQ_PKT_RDATA(pkt)->start +
         cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
     MCREQ_PKT_RDATA(pkt)->nsubreq = cmd->specs().specs().size();
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd,
-                      ctx.is_mutate() ? LCBTRACE_OP_MUTATEIN : LCBTRACE_OP_LOOKUPIN, MCREQ_PKT_RDATA(pkt)->span);
+    MCREQ_PKT_RDATA(pkt)->span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt)
     return LCB_SUCCESS;
 }

package/deps/lcb/src/operations/touch.cc

@@ -112,6 +112,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_durability(lcb_CMDTOUCH * /* cmd */, lc
     return LCB_ERR_UNSUPPORTED_OPERATION;
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of(lcb_CMDTOUCH *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 static lcb_STATUS touch_validate(lcb_INSTANCE *instance, const lcb_CMDTOUCH *cmd)
 {
     if (cmd->key().empty()) {
@@ -126,39 +131,52 @@ static lcb_STATUS touch_validate(lcb_INSTANCE *instance, const lcb_CMDTOUCH *cmd
 
 static lcb_STATUS touch_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDTOUCH> cmd)
 {
-    protocol_binary_request_touch tcmd;
-    protocol_binary_request_header *hdr = &tcmd.message.header;
+    protocol_binary_request_header hdr{};
     mc_PIPELINE *pl;
     mc_PACKET *pkt;
     lcb_STATUS err;
-    lcb_U8 ffextlen = 0;
-    size_t hsize;
+
+    std::vector<std::uint8_t> framing_extras;
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+    }
+
+    hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
+    auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
 
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
-    err = mcreq_basic_packet(&instance->cmdq, &keybuf, cmd->collection().collection_id(), hdr, 4, ffextlen, &pkt, &pl,
+    err = mcreq_basic_packet(&instance->cmdq, &keybuf, cmd->collection().collection_id(), &hdr, 4, ffextlen, &pkt, &pl,
                              MCREQ_BASICPACKET_F_FALLBACKOK);
     if (err != LCB_SUCCESS) {
         return err;
     }
-    hsize = hdr->request.extlen + sizeof(*hdr) + ffextlen;
 
-    hdr->request.magic = PROTOCOL_BINARY_REQ;
-    hdr->request.opcode = PROTOCOL_BINARY_CMD_TOUCH;
-    hdr->request.cas = 0;
-    hdr->request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr->request.opaque = pkt->opaque;
-    hdr->request.bodylen = htonl(4 + ffextlen + ntohs(hdr->request.keylen));
-    tcmd.message.body.norm.expiration = htonl(cmd->expiry());
+    hdr.request.opcode = PROTOCOL_BINARY_CMD_TOUCH;
+    hdr.request.cas = 0;
+    hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
+    hdr.request.opaque = pkt->opaque;
+    hdr.request.bodylen = htonl(hdr.request.extlen + ffextlen + mcreq_get_key_size(&hdr));
+
+    memcpy(SPAN_BUFFER(&pkt->kh_span), &hdr, sizeof(hdr));
+    std::size_t offset = sizeof(hdr);
+    if (!framing_extras.empty()) {
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
+        offset += framing_extras.size();
+    }
+    std::uint32_t expiry = htonl(cmd->expiry());
+    memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, &expiry, sizeof(expiry));
 
-    memcpy(SPAN_BUFFER(&pkt->kh_span), tcmd.bytes, hsize);
     pkt->u_rdata.reqdata.cookie = cmd->cookie();
     pkt->u_rdata.reqdata.start = cmd->start_time_or_default_in_nanoseconds(gethrtime());
     pkt->u_rdata.reqdata.deadline =
         pkt->u_rdata.reqdata.start +
         cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_TOUCH, pkt->u_rdata.reqdata.span);
+    pkt->u_rdata.reqdata.span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt);
-    TRACE_TOUCH_BEGIN(instance, hdr, cmd);
+    TRACE_TOUCH_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;
 }
 

package/deps/lcb/src/operations/unlock.cc

@@ -101,6 +101,11 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_cas(lcb_CMDUNLOCK *cmd, uint64_t cas)
     return cmd->cas(cas);
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of(lcb_CMDUNLOCK *cmd, const char *data, size_t data_len)
+{
+    return cmd->on_behalf_of(std::string(data, data_len));
+}
+
 static lcb_STATUS unlock_validate(lcb_INSTANCE *instance, const lcb_CMDUNLOCK *cmd)
 {
     if (cmd->key().empty()) {
@@ -124,10 +129,21 @@ static lcb_STATUS unlock_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
     mc_PACKET *pkt;
     mc_REQDATA *rd;
     lcb_STATUS err;
-    protocol_binary_request_header hdr;
+    protocol_binary_request_header hdr{};
+
+    std::vector<std::uint8_t> framing_extras;
+    if (cmd->want_impersonation()) {
+        err = lcb::flexible_framing_extras::encode_impersonate_user(cmd->impostor(), framing_extras);
+        if (err != LCB_SUCCESS) {
+            return err;
+        }
+    }
+
+    hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
+    auto ffextlen = static_cast<std::uint8_t>(framing_extras.size());
 
     lcb_KEYBUF keybuf{LCB_KV_COPY, {cmd->key().c_str(), cmd->key().size()}};
-    err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &hdr, 0, 0, &pkt, &pl,
+    err = mcreq_basic_packet(cq, &keybuf, cmd->collection().collection_id(), &hdr, 0, ffextlen, &pkt, &pl,
                              MCREQ_BASICPACKET_F_FALLBACKOK);
     if (err != LCB_SUCCESS) {
         return err;
@@ -139,15 +155,18 @@ static lcb_STATUS unlock_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
     rd->deadline =
         rd->start + cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
 
-    hdr.request.magic = PROTOCOL_BINARY_REQ;
     hdr.request.opcode = PROTOCOL_BINARY_CMD_UNLOCK_KEY;
     hdr.request.datatype = PROTOCOL_BINARY_RAW_BYTES;
-    hdr.request.bodylen = htonl((lcb_uint32_t)ntohs(hdr.request.keylen));
+    hdr.request.bodylen = htonl(mcreq_get_key_size(&hdr));
     hdr.request.opaque = pkt->opaque;
     hdr.request.cas = lcb_htonll(cmd->cas());
 
     memcpy(SPAN_BUFFER(&pkt->kh_span), hdr.bytes, sizeof(hdr.bytes));
-    LCBTRACE_KV_START(instance->settings, pkt->opaque, cmd, LCBTRACE_OP_TOUCH, rd->span);
+    std::size_t offset = sizeof(hdr);
+    if (!framing_extras.empty()) {
+        memcpy(SPAN_BUFFER(&pkt->kh_span) + offset, framing_extras.data(), framing_extras.size());
+    }
+    rd->span = lcb::trace::start_kv_span(instance->settings, pkt, cmd);
     LCB_SCHED_ADD(instance, pl, pkt);
     TRACE_UNLOCK_BEGIN(instance, &hdr, cmd);
     return LCB_SUCCESS;

package/deps/lcb/src/packetutils.h

@@ -23,6 +23,7 @@
 #include <libcouchbase/couchbase.h>
 #include <memcached/protocol_binary.h>
 #include "rdb/rope.h"
+#include "utilities.h"
 
 #ifndef __cplusplus
 typedef struct packet_info_st packet_info;
@@ -315,10 +316,10 @@ class MemcachedResponse
         }
         std::string emsg;
         if (!jerr["ref"].empty()) {
-            *err_ref = strdup(jerr["ref"].asCString());
+            *err_ref = lcb_strdup(jerr["ref"].asCString());
         }
         if (!jerr["context"].empty()) {
-            *err_ctx = strdup(jerr["context"].asCString());
+            *err_ctx = lcb_strdup(jerr["context"].asCString());
         }
         return LCB_SUCCESS;
     }

package/deps/lcb/src/retryq.cc

@@ -366,14 +366,33 @@ void RetryQueue::add(mc_EXPACKET *pkt, const lcb_STATUS err, protocol_binary_res
             if (server == nullptr) {
                 continue;
             }
+
             /* check pending queue */
-            SLLIST_ITERFOR(&server->nbmgr.sendq.pending, &iter)
             {
-                nb_SNDQELEM *el = SLLIST_ITEM(iter.cur, nb_SNDQELEM, slnode);
-                if (el->parent == op->pkt) {
-                    sllist_iter_remove(&server->nbmgr.sendq.pending, &iter);
+                nb_SENDQ *sq = &server->nbmgr.sendq;
+
+                /* in the case of completion IO, there is a chunk of the sendq which
+                 * has already been written to the network and cannot be cancelled,
+                 * we need to only scan to remove packets which have NOT been sent
+                 * yet.
+                 */
+                sllist_node *ll;
+                if (sq->last_requested) {
+                    ll = sq->last_requested->slnode.next;
+                } else {
+                    ll = SLLIST_FIRST(&sq->pending);
+                }
+                if (ll) {
+                    for (slist_iter_init_at(ll, &iter); !sllist_iter_end(&sq->pending, &iter);
+                         slist_iter_incr(&sq->pending, &iter)) {
+                        nb_SNDQELEM *el = SLLIST_ITEM(iter.cur, nb_SNDQELEM, slnode);
+                        if (el->parent == op->pkt) {
+                            sllist_iter_remove(&sq->pending, &iter);
+                        }
+                    }
                 }
             }
+
             /* check flush queue */
             SLLIST_ITERFOR(&server->nbmgr.sendq.pdus, &iter)
             {
@@ -406,7 +425,7 @@ void RetryQueue::add(mc_EXPACKET *pkt, const lcb_STATUS err, protocol_binary_res
     uint32_t cid = mcreq_get_cid(get_instance(), &pkt->base);
     lcb_log(LOGARGS(this, DEBUG),
             "Adding PKT=%p to retry queue. retries=%u, cid=%u, opaque=%u, now=%" PRIu64 "ms, spent=%" PRIu64
-            "us, deadline_in=%" PRIu64 "us, , status=0x%02x, rc=%s",
+            "us, deadline_in=%" PRIu64 "us, status=0x%02x, rc=%s",
             (void *)pkt, pkt->base.retries, cid, pkt->base.opaque, LCB_NS2MS(now), LCB_NS2US(now - op->start),
             LCB_NS2US(op->deadline - now), status, lcb_strerror_short(err));
     schedule();

package/deps/lcb/src/search/search.cc

@@ -43,6 +43,7 @@ static lcb_STATUS search_execute(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
     auto *req = new lcb_SEARCH_HANDLE_(instance, cmd->cookie(), cmd.get());
     if (req->has_error()) {
         lcb_STATUS rc = req->last_error();
+        req->clear_callback();
         delete req;
         return rc;
     }