zeroc-ice 3.8.2 → 3.8.3

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

@@ -26,6 +26,7 @@
 #include <algorithm>
 #include <iomanip>
 #include <stdexcept>
+#include <utility>
 
 #ifdef ICE_HAS_BZIP2
 #    include <bzlib.h>
@@ -401,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());
@@ -547,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); });
             }
         }
     }
@@ -572,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
 {
@@ -662,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.
     //
@@ -783,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);
     }
 }
 
@@ -807,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)
     {
@@ -1595,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)
@@ -1791,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); });
                 }
             }
         }
@@ -1807,7 +1803,7 @@ Ice::ConnectionI::finish(bool close)
 
     if (_closeCallback)
     {
-        closeCallback(_closeCallback);
+        executeCallback(_closeCallback);
         _closeCallback = nullptr;
     }
 
@@ -1870,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,
@@ -1889,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),
@@ -2180,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))
                 {
@@ -2407,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.
@@ -2442,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());
     }
 }
 

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

@@ -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;

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

@@ -38,8 +38,8 @@ IceInternal::isAbsolutePath(const string& path)
     }
 
 #ifdef _WIN32
-    // We need at least 3 non whitespace character to have
-    // and absolute path
+    // We need at least 3 non whitespace characters to have
+    // an absolute path
     if (i + 3 > size)
     {
         return false;
@@ -199,7 +199,7 @@ int
 IceInternal::getcwd(string& cwd)
 {
     //
-    // Don't need to use a wide string converter, the wide string come
+    // Don't need to use a wide string converter, the wide string comes
     // from Windows API.
     //
     wchar_t cwdbuf[_MAX_PATH];
@@ -242,19 +242,19 @@ IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
         throw FileLockException(__FILE__, __LINE__, GetLastError(), _path);
     }
 
-    OVERLAPPED overlaped;
-    overlaped.Internal = 0;
-    overlaped.InternalHigh = 0;
-    overlaped.Offset = 0;
-    overlaped.OffsetHigh = 0;
+    OVERLAPPED overlapped;
+    overlapped.Internal = 0;
+    overlapped.InternalHigh = 0;
+    overlapped.Offset = 0;
+    overlapped.OffsetHigh = 0;
 
 #    if defined(_MSC_VER)
-    overlaped.hEvent = nullptr;
+    overlapped.hEvent = nullptr;
 #    else
-    overlaped.hEvent = 0;
+    overlapped.hEvent = 0;
 #    endif
 
-    if (::LockFileEx(_fd, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, 0, 0, &overlaped) == 0)
+    if (::LockFileEx(_fd, LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY, 0, 0, 0, &overlapped) == 0)
     {
         ::CloseHandle(_fd);
         throw FileLockException(__FILE__, __LINE__, GetLastError(), _path);
@@ -363,7 +363,7 @@ IceInternal::FileLock::FileLock(const std::string& path) : _path(path)
     //
 
     //
-    // Now that we have acquire an exclusive write lock,
+    // Now that we have acquired an exclusive write lock,
     // write the process pid there.
     //
     ostringstream os;

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

@@ -28,7 +28,7 @@ FixedRequestHandler::asyncRequestCanceled(const OutgoingAsyncBasePtr& outAsync,
 }
 
 Ice::ConnectionIPtr
-FixedRequestHandler::getConnection()
+FixedRequestHandler::getConnection() noexcept
 {
     return _connection;
 }

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

@@ -18,7 +18,7 @@ namespace IceInternal
 
         void asyncRequestCanceled(const OutgoingAsyncBasePtr&, std::exception_ptr) final;
 
-        Ice::ConnectionIPtr getConnection() final;
+        Ice::ConnectionIPtr getConnection() noexcept final;
 
     private:
         Ice::ConnectionIPtr _connection;

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

@@ -12,8 +12,6 @@
 
 namespace IceInternal
 {
-    std::vector<unsigned char> calcSHA1(const std::vector<unsigned char>&);
-
     using HeaderFields = std::map<std::string, std::pair<std::string, std::string>>;
 
     class WebSocketException

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

@@ -70,15 +70,18 @@ IdleTimeoutTransceiverDecorator::initialize(Buffer& readBuffer, Buffer& writeBuf
 
 IdleTimeoutTransceiverDecorator::~IdleTimeoutTransceiverDecorator()
 {
-    // Since ConnectionI is noexcept, decoratorInit always sets _heartbeatTimerTask.
-    assert(_heartbeatTimerTask);
-    _timer->cancel(_heartbeatTimerTask);
+    // _heartbeatTimerTask remains null when the connection creation fails before decoratorInit is called.
+    if (_heartbeatTimerTask)
+    {
+        _timer->cancel(_heartbeatTimerTask);
+    }
     disableIdleCheck();
 }
 
 void
 IdleTimeoutTransceiverDecorator::close()
 {
+    assert(_heartbeatTimerTask); // close is only called on a connection that completed decoratorInit.
     _timer->cancel(_heartbeatTimerTask);
     disableIdleCheck();
     _decoratee->close();

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

@@ -38,9 +38,7 @@ IncomingRequest::IncomingRequest(
 
     inputStream.read(_current.operation, false);
 
-    uint8_t mode;
-    inputStream.read(mode);
-    _current.mode = static_cast<OperationMode>(mode);
+    inputStream.read(_current.mode);
 
     int32_t sz = inputStream.readSize();
     while (sz--)