couchbase 3.4.0 → 3.4.2

data/ext/couchbase/core/impl/get_all_query_indexes.cxx

@@ -45,7 +45,7 @@ initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                couchbase::get_all_query_indexes_options::built options,
                                query_context query_ctx,
                                std::string collection_name,
-                               get_all_indexes_handler&& handler)
+                               get_all_query_indexes_handler&& handler)
 {
     core->execute(
       operations::management::query_index_get_all_request{
@@ -68,9 +68,9 @@ void
 initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                std::string bucket_name,
                                couchbase::get_all_query_indexes_options::built options,
-                               get_all_indexes_handler&& handler)
+                               get_all_query_indexes_handler&& handler)
 {
     initiate_get_all_query_indexes(core, std::move(bucket_name), options, {}, "", std::move(handler));
 }
 
-} // namespace couchbase::core::impl
+} // namespace couchbase::core::impl

data/ext/couchbase/core/impl/query.cxx

@@ -152,10 +152,10 @@ build_result(operations::query_response& resp)
 }
 
 static core::operations::query_request
-build_query_request(query_options::built options)
+build_query_request(std::string statement, query_options::built options)
 {
     operations::query_request request{
-        "",
+        std::move(statement),
         options.adhoc,
         options.metrics,
         options.readonly,
@@ -222,8 +222,9 @@ build_transaction_query_result(operations::query_response resp, std::error_code
 core::operations::query_request
 build_transaction_query_request(query_options::built opts)
 {
-    return build_query_request(opts);
+    return build_query_request("", opts);
 }
+
 void
 initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          std::string statement,
@@ -231,8 +232,7 @@ initiate_query_operation(std::shared_ptr<couchbase::core::cluster> core,
                          query_options::built options,
                          query_handler&& handler)
 {
-    auto request = build_query_request(options);
-    request.statement = std::move(statement);
+    auto request = build_query_request(std::move(statement), options);
     if (query_context) {
         request.query_context = std::move(query_context);
     }

data/ext/couchbase/core/impl/transaction_get_result.cxx

@@ -0,0 +1,54 @@
+
+
+#include <core/transactions/transaction_get_result.hxx>
+#include <couchbase/transactions/transaction_get_result.hxx>
+
+namespace couchbase::transactions
+{
+
+transaction_get_result::transaction_get_result()
+  : base_(std::make_shared<couchbase::core::transactions::transaction_get_result>())
+{
+}
+
+const std::vector<std::byte>&
+transaction_get_result::content() const
+{
+    return base_->content();
+}
+void
+transaction_get_result::content(std::vector<std::byte> content)
+{
+    return base_->content(content);
+}
+void
+transaction_get_result::content(std::vector<std::byte>&& content)
+{
+    return base_->content(content);
+}
+const std::string
+transaction_get_result::key() const
+{
+    return base_->key();
+}
+const std::string
+transaction_get_result::bucket() const
+{
+    return base_->bucket();
+}
+const std::string
+transaction_get_result::scope() const
+{
+    return base_->scope();
+}
+const std::string
+transaction_get_result::collection() const
+{
+    return base_->collection();
+}
+const couchbase::cas
+transaction_get_result::cas() const
+{
+    return base_->cas();
+}
+} // namespace couchbase::transactions

data/ext/couchbase/core/io/dns_client.cxx

@@ -0,0 +1,225 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "dns_client.hxx"
+
+#include "core/logger/logger.hxx"
+#include "core/utils/join_strings.hxx"
+#include "dns_codec.hxx"
+#include "dns_config.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <asio/ip/tcp.hpp>
+#include <asio/read.hpp>
+#include <asio/write.hpp>
+
+#include <memory>
+#include <sstream>
+
+namespace couchbase::core::io::dns
+{
+class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
+{
+  public:
+    dns_srv_command(asio::io_context& ctx,
+                    const std::string& name,
+                    const std::string& service,
+                    const asio::ip::address& address,
+                    std::uint16_t port,
+                    utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)> handler)
+      : deadline_(ctx)
+      , udp_deadline_(ctx)
+      , udp_(ctx)
+      , tcp_(ctx)
+      , address_(address)
+      , port_(port)
+      , handler_(std::move(handler))
+    {
+        static std::string protocol{ "_tcp" };
+        dns_message request{};
+        question_record qr;
+        qr.klass = resource_class::in;
+        qr.type = resource_type::srv;
+        qr.name.labels.push_back(service);
+        qr.name.labels.push_back(protocol);
+        std::string label;
+        std::istringstream name_stream(name);
+        while (std::getline(name_stream, label, '.')) {
+            qr.name.labels.push_back(label);
+        }
+        request.questions.emplace_back(qr);
+        send_buf_ = dns_codec::encode(request);
+    }
+
+    void execute(std::chrono::milliseconds total_timeout, std::chrono::milliseconds udp_timeout)
+    {
+        asio::ip::udp::endpoint endpoint(address_, port_);
+        udp_.open(endpoint.protocol());
+        udp_.async_send_to(
+          asio::buffer(send_buf_), endpoint, [self = shared_from_this()](std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
+              if (ec1) {
+                  self->udp_deadline_.cancel();
+                  CB_LOG_DEBUG("DNS UDP write operation has got error {}, retrying with TCP", ec1.message());
+                  return self->retry_with_tcp();
+              }
+
+              self->recv_buf_.resize(512);
+              self->udp_.async_receive_from(
+                asio::buffer(self->recv_buf_), self->udp_sender_, [self](std::error_code ec2, std::size_t bytes_transferred) mutable {
+                    self->udp_deadline_.cancel();
+                    if (ec2) {
+                        CB_LOG_DEBUG("DNS UDP read operation has got error {}, retrying with TCP", ec2.message());
+                        return self->retry_with_tcp();
+                    }
+                    self->recv_buf_.resize(bytes_transferred);
+                    const dns_message message = dns_codec::decode(self->recv_buf_);
+                    if (message.header.flags.tc == truncation::yes) {
+                        self->udp_.close();
+                        CB_LOG_DEBUG("DNS UDP read operation returned truncated response, retrying with TCP");
+                        return self->retry_with_tcp();
+                    }
+                    self->deadline_.cancel();
+                    dns_srv_response resp{ ec2 };
+                    resp.targets.reserve(message.answers.size());
+                    for (const auto& answer : message.answers) {
+                        resp.targets.emplace_back(dns_srv_response::address{ utils::join_strings(answer.target.labels, "."), answer.port });
+                    }
+                    CB_LOG_DEBUG("DNS UDP returned {} records", resp.targets.size());
+                    return self->handler_(std::move(resp));
+                });
+          });
+        udp_deadline_.expires_after(udp_timeout);
+        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            CB_LOG_DEBUG("DNS UDP deadline has been reached, cancelling UDP operation and fall back to TCP");
+            self->udp_.cancel();
+            return self->retry_with_tcp();
+        });
+
+        deadline_.expires_after(total_timeout);
+        deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            CB_LOG_DEBUG("DNS deadline has been reached, cancelling in-flight operations (tcp.is_open={})", self->tcp_.is_open());
+            self->udp_.cancel();
+            if (self->tcp_.is_open()) {
+                self->tcp_.cancel();
+            }
+        });
+    }
+
+  private:
+    void retry_with_tcp()
+    {
+        if (bool expected_state{ false }; !retrying_with_tcp_.compare_exchange_strong(expected_state, true)) {
+            return;
+        }
+
+        const asio::ip::tcp::no_delay no_delay(true);
+        std::error_code ignore_ec;
+        tcp_.set_option(no_delay, ignore_ec);
+        const asio::ip::tcp::endpoint endpoint(address_, port_);
+        tcp_.async_connect(endpoint, [self = shared_from_this()](std::error_code ec1) mutable {
+            if (ec1) {
+                self->deadline_.cancel();
+                CB_LOG_DEBUG("DNS TCP connection has been aborted, {}", ec1.message());
+                return self->handler_({ ec1 });
+            }
+            auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
+            self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size & 0xffU));
+            self->send_buf_.insert(self->send_buf_.begin(), static_cast<std::uint8_t>(send_size >> 8U));
+            asio::async_write(
+              self->tcp_, asio::buffer(self->send_buf_), [self](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
+                  if (ec2) {
+                      CB_LOG_DEBUG("DNS TCP write operation has been aborted, {}", ec2.message());
+                      self->deadline_.cancel();
+                      if (ec2 == asio::error::operation_aborted) {
+                          ec2 = errc::common::unambiguous_timeout;
+                      }
+                      return self->handler_({ ec2 });
+                  }
+                  asio::async_read(self->tcp_,
+                                   asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
+                                   [self](std::error_code ec3, std::size_t /* bytes_transferred */) mutable {
+                                       if (ec3) {
+                                           CB_LOG_DEBUG("DNS TCP buf size read operation has been aborted, {}", ec3.message());
+                                           self->deadline_.cancel();
+                                           return self->handler_({ ec3 });
+                                       }
+                                       self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
+                                       self->recv_buf_.resize(self->recv_buf_size_);
+                                       CB_LOG_DEBUG("DNS TCP schedule read of {} bytes", self->recv_buf_size_);
+                                       asio::async_read(self->tcp_,
+                                                        asio::buffer(self->recv_buf_),
+                                                        [self](std::error_code ec4, std::size_t bytes_transferred) mutable {
+                                                            self->deadline_.cancel();
+                                                            if (ec4) {
+                                                                CB_LOG_DEBUG("DNS TCP read operation has been aborted, {}", ec4.message());
+                                                                return self->handler_({ ec4 });
+                                                            }
+                                                            self->recv_buf_.resize(bytes_transferred);
+                                                            const dns_message message = dns_codec::decode(self->recv_buf_);
+                                                            dns_srv_response resp{ ec4 };
+                                                            resp.targets.reserve(message.answers.size());
+                                                            for (const auto& answer : message.answers) {
+                                                                resp.targets.emplace_back(dns_srv_response::address{
+                                                                  utils::join_strings(answer.target.labels, "."), answer.port });
+                                                            }
+                                                            CB_LOG_DEBUG("DNS TCP returned {} records", resp.targets.size());
+                                                            return self->handler_(std::move(resp));
+                                                        });
+                                   });
+              });
+        });
+    }
+
+    asio::steady_timer deadline_;
+    asio::steady_timer udp_deadline_;
+    asio::ip::udp::socket udp_;
+    asio::ip::udp::endpoint udp_sender_{};
+    asio::ip::tcp::socket tcp_;
+
+    asio::ip::address address_;
+    std::uint16_t port_;
+    utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)> handler_;
+
+    std::vector<std::uint8_t> send_buf_{};
+    std::uint16_t recv_buf_size_{ 0 };
+    std::vector<std::uint8_t> recv_buf_{};
+
+    std::atomic_bool retrying_with_tcp_{ false };
+};
+
+void
+dns_client::query_srv(const std::string& name,
+                      const std::string& service,
+                      const dns_config& config,
+                      utils::movable_function<void(dns_srv_response&&)>&& handler)
+{
+    std::error_code ec;
+    auto address = asio::ip::address::from_string(config.nameserver(), ec);
+    if (ec) {
+        return handler({ ec });
+    }
+    auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, address, config.port(), std::move(handler));
+    return cmd->execute(config.timeout(), config.timeout() / 2);
+}
+} // namespace couchbase::core::io::dns

data/ext/couchbase/core/io/dns_client.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *   Copyright 2020-2021 Couchbase, Inc.
+ *   Copyright 2020-Present Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -17,207 +17,38 @@
 
 #pragma once
 
-#include "core/utils/join_strings.hxx"
-#include "dns_codec.hxx"
+#include "core/utils/movable_function.hxx"
 #include "dns_config.hxx"
 
-#include <couchbase/error_codes.hxx>
+#include <asio/io_context.hpp>
 
-#include <asio/ip/tcp.hpp>
-#include <asio/read.hpp>
-#include <asio/write.hpp>
-
-#include <memory>
-#include <sstream>
+#include <cinttypes>
+#include <string>
+#include <vector>
 
 namespace couchbase::core::io::dns
 {
+struct dns_srv_response {
+    struct address {
+        std::string hostname;
+        std::uint16_t port;
+    };
+    std::error_code ec;
+    std::vector<address> targets{};
+};
+
 class dns_client
 {
   public:
-    struct dns_srv_response {
-        struct address {
-            std::string hostname;
-            std::uint16_t port;
-        };
-        std::error_code ec;
-        std::vector<address> targets{};
-    };
-
-    class dns_srv_command : public std::enable_shared_from_this<dns_srv_command>
-    {
-      public:
-        dns_srv_command(asio::io_context& ctx,
-                        const std::string& name,
-                        const std::string& service,
-                        const asio::ip::address& address,
-                        std::uint16_t port)
-          : deadline_(ctx)
-          , udp_(ctx)
-          , tcp_(ctx)
-          , address_(address)
-          , port_(port)
-        {
-            static std::string protocol{ "_tcp" };
-            dns_message request{};
-            question_record qr;
-            qr.klass = resource_class::in;
-            qr.type = resource_type::srv;
-            qr.name.labels.push_back(service);
-            qr.name.labels.push_back(protocol);
-            std::string label;
-            std::istringstream name_stream(name);
-            while (std::getline(name_stream, label, '.')) {
-                qr.name.labels.push_back(label);
-            }
-            request.questions.emplace_back(qr);
-            send_buf_ = dns_codec::encode(request);
-        }
-
-        template<class Handler>
-        void execute(std::chrono::milliseconds timeout, Handler&& handler)
-        {
-            asio::ip::udp::endpoint endpoint(address_, port_);
-            udp_.open(endpoint.protocol());
-            udp_.async_send_to(asio::buffer(send_buf_),
-                               endpoint,
-                               [self = shared_from_this(), handler = std::forward<Handler>(handler)](
-                                 std::error_code ec1, std::size_t /* bytes_transferred */) mutable {
-                                   if (ec1 == asio::error::operation_aborted) {
-                                       self->deadline_.cancel();
-                                       return handler({ errc::common::unambiguous_timeout });
-                                   }
-                                   if (ec1) {
-                                       self->deadline_.cancel();
-                                       return handler({ ec1 });
-                                   }
-
-                                   self->recv_buf_.resize(512);
-                                   self->udp_.async_receive_from(asio::buffer(self->recv_buf_),
-                                                                 self->udp_sender_,
-                                                                 [self, handler = std::forward<Handler>(handler)](
-                                                                   std::error_code ec2, std::size_t bytes_transferred) mutable {
-                                                                     self->deadline_.cancel();
-                                                                     if (ec2) {
-                                                                         return handler({ ec2 });
-                                                                     }
-                                                                     self->recv_buf_.resize(bytes_transferred);
-                                                                     dns_message message = dns_codec::decode(self->recv_buf_);
-                                                                     if (message.header.flags.tc == truncation::yes) {
-                                                                         self->udp_.close();
-                                                                         return self->retry_with_tcp(std::forward<Handler>(handler));
-                                                                     }
-                                                                     dns_srv_response resp{ ec2 };
-                                                                     resp.targets.reserve(message.answers.size());
-                                                                     for (const auto& answer : message.answers) {
-                                                                         resp.targets.emplace_back(dns_srv_response::address{
-                                                                           utils::join_strings(answer.target.labels, "."), answer.port });
-                                                                     }
-                                                                     return handler(std::move(resp));
-                                                                 });
-                               });
-            deadline_.expires_after(timeout);
-            deadline_.async_wait([self = shared_from_this()](std::error_code ec) {
-                if (ec == asio::error::operation_aborted) {
-                    return;
-                }
-                self->udp_.cancel();
-                if (self->tcp_.is_open()) {
-                    self->tcp_.cancel();
-                }
-            });
-        }
-
-      private:
-        template<class Handler>
-        void retry_with_tcp(Handler&& handler)
-        {
-            asio::ip::tcp::no_delay no_delay(true);
-            std::error_code ignore_ec;
-            tcp_.set_option(no_delay, ignore_ec);
-            asio::ip::tcp::endpoint endpoint(address_, port_);
-            tcp_.async_connect(
-              endpoint, [self = shared_from_this(), handler = std::forward<Handler>(handler)](std::error_code ec1) mutable {
-                  if (ec1) {
-                      self->deadline_.cancel();
-                      return handler({ ec1 });
-                  }
-                  auto send_size = static_cast<std::uint16_t>(self->send_buf_.size());
-                  self->send_buf_.insert(self->send_buf_.begin(), std::uint8_t(send_size & 0xffU));
-                  self->send_buf_.insert(self->send_buf_.begin(), std::uint8_t(send_size >> 8U));
-                  asio::async_write(
-                    self->tcp_,
-                    asio::buffer(self->send_buf_),
-                    [self, handler = std::forward<Handler>(handler)](std::error_code ec2, std::size_t /* bytes_transferred */) mutable {
-                        if (ec2) {
-                            self->deadline_.cancel();
-                            if (ec2 == asio::error::operation_aborted) {
-                                ec2 = errc::common::unambiguous_timeout;
-                            }
-                            return handler({ ec2 });
-                        }
-                        asio::async_read(self->tcp_,
-                                         asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
-                                         [self, handler = std::forward<Handler>(handler)](std::error_code ec3,
-                                                                                          std::size_t /* bytes_transferred */) mutable {
-                                             if (ec3) {
-                                                 self->deadline_.cancel();
-                                                 return handler({ ec3 });
-                                             }
-                                             self->recv_buf_size_ = utils::byte_swap(self->recv_buf_size_);
-                                             self->recv_buf_.resize(self->recv_buf_size_);
-                                             asio::async_read(self->tcp_,
-                                                              asio::buffer(self->recv_buf_),
-                                                              [self, handler = std::forward<Handler>(handler)](
-                                                                std::error_code ec4, std::size_t bytes_transferred) mutable {
-                                                                  self->deadline_.cancel();
-                                                                  if (ec4) {
-                                                                      return handler({ ec4 });
-                                                                  }
-                                                                  self->recv_buf_.resize(bytes_transferred);
-                                                                  dns_message message = dns_codec::decode(self->recv_buf_);
-                                                                  dns_srv_response resp{ ec4 };
-                                                                  resp.targets.reserve(message.answers.size());
-                                                                  for (const auto& answer : message.answers) {
-                                                                      resp.targets.emplace_back(dns_srv_response::address{
-                                                                        utils::join_strings(answer.target.labels, "."), answer.port });
-                                                                  }
-                                                                  return handler(std::move(resp));
-                                                              });
-                                         });
-                    });
-              });
-        }
-
-        asio::steady_timer deadline_;
-        asio::ip::udp::socket udp_;
-        asio::ip::udp::endpoint udp_sender_{};
-        asio::ip::tcp::socket tcp_;
-
-        asio::ip::address address_;
-        std::uint16_t port_;
-
-        std::vector<std::uint8_t> send_buf_{};
-        std::uint16_t recv_buf_size_{ 0 };
-        std::vector<std::uint8_t> recv_buf_{};
-    };
-
     explicit dns_client(asio::io_context& ctx)
       : ctx_(ctx)
     {
     }
 
-    template<class Handler>
-    void query_srv(const std::string& name, const std::string& service, const dns_config& config, Handler&& handler)
-    {
-        std::error_code ec;
-        auto address = asio::ip::address::from_string(config.nameserver(), ec);
-        if (ec) {
-            return handler({ ec });
-        }
-        auto cmd = std::make_shared<dns_srv_command>(ctx_, name, service, address, config.port());
-        cmd->execute(config.timeout(), std::forward<Handler>(handler));
-    }
+    void query_srv(const std::string& name,
+                   const std::string& service,
+                   const dns_config& config,
+                   utils::movable_function<void(couchbase::core::io::dns::dns_srv_response&& resp)>&& handler);
 
     asio::io_context& ctx_;
 };

data/ext/couchbase/core/meta/CMakeLists.txt

@@ -7,11 +7,13 @@ target_link_libraries(
           snappy
           fmt::fmt
           spdlog::spdlog)
-target_include_directories(couchbase_meta PRIVATE
-        ${PROJECT_BINARY_DIR}/generated
-        ${PROJECT_SOURCE_DIR}
-        ${PROJECT_SOURCE_DIR}/third_party/http_parser)
+target_include_directories(couchbase_meta PRIVATE ${PROJECT_BINARY_DIR}/generated ${PROJECT_SOURCE_DIR}
+                                                  ${PROJECT_SOURCE_DIR}/third_party/http_parser)
 
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-  target_link_libraries(couchbase_meta PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+    target_link_libraries(couchbase_meta PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+  else()
+    target_link_libraries(couchbase_meta PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  endif()
 endif()

data/ext/couchbase/core/meta/version.cxx

@@ -100,9 +100,28 @@ sdk_build_info()
     info["openssl_runtime"] = OpenSSL_version(OPENSSL_VERSION);
 #elif defined(SSLEAY_VERSION)
     info["openssl_runtime"] = SSLeay_version(SSLEAY_VERSION);
+#endif
+#if defined(OPENSSL_INFO_CONFIG_DIR)
+    info["openssl_config_dir"] = OPENSSL_info(OPENSSL_INFO_CONFIG_DIR);
+#elif defined(OPENSSL_DIR)
+    if (std::string config_dir(OpenSSL_version(OPENSSL_DIR)); !config_dir.empty()) {
+        if (auto quote = config_dir.find('"'); quote != std::string::npos && quote + 2 < config_dir.size()) {
+            info["openssl_config_dir"] = config_dir.substr(quote + 1, config_dir.size() - quote - 2);
+        } else {
+            info["openssl_config_dir"] = config_dir;
+        }
+    }
 #endif
     info["openssl_default_cert_dir"] = X509_get_default_cert_dir();
     info["openssl_default_cert_file"] = X509_get_default_cert_file();
+    info["openssl_ssl_interface_include_directories"] = OPENSSL_SSL_INTERFACE_INCLUDE_DIRECTORIES;
+    info["openssl_ssl_interface_link_libraries"] = OPENSSL_SSL_INTERFACE_LINK_LIBRARIES;
+    info["openssl_ssl_imported_location"] = OPENSSL_SSL_IMPORTED_LOCATION;
+    info["openssl_crypto_interface_imported_location"] = OPENSSL_CRYPTO_IMPORTED_LOCATION;
+    info["openssl_crypto_interface_include_directories"] = OPENSSL_CRYPTO_INTERFACE_INCLUDE_DIRECTORIES;
+    info["openssl_crypto_interface_link_libraries"] = OPENSSL_CRYPTO_INTERFACE_LINK_LIBRARIES;
+    info["openssl_pkg_config_interface_include_directories"] = OPENSSL_PKG_CONFIG_INTERFACE_INCLUDE_DIRECTORIES;
+    info["openssl_pkg_config_interface_link_libraries"] = OPENSSL_PKG_CONFIG_INTERFACE_LINK_LIBRARIES;
     info["__cplusplus"] = fmt::format("{}", __cplusplus);
 #if defined(_MSC_VER)
     info["_MSC_VER"] = fmt::format("{}", _MSC_VER);

data/ext/couchbase/core/operations/document_search.cxx

@@ -92,11 +92,14 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
             { "vectors", { { index_name, scan_vectors } } },
         };
     }
-    if (scope_name) {
-        body["scope"] = scope_name.value();
+    if (!collections.empty()) {
         body["collections"] = collections;
     }
 
+    for (const auto& [key, value] : raw) {
+        body[key] = utils::json::parse(value);
+    }
+
     encoded.type = type;
     encoded.headers["content-type"] = "application/json";
     encoded.method = "POST";

data/ext/couchbase/core/operations/document_search.hxx

@@ -130,7 +130,6 @@ struct search_request {
     std::optional<couchbase::core::search_highlight_style> highlight_style{};
     std::vector<std::string> highlight_fields{};
     std::vector<std::string> fields{};
-    std::optional<std::string> scope_name{};
     std::vector<std::string> collections{};
 
     std::optional<couchbase::core::search_scan_consistency> scan_consistency{};

data/ext/couchbase/core/transactions/active_transaction_record.hxx

@@ -153,7 +153,7 @@ class active_transaction_record
                 if (const auto* compat = val.find(ATR_FIELD_FORWARD_COMPAT); compat != nullptr) {
                     forward_compat = *compat;
                 }
-
+                std::optional<uint32_t> expires_after_msec = std::max(val.optional<int32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS).value_or(0), 0);
                 entries.emplace_back(resp.ctx.bucket(),
                                      resp.ctx.id(),
                                      key,
@@ -163,7 +163,7 @@ class active_transaction_record
                                      parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_COMPLETE).value_or("")),
                                      parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_START).value_or("")),
                                      parse_mutation_cas(val.optional<std::string>(ATR_FIELD_TIMESTAMP_ROLLBACK_COMPLETE).value_or("")),
-                                     val.optional<std::uint32_t>(ATR_FIELD_EXPIRES_AFTER_MSECS),
+                                     expires_after_msec,
                                      process_document_ids(val, ATR_FIELD_DOCS_INSERTED),
                                      process_document_ids(val, ATR_FIELD_DOCS_REPLACED),
                                      process_document_ids(val, ATR_FIELD_DOCS_REMOVED),