zeroc-ice 3.8.1 → 3.8.3

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

@@ -12,7 +12,8 @@
 #include "Ice/Properties.h"
 #include "IdleTimeoutTransceiverDecorator.h"
 #include "Instance.h"
-#include "ObjectAdapterI.h"   // For getThreadPool()
+#include "ObjectAdapterI.h" // For getThreadPool()
+#include "OutgoingResponseInternal.h"
 #include "ReferenceFactory.h" // For createProxy().
 #include "RequestHandler.h"   // For RetryException
 #include "ThreadPool.h"
@@ -25,6 +26,7 @@
 #include <algorithm>
 #include <iomanip>
 #include <stdexcept>
+#include <utility>
 
 #ifdef ICE_HAS_BZIP2
 #    include <bzlib.h>
@@ -400,7 +402,11 @@ Ice::ConnectionI::startAsync(
     }
     catch (const Ice::LocalException&)
     {
-        exception(current_exception());
+        {
+            std::lock_guard lock(_mutex);
+            setState(StateClosed, current_exception());
+        }
+
         if (connectionStartFailed)
         {
             connectionStartFailed(shared_from_this(), current_exception());
@@ -546,14 +552,14 @@ Ice::ConnectionI::close(function<void()> response, function<void(std::exception_
         {
             if (response)
             {
-                response();
+                executeCallback(response);
             }
         }
         else
         {
             if (exception)
             {
-                exception(closeException);
+                executeCallback([&] { exception(closeException); });
             }
         }
     }
@@ -571,30 +577,6 @@ Ice::ConnectionI::isActiveOrHolding() const
     return _state > StateNotValidated && _state < StateClosing;
 }
 
-bool
-Ice::ConnectionI::isFinished() const
-{
-    //
-    // We can use trylock here, because as long as there are still
-    // threads operating in this connection object, connection
-    // destruction is considered as not yet finished.
-    //
-    std::unique_lock<std::mutex> lock(_mutex, std::try_to_lock);
-
-    if (!lock.owns_lock())
-    {
-        return false;
-    }
-
-    if (_state != StateFinished || _upcallCount != 0)
-    {
-        return false;
-    }
-
-    assert(_state == StateFinished);
-    return true;
-}
-
 void
 Ice::ConnectionI::throwException() const
 {
@@ -661,7 +643,7 @@ Ice::ConnectionI::sendAsyncRequest(const OutgoingAsyncBasePtr& out, bool compres
 
     std::lock_guard lock(_mutex);
     //
-    // If the exception is closed before we even have a chance
+    // If the connection is closed before we even have a chance
     // to send our request, we always try to send the request
     // again.
     //
@@ -782,18 +764,27 @@ Ice::ConnectionI::flushBatchRequestsAsync(
 void
 Ice::ConnectionI::setCloseCallback(CloseCallback callback)
 {
-    std::lock_guard lock(_mutex);
-    if (_state >= StateClosed)
+    // Holds the callback this call replaces, so that it is destroyed after the lock is released. Destroying a
+    // callback can run arbitrary user code - a language mapping may attach a finalizer to it - and that code can
+    // call back into this connection, which would deadlock on the non-recursive _mutex.
+    CloseCallback previous;
+
     {
-        if (callback)
+        std::lock_guard lock(_mutex);
+        if (_state >= StateClosed)
         {
-            auto self = shared_from_this();
-            _threadPool->execute([self, callback = std::move(callback)]() { self->closeCallback(callback); }, self);
+            if (callback)
+            {
+                auto self = shared_from_this();
+                _threadPool->execute(
+                    [self, callback = std::move(callback)]() { self->executeCallback(callback); },
+                    self);
+            }
+        }
+        else
+        {
+            previous = std::exchange(_closeCallback, std::move(callback));
         }
-    }
-    else
-    {
-        _closeCallback = std::move(callback);
     }
 }
 
@@ -806,11 +797,17 @@ Ice::ConnectionI::disableInactivityCheck() noexcept
 }
 
 void
-Ice::ConnectionI::closeCallback(const CloseCallback& callback)
+Ice::ConnectionI::executeCallback(const CloseCallback& callback) noexcept
+{
+    executeCallback([self = shared_from_this(), &callback] { callback(self); });
+}
+
+void
+Ice::ConnectionI::executeCallback(const std::function<void()>& callback) noexcept
 {
     try
     {
-        callback(shared_from_this());
+        callback();
     }
     catch (const std::exception& ex)
     {
@@ -1012,7 +1009,7 @@ Ice::ConnectionI::setAdapter(const ObjectAdapterPtr& adapter)
     {
         // Go through the adapter to set the adapter on this connection
         // to ensure the object adapter is still active.
-        dynamic_pointer_cast<ObjectAdapterI>(adapter)->setAdapterOnConnection(shared_from_this());
+        static_pointer_cast<ObjectAdapterI>(adapter)->setAdapterOnConnection(shared_from_this());
     }
     else
     {
@@ -1594,7 +1591,7 @@ Ice::ConnectionI::finished(ThreadPoolCurrent& current, bool close)
     }
 
     // If there are no callbacks to call, we don't call ioCompleted() since we're not going to call code that will
-    // potentially block (this avoids promoting a new leader and unecessary thread creation, especially if this is
+    // potentially block (this avoids promoting a new leader and unnecessary thread creation, especially if this is
     // called on shutdown).
     if (!_connectionStartCompleted && !_connectionStartFailed && _sendStreams.empty() && _asyncRequests.empty() &&
         !_closeCallback)
@@ -1790,14 +1787,14 @@ Ice::ConnectionI::finish(bool close)
             {
                 if (pair.first)
                 {
-                    pair.first();
+                    executeCallback(pair.first);
                 }
             }
             else
             {
                 if (pair.second)
                 {
-                    pair.second(_exception);
+                    executeCallback([this, &pair] { pair.second(_exception); });
                 }
             }
         }
@@ -1806,7 +1803,7 @@ Ice::ConnectionI::finish(bool close)
 
     if (_closeCallback)
     {
-        closeCallback(_closeCallback);
+        executeCallback(_closeCallback);
         _closeCallback = nullptr;
     }
 
@@ -1869,17 +1866,19 @@ Ice::ConnectionI::setBufferSize(int32_t rcvSize, int32_t sndSize)
     {
         rethrow_exception(_exception);
     }
-    _transceiver->setBufferSize(rcvSize, sndSize);
+    try
+    {
+        _transceiver->setBufferSize(rcvSize, sndSize);
+    }
+    catch (...)
+    {
+        // The failing call may have closed the socket, so close the connection as well.
+        setState(StateClosed, current_exception());
+        throw;
+    }
     _info = nullptr; // Invalidate the cached connection info
 }
 
-void
-Ice::ConnectionI::exception(std::exception_ptr ex)
-{
-    std::lock_guard lock(_mutex);
-    setState(StateClosed, ex);
-}
-
 Ice::ConnectionI::ConnectionI(
     CommunicatorPtr communicator,
     const InstancePtr& instance,
@@ -1888,7 +1887,7 @@ Ice::ConnectionI::ConnectionI(
     const EndpointIPtr& endpoint,
     const shared_ptr<ObjectAdapterI>& adapter,
     std::function<void(const ConnectionIPtr&)> removeFromFactory,
-    const ConnectionOptions& options) noexcept
+    const ConnectionOptions& options)
     : _communicator(std::move(communicator)),
       _instance(instance),
       _transceiver(transceiver),
@@ -2179,7 +2178,7 @@ Ice::ConnectionI::setState(State state)
 
                 //
                 // Don't need to close now for connections so only close the transceiver
-                // if the selector request it.
+                // if the selector requests it.
                 //
                 if (_threadPool->finish(shared_from_this(), false))
                 {
@@ -2406,7 +2405,7 @@ Ice::ConnectionI::sendHeartbeat() noexcept
         }
 
         // We send a heartbeat to the peer to generate a "write" on the connection. This write in turns creates
-        // a read on the peer, and resets the peer's idle check timer. When _sendStream is not empty, there is
+        // a read on the peer, and resets the peer's idle check timer. When _sendStreams is not empty, there is
         // already an outstanding write, so we don't need to send a heartbeat. It's possible the first message
         // of _sendStreams was already sent but not yet removed from _sendStreams: it means the last write
         // occurred very recently, which is good enough with respect to the idle check.
@@ -2441,74 +2440,71 @@ Ice::ConnectionI::sendResponse(OutgoingResponse response, uint8_t compress)
 {
     bool isTwoWay = !_endpoint->datagram() && response.current().requestId != 0;
 
-    bool finished = false;
+    // We hold _mutex for the duration of this function, including the catch handler below; hence the lock is not
+    // declared inside the try block.
+    std::unique_lock lock(_mutex);
+    assert(_state > StateNotValidated);
+
     try
     {
-        std::unique_lock lock(_mutex);
-        assert(_state > StateNotValidated);
+        bool finished = false;
 
-        try
+        if (--_upcallCount == 0)
         {
-            if (--_upcallCount == 0)
+            if (_state == StateFinished)
             {
-                if (_state == StateFinished)
+                finished = true;
+                if (_observer)
                 {
-                    finished = true;
-                    if (_observer)
-                    {
-                        _observer.detach();
-                    }
+                    _observer.detach();
                 }
-                _conditionVariable.notify_all();
             }
+            _conditionVariable.notify_all();
+        }
 
-            if (_state >= StateClosed)
-            {
-                exception_ptr exception = _exception;
-                assert(exception);
-
-                if (finished && _removeFromFactory)
-                {
-                    lock.unlock();
-                    _removeFromFactory(shared_from_this());
-                }
-
-                rethrow_exception(exception);
-            }
-            assert(!finished);
+        if (_state >= StateClosed)
+        {
+            // The connection is already closed (or finished): we can't send the response. There is nothing else to
+            // do here since the connection's exception is already set.
+            assert(_exception);
 
-            if (isTwoWay)
+            if (finished && _removeFromFactory)
             {
-                OutgoingMessage message(&response.outputStream(), compress > 0);
-                sendMessage(message);
+                lock.unlock();
+                _removeFromFactory(shared_from_this());
             }
 
-            if (_state == StateActive && _maxDispatches > 0 && _dispatchCount == _maxDispatches)
-            {
-                // Resume reading if the connection is active and the dispatch count is about to be less than
-                // _maxDispatches.
-                _threadPool->update(shared_from_this(), SocketOperationNone, SocketOperationRead);
-                if (_idleTimeoutTransceiver)
-                {
-                    _idleTimeoutTransceiver->enableIdleCheck();
-                }
-            }
+            return;
+        }
+        assert(!finished);
 
-            --_dispatchCount;
+        if (isTwoWay)
+        {
+            OutgoingMessage message(&response.outputStream(), compress > 0);
+            sendMessage(message);
+        }
 
-            if (_state == StateClosing && _upcallCount == 0)
+        if (_state == StateActive && _maxDispatches > 0 && _dispatchCount == _maxDispatches)
+        {
+            // Resume reading if the connection is active and the dispatch count is about to be less than
+            // _maxDispatches.
+            _threadPool->update(shared_from_this(), SocketOperationNone, SocketOperationRead);
+            if (_idleTimeoutTransceiver)
             {
-                initiateShutdown();
+                _idleTimeoutTransceiver->enableIdleCheck();
             }
         }
-        catch (const LocalException&)
+
+        --_dispatchCount;
+
+        if (_state == StateClosing && _upcallCount == 0)
         {
-            setState(StateClosed, current_exception());
+            initiateShutdown();
         }
     }
     catch (...)
     {
-        dispatchException(current_exception(), 1);
+        setState(StateClosed, current_exception());
     }
 }
 
@@ -2717,7 +2713,7 @@ Ice::ConnectionI::sendNextMessages(vector<OutgoingMessage>& callbacks)
                 _writeStream.swap(*message->stream);
                 if (message->sent())
                 {
-                    callbacks.push_back(*message);
+                    callbacks.push_back(std::move(*message));
                 }
             }
             _sendStreams.pop_front();
@@ -2850,7 +2846,7 @@ Ice::ConnectionI::sendMessage(OutgoingMessage& message)
     // message was queued.
     if (!_sendStreams.empty())
     {
-        _sendStreams.push_back(message);
+        _sendStreams.push_back(std::move(message));
         _sendStreams.back().adopt(nullptr);
         return AsyncStatusQueued;
     }
@@ -2895,7 +2891,7 @@ Ice::ConnectionI::sendMessage(OutgoingMessage& message)
             return status;
         }
 
-        _sendStreams.push_back(message);
+        _sendStreams.push_back(std::move(message));
         _sendStreams.back().adopt(&stream);
     }
     else
@@ -2945,7 +2941,7 @@ Ice::ConnectionI::sendMessage(OutgoingMessage& message)
             return status;
         }
 
-        _sendStreams.push_back(message);
+        _sendStreams.push_back(std::move(message));
         _sendStreams.back().adopt(nullptr); // Adopt the stream.
 #ifdef ICE_HAS_BZIP2
     }
@@ -3260,6 +3256,22 @@ Ice::ConnectionI::parseMessage(int32_t& upcallCount, function<bool(InputStream&)
                             "received batch request with " + to_string(requestCount) + " batches"};
                     }
 
+                    // A batched request occupies at least 12 bytes on the wire (a 2-byte identity, a
+                    // 1-byte facet path, a 1-byte operation name, a 1-byte operation mode, a 1-byte
+                    // context, and a 6-byte parameters encapsulation). Reject a count larger than the
+                    // remaining message data could possibly hold. The message size is already capped
+                    // at Ice.MessageSizeMax (<= INT32_MAX bytes), so this also keeps requestCount well
+                    // within range when it is accumulated into the dispatch counters below.
+                    constexpr int32_t minBatchRequestSize = 12;
+                    if (requestCount > (stream.b.end() - stream.i) / minBatchRequestSize)
+                    {
+                        throw MarshalException{
+                            __FILE__,
+                            __LINE__,
+                            "received batch request with " + to_string(requestCount) +
+                                " batches, more than the message can contain"};
+                    }
+
                     upcall = [self = shared_from_this(), requestCount, adapter, compress](InputStream& messageStream)
                     {
                         self->dispatchAll(messageStream, requestCount, requestId, compress, adapter);
@@ -3297,7 +3309,7 @@ Ice::ConnectionI::parseMessage(int32_t& upcallCount, function<bool(InputStream&)
 
                 if (q != _asyncRequests.end())
                 {
-                    auto outAsync = q->second;
+                    auto outAsync = std::move(q->second);
 
                     if (q == _asyncRequestsHint)
                     {
@@ -3437,9 +3449,10 @@ Ice::ConnectionI::dispatchAll(
             {
                 // Received request on a connection without an object adapter.
                 sendResponse(
-                    makeOutgoingResponse(
+                    makeOutgoingResponseCore(
                         make_exception_ptr(ObjectNotExistException{__FILE__, __LINE__}),
-                        request.current()),
+                        request.current(),
+                        _instance.get()),
                     0);
             }
 

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

@@ -72,7 +72,7 @@ namespace Ice
     public:
         std::shared_ptr<ConnectionI> shared_from_this()
         {
-            return std::dynamic_pointer_cast<ConnectionI>(IceInternal::EventHandler::shared_from_this());
+            return std::static_pointer_cast<ConnectionI>(IceInternal::EventHandler::shared_from_this());
         }
 
         struct OutgoingMessage
@@ -146,7 +146,6 @@ namespace Ice
         void close(std::function<void()> response, std::function<void(std::exception_ptr)> exception) noexcept final;
 
         [[nodiscard]] bool isActiveOrHolding() const;
-        [[nodiscard]] bool isFinished() const;
 
         void throwException() const final; // From Connection. Throws the connection exception if destroyed.
 
@@ -209,8 +208,6 @@ namespace Ice
 
         void setBufferSize(std::int32_t rcvSize, std::int32_t sndSize) final; // From Connection
 
-        void exception(std::exception_ptr);
-
         // This method is called to execute user code (connection start completion callback, invocation sent callbacks,
         // or an upcall issued from an incoming message). The invocation sent callbacks and the message upcall might
         // both be set.
@@ -221,7 +218,13 @@ namespace Ice
             InputStream& messageStream);
         void finish(bool);
 
-        void closeCallback(const CloseCallback&);
+        // Executes a callback provided by the application, catching and logging any exception it throws.
+        void executeCallback(const CloseCallback& callback) noexcept;
+        void executeCallback(const std::function<void()>& callback) noexcept;
+
+        /// Gets the thread pool that services this connection: the client thread pool for an outgoing connection,
+        /// and the object adapter's thread pool for an incoming connection.
+        [[nodiscard]] const IceInternal::ThreadPoolPtr& getThreadPool() const noexcept { return _threadPool; }
 
         /// Aborts the connection with a ConnectionAbortedException if the connection is active and did not receive
         /// a byte for some time. See the IdleTimeoutTransceiverDecorator.
@@ -250,7 +253,7 @@ namespace Ice
             const IceInternal::EndpointIPtr&,
             const std::shared_ptr<ObjectAdapterI>&,
             std::function<void(const ConnectionIPtr&)>,
-            const ConnectionOptions&) noexcept;
+            const ConnectionOptions&);
 
         static ConnectionIPtr create(
             const Ice::CommunicatorPtr&,
@@ -289,12 +292,12 @@ namespace Ice
         bool validate(IceInternal::SocketOperation = IceInternal::SocketOperationNone);
 
         /// Sends the next queued messages. This method is called by message() once the message which is being sent
-        /// (_sendStreams.First) is fully sent. Before sending the next message, this message is removed from
-        /// _sendsStream. If any, its sent callback is also queued in given callback queue.
+        /// (_sendStreams.front()) is fully sent. Before sending the next message, this message is removed from
+        /// _sendStreams. If any, its sent callback is also queued in given callback queue.
         ///
         /// @param callbacks The sent callbacks to call for the messages that were sent.
         /// @return The socket operation to register with the thread pool's selector to send the remainder of the
-        /// pending message being sent (_sendStreams.First).
+        /// pending message being sent (_sendStreams.front()).
         IceInternal::SocketOperation sendNextMessages(std::vector<OutgoingMessage>& callbacks);
 
         /// Sends or queues the given message.

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

@@ -16,7 +16,7 @@ using namespace std;
 namespace
 {
     mutex consoleMutex;
-    // We leak consoleUtil object to ensure that is available during static destruction.
+    // We leak consoleUtil object to ensure that it is available during static destruction.
     ConsoleUtil* consoleUtil = 0;
 }
 

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

@@ -52,25 +52,21 @@ IceInternal::DefaultsAndOverrides::DefaultsAndOverrides(const PropertiesPtr& pro
         throw ParseException(__FILE__, __LINE__, "illegal value '" + value + "'; expected 'Random' or 'Ordered'");
     }
 
-    const_cast<chrono::milliseconds&>(defaultInvocationTimeout) =
-        chrono::milliseconds(properties->getIcePropertyAsInt("Ice.Default.InvocationTimeout"));
-    if (defaultInvocationTimeout.count() < 1 && defaultInvocationTimeout.count() != -1)
+    auto invocationTimeout = chrono::milliseconds(properties->getIcePropertyAsInt("Ice.Default.InvocationTimeout"));
+    if (invocationTimeout <= chrono::milliseconds::zero())
     {
-        throw InitializationException{
-            __FILE__,
-            __LINE__,
-            "invalid value for Ice.Default.InvocationTimeout: " + to_string(defaultInvocationTimeout.count())};
+        // Zero or any negative timeout means infinite and is normalized to -1.
+        invocationTimeout = chrono::milliseconds(-1);
     }
+    const_cast<chrono::milliseconds&>(defaultInvocationTimeout) = invocationTimeout;
 
-    const_cast<chrono::seconds&>(defaultLocatorCacheTimeout) =
-        chrono::seconds(properties->getIcePropertyAsInt("Ice.Default.LocatorCacheTimeout"));
-    if (defaultLocatorCacheTimeout.count() < -1)
+    auto locatorCacheTimeout = chrono::seconds(properties->getIcePropertyAsInt("Ice.Default.LocatorCacheTimeout"));
+    if (locatorCacheTimeout < chrono::seconds::zero())
     {
-        throw InitializationException{
-            __FILE__,
-            __LINE__,
-            "invalid value for Ice.Default.LocatorCacheTimeout: " + to_string(defaultLocatorCacheTimeout.count())};
+        // Any negative timeout means infinite and is normalized to -1; 0 means no caching.
+        locatorCacheTimeout = chrono::seconds(-1);
     }
+    const_cast<chrono::seconds&>(defaultLocatorCacheTimeout) = locatorCacheTimeout;
 
     value = properties->getIceProperty("Ice.Default.EncodingVersion");
     defaultEncoding = stringToEncodingVersion(value);

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

@@ -64,7 +64,7 @@ namespace IceInternal
         [[nodiscard]] virtual EndpointIPtr connectionId(const std::string&) const = 0;
 
         //
-        // Return true if the endpoints support bzip2 compress, or false
+        // Return true if the endpoint supports bzip2 compression, or false
         // otherwise.
         //
         [[nodiscard]] virtual bool compress() const = 0;