couchbase 3.8.1 → 3.9.0

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

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

@@ -38,7 +38,7 @@ get_and_touch_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_touch_request_body::fill_extras()
 {
   extras_.resize(sizeof(expiry_));
-  std::uint32_t field = utils::byte_swap(expiry_);
+  std::uint32_t field = utils::host_to_network(expiry_);
   memcpy(extras_.data(), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

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

@@ -18,6 +18,7 @@
 #include "cmd_get_cluster_config.hxx"
 
 #include "core/logger/logger.hxx"
+#include "core/logger/redaction.hxx"
 #include "core/topology/configuration_json.hxx"
 #include "core/utils/json.hxx"
 
@@ -77,14 +78,15 @@ get_cluster_config_response_body::parse(key_value_status_code status,
   if (status == key_value_status_code::success) {
     const std::vector<std::uint8_t>::difference_type offset =
       framing_extras_size + key_size + extras_size;
-    std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset,
-                                  body.size() - static_cast<std::size_t>(offset) };
+    const std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset,
+                                        body.size() - static_cast<std::size_t>(offset) };
     try {
       config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
       config_text_.emplace(config_text);
     } catch (const tao::pegtl::parse_error& e) {
-      CB_LOG_DEBUG(
-        "unable to parse cluster configuration as JSON: {}, {}", e.message(), config_text);
+      CB_LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}",
+                   e.message(),
+                   logger::metadata(config_text));
     }
     return true;
   }

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

@@ -41,11 +41,11 @@ get_collection_id_response_body::parse(key_value_status_code status,
     std::vector<std::uint8_t>::difference_type offset = framing_extras_size + key_size;
 
     std::memcpy(&manifest_uid_, body.data() + offset, sizeof(manifest_uid_));
-    manifest_uid_ = utils::byte_swap(manifest_uid_);
+    manifest_uid_ = utils::network_to_host(manifest_uid_);
     offset += 8;
 
     std::memcpy(&collection_uid_, body.data() + offset, sizeof(collection_uid_));
-    collection_uid_ = utils::byte_swap(collection_uid_);
+    collection_uid_ = utils::network_to_host(collection_uid_);
     return true;
   }
   return false;

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

@@ -56,7 +56,7 @@ get_error_map_response_body::parse(key_value_status_code status,
 void
 get_error_map_request_body::fill_body()
 {
-  std::uint16_t version = utils::byte_swap(version_);
+  std::uint16_t version = utils::host_to_network(version_);
   value_.resize(sizeof(version));
   std::memcpy(value_.data(), &version, sizeof(version));
 }

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

@@ -40,19 +40,19 @@ get_meta_response_body::parse(key_value_status_code status,
     if (extras_size == sizeof(deleted_) + sizeof(flags_) + sizeof(expiry_) +
                          sizeof(sequence_number_) + sizeof(datatype_)) {
       memcpy(&deleted_, body.data() + offset, sizeof(deleted_));
-      deleted_ = utils::byte_swap(deleted_);
+      deleted_ = utils::network_to_host(deleted_);
       offset += 4;
 
       memcpy(&flags_, body.data() + offset, sizeof(flags_));
-      flags_ = utils::byte_swap(flags_);
+      flags_ = utils::network_to_host(flags_);
       offset += 4;
 
       memcpy(&expiry_, body.data() + offset, sizeof(expiry_));
-      expiry_ = utils::byte_swap(expiry_);
+      expiry_ = utils::network_to_host(expiry_);
       offset += 4;
 
       memcpy(&sequence_number_, body.data() + offset, sizeof(sequence_number_));
-      sequence_number_ = utils::byte_swap(sequence_number_);
+      sequence_number_ = utils::network_to_host(sequence_number_);
       offset += 8;
 
       datatype_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);

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

@@ -45,7 +45,7 @@ get_replica_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_hello.cxx

@@ -48,7 +48,7 @@ hello_response_body::parse(key_value_status_code status,
     for (size_t i = 0; i < num_features; i++) {
       std::uint16_t field = 0;
       std::memcpy(&field, value + (i * 2), sizeof(std::uint16_t));
-      field = utils::byte_swap(field);
+      field = utils::network_to_host(field);
       if (is_valid_hello_feature(field)) {
         supported_features_.push_back(static_cast<hello_feature>(field));
       }

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

@@ -43,19 +43,19 @@ increment_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;
@@ -84,15 +84,15 @@ increment_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(initial_value_));
 
-  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_insert.cxx

@@ -42,12 +42,12 @@ insert_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;
@@ -74,10 +74,10 @@ insert_request_body::fill_extras()
 {
   extras_.resize(sizeof(flags_) + sizeof(expiry_));
 
-  std::uint32_t field = utils::byte_swap(flags_);
+  std::uint32_t field = utils::host_to_network(flags_);
   memcpy(extras_.data(), &field, sizeof(field));
 
-  field = utils::byte_swap(expiry_);
+  field = utils::host_to_network(expiry_);
   memcpy(extras_.data() + sizeof(flags_), &field, sizeof(field));
 }
 } // namespace couchbase::core::protocol

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

@@ -48,14 +48,14 @@ lookup_in_response_body::parse(key_value_status_code status,
 
       std::uint16_t entry_status = 0;
       memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
-      entry_status = utils::byte_swap(entry_status);
+      entry_status = utils::network_to_host(entry_status);
       Expects(is_valid_status(entry_status));
       field.status = static_cast<key_value_status_code>(entry_status);
       offset += static_cast<offset_type>(sizeof(entry_status));
 
       std::uint32_t entry_size = 0;
       memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-      entry_size = utils::byte_swap(entry_size);
+      entry_size = utils::network_to_host(entry_size);
       Expects(entry_size < 20 * 1024 * 1024);
       offset += static_cast<offset_type>(sizeof(entry_size));
 
@@ -101,7 +101,8 @@ lookup_in_request_body::fill_value()
     ++offset;
     value_[offset] = spec.flags_;
     ++offset;
-    std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
+    std::uint16_t path_size =
+      utils::host_to_network(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
     std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
     offset += sizeof(path_size);
     std::memcpy(value_.data() + offset, spec.path_.data(), spec.path_.size());

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

@@ -47,14 +47,14 @@ lookup_in_replica_response_body::parse(key_value_status_code status,
 
       std::uint16_t entry_status = 0;
       memcpy(&entry_status, body.data() + offset, sizeof(entry_status));
-      entry_status = utils::byte_swap(entry_status);
+      entry_status = utils::network_to_host(entry_status);
       Expects(is_valid_status(entry_status));
       field.status = static_cast<key_value_status_code>(entry_status);
       offset += static_cast<offset_type>(sizeof(entry_status));
 
       std::uint32_t entry_size = 0;
       memcpy(&entry_size, body.data() + offset, sizeof(entry_size));
-      entry_size = utils::byte_swap(entry_size);
+      entry_size = utils::network_to_host(entry_size);
       Expects(entry_size < 20 * 1024 * 1024);
       offset += static_cast<offset_type>(sizeof(entry_size));
 
@@ -100,7 +100,8 @@ lookup_in_replica_request_body::fill_value()
     ++offset;
     value_[offset] = spec.flags_;
     ++offset;
-    std::uint16_t path_size = utils::byte_swap(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
+    std::uint16_t path_size =
+      utils::host_to_network(gsl::narrow_cast<std::uint16_t>(spec.path_.size()));
     std::memcpy(value_.data() + offset, &path_size, sizeof(path_size));
     offset += sizeof(path_size);
     std::memcpy(value_.data() + offset, spec.path_.data(), spec.path_.size());