couchbase 3.1.0 → 3.3.0

data/ext/couchbase/couchbase/utils/unsigned_leb128.hxx

@@ -0,0 +1,181 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2018 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 <array>
+#include <gsl/util>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+
+namespace couchbase::utils
+{
+
+/**
+ * Helper code for encode and decode of LEB128 values.
+ * - mcbp encodes collection-ID as an unsigned LEB128
+ * - see https://en.wikipedia.org/wiki/LEB128
+ */
+
+struct Leb128NoThrow {
+};
+
+/**
+ * decode_unsigned_leb128 returns the decoded T and a const_byte_buffer
+ * initialised with the data following the leb128 data. This form of the decode
+ * does not throw for invalid input and the caller should always check
+ * second.data() for success or error (see returns info).
+ *
+ * @param buf buffer containing a leb128 encoded value (of size T)
+ * @returns On error a std::pair where first is set to 0 and second is nullptr/0
+ *          const_byte_buffer. On success a std::pair where first is the decoded
+ *          value and second is a buffer initialised with the data following the
+ *          leb128 data.
+ */
+template<class T>
+typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
+decode_unsigned_leb128(std::string_view buf, struct Leb128NoThrow /* unused */)
+{
+    T rv = static_cast<uint8_t>(buf[0]) & 0x7fULL;
+    size_t end = 0;
+    if ((static_cast<uint8_t>(buf[0]) & 0x80ULL) == 0x80ULL) {
+        T shift = 7;
+        // shift in the remaining data
+        for (end = 1; end < buf.size(); end++) {
+            rv |= (static_cast<uint8_t>(buf[end]) & 0x7fULL) << shift;
+            if ((static_cast<uint8_t>(buf[end]) & 0x80ULL) == 0) {
+                break; // no more
+            }
+            shift += 7;
+        }
+
+        // We should of stopped for a stop byte, not the end of the buffer
+        if (end == buf.size()) {
+            return { 0, std::string_view{} };
+        }
+    }
+    // Return the decoded value and a buffer for any remaining data
+    return { rv, std::string_view{ buf.data() + end + 1, buf.size() - (end + 1) } };
+}
+
+/**
+ * decode_unsigned_leb128 returns the decoded T and a const_byte_buffer
+ * initialised with the data following the leb128 data. This form of the decode
+ * throws for invalid input.
+ *
+ * @param buf buffer containing a leb128 encoded value (of size T)
+ * @returns std::pair first is the decoded value and second a buffer for the
+ *          remaining data (size will be 0 for no more data)
+ * @throws std::invalid_argument if buf[0] does not encode a leb128 value with
+ *         a stop byte.
+ */
+template<class T>
+typename std::enable_if_t<std::is_unsigned_v<T>, std::pair<T, std::string_view>>
+decode_unsigned_leb128(std::string_view buf)
+{
+    if (buf.size() > 0) {
+        auto rv = decode_unsigned_leb128<T>(buf, Leb128NoThrow());
+        if (rv.second.data()) {
+            return rv;
+        }
+    }
+    throw std::invalid_argument("decode_unsigned_leb128: invalid buf size:" + std::to_string(buf.size()));
+}
+
+/**
+ * @return a buffer to the data after the leb128 prefix
+ */
+template<class T>
+typename std::enable_if_t<std::is_unsigned_v<T>, std::string_view>
+skip_unsigned_leb128(std::string_view buf)
+{
+    return decode_unsigned_leb128<T>(buf).second;
+}
+
+// Empty, non specialised version of the decoder class
+template<class T, class Enable = void>
+class unsigned_leb128
+{
+};
+
+/**
+ * For encoding a unsigned T leb128, class constructs from a T value and
+ * provides a const_byte_buffer for access to the encoded
+ */
+template<class T>
+class unsigned_leb128<T, typename std::enable_if_t<std::is_unsigned_v<T>>>
+{
+  public:
+    explicit unsigned_leb128(T in)
+    {
+        while (in > 0) {
+            auto byte = gsl::narrow_cast<uint8_t>(in & 0x7fULL);
+            in >>= 7;
+
+            // In has more data?
+            if (in > 0) {
+                byte |= 0x80;
+                encodedData[encodedSize - 1U] = byte;
+                // Increase the size
+                encodedSize++;
+            } else {
+                encodedData[encodedSize - 1U] = byte;
+            }
+        }
+    }
+
+    [[nodiscard]] std::string get() const
+    {
+        return { begin(), end() };
+    }
+
+    [[nodiscard]] const uint8_t* begin() const
+    {
+        return encodedData.data();
+    }
+
+    [[nodiscard]] const uint8_t* end() const
+    {
+        return encodedData.data() + encodedSize;
+    }
+
+    [[nodiscard]] const uint8_t* data() const
+    {
+        return encodedData.data();
+    }
+
+    [[nodiscard]] size_t size() const
+    {
+        return encodedSize;
+    }
+
+    constexpr static size_t getMaxSize()
+    {
+        return maxSize;
+    }
+
+  private:
+    // Larger T may need a larger array
+    static_assert(sizeof(T) <= 8, "Class is only valid for uint 8/16/64");
+
+    // value is large enough to store ~0 as leb128
+    static constexpr size_t maxSize = sizeof(T) + (((sizeof(T) + 1) / 8) + 1);
+    std::array<uint8_t, maxSize> encodedData{};
+    uint8_t encodedSize{ 1 };
+};
+
+} // namespace couchbase::utils

data/ext/couchbase/couchbase/utils/url_codec.cxx

@@ -0,0 +1,404 @@
+/* -*- 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.
+ */
+
+#include <couchbase/utils/url_codec.hxx>
+
+#include <fmt/core.h>
+
+#include <cctype>
+#include <climits>
+
+namespace couchbase::utils::string_codec
+{
+
+namespace priv
+{
+inline bool
+is_legal_uri_char(char c)
+{
+    auto uc = static_cast<unsigned char>(c);
+    if ((isalpha(uc) != 0) || (isdigit(uc) != 0)) {
+        return true;
+    }
+    switch (uc) {
+        case '-':
+        case '_':
+        case '.':
+        case '~':
+        case '!':
+        case '*':
+        case '\'':
+        case '(':
+        case ')':
+        case ';':
+        case ':':
+        case '@':
+        case '&':
+        case '=':
+        case '+':
+        case '$':
+        case ',':
+        case '/':
+        case '?':
+        case '#':
+        case '[':
+        case ']':
+            return true;
+        default:
+            break;
+    }
+    return false;
+}
+
+template<typename T>
+inline bool
+is_already_escape(T first, T last)
+{
+    first++; // ignore '%'
+    std::size_t jj = 0;
+    for (; first != last && jj < 2; ++jj, ++first) {
+        if (!isxdigit(*first)) {
+            return false;
+        }
+    }
+    return jj == 2;
+}
+} // namespace priv
+
+template<typename Ti, typename To>
+bool
+url_encode(Ti first, Ti last, To& o, bool check_encoded = true)
+{
+    // If re-encoding detection is enabled, this flag indicates not to
+    // re-encode
+    bool skip_encoding = false;
+
+    for (; first != last; ++first) {
+        if (!skip_encoding && check_encoded) {
+            if (*first == '%') {
+                skip_encoding = priv::is_already_escape(first, last);
+            } else if (*first == '+') {
+                skip_encoding = true;
+            }
+        }
+        if (skip_encoding || priv::is_legal_uri_char(*first)) {
+            if (skip_encoding && *first != '%' && !priv::is_legal_uri_char(*first)) {
+                return false;
+            }
+
+            o.insert(o.end(), first, first + 1);
+        } else {
+            unsigned int c = static_cast<unsigned char>(*first);
+            std::size_t numbytes = 0;
+
+            if ((c & 0x80) == 0) { /* ASCII character */
+                numbytes = 1;
+            } else if ((c & 0xE0) == 0xC0) { /* 110x xxxx */
+                numbytes = 2;
+            } else if ((c & 0xF0) == 0xE0) { /* 1110 xxxx */
+                numbytes = 3;
+            } else if ((c & 0xF8) == 0xF0) { /* 1111 0xxx */
+                numbytes = 4;
+            } else {
+                return false;
+            }
+
+            do {
+                o.append(fmt::format("%{:x}", static_cast<std::uint8_t>(*first)));
+            } while (--numbytes && ++first != last);
+        }
+    }
+    return true;
+}
+
+template<typename Tin, typename Tout>
+bool
+url_encode(const Tin& in, Tout& out)
+{
+    return url_encode(in.begin(), in.end(), out);
+}
+
+std::string
+url_encode(const std::string& src)
+{
+    std::string dst{};
+    url_encode(src.begin(), src.end(), dst);
+    return dst;
+}
+
+template<typename Ti, typename To>
+bool
+url_decode(Ti first, Ti last, To out, std::size_t& nout)
+{
+    for (; first != last && *first != '\0'; ++first) {
+        if (*first == '%') {
+            char nextbuf[3] = { 0 };
+            std::size_t jj = 0;
+            first++;
+            nextbuf[0] = *first;
+            for (; first != last && jj < 2; ++jj) {
+                nextbuf[jj] = *first;
+                if (jj != 1) {
+                    first++;
+                }
+            }
+            if (jj != 2) {
+                return false;
+            }
+
+            char* end = nullptr;
+            unsigned long octet = std::strtoul(nextbuf, &end, 16);
+            if (octet == ULONG_MAX || (octet == 0 && end == nextbuf)) {
+                return false;
+            }
+
+            *out = static_cast<char>(octet);
+        } else {
+            *out = *first;
+        }
+
+        out++;
+        nout++;
+    }
+    return true;
+}
+
+std::string
+url_decode(const std::string& src)
+{
+    std::string dst{};
+    std::size_t n = 0;
+    if (url_decode(src.begin(), src.end(), dst.begin(), n)) {
+        dst.resize(n);
+    }
+    return dst;
+}
+
+/* See: https://url.spec.whatwg.org/#urlencoded-serializing: */
+/*
+ * 0x2A
+ * 0x2D
+ * 0x2E
+ * 0x30 to 0x39
+ * 0x41 to 0x5A
+ * 0x5F
+ * 0x61 to 0x7A
+ *  Append a code point whose value is byte to output.
+ * Otherwise
+ *  Append byte, percent encoded, to output.
+ */
+template<typename Ti, typename To>
+void
+form_encode(Ti first, Ti last, To& out)
+{
+    for (; first != last; ++first) {
+        auto c = static_cast<unsigned char>(*first);
+        if (isalnum(c)) {
+            out.insert(out.end(), first, first + 1);
+            continue;
+        }
+        if (c == ' ') {
+            char tmp = '+';
+            out.insert(out.end(), &tmp, &tmp + 1);
+        } else if ((c == 0x2A || c == 0x2D || c == 0x2E) || (c >= 0x30 && c <= 0x39) || (c >= 0x41 && c <= 0x5A) || (c == 0x5F) ||
+                   (c >= 0x60 && c <= 0x7A)) {
+            out.insert(out.end(), static_cast<char>(c));
+        } else {
+            out.append(fmt::format("%{:x}", static_cast<std::uint8_t>(*first)));
+        }
+    }
+}
+
+std::string
+form_encode(const std::string& src)
+{
+    std::string dst;
+    form_encode(src.begin(), src.end(), dst);
+    return dst;
+}
+
+namespace v2
+{
+bool
+should_escape(char c, encoding mode)
+{
+    // §2.3 Unreserved characters (alphanum)
+    if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9')) {
+        return false;
+    }
+
+    if (mode == encoding::encode_host || mode == encoding::encode_zone) {
+        // §3.2.2 Host allows
+        //	sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+        // as part of reg-name.
+        // We add : because we include :port as part of host.
+        // We add [ ] because we include [ipv6]:port as part of host.
+        // We add < > because they're the only characters left that we could possibly allow, and Parse will reject them if we escape them
+        // (because hosts can't use %-encoding for ASCII bytes).
+        switch (c) {
+            case '!':
+            case '$':
+            case '&':
+            case '\'':
+            case '(':
+            case ')':
+            case '*':
+            case '+':
+            case ',':
+            case ';':
+            case '=':
+            case ':':
+            case '[':
+            case ']':
+            case '<':
+            case '>':
+            case '"':
+                return false;
+
+            default:
+                break;
+        }
+    }
+
+    switch (c) {
+        case '-':
+        case '_':
+        case '.':
+        case '~':
+            // §2.3 Unreserved characters (mark)
+            return false;
+
+        case '$':
+        case '&':
+        case '+':
+        case ',':
+        case '/':
+        case ':':
+        case ';':
+        case '=':
+        case '?':
+        case '@':
+            // §2.2 Reserved characters (reserved)
+            // Different sections of the URL allow a few of
+            // the reserved characters to appear unescaped.
+            switch (mode) {
+                case encoding::encode_path: // §3.3
+                    // The RFC allows : @ & = + $ but saves / ; , for assigning meaning to individual path segments. This package only
+                    // manipulates the path as a whole, so we allow those last three as well. That leaves only ? to escape.
+                    return c == '?';
+
+                case encoding::encode_path_segment: // §3.3
+                    // The RFC allows : @ & = + $ but saves / ; , for assigning meaning to individual path segments.
+                    return c == '/' || c == ';' || c == ',' || c == '?';
+
+                case encoding::encode_user_password: // §3.2.1
+                    // The RFC allows ';', ':', '&', '=', '+', '$', and ',' in userinfo, so we must escape only '@', '/', and '?'. The
+                    // parsing of userinfo treats ':' as special so we must escape that too.
+                    return c == '@' || c == '/' || c == '?' || c == ':';
+
+                case encoding::encode_query_component: // §3.4
+                    // The RFC reserves (so we must escape) everything.
+                    return true;
+
+                case encoding::encode_fragment: // §4.1
+                    // The RFC text is silent but the grammar allows everything, so escape nothing.
+                    return false;
+
+                default:
+                    break;
+            }
+
+        default:
+            break;
+    }
+
+    if (mode == encoding::encode_fragment) {
+        // RFC 3986 §2.2 allows not escaping sub-delims. A subset of sub-delims are included in reserved from RFC 2396 §2.2. The remaining
+        // sub-delims do not need to be escaped. To minimize potential breakage, we apply two restrictions: (1) we always escape sub-delims
+        // outside of the fragment, and (2) we always escape single quote to avoid breaking callers that had previously assumed that single
+        // quotes would be escaped. See issue #19917.
+        switch (c) {
+            case '!':
+            case '(':
+            case ')':
+            case '*':
+                return false;
+
+            default:
+                break;
+        }
+    }
+
+    // Everything else must be escaped.
+    return true;
+}
+
+constexpr auto upper_hex = "0123456789ABCDEF";
+
+std::string
+escape(const std::string& s, encoding mode)
+{
+    std::size_t space_count{ 0 };
+    std::size_t hex_count{ 0 };
+
+    for (const auto& c : s) {
+        if (should_escape(c, mode)) {
+            if (c == ' ' && mode == encoding::encode_query_component) {
+                ++space_count;
+            } else {
+                ++hex_count;
+            }
+        }
+    }
+
+    if (space_count == 0 && hex_count == 0) {
+        return s;
+    }
+
+    std::size_t required = s.size() + 2 * hex_count;
+    std::string t;
+    t.resize(required);
+
+    if (hex_count == 0) {
+        for (std::size_t i = 0; i < s.size(); ++i) {
+            if (s[i] == ' ') {
+                t[i] = '+';
+            } else {
+                t[i] = s[i];
+            }
+        }
+        return t;
+    }
+
+    std::size_t j{ 0 };
+    for (const auto& c : s) {
+        if (c == ' ' && mode == encoding::encode_query_component) {
+            t[j++] = '+';
+        } else if (should_escape(c, mode)) {
+            t[j++] = '%';
+            t[j++] = upper_hex[(c >> 4U) & 0x0f];
+            t[j++] = upper_hex[c & 0x0f];
+        } else {
+            t[j++] = c;
+        }
+    }
+    return t;
+}
+
+} // namespace v2
+
+} // namespace couchbase::utils::string_codec

data/ext/couchbase/couchbase/utils/url_codec.hxx

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <map>
+#include <sstream>
+#include <string>
+
+namespace couchbase::utils::string_codec
+{
+std::string
+url_decode(const std::string& src);
+
+std::string
+url_encode(const std::string& src);
+
+std::string
+form_encode(const std::string& src);
+
+namespace v2
+{
+enum class encoding {
+    encode_path,
+    encode_path_segment,
+    encode_host,
+    encode_zone,
+    encode_user_password,
+    encode_query_component,
+    encode_fragment,
+};
+
+std::string
+escape(const std::string& s, encoding mode);
+
+/**
+ * Escapes the string so it can be safely placed inside a URL query.
+ *
+ * @param s
+ * @return
+ */
+inline std::string
+query_escape(const std::string& s)
+{
+    return escape(s, encoding::encode_query_component);
+}
+
+/**
+ * Escapes the string so it can be safely placed inside a URL path segment, replacing special characters (including /) with %XX sequences as
+ * needed.
+ */
+inline std::string
+path_escape(const std::string& s)
+{
+    return escape(s, encoding::encode_path_segment);
+}
+
+inline std::string
+form_encode(const std::map<std::string, std::string>& values)
+{
+    std::stringstream ss;
+    bool first{ true };
+    for (const auto& [key, value] : values) {
+        if (first) {
+            first = false;
+        } else {
+            ss << '&';
+        }
+        ss << query_escape(key) << '=' << query_escape(value);
+    }
+    return ss.str();
+}
+} // namespace v2
+
+} // namespace couchbase::utils::string_codec

data/ext/couchbase/couchbase/view_scan_consistency.hxx

@@ -0,0 +1,27 @@
+/* -*- 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
+
+namespace couchbase
+{
+enum class view_scan_consistency {
+    not_bounded = 0,
+    update_after,
+    request_plus,
+};
+} // namespace couchbase

data/ext/couchbase/couchbase/view_sort_order.hxx

@@ -0,0 +1,23 @@
+/* -*- 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
+
+namespace couchbase
+{
+enum class view_sort_order { ascending = 0, descending };
+} // namespace couchbase