couchbase 3.2.4 → 3.2.5

package/deps/lcb/src/n1ql/query_handle.cc

@@ -95,8 +95,8 @@ static void prepare_rowcb(lcb_INSTANCE *instance, int, const lcb_RESPQUERY *row)
 
 bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &rc)
 {
-    first_error_message.clear();
-    first_error_code = 0;
+    first_error.message.clear();
+    first_error.code = 0;
 
     Json::Value meta;
     if (!Json::Reader(Json::Features::strictMode()).parse(row, row + row_len, meta)) {
@@ -105,22 +105,42 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
     const Json::Value &errors = meta["errors"];
     if (errors.isArray() && !errors.empty()) {
         const Json::Value &err = errors[0];
+        if (err.isMember("retry") && err["retry"].isBool()) {
+            first_error.retry = err["retry"].asBool();
+        }
+        if (err.isMember("reason") && err["reason"].isObject()) {
+            const Json::Value &reason = err["reason"];
+            if (reason.isMember("code") && reason["code"].isNumeric()) {
+                first_error.reason_code = reason["code"].asInt();
+            }
+        }
         const Json::Value &msg = err["msg"];
         if (msg.isString()) {
-            first_error_message = msg.asString();
+            first_error.message = msg.asString();
         }
         const Json::Value &code = err["code"];
         if (code.isNumeric()) {
-            first_error_code = code.asUInt();
-            switch (first_error_code) {
+            first_error.code = code.asUInt();
+            switch (first_error.code) {
                 case 3000:
                     rc = LCB_ERR_PARSING_FAILURE;
                     break;
                 case 12009:
                     rc = LCB_ERR_DML_FAILURE;
-                    if (first_error_message.find("CAS mismatch") != std::string::npos) {
+                    if (first_error.message.find("CAS mismatch") != std::string::npos) {
                         rc = LCB_ERR_CAS_MISMATCH;
                     }
+                    switch (first_error.reason_code) {
+                        case 12033:
+                            rc = LCB_ERR_CAS_MISMATCH;
+                            break;
+                        case 17014:
+                            rc = LCB_ERR_DOCUMENT_NOT_FOUND;
+                            break;
+                        case 17012:
+                            rc = LCB_ERR_DOCUMENT_EXISTS;
+                            break;
+                    }
                     break;
                 case 4040:
                 case 4050:
@@ -132,31 +152,34 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
                     break;
                 case 4300:
                     rc = LCB_ERR_PLANNING_FAILURE;
-                    if (!first_error_message.empty()) {
+                    if (!first_error.message.empty()) {
                         std::regex already_exists("index.+already exists");
-                        if (std::regex_search(first_error_message, already_exists)) {
+                        if (std::regex_search(first_error.message, already_exists)) {
                             rc = LCB_ERR_INDEX_EXISTS;
                         }
                     }
                     break;
                 case 5000:
                     rc = LCB_ERR_INTERNAL_SERVER_FAILURE;
-                    if (!first_error_message.empty()) {
+                    if (!first_error.message.empty()) {
                         std::regex already_exists("Index.+already exists"); /* NOTE: case sensitive */
                         std::regex not_found("index.+not found");
-                        if (std::regex_search(first_error_message, already_exists)) {
+                        if (std::regex_search(first_error.message, already_exists)) {
                             rc = LCB_ERR_INDEX_EXISTS;
-                        } else if (std::regex_search(first_error_message, not_found)) {
+                        } else if (std::regex_search(first_error.message, not_found)) {
                             rc = LCB_ERR_INDEX_NOT_FOUND;
-                        } else if (first_error_message.find(
+                        } else if (first_error.message.find(
                                        "Limit for number of indexes that can be created per scope has been reached") !=
                                    std::string::npos) {
                             rc = LCB_ERR_QUOTA_LIMITED;
                         }
                     }
                     break;
-                case 12004:
                 case 12016:
+                    /* see MB-50643 */
+                    first_error.retry = false;
+                    /* fallthrough */
+                case 12004:
                     rc = LCB_ERR_INDEX_NOT_FOUND;
                     break;
                 case 12003:
@@ -177,14 +200,14 @@ bool lcb_QUERY_HANDLE_::parse_meta(const char *row, size_t row_len, lcb_STATUS &
                     break;
 
                 default:
-                    if (first_error_code >= 4000 && first_error_code < 5000) {
+                    if (first_error.code >= 4000 && first_error.code < 5000) {
                         rc = LCB_ERR_PLANNING_FAILURE;
-                    } else if (first_error_code >= 5000 && first_error_code < 6000) {
+                    } else if (first_error.code >= 5000 && first_error.code < 6000) {
                         rc = LCB_ERR_INTERNAL_SERVER_FAILURE;
-                    } else if (first_error_code >= 10000 && first_error_code < 11000) {
+                    } else if (first_error.code >= 10000 && first_error.code < 11000) {
                         rc = LCB_ERR_AUTHENTICATION_FAILURE;
-                    } else if ((first_error_code >= 12000 && first_error_code < 13000) ||
-                               (first_error_code >= 14000 && first_error_code < 15000)) {
+                    } else if ((first_error.code >= 12000 && first_error.code < 13000) ||
+                               (first_error.code >= 14000 && first_error.code < 15000)) {
                         rc = LCB_ERR_INDEX_FAILURE;
                     }
                     break;
@@ -218,11 +241,13 @@ void lcb_QUERY_HANDLE_::invoke_row(lcb_RESPQUERY *resp, bool is_last)
         resp->row = static_cast<const char *>(meta_buf.iov_base);
         resp->nrow = meta_buf.iov_len;
         parse_meta(resp->row, resp->nrow, resp->ctx.rc);
-        if (!first_error_message.empty()) {
-            resp->ctx.first_error_message = first_error_message.c_str();
-            resp->ctx.first_error_message_len = first_error_message.size();
+        resp->ctx.error_response_body = resp->row;
+        resp->ctx.error_response_body_len = resp->nrow;
+        if (!first_error.message.empty()) {
+            resp->ctx.first_error_message = first_error.message.c_str();
+            resp->ctx.first_error_message_len = first_error.message.size();
         }
-        resp->ctx.first_error_code = first_error_code;
+        resp->ctx.first_error_code = first_error.code;
         if (span_ != nullptr) {
             lcb::trace::finish_http_span(span_, this);
             span_ = nullptr;
@@ -358,27 +383,27 @@ lcb_RETRY_ACTION lcb_QUERY_HANDLE_::has_retriable_error(lcb_STATUS &rc)
     const uint32_t default_backoff = 100 /* ms */;
     if (rc == LCB_ERR_PREPARED_STATEMENT_FAILURE) {
         lcb_log(LOGARGS(this, TRACE), LOGFMT "Will retry request. rc: %s, code: %d, msg: %s", LOGID(this),
-                lcb_strerror_short(rc), first_error_code, first_error_message.c_str());
+                lcb_strerror_short(rc), first_error.code, first_error.message.c_str());
         return {1, default_backoff};
     }
-    if (first_error_code == 13014 &&
+    if (first_error.code == 13014 &&
         LCBT_SETTING(instance_, auth)->mode() == LCBAUTH_MODE_DYNAMIC) { // datastore.couchbase.insufficient_credentials
         auto result = request_credentials(LCBAUTH_REASON_AUTHENTICATION_FAILURE);
         bool credentials_found = result == LCBAUTH_RESULT_OK;
         lcb_log(LOGARGS(this, TRACE),
                 LOGFMT "Invalidate credentials and retry request. creds: %s, rc: %s, code: %d, msg: %s", LOGID(this),
-                credentials_found ? "ok" : "not_found", lcb_strerror_short(rc), first_error_code,
-                first_error_message.c_str());
+                credentials_found ? "ok" : "not_found", lcb_strerror_short(rc), first_error.code,
+                first_error.message.c_str());
         return {credentials_found, default_backoff};
     }
-    if (!first_error_message.empty()) {
+    if (!first_error.message.empty()) {
         for (const auto &magic_string : wtf_magic_strings) {
-            if (first_error_message.find(magic_string) != std::string::npos) {
+            if (first_error.message.find(magic_string) != std::string::npos) {
                 lcb_log(LOGARGS(this, TRACE),
                         LOGFMT
                         "Special error message detected. Will retry request. rc: %s (update to %s), code: %d, msg: %s",
                         LOGID(this), lcb_strerror_short(rc), lcb_strerror_short(LCB_ERR_PREPARED_STATEMENT_FAILURE),
-                        first_error_code, first_error_message.c_str());
+                        first_error.code, first_error.message.c_str());
                 rc = LCB_ERR_PREPARED_STATEMENT_FAILURE;
                 return {1, default_backoff};
             }
@@ -388,7 +413,7 @@ lcb_RETRY_ACTION lcb_QUERY_HANDLE_::has_retriable_error(lcb_STATUS &rc)
     if (rc == LCB_SUCCESS) {
         return {0, 0};
     }
-    return lcb_query_should_retry(instance_->settings, this, rc);
+    return lcb_query_should_retry(instance_->settings, this, rc, first_error.retry);
 }
 
 lcb_STATUS lcb_QUERY_HANDLE_::issue_htreq(const std::string &body)

package/deps/lcb/src/n1ql/query_handle.hh

@@ -27,6 +27,19 @@
 #include "capi/cmd_query.hh"
 #include "query_cache.hh"
 
+/**
+ * @private
+ */
+namespace lcb
+{
+struct query_error {
+    std::string message{};
+    uint32_t code{};
+    bool retry{false};
+    uint32_t reason_code{0};
+};
+} // namespace lcb
+
 /**
  * @private
  */
@@ -296,8 +309,7 @@ struct lcb_QUERY_HANDLE_ : lcb::jsparse::Parser::Actions {
     /** String of the original statement. Cached here to avoid jsoncpp lookups */
     std::string statement_;
     std::string client_context_id_;
-    std::string first_error_message{};
-    uint32_t first_error_code{};
+    lcb::query_error first_error{};
 
     /** Whether we're retrying this */
     int retries_{0};

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

@@ -141,6 +141,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of(lcb_CMDCOUNTER *cmd, con
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdcounter_on_behalf_of_extra_privilege(lcb_CMDCOUNTER *cmd, const char *privilege,
+                                                                        size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS counter_validate(lcb_INSTANCE *instance, const lcb_CMDCOUNTER *cmd)
 {
     if (cmd->key().empty()) {
@@ -184,6 +190,12 @@ static lcb_STATUS counter_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_C
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;

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

@@ -112,6 +112,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of(lcb_CMDEXISTS *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdexists_on_behalf_of_extra_privilege(lcb_CMDEXISTS *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS exists_validate(lcb_INSTANCE *instance, const lcb_CMDEXISTS *cmd)
 {
     if (cmd->key().empty()) {
@@ -139,6 +145,12 @@ static lcb_STATUS exists_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;

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

@@ -129,6 +129,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of(lcb_CMDGET *cmd, const char
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdget_on_behalf_of_extra_privilege(lcb_CMDGET *cmd, const char *privilege,
+                                                                    size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS get_validate(lcb_INSTANCE *instance, const lcb_CMDGET *cmd)
 {
     if (cmd->key().empty()) {
@@ -159,6 +165,12 @@ static lcb_STATUS get_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMDGE
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;

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

@@ -144,6 +144,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of(lcb_CMDGETREPLICA *cm
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdgetreplica_on_behalf_of_extra_privilege(lcb_CMDGETREPLICA *cmd,
+                                                                           const char *privilege, size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 struct RGetCookie : mc_REQDATAEX {
     RGetCookie(void *cookie, lcb_INSTANCE *instance, get_replica_mode, int vb);
     void decref()
@@ -349,20 +355,26 @@ static lcb_STATUS get_replica_schedule(lcb_INSTANCE *instance, std::shared_ptr<l
         return LCB_ERR_NO_MATCHING_SERVER;
     }
 
-    /* Initialize the cookie */
-    auto *rck = new RGetCookie(cmd->cookie(), instance, cmd->mode(), vbid);
-    rck->start = cmd->start_time_or_default_in_nanoseconds(gethrtime());
-    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;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
+    /* Initialize the cookie */
+    auto *rck = new RGetCookie(cmd->cookie(), instance, cmd->mode(), vbid);
+    rck->start = cmd->start_time_or_default_in_nanoseconds(gethrtime());
+    rck->deadline =
+        rck->start + cmd->timeout_or_default_in_nanoseconds(LCB_US2NS(LCBT_SETTING(instance, operation_timeout)));
+
     /* Initialize the packet */
     req.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;
     req.request.opcode = PROTOCOL_BINARY_CMD_GET_REPLICA;

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

@@ -117,6 +117,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of(lcb_CMDREMOVE *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdremove_on_behalf_of_extra_privilege(lcb_CMDREMOVE *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS remove_validate(lcb_INSTANCE *instance, const lcb_CMDREMOVE *cmd)
 {
     if (cmd->key().empty()) {
@@ -159,6 +165,12 @@ static lcb_STATUS remove_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;

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

@@ -234,6 +234,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of(lcb_CMDSTORE *cmd, const c
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdstore_on_behalf_of_extra_privilege(lcb_CMDSTORE *cmd, const char *privilege,
+                                                                      size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 struct DurStoreCtx : mc_REQDATAEX {
     lcb_INSTANCE *instance;
     lcb_U16 persist_to;
@@ -400,6 +406,12 @@ static lcb_STATUS store_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, 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;

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

@@ -409,6 +409,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of(lcb_CMDSUBDOC *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdsubdoc_on_behalf_of_extra_privilege(lcb_CMDSUBDOC *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 namespace SubdocCmdTraits
 {
 enum Options {
@@ -798,6 +804,12 @@ static lcb_STATUS subdoc_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         if (rc != LCB_SUCCESS) {
             return rc;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            rc = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, 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());

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

@@ -117,6 +117,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of(lcb_CMDTOUCH *cmd, const c
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdtouch_on_behalf_of_extra_privilege(lcb_CMDTOUCH *cmd, const char *privilege,
+                                                                      size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS touch_validate(lcb_INSTANCE *instance, const lcb_CMDTOUCH *cmd)
 {
     if (cmd->key().empty()) {
@@ -142,6 +148,12 @@ static lcb_STATUS touch_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CMD
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;

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

@@ -106,6 +106,12 @@ LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of(lcb_CMDUNLOCK *cmd, const
     return cmd->on_behalf_of(std::string(data, data_len));
 }
 
+LIBCOUCHBASE_API lcb_STATUS lcb_cmdunlock_on_behalf_of_extra_privilege(lcb_CMDUNLOCK *cmd, const char *privilege,
+                                                                       size_t privilege_len)
+{
+    return cmd->on_behalf_of_add_extra_privilege(std::string(privilege, privilege_len));
+}
+
 static lcb_STATUS unlock_validate(lcb_INSTANCE *instance, const lcb_CMDUNLOCK *cmd)
 {
     if (cmd->key().empty()) {
@@ -137,6 +143,12 @@ static lcb_STATUS unlock_schedule(lcb_INSTANCE *instance, std::shared_ptr<lcb_CM
         if (err != LCB_SUCCESS) {
             return err;
         }
+        for (const auto &privilege : cmd->extra_privileges()) {
+            err = lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(privilege, framing_extras);
+            if (err != LCB_SUCCESS) {
+                return err;
+            }
+        }
     }
 
     hdr.request.magic = framing_extras.empty() ? PROTOCOL_BINARY_REQ : PROTOCOL_BINARY_AREQ;

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

@@ -97,8 +97,7 @@ void lcb_SEARCH_HANDLE_::invoke_row(lcb_RESPSEARCH *resp)
                     } else if (resp->ctx.http_response_code == 400) {
                         if (error_message_.find("not_found") != std::string::npos) {
                             resp->ctx.rc = LCB_ERR_INDEX_NOT_FOUND;
-                        } else if (error_message_.find("CreateIndex, Prepare failed, err: num_fts_indexes") !=
-                                   std::string::npos) {
+                        } else if (error_message_.find("num_fts_indexes") != std::string::npos) {
                             resp->ctx.rc = LCB_ERR_QUOTA_LIMITED;
                         }
                     } else if (resp->ctx.http_response_code == 429) {

package/deps/lcb/src/ssl/ssl_common.c

@@ -359,7 +359,7 @@ lcbio_pSSLCTX lcbio_ssl_new(const char *tsfile, const char *cafile, const char *
         }
         if (cafile && keyfile) {
             lcb_log(LOGARGS_S(settings, LCB_LOG_DEBUG), "Authenticate with key \"%s\", cert \"%s\"", keyfile, cafile);
-            if (!SSL_CTX_use_certificate_file(ret->ctx, cafile, SSL_FILETYPE_PEM)) {
+            if (!SSL_CTX_use_certificate_chain_file(ret->ctx, cafile)) {
                 *errp = LCB_ERR_SSL_ERROR;
                 goto GT_ERR;
             }

package/deps/lcb/src/utilities.cc

@@ -214,3 +214,24 @@ lcb_STATUS lcb::flexible_framing_extras::encode_impersonate_user(const std::stri
     }
     return LCB_SUCCESS;
 }
+
+lcb_STATUS lcb::flexible_framing_extras::encode_impersonate_users_extra_privilege(
+    const std::string &privilege, std::vector<std::uint8_t> &flexible_framing_extras)
+{
+    auto privilege_len = privilege.size();
+    if (privilege_len > std::numeric_limits<std::uint8_t>::max() + 0xfU) {
+        return LCB_ERR_INVALID_ARGUMENT;
+    }
+    std::uint8_t frame_id = 0x06;
+    if (privilege_len < 15) {
+        auto frame_size = static_cast<std::uint8_t>(privilege_len);
+        flexible_framing_extras.emplace_back(frame_id << 4U | frame_size);
+    } else {
+        flexible_framing_extras.emplace_back(frame_id << 4U | 0xfU);
+        flexible_framing_extras.emplace_back(privilege_len - 0xfU);
+    }
+    for (const auto byte : privilege) {
+        flexible_framing_extras.emplace_back(byte);
+    }
+    return LCB_SUCCESS;
+}

package/deps/lcb/src/utilities.h

@@ -29,6 +29,9 @@ namespace lcb
 namespace flexible_framing_extras
 {
 lcb_STATUS encode_impersonate_user(const std::string &username, std::vector<std::uint8_t> &flexible_framing_extras);
+
+lcb_STATUS encode_impersonate_users_extra_privilege(const std::string &privilege,
+                                                    std::vector<std::uint8_t> &flexible_framing_extras);
 } // namespace flexible_framing_extras
 } // namespace lcb
 

package/deps/lcb/tests/iotests/mock-environment.cc

@@ -423,7 +423,16 @@ static void statsCallback(lcb_INSTANCE *instance, lcb_CALLBACK_TYPE, const lcb_R
                 }
                 break;
             case 7:
-                version = MockEnvironment::VERSION_70;
+                switch (minor) {
+                    case 0:
+                        version = MockEnvironment::VERSION_70;
+                        break;
+                    case 1:
+                        version = MockEnvironment::VERSION_71;
+                        break;
+                    default:
+                        break;
+                }
                 break;
             default:
                 break;

package/deps/lcb/tests/iotests/mock-environment.h

@@ -246,7 +246,8 @@ class MockEnvironment : public ::testing::Environment
         VERSION_60 = 10,
         VERSION_65 = 11,
         VERSION_66 = 12,
-        VERSION_70 = 13
+        VERSION_70 = 13,
+        VERSION_71 = 14,
     };
 
     void SetUp() override;

package/deps/lcb/tests/iotests/serverparams.h

@@ -37,10 +37,15 @@ class ServerParams
     void makeConnectParams(lcb_CREATEOPTS *&crst, lcb_io_opt_t io, lcb_INSTANCE_TYPE type = LCB_TYPE_BUCKET)
     {
         lcb_createopts_create(&crst, type);
-        if (host.find("couchbase://") == 0) {
+        if (host.find("couchbase") == 0) {
             connstr = host;
             // deactivate dnssrv and compression, use cccp bootstrap
-            connstr += "?dnssrv=off&bootstrap_on=cccp&compression=off";
+            if (host.find("?") == std::string::npos) {
+                connstr += "?";
+            } else {
+                connstr += "&";
+            }
+            connstr += "dnssrv=off&bootstrap_on=cccp&compression=off";
         } else {
             if (mcNodes.empty() || type == LCB_TYPE_CLUSTER) {
                 connstr = "couchbase://" + host + "=http";