zeroc-ice 3.8.2 → 3.8.3

data/dist/ice/cpp/include/generated/IceLocatorDiscovery/Lookup.h

@@ -1,6 +1,6 @@
 // Copyright (c) ZeroC, Inc.
 
-// slice2cpp version 3.8.2
+// slice2cpp version 3.8.3
 // <auto-generated>Generated from Slice file 'Lookup.ice'.</auto-generated>
 // clang-format off
 
@@ -18,7 +18,7 @@
 #   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 2
+#   if ICE_INT_VERSION % 100 < 3
 #       error Ice patch level mismatch!
 #   endif
 #endif
@@ -94,11 +94,24 @@ namespace IceLocatorDiscovery
 
         /// Provides a reply to a ::IceLocatorDiscovery::LookupPrx::findLocator request.
         /// @param prx The proxy of the locator.
-        /// @param response The response callback.
-        /// @param exception The exception callback.
-        /// @param sent The sent callback.
+        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
+        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
+        /// function.
+        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
+        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
+        /// function.
+        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
+        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
+        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
+        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
+        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
+        /// asynchronous case.
         /// @param context The request context.
         /// @return A function that can be called to cancel the invocation locally.
+        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
+        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
+        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
+        /// callbacks, and the request is sent later, by a flush.
         // NOLINTNEXTLINE(modernize-use-nodiscard)
         std::function<void()> foundLocatorAsync(const std::optional<::Ice::LocatorPrx>& prx, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 
@@ -190,11 +203,24 @@ namespace IceLocatorDiscovery
         /// @param instanceName Restrict the search to Ice registries configured with the given instance name. If
         /// empty, all the available registries will reply.
         /// @param reply The reply object to use to send the reply.
-        /// @param response The response callback.
-        /// @param exception The exception callback.
-        /// @param sent The sent callback.
+        /// @param response The response callback. The Ice runtime calls this function from an Ice thread pool
+        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
+        /// function.
+        /// @param exception The exception callback. The Ice runtime calls this function from an Ice thread pool
+        /// thread. If you set Ice::InitializationData::executor, the executor determines the thread that executes this
+        /// function.
+        /// @param sent The sent callback. The Ice runtime calls this function when the request is accepted by the
+        /// transport. When the request is accepted synchronously, the Ice runtime calls this function from the current
+        /// thread and passes `true` as argument. When the request is accepted asynchronously, the Ice runtime calls
+        /// this function from an Ice thread pool thread and passes `false` as argument. If you set
+        /// Ice::InitializationData::executor, the executor determines the thread that executes this function in the
+        /// asynchronous case.
         /// @param context The request context.
         /// @return A function that can be called to cancel the invocation locally.
+        /// @remark When this proxy is a oneway or datagram proxy, the Ice runtime does not call the response
+        /// callback: a successful invocation completes with the sent callback. When this proxy is a batch
+        /// proxy, this function only adds the request to the batch: the Ice runtime calls none of the
+        /// callbacks, and the request is sent later, by a flush.
         // NOLINTNEXTLINE(modernize-use-nodiscard)
         std::function<void()> findLocatorAsync(std::string_view instanceName, const std::optional<LookupReplyPrx>& reply, std::function<void()> response, std::function<void(std::exception_ptr)> exception = nullptr, std::function<void(bool)> sent = nullptr, const Ice::Context& context = Ice::noExplicitContext) const;
 

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

@@ -9,7 +9,7 @@ using namespace std;
 void
 IceInternal::addDefaultPluginFactories(vector<Ice::PluginFactory>& pluginFactories)
 {
-    // These built-in plug-ins are always available and not returned by a Ice::namePluginFactory function.
+    // These built-in plug-ins are always available and not returned by an Ice::namePluginFactory function.
     vector<Ice::PluginFactory> defaultPluginFactories{{Ice::tcpPluginFactory(), Ice::sslPluginFactory()}};
 
     Ice::PluginFactory udpPluginFactory{Ice::udpPluginFactory()};

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

@@ -2,72 +2,48 @@
 
 #include "Base64.h"
 
+#include <algorithm>
+#include <cctype>
 #include <cstddef>
 #include <iterator>
+#include <sstream>
 
 using namespace std;
 
 string
 IceInternal::Base64::encode(const vector<byte>& plainSeq)
 {
+    // Reserve the exact amount of space needed for the returned base64 string.
     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};
+    retval.reserve(((plainSeq.size() + 2) / 3) * 4);
 
     for (size_t i = 0; i < plainSeq.size(); i += 3)
     {
-        by1 = plainSeq[i];
-        by2 = byte{0};
-        by3 = byte{0};
-
+        byte by1 = plainSeq[i];
+        byte by2 = byte{0};
+        byte 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);
-
+        retval += encode(by1 >> 2);
+        retval += encode((by1 & byte{0x3}) << 4 | (by2 >> 4));
         if ((i + 1) < plainSeq.size())
         {
-            retval += encode(by6);
+            retval += encode((by2 & byte{0xf}) << 2 | (by3 >> 6));
         }
         else
         {
             retval += "=";
         }
-
         if ((i + 2) < plainSeq.size())
         {
-            retval += encode(by7);
+            retval += encode(by3 & byte{0x3f});
         }
         else
         {
@@ -75,96 +51,60 @@ IceInternal::Base64::encode(const vector<byte>& plainSeq)
         }
     }
 
-    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;
+    return retval;
 }
 
 vector<byte>
-IceInternal::Base64::decode(const string& str)
+IceInternal::Base64::decode(string str)
 {
-    string newStr;
-
-    newStr.reserve(str.length());
+    // First, remove any whitespace from the string.
+    auto it = std::remove_if(str.begin(), str.end(), [](unsigned char c) { return std::isspace(c); });
+    str.erase(it, str.end());
 
-    for (size_t j = 0; j < str.length(); j++)
+    // Reject any non-base64 characters.
+    auto paddingStart = str.begin() + static_cast<ptrdiff_t>(str.find_last_not_of('=') + 1);
+    it = std::find_if_not(str.begin(), paddingStart, isBase64);
+    if (it != paddingStart)
     {
-        if (isBase64(str[j]))
-        {
-            newStr += str[j];
-        }
+        ostringstream os;
+        os << "invalid base64 character '" << *it << "' (ordinal " << +static_cast<unsigned char>(*it) << ")";
+        throw std::invalid_argument(os.str());
     }
-
-    vector<byte> retval;
-
-    if (newStr.length() == 0)
+    // Reject bad padding. There can be at most 2 padding characters, and it must make the total length a multiple of 4.
+    if (paddingStart != str.end() && (str.end() - paddingStart > 2 || (str.size() % 4) != 0))
     {
-        return retval;
+        throw std::invalid_argument("invalid base64 padding");
     }
+    // Drop any padding characters at this point.
+    str.erase(paddingStart, str.end());
 
-    // 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)
+    // Reject any base64 strings with only 1 out of 4 characters in the final sequence.
+    // The final sequence may have 2, 3, or 4 characters, but 1 can't encode a full byte.
+    if (str.length() % 4 == 1)
     {
-        c2 = 'A';
-        c3 = 'A';
-        c4 = 'A';
-
-        c1 = newStr[i];
-
-        if ((i + 1) < newStr.length())
-        {
-            c2 = newStr[i + 1];
-        }
+        throw std::invalid_argument("invalid base64 string length");
+    }
 
-        if ((i + 2) < newStr.length())
-        {
-            c3 = newStr[i + 2];
-        }
+    vector<byte> retval;
+    retval.reserve((str.length() * 3) / 4);
 
-        if ((i + 3) < newStr.length())
-        {
-            c4 = newStr[i + 3];
-        }
+    for (size_t i = 0; i < str.length(); i += 4)
+    {
+        const char c1 = str[i];
+        const char c2 = str[i + 1]; // Guaranteed okay because of the 'str.length() % 4 == 1' check above.
+        const char c3 = ((i + 2) < str.length()) ? str[i + 2] : '=';
+        const char c4 = ((i + 3) < str.length()) ? str[i + 3] : '=';
 
-        by1 = decode(c1);
-        by2 = decode(c2);
-        by3 = decode(c3);
-        by4 = decode(c4);
+        const byte by1 = decode(c1);
+        const byte by2 = decode(c2);
+        const byte by3 = decode(c3);
+        const byte 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);
@@ -177,37 +117,7 @@ IceInternal::Base64::decode(const string& str)
 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;
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '+' || c == '/';
 }
 
 char

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

@@ -14,10 +14,10 @@ namespace IceInternal
     {
     public:
         static std::string encode(const std::vector<std::byte>&);
-        static std::vector<std::byte> decode(const std::string&);
-        static bool isBase64(char);
+        static std::vector<std::byte> decode(std::string);
 
     private:
+        static bool isBase64(char);
         static char encode(std::byte);
         static std::byte decode(char);
     };

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

@@ -79,17 +79,19 @@ BatchRequestQueue::prepareBatchRequest(OutputStream* 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);
+    {
+        // Bring the request stream back and become the owner so this thread's own auto-flush below can
+        // re-enter swap(). swap() lets only _batchStreamOwnerId through while the stream is in use, and only
+        // after passing that gate does it read the queue's bookkeeping; no other thread can touch the queue,
+        // so the mutations below need no further synchronization.
+        lock_guard lock(_mutex);
+        assert(_batchStreamInUse);
+        _batchStream.swap(*os);
+        _batchStreamOwnerId = std::this_thread::get_id();
+    }
 
     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
@@ -115,15 +117,18 @@ BatchRequestQueue::finishBatchRequest(OutputStream* os, const Ice::ObjectPrx& pr
         lock_guard lock(_mutex);
         _batchStream.resize(_batchMarker);
         _batchStreamInUse = false;
-        _batchStreamCanFlush = false;
+        _batchStreamOwnerId = std::thread::id{};
         _conditionVariable.notify_all();
     }
-    catch (const std::exception&)
+    catch (...)
     {
+        // Restore the queue to a usable state on any exception, including a non-std::exception escaping the
+        // interceptor. Otherwise _batchStreamInUse would stay set and wedge the queue (all future
+        // prepareBatchRequest/swap calls would block forever).
         lock_guard lock(_mutex);
         _batchStream.resize(_batchMarker);
         _batchStreamInUse = false;
-        _batchStreamCanFlush = false;
+        _batchStreamOwnerId = std::thread::id{};
         _conditionVariable.notify_all();
         throw;
     }
@@ -146,13 +151,23 @@ int
 BatchRequestQueue::swap(OutputStream* os, bool& compress) noexcept
 {
     unique_lock lock(_mutex);
+
+    // Only the thread that currently owns the in-use stream may bypass the wait, to run its own auto-flush;
+    // every other caller waits for the in-progress batch request to finish. (The owner can't change while we
+    // block here: a thread becomes the owner only inside finishBatchRequest, never while parked in this wait.)
+    if (_batchStreamOwnerId != std::this_thread::get_id())
+    {
+        _conditionVariable.wait(lock, [this] { return !_batchStreamInUse; });
+    }
+
+    // Read the bookkeeping only after passing the gate above: finishBatchRequest mutates these scalars
+    // without the lock while it owns the in-use stream, so reading _batchRequestNum before the wait would
+    // race those writes.
     if (_batchRequestNum == 0)
     {
         return 0;
     }
 
-    _conditionVariable.wait(lock, [this] { return !_batchStreamInUse || _batchStreamCanFlush; });
-
     vector<byte> lastRequest;
     if (_batchMarker < _batchStream.b.size())
     {

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

@@ -11,6 +11,7 @@
 #include <condition_variable>
 #include <functional>
 #include <mutex>
+#include <thread>
 
 namespace IceInternal
 {
@@ -33,7 +34,10 @@ namespace IceInternal
         std::function<void(const Ice::BatchRequest&, int, int)> _interceptor;
         Ice::OutputStream _batchStream;
         bool _batchStreamInUse{false};
-        bool _batchStreamCanFlush{false};
+        // While finishBatchRequest holds the in-use stream, this is its thread: the only thread allowed to
+        // re-enter swap() (for its own auto-flush). A default-constructed id means no thread may flush the
+        // in-use stream, so other threads wait for _batchStreamInUse to clear.
+        std::thread::id _batchStreamOwnerId{};
         bool _batchCompress{false};
         int _batchRequestNum{0};
         size_t _batchMarker;

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

@@ -37,7 +37,7 @@ IceInternal::Buffer::Container::Container(const vector<value_type>& v) noexcept
     }
     else
     {
-        _buf = const_cast<value_type*>(&v[0]);
+        _buf = const_cast<value_type*>(v.data());
         _size = v.size();
         _capacity = _size;
         _owned = false;

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

@@ -211,7 +211,7 @@ CollocatedRequestHandler::dispatchException(int32_t requestId, exception_ptr ex)
 }
 
 ConnectionIPtr
-CollocatedRequestHandler::getConnection()
+CollocatedRequestHandler::getConnection() noexcept
 {
     return nullptr;
 }

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

@@ -34,7 +34,7 @@ namespace IceInternal
 
         void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) final;
 
-        Ice::ConnectionIPtr getConnection() final;
+        Ice::ConnectionIPtr getConnection() noexcept final;
 
         AsyncStatus invokeAsyncRequest(OutgoingAsyncBase*, int, bool);
 

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

@@ -48,11 +48,12 @@ Ice::Communicator::destroy() noexcept
 void
 Ice::Communicator::destroyAsync(function<void()> completed) noexcept
 {
-    if (completed)
+    if (!completed)
     {
-        _instance->destroyAsync(std::move(completed));
+        // we tolerate null callbacks
+        completed = [] {};
     }
-    // we tolerate null callbacks, they do nothing
+    _instance->destroyAsync(std::move(completed));
 }
 
 void

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

@@ -6,6 +6,7 @@
 #include "ConnectionI.h"
 #include "Instance.h"
 #include "ObjectAdapterFactory.h"
+#include "RequestHandler.h" // For RetryException
 
 using namespace std;
 using namespace Ice;
@@ -97,6 +98,13 @@ CommunicatorFlushBatchAsync::flushConnection(const ConnectionIPtr& con, Ice::Com
             con->sendAsyncRequest(flushBatch, compress, false, batchRequestNum);
         }
     }
+    catch (const RetryException& ex)
+    {
+        // If the connection is closed and sendAsyncRequest throws a RetryException, we rethrow the underlying exception
+        // to the caller.
+        check(false);
+        rethrow_exception(ex.get());
+    }
     catch (const LocalException&)
     {
         check(false);

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

@@ -59,23 +59,13 @@ ConnectRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync
 }
 
 Ice::ConnectionIPtr
-ConnectRequestHandler::getConnection()
+ConnectRequestHandler::getConnection() noexcept
 {
     lock_guard lock(_mutex);
-    //
-    // First check for the connection, it's important otherwise the user could first get a connection
-    // and then the exception if he tries to obtain the proxy cached connection mutiple times (the
-    // exception can be set after the connection is set if the flush of pending requests fails).
-    //
-    if (_connection)
-    {
-        return _connection;
-    }
-    else if (_exception)
-    {
-        rethrow_exception(_exception);
-    }
-    return nullptr;
+    // Return the connection in whatever state it is; if the connection establishment failed, return null. Like all
+    // getConnection implementations, this function never throws: a null return is how the absence of a connection is
+    // reported.
+    return _connection;
 }
 
 void

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

@@ -25,7 +25,7 @@ namespace IceInternal
 
         void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) final;
 
-        Ice::ConnectionIPtr getConnection() final;
+        Ice::ConnectionIPtr getConnection() noexcept final;
 
         // setConnection and setException are the response and exception for RoutableReference::getConnectionAsync.
         void setConnection(Ice::ConnectionIPtr, bool);

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

@@ -205,7 +205,7 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route
         // endpoints that differ in the value of the compression flag
         // only, we always set the compression flag to false here in
         // this connection factory. We also clear the timeout as it is
-        // no longer used for Ice 3.8.
+        // no longer used for Ice 3.8 or greater.
         //
         endpoint = endpoint->compress(false)->timeout(-1);
 
@@ -387,7 +387,7 @@ IceInternal::OutgoingConnectionFactory::incPendingConnectCount()
     //
     // Keep track of the number of pending connects. The outgoing connection factory
     // waitUntilFinished() method waits for all the pending connects to terminate before
-    // to return. This ensures that the communicator client thread pool isn't destroyed
+    // returning. This ensures that the communicator client thread pool isn't destroyed
     // too soon and will still be available to execute the ice_exception() callbacks for
     // the asynchronous requests waiting on a connection to be established.
     //
@@ -426,7 +426,7 @@ IceInternal::OutgoingConnectionFactory::getConnection(
             throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
         }
 
-        // Search for an existing connections matching one of the given endpoints.
+        // Search for an existing connection matching one of the given endpoints.
         Ice::ConnectionIPtr connection = findConnection(connectors, compress);
         if (connection)
         {
@@ -695,7 +695,7 @@ IceInternal::OutgoingConnectionFactory::handleException(exception_ptr ex, bool h
     {
         Trace out(_instance->initializationData().logger, traceLevels->networkCat);
 
-        out << "couldn't resolve endpoint host";
+        out << "could not resolve endpoint host";
 
         try
         {
@@ -903,9 +903,9 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::getConnection()
         {
             //
             // A null return value from getConnection indicates that the connection
-            // is being established and that everthing has been done to ensure that
+            // is being established and that everything has been done to ensure that
             // the callback will be notified when the connection establishment is
-            // done or that the callback already obtain the connection.
+            // done or that the callback already obtained the connection.
             //
             return;
         }
@@ -1510,7 +1510,6 @@ IceInternal::IncomingConnectionFactory::startAcceptor()
         return;
     }
 
-    _acceptorStopped = false;
     createAcceptor();
 }
 
@@ -1523,7 +1522,6 @@ IceInternal::IncomingConnectionFactory::stopAcceptor()
         return;
     }
 
-    _acceptorStopped = true;
     _acceptorStarted = false;
     if (_adapter->getThreadPool()->finish(shared_from_this(), true))
     {

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

@@ -241,9 +241,6 @@ namespace IceInternal
         EndpointIPtr _endpoint;
 
         bool _acceptorStarted{false};
-#if defined(__APPLE__) && TARGET_OS_IPHONE != 0
-        bool _acceptorStopped{false};
-#endif
 
         std::shared_ptr<Ice::ObjectAdapterI> _adapter;
         const bool _warn;