zeroc-ice 3.8.2 → 3.8.3

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

@@ -243,7 +243,8 @@ Ice::InputStream::startEncapsulation()
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if (i - sizeof(std::int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -305,7 +306,8 @@ Ice::InputStream::skipEmptyEncapsulation()
     {
         throw MarshalException{__FILE__, __LINE__, to_string(sz) + " is not a valid encapsulation size"};
     }
-    if (i - sizeof(std::int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -342,7 +344,8 @@ Ice::InputStream::readEncapsulation(const std::byte*& v, std::int32_t& sz)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if (i - sizeof(std::int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -368,7 +371,8 @@ Ice::InputStream::skipEncapsulation()
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
-    if (i - sizeof(int32_t) + sz > b.end())
+    // sz includes the 4 bytes of the size itself, which we've already read.
+    if (sz - 4 > b.end() - i)
     {
         throwUnmarshalOutOfBoundsException(__FILE__, __LINE__);
     }
@@ -446,7 +450,7 @@ Ice::InputStream::readAndCheckSeqSize(int minSize)
     //
     // If there isn't enough data to read on the stream for the sequence (and
     // possibly enclosed sequences), something is wrong with the marshaled
-    // data: it's claiming having more data that what is possible to read.
+    // data: it's claiming to have more data than what is possible to read.
     //
     if (_startSeq + minSeqSize > static_cast<int64_t>(b.size()))
     {
@@ -598,7 +602,7 @@ Ice::InputStream::read(vector<int16_t>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int16_t) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(int16_t) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -608,7 +612,7 @@ Ice::InputStream::read(vector<int16_t>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -656,7 +660,7 @@ Ice::InputStream::read(vector<int32_t>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int32_t) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(int32_t) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -668,7 +672,7 @@ Ice::InputStream::read(vector<int32_t>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -724,7 +728,7 @@ Ice::InputStream::read(vector<int64_t>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(int64_t) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(int64_t) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -740,7 +744,7 @@ Ice::InputStream::read(vector<int64_t>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -788,7 +792,7 @@ Ice::InputStream::read(vector<float>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(float) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(float) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -800,7 +804,7 @@ Ice::InputStream::read(vector<float>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -856,7 +860,7 @@ Ice::InputStream::read(vector<double>& v)
         if constexpr (endian::native == endian::big)
         {
             const byte* src = &(*begin);
-            byte* dest = reinterpret_cast<byte*>(&v[0]) + sizeof(double) - 1;
+            byte* dest = reinterpret_cast<byte*>(v.data()) + sizeof(double) - 1;
             for (int j = 0; j < sz; ++j)
             {
                 *dest-- = *src++;
@@ -872,7 +876,7 @@ Ice::InputStream::read(vector<double>& v)
         }
         else
         {
-            copy(begin, i, reinterpret_cast<byte*>(&v[0]));
+            copy(begin, i, reinterpret_cast<byte*>(v.data()));
         }
     }
     else
@@ -1143,7 +1147,7 @@ Ice::InputStream::readOptImpl(int32_t readTag, OptionalFormat expectedFormat)
         auto tag = static_cast<int32_t>(v >> 3);
         if (tag > 30)
         {
-            // We check for '> 30' instead of '> 29' because 30 is special sentinel tag, handled by the next block.
+            // We check for '> 30' instead of '> 29' because 30 is a special sentinel tag, handled by the next block.
             ostringstream os;
             os << "invalid tag '" << tag << "': tags larger than 29 must be encoded as a size";
             throw MarshalException(__FILE__, __LINE__, os.str());
@@ -1460,7 +1464,7 @@ Ice::InputStream::EncapsDecoder10::read(PatchFunc patchFunc, void* patchAddr)
     //
     int32_t index;
     _stream->read(index);
-    if (index > 0)
+    if (index > 0 || index == INT32_MIN)
     {
         throw MarshalException(__FILE__, __LINE__, "invalid object id");
     }
@@ -1486,7 +1490,7 @@ Ice::InputStream::EncapsDecoder10::throwException(UserExceptionFactory exception
     assert(_sliceType == NoSlice);
 
     //
-    // User exception with the 1.0 encoding start with a boolean flag
+    // User exceptions with the 1.0 encoding start with a boolean flag
     // that indicates whether or not the exception has classes.
     //
     // This allows reading the pending values even if some part of
@@ -2102,7 +2106,7 @@ Ice::InputStream::EncapsDecoder11::readInstance(int32_t index, const PatchFunc&
 
     //
     // Get the object ID before we start reading slices. If some
-    // slices are skiped, the indirect object table are still read and
+    // slices are skipped, the indirect object table is still read and
     // might read other instances.
     //
     index = ++_valueIdIndex;

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

@@ -66,7 +66,6 @@
 #    include <csignal>
 #    include <pwd.h>
 #    include <sys/types.h>
-#    include <syslog.h>
 #endif
 
 #if defined(__linux__) || defined(__GLIBC__)
@@ -87,7 +86,6 @@ namespace
     struct sigaction oldAction;
 #endif
     bool printProcessIdDone = false;
-    string identForOpenlog;
 
     //
     // Should be called with staticMutex locked
@@ -617,7 +615,7 @@ IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const I
         catch (...)
         {
             //
-            // We clean it up, even through this error is not recoverable
+            // We clean it up, even though this error is not recoverable
             // (can't call again createAdmin after fixing the problem since all the facets
             // in the adapter are lost)
             //
@@ -676,7 +674,7 @@ IceInternal::Instance::getAdmin()
         catch (...)
         {
             //
-            // We clean it up, even through this error is not recoverable
+            // We clean it up, even though this error is not recoverable
             // (can't call again createAdmin after fixing the problem since all the facets
             // in the adapter are lost)
             //
@@ -741,7 +739,7 @@ IceInternal::Instance::setServerProcessProxy(const ObjectAdapterPtr& adminAdapte
             if (_traceLevels->location >= 1)
             {
                 Trace out(_initData.logger, _traceLevels->locationCat);
-                out << "couldn't register server '" + serverId + "' with the locator registry:\n";
+                out << "could not register server '" + serverId + "' with the locator registry:\n";
                 out << "the server is not known to the locator registry";
             }
 
@@ -755,7 +753,7 @@ IceInternal::Instance::setServerProcessProxy(const ObjectAdapterPtr& adminAdapte
             if (_traceLevels->location >= 1)
             {
                 Trace out(_initData.logger, _traceLevels->locationCat);
-                out << "couldn't register server '" + serverId + "' with the locator registry:\n" << ex;
+                out << "could not register server '" + serverId + "' with the locator registry:\n" << ex;
             }
             throw;
         }
@@ -919,12 +917,6 @@ IceInternal::Instance::setLogger(const Ice::LoggerPtr& logger)
     _initData.logger = logger;
 }
 
-void
-IceInternal::Instance::setThreadHook(function<void()> threadStart, function<void()> threadStop)
-{
-    _initData.threadStart = std::move(threadStart);
-    _initData.threadStop = std::move(threadStop);
-}
 namespace
 {
     bool logStdErrConvert = true;
@@ -1026,15 +1018,6 @@ IceInternal::Instance::initialize(const Ice::CommunicatorPtr& communicator)
                 sigemptyset(&action.sa_mask);
                 action.sa_flags = 0;
                 sigaction(SIGPIPE, &action, &oldAction);
-                if (_initData.properties->getIcePropertyAsInt("Ice.UseSyslog") > 0)
-                {
-                    identForOpenlog = programName;
-                    if (identForOpenlog.empty())
-                    {
-                        identForOpenlog = "<Unknown Ice Program>";
-                    }
-                    openlog(identForOpenlog.c_str(), LOG_PID, LOG_USER);
-                }
 #else
                 logStdErrConvert = _initData.properties->getIcePropertyAsInt("Ice.LogStdErr.Convert") > 0 &&
                                    _initData.properties->getIceProperty("Ice.StdErr").empty();
@@ -1050,7 +1033,7 @@ IceInternal::Instance::initialize(const Ice::CommunicatorPtr& communicator)
             {
                 if (!logfile.empty())
                 {
-                    throw InitializationException(__FILE__, __LINE__, "Both syslog and file logger cannot be enabled.");
+                    throw InitializationException(__FILE__, __LINE__, "cannot enable both syslog and file logger");
                 }
 
                 _initData.logger =
@@ -1185,6 +1168,10 @@ IceInternal::Instance::initialize(const Ice::CommunicatorPtr& communicator)
 
         const_cast<bool&>(_acceptClassCycles) = _initData.properties->getIcePropertyAsInt("Ice.AcceptClassCycles") > 0;
 
+        // Read here (not in the noexcept destroy) so an invalid value is reported when the communicator is created.
+        const_cast<bool&>(_warnUnusedProperties) =
+            _initData.properties->getIcePropertyAsInt("Ice.Warn.UnusedProperties") > 0;
+
         string implicitContextKind = _initData.properties->getIceProperty("Ice.ImplicitContext");
         if (implicitContextKind == "Shared")
         {
@@ -1218,7 +1205,7 @@ IceInternal::Instance::initialize(const Ice::CommunicatorPtr& communicator)
         const bool ipv6 = isIPv6Supported ? (_initData.properties->getIcePropertyAsInt("Ice.IPv6") > 0) : false;
         if (!ipv4 && !ipv6)
         {
-            throw InitializationException(__FILE__, __LINE__, "Both IPV4 and IPv6 support cannot be disabled.");
+            throw InitializationException(__FILE__, __LINE__, "cannot disable both IPv4 and IPv6 support");
         }
         else if (ipv4 && ipv6)
         {
@@ -1258,20 +1245,26 @@ IceInternal::Instance::initialize(const Ice::CommunicatorPtr& communicator)
                 istringstream value(retryValue);
 
                 int v;
-                if (!(value >> v) || !value.eof())
-                {
-                    v = 0;
-                }
+                bool parsed = static_cast<bool>(value >> v) && value.eof();
 
                 //
                 // If -1 is the first value, no retry and wait intervals.
                 //
-                if (v == -1 && _retryIntervals.empty())
+                if (parsed && v == -1 && _retryIntervals.empty())
                 {
                     break;
                 }
 
-                _retryIntervals.push_back(v > 0 ? v : 0);
+                // Any value that is not a non-negative integer (or the leading -1 handled above) is invalid and
+                // treated as 0.
+                if (!parsed || v < 0)
+                {
+                    Warning out(_initData.logger);
+                    out << "invalid value '" << retryValue << "' in property Ice.RetryIntervals, assuming 0";
+                    v = 0;
+                }
+
+                _retryIntervals.push_back(v);
             }
         }
 
@@ -1373,12 +1366,6 @@ IceInternal::Instance::~Instance()
 
 #ifndef _WIN32
         sigaction(SIGPIPE, &oldAction, nullptr);
-
-        if (!identForOpenlog.empty())
-        {
-            closelog();
-            identForOpenlog.clear();
-        }
 #endif
     }
 }
@@ -1733,7 +1720,7 @@ IceInternal::Instance::destroy() noexcept
         _locatorManager->destroy();
     }
 
-    if (_initData.properties->getIcePropertyAsInt("Ice.Warn.UnusedProperties") > 0)
+    if (_warnUnusedProperties)
     {
         set<string> unusedProperties = _initData.properties.get()->getUnusedProperties();
         if (unusedProperties.size() != 0)
@@ -1819,10 +1806,25 @@ IceInternal::Instance::updateConnectionObservers()
 {
     try
     {
-        assert(_outgoingConnectionFactory);
-        _outgoingConnectionFactory->updateConnectionObservers();
-        assert(_objectAdapterFactory);
-        _objectAdapterFactory->updateObservers(&ObjectAdapterI::updateConnectionObservers);
+        // This updater can run concurrently with destroy(). Copy the subsystem pointers under the mutex, and bail out
+        // once destruction has started: destroy() tears down these subsystems (while _state is StateDestroyInProgress)
+        // before nulling them (when it sets _state to StateDestroyed).
+        OutgoingConnectionFactoryPtr outgoingConnectionFactory;
+        ObjectAdapterFactoryPtr objectAdapterFactory;
+        {
+            lock_guard lock(_mutex);
+            if (_state >= StateDestroyInProgress)
+            {
+                return;
+            }
+            outgoingConnectionFactory = _outgoingConnectionFactory;
+            objectAdapterFactory = _objectAdapterFactory;
+        }
+
+        assert(outgoingConnectionFactory);
+        outgoingConnectionFactory->updateConnectionObservers();
+        assert(objectAdapterFactory);
+        objectAdapterFactory->updateObservers(&ObjectAdapterI::updateConnectionObservers);
     }
     catch (const Ice::CommunicatorDestroyedException&)
     {
@@ -1834,23 +1836,44 @@ IceInternal::Instance::updateThreadObservers()
 {
     try
     {
-        if (_clientThreadPool)
+        // This updater can run concurrently with destroy(). Copy the subsystem pointers under the mutex, and bail out
+        // once destruction has started: destroy() tears down these subsystems (while _state is StateDestroyInProgress)
+        // before nulling them (when it sets _state to StateDestroyed).
+        ThreadPoolPtr clientThreadPool;
+        ThreadPoolPtr serverThreadPool;
+        ObjectAdapterFactoryPtr objectAdapterFactory;
+        EndpointHostResolverPtr endpointHostResolver;
+        ThreadObserverTimerPtr timer;
+        {
+            lock_guard lock(_mutex);
+            if (_state >= StateDestroyInProgress)
+            {
+                return;
+            }
+            clientThreadPool = _clientThreadPool;
+            serverThreadPool = _serverThreadPool;
+            objectAdapterFactory = _objectAdapterFactory;
+            endpointHostResolver = _endpointHostResolver;
+            timer = _timer;
+        }
+
+        if (clientThreadPool)
         {
-            _clientThreadPool->updateObservers();
+            clientThreadPool->updateObservers();
         }
-        if (_serverThreadPool)
+        if (serverThreadPool)
         {
-            _serverThreadPool->updateObservers();
+            serverThreadPool->updateObservers();
         }
-        assert(_objectAdapterFactory);
-        _objectAdapterFactory->updateObservers(&ObjectAdapterI::updateThreadObservers);
-        if (_endpointHostResolver)
+        assert(objectAdapterFactory);
+        objectAdapterFactory->updateObservers(&ObjectAdapterI::updateThreadObservers);
+        if (endpointHostResolver)
         {
-            _endpointHostResolver->updateObserver();
+            endpointHostResolver->updateObserver();
         }
-        if (_timer)
+        if (timer)
         {
-            _timer->updateObserver(_initData.observer);
+            timer->updateObserver(_initData.observer);
         }
     }
     catch (const Ice::CommunicatorDestroyedException&)

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

@@ -40,9 +40,6 @@ namespace IceInternal
     class ThreadObserverTimer;
     using ThreadObserverTimerPtr = std::shared_ptr<ThreadObserverTimer>;
 
-    class MetricsAdminI;
-    using MetricsAdminIPtr = std::shared_ptr<MetricsAdminI>;
-
     /// Structure to track warnings for attempts to set socket buffer sizes.
     struct BufSizeWarnInfo
     {
@@ -112,7 +109,6 @@ namespace IceInternal
         void setDefaultRouter(const std::optional<Ice::RouterPrx>&);
 
         void setLogger(const Ice::LoggerPtr&);
-        void setThreadHook(std::function<void()>, std::function<void()>);
 
         [[nodiscard]] const Ice::StringConverterPtr& getStringConverter() const { return _stringConverter; }
         [[nodiscard]] const Ice::WstringConverterPtr& getWstringConverter() const { return _wstringConverter; }
@@ -158,6 +154,7 @@ namespace IceInternal
         const std::int32_t _classGraphDepthMax{0};                         // Immutable, not reset by destroy().
         const Ice::ToStringMode _toStringMode{Ice::ToStringMode::Unicode}; // Immutable, not reset by destroy().
         const bool _acceptClassCycles{false};                              // Immutable, not reset by destroy().
+        const bool _warnUnusedProperties{false};                           // Immutable, not reset by destroy().
         Ice::ConnectionOptions _clientConnectionOptions;
         Ice::ConnectionOptions _serverConnectionOptions;
         RouterManagerPtr _routerManager;
@@ -177,7 +174,6 @@ namespace IceInternal
         ThreadObserverTimerPtr _timer;
         EndpointFactoryManagerPtr _endpointFactoryManager;
         Ice::PluginManagerPtr _pluginManager;
-        const Ice::ImplicitContextPtr _implicitContext;
         Ice::StringConverterPtr _stringConverter;
         Ice::WstringConverterPtr _wstringConverter;
         bool _adminEnabled{false};
@@ -185,7 +181,6 @@ namespace IceInternal
         Ice::FacetMap _adminFacets;
         Ice::Identity _adminIdentity;
         std::set<std::string, std::less<>> _adminFacetFilter;
-        IceInternal::MetricsAdminIPtr _metricsAdmin;
         std::map<std::int16_t, BufSizeWarnInfo> _setBufSizeWarn;
         std::mutex _setBufSizeWarnMutex;
         mutable std::recursive_mutex _mutex;

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

@@ -320,7 +320,7 @@ namespace
     {
         if (error == 0)
         {
-            return "couldn't open file";
+            return "could not open file";
         }
         else
         {

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

@@ -661,7 +661,7 @@ IceInternal::LocatorInfo::getEndpointsException(const ReferencePtr& ref, std::ex
         if (ref->getInstance()->traceLevels()->location >= 1)
         {
             Trace out(ref->getInstance()->initializationData().logger, ref->getInstance()->traceLevels()->locationCat);
-            out << "couldn't contact the locator to retrieve endpoints\n";
+            out << "could not contact the locator to retrieve endpoints\n";
             if (ref->getAdapterId().empty())
             {
                 out << "well-known proxy = " << ref->toString() << "\n";
@@ -810,7 +810,7 @@ IceInternal::LocatorInfo::finishRequest(
     {
         //
         // Remove the cached references of well-known objects for which we tried
-        // to resolved the endpoints if these endpoints are empty.
+        // to resolve the endpoints if these endpoints are empty.
         //
         for (const auto& wellKnownRef : wellKnownRefs)
         {

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

@@ -77,11 +77,6 @@ namespace
 
         using RemoteLoggerMap = map<RemoteLoggerPrx, Filters, ObjectIdentityCompare>;
 
-        struct GetRemoteLoggerMapKey
-        {
-            RemoteLoggerMap::key_type operator()(const RemoteLoggerMap::value_type& val) { return val.first; }
-        };
-
         RemoteLoggerMap _remoteLoggerMap;
         CommunicatorPtr _sendLogCommunicator;
         bool _destroyed{false};
@@ -515,21 +510,21 @@ namespace
                     }
                 }
             }
+        }
 
-            //
-            // Queue updated, now find which remote loggers want this message
-            //
-            for (const auto& q : _remoteLoggerMap)
-            {
-                const Filters& filters = q.second;
+        //
+        // Queue updated, now find which remote loggers want this message
+        //
+        for (const auto& q : _remoteLoggerMap)
+        {
+            const Filters& filters = q.second;
 
-                if (filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
+            if (filters.messageTypes.empty() || filters.messageTypes.count(logMessage.type) != 0)
+            {
+                if (logMessage.type != LogMessageType::TraceMessage || filters.traceCategories.empty() ||
+                    filters.traceCategories.count(logMessage.traceCategory) != 0)
                 {
-                    if (logMessage.type != LogMessageType::TraceMessage || filters.traceCategories.empty() ||
-                        filters.traceCategories.count(logMessage.traceCategory) != 0)
-                    {
-                        remoteLoggers.push_back(q.first);
-                    }
+                    remoteLoggers.push_back(q.first);
                 }
             }
         }
@@ -671,10 +666,10 @@ namespace
         {
             lock_guard lock(_mutex);
 
+            _detached.store(true);
             if (_sendLogThread.joinable())
             {
                 sendLogThread = std::move(_sendLogThread);
-                _detached.store(true);
                 _conditionVariable.notify_all();
             }
         }

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

@@ -179,7 +179,7 @@ Ice::LoggerI::write(const string& message, bool indent)
                     _nextRetry = chrono::steady_clock::now() + retryTimeout;
 
                     //
-                    // We temporarily set the maximum size to 0 to ensure there isn't more rename attempts
+                    // We temporarily set the maximum size to 0 to ensure there aren't more rename attempts
                     // in the nested error call.
                     //
                     size_t sizeMax = _sizeMax;

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

@@ -36,8 +36,8 @@ namespace Ice
         std::size_t _sizeMax;
 
         //
-        // In case of a log file rename failure is set to the time in milliseconds
-        // after which rename could be attempted again. Otherwise is set to zero.
+        // In case of a log file rename failure, set to the time point after which
+        // the rename can be attempted again. Otherwise, set to the epoch (zero).
         //
         std::chrono::steady_clock::time_point _nextRetry;
     };

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

@@ -443,7 +443,12 @@ namespace IceInternal
             // If there's still no room, remove the oldest entry (at the front).
             if (static_cast<int>(_detachedQueue.size()) == _retain)
             {
-                _objects.erase(_detachedQueue.front()->_object->id);
+                EntryTPtr front = _detachedQueue.front();
+                // Reset the evicted entry's position so a surviving EntryTPtr doesn't keep an iterator into the erased
+                // list node.
+                front->_detachedPos = _detachedQueue.end();
+
+                _objects.erase(front->_object->id);
                 _detachedQueue.pop_front();
             }
 

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

@@ -493,30 +493,34 @@ namespace IceMX
                 return getObserver(helper);
             }
 
-            std::lock_guard lock(_mutex);
-            if (!_metrics)
             {
-                return nullptr;
-            }
+                std::lock_guard lock(_mutex);
+                if (!_metrics)
+                {
+                    return nullptr;
+                }
 
-            typename ObserverImplType::EntrySeqType metricsObjects;
-            for (const auto& map : _maps)
-            {
-                typename ObserverImplType::EntryPtrType entry = map->getMatching(helper, old->getEntry(map.get()));
-                if (entry)
+                typename ObserverImplType::EntrySeqType metricsObjects;
+                for (const auto& map : _maps)
                 {
-                    metricsObjects.push_back(entry);
+                    typename ObserverImplType::EntryPtrType entry = map->getMatching(helper, old->getEntry(map.get()));
+                    if (entry)
+                    {
+                        metricsObjects.push_back(entry);
+                    }
+                }
+                if (!metricsObjects.empty())
+                {
+                    ObserverImplPtrType obsv = std::make_shared<ObserverImplType>();
+                    obsv->init(helper, metricsObjects, old.get());
+                    return obsv;
                 }
-            }
-            if (metricsObjects.empty())
-            {
-                old->detach();
-                return nullptr;
             }
 
-            ObserverImplPtrType obsv = std::make_shared<ObserverImplType>();
-            obsv->init(helper, metricsObjects, old.get());
-            return obsv;
+            // No map matched the updated observer: detach the old observer outside the factory mutex, since
+            // detach() can call into a user-supplied instrumentation delegate.
+            old->detach();
+            return nullptr;
         }
 
         template<typename SubMapMetricsType>

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

@@ -38,7 +38,7 @@ Ice::NativePropertiesAdmin::getPropertiesForPrefix(string prefix, const Current&
 void
 Ice::NativePropertiesAdmin::setProperties(PropertyDict props, const Current&)
 {
-    lock_guard lock{_mutex};
+    unique_lock lock{_mutex};
 
     PropertyDict old = _properties->getPropertiesForPrefix("");
     PropertyDict::const_iterator p;
@@ -157,8 +157,11 @@ Ice::NativePropertiesAdmin::setProperties(PropertyDict props, const Current&)
         changes.insert(changed.begin(), changed.end());
         changes.insert(removed.begin(), removed.end());
 
-        // Copy callbacks to allow callbacks to update callbacks
+        // Copy the callbacks and release the lock before invoking them. This allows the callbacks to update the
+        // callbacks, and avoids a lock-order inversion: a callback may acquire an application lock, while another
+        // thread may call into the admin (e.g. add/removeUpdateCallback) while holding that same lock.
         auto callbacks = _updateCallbacks;
+        lock.unlock();
         for (const auto& cb : callbacks)
         {
             cb(changes);