couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/origin.hxx

@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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.
+ */
+
+#pragma once
+
+#include "core/utils/connection_string.hxx"
+
+#include <fmt/core.h>
+
+#include <string>
+#include <utility>
+
+namespace couchbase::core
+{
+struct cluster_credentials {
+    std::string username{};
+    std::string password{};
+    std::string certificate_path{};
+    std::string key_path{};
+    std::vector<std::string> allowed_sasl_mechanisms{ "SCRAM-SHA512", "SCRAM-SHA256", "SCRAM-SHA1", "PLAIN" };
+
+    [[nodiscard]] bool uses_certificate() const
+    {
+        return !certificate_path.empty();
+    }
+};
+
+struct origin {
+    using node_entry = std::pair<std::string, std::string>;
+    using node_list = std::vector<node_entry>;
+
+    origin() = default;
+
+    ~origin() = default;
+
+    origin(origin&& other) = default;
+
+    origin(const origin& other)
+      : options_(other.options_)
+      , credentials_(other.credentials_)
+      , nodes_(other.nodes_)
+      , next_node_(nodes_.begin())
+    {
+    }
+
+    origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, cluster_options options)
+      : options_(std::move(options))
+      , credentials_(std::move(auth))
+      , nodes_{ { hostname, std::to_string(port) } }
+      , next_node_(nodes_.begin())
+    {
+    }
+
+    origin(cluster_credentials auth, const std::string& hostname, const std::string& port, cluster_options options)
+      : options_(std::move(options))
+      , credentials_(std::move(auth))
+      , nodes_{ { hostname, port } }
+      , next_node_(nodes_.begin())
+    {
+    }
+
+    origin(cluster_credentials auth, const utils::connection_string& connstr)
+      : options_(connstr.options)
+      , credentials_(std::move(auth))
+    {
+        nodes_.reserve(connstr.bootstrap_nodes.size());
+        for (const auto& node : connstr.bootstrap_nodes) {
+            nodes_.emplace_back(node.address, node.port > 0 ? std::to_string(node.port) : std::to_string(connstr.default_port));
+        }
+        next_node_ = nodes_.begin();
+    }
+
+    origin& operator=(origin&& other) = default;
+
+    origin& operator=(const origin& other)
+    {
+        if (this != &other) {
+            options_ = other.options_;
+            credentials_ = other.credentials_;
+            nodes_ = other.nodes_;
+            next_node_ = nodes_.begin();
+            exhausted_ = false;
+        }
+        return *this;
+    }
+
+    [[nodiscard]] const std::string& username() const
+    {
+        return credentials_.username;
+    }
+
+    [[nodiscard]] const std::string& password() const
+    {
+        return credentials_.password;
+    }
+
+    [[nodiscard]] const std::string& certificate_path() const
+    {
+        return credentials_.certificate_path;
+    }
+
+    [[nodiscard]] const std::string& key_path() const
+    {
+        return credentials_.key_path;
+    }
+
+    [[nodiscard]] std::vector<std::string> get_hostnames() const
+    {
+        std::vector<std::string> res;
+        res.reserve(nodes_.size());
+        for (const auto& [hostname, _] : nodes_) {
+            res.emplace_back(hostname);
+        }
+        return res;
+    }
+
+    [[nodiscard]] std::vector<std::string> get_nodes() const
+    {
+        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 set_nodes(node_list nodes)
+    {
+        nodes_ = std::move(nodes);
+        next_node_ = nodes_.begin();
+        exhausted_ = false;
+    }
+
+    [[nodiscard]] std::pair<std::string, std::string> next_address()
+    {
+        if (exhausted_) {
+            restart();
+        }
+
+        auto address = *next_node_;
+        if (++next_node_ == nodes_.end()) {
+            exhausted_ = true;
+        }
+        return address;
+    }
+
+    [[nodiscard]] bool exhausted() const
+    {
+        return exhausted_;
+    }
+
+    void restart()
+    {
+        exhausted_ = false;
+        next_node_ = nodes_.begin();
+    }
+
+    [[nodiscard]] const couchbase::core::cluster_options& options() const
+    {
+        return options_;
+    }
+
+    [[nodiscard]] couchbase::core::cluster_options& options()
+    {
+        return options_;
+    }
+
+    [[nodiscard]] const couchbase::core::cluster_credentials& credentials() const
+    {
+        return credentials_;
+    }
+
+  private:
+    couchbase::core::cluster_options options_{};
+    cluster_credentials credentials_{};
+    node_list nodes_{};
+    node_list::iterator next_node_{};
+    bool exhausted_{ false };
+};
+
+} // namespace couchbase::core

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/platform/CMakeLists.txt

@@ -0,0 +1,16 @@
+add_library(couchbase_backtrace OBJECT backtrace.c)
+target_include_directories(couchbase_backtrace PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
+target_link_libraries(couchbase_backtrace PRIVATE ${PLATFORM_LIBRARIES})
+set_target_properties(couchbase_backtrace PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+add_library(
+  couchbase_platform STATIC
+        dirutils.cc
+        random.cc
+        string_hex.cc
+        uuid.cc
+        base64.cc
+        terminate_handler.cc)
+set_target_properties(couchbase_platform PROPERTIES POSITION_INDEPENDENT_CODE ON)
+target_include_directories(couchbase_platform PRIVATE ${PROJECT_BINARY_DIR}/generated ../..)
+target_link_libraries(couchbase_platform PRIVATE project_options project_warnings couchbase_backtrace)

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/platform/backtrace.c

@@ -0,0 +1,189 @@
+/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2015 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 "backtrace.h"
+
+#include <inttypes.h>
+
+#if defined(WIN32) && defined(HAVE_BACKTRACE_SUPPORT)
+#define WIN32_LEAN_AND_MEAN
+#include <Dbghelp.h>
+#include <windows.h>
+#endif
+
+#if defined(HAVE_BACKTRACE) && defined(HAVE_DLADDR)
+#define HAVE_BACKTRACE_SUPPORT 1
+#include <dlfcn.h>    // for dladdr()
+#include <execinfo.h> // for backtrace()
+#include <stddef.h>   // for ptrdiff_t
+#endif
+
+// Maximum number of frames that will be printed.
+#define MAX_FRAMES 50
+
+#if defined(HAVE_BACKTRACE_SUPPORT)
+/**
+ * Populates buf with a description of the given address in the program.
+ **/
+static void
+describe_address(char* msg, size_t len, void* addr)
+{
+#if defined(WIN32)
+
+    // Get module information
+    IMAGEHLP_MODULE64 module_info;
+    module_info.SizeOfStruct = sizeof(IMAGEHLP_MODULE64);
+    SymGetModuleInfo64(GetCurrentProcess(), (DWORD64)addr, &module_info);
+
+    // Get symbol information.
+    DWORD64 displacement = 0;
+    char buffer[sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR)];
+    PSYMBOL_INFO sym_info = (PSYMBOL_INFO)buffer;
+    sym_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+    sym_info->MaxNameLen = MAX_SYM_NAME;
+
+    if (SymFromAddr(GetCurrentProcess(), (DWORD64)addr, &displacement, sym_info)) {
+        snprintf(msg, len, "%s(%s+%lld) [0x%p]", module_info.ImageName ? module_info.ImageName : "", sym_info->Name, displacement, addr);
+    } else {
+        // No symbol found.
+        snprintf(msg, len, "[0x%p]", addr);
+    }
+#else  // !WIN32
+    Dl_info info;
+    int status = dladdr(addr, &info);
+
+    if (status != 0) {
+        ptrdiff_t image_offset = (char*)addr - (char*)info.dli_fbase;
+        if (info.dli_fname != NULL && info.dli_fname[0] != '\0') {
+            // Found a nearest symbol - print it.
+            if (info.dli_saddr == 0) {
+                // No function offset calculation possible.
+                snprintf(msg,
+                         len,
+                         "%s(%s) [%p+0x%" PRIx64 "]",
+                         info.dli_fname,
+                         info.dli_sname ? info.dli_sname : "",
+                         info.dli_fbase,
+                         (uint64_t)image_offset);
+            } else {
+                char sign;
+                ptrdiff_t offset;
+                if (addr >= info.dli_saddr) {
+                    sign = '+';
+                    offset = (char*)addr - (char*)info.dli_saddr;
+                } else {
+                    sign = '-';
+                    offset = (char*)info.dli_saddr - (char*)addr;
+                }
+                snprintf(msg,
+                         len,
+                         "%s(%s%c%#tx) [%p+0x%" PRIx64 "]",
+                         info.dli_fname,
+                         info.dli_sname ? info.dli_sname : "",
+                         sign,
+                         offset,
+                         info.dli_fbase,
+                         (uint64_t)image_offset);
+            }
+        } else {
+            // No function found; just print library name and offset.
+            snprintf(msg, len, "%s [%p+0x%" PRIx64 "]", info.dli_fname, info.dli_fbase, (uint64_t)image_offset);
+        }
+    } else {
+        // dladdr failed.
+        snprintf(msg, len, "[%p]", addr);
+    }
+#endif // WIN32
+}
+
+void
+print_backtrace(write_cb_t write_cb, void* context)
+{
+    void* frames[MAX_FRAMES];
+#if defined(WIN32)
+    int active_frames = CaptureStackBackTrace(0, MAX_FRAMES, frames, NULL);
+    SymInitialize(GetCurrentProcess(), NULL, TRUE);
+#else
+    int active_frames = backtrace(frames, MAX_FRAMES);
+#endif
+
+    // Note we start from 1 to skip our own frame.
+    for (int ii = 1; ii < active_frames; ii++) {
+        // Fixed-sized buffer; possible that description will be cropped.
+        char msg[300];
+        describe_address(msg, sizeof(msg), frames[ii]);
+        write_cb(context, msg);
+    }
+    if (active_frames == MAX_FRAMES) {
+        write_cb(context, "<frame limit reached, possible truncation>");
+    }
+}
+
+#else // if defined(HAVE_BACKTRACE_SUPPORT)
+
+void
+print_backtrace(write_cb_t write_cb, void* context)
+{
+    write_cb(context, "<backtrace not supported on this platform>");
+}
+
+#endif // defined(HAVE_BACKTRACE_SUPPORT)
+
+static void
+print_to_file_cb(void* ctx, const char* frame)
+{
+    fprintf(ctx, "\t%s\n", frame);
+}
+
+void
+print_backtrace_to_file(FILE* stream)
+{
+    print_backtrace(print_to_file_cb, stream);
+}
+
+struct context {
+    const char* indent;
+    char* buffer;
+    size_t size;
+    size_t offset;
+    bool error;
+};
+
+static void
+memory_cb(void* ctx, const char* frame)
+{
+    struct context* c = ctx;
+
+    if (!c->error) {
+
+        int length = snprintf(c->buffer + c->offset, c->size - c->offset, "%s%s\n", c->indent, frame);
+
+        if ((length < 0) || (length >= (int)(c->size - c->offset))) {
+            c->error = true;
+        } else {
+            c->offset += (size_t)length;
+        }
+    }
+}
+
+bool
+print_backtrace_to_buffer(const char* indent, char* buffer, size_t size)
+{
+    struct context c = { .indent = indent, .buffer = buffer, .size = size, .offset = 0, .error = false };
+    print_backtrace(memory_cb, &c);
+    return !c.error;
+}

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/platform/base64.cc

@@ -0,0 +1,234 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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.
+ */
+
+/*
+ * Function to base64 encode and decode text as described in RFC 4648
+ *
+ * @author Trond Norbye
+ */
+
+#include "base64.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdint>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+/**
+ * An array of the legal characters used for direct lookup
+ */
+static const std::uint8_t codemap[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * A method to map the code back to the value
+ *
+ * @param code the code to map
+ * @return the byte value for the code character
+ */
+static std::uint32_t
+code2val(const std::uint8_t code)
+{
+    if (code >= 'A' && code <= 'Z') {
+        return std::uint32_t(code) - 'A';
+    }
+    if (code >= 'a' && code <= 'z') {
+        return std::uint32_t(code) - 'a' + std::uint8_t(26);
+    }
+    if (code >= '0' && code <= '9') {
+        return std::uint32_t(code) - '0' + std::uint8_t(52);
+    }
+    if (code == '+') {
+        return std::uint32_t(62);
+    }
+    if (code == '/') {
+        return std::uint32_t(63);
+    }
+    throw std::invalid_argument("couchbase::core::base64::code2val Invalid input character");
+}
+
+/**
+ * Encode up to 3 characters to 4 output character.
+ *
+ * @param s pointer to the input stream
+ * @param d pointer to the output stream
+ * @param num the number of characters from s to encode
+ */
+static void
+encode_rest(const std::uint8_t* s, std::string& result, size_t num)
+{
+    std::uint32_t val = 0;
+
+    switch (num) {
+        case 2:
+            val = static_cast<std::uint32_t>((*s << 16U) | (*(s + 1) << 8U));
+            break;
+        case 1:
+            val = static_cast<std::uint32_t>((*s << 16U));
+            break;
+        default:
+            throw std::invalid_argument("base64::encode_rest num may be 1 or 2");
+    }
+
+    result.push_back(static_cast<char>(codemap[(val >> 18U) & 63]));
+    result.push_back(static_cast<char>(codemap[(val >> 12U) & 63]));
+    if (num == 2) {
+        result.push_back(static_cast<char>(codemap[(val >> 6U) & 63]));
+    } else {
+        result.push_back('=');
+    }
+    result.push_back('=');
+}
+
+/**
+ * Encode 3 bytes to 4 output character.
+ *
+ * @param s pointer to the input stream
+ * @param d pointer to the output stream
+ */
+static void
+encode_triplet(const std::uint8_t* s, std::string& str)
+{
+    auto val = static_cast<std::uint32_t>((*s << 16U) | (*(s + 1) << 8U) | (*(s + 2)));
+    str.push_back(static_cast<char>(codemap[(val >> 18U) & 63]));
+    str.push_back(static_cast<char>(codemap[(val >> 12U) & 63]));
+    str.push_back(static_cast<char>(codemap[(val >> 6U) & 63]));
+    str.push_back(static_cast<char>(codemap[val & 63]));
+}
+
+/**
+ * decode 4 input characters to up to two output bytes
+ *
+ * @param s source string
+ * @param d destination
+ * @return the number of characters inserted
+ */
+static int
+decode_quad(const std::uint8_t* s, std::string& d)
+{
+    std::uint32_t value = code2val(s[0]) << 18U;
+    value |= code2val(s[1]) << 12U;
+
+    int ret = 3;
+
+    if (s[2] == '=') {
+        ret = 1;
+    } else {
+        value |= code2val(s[2]) << 6U;
+        if (s[3] == '=') {
+            ret = 2;
+        } else {
+            value |= code2val(s[3]);
+        }
+    }
+
+    d.push_back(static_cast<char>(value >> 16U));
+    if (ret > 1) {
+        d.push_back(static_cast<char>(value >> 8U));
+        if (ret > 2) {
+            d.push_back(static_cast<char>(value));
+        }
+    }
+
+    return ret;
+}
+
+namespace couchbase::core::base64
+{
+std::string
+encode(const std::string_view blob, bool prettyprint)
+{
+    // base64 encoding encodes up to 3 input characters to 4 output
+    // characters in the alphabet above.
+    auto triplets = blob.size() / 3;
+    auto rest = blob.size() % 3;
+    auto chunks = triplets;
+    if (rest != 0) {
+        ++chunks;
+    }
+
+    std::string result;
+    if (prettyprint) {
+        // In pretty-print mode we insert a newline after adding
+        // 16 chunks (four characters).
+        result.reserve(chunks * 4 + chunks / 16);
+    } else {
+        result.reserve(chunks * 4);
+    }
+
+    const auto* in = reinterpret_cast<const std::uint8_t*>(blob.data());
+
+    chunks = 0;
+    for (size_t ii = 0; ii < triplets; ++ii) {
+        encode_triplet(in, result);
+        in += 3;
+
+        if (prettyprint && (++chunks % 16) == 0) {
+            result.push_back('\n');
+        }
+    }
+
+    if (rest > 0) {
+        encode_rest(in, result, rest);
+    }
+
+    if (prettyprint && result.back() != '\n') {
+        result.push_back('\n');
+    }
+
+    return result;
+}
+
+std::string
+decode(std::string_view blob)
+{
+    std::string destination;
+
+    if (blob.empty()) {
+        return destination;
+    }
+
+    // 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;
+    destination.reserve(estimate + 3);
+
+    const auto* in = reinterpret_cast<const std::uint8_t*>(blob.data());
+    size_t offset = 0;
+    while (offset < blob.size()) {
+        if (std::isspace(static_cast<int>(*in)) != 0) {
+            ++offset;
+            ++in;
+            continue;
+        }
+
+        // We need at least 4 bytes
+        if ((offset + 4) > blob.size()) {
+            throw std::invalid_argument("couchbase::core::base64::decode invalid input");
+        }
+
+        decode_quad(in, destination);
+        in += 4;
+        offset += 4;
+    }
+
+    return destination;
+}
+
+} // namespace couchbase::core::base64

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/platform/base64.h

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2016 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.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace couchbase::core::base64
+{
+
+/**
+ * Base64 encode data
+ *
+ * @param source the string to encode
+ * @return the base64 encoded value
+ */
+std::string
+encode(std::string_view blob, bool prettyprint = false);
+
+/**
+ * Decode a base64 encoded blob (which may be pretty-printed to avoid
+ * super-long lines)
+ *
+ * @param source string to decode
+ * @return the decoded data
+ */
+std::string
+decode(std::string_view blob);
+
+} // namespace couchbase::core::base64