couchbase 3.8.2 → 3.9.0

data/ext/couchbase/core/origin.cxx

@@ -16,7 +16,6 @@
  */
 
 #include "origin.hxx"
-#include <couchbase/build_config.hxx>
 
 #include "core/utils/connection_string.hxx"
 #include "topology/configuration.hxx"
@@ -224,24 +223,6 @@ struct traits<couchbase::transactions::transactions_config::built> {
   }
 };
 
-template<>
-struct traits<couchbase::core::columnar::security_options> {
-  template<template<typename...> class Traits>
-  static void assign(tao::json::basic_value<Traits>& v,
-                     const couchbase::core::columnar::security_options& o)
-  {
-    v = {
-      { "trust_only_capella", o.trust_only_capella },
-      { "trust_only_pem_file", o.trust_only_pem_file },
-      { "trust_only_pem_string", o.trust_only_pem_string },
-      { "trust_only_platform", o.trust_only_platform },
-      { "trust_only_certificates", o.trust_only_certificates.size() },
-      // TODO(JC): add if/when we support the cipher_suites option
-      // { "cipher_suites", utils::join_strings(o.cipher_suites, ":") },
-    };
-  }
-};
-
 } // namespace tao::json
 
 namespace couchbase::core
@@ -267,13 +248,10 @@ origin::to_json() const -> std::string
         { "config_poll_floor", options_.config_poll_floor },
         { "user_agent_extra", options_.user_agent_extra },
         { "dump_configuration", options_.dump_configuration },
+        { "log_redaction", options_.log_redaction },
         { "disable_mozilla_ca_certificates", options_.disable_mozilla_ca_certificates },
         { "network", options_.network },
         { "tls_verify", options_.tls_verify },
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-        { "dispatch_timeout", options_.dispatch_timeout },
-        { "security_options", options_.security_options },
-#else
         { "key_value_timeout", options_.key_value_timeout },
         { "key_value_durable_timeout", options_.key_value_durable_timeout },
         { "view_timeout", options_.view_timeout },
@@ -297,7 +275,6 @@ origin::to_json() const -> std::string
         { "orphan_reporter_options", options_.orphan_options },
         { "transactions_options", options_.transactions },
         { "server_group", options_.server_group },
-#endif
       },
     },
   };
@@ -311,6 +288,9 @@ origin::to_json() const -> std::string
     }
     json["bootstrap_nodes"] = nodes;
   }
+  // Every value in here is left as it is. The document this returns is annotated as a whole at
+  // the log site, because a tag written into one of its string values would be read back as part
+  // of that value by anything that parses the line as JSON.
   return tao::json::to_string(json);
 }
 
@@ -319,9 +299,15 @@ origin::to_json() const -> std::string
 couchbase::core::origin::origin(origin&& other) noexcept
   : options_(std::move(other.options_))
   , nodes_(std::move(other.nodes_))
-  , next_node_(other.next_node_)
+  // next_node_ is an iterator into nodes_. Container move construction transfers the buffer, so
+  // iterators into the source stay valid and now denote elements of nodes_ -- other.next_node_ can
+  // be adopted as-is, preserving the round-robin position. The empty case is guarded separately
+  // because that guarantee does not extend to a past-the-end iterator. nodes_ is declared before
+  // next_node_, so it is already initialized here.
+  , next_node_(nodes_.empty() ? nodes_.begin() : other.next_node_)
   , exhausted_(other.exhausted_)
   , connection_string_(std::move(other.connection_string_))
+  , uses_protostellar_(other.uses_protostellar_)
   , credentials_(std::move(other.credentials_))
 {
 }
@@ -330,20 +316,38 @@ auto
 couchbase::core::origin::operator=(origin&& other) noexcept -> origin&
 {
   if (this != &other) {
+    const auto offset = other.nodes_.empty() ? 0 : other.next_node_ - other.nodes_.begin();
     options_ = std::move(other.options_);
     nodes_ = std::move(other.nodes_);
-    next_node_ = other.next_node_;
+    next_node_ = nodes_.begin() + offset;
     exhausted_ = other.exhausted_;
     connection_string_ = std::move(other.connection_string_);
+    uses_protostellar_ = other.uses_protostellar_;
     credentials_ = std::move(other.credentials_);
   }
   return *this;
 }
 
+// A copy is a fresh origin that has not attempted anything, so the rotation cursor is deliberately
+// reset rather than carried. This matters: next_address() marks an origin exhausted as it hands out
+// the *last* node, which on a single-node cluster is the very first call, so a cluster origin is
+// normally exhausted immediately after bootstrap. open_bucket() copies that origin into every
+// bucket and on into every session, and mcbp_session::initiate_bootstrap() tests exhausted()
+// before it ever calls next_address() -- so carrying the flag would send a session that has tried
+// nothing down the "reached the end of the list of bootstrap nodes" path: an unconditional 500 ms
+// backoff.
+//
+// Moving, by contrast, does carry it: a move transfers identity rather than producing an
+// independent origin.
+//
+// connection_string_ and uses_protostellar_ *are* copied. They were being dropped entirely, which
+// left connection_string() returning "" on any copied origin.
 couchbase::core::origin::origin(const couchbase::core::origin& other)
   : options_(other.options_)
   , nodes_(other.nodes_)
   , next_node_(nodes_.begin())
+  , connection_string_(other.connection_string_)
+  , uses_protostellar_(other.uses_protostellar_)
 {
   update_credentials(other.credentials());
 }
@@ -378,6 +382,7 @@ couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
                                 const couchbase::core::utils::connection_string& connstr)
   : options_(connstr.options)
   , connection_string_(connstr.input)
+  , uses_protostellar_(connstr.uses_protostellar())
   , credentials_(std::move(auth))
 {
   nodes_.reserve(connstr.bootstrap_nodes.size());
@@ -396,10 +401,13 @@ couchbase::core::origin::operator=(const couchbase::core::origin& other) -> couc
 {
   if (this != &other) {
     options_ = other.options_;
+    connection_string_ = other.connection_string_;
     update_credentials(other.credentials());
     nodes_ = other.nodes_;
+    // Rotation state is reset, not carried -- see the copy constructor for why.
     next_node_ = nodes_.begin();
     exhausted_ = false;
+    uses_protostellar_ = other.uses_protostellar_;
   }
   return *this;
 }
@@ -409,6 +417,11 @@ couchbase::core::origin::connection_string() const -> const std::string&
   return connection_string_;
 }
 auto
+couchbase::core::origin::uses_protostellar() const -> bool
+{
+  return uses_protostellar_;
+}
+auto
 couchbase::core::origin::username() const -> std::string
 {
   const std::shared_lock lock(credentials_mutex_);
@@ -458,6 +471,16 @@ couchbase::core::origin::get_nodes() const -> std::vector<std::string>
   }
   return res;
 }
+auto
+couchbase::core::origin::get_node_addresses() const -> std::vector<std::string>
+{
+  std::vector<std::string> res;
+  res.reserve(nodes_.size());
+  for (const auto& [hostname, port] : nodes_) {
+    res.emplace_back(fmt::format("{}:{}", hostname, port));
+  }
+  return res;
+}
 
 void
 couchbase::core::origin::shuffle_nodes()
@@ -502,6 +525,11 @@ couchbase::core::origin::set_nodes_from_config(const topology::configuration& co
     shuffle_nodes();
   }
   next_node_ = nodes_.begin();
+  // Matches set_nodes(): the node list has just been replaced, so any exhaustion recorded against
+  // the previous list is meaningless. Without this an origin that was exhausted stays exhausted
+  // across every config update -- cluster.cxx calls this on a long-lived origin that
+  // next_address() will have marked exhausted.
+  exhausted_ = false;
 }
 void
 couchbase::core::origin::update_credentials(cluster_credentials auth)

data/ext/couchbase/core/origin.hxx

@@ -60,6 +60,9 @@ struct origin {
   auto operator=(const origin& other) -> origin&;
 
   [[nodiscard]] auto connection_string() const -> const std::string&;
+  // True when built from a couchbase2:// connection string (Protostellar transport). Lets the
+  // connect path branch to the gRPC client without re-parsing the connection string.
+  [[nodiscard]] auto uses_protostellar() const -> bool;
   [[nodiscard]] auto username() const -> std::string;
   [[nodiscard]] auto password() const -> std::string;
   [[nodiscard]] auto certificate_path() const -> std::string;
@@ -68,6 +71,10 @@ struct origin {
 
   [[nodiscard]] auto get_hostnames() const -> std::vector<std::string>;
   [[nodiscard]] auto get_nodes() const -> std::vector<std::string>;
+  // The same addresses as get_nodes(), without the display quotes baked into each entry. Log
+  // statements want them bare so that logger::system_data_list() can put a tag inside the quotes it
+  // renders; a tag around a pre-quoted entry hashes the punctuation with the value.
+  [[nodiscard]] auto get_node_addresses() const -> std::vector<std::string>;
 
   void shuffle_nodes();
   void set_nodes(node_list nodes);
@@ -84,6 +91,10 @@ struct origin {
   [[nodiscard]] auto options() const -> const couchbase::core::cluster_options&;
   [[nodiscard]] auto options() -> couchbase::core::cluster_options&;
   [[nodiscard]] auto credentials() const -> couchbase::core::cluster_credentials;
+  // A JSON dump of the whole origin, less the credentials. Its only callers are the log
+  // statements in the cluster open paths, and they annotate the whole document: a tag written
+  // into one of these values instead would be read back as part of that value by anything that
+  // parses the line as JSON. So nothing in here is annotated.
   [[nodiscard]] auto to_json() const -> std::string;
 
 private:
@@ -92,6 +103,7 @@ private:
   node_list::iterator next_node_{};
   bool exhausted_{ false };
   std::string connection_string_{};
+  bool uses_protostellar_{ false };
   cluster_credentials credentials_{};
   mutable std::shared_mutex credentials_mutex_{};
 };

data/ext/couchbase/core/orphan_reporter.cxx

@@ -20,6 +20,7 @@
 #include <couchbase/build_info.hxx>
 
 #include "logger/logger.hxx"
+#include "logger/redaction.hxx"
 #include "utils/concurrent_fixed_priority_queue.hxx"
 #include "utils/json.hxx"
 
@@ -120,7 +121,7 @@ private:
       }
 
       if (auto report = self->flush_and_create_output(); report.has_value()) {
-        CB_LOG_WARNING("Orphan responses observed: {}", report.value());
+        CB_LOG_WARNING("Orphan responses observed: {}", logger::system_data(report.value()));
       }
 
       self->rearm();

data/ext/couchbase/core/platform/random.cc

@@ -25,7 +25,7 @@
 #include <mutex>
 #include <system_error>
 
-#ifdef WIN32
+#ifdef _WIN32
 // We need to include windows.h _before_ wincrypt.h
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
@@ -45,7 +45,7 @@ class RandomGeneratorProvider
 public:
   RandomGeneratorProvider()
   {
-#ifdef WIN32
+#ifdef _WIN32
     if (!CryptAcquireContext(
           &handle, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
       throw std::system_error(int(GetLastError()),
@@ -69,7 +69,7 @@ public:
 
   virtual ~RandomGeneratorProvider()
   {
-#ifdef WIN32
+#ifdef _WIN32
     CryptReleaseContext(handle, 0);
 #else
     close(handle);
@@ -78,8 +78,8 @@ public:
 
   auto getBytes(void* dest, std::size_t size) -> bool
   {
-    const std::lock_guard<std::mutex> lock(mutex);
-#ifdef WIN32
+    const std::scoped_lock<std::mutex> lock(mutex);
+#ifdef _WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
 #if defined(__clang__) && defined(__clang_analyzer__)
@@ -92,7 +92,7 @@ public:
   }
 
 private:
-#ifdef WIN32
+#ifdef _WIN32
   HCRYPTPROV handle{};
 #else
   int handle = -1;
@@ -107,7 +107,7 @@ RandomGenerator::RandomGenerator()
 {
   if (!shared_provider) {
     // This might be the first one, lets lock and create
-    const std::lock_guard<std::mutex> guard(shared_provider_lock);
+    const std::scoped_lock<std::mutex> guard(shared_provider_lock);
     if (!shared_provider) { // cppcheck-suppress identicalInnerCondition; DCLP
       shared_provider = std::make_unique<RandomGeneratorProvider>();
     }

data/ext/couchbase/core/protocol/client_request.cxx

@@ -23,8 +23,8 @@
 namespace couchbase::core::protocol
 {
 auto
-compress_value(const std::vector<std::byte>& value,
-               std::vector<std::byte>::iterator& output) -> std::pair<bool, std::uint32_t>
+compress_value(const std::vector<std::byte>& value, const std::vector<std::byte>::iterator& output)
+  -> std::pair<bool, std::uint32_t>
 {
   static const double min_ratio = 0.83;
 

data/ext/couchbase/core/protocol/client_request.hxx

@@ -23,6 +23,7 @@
 #include "client_response.hxx"
 #include "core/utils/binary.hxx"
 #include "core/utils/byteswap.hxx"
+#include "datatype.hxx"
 #include "magic.hxx"
 
 #include <algorithm>
@@ -32,8 +33,8 @@
 namespace couchbase::core::protocol
 {
 auto
-compress_value(const std::vector<std::byte>& value,
-               std::vector<std::byte>::iterator& output) -> std::pair<bool, std::uint32_t>;
+compress_value(const std::vector<std::byte>& value, const std::vector<std::byte>::iterator& output)
+  -> std::pair<bool, std::uint32_t>;
 
 template<typename Body>
 class client_request
@@ -62,7 +63,7 @@ public:
 
   void opaque(std::uint32_t val)
   {
-    opaque_ = utils::byte_swap(val);
+    opaque_ = utils::host_to_network(val);
   }
 
   void datatype(protocol::datatype val)
@@ -72,12 +73,12 @@ public:
 
   void cas(couchbase::cas val)
   {
-    cas_ = utils::byte_swap(val.value());
+    cas_ = utils::host_to_network(val.value());
   }
 
   [[nodiscard]] auto opaque() const -> std::uint32_t
   {
-    return utils::byte_swap(opaque_);
+    return utils::network_to_host(opaque_);
   }
 
   void opcode(client_opcode val)
@@ -116,23 +117,38 @@ public:
 private:
   [[nodiscard]] auto generate_payload(bool try_to_compress) -> std::vector<std::byte>
   {
+    // Bind the body's four wire regions once. Note that value()/extras() on some bodies (e.g.
+    // hello, mutate_in) lazily populate their buffers on first access, so this also materialises
+    // them before we measure and copy.
+    const auto& framing_extras = body_.framing_extras();
+    const auto& extras = body_.extras();
+    const auto& key = body_.key();
+    const auto& value = body_.value();
+
+    // Size the buffer from the same regions that get copied into it, rather than from the
+    // independent body_.size(). body_.size() is defined as exactly this sum for every body type,
+    // so the byte layout is unchanged; deriving the length here makes the buffer provably large
+    // enough for the copies below. (Without it GCC folds body_.size() to 0 for zero-length bodies
+    // such as noop, decides body_itr is one-past-the-end, and emits a bogus -Warray-bounds.)
+    const std::size_t body_size_bytes =
+      framing_extras.size() + extras.size() + key.size() + value.size();
+
     // SA: for some reason GCC 8.5.0 on CentOS 8 sees here null-pointer dereference
     // JC: BoringSSL changes, noticed the same when building w/ GCC 11.3.0; TODO:  is 12 okay?
 #if defined(__GNUC__) && __GNUC__ >= 8 && __GNUC__ < 12
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wnull-dereference"
 #endif
-    std::vector<std::byte> payload(header_size + body_.size(), std::byte{});
+    std::vector<std::byte> payload(header_size + body_size_bytes, std::byte{});
     payload[0] = static_cast<std::byte>(magic_);
     payload[1] = static_cast<std::byte>(opcode_);
 #if defined(__GNUC__) && __GNUC__ >= 8 && __GNUC__ < 12
 #pragma GCC diagnostic pop
 #endif
-    const auto& framing_extras = body_.framing_extras();
 
-    std::uint16_t key_size = gsl::narrow_cast<std::uint16_t>(body_.key().size());
+    std::uint16_t key_size = gsl::narrow_cast<std::uint16_t>(key.size());
     if (framing_extras.size() == 0) {
-      key_size = utils::byte_swap(key_size);
+      key_size = utils::host_to_network(key_size);
       memcpy(payload.data() + 2, &key_size, sizeof(key_size));
     } else {
       magic_ = protocol::magic::alt_client_request;
@@ -141,15 +157,16 @@ private:
       payload[3] = gsl::narrow_cast<std::byte>(key_size);
     }
 
-    std::uint8_t ext_size = gsl::narrow_cast<std::uint8_t>(body_.extras().size());
+    std::uint8_t ext_size = gsl::narrow_cast<std::uint8_t>(extras.size());
     memcpy(payload.data() + 4, &ext_size, sizeof(ext_size));
 
     payload[5] = static_cast<std::byte>(datatype_);
 
-    std::uint16_t vbucket = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(partition_));
+    std::uint16_t vbucket = utils::host_to_network(gsl::narrow_cast<std::uint16_t>(partition_));
     memcpy(payload.data() + 6, &vbucket, sizeof(vbucket));
 
-    std::uint32_t body_size = utils::byte_swap(gsl::narrow_cast<std::uint32_t>(body_.size()));
+    std::uint32_t body_size =
+      utils::host_to_network(gsl::narrow_cast<std::uint32_t>(body_size_bytes));
     memcpy(payload.data() + 8, &body_size, sizeof(body_size));
 
     memcpy(payload.data() + 12, &opaque_, sizeof(opaque_));
@@ -159,24 +176,24 @@ private:
     if (framing_extras.size() > 0) {
       body_itr = std::copy(framing_extras.begin(), framing_extras.end(), body_itr);
     }
-    body_itr = std::copy(body_.extras().begin(), body_.extras().end(), body_itr);
-    body_itr = utils::to_binary(body_.key(), body_itr);
+    body_itr = std::copy(extras.begin(), extras.end(), body_itr);
+    body_itr = utils::to_binary(key, body_itr);
 
     if (static const std::size_t min_size_to_compress = 32;
-        try_to_compress && body_.value().size() > min_size_to_compress) {
-      if (auto [compressed, new_value_size] = compress_value(body_.value(), body_itr); compressed) {
+        try_to_compress && value.size() > min_size_to_compress) {
+      if (auto [compressed, new_value_size] = compress_value(value, body_itr); compressed) {
         /* the compressed value meets requirements and was copied to the payload */
-        payload[5] |= static_cast<std::byte>(protocol::datatype::snappy);
-        std::uint32_t new_body_size = utils::byte_swap(body_size) -
-                                      gsl::narrow_cast<std::uint32_t>(body_.value().size()) +
+        protocol::set_flag(payload[5], protocol::datatype::snappy);
+        std::uint32_t new_body_size = utils::network_to_host(body_size) -
+                                      gsl::narrow_cast<std::uint32_t>(value.size()) +
                                       new_value_size;
         payload.resize(header_size + new_body_size);
-        new_body_size = utils::byte_swap(new_body_size);
+        new_body_size = utils::host_to_network(new_body_size);
         memcpy(payload.data() + 8, &new_body_size, sizeof(new_body_size));
         return payload;
       }
     }
-    std::copy(body_.value().begin(), body_.value().end(), body_itr);
+    std::copy(value.begin(), value.end(), body_itr);
     return payload;
   }
 };

data/ext/couchbase/core/protocol/client_response.cxx

@@ -19,6 +19,7 @@
 
 #include "core/utils/json.hxx"
 
+#include <cstddef>
 #include <cstring>
 #include <gsl/assert>
 #include <tao/json/value.hpp>
@@ -31,8 +32,15 @@ parse_server_duration_us(const io::mcbp_message& msg) -> double
   if (msg.header.magic != static_cast<std::uint8_t>(magic::alt_client_response)) {
     return 0;
   }
-  auto framing_extras_size = static_cast<std::uint8_t>(msg.header.keylen & 0xfU);
-  if (framing_extras_size == 0) {
+  // Byte 2 of the header, read as a byte. `keylen` holds the wire bytes untouched, so masking it
+  // as a native integer reads byte 2 on a little-endian host and byte 3 -- the key length -- on a
+  // big-endian one. The mask also truncated the field to its low nibble: four bits is the length
+  // of one frame inside the region, not the length of the region, which may exceed 15 bytes.
+  const auto framing_extras_size = msg.header.alt_sizes().framing_extras;
+  // A region the body cannot hold is a malformed response, not a duration: the loop below walks
+  // to framing_extras_size without consulting the body again, and the nibble mask was the only
+  // thing that had been keeping it near the front of the buffer.
+  if (framing_extras_size == 0 || std::size_t{ framing_extras_size } > msg.body.size()) {
     return 0;
   }
   std::size_t offset = 0;
@@ -44,7 +52,7 @@ parse_server_duration_us(const io::mcbp_message& msg) -> double
       if (frame_size == 2 && framing_extras_size - offset >= frame_size) {
         std::uint16_t encoded_duration{};
         std::memcpy(&encoded_duration, msg.body.data() + offset, sizeof(encoded_duration));
-        encoded_duration = utils::byte_swap(encoded_duration);
+        encoded_duration = utils::network_to_host(encoded_duration);
         return std::pow(encoded_duration, 1.74) / 2;
       }
     }

data/ext/couchbase/core/protocol/client_response.hxx

@@ -23,6 +23,7 @@
 #include "client_opcode.hxx"
 #include "client_opcode_fmt.hxx"
 #include "cmd_info.hxx"
+#include "core/io/mcbp_buffer_pool.hxx"
 #include "core/io/mcbp_message.hxx"
 #include "core/utils/byteswap.hxx"
 #include "datatype.hxx"
@@ -68,6 +69,9 @@ private:
   std::uint32_t opaque_{};
   std::uint64_t cas_{};
   cmd_info info_{};
+  // When set, data_ (moved out of the mcbp_message body) is returned to the destroying thread's
+  // buffer pool on destruction so its storage can be recycled. See core/io/mcbp_buffer_pool.hxx.
+  bool recycle_body_{ false };
 
 public:
   client_response() = default;
@@ -80,11 +84,28 @@ public:
     : header_(msg.header_data())
     , data_(std::move(msg.body))
     , info_(info)
+    , recycle_body_(msg.recycle_body)
   {
     verify_header();
     parse_body();
   }
 
+  client_response(const client_response&) = default;
+  auto operator=(const client_response&) -> client_response& = default;
+  client_response(client_response&&) = default;
+  auto operator=(client_response&&) -> client_response& = default;
+
+  ~client_response()
+  {
+    // Recycle the frame buffer to the destroying thread's own pool. The pool is thread-local, so
+    // this is safe on whichever IO thread (read loop or a command strand) destroys the response;
+    // std::vector value semantics mean no two responses ever share data_, so a buffer is never
+    // returned twice.
+    if (recycle_body_) {
+      io::tls_response_body_pool().release(std::move(data_));
+    }
+  }
+
   [[nodiscard]] auto opcode() const -> client_opcode
   {
     return opcode_;
@@ -131,7 +152,7 @@ public:
 
     std::uint16_t status = 0;
     memcpy(&status, header_.data() + 6, sizeof(status));
-    status = utils::byte_swap(status);
+    status = utils::network_to_host(status);
     status_ = static_cast<key_value_status_code>(status);
 
     extras_size_ = std::to_integer<std::uint8_t>(header_[4]);
@@ -140,19 +161,19 @@ public:
       key_size_ = std::to_integer<std::uint8_t>(header_[3]);
     } else {
       memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
-      key_size_ = utils::byte_swap(key_size_);
+      key_size_ = utils::network_to_host(key_size_);
     }
 
     std::uint32_t field = 0;
     memcpy(&field, header_.data() + 8, sizeof(field));
-    body_size_ = utils::byte_swap(field);
+    body_size_ = utils::network_to_host(field);
     data_.resize(body_size_);
 
     memcpy(&opaque_, header_.data() + 12, sizeof(opaque_));
-    opaque_ = utils::byte_swap(opaque_);
+    opaque_ = utils::network_to_host(opaque_);
 
     memcpy(&cas_, header_.data() + 16, sizeof(cas_));
-    cas_ = utils::byte_swap(cas_);
+    cas_ = utils::network_to_host(cas_);
   }
 
   [[nodiscard]] auto error_info() const -> std::optional<key_value_extended_error_info>
@@ -200,7 +221,7 @@ public:
           frame_size == 2 && framing_extras_size_ - offset >= frame_size) {
         std::uint16_t encoded_duration{};
         std::memcpy(&encoded_duration, data_.data() + offset, sizeof(encoded_duration));
-        encoded_duration = utils::byte_swap(encoded_duration);
+        encoded_duration = utils::network_to_host(encoded_duration);
         info_.server_duration_us = std::pow(encoded_duration, 1.74) / 2;
       }
       offset += frame_size;

data/ext/couchbase/core/protocol/cmd_append.cxx

@@ -42,12 +42,12 @@ protocol::append_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       return true;

data/ext/couchbase/core/protocol/cmd_cluster_map_change_notification.cxx

@@ -40,11 +40,11 @@ cluster_map_change_notification_request_body::parse(const header_buffer& header,
   offset_type offset = ext_size;
   if (ext_size == 4) {
     memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
-    protocol_revision_ = utils::byte_swap(protocol_revision_);
+    protocol_revision_ = utils::network_to_host(protocol_revision_);
   }
   std::uint16_t key_size = 0;
   memcpy(&key_size, header.data() + 2, sizeof(key_size));
-  key_size = utils::byte_swap(key_size);
+  key_size = utils::network_to_host(key_size);
   const auto* data_ptr = reinterpret_cast<const char*>(body.data());
   bucket_.assign(data_ptr + offset, data_ptr + offset + key_size);
   offset += key_size;

data/ext/couchbase/core/protocol/cmd_decrement.cxx

@@ -42,19 +42,19 @@ decrement_response_body::parse(key_value_status_code status,
     if (extras_size == 16) {
       std::uint64_t partition_uuid{};
       memcpy(&partition_uuid, body.data() + offset, sizeof(partition_uuid));
-      partition_uuid = utils::byte_swap(partition_uuid);
+      partition_uuid = utils::network_to_host(partition_uuid);
       offset += 8;
 
       std::uint64_t sequence_number{};
       memcpy(&sequence_number, body.data() + offset, sizeof(sequence_number));
-      sequence_number = utils::byte_swap(sequence_number);
+      sequence_number = utils::network_to_host(sequence_number);
 
       token_ = couchbase::utils::build_mutation_token(partition_uuid, sequence_number);
       offset += 8;
     }
     offset += key_size;
     memcpy(&content_, body.data() + offset, sizeof(content_));
-    content_ = utils::byte_swap(content_);
+    content_ = utils::network_to_host(content_);
     return true;
   }
   return false;
@@ -82,15 +82,15 @@ decrement_request_body::fill_extras()
   using offset_type = std::vector<std::byte>::difference_type;
   offset_type offset = 0;
 
-  std::uint64_t num = utils::byte_swap(delta_);
+  std::uint64_t num = utils::host_to_network(delta_);
   memcpy(extras_.data() + offset, &num, sizeof(num));
   offset += static_cast<offset_type>(sizeof(delta_));
 
-  num = utils::byte_swap(initial_value_);
+  num = utils::host_to_network(initial_value_);
   memcpy(extras_.data() + offset, &num, sizeof(num));
   offset += static_cast<offset_type>(sizeof(delta_));
 
-  std::uint32_t ttl = utils::byte_swap(expiry_);
+  std::uint32_t ttl = utils::host_to_network(expiry_);
   memcpy(extras_.data() + offset, &ttl, sizeof(ttl));
 }
 } // namespace couchbase::core::protocol

data/ext/couchbase/core/protocol/cmd_get.cxx

@@ -39,7 +39,7 @@ get_response_body::parse(key_value_status_code status,
     std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
     if (extras_size == 4) {
       memcpy(&flags_, body.data() + offset, sizeof(flags_));
-      flags_ = utils::byte_swap(flags_);
+      flags_ = utils::network_to_host(flags_);
       offset += 4;
     } else {
       offset += extras_size;

data/ext/couchbase/core/protocol/cmd_get_and_lock.cxx

@@ -38,7 +38,7 @@ get_and_lock_response_body::parse(key_value_status_code status,
     std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
     if (extras_size == 4) {
       memcpy(&flags_, body.data() + offset, sizeof(flags_));
-      flags_ = utils::byte_swap(flags_);
+      flags_ = utils::network_to_host(flags_);
       offset += 4;
     } else {
       offset += extras_size;
@@ -60,7 +60,7 @@ void
 get_and_lock_request_body::fill_extras()
 {
   extras_.resize(sizeof(lock_time_));
-  std::uint32_t field = utils::byte_swap(lock_time_);
+  std::uint32_t field = utils::host_to_network(lock_time_);
   memcpy(extras_.data(), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol