couchbase 3.5.2 → 3.5.4

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

@@ -23,22 +23,27 @@
 
 #include "base64.h"
 
-#include <algorithm>
+#include <gsl/span>
+
 #include <array>
 #include <cctype>
+#include <cstddef>
 #include <cstdint>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 #include <vector>
 
+namespace
+{
 /**
  * An array of the legal characters used for direct lookup
  */
-static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-                                 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-                                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-                                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-                                 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
+const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+                          'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+                          'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+                          'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+                          '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/' };
 
 /**
  * A method to map the code back to the value
@@ -46,8 +51,8 @@ static const std::array codemap{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J
  * @param code the code to map
  * @return the byte value for the code character
  */
-static std::uint32_t
-code2val(const char code)
+auto
+code2val(const char code) -> std::uint32_t
 {
   if (code >= 'A' && code <= 'Z') {
     return static_cast<std::uint32_t>(code) - static_cast<std::uint32_t>('A');
@@ -67,6 +72,8 @@ code2val(const char code)
   throw std::invalid_argument("couchbase::core::base64::code2val Invalid input character");
 }
 
+// TODO(CXXCBC-549): clang-tidy-19 reports subscript with non-const index
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-constant-array-index)
 /**
  * Encode up to 3 characters to 4 output character.
  *
@@ -74,10 +81,10 @@ code2val(const char code)
  * @param d pointer to the output stream
  * @param num the number of characters from s to encode
  */
-static void
+void
 encode_rest(const std::byte* s, std::string& result, size_t num)
 {
-  std::uint32_t val;
+  std::uint32_t val = 0;
 
   switch (num) {
     case 2:
@@ -106,7 +113,7 @@ encode_rest(const std::byte* s, std::string& result, size_t num)
  * @param s pointer to the input stream
  * @param d pointer to the output stream
  */
-static void
+void
 encode_triplet(const std::byte* s, std::string& str)
 {
   auto val = (static_cast<std::uint32_t>(*s) << 16U) |      //
@@ -117,6 +124,7 @@ encode_triplet(const std::byte* s, std::string& str)
   str.push_back(codemap[(val >> 6U) & 63]);
   str.push_back(codemap[val & 63]);
 }
+// NOLINTEND(cppcoreguidelines-pro-bounds-constant-array-index)
 
 /**
  * decode 4 input characters to up to two output bytes
@@ -125,8 +133,8 @@ encode_triplet(const std::byte* s, std::string& str)
  * @param d destination
  * @return the number of characters inserted
  */
-static int
-decode_quad(const char* s, std::vector<std::byte>& d)
+auto
+decode_quad(const char* s, std::vector<std::byte>& d) -> int
 {
   std::uint32_t value = code2val(s[0]) << 18U;
   value |= code2val(s[1]) << 12U;
@@ -154,11 +162,12 @@ decode_quad(const char* s, std::vector<std::byte>& d)
 
   return ret;
 }
+} // namespace
 
 namespace couchbase::core::base64
 {
-std::string
-encode(gsl::span<const std::byte> blob, bool pretty_print)
+auto
+encode(gsl::span<const std::byte> blob, bool pretty_print) -> std::string
 {
   // base64 encodes up to 3 input characters to 4 output
   // characters in the alphabet above.
@@ -173,7 +182,7 @@ encode(gsl::span<const std::byte> blob, bool pretty_print)
   if (pretty_print) {
     // In pretty-print mode we insert a newline after adding
     // 16 chunks (four characters).
-    result.reserve(chunks * 4 + chunks / 16);
+    result.reserve((chunks * 4) + (chunks / 16));
   } else {
     result.reserve(chunks * 4);
   }
@@ -201,8 +210,8 @@ encode(gsl::span<const std::byte> blob, bool pretty_print)
   return result;
 }
 
-std::vector<std::byte>
-decode(std::string_view blob)
+auto
+decode(std::string_view blob) -> std::vector<std::byte>
 {
   std::vector<std::byte> destination;
 
@@ -213,7 +222,7 @@ decode(std::string_view blob)
   // To reduce the number of reallocations, start by reserving an
   // output buffer of 75% of the input size (and add 3 to avoid dealing
   // with zero)
-  size_t estimate = blob.size() / 100 * 75;
+  const size_t estimate = blob.size() / 100 * 75;
   destination.reserve(estimate + 3);
 
   const auto* in = blob.data();
@@ -238,15 +247,15 @@ decode(std::string_view blob)
   return destination;
 }
 
-std::string
-decode_to_string(std::string_view blob)
+auto
+decode_to_string(std::string_view blob) -> std::string
 {
   auto decoded = decode(blob);
   return { reinterpret_cast<const char*>(decoded.data()), decoded.size() };
 }
 
-std::string
-encode(std::string_view blob, bool pretty_print)
+auto
+encode(std::string_view blob, bool pretty_print) -> std::string
 {
   return encode(gsl::as_bytes(gsl::span{ blob.data(), blob.size() }), pretty_print);
 }

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

@@ -11,6 +11,9 @@
 #include "dirutils.h"
 
 #include <cstring>
+#include <string>
+#include <vector>
+
 #ifdef _MSC_VER
 #include <filesystem>
 
@@ -21,10 +24,12 @@
 
 namespace couchbase::core::platform
 {
-static std::string
-split(const std::string& input, bool directory)
+namespace
+{
+auto
+split(const std::string& input, bool directory) -> std::string
 {
-  std::string::size_type path = input.find_last_of("\\/");
+  const std::string::size_type path = input.find_last_of("\\/");
   std::string file;
   std::string dir;
 
@@ -33,7 +38,7 @@ split(const std::string& input, bool directory)
     file = input;
   } else {
     dir = input.substr(0, path);
-    if (dir.length() == 0) {
+    if (dir.empty()) {
       dir = input.substr(0, 1);
     }
 
@@ -49,15 +54,16 @@ split(const std::string& input, bool directory)
   }
   return file;
 }
+} // namespace
 
-std::string
-dirname(const std::string& dir)
+auto
+dirname(const std::string& dir) -> std::string
 {
   return split(dir, true);
 }
 
-std::string
-basename(const std::string& name)
+auto
+basename(const std::string& name) -> std::string
 {
   return split(name, false);
 }
@@ -93,14 +99,18 @@ find_files_with_prefix(const std::string& dir, const std::string& name)
   return files;
 }
 #else
-std::vector<std::string>
-find_files_with_prefix(const std::string& dir, const std::string& name)
+auto
+find_files_with_prefix(const std::string& dir, const std::string& name) -> std::vector<std::string>
 {
   std::vector<std::string> files;
+  // TODO(CXXCBC-549): clang-tidy-19 reports function is not thread safe
+  // NOLINTNEXTLINE(concurrency-mt-unsafe)
   if (DIR* dp = opendir(dir.c_str()); dp != nullptr) {
-    const struct dirent* de;
+    const struct dirent* de = nullptr;
+    // TODO(CXXCBC-549): clang-tidy-19 reports function is not thread safe
+    // NOLINTNEXTLINE(concurrency-mt-unsafe)
     while ((de = readdir(dp)) != nullptr) {
-      if (std::string fnm(de->d_name); fnm == "." || fnm == "..") {
+      if (const std::string fnm(de->d_name); fnm == "." || fnm == "..") {
         continue;
       }
       if (strncmp(de->d_name, name.c_str(), name.length()) == 0) {
@@ -117,8 +127,8 @@ find_files_with_prefix(const std::string& dir, const std::string& name)
 }
 #endif
 
-std::vector<std::string>
-find_files_with_prefix(const std::string& name)
+auto
+find_files_with_prefix(const std::string& name) -> std::vector<std::string>
 {
   return find_files_with_prefix(dirname(name), basename(name));
 }

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

@@ -19,13 +19,17 @@
 
 #include <cerrno>
 #include <chrono>
+#include <cstddef>
+#include <cstdint>
 #include <memory>
 #include <mutex>
 #include <system_error>
 
 #ifdef WIN32
 // We need to include windows.h _before_ wincrypt.h
+#ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
+#endif
 #include <windows.h>
 
 #include <wincrypt.h>
@@ -50,7 +54,7 @@ public:
                               "initialize random generator");
     }
 #else
-    if ((handle = open("/dev/urandom", O_RDONLY)) == -1) {
+    if (handle = open("/dev/urandom", O_RDONLY | O_CLOEXEC); handle == -1) {
       throw std::system_error(errno,
                               std::system_category(),
                               "RandomGeneratorProvider::Failed to "
@@ -58,6 +62,10 @@ public:
     }
 #endif
   }
+  RandomGeneratorProvider(const RandomGeneratorProvider&) = delete;
+  auto operator=(const RandomGeneratorProvider&) -> RandomGeneratorProvider& = delete;
+  RandomGeneratorProvider(RandomGeneratorProvider&&) = delete;
+  auto operator=(RandomGeneratorProvider&&) -> RandomGeneratorProvider& = delete;
 
   virtual ~RandomGeneratorProvider()
   {
@@ -68,17 +76,19 @@ public:
 #endif
   }
 
-  bool getBytes(void* dest, size_t size)
+  auto getBytes(void* dest, std::size_t size) -> bool
   {
-    std::lock_guard<std::mutex> lock(mutex);
+    const std::lock_guard<std::mutex> lock(mutex);
 #ifdef WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
-    return size_t(read(handle, dest, size)) == size;
+    // TODO(CXXCBC-549)
+    // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
+    return static_cast<std::size_t>(read(handle, dest, size)) == size;
 #endif
   }
 
-protected:
+private:
 #ifdef WIN32
   HCRYPTPROV handle{};
 #else
@@ -94,17 +104,17 @@ RandomGenerator::RandomGenerator()
 {
   if (!shared_provider) {
     // This might be the first one, lets lock and create
-    std::lock_guard<std::mutex> guard(shared_provider_lock);
-    if (!shared_provider) {
+    const std::lock_guard<std::mutex> guard(shared_provider_lock);
+    if (!shared_provider) { // cppcheck-suppress identicalInnerCondition; DCLP
       shared_provider = std::make_unique<RandomGeneratorProvider>();
     }
   }
 }
 
-std::uint64_t
-RandomGenerator::next()
+auto
+RandomGenerator::next() -> std::uint64_t
 {
-  std::uint64_t ret;
+  std::uint64_t ret = 0;
   if (getBytes(&ret, sizeof(ret))) {
     return ret;
   }
@@ -112,8 +122,8 @@ RandomGenerator::next()
   return static_cast<std::uint64_t>(std::chrono::steady_clock::now().time_since_epoch().count());
 }
 
-bool
-RandomGenerator::getBytes(void* dest, size_t size)
+auto
+RandomGenerator::getBytes(void* dest, std::size_t size) -> bool
 {
   return shared_provider->getBytes(dest, size);
 }

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

@@ -34,6 +34,6 @@ public:
 
   std::uint64_t next();
 
-  bool getBytes(void* dest, size_t size);
+  static bool getBytes(void* dest, size_t size);
 };
 } // namespace couchbase::core

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

@@ -17,14 +17,21 @@
 
 #include "string_hex.h"
 
+#include <array>
 #include <cinttypes>
+#include <cstdint>
+#include <cstdio>
 #include <iomanip>
+#include <ios>
 #include <sstream>
 #include <stdexcept>
 #include <string>
+#include <string_view>
 
-static inline std::uint8_t
-from_hex_digit(char c)
+namespace
+{
+inline auto
+from_hex_digit(char c) -> std::uint8_t
 {
   if ('0' <= c && c <= '9') {
     return static_cast<std::uint8_t>(c - '0');
@@ -38,9 +45,10 @@ from_hex_digit(char c)
   throw std::invalid_argument(
     "couchbase::core::from_hex_digit: character was not in hexadecimal range");
 }
+} // namespace
 
-std::uint64_t
-couchbase::core::from_hex(std::string_view buffer)
+auto
+couchbase::core::from_hex(std::string_view buffer) -> std::uint64_t
 {
   std::uint64_t ret = 0;
   if (buffer.size() > 16) {
@@ -48,54 +56,55 @@ couchbase::core::from_hex(std::string_view buffer)
                               std::to_string(buffer.size()));
   }
 
-  for (char digit : buffer) {
+  for (const char digit : buffer) {
     ret = (ret << 4) | from_hex_digit(digit);
   }
 
   return ret;
 }
 
-std::string
-couchbase::core::to_hex(std::uint8_t val)
+auto
+couchbase::core::to_hex(std::uint8_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%02" PRIx8, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint16_t val)
+auto
+couchbase::core::to_hex(std::uint16_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%04" PRIx16, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint32_t val)
+auto
+couchbase::core::to_hex(std::uint32_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%08" PRIx32, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::uint64_t val)
+auto
+couchbase::core::to_hex(std::uint64_t val) -> std::string
 {
-  char buf[32];
-  snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
-  return std::string{ buf };
+  std::array<char, 32> buf{};
+  snprintf(buf.data(), buf.size(), "0x%016" PRIx64, val);
+  return std::string{ buf.data() };
 }
 
-std::string
-couchbase::core::to_hex(std::string_view buffer)
+auto
+couchbase::core::to_hex(std::string_view buffer) -> std::string
 {
   if (buffer.empty()) {
     return "";
   }
   std::stringstream ss;
   for (const auto& c : buffer) {
-    ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << std::uint32_t(c) << " ";
+    ss << "0x" << std::hex << std::setfill('0') << std::setw(2) << static_cast<std::uint32_t>(c)
+       << " ";
   }
   auto ret = ss.str();
   ret.resize(ret.size() - 1);

data/ext/couchbase/core/platform/string_hex.h

@@ -17,6 +17,7 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 #include <string_view>
 
 namespace couchbase::core

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

@@ -21,17 +21,21 @@
 #include "core/logger/logger.hxx"
 #include "core/meta/version.hxx"
 
+#include <array>
+#include <cstdio>
 #include <cstdlib>
 #include <exception>
 
 namespace couchbase::core::platform
 {
-static bool should_include_backtrace = true;
-static std::terminate_handler default_terminate_handler = nullptr;
+namespace
+{
+bool should_include_backtrace = true;
+std::terminate_handler default_terminate_handler = nullptr;
 
 // Logs details on the handled exception. Attempts to log to
 // `terminate_logger` if non-null; otherwise prints to stderr.
-static void
+void
 log_handled_exception()
 {
 #ifdef WIN32
@@ -46,7 +50,7 @@ log_handled_exception()
     // try once to re-throw currently active exception (so we can print
     // its what() message).
     if (tried_throw++ == 0) {
-      throw;
+      std::rethrow_exception(std::current_exception());
     }
   } catch (const std::exception& e) {
     CB_LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
@@ -57,18 +61,16 @@ log_handled_exception()
 }
 
 // Log the symbolified backtrace to this point.
-static void
+void
 log_backtrace()
 {
-  static const char format_str[] = "Call stack:\n%s";
-
-  char buffer[8192];
-  if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
-    CB_LOG_CRITICAL("Call stack:\n{}", buffer);
+  std::array<char, 8192> buffer{};
+  if (print_backtrace_to_buffer("    ", buffer.data(), buffer.size())) {
+    CB_LOG_CRITICAL("Call stack:\n{}", buffer.data());
   } else {
     // Exceeded buffer space - print directly to stderr FD (requires no
     // buffering, but has the disadvantage that we don't get it in the log).
-    fprintf(stderr, format_str, "");
+    fprintf(stderr, "Call stack:\n%s", "");
     print_backtrace_to_file(stderr);
     fflush(stderr);
     CB_LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
@@ -77,7 +79,7 @@ log_backtrace()
 
 // Replacement terminate_handler which prints the exception's what() and a
 // backtrace of the current stack before chaining to the default handler.
-static void
+void
 backtrace_terminate_handler()
 {
   static bool meta_reported = false;
@@ -107,6 +109,7 @@ backtrace_terminate_handler()
 
   std::abort();
 }
+} // namespace
 
 void
 install_backtrace_terminate_handler()

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

@@ -19,8 +19,12 @@
 
 #include "string_hex.h"
 
-#include <iomanip>
+#include <cstddef>
+#include <cstdint>
 #include <random>
+#include <stdexcept>
+#include <string>
+#include <string_view>
 
 void
 couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
@@ -38,16 +42,16 @@ couchbase::core::uuid::random(couchbase::core::uuid::uuid_t& uuid)
   uuid[6] |= 0x40;
 }
 
-couchbase::core::uuid::uuid_t
-couchbase::core::uuid::random()
+auto
+couchbase::core::uuid::random() -> couchbase::core::uuid::uuid_t
 {
   uuid_t ret;
   random(ret);
   return ret;
 }
 
-couchbase::core::uuid::uuid_t
-couchbase::core::uuid::from_string(std::string_view str)
+auto
+couchbase::core::uuid::from_string(std::string_view str) -> couchbase::core::uuid::uuid_t
 {
   uuid_t ret;
   if (str.size() != 36) {
@@ -66,16 +70,19 @@ couchbase::core::uuid::from_string(std::string_view str)
           throw std::invalid_argument("couchbase::core::uuid::from_string: hyphen not found where "
                                       "expected");
         }
-        ++ii; // fall-through
+        ++ii;
+        [[fallthrough]];
       default:
-        ret[jj++] = std::uint8_t(from_hex({ str.data() + ii, 2 }));
+        // TODO(CXXCBC-549): clang-tidy-19 reports issue with subscript
+        // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
+        ret[jj++] = static_cast<std::uint8_t>(from_hex({ str.data() + ii, 2 }));
     }
   }
   return ret;
 }
 
-inline char
-to_char(std::uint8_t c)
+inline auto
+to_char(std::uint8_t c) -> char
 {
   if (c <= 9) {
     return static_cast<char>('0' + c);
@@ -83,8 +90,8 @@ to_char(std::uint8_t c)
   return static_cast<char>('a' + (c - 10));
 }
 
-std::string
-couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid)
+auto
+couchbase::core::uuid::to_string(const couchbase::core::uuid::uuid_t& uuid) -> std::string
 {
   std::string ret(36, '-');
   std::size_t i = 0;

data/ext/couchbase/core/platform/uuid.h

@@ -34,23 +34,23 @@ random(uuid_t& uuid);
 /**
  * Generate a new random uuid and return it
  */
-uuid_t
-random();
+auto
+random() -> uuid_t;
 
 /**
  * Convert a textual version of a UUID to a uuid type
  * @throw std::invalid_argument if the textual uuid is not
  *        formatted correctly
  */
-uuid_t
-from_string(std::string_view str);
+auto
+from_string(std::string_view str) -> uuid_t;
 
 /**
  * Print a textual version of the UUID in the form:
  *
  *     00000000-0000-0000-0000-000000000000
  */
-std::string
-to_string(const couchbase::core::uuid::uuid_t& uuid);
+auto
+to_string(const couchbase::core::uuid::uuid_t& uuid) -> std::string;
 
 } // namespace couchbase::core::uuid

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

@@ -29,7 +29,7 @@ compress_value(const std::vector<std::byte>& value,
   static const double min_ratio = 0.83;
 
   std::string compressed;
-  std::size_t compressed_size =
+  const std::size_t compressed_size =
     snappy::Compress(reinterpret_cast<const char*>(value.data()), value.size(), &compressed);
   if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(value.size()) <
       min_ratio) {

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

@@ -29,8 +29,6 @@
 #include <cstring>
 #include <gsl/util>
 
-#include <iostream>
-
 namespace couchbase::core::protocol
 {
 auto
@@ -127,7 +125,7 @@ private:
     std::vector<std::byte> payload(header_size + body_.size(), std::byte{});
     payload[0] = static_cast<std::byte>(magic_);
     payload[1] = static_cast<std::byte>(opcode_);
-#if defined(__GNUC__) && __GNUC__ == 8
+#if defined(__GNUC__) && __GNUC__ >= 8 && __GNUC__ < 12
 #pragma GCC diagnostic pop
 #endif
     const auto& framing_extras = body_.framing_extras();