couchbase 3.0.3-universal-darwin-20

data/ext/couchbase/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
+{
+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();
+
+    uint64_t next();
+
+    bool getBytes(void* dest, size_t size);
+};
+} // namespace couchbase

data/ext/couchbase/platform/string_hex.cc

@@ -0,0 +1,99 @@
+/* -*- 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 <platform/string_hex.h>
+
+#include <cinttypes>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+
+static inline uint8_t
+from_hex_digit(char c)
+{
+    if ('0' <= c && c <= '9') {
+        return static_cast<uint8_t>(c - '0');
+    } else if ('A' <= c && c <= 'F') {
+        return static_cast<uint8_t>(c + 10 - 'A');
+    } else if ('a' <= c && c <= 'f') {
+        return static_cast<uint8_t>(c + 10 - 'a');
+    }
+    throw std::invalid_argument("couchbase::from_hex_digit: character was not in hexadecimal range");
+}
+
+uint64_t
+couchbase::from_hex(std::string_view buffer)
+{
+    uint64_t ret = 0;
+    if (buffer.size() > 16) {
+        throw std::overflow_error("couchbase::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::to_hex(uint8_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%02" PRIx8, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::to_hex(uint16_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%04" PRIx16, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::to_hex(uint32_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%08" PRIx32, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::to_hex(uint64_t val)
+{
+    char buf[32];
+    snprintf(buf, sizeof(buf), "0x%016" PRIx64, val);
+    return std::string{ buf };
+}
+
+std::string
+couchbase::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) << uint32_t(c) << " ";
+    }
+    auto ret = ss.str();
+    ret.resize(ret.size() - 1);
+    return ret;
+}

data/ext/couchbase/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 <string_view>
+#include <cstdint>
+
+namespace couchbase
+{
+/**
+ * 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 uint64_t
+ */
+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

data/ext/couchbase/platform/terminate_handler.cc

@@ -0,0 +1,130 @@
+/* -*- 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 <platform/terminate_handler.h>
+
+#include <cstdlib>
+#include <exception>
+
+#include <spdlog/spdlog.h>
+#include <platform/backtrace.h>
+
+#include <version.hxx>
+
+namespace couchbase::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) {
+        spdlog::critical("Caught unhandled std::exception-derived exception. what(): {}", e.what());
+    } catch (...) {
+        spdlog::critical("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))) {
+        spdlog::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);
+        spdlog::critical("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) {
+        spdlog::critical(R"(*** Fatal error encountered during exception handling (rev="{}", compiler="{}", system="{}", date="{}") ***)",
+                         BACKEND_GIT_REVISION,
+                         BACKEND_CXX_COMPILER,
+                         BACKEND_SYSTEM,
+                         BACKEND_BUILD_TIMESTAMP);
+        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.
+    spdlog::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::platform

data/ext/couchbase/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::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::platform

data/ext/couchbase/platform/uuid.cc

@@ -0,0 +1,96 @@
+/* -*- 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 <platform/uuid.h>
+#include <platform/string_hex.h>
+
+#include <iomanip>
+#include <random>
+#include <sstream>
+
+void
+couchbase::uuid::random(couchbase::uuid::uuid_t& uuid)
+{
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<uint64_t> dis;
+
+    // The uuid is 16 bytes, which is the same as two 64 bit integers
+    auto* ptr = reinterpret_cast<uint64_t*>(uuid.data());
+    ptr[0] = dis(gen);
+    ptr[1] = dis(gen);
+
+    // Make sure that it looks like a version 4
+    uuid[6] &= 0x0f;
+    uuid[6] |= 0x40;
+}
+
+couchbase::uuid::uuid_t
+couchbase::uuid::random()
+{
+    uuid_t ret;
+    random(ret);
+    return ret;
+}
+
+couchbase::uuid::uuid_t
+couchbase::uuid::from_string(std::string_view str)
+{
+    uuid_t ret;
+    if (str.size() != 36) {
+        throw std::invalid_argument("couchbase::uuid::from_string: string was wrong size got: " + std::to_string(str.size()) +
+                                    " (expected: 36)");
+    }
+
+    size_t jj = 0;
+    for (size_t ii = 0; ii < 36; ii += 2) {
+        switch (ii) {
+            case 8:
+            case 13:
+            case 18:
+            case 23:
+                if (str[ii] != '-') {
+                    throw std::invalid_argument("couchbase::uuid::from_string: hyphen not found where "
+                                                "expected");
+                }
+                ++ii; // fall-through
+            default:
+                ret[jj++] = uint8_t(couchbase::from_hex({ str.data() + ii, 2 }));
+        }
+    }
+    return ret;
+}
+
+std::string
+couchbase::uuid::to_string(const couchbase::uuid::uuid_t& uuid)
+{
+    std::stringstream ss;
+    ss << std::hex << std::setfill('0');
+    int ii = 0;
+    for (const auto& c : uuid) {
+        ss << std::setw(2) << uint32_t(c);
+        switch (++ii) {
+            case 4:
+            case 6:
+            case 8:
+            case 10:
+                ss << '-';
+            default:;
+        }
+    }
+
+    return ss.str();
+}