zeroc-ice 3.7.9.1 → 3.8.0

data/dist/ice/cpp/src/Ice/Base64.cpp

@@ -0,0 +1,263 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Base64.h"
+
+#include <cstddef>
+#include <iterator>
+
+using namespace std;
+
+string
+IceInternal::Base64::encode(const vector<byte>& plainSeq)
+{
+    string retval;
+
+    if (plainSeq.size() == 0)
+    {
+        return retval;
+    }
+
+    // Reserve enough space for the returned base64 string
+    size_t base64Bytes = (((plainSeq.size() * 4) / 3) + 1);
+    size_t newlineBytes = (((base64Bytes * 2) / 76) + 1);
+    size_t totalBytes = base64Bytes + newlineBytes;
+
+    retval.reserve(totalBytes);
+
+    byte by1 = byte{0};
+    byte by2 = byte{0};
+    byte by3 = byte{0};
+    byte by4 = byte{0};
+    byte by5 = byte{0};
+    byte by6 = byte{0};
+    byte by7 = byte{0};
+
+    for (size_t i = 0; i < plainSeq.size(); i += 3)
+    {
+        by1 = plainSeq[i];
+        by2 = byte{0};
+        by3 = byte{0};
+
+        if ((i + 1) < plainSeq.size())
+        {
+            by2 = plainSeq[i + 1];
+        }
+
+        if ((i + 2) < plainSeq.size())
+        {
+            by3 = plainSeq[i + 2];
+        }
+
+        by4 = by1 >> 2;
+        by5 = (by1 & byte{0x3}) << 4 | (by2 >> 4);
+        by6 = (by2 & byte{0xf}) << 2 | (by3 >> 6);
+        by7 = by3 & byte{0x3f};
+
+        retval += encode(by4);
+        retval += encode(by5);
+
+        if ((i + 1) < plainSeq.size())
+        {
+            retval += encode(by6);
+        }
+        else
+        {
+            retval += "=";
+        }
+
+        if ((i + 2) < plainSeq.size())
+        {
+            retval += encode(by7);
+        }
+        else
+        {
+            retval += "=";
+        }
+    }
+
+    string outString;
+    outString.reserve(totalBytes);
+    string::iterator iter = retval.begin();
+
+    while ((retval.end() - iter) > 76)
+    {
+        copy(iter, iter + 76, back_inserter(outString));
+        outString += "\r\n";
+        iter += 76;
+    }
+
+    copy(iter, retval.end(), back_inserter(outString));
+
+    return outString;
+}
+
+vector<byte>
+IceInternal::Base64::decode(const string& str)
+{
+    string newStr;
+
+    newStr.reserve(str.length());
+
+    for (size_t j = 0; j < str.length(); j++)
+    {
+        if (isBase64(str[j]))
+        {
+            newStr += str[j];
+        }
+    }
+
+    vector<byte> retval;
+
+    if (newStr.length() == 0)
+    {
+        return retval;
+    }
+
+    // Note: This is how we were previously computing the size of the return
+    //       sequence.  The method below is more efficient (and correct).
+    // size_t lines = str.size() / 78;
+    // size_t totalBytes = (lines * 76) + (((str.size() - (lines * 78)) * 3) / 4);
+
+    // Figure out how long the final sequence is going to be.
+    size_t totalBytes = (newStr.size() * 3 / 4) + 1;
+
+    retval.reserve(totalBytes);
+
+    byte by1{0};
+    byte by2{0};
+    byte by3{0};
+    byte by4{0};
+
+    char c1, c2, c3, c4;
+
+    for (size_t i = 0; i < newStr.length(); i += 4)
+    {
+        c2 = 'A';
+        c3 = 'A';
+        c4 = 'A';
+
+        c1 = newStr[i];
+
+        if ((i + 1) < newStr.length())
+        {
+            c2 = newStr[i + 1];
+        }
+
+        if ((i + 2) < newStr.length())
+        {
+            c3 = newStr[i + 2];
+        }
+
+        if ((i + 3) < newStr.length())
+        {
+            c4 = newStr[i + 3];
+        }
+
+        by1 = decode(c1);
+        by2 = decode(c2);
+        by3 = decode(c3);
+        by4 = decode(c4);
+
+        retval.push_back((by1 << 2) | by2 >> 4);
+
+        if (c3 != '=')
+        {
+            retval.push_back(((by2 & byte{0xf}) << 4) | (by3 >> 2));
+        }
+
+        if (c4 != '=')
+        {
+            retval.push_back(((by3 & byte{0x3}) << 6) | by4);
+        }
+    }
+
+    return retval;
+}
+
+bool
+IceInternal::Base64::isBase64(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+    {
+        return true;
+    }
+
+    if (c >= 'a' && c <= 'z')
+    {
+        return true;
+    }
+
+    if (c >= '0' && c <= '9')
+    {
+        return true;
+    }
+
+    if (c == '+')
+    {
+        return true;
+    }
+
+    if (c == '/')
+    {
+        return true;
+    }
+
+    if (c == '=')
+    {
+        return true;
+    }
+
+    return false;
+}
+
+char
+IceInternal::Base64::encode(byte uc)
+{
+    if (uc < byte{26})
+    {
+        return 'A' + static_cast<char>(uc);
+    }
+
+    if (uc < byte{52})
+    {
+        return 'a' + static_cast<char>(uc) - 26;
+    }
+
+    if (uc < byte{62})
+    {
+        return '0' + static_cast<char>(uc) - 52;
+    }
+
+    if (uc == byte{62})
+    {
+        return '+';
+    }
+
+    return '/';
+}
+
+byte
+IceInternal::Base64::decode(char c)
+{
+    if (c >= 'A' && c <= 'Z')
+    {
+        return static_cast<byte>(c - 'A');
+    }
+
+    if (c >= 'a' && c <= 'z')
+    {
+        return static_cast<byte>(c - 'a' + 26);
+    }
+
+    if (c >= '0' && c <= '9')
+    {
+        return static_cast<byte>(c - '0' + 52);
+    }
+
+    if (c == '+')
+    {
+        return byte{62};
+    }
+
+    return byte{63};
+}

data/dist/ice/cpp/src/Ice/Base64.h

@@ -0,0 +1,26 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_BASE_64_H
+#define ICE_BASE_64_H
+
+#include "Ice/Config.h"
+
+#include <string>
+#include <vector>
+
+namespace IceInternal
+{
+    class Base64
+    {
+    public:
+        static std::string encode(const std::vector<std::byte>&);
+        static std::vector<std::byte> decode(const std::string&);
+        static bool isBase64(char);
+
+    private:
+        static char encode(std::byte);
+        static std::byte decode(char);
+    };
+}
+
+#endif

data/dist/ice/cpp/src/Ice/BatchRequestQueue.cpp

@@ -0,0 +1,199 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "BatchRequestQueue.h"
+#include "Ice/Properties.h"
+#include "Ice/Proxy.h"
+#include "Instance.h"
+#include "Reference.h"
+
+using namespace std;
+using namespace Ice;
+using namespace IceInternal;
+
+namespace
+{
+    const int udpOverhead = 20 + 8;
+
+    class BatchRequestI final : public Ice::BatchRequest
+    {
+    public:
+        BatchRequestI(BatchRequestQueue& queue, const Ice::ObjectPrx& proxy, string_view operation, int size)
+            : _queue(queue),
+              _proxy(proxy),
+              _operation(operation),
+              _size(size)
+        {
+        }
+
+        void enqueue() const final { _queue.enqueueBatchRequest(_proxy); }
+
+        [[nodiscard]] int getSize() const final { return _size; }
+
+        [[nodiscard]] string_view getOperation() const override { return _operation; }
+
+        [[nodiscard]] const Ice::ObjectPrx& getProxy() const final { return _proxy; }
+
+    private:
+        BatchRequestQueue& _queue;
+        const Ice::ObjectPrx& _proxy;
+        const string_view _operation;
+        const int _size;
+    };
+}
+
+BatchRequest::~BatchRequest() = default; // avoid weak vtable
+
+BatchRequestQueue::BatchRequestQueue(const InstancePtr& instance, bool datagram)
+    : _interceptor(instance->initializationData().batchRequestInterceptor),
+      _batchStream(instance.get(), currentProtocolEncoding)
+{
+    _batchStream.writeBlob(requestBatchHdr, sizeof(requestBatchHdr));
+    _batchMarker = _batchStream.b.size();
+
+    _maxSize = instance->batchAutoFlushSize();
+    if (_maxSize > 0 && datagram)
+    {
+        const Ice::InitializationData& initData = instance->initializationData();
+        int32_t udpSndSize = initData.properties->getPropertyAsIntWithDefault("Ice.UDP.SndSize", 65535 - udpOverhead);
+        if (udpSndSize < _maxSize)
+        {
+            _maxSize = udpSndSize;
+        }
+    }
+}
+
+void
+BatchRequestQueue::prepareBatchRequest(OutputStream* os)
+{
+    unique_lock lock(_mutex);
+    if (_exception)
+    {
+        rethrow_exception(_exception);
+    }
+    _conditionVariable.wait(lock, [this] { return !_batchStreamInUse; });
+
+    _batchStreamInUse = true;
+    _batchStream.swap(*os);
+}
+
+void
+BatchRequestQueue::finishBatchRequest(OutputStream* os, const Ice::ObjectPrx& proxy, string_view operation)
+{
+    //
+    // No need for synchronization, no other threads are supposed
+    // to modify the queue since we set _batchStreamInUse to true.
+    //
+    assert(_batchStreamInUse);
+    _batchStream.swap(*os);
+
+    try
+    {
+        _batchStreamCanFlush = true; // Allow flush to proceed even if the stream is marked in use.
+
+        if (_maxSize > 0 && _batchStream.b.size() >= static_cast<size_t>(_maxSize))
+        {
+            proxy->ice_flushBatchRequestsAsync(nullptr); // auto-flush, don't wait for response
+        }
+
+        assert(_batchMarker < _batchStream.b.size());
+        if (_interceptor)
+        {
+            BatchRequestI request(*this, proxy, operation, static_cast<int>(_batchStream.b.size() - _batchMarker));
+            _interceptor(request, _batchRequestNum, static_cast<int>(_batchMarker));
+        }
+        else
+        {
+            optional<bool> compress = proxy->_getReference()->getCompressOverride();
+            if (compress.has_value())
+            {
+                _batchCompress |= *compress;
+            }
+            _batchMarker = _batchStream.b.size();
+            ++_batchRequestNum;
+        }
+
+        lock_guard lock(_mutex);
+        _batchStream.resize(_batchMarker);
+        _batchStreamInUse = false;
+        _batchStreamCanFlush = false;
+        _conditionVariable.notify_all();
+    }
+    catch (const std::exception&)
+    {
+        lock_guard lock(_mutex);
+        _batchStream.resize(_batchMarker);
+        _batchStreamInUse = false;
+        _batchStreamCanFlush = false;
+        _conditionVariable.notify_all();
+        throw;
+    }
+}
+
+void
+BatchRequestQueue::abortBatchRequest(OutputStream* os)
+{
+    lock_guard lock(_mutex);
+    if (_batchStreamInUse)
+    {
+        _batchStream.swap(*os);
+        _batchStream.resize(_batchMarker);
+        _batchStreamInUse = false;
+        _conditionVariable.notify_all();
+    }
+}
+
+int
+BatchRequestQueue::swap(OutputStream* os, bool& compress) noexcept
+{
+    unique_lock lock(_mutex);
+    if (_batchRequestNum == 0)
+    {
+        return 0;
+    }
+
+    _conditionVariable.wait(lock, [this] { return !_batchStreamInUse || _batchStreamCanFlush; });
+
+    vector<byte> lastRequest;
+    if (_batchMarker < _batchStream.b.size())
+    {
+        vector<byte>(_batchStream.b.begin() + _batchMarker, _batchStream.b.end()).swap(lastRequest);
+        _batchStream.b.resize(_batchMarker);
+    }
+
+    int requestNum = _batchRequestNum;
+    _batchStream.swap(*os);
+    compress = _batchCompress;
+
+    //
+    // Reset the batch.
+    //
+    _batchRequestNum = 0;
+    _batchCompress = false;
+    _batchStream.writeBlob(requestBatchHdr, sizeof(requestBatchHdr));
+    _batchMarker = _batchStream.b.size();
+    if (!lastRequest.empty())
+    {
+        _batchStream.writeBlob(lastRequest.data(), lastRequest.size());
+    }
+    return requestNum;
+}
+
+void
+BatchRequestQueue::destroy(std::exception_ptr ex)
+{
+    lock_guard lock(_mutex);
+    _exception = ex;
+}
+
+void
+BatchRequestQueue::enqueueBatchRequest(const Ice::ObjectPrx& proxy)
+{
+    assert(_batchMarker < _batchStream.b.size());
+    optional<bool> compress = proxy->_getReference()->getCompressOverride();
+    if (compress.has_value())
+    {
+        _batchCompress |= *compress;
+    }
+    _batchMarker = _batchStream.b.size();
+    ++_batchRequestNum;
+}

data/dist/ice/cpp/src/Ice/BatchRequestQueue.h

@@ -0,0 +1,49 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_BATCH_REQUEST_QUEUE_H
+#define ICE_BATCH_REQUEST_QUEUE_H
+
+#include "Ice/BatchRequest.h"
+#include "Ice/BatchRequestQueueF.h"
+#include "Ice/InstanceF.h"
+#include "Ice/OutputStream.h"
+
+#include <condition_variable>
+#include <functional>
+#include <mutex>
+
+namespace IceInternal
+{
+    class BatchRequestQueue
+    {
+    public:
+        BatchRequestQueue(const InstancePtr&, bool);
+
+        void prepareBatchRequest(Ice::OutputStream*);
+        void finishBatchRequest(Ice::OutputStream*, const Ice::ObjectPrx&, std::string_view);
+        void abortBatchRequest(Ice::OutputStream*);
+
+        int swap(Ice::OutputStream*, bool&) noexcept;
+
+        void destroy(std::exception_ptr);
+
+        void enqueueBatchRequest(const Ice::ObjectPrx&);
+
+    private:
+        std::function<void(const Ice::BatchRequest&, int, int)> _interceptor;
+        Ice::OutputStream _batchStream;
+        bool _batchStreamInUse{false};
+        bool _batchStreamCanFlush{false};
+        bool _batchCompress{false};
+        int _batchRequestNum{0};
+        size_t _batchMarker;
+        std::exception_ptr _exception;
+        std::int32_t _maxSize;
+
+        std::mutex _mutex;
+        std::condition_variable _conditionVariable;
+    };
+
+};
+
+#endif

data/dist/ice/cpp/src/Ice/Buffer.cpp

@@ -0,0 +1,187 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Buffer.h"
+
+#include <cstdlib>
+#include <cstring>
+
+using namespace std;
+using namespace IceInternal;
+
+IceInternal::Buffer::Container::Container() noexcept
+    : _buf(nullptr),
+      _size(0),
+      _capacity(0),
+      _shrinkCounter(0),
+      _owned(true)
+{
+}
+
+IceInternal::Buffer::Container::Container(const_iterator beg, const_iterator end) noexcept
+    : _buf(const_cast<iterator>(beg)),
+      _size(static_cast<size_t>(end - beg)),
+      _capacity(static_cast<size_t>(end - beg)),
+      _shrinkCounter(0),
+      _owned(false)
+{
+}
+
+IceInternal::Buffer::Container::Container(const vector<value_type>& v) noexcept : _shrinkCounter(0)
+{
+    if (v.empty())
+    {
+        _buf = nullptr;
+        _size = 0;
+        _capacity = 0;
+        _owned = true;
+    }
+    else
+    {
+        _buf = const_cast<value_type*>(&v[0]);
+        _size = v.size();
+        _capacity = _size;
+        _owned = false;
+    }
+}
+
+IceInternal::Buffer::Container::Container(Container& other, bool adopt) noexcept
+{
+    if (adopt)
+    {
+        _buf = other._buf;
+        _size = other._size;
+        _capacity = other._capacity;
+        _shrinkCounter = other._shrinkCounter;
+        _owned = other._owned;
+
+        other._buf = nullptr;
+        other._size = 0;
+        other._capacity = 0;
+        other._shrinkCounter = 0;
+        other._owned = true;
+    }
+    else
+    {
+        _buf = other._buf;
+        _size = other._size;
+        _capacity = other._capacity;
+        _shrinkCounter = 0;
+        _owned = false;
+    }
+}
+
+IceInternal::Buffer::Container::Container(Container&& other) noexcept
+    : _buf(other._buf),
+      _size(other._size),
+      _capacity(other._capacity),
+      _shrinkCounter(other._shrinkCounter),
+      _owned(other._owned)
+{
+    // Reset other to default state.
+    other._buf = nullptr;
+    other._size = 0;
+    other._capacity = 0;
+    other._shrinkCounter = 0;
+    other._owned = true;
+}
+
+IceInternal::Buffer::Container&
+IceInternal::Buffer::Container::operator=(Container&& other) noexcept
+{
+    if (this != &other)
+    {
+        // If we own the buffer, free it first.
+        if (_owned)
+        {
+            ::free(_buf);
+        }
+        _buf = other._buf;
+        _size = other._size;
+        _capacity = other._capacity;
+        _shrinkCounter = other._shrinkCounter;
+        _owned = other._owned;
+
+        // Reset other to default state.
+        other._buf = nullptr;
+        other._size = 0;
+        other._capacity = 0;
+        other._shrinkCounter = 0;
+        other._owned = true;
+    }
+    return *this;
+}
+
+IceInternal::Buffer::Container::~Container()
+{
+    if (_owned)
+    {
+        ::free(_buf);
+    }
+}
+
+void
+IceInternal::Buffer::Container::swap(Container& other) noexcept
+{
+    std::swap(_buf, other._buf);
+    std::swap(_size, other._size);
+    std::swap(_capacity, other._capacity);
+    std::swap(_shrinkCounter, other._shrinkCounter);
+    std::swap(_owned, other._owned);
+}
+
+void
+IceInternal::Buffer::Container::clear()
+{
+    if (_owned)
+    {
+        ::free(_buf);
+    }
+
+    _buf = nullptr;
+    _size = 0;
+    _capacity = 0;
+    _shrinkCounter = 0;
+    _owned = true;
+}
+
+void
+IceInternal::Buffer::Container::reserve(size_type n)
+{
+    size_type c = _capacity;
+    if (n > _capacity)
+    {
+        _capacity = std::max<size_type>(n, 2 * _capacity);
+        _capacity = std::max<size_type>(static_cast<size_type>(240), _capacity);
+    }
+    else if (n < _capacity)
+    {
+        _capacity = n;
+    }
+    else
+    {
+        return;
+    }
+
+    pointer p;
+    if (_owned)
+    {
+        p = reinterpret_cast<pointer>(::realloc(_buf, _capacity));
+    }
+    else
+    {
+        p = reinterpret_cast<pointer>(::malloc(_capacity));
+        if (p)
+        {
+            ::memcpy(p, _buf, _size);
+            _owned = true;
+        }
+    }
+
+    if (!p)
+    {
+        _capacity = c; // Restore the previous capacity.
+        throw std::bad_alloc();
+    }
+
+    _buf = p;
+}