couchbase 4.1.2 → 4.1.3

package/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

package/deps/couchbase-cxx-client/core/platform/dirutils.cc

@@ -0,0 +1,123 @@
+/*
+ *     Copyright 2013-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+
+#include "dirutils.h"
+
+#include <cstring>
+#ifdef _MSC_VER
+#include <filesystem>
+
+#include <windows.h>
+#else
+#include <dirent.h>
+#endif
+
+namespace couchbase::core::platform
+{
+static std::string
+split(const std::string& input, bool directory)
+{
+    std::string::size_type path = input.find_last_of("\\/");
+    std::string file;
+    std::string dir;
+
+    if (path == std::string::npos) {
+        dir = ".";
+        file = input;
+    } else {
+        dir = input.substr(0, path);
+        if (dir.length() == 0) {
+            dir = input.substr(0, 1);
+        }
+
+        while (dir.length() > 1 && dir.find_last_of("\\/") == (dir.length() - 1)) {
+            dir.resize(dir.length() - 1);
+        }
+
+        file = input.substr(path + 1);
+    }
+
+    if (directory) {
+        return dir;
+    }
+    return file;
+}
+
+std::string
+dirname(const std::string& dir)
+{
+    return split(dir, true);
+}
+
+std::string
+basename(const std::string& name)
+{
+    return split(name, false);
+}
+
+#ifdef _MSC_VER
+std::vector<std::string>
+find_files_with_prefix(const std::string& dir, const std::string& name)
+{
+    std::vector<std::string> files;
+    auto match = std::filesystem::path(dir) / (name + "*");
+    WIN32_FIND_DATAW FindFileData;
+
+    HANDLE hFind = FindFirstFileExW(match.c_str(), FindExInfoStandard, &FindFileData, FindExSearchNameMatch, NULL, 0);
+
+    if (hFind != INVALID_HANDLE_VALUE) {
+        do {
+            std::wstring fn = FindFileData.cFileName;
+            std::string fnm(fn.length(), 0);
+            std::transform(fn.begin(), fn.end(), fnm.begin(), [](wchar_t c) { return static_cast<char>(c); });
+            if (fnm != "." && fnm != "..") {
+                std::string entry = dir;
+                entry.append("\\");
+                entry.append(fnm);
+                files.push_back(entry);
+            }
+        } while (FindNextFileW(hFind, &FindFileData));
+
+        FindClose(hFind);
+    }
+    return files;
+}
+#else
+std::vector<std::string>
+find_files_with_prefix(const std::string& dir, const std::string& name)
+{
+    std::vector<std::string> files;
+    if (DIR* dp = opendir(dir.c_str()); dp != nullptr) {
+        const struct dirent* de;
+        while ((de = readdir(dp)) != nullptr) {
+            if (std::string fnm(de->d_name); fnm == "." || fnm == "..") {
+                continue;
+            }
+            if (strncmp(de->d_name, name.c_str(), name.length()) == 0) {
+                std::string entry = dir;
+                entry.append("/");
+                entry.append(de->d_name);
+                files.push_back(entry);
+            }
+        }
+
+        closedir(dp);
+    }
+    return files;
+}
+#endif
+
+std::vector<std::string>
+find_files_with_prefix(const std::string& name)
+{
+    return find_files_with_prefix(dirname(name), basename(name));
+}
+
+} // namespace couchbase::core::platform

package/deps/couchbase-cxx-client/core/platform/dirutils.h

@@ -0,0 +1,43 @@
+/*
+ *     Copyright 2016-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace couchbase::core::platform
+{
+/**
+ * Return the directory part of an absolute path
+ */
+std::string
+dirname(const std::string& dir);
+
+/**
+ * Return the filename part of an absolute path
+ */
+std::string
+basename(const std::string& name);
+
+/**
+ * Return a vector containing all of the files starting with a given
+ * name stored in a given directory
+ */
+std::vector<std::string>
+find_files_with_prefix(const std::string& dir, const std::string& name);
+
+/**
+ * Return a vector containing all of the files starting with a given
+ * name specified with this absolute path
+ */
+std::vector<std::string>
+find_files_with_prefix(const std::string& name);
+
+} // namespace couchbase::core::platform

package/deps/couchbase-cxx-client/core/platform/random.cc

@@ -0,0 +1,120 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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 "random.h"
+
+#include <cerrno>
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <system_error>
+
+#ifdef WIN32
+// We need to include windows.h _before_ wincrypt.h
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#include <wincrypt.h>
+#else
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+
+namespace couchbase::core
+{
+class RandomGeneratorProvider
+{
+  public:
+    RandomGeneratorProvider()
+    {
+#ifdef WIN32
+        if (!CryptAcquireContext(&handle, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
+            throw std::system_error(int(GetLastError()),
+                                    std::system_category(),
+                                    "RandomGeneratorProvider::Failed to "
+                                    "initialize random generator");
+        }
+#else
+        if ((handle = open("/dev/urandom", O_RDONLY)) == -1) {
+            throw std::system_error(errno,
+                                    std::system_category(),
+                                    "RandomGeneratorProvider::Failed to "
+                                    "initialize random generator");
+        }
+#endif
+    }
+
+    virtual ~RandomGeneratorProvider()
+    {
+#ifdef WIN32
+        CryptReleaseContext(handle, 0);
+#else
+        close(handle);
+#endif
+    }
+
+    bool getBytes(void* dest, size_t size)
+    {
+        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;
+#endif
+    }
+
+  protected:
+#ifdef WIN32
+    HCRYPTPROV handle{};
+#else
+    int handle = -1;
+#endif
+    std::mutex mutex;
+};
+
+std::mutex shared_provider_lock;
+std::unique_ptr<RandomGeneratorProvider> shared_provider;
+
+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) {
+            shared_provider = std::make_unique<RandomGeneratorProvider>();
+        }
+    }
+}
+
+std::uint64_t
+RandomGenerator::next()
+{
+    std::uint64_t ret;
+    if (getBytes(&ret, sizeof(ret))) {
+        return ret;
+    }
+
+    return static_cast<std::uint64_t>(std::chrono::steady_clock::now().time_since_epoch().count());
+}
+
+bool
+RandomGenerator::getBytes(void* dest, size_t size)
+{
+    return shared_provider->getBytes(dest, size);
+}
+
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/platform/random.h

@@ -0,0 +1,39 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2014 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 <cstddef>
+#include <cstdint>
+
+namespace couchbase::core
+{
+class RandomGeneratorProvider;
+
+/**
+ * The RandomGenerator use windows crypto framework on windows and
+ * /dev/urandom on the other platforms in order to get random data.
+ */
+class RandomGenerator
+{
+  public:
+    RandomGenerator();
+
+    std::uint64_t next();
+
+    bool getBytes(void* dest, size_t size);
+};
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/platform/string_hex.cc

@@ -0,0 +1,101 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017 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 "string_hex.h"
+
+#include <cinttypes>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+static inline std::uint8_t
+from_hex_digit(char c)
+{
+    if ('0' <= c && c <= '9') {
+        return static_cast<std::uint8_t>(c - '0');
+    }
+    if ('A' <= c && c <= 'F') {
+        return static_cast<std::uint8_t>(c + 10 - 'A');
+    }
+    if ('a' <= c && c <= 'f') {
+        return static_cast<std::uint8_t>(c + 10 - 'a');
+    }
+    throw std::invalid_argument("couchbase::core::from_hex_digit: character was not in hexadecimal range");
+}
+
+std::uint64_t
+couchbase::core::from_hex(std::string_view buffer)
+{
+    std::uint64_t ret = 0;
+    if (buffer.size() > 16) {
+        throw std::overflow_error("couchbase::core::from_hex: input string too long: " + std::to_string(buffer.size()));
+    }
+
+    for (char digit : buffer) {
+        ret = (ret << 4) | from_hex_digit(digit);
+    }
+
+    return ret;
+}
+
+std::string
+couchbase::core::to_hex(std::uint8_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::core::to_hex(std::uint16_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::core::to_hex(std::uint32_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::core::to_hex(std::uint64_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::core::to_hex(std::string_view buffer)
+{
+    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) << " ";
+    }
+    auto ret = ss.str();
+    ret.resize(ret.size() - 1);
+    return ret;
+}

package/deps/couchbase-cxx-client/core/platform/string_hex.h

@@ -0,0 +1,50 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2017 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 <cstdint>
+#include <string_view>
+
+namespace couchbase::core
+{
+/**
+ * Get the value for a string of hex characters
+ *
+ * @param buffer the input buffer
+ * @return the value of the string
+ * @throws std::invalid_argument for an invalid character in the string
+ *         std::overflow_error if the input string won't fit in std::uint64_t
+ */
+std::uint64_t
+from_hex(std::string_view buffer);
+
+std::string
+to_hex(std::uint8_t val);
+
+std::string
+to_hex(std::uint16_t val);
+
+std::string
+to_hex(std::uint32_t val);
+
+std::string
+to_hex(std::uint64_t val);
+
+std::string
+to_hex(std::string_view buffer);
+
+} // namespace couchbase::core

package/deps/couchbase-cxx-client/core/platform/terminate_handler.cc

@@ -0,0 +1,125 @@
+/* -*- 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.
+ */
+
+#include "terminate_handler.h"
+
+#include "backtrace.h"
+#include "core/logger/logger.hxx"
+#include "core/meta/version.hxx"
+
+#include <cstdlib>
+#include <exception>
+
+namespace couchbase::core::platform
+{
+static bool should_include_backtrace = true;
+static 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
+log_handled_exception()
+{
+#ifdef WIN32
+    // Windows doesn't like us re-throwing the exception in the handler (and
+    // seems to result in immediate process termination). As such skip logging
+    // the exception here.
+    return;
+#else
+    // Attempt to get the exception's what() message.
+    try {
+        static int tried_throw = 0;
+        // try once to re-throw currently active exception (so we can print
+        // its what() message).
+        if (tried_throw++ == 0) {
+            throw;
+        }
+    } catch (const std::exception& e) {
+        LOG_CRITICAL("Caught unhandled std::exception-derived exception. what(): {}", e.what());
+    } catch (...) {
+        LOG_CRITICAL_RAW("Caught unknown/unhandled exception.");
+    }
+#endif
+}
+
+// Log the symbolified backtrace to this point.
+static void
+log_backtrace()
+{
+    static const char format_str[] = "Call stack:\n%s";
+
+    char buffer[8192];
+    if (print_backtrace_to_buffer("    ", buffer, sizeof(buffer))) {
+        LOG_CRITICAL("Call stack:\n{}", buffer);
+    } 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, "");
+        print_backtrace_to_file(stderr);
+        fflush(stderr);
+        LOG_CRITICAL_RAW("Call stack exceeds 8k, rendered to STDERR");
+    }
+}
+
+// Replacement terminate_handler which prints the exception's what() and a
+// backtrace of the current stack before chaining to the default handler.
+static void
+backtrace_terminate_handler()
+{
+    static bool meta_reported = false;
+    if (!meta_reported) {
+        LOG_CRITICAL(R"(*** Fatal error encountered during exception handling ({}) ***)", meta::sdk_build_info_short());
+        meta_reported = true;
+    }
+    log_handled_exception();
+
+    if (should_include_backtrace) {
+        log_backtrace();
+    }
+
+    // Chain to the default handler if available (as it may be able to print
+    // other useful information on why we were told to terminate).
+    if (default_terminate_handler != nullptr && default_terminate_handler != backtrace_terminate_handler) {
+        default_terminate_handler();
+    }
+
+#if !defined(HAVE_BREAKPAD)
+    // Shut down the logger (and flush everything). If breakpad is installed
+    // then we'll let it do it.
+    logger::shutdown();
+#endif
+
+    std::abort();
+}
+
+void
+install_backtrace_terminate_handler()
+{
+    if (default_terminate_handler != nullptr) {
+        // restore the previously saved one before (re)installing ours.
+        std::set_terminate(default_terminate_handler);
+    }
+    default_terminate_handler = std::set_terminate(backtrace_terminate_handler);
+}
+
+void
+set_terminate_handler_print_backtrace(bool print)
+{
+    should_include_backtrace = print;
+}
+
+} // namespace couchbase::core::platform

package/deps/couchbase-cxx-client/core/platform/terminate_handler.h

@@ -0,0 +1,36 @@
+/* -*- 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
+
+namespace couchbase::core::platform
+{
+/**
+ * Interposes our own C++ terminate handler to print backtrace upon failures.
+ * Chains to the default handler (if exists) after printing the backtrace,
+ * then calls std::abort().
+ */
+void
+install_backtrace_terminate_handler();
+
+/**
+ * Control if our C++ terminate handler should include a backtrace or not.
+ */
+void
+set_terminate_handler_print_backtrace(bool print);
+
+} // namespace couchbase::core::platform