zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,271 +1,295 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/Instance.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/Router.h>
-#include <Ice/LocatorInfo.h>
-#include <Ice/Locator.h>
-#include <Ice/ReferenceFactory.h>
-#include <Ice/ProxyFactory.h>
-#include <Ice/ThreadPool.h>
-#include <Ice/ConnectionFactory.h>
-#include <Ice/ValueFactoryManagerI.h>
-#include <Ice/LocalException.h>
-#include <Ice/ObjectAdapterFactory.h>
-#include <Ice/Exception.h>
-#include <Ice/PropertiesI.h>
-#include <Ice/PropertiesAdminI.h>
-#include <Ice/LoggerI.h>
-#include <Ice/NetworkProxy.h>
-#include <Ice/EndpointFactoryManager.h>
-#include <Ice/IPEndpointI.h> // For EndpointHostResolver
-#include <Ice/WSEndpoint.h>
-#include <Ice/RequestHandlerFactory.h>
-#include <Ice/RetryQueue.h>
-#include <Ice/DynamicLibrary.h>
-#include <Ice/PluginManagerI.h>
-#include <Ice/Initialize.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/PropertiesI.h>
-#include <Ice/Communicator.h>
-#include <Ice/InstrumentationI.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/LoggerAdminI.h>
-#include <Ice/RegisterPluginsInit.h>
-#include <Ice/ObserverHelper.h>
-#include <Ice/Functional.h>
-#include <Ice/ConsoleUtil.h>
-
-#include <IceUtil/DisableWarnings.h>
-#include <IceUtil/FileUtil.h>
-#include <IceUtil/StringUtil.h>
-#include <Ice/UUID.h>
-#include <IceUtil/Mutex.h>
-#include <IceUtil/MutexPtrLock.h>
-#include <IceUtil/Atomic.h>
-
-#include <stdio.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "Instance.h"
+#include "AddDefaultPluginFactories.h"
+#include "CheckIdentity.h"
+#include "ConnectionFactory.h"
+#include "ConsoleUtil.h"
+#include "DefaultsAndOverrides.h"
+#include "EndpointFactoryManager.h"
+#include "FileUtil.h"
+#include "IPEndpointI.h" // For EndpointHostResolver
+#include "Ice/Communicator.h"
+#include "Ice/DefaultSliceLoader.h"
+#include "Ice/Initialize.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Locator.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/NativePropertiesAdmin.h"
+#include "Ice/ObserverHelper.h"
+#include "Ice/Properties.h"
+#include "Ice/Router.h"
+#include "Ice/StringUtil.h"
+#include "Ice/UUID.h"
+#include "InstrumentationI.h"
+#include "LocatorInfo.h"
+#include "LoggerAdminI.h"
+#include "LoggerI.h"
+#include "NetworkProxy.h"
+#include "ObjectAdapterFactory.h"
+#include "PluginManagerI.h"
+#include "ReferenceFactory.h"
+#include "RetryQueue.h"
+#include "RouterInfo.h"
+#include "SSL/SSLEngine.h"
+#include "ThreadPool.h"
+#include "TimeUtil.h"
+#include "TraceLevels.h"
+
+#include "DisableWarnings.h"
+
+#include <cstdio>
 #include <list>
+#include <mutex>
+#if defined(_WIN32)
+#    include "SSL/SchannelEngine.h"
+#elif defined(__APPLE__)
+#    include "SSL/SecureTransportEngine.h"
+#else
+#    include "SSL/OpenSSLEngine.h"
+#endif
 
 #ifdef __APPLE__
-#   include <Ice/OSLogLoggerI.h>
+#    include "OSLogLoggerI.h"
+#    if TARGET_OS_IPHONE == 0
+#        include <libproc.h> // For proc_pidpath
+#    endif
 #endif
 
 #ifndef _WIN32
-#   include <Ice/SysLoggerI.h>
-#   include <Ice/SystemdJournalI.h>
+#    if !defined(__APPLE__) || TARGET_OS_IPHONE == 0
+#        include "SysLoggerI.h"
+#    endif
 
-#   include <signal.h>
-#   include <syslog.h>
-#   include <pwd.h>
-#   include <sys/types.h>
+#    include "SystemdJournalI.h"
+
+#    include <csignal>
+#    include <pwd.h>
+#    include <sys/types.h>
+#    include <syslog.h>
 #endif
 
-#if defined(__linux__) || defined(__sun) || defined(_AIX) || defined(__GLIBC__)
-#   include <grp.h> // for initgroups
+#if defined(__linux__) || defined(__GLIBC__)
+#    include <grp.h> // for initgroups
 #endif
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-namespace IceUtilInternal
-{
-
-extern bool nullHandleAbort;
-extern bool printStackTraces;
-
-};
-
 namespace
 {
-
-IceUtil::Mutex* staticMutex = 0;
-bool oneOfDone = false;
-std::list<IceInternal::Instance*>* instanceList = 0;
+    mutex staticMutex;
+    bool oneOffDone = false;
+    std::list<IceInternal::Instance*>* instanceList = nullptr;
 
 #ifndef _WIN32
-struct sigaction oldAction;
+    struct sigaction oldAction;
 #endif
-bool printProcessIdDone = false;
-string identForOpenlog;
+    bool printProcessIdDone = false;
+    string identForOpenlog;
 
-//
-// Should be called with staticMutex locked
-//
-size_t instanceCount()
-{
-    if(instanceList == 0)
+    //
+    // Should be called with staticMutex locked
+    //
+    size_t instanceCount()
     {
-        return 0;
+        if (instanceList == nullptr)
+        {
+            return 0;
+        }
+        else
+        {
+            return instanceList->size();
+        }
     }
-    else
+
+    string getProgramName()
     {
-        return instanceList->size();
+        string programName;
+#if defined(__APPLE__) && TARGET_OS_IPHONE == 0
+        vector<char> buffer(PATH_MAX);
+        int len = proc_pidpath(getpid(), buffer.data(), static_cast<uint32_t>(buffer.size()));
+        if (len > 0)
+        {
+            programName = string{buffer.data(), static_cast<size_t>(len)};
+        }
+#elif defined(__linux__)
+        vector<char> buffer(PATH_MAX);
+        ssize_t len = readlink("/proc/self/exe", buffer.data(), buffer.size());
+        if (len > 0)
+        {
+            programName = string{buffer.data(), static_cast<size_t>(len)};
+        }
+#elif defined(_WIN32)
+        vector<char> buffer(MAX_PATH);
+        DWORD len = GetModuleFileNameA(NULL, buffer.data(), static_cast<DWORD>(buffer.size()));
+        if (len > 0)
+        {
+            programName = string{buffer.data(), static_cast<size_t>(len)};
+        }
+#endif
+        size_t pos = programName.find_last_of("/\\");
+        if (pos != string::npos)
+        {
+            programName = programName.substr(pos + 1);
+        }
+        return programName;
     }
-}
 
-class Init
-{
-public:
-
-    Init()
+    void checkPrintStackTraces(const InitializationData& initData) noexcept
     {
-        staticMutex = new IceUtil::Mutex;
-
-        //
-        // Although probably not necessary here, we consistently lock
-        // staticMutex before accessing instanceList
-        //
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
-        instanceList = new std::list<IceInternal::Instance*>;
+#ifdef NDEBUG
+        // Release build
+        if (initData.properties->getIcePropertyAsInt("Ice.PrintStackTraces") > 0)
+#else
+        // Debug build
+        if (initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 1) > 0)
+#endif
+        {
+            try
+            {
+                LocalException::ice_enableStackTraceCollection();
+            }
+            catch (const std::exception& ex)
+            {
+                Warning out(initData.logger);
+                out << "Cannot enable stack trace collection:\n" << ex;
+                out << "\nYou can turn off this warning by setting Ice.PrintStackTraces=0";
+            }
+        }
     }
 
-    ~Init()
+    class Init
     {
+    public:
+        Init() noexcept
         {
-            IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
-            int notDestroyedCount = 0;
+            // Although probably not necessary here, we consistently lock
+            // staticMutex before accessing instanceList.
+            lock_guard lock(staticMutex);
+            instanceList = new std::list<IceInternal::Instance*>;
+        }
 
-            for(std::list<IceInternal::Instance*>::const_iterator p = instanceList->begin();
-                p != instanceList->end(); ++p)
+        ~Init()
+        {
             {
-                if(!(*p)->destroyed())
-                {
-                    notDestroyedCount++;
-                }
-            }
+                lock_guard lock(staticMutex);
+                int notDestroyedCount = 0;
 
-            if(notDestroyedCount > 0)
-            {
-                consoleErr << "!! " << IceUtil::Time::now().toDateTime() << " error: ";
-                if(notDestroyedCount == 1)
+                for (const auto& p : *instanceList)
                 {
-                    consoleErr << "communicator ";
+                    if (!p->destroyed())
+                    {
+                        notDestroyedCount++;
+                    }
                 }
-                else
+
+                if (notDestroyedCount > 0)
                 {
-                    consoleErr << notDestroyedCount << " communicators ";
+                    consoleErr << "!! " << timePointToDateTimeString(chrono::system_clock::now()) << " error: ";
+                    if (notDestroyedCount == 1)
+                    {
+                        consoleErr << "communicator ";
+                    }
+                    else
+                    {
+                        consoleErr << notDestroyedCount << " communicators ";
+                    }
+                    consoleErr << "not destroyed during global destruction.";
                 }
-                consoleErr << "not destroyed during global destruction.";
-            }
 
-            delete instanceList;
-            instanceList = 0;
+                delete instanceList;
+                instanceList = nullptr;
+            }
         }
-        delete staticMutex;
-        staticMutex = 0;
-    }
-};
-
-Init init;
-
-//
-// Static initializer to register plugins.
-//
-IceInternal::RegisterPluginsInit initPlugins;
+    };
 
+    Init init;
 }
 
 namespace IceInternal // Required because ObserverUpdaterI is a friend of Instance
 {
-
-class ObserverUpdaterI : public Ice::Instrumentation::ObserverUpdater
-{
-public:
-
-    ObserverUpdaterI(const InstancePtr&);
-
-    virtual void updateConnectionObservers();
-    virtual void updateThreadObservers();
-
-private:
-
-    const InstancePtr _instance;
-};
-
-//
-// Timer specialization which supports the thread observer
-//
-class Timer : public IceUtil::Timer
-{
-public:
-
-    Timer(int priority) :
-        IceUtil::Timer(priority),
-        _hasObserver(0)
-    {
-    }
-
-    Timer() :
-        _hasObserver(0)
+    class ObserverUpdaterI : public Ice::Instrumentation::ObserverUpdater
     {
-    }
-
-    void updateObserver(const Ice::Instrumentation::CommunicatorObserverPtr&);
+    public:
+        ObserverUpdaterI(InstancePtr);
 
-private:
+        void updateConnectionObservers() override;
+        void updateThreadObservers() override;
 
-    virtual void runTimerTask(const IceUtil::TimerTaskPtr&);
+    private:
+        const InstancePtr _instance;
+    };
 
-    IceUtil::Mutex _mutex;
     //
-    // TODO: Replace by std::atomic<bool> when it becomes widely
-    // available.
+    // Timer specialization which supports the thread observer
     //
-    IceUtilInternal::Atomic _hasObserver;
-    ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
-};
+    class ThreadObserverTimer final : public IceInternal::Timer
+    {
+    public:
+        ThreadObserverTimer() : _hasObserver(false) {}
+
+        void updateObserver(const Ice::Instrumentation::CommunicatorObserverPtr&);
 
+    private:
+        void runTimerTask(const TimerTaskPtr&) final;
+
+        std::mutex _mutex;
+        std::atomic<bool> _hasObserver;
+        ObserverHelperT<Ice::Instrumentation::ThreadObserver> _observer;
+    };
 }
 
 void
-Timer::updateObserver(const Ice::Instrumentation::CommunicatorObserverPtr& obsv)
+ThreadObserverTimer::updateObserver(const Ice::Instrumentation::CommunicatorObserverPtr& obsv)
 {
-    IceUtil::Mutex::Lock sync(_mutex);
+    lock_guard lock(_mutex);
     assert(obsv);
-    _observer.attach(obsv->getThreadObserver("Communicator",
-                                            "Ice.Timer",
-                                            Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle),
-                                            _observer.get()));
-    _hasObserver.exchange(_observer.get() ? 1 : 0);
+    _observer.attach(obsv->getThreadObserver(
+        "Communicator",
+        "Ice.Timer",
+        Instrumentation::ThreadState::ThreadStateIdle,
+        _observer.get()));
+    _hasObserver.exchange(_observer);
 }
 
 void
-Timer::runTimerTask(const IceUtil::TimerTaskPtr& task)
+ThreadObserverTimer::runTimerTask(const TimerTaskPtr& task)
 {
-    if(_hasObserver != 0)
+    if (_hasObserver)
     {
         Ice::Instrumentation::ThreadObserverPtr threadObserver;
         {
-            IceUtil::Mutex::Lock sync(_mutex);
+            lock_guard lock(_mutex);
             threadObserver = _observer.get();
         }
-        if(threadObserver)
+        if (threadObserver)
         {
-            threadObserver->stateChanged(Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle),
-                                         Instrumentation::ICE_ENUM(ThreadState, ThreadStateInUseForOther));
+            threadObserver->stateChanged(
+                Instrumentation::ThreadState::ThreadStateIdle,
+                Instrumentation::ThreadState::ThreadStateInUseForOther);
         }
         try
         {
             task->runTimerTask();
         }
-        catch(...)
+        catch (...)
         {
-            if(threadObserver)
+            if (threadObserver)
             {
-                threadObserver->stateChanged(Instrumentation::ICE_ENUM(ThreadState, ThreadStateInUseForOther),
-                                             Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle));
+                threadObserver->stateChanged(
+                    Instrumentation::ThreadState::ThreadStateInUseForOther,
+                    Instrumentation::ThreadState::ThreadStateIdle);
             }
+            throw;
         }
-        if(threadObserver)
+
+        if (threadObserver)
         {
-            threadObserver->stateChanged(Instrumentation::ICE_ENUM(ThreadState, ThreadStateInUseForOther),
-                                         Instrumentation::ICE_ENUM(ThreadState, ThreadStateIdle));
+            threadObserver->stateChanged(
+                Instrumentation::ThreadState::ThreadStateInUseForOther,
+                Instrumentation::ThreadState::ThreadStateIdle);
         }
     }
     else
@@ -274,11 +298,7 @@ Timer::runTimerTask(const IceUtil::TimerTaskPtr& task)
     }
 }
 
-IceUtil::Shared* IceInternal::upCast(Instance* p) { return p; }
-
-IceInternal::ObserverUpdaterI::ObserverUpdaterI(const InstancePtr& instance) : _instance(instance)
-{
-}
+IceInternal::ObserverUpdaterI::ObserverUpdaterI(InstancePtr instance) : _instance(std::move(instance)) {}
 
 void
 IceInternal::ObserverUpdaterI::updateConnectionObservers()
@@ -295,7 +315,7 @@ IceInternal::ObserverUpdaterI::updateThreadObservers()
 bool
 IceInternal::Instance::destroyed() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     return _state == StateDestroyed;
 }
 
@@ -318,9 +338,9 @@ IceInternal::Instance::defaultsAndOverrides() const
 RouterManagerPtr
 IceInternal::Instance::routerManager() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -332,9 +352,9 @@ IceInternal::Instance::routerManager() const
 LocatorManagerPtr
 IceInternal::Instance::locatorManager() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -346,9 +366,9 @@ IceInternal::Instance::locatorManager() const
 ReferenceFactoryPtr
 IceInternal::Instance::referenceFactory() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -357,40 +377,12 @@ IceInternal::Instance::referenceFactory() const
     return _referenceFactory;
 }
 
-RequestHandlerFactoryPtr
-IceInternal::Instance::requestHandlerFactory() const
-{
-    Lock sync(*this);
-
-    if(_state == StateDestroyed)
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
-
-    assert(_requestHandlerFactory);
-    return _requestHandlerFactory;
-}
-
-ProxyFactoryPtr
-IceInternal::Instance::proxyFactory() const
-{
-    Lock sync(*this);
-
-    if(_state == StateDestroyed)
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
-
-    assert(_proxyFactory);
-    return _proxyFactory;
-}
-
 OutgoingConnectionFactoryPtr
 IceInternal::Instance::outgoingConnectionFactory() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -402,9 +394,9 @@ IceInternal::Instance::outgoingConnectionFactory() const
 ObjectAdapterFactoryPtr
 IceInternal::Instance::objectAdapterFactory() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -434,9 +426,9 @@ IceInternal::Instance::networkProxy() const
 ThreadPoolPtr
 IceInternal::Instance::clientThreadPool()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -448,21 +440,21 @@ IceInternal::Instance::clientThreadPool()
 ThreadPoolPtr
 IceInternal::Instance::serverThreadPool()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
-    if(!_serverThreadPool) // Lazy initialization.
+    if (!_serverThreadPool) // Lazy initialization.
     {
-        if(_state == StateDestroyInProgress)
+        if (_state == StateDestroyInProgress)
         {
             throw CommunicatorDestroyedException(__FILE__, __LINE__);
         }
-        int timeout = _initData.properties->getPropertyAsInt("Ice.ServerIdleTime");
-        _serverThreadPool = new ThreadPool(this, "Ice.ThreadPool.Server", timeout);
+        int timeout = _initData.properties->getIcePropertyAsInt("Ice.ServerIdleTime");
+        _serverThreadPool = ThreadPool::create(shared_from_this(), "Ice.ThreadPool.Server", timeout);
     }
 
     return _serverThreadPool;
@@ -471,9 +463,9 @@ IceInternal::Instance::serverThreadPool()
 EndpointHostResolverPtr
 IceInternal::Instance::endpointHostResolver()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -485,9 +477,9 @@ IceInternal::Instance::endpointHostResolver()
 RetryQueuePtr
 IceInternal::Instance::retryQueue()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -496,12 +488,12 @@ IceInternal::Instance::retryQueue()
     return _retryQueue;
 }
 
-IceUtil::TimerPtr
+IceInternal::TimerPtr
 IceInternal::Instance::timer()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -512,9 +504,9 @@ IceInternal::Instance::timer()
 EndpointFactoryManagerPtr
 IceInternal::Instance::endpointFactoryManager() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -523,26 +515,12 @@ IceInternal::Instance::endpointFactoryManager() const
     return _endpointFactoryManager;
 }
 
-DynamicLibraryListPtr
-IceInternal::Instance::dynamicLibraryList() const
-{
-    Lock sync(*this);
-
-    if(_state == StateDestroyed)
-    {
-        throw CommunicatorDestroyedException(__FILE__, __LINE__);
-    }
-
-    assert(_dynamicLibraryList);
-    return _dynamicLibraryList;
-}
-
 PluginManagerPtr
 IceInternal::Instance::pluginManager() const
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -551,53 +529,73 @@ IceInternal::Instance::pluginManager() const
     return _pluginManager;
 }
 
-const ACMConfig&
-IceInternal::Instance::clientACM() const
+ConnectionOptions
+IceInternal::Instance::serverConnectionOptions(const string& adapterName) const
 {
-    // No mutex lock, immutable.
-    return _clientACM;
-}
+    assert(!adapterName.empty());
+    string propertyPrefix = adapterName + ".Connection";
 
-const ACMConfig&
-IceInternal::Instance::serverACM() const
-{
-    // No mutex lock, immutable.
-    return _serverACM;
+    const PropertiesPtr& properties = _initData.properties;
+
+    ConnectionOptions connectionOptions;
+
+    connectionOptions.connectTimeout = chrono::seconds(properties->getPropertyAsIntWithDefault(
+        propertyPrefix + ".ConnectTimeout",
+        static_cast<int>(_serverConnectionOptions.connectTimeout.count())));
+
+    connectionOptions.closeTimeout = chrono::seconds(properties->getPropertyAsIntWithDefault(
+        propertyPrefix + ".CloseTimeout",
+        static_cast<int>(_serverConnectionOptions.closeTimeout.count())));
+
+    connectionOptions.idleTimeout = chrono::seconds(properties->getPropertyAsIntWithDefault(
+        propertyPrefix + ".IdleTimeout",
+        static_cast<int>(_serverConnectionOptions.idleTimeout.count())));
+
+    connectionOptions.enableIdleCheck = properties->getPropertyAsIntWithDefault(
+                                            propertyPrefix + ".EnableIdleCheck",
+                                            _serverConnectionOptions.enableIdleCheck ? 1 : 0) > 0;
+
+    connectionOptions.inactivityTimeout = chrono::seconds(properties->getPropertyAsIntWithDefault(
+        propertyPrefix + ".InactivityTimeout",
+        static_cast<int>(_serverConnectionOptions.inactivityTimeout.count())));
+
+    connectionOptions.maxDispatches = properties->getPropertyAsIntWithDefault(
+        propertyPrefix + ".MaxDispatches",
+        _serverConnectionOptions.maxDispatches);
+
+    return connectionOptions;
 }
 
-Ice::ObjectPrxPtr
+Ice::ObjectPrx
 IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const Identity& adminIdentity)
 {
     ObjectAdapterPtr adapter = adminAdapter;
     bool createAdapter = !adminAdapter;
 
-    Lock sync(*this);
+    unique_lock lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
-    if(adminIdentity.name.empty())
-    {
-        throw Ice::IllegalIdentityException(__FILE__, __LINE__, adminIdentity);
-    }
+    checkIdentity(adminIdentity, __FILE__, __LINE__);
 
-    if(_adminAdapter)
+    if (_adminAdapter)
     {
         throw InitializationException(__FILE__, __LINE__, "Admin already created");
     }
 
-    if(!_adminEnabled)
+    if (!_adminEnabled)
     {
         throw InitializationException(__FILE__, __LINE__, "Admin is disabled");
     }
 
-    if(createAdapter)
+    if (createAdapter)
     {
-        if(_initData.properties->getProperty("Ice.Admin.Endpoints") != "")
+        if (_initData.properties->getIceProperty("Ice.Admin.Endpoints") != "")
         {
-            adapter = _objectAdapterFactory->createObjectAdapter("Ice.Admin", 0);
+            adapter = _objectAdapterFactory->createObjectAdapter("Ice.Admin", nullopt, nullopt);
         }
         else
         {
@@ -608,15 +606,15 @@ IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const I
     _adminIdentity = adminIdentity;
     _adminAdapter = adapter;
     addAllAdminFacets();
-    sync.release();
+    lock.unlock();
 
-    if(createAdapter)
+    if (createAdapter)
     {
         try
         {
             adapter->activate();
         }
-        catch(...)
+        catch (...)
         {
             //
             // We clean it up, even through this error is not recoverable
@@ -624,8 +622,8 @@ IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const I
             // in the adapter are lost)
             //
             adapter->destroy();
-            sync.acquire();
-            _adminAdapter = 0;
+            lock.lock();
+            _adminAdapter = nullptr;
             throw;
         }
     }
@@ -633,36 +631,36 @@ IceInternal::Instance::createAdmin(const ObjectAdapterPtr& adminAdapter, const I
     return adapter->createProxy(adminIdentity);
 }
 
-Ice::ObjectPrxPtr
+std::optional<ObjectPrx>
 IceInternal::Instance::getAdmin()
 {
-    Lock sync(*this);
+    unique_lock lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
-    if(_adminAdapter)
+    if (_adminAdapter)
     {
         return _adminAdapter->createProxy(_adminIdentity);
     }
-    else if(_adminEnabled)
+    else if (_adminEnabled)
     {
         ObjectAdapterPtr adapter;
-        if(_initData.properties->getProperty("Ice.Admin.Endpoints") != "")
+        if (_initData.properties->getIceProperty("Ice.Admin.Endpoints") != "")
         {
-            adapter = _objectAdapterFactory->createObjectAdapter("Ice.Admin", 0);
+            adapter = _objectAdapterFactory->createObjectAdapter("Ice.Admin", nullopt, nullopt);
         }
         else
         {
-            return 0;
+            return nullopt;
         }
 
         Identity adminIdentity;
         adminIdentity.name = "admin";
-        adminIdentity.category = _initData.properties->getProperty("Ice.Admin.InstanceName");
-        if(adminIdentity.category.empty())
+        adminIdentity.category = _initData.properties->getIceProperty("Ice.Admin.InstanceName");
+        if (adminIdentity.category.empty())
         {
             adminIdentity.category = Ice::generateUUID();
         }
@@ -670,12 +668,12 @@ IceInternal::Instance::getAdmin()
         _adminIdentity = adminIdentity;
         _adminAdapter = adapter;
         addAllAdminFacets();
-        sync.release();
+        lock.unlock();
         try
         {
             adapter->activate();
         }
-        catch(...)
+        catch (...)
         {
             //
             // We clean it up, even through this error is not recoverable
@@ -683,8 +681,8 @@ IceInternal::Instance::getAdmin()
             // in the adapter are lost)
             //
             adapter->destroy();
-            sync.acquire();
-            _adminAdapter = 0;
+            lock.lock();
+            _adminAdapter = nullptr;
             throw;
         }
 
@@ -693,7 +691,7 @@ IceInternal::Instance::getAdmin()
     }
     else
     {
-        return 0;
+        return nullopt;
     }
 }
 
@@ -707,15 +705,15 @@ IceInternal::Instance::addAllAdminFacets()
     //
     FacetMap filteredFacets;
 
-    for(FacetMap::iterator p = _adminFacets.begin(); p != _adminFacets.end(); ++p)
+    for (const auto& adminFacet : _adminFacets)
     {
-        if(_adminFacetFilter.empty() || _adminFacetFilter.find(p->first) != _adminFacetFilter.end())
+        if (_adminFacetFilter.empty() || _adminFacetFilter.find(adminFacet.first) != _adminFacetFilter.end())
         {
-            _adminAdapter->addFacet(p->second, _adminIdentity, p->first);
+            _adminAdapter->addFacet(adminFacet.second, _adminIdentity, adminFacet.first);
         }
         else
         {
-            filteredFacets[p->first] = p->second;
+            filteredFacets[adminFacet.first] = adminFacet.second;
         }
     }
     _adminFacets.swap(filteredFacets);
@@ -724,12 +722,12 @@ IceInternal::Instance::addAllAdminFacets()
 void
 IceInternal::Instance::setServerProcessProxy(const ObjectAdapterPtr& adminAdapter, const Identity& adminIdentity)
 {
-    ObjectPrxPtr admin = adminAdapter->createProxy(adminIdentity);
-    LocatorPrxPtr locator = adminAdapter->getLocator();
-    const string serverId = _initData.properties->getProperty("Ice.Admin.ServerId");
-    if(locator && serverId != "")
+    ObjectPrx admin = adminAdapter->createProxy(adminIdentity);
+    optional<LocatorPrx> locator = adminAdapter->getLocator();
+    const string serverId = _initData.properties->getIceProperty("Ice.Admin.ServerId");
+    if (locator && serverId != "")
     {
-        ProcessPrxPtr process = ICE_UNCHECKED_CAST(ProcessPrx, admin->ice_facet("Process"));
+        auto process = admin->ice_facet<ProcessPrx>("Process");
         try
         {
             //
@@ -738,77 +736,81 @@ IceInternal::Instance::setServerProcessProxy(const ObjectAdapterPtr& adminAdapte
             //
             locator->getRegistry()->setServerProcessProxy(serverId, process);
         }
-        catch(const ServerNotFoundException&)
+        catch (const ServerNotFoundException&)
         {
-            if(_traceLevels->location >= 1)
+            if (_traceLevels->location >= 1)
             {
                 Trace out(_initData.logger, _traceLevels->locationCat);
-                out << "couldn't register server `" + serverId + "' with the locator registry:\n";
+                out << "couldn't register server '" + serverId + "' with the locator registry:\n";
                 out << "the server is not known to the locator registry";
             }
 
-            throw InitializationException(__FILE__, __LINE__, "Locator `" + _proxyFactory->proxyToString(locator) +
-                                          "' knows nothing about server `" + serverId + "'");
+            throw InitializationException(
+                __FILE__,
+                __LINE__,
+                "Locator '" + locator->ice_toString() + "' knows nothing about server '" + serverId + "'");
         }
-        catch(const LocalException& ex)
+        catch (const LocalException& ex)
         {
-            if(_traceLevels->location >= 1)
+            if (_traceLevels->location >= 1)
             {
                 Trace out(_initData.logger, _traceLevels->locationCat);
-                out << "couldn't register server `" + serverId + "' with the locator registry:\n" << ex;
+                out << "couldn't register server '" + serverId + "' with the locator registry:\n" << ex;
             }
             throw;
         }
 
-        if(_traceLevels->location >= 1)
+        if (_traceLevels->location >= 1)
         {
             Trace out(_initData.logger, _traceLevels->locationCat);
-            out << "registered server `" + serverId + "' with the locator registry";
+            out << "registered server '" + serverId + "' with the locator registry";
         }
     }
 }
 
 void
-IceInternal::Instance::addAdminFacet(const Ice::ObjectPtr& servant, const string& facet)
+IceInternal::Instance::addAdminFacet(ObjectPtr servant, string facet)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
-    if(_adminAdapter == 0 || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
+    if (_adminAdapter == nullptr ||
+        (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
     {
-        if(_adminFacets.insert(FacetMap::value_type(facet, servant)).second == false)
+        if (_adminFacets.insert(FacetMap::value_type(facet, servant)).second == false)
         {
             throw AlreadyRegisteredException(__FILE__, __LINE__, "facet", facet);
         }
     }
     else
     {
-        _adminAdapter->addFacet(servant, _adminIdentity, facet);
+        _adminAdapter->addFacet(std::move(servant), _adminIdentity, std::move(facet));
     }
 }
 
-Ice::ObjectPtr
-IceInternal::Instance::removeAdminFacet(const string& facet)
+ObjectPtr
+IceInternal::Instance::removeAdminFacet(string_view facet)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
     ObjectPtr result;
 
-    if(_adminAdapter == 0 || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
+    if (_adminAdapter == nullptr ||
+        (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
     {
-        FacetMap::iterator p = _adminFacets.find(facet);
-        if(p == _adminFacets.end())
+        auto p = _adminFacets.find(facet);
+        if (p == _adminFacets.end())
         {
-            throw NotRegisteredException(__FILE__, __LINE__, "facet", facet);
+            throw NotRegisteredException(__FILE__, __LINE__, "facet", string{facet});
         }
         else
         {
@@ -824,12 +826,12 @@ IceInternal::Instance::removeAdminFacet(const string& facet)
     return result;
 }
 
-Ice::ObjectPtr
-IceInternal::Instance::findAdminFacet(const string& facet)
+ObjectPtr
+IceInternal::Instance::findAdminFacet(string_view facet)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -839,10 +841,10 @@ IceInternal::Instance::findAdminFacet(const string& facet)
     //
     // If the _adminAdapter was not yet created, or this facet is filtered out, we check _adminFacets
     //
-    if(!_adminAdapter || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
+    if (!_adminAdapter || (!_adminFacetFilter.empty() && _adminFacetFilter.find(facet) == _adminFacetFilter.end()))
     {
-        FacetMap::iterator p = _adminFacets.find(facet);
-        if(p != _adminFacets.end())
+        auto p = _adminFacets.find(facet);
+        if (p != _adminFacets.end())
         {
             result = p->second;
         }
@@ -859,21 +861,21 @@ IceInternal::Instance::findAdminFacet(const string& facet)
 FacetMap
 IceInternal::Instance::findAllAdminFacets()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
-    if(!_adminAdapter)
+    if (!_adminAdapter)
     {
         return _adminFacets;
     }
     else
     {
         FacetMap result = _adminAdapter->findAllFacets(_adminIdentity);
-        if(!_adminFacets.empty())
+        if (!_adminFacets.empty())
         {
             // Also returns filtered facets
             result.insert(_adminFacets.begin(), _adminFacets.end());
@@ -883,11 +885,11 @@ IceInternal::Instance::findAllAdminFacets()
 }
 
 void
-IceInternal::Instance::setDefaultLocator(const Ice::LocatorPrxPtr& defaultLocator)
+IceInternal::Instance::setDefaultLocator(const optional<LocatorPrx>& defaultLocator)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -896,11 +898,11 @@ IceInternal::Instance::setDefaultLocator(const Ice::LocatorPrxPtr& defaultLocato
 }
 
 void
-IceInternal::Instance::setDefaultRouter(const Ice::RouterPrxPtr& defaultRouter)
+IceInternal::Instance::setDefaultRouter(const optional<RouterPrx>& defaultRouter)
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_state == StateDestroyed)
+    if (_state == StateDestroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -917,147 +919,102 @@ IceInternal::Instance::setLogger(const Ice::LoggerPtr& logger)
     _initData.logger = logger;
 }
 
-#ifdef ICE_CPP11_MAPPING
 void
 IceInternal::Instance::setThreadHook(function<void()> threadStart, function<void()> threadStop)
 {
     _initData.threadStart = std::move(threadStart);
     _initData.threadStop = std::move(threadStop);
 }
-#else
-void
-IceInternal::Instance::setThreadHook(const Ice::ThreadNotificationPtr& threadHook)
+namespace
 {
-    //
-    // No locking, as it can only be called during plug-in loading
-    //
-    _initData.threadHook = threadHook;
+    bool logStdErrConvert = true;
 }
-#endif
 
-namespace
+InstancePtr
+IceInternal::Instance::create(const Ice::CommunicatorPtr& communicator, Ice::InitializationData initData)
 {
+    auto instance = shared_ptr<Instance>(new Instance(std::move(initData)));
+    instance->initialize(communicator);
+    return instance;
+}
 
-bool logStdErrConvert = true;
-
+IceInternal::Instance::Instance(InitializationData initData)
+    : _initData(std::move(initData)),
+      _stringConverter(Ice::getProcessStringConverter()),
+      _wstringConverter(Ice::getProcessWstringConverter()),
+      _applicationSliceLoader(make_shared<CompositeSliceLoader>())
+{
+#if defined(ICE_USE_SCHANNEL)
+    if (_initData.clientAuthenticationOptions && _initData.clientAuthenticationOptions->trustedRootCertificates)
+    {
+        CertDuplicateStore(_initData.clientAuthenticationOptions->trustedRootCertificates);
+    }
+#elif defined(ICE_USE_SECURE_TRANSPORT)
+    if (_initData.clientAuthenticationOptions && _initData.clientAuthenticationOptions->trustedRootCertificates)
+    {
+        CFRetain(_initData.clientAuthenticationOptions->trustedRootCertificates);
+    }
+#endif
 }
 
-IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const InitializationData& initData) :
-    _state(StateActive),
-    _initData(initData),
-    _messageSizeMax(0),
-    _batchAutoFlushSize(0),
-    _classGraphDepthMax(0),
-    _collectObjects(false),
-    _toStringMode(ICE_ENUM(ToStringMode, Unicode)),
-    _acceptClassCycles(false),
-    _implicitContext(0),
-    _stringConverter(Ice::getProcessStringConverter()),
-    _wstringConverter(Ice::getProcessWstringConverter()),
-    _adminEnabled(false)
+void
+IceInternal::Instance::initialize(const Ice::CommunicatorPtr& communicator)
 {
     try
     {
-        __setNoDelete(true);
+        if (!_initData.properties)
         {
-            IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
-            instanceList->push_back(this);
+            // Plain empty properties, in particular, no ICE_CONFIG properties.
+            _initData.properties = make_shared<Ice::Properties>();
+        }
 
-            if(!_initData.properties)
-            {
-                _initData.properties = createProperties();
-            }
+        string programName = _initData.properties->getIceProperty("Ice.ProgramName");
+
+        if (programName.empty())
+        {
+            programName = getProgramName();
+            _initData.properties->setProperty("Ice.ProgramName", programName);
+        }
+
+        {
+            lock_guard lock(staticMutex);
+            instanceList->push_back(this);
 
-            if(!oneOfDone)
+            if (!oneOffDone)
             {
                 //
                 // StdOut and StdErr redirection
                 //
-                string stdOutFilename = _initData.properties->getProperty("Ice.StdOut");
-                string stdErrFilename = _initData.properties->getProperty("Ice.StdErr");
+                string stdOutFilename = _initData.properties->getIceProperty("Ice.StdOut");
+                string stdErrFilename = _initData.properties->getIceProperty("Ice.StdErr");
 
-                if(stdOutFilename != "")
+                if (stdOutFilename != "")
                 {
-                    FILE* file = IceUtilInternal::freopen(stdOutFilename, "a", stdout);
-                    if(file == 0)
+                    FILE* file = IceInternal::freopen(stdOutFilename, "a", stdout);
+                    if (file == nullptr)
                     {
-                        throw FileException(__FILE__, __LINE__, getSystemErrno(), stdOutFilename);
+                        throw FileException(__FILE__, __LINE__, stdOutFilename);
                     }
                 }
 
-                if(stdErrFilename != "")
+                if (stdErrFilename != "")
                 {
-                    FILE* file = IceUtilInternal::freopen(stdErrFilename, "a", stderr);
-                    if(file == 0)
+                    FILE* file = IceInternal::freopen(stdErrFilename, "a", stderr);
+                    if (file == nullptr)
                     {
-                        throw FileException(__FILE__, __LINE__, getSystemErrno(), stdErrFilename);
+                        throw FileException(__FILE__, __LINE__, stdErrFilename);
                     }
                 }
 
-                if(_initData.properties->getPropertyAsInt("Ice.NullHandleAbort") > 0)
-                {
-                    IceUtilInternal::nullHandleAbort = true;
-                }
-
-#ifdef NDEBUG
-                if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 0) > 0)
-                {
-                    IceUtilInternal::printStackTraces = true;
-                }
-#else
-                if(_initData.properties->getPropertyAsIntWithDefault("Ice.PrintStackTraces", 1) == 0)
-                {
-                    IceUtilInternal::printStackTraces = false;
-                }
-#endif
-
-#ifndef _WIN32
-                string newUser = _initData.properties->getProperty("Ice.ChangeUser");
-                if(!newUser.empty())
-                {
-                    struct passwd pwbuf;
-                    vector<char> buffer(4096); // 4KB initial buffer
-                    struct passwd *pw;
-                    int err;
-                    while((err =  getpwnam_r(newUser.c_str(), &pwbuf, &buffer[0], buffer.size(), &pw)) == ERANGE &&
-                          buffer.size() < 1024 * 1024) // Limit buffer to 1M
-                    {
-                        buffer.resize(buffer.size() * 2);
-                    }
-                    if(err != 0)
-                    {
-                        throw Ice::SyscallException(__FILE__, __LINE__, err);
-                    }
-                    else if(pw == 0)
-                    {
-                        throw InitializationException(__FILE__, __LINE__, "unknown user account `" + newUser + "'");
-                    }
-
-                    if(setgid(pw->pw_gid) == -1)
-                    {
-                        throw SyscallException(__FILE__, __LINE__, getSystemErrno());
-                    }
-
-                    if(initgroups(pw->pw_name, static_cast<int>(pw->pw_gid)) == -1)
-                    {
-                        throw SyscallException(__FILE__, __LINE__, getSystemErrno());
-                    }
-
-                    if(setuid(pw->pw_uid) == -1)
-                    {
-                        throw SyscallException(__FILE__, __LINE__, getSystemErrno());
-                    }
-                }
-#endif
-                oneOfDone = true;
+                oneOffDone = true;
             }
 
-            if(instanceCount() == 1)
+            if (instanceCount() == 1)
             {
 #if defined(_WIN32)
                 WORD version = MAKEWORD(1, 1);
                 WSADATA data;
-                if(WSAStartup(version, &data) != 0)
+                if (WSAStartup(version, &data) != 0)
                 {
                     throw SocketException(__FILE__, __LINE__, getSocketErrno());
                 }
@@ -1069,192 +1026,205 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
                 sigemptyset(&action.sa_mask);
                 action.sa_flags = 0;
                 sigaction(SIGPIPE, &action, &oldAction);
-                if(_initData.properties->getPropertyAsInt("Ice.UseSyslog") > 0)
+                if (_initData.properties->getIcePropertyAsInt("Ice.UseSyslog") > 0)
                 {
-                    identForOpenlog = _initData.properties->getProperty("Ice.ProgramName");
-                    if(identForOpenlog.empty())
+                    identForOpenlog = programName;
+                    if (identForOpenlog.empty())
                     {
                         identForOpenlog = "<Unknown Ice Program>";
                     }
                     openlog(identForOpenlog.c_str(), LOG_PID, LOG_USER);
                 }
 #else
-                logStdErrConvert =
-                    _initData.properties->getPropertyAsIntWithDefault("Ice.LogStdErr.Convert", 1) > 0 &&
-                    _initData.properties->getProperty("Ice.StdErr").empty();
+                logStdErrConvert = _initData.properties->getIcePropertyAsInt("Ice.LogStdErr.Convert") > 0 &&
+                                   _initData.properties->getIceProperty("Ice.StdErr").empty();
 #endif
             }
         }
 
-        if(!_initData.logger)
+        if (!_initData.logger)
         {
-            string logfile = _initData.properties->getProperty("Ice.LogFile");
-#ifndef _WIN32
-            if(_initData.properties->getPropertyAsInt("Ice.UseSyslog") > 0)
+            string logfile = _initData.properties->getIceProperty("Ice.LogFile");
+#if !defined(_WIN32) && (!defined(__APPLE__) || TARGET_OS_IPHONE == 0)
+            if (_initData.properties->getIcePropertyAsInt("Ice.UseSyslog") > 0)
             {
-                if(!logfile.empty())
+                if (!logfile.empty())
                 {
                     throw InitializationException(__FILE__, __LINE__, "Both syslog and file logger cannot be enabled.");
                 }
 
-                _initData.logger = ICE_MAKE_SHARED(SysLoggerI,
-                                                   _initData.properties->getProperty("Ice.ProgramName"),
-                                                   _initData.properties->getPropertyWithDefault("Ice.SyslogFacility", "LOG_USER"));
+                _initData.logger =
+                    make_shared<SysLoggerI>(programName, _initData.properties->getIceProperty("Ice.SyslogFacility"));
             }
             else
 #endif
 
-#ifdef ICE_SWIFT
-            if(!_initData.logger && _initData.properties->getPropertyAsInt("Ice.UseOSLog") > 0)
+#ifdef __APPLE__
+                if (!_initData.logger && _initData.properties->getIcePropertyAsInt("Ice.UseOSLog") > 0)
             {
-                _initData.logger = ICE_MAKE_SHARED(OSLogLoggerI,
-                                                   _initData.properties->getProperty("Ice.ProgramName"));
+                _initData.logger = make_shared<OSLogLoggerI>(programName);
             }
             else
 #endif
 
 #ifdef ICE_USE_SYSTEMD
-            if(_initData.properties->getPropertyAsInt("Ice.UseSystemdJournal") > 0)
+                if (_initData.properties->getIcePropertyAsInt("Ice.UseSystemdJournal") > 0)
             {
-                _initData.logger = ICE_MAKE_SHARED(SystemdJournalI,
-                                                   _initData.properties->getProperty("Ice.ProgramName"));
+                _initData.logger = make_shared<SystemdJournalI>(programName);
             }
             else
 #endif
-            if(!logfile.empty())
+                if (!logfile.empty())
             {
-                Int sz = _initData.properties->getPropertyAsIntWithDefault("Ice.LogFile.SizeMax", 0);
-                if(sz < 0)
+                int32_t sz = _initData.properties->getIcePropertyAsInt("Ice.LogFile.SizeMax");
+                if (sz < 0)
                 {
                     sz = 0;
                 }
-                _initData.logger = ICE_MAKE_SHARED(LoggerI, _initData.properties->getProperty("Ice.ProgramName"),
-                                                   logfile, true, static_cast<size_t>(sz));
+                _initData.logger = make_shared<LoggerI>(programName, logfile, true, static_cast<size_t>(sz));
             }
             else
             {
                 _initData.logger = getProcessLogger();
-                if(ICE_DYNAMIC_CAST(LoggerI, _initData.logger))
+                if (dynamic_pointer_cast<LoggerI>(_initData.logger))
                 {
-                    _initData.logger = ICE_MAKE_SHARED(LoggerI, _initData.properties->getProperty("Ice.ProgramName"), "", logStdErrConvert);
+                    _initData.logger = make_shared<LoggerI>(programName, "", logStdErrConvert);
                 }
             }
         }
+        assert(_initData.logger);
 
-        const_cast<TraceLevelsPtr&>(_traceLevels) = new TraceLevels(_initData.properties);
+        // This affects the entire process.
+        checkPrintStackTraces(_initData);
 
-        const_cast<DefaultsAndOverridesPtr&>(_defaultsAndOverrides) =
-            new DefaultsAndOverrides(_initData.properties, _initData.logger);
+        const_cast<TraceLevelsPtr&>(_traceLevels) = make_shared<TraceLevels>(_initData.properties);
 
-        const ACMConfig defaultClientACM(_initData.properties, _initData.logger, "Ice.ACM", ACMConfig(false));
-        const ACMConfig defaultServerACM(_initData.properties, _initData.logger, "Ice.ACM", ACMConfig(true));
+        const_cast<DefaultsAndOverridesPtr&>(_defaultsAndOverrides) =
+            make_shared<DefaultsAndOverrides>(_initData.properties);
 
-        const_cast<ACMConfig&>(_clientACM) = ACMConfig(_initData.properties,
-                                                       _initData.logger,
-                                                       "Ice.ACM.Client",
-                                                       defaultClientACM);
+        const_cast<ConnectionOptions&>(_clientConnectionOptions) = readConnectionOptions("Ice.Connection.Client");
+        const_cast<ConnectionOptions&>(_serverConnectionOptions) = readConnectionOptions("Ice.Connection.Server");
 
-        const_cast<ACMConfig&>(_serverACM) = ACMConfig(_initData.properties,
-                                                       _initData.logger,
-                                                       "Ice.ACM.Server",
-                                                       defaultServerACM);
+        // The maximum size of an Ice protocol message in bytes. This is limited to 0x7fffffff, which corresponds to
+        // the maximum value of a 32-bit signed integer (int32_t).
+        const int32_t messageSizeMaxUpperLimit = numeric_limits<int32_t>::max();
+        int32_t messageSizeMax = _initData.properties->getIcePropertyAsInt("Ice.MessageSizeMax");
+        if (messageSizeMax > messageSizeMaxUpperLimit / 1024)
+        {
+            ostringstream os;
+            os << "Ice.MessageSizeMax '" << messageSizeMax << "' is too large, it must be less than or equal to '"
+               << (messageSizeMaxUpperLimit / 1024) << "' KiB";
+            throw InitializationException{__FILE__, __LINE__, os.str()};
+        }
+        else if (messageSizeMax < 1)
+        {
+            const_cast<int32_t&>(_messageSizeMax) = messageSizeMaxUpperLimit;
+        }
+        else
+        {
+            // The property is specified in kibibytes (KiB); _messageSizeMax is stored in bytes.
+            const_cast<int32_t&>(_messageSizeMax) = messageSizeMax * 1024;
+        }
 
+        int32_t batchAutoFlushSize = _initData.properties->getIcePropertyAsInt("Ice.BatchAutoFlushSize");
+        if (batchAutoFlushSize > messageSizeMaxUpperLimit / 1024)
         {
-            static const int defaultMessageSizeMax = 1024;
-            Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.MessageSizeMax", defaultMessageSizeMax);
-            if(num < 1 || static_cast<size_t>(num) > static_cast<size_t>(0x7fffffff / 1024))
-            {
-                const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(0x7fffffff);
-            }
-            else
-            {
-                // Property is in kilobytes, _messageSizeMax in bytes.
-                const_cast<size_t&>(_messageSizeMax) = static_cast<size_t>(num) * 1024;
-            }
+            ostringstream os;
+            os << "Ice.BatchAutoFlushSize '" << batchAutoFlushSize
+               << "' is too large, it must be less than or equal to '" << (messageSizeMaxUpperLimit / 1024) << "' KiB";
+            throw InitializationException{__FILE__, __LINE__, os.str()};
+        }
+        else if (batchAutoFlushSize < 1)
+        {
+            const_cast<int32_t&>(_batchAutoFlushSize) = messageSizeMaxUpperLimit;
+        }
+        else
+        {
+            // The property is specified in kibibytes (KiB); _batchAutoFlushSize is stored in bytes.
+            const_cast<int32_t&>(_batchAutoFlushSize) = batchAutoFlushSize * 1024;
         }
 
-        if(_initData.properties->getProperty("Ice.BatchAutoFlushSize").empty() &&
-           !_initData.properties->getProperty("Ice.BatchAutoFlush").empty())
+        int32_t classGraphDepthMax = _initData.properties->getIcePropertyAsInt("Ice.ClassGraphDepthMax");
+        if (classGraphDepthMax < 1)
         {
-            if(_initData.properties->getPropertyAsInt("Ice.BatchAutoFlush") > 0)
-            {
-                const_cast<size_t&>(_batchAutoFlushSize) = _messageSizeMax;
-            }
+            const_cast<int32_t&>(_classGraphDepthMax) = numeric_limits<int32_t>::max();
         }
         else
         {
-            Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.BatchAutoFlushSize", 1024); // 1MB default
-            if(num < 1)
-            {
-                const_cast<size_t&>(_batchAutoFlushSize) = static_cast<size_t>(num);
-            }
-            else if(static_cast<size_t>(num) > static_cast<size_t>(0x7fffffff / 1024))
-            {
-                const_cast<size_t&>(_batchAutoFlushSize) = static_cast<size_t>(0x7fffffff);
-            }
-            else
-            {
-                // Property is in kilobytes, convert in bytes.
-                const_cast<size_t&>(_batchAutoFlushSize) = static_cast<size_t>(num) * 1024;
-            }
+            const_cast<int32_t&>(_classGraphDepthMax) = classGraphDepthMax;
         }
 
+        // Update _initData.sliceLoader.
+
+        if (_initData.sliceLoader)
         {
-            static const int defaultValue = 100;
-            Int num = _initData.properties->getPropertyAsIntWithDefault("Ice.ClassGraphDepthMax", defaultValue);
-            if(num < 1 || static_cast<size_t>(num) > static_cast<size_t>(0x7fffffff))
-            {
-                const_cast<size_t&>(_classGraphDepthMax) = static_cast<size_t>(0x7fffffff);
-            }
-            else
-            {
-                const_cast<size_t&>(_classGraphDepthMax) = static_cast<size_t>(num);
-            }
+            _applicationSliceLoader->add(_initData.sliceLoader);
         }
 
-        const_cast<bool&>(_collectObjects) = _initData.properties->getPropertyAsInt("Ice.CollectObjects") > 0;
+        auto compositeSliceLoader = make_shared<CompositeSliceLoader>();
+        compositeSliceLoader->add(_applicationSliceLoader);
+        compositeSliceLoader->add(DefaultSliceLoader::instance());
+        _initData.sliceLoader = std::move(compositeSliceLoader);
 
-        string toStringModeStr = _initData.properties->getPropertyWithDefault("Ice.ToStringMode", "Unicode");
-        if(toStringModeStr == "ASCII")
+        string toStringModeStr = _initData.properties->getIceProperty("Ice.ToStringMode");
+        if (toStringModeStr == "ASCII")
         {
-            const_cast<ToStringMode&>(_toStringMode) = ICE_ENUM(ToStringMode, ASCII);
+            const_cast<ToStringMode&>(_toStringMode) = ToStringMode::ASCII;
         }
-        else if(toStringModeStr == "Compat")
+        else if (toStringModeStr == "Compat")
         {
-            const_cast<ToStringMode&>(_toStringMode) = ICE_ENUM(ToStringMode, Compat);
+            const_cast<ToStringMode&>(_toStringMode) = ToStringMode::Compat;
         }
-        else if(toStringModeStr != "Unicode")
+        else if (toStringModeStr != "Unicode")
         {
-            throw InitializationException(__FILE__, __LINE__, "The value for Ice.ToStringMode must be Unicode, ASCII or Compat");
+            throw InitializationException(
+                __FILE__,
+                __LINE__,
+                "The value for Ice.ToStringMode must be Unicode, ASCII or Compat");
         }
 
-        const_cast<bool&>(_acceptClassCycles) = _initData.properties->getPropertyAsInt("Ice.AcceptClassCycles") > 0;
-
-        const_cast<ImplicitContextIPtr&>(_implicitContext) =
-            ImplicitContextI::create(_initData.properties->getProperty("Ice.ImplicitContext"));
+        const_cast<bool&>(_acceptClassCycles) = _initData.properties->getIcePropertyAsInt("Ice.AcceptClassCycles") > 0;
 
-        _routerManager = new RouterManager;
-
-        _locatorManager = new LocatorManager(_initData.properties);
+        string implicitContextKind = _initData.properties->getIceProperty("Ice.ImplicitContext");
+        if (implicitContextKind == "Shared")
+        {
+            _implicitContextKind = ImplicitContextKind::Shared;
+            _sharedImplicitContext = std::make_shared<ImplicitContext>();
+        }
+        else if (implicitContextKind == "PerThread")
+        {
+            _implicitContextKind = ImplicitContextKind::PerThread;
+        }
+        else if (implicitContextKind == "None")
+        {
+            _implicitContextKind = ImplicitContextKind::None;
+        }
+        else
+        {
+            throw Ice::InitializationException(
+                __FILE__,
+                __LINE__,
+                "'" + implicitContextKind + "' is not a valid value for Ice.ImplicitContext");
+        }
 
-        _referenceFactory = new ReferenceFactory(this, communicator);
+        _routerManager = make_shared<RouterManager>();
 
-        _requestHandlerFactory = new RequestHandlerFactory(this);
+        _locatorManager = make_shared<LocatorManager>(_initData.properties);
 
-        _proxyFactory = new ProxyFactory(this);
+        _referenceFactory = make_shared<ReferenceFactory>(shared_from_this(), communicator);
 
         const bool isIPv6Supported = IceInternal::isIPv6Supported();
-        const bool ipv4 = _initData.properties->getPropertyAsIntWithDefault("Ice.IPv4", 1) > 0;
-        const bool ipv6 = _initData.properties->getPropertyAsIntWithDefault("Ice.IPv6", isIPv6Supported ? 1 : 0) > 0;
-        if(!ipv4 && !ipv6)
+        const bool ipv4 = _initData.properties->getIcePropertyAsInt("Ice.IPv4") > 0;
+        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.");
         }
-        else if(ipv4 && ipv6)
+        else if (ipv4 && ipv6)
         {
             _protocolSupport = EnableBoth;
         }
-        else if(ipv4)
+        else if (ipv4)
         {
             _protocolSupport = EnableIPv4;
         }
@@ -1262,77 +1232,149 @@ IceInternal::Instance::Instance(const CommunicatorPtr& communicator, const Initi
         {
             _protocolSupport = EnableIPv6;
         }
-        _preferIPv6 = _initData.properties->getPropertyAsInt("Ice.PreferIPv6Address") > 0;
+        _preferIPv6 = _initData.properties->getIcePropertyAsInt("Ice.PreferIPv6Address") > 0;
 
         _networkProxy = IceInternal::createNetworkProxy(_initData.properties, _protocolSupport);
 
-        _endpointFactoryManager = new EndpointFactoryManager(this);
+        _endpointFactoryManager = make_shared<EndpointFactoryManager>(shared_from_this());
+
+        _pluginManager = make_shared<PluginManagerI>(communicator);
+
+        _outgoingConnectionFactory = make_shared<OutgoingConnectionFactory>(communicator, shared_from_this());
 
-        _dynamicLibraryList = new DynamicLibraryList;
+        _objectAdapterFactory = make_shared<ObjectAdapterFactory>(shared_from_this(), communicator);
 
-        _pluginManager = ICE_MAKE_SHARED(PluginManagerI, communicator, _dynamicLibraryList);
+        _retryQueue = make_shared<RetryQueue>(shared_from_this());
 
-        if(!_initData.valueFactoryManager)
+        StringSeq retryValues = _initData.properties->getIcePropertyAsList("Ice.RetryIntervals");
+        if (retryValues.size() == 0)
         {
-            _initData.valueFactoryManager = ICE_MAKE_SHARED(ValueFactoryManagerI);
+            _retryIntervals.push_back(0);
         }
+        else
+        {
+            for (const auto& retryValue : retryValues)
+            {
+                istringstream value(retryValue);
 
-        _objectFactoryMapHint = _objectFactoryMap.end();
-
-        _outgoingConnectionFactory = new OutgoingConnectionFactory(communicator, this);
+                int v;
+                if (!(value >> v) || !value.eof())
+                {
+                    v = 0;
+                }
 
-        _objectAdapterFactory = ICE_MAKE_SHARED(ObjectAdapterFactory, this, communicator);
+                //
+                // If -1 is the first value, no retry and wait intervals.
+                //
+                if (v == -1 && _retryIntervals.empty())
+                {
+                    break;
+                }
 
-        _retryQueue = new RetryQueue(this);
+                _retryIntervals.push_back(v > 0 ? v : 0);
+            }
+        }
 
-        __setNoDelete(false);
+#if defined(_WIN32)
+        _sslEngine = make_shared<Ice::SSL::Schannel::SSLEngine>(shared_from_this());
+#elif defined(__APPLE__)
+        _sslEngine = make_shared<Ice::SSL::SecureTransport::SSLEngine>(shared_from_this());
+#else
+        _sslEngine = make_shared<Ice::SSL::OpenSSL::SSLEngine>(shared_from_this());
+#endif
+        _sslEngine->initialize();
     }
-    catch(...)
+    catch (...)
     {
         {
-            IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
+            lock_guard lock(staticMutex);
             instanceList->remove(this);
         }
         destroy();
-        __setNoDelete(false);
         throw;
     }
 }
 
+const Ice::ImplicitContextPtr&
+IceInternal::Instance::getImplicitContext() const
+{
+    switch (_implicitContextKind)
+    {
+        case ImplicitContextKind::PerThread:
+        {
+            static thread_local std::map<const IceInternal::Instance*, ImplicitContextPtr> perThreadImplicitContextMap;
+            auto it = perThreadImplicitContextMap.find(this);
+            if (it == perThreadImplicitContextMap.end())
+            {
+                auto r = perThreadImplicitContextMap.emplace(this, std::make_shared<ImplicitContext>());
+                return r.first->second;
+            }
+            else
+            {
+                return it->second;
+            }
+        }
+        case ImplicitContextKind::Shared:
+        {
+            assert(_sharedImplicitContext);
+            return _sharedImplicitContext;
+        }
+        default:
+        {
+            assert(_sharedImplicitContext == nullptr);
+            assert(_implicitContextKind == ImplicitContextKind::None);
+            return _sharedImplicitContext;
+        }
+    }
+}
+
 IceInternal::Instance::~Instance()
 {
     assert(_state == StateDestroyed);
     assert(!_referenceFactory);
-    assert(!_proxyFactory);
     assert(!_outgoingConnectionFactory);
 
     assert(!_objectAdapterFactory);
     assert(!_clientThreadPool);
     assert(!_serverThreadPool);
     assert(!_endpointHostResolver);
+    assert(!_endpointHostResolverThread.joinable());
     assert(!_retryQueue);
     assert(!_timer);
     assert(!_routerManager);
     assert(!_locatorManager);
     assert(!_endpointFactoryManager);
-    assert(!_dynamicLibraryList);
     assert(!_pluginManager);
 
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
-    if(instanceList != 0)
+    // Join all the destroy threads.
+    for (auto& thread : _destroyThreads)
+    {
+        if (thread.get_id() == std::this_thread::get_id()) // completed may release the last ref-count
+        {
+            // Detach to avoid a deadlock.
+            thread.detach();
+        }
+        else
+        {
+            thread.join();
+        }
+    }
+
+    lock_guard lock(staticMutex);
+    if (instanceList != nullptr)
     {
         instanceList->remove(this);
     }
-    if(instanceCount() == 0)
+    if (instanceCount() == 0)
     {
 #if defined(_WIN32)
         WSACleanup();
 #endif
 
 #ifndef _WIN32
-        sigaction(SIGPIPE, &oldAction, 0);
+        sigaction(SIGPIPE, &oldAction, nullptr);
 
-        if(!identForOpenlog.empty())
+        if (!identForOpenlog.empty())
         {
             closelog();
             identForOpenlog.clear();
@@ -1342,19 +1384,27 @@ IceInternal::Instance::~Instance()
 }
 
 void
-IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::CommunicatorPtr& communicator)
+IceInternal::Instance::finishSetup(const Ice::CommunicatorPtr& communicator)
 {
-    //
     // Load plug-ins.
-    //
     assert(!_serverThreadPool);
-    PluginManagerI* pluginManagerImpl = dynamic_cast<PluginManagerI*>(_pluginManager.get());
+    auto pluginManagerImpl = dynamic_pointer_cast<PluginManagerI>(_pluginManager);
     assert(pluginManagerImpl);
-    pluginManagerImpl->loadPlugins(argc, argv);
+
+    addDefaultPluginFactories(_initData.pluginFactories);
+    bool libraryLoaded = pluginManagerImpl->loadPlugins();
+
+    // On Windows, if we loaded any plugin and stack trace collection is enabled, we need to call
+    // ice_enableStackTraceCollection() again to refresh the module list. This refresh is fairly slow so we make it only
+    // when necessary. Extra calls to ice_enableStackTraceCollection() are no-op on other platforms.
+    if (libraryLoaded)
+    {
+        checkPrintStackTraces(_initData);
+    }
 
     //
     // Initialize the endpoint factories once all the plugins are loaded. This gives
-    // the opportunity for the endpoint factories to find underyling factories.
+    // the opportunity for the endpoint factories to find underlying factories.
     //
     _endpointFactoryManager->initialize();
 
@@ -1371,37 +1421,37 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
     // since one of these plugins can be a Logger plugin that sets a new logger during loading
     //
 
-    if(_initData.properties->getProperty("Ice.Admin.Enabled") == "")
+    if (_initData.properties->getIceProperty("Ice.Admin.Enabled") == "")
     {
-        _adminEnabled = _initData.properties->getProperty("Ice.Admin.Endpoints") != "";
+        _adminEnabled = _initData.properties->getIceProperty("Ice.Admin.Endpoints") != "";
     }
     else
     {
-        _adminEnabled = _initData.properties->getPropertyAsInt("Ice.Admin.Enabled") > 0;
+        _adminEnabled = _initData.properties->getIcePropertyAsInt("Ice.Admin.Enabled") > 0;
     }
 
-    StringSeq facetSeq = _initData.properties->getPropertyAsList("Ice.Admin.Facets");
-    if(!facetSeq.empty())
+    StringSeq facetSeq = _initData.properties->getIcePropertyAsList("Ice.Admin.Facets");
+    if (!facetSeq.empty())
     {
         _adminFacetFilter.insert(facetSeq.begin(), facetSeq.end());
     }
 
-    if(_adminEnabled)
+    if (_adminEnabled)
     {
         //
         // Process facet
         //
         const string processFacetName = "Process";
-        if(_adminFacetFilter.empty() || _adminFacetFilter.find(processFacetName) != _adminFacetFilter.end())
+        if (_adminFacetFilter.empty() || _adminFacetFilter.find(processFacetName) != _adminFacetFilter.end())
         {
-            _adminFacets.insert(make_pair(processFacetName, ICE_MAKE_SHARED(ProcessI, communicator)));
+            _adminFacets.insert(make_pair(processFacetName, make_shared<ProcessI>(communicator)));
         }
 
         //
         // Logger facet
         //
         const string loggerFacetName = "Logger";
-        if(_adminFacetFilter.empty() || _adminFacetFilter.find(loggerFacetName) != _adminFacetFilter.end())
+        if (_adminFacetFilter.empty() || _adminFacetFilter.find(loggerFacetName) != _adminFacetFilter.end())
         {
             LoggerAdminLoggerPtr logger = createLoggerAdminLogger(_initData.properties, _initData.logger);
             setLogger(logger);
@@ -1412,10 +1462,10 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
         // Properties facet
         //
         const string propertiesFacetName = "Properties";
-        PropertiesAdminIPtr propsAdmin;
-        if(_adminFacetFilter.empty() || _adminFacetFilter.find(propertiesFacetName) != _adminFacetFilter.end())
+        NativePropertiesAdminPtr propsAdmin;
+        if (_adminFacetFilter.empty() || _adminFacetFilter.find(propertiesFacetName) != _adminFacetFilter.end())
         {
-            propsAdmin = ICE_MAKE_SHARED(PropertiesAdminI, this);
+            propsAdmin = make_shared<NativePropertiesAdmin>(_initData.properties, _initData.logger);
             _adminFacets.insert(make_pair(propertiesFacetName, propsAdmin));
         }
 
@@ -1423,24 +1473,20 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
         // Metrics facet
         //
         const string metricsFacetName = "Metrics";
-        if(_adminFacetFilter.empty() || _adminFacetFilter.find(metricsFacetName) != _adminFacetFilter.end())
+        if (_adminFacetFilter.empty() || _adminFacetFilter.find(metricsFacetName) != _adminFacetFilter.end())
         {
-            CommunicatorObserverIPtr observer = ICE_MAKE_SHARED(CommunicatorObserverI, _initData);
+            CommunicatorObserverIPtr observer = make_shared<CommunicatorObserverI>(_initData);
             _initData.observer = observer;
             _adminFacets.insert(make_pair(metricsFacetName, observer->getFacet()));
 
             //
             // Make sure the metrics admin facet receives property updates.
             //
-            if(propsAdmin)
+            if (propsAdmin)
             {
-#ifdef ICE_CPP11_MAPPING
                 auto metricsAdmin = observer->getFacet();
-                propsAdmin->addUpdateCallback(
-                    [metricsAdmin](const PropertyDict& changes) { metricsAdmin->updated(changes); });
-#else
-                propsAdmin->addUpdateCallback(observer->getFacet());
-#endif
+                propsAdmin->addUpdateCallback([metricsAdmin](const PropertyDict& changes)
+                                              { metricsAdmin->updated(changes); });
             }
         }
     }
@@ -1448,9 +1494,9 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
     //
     // Set observer updater
     //
-    if(_initData.observer)
+    if (_initData.observer)
     {
-        _initData.observer->setObserverUpdater(ICE_MAKE_SHARED(ObserverUpdaterI, this));
+        _initData.observer->setObserverUpdater(make_shared<ObserverUpdaterI>(shared_from_this()));
     }
 
     //
@@ -1458,18 +1504,9 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
     //
     try
     {
-        bool hasPriority = _initData.properties->getProperty("Ice.ThreadPriority") != "";
-        int priority = _initData.properties->getPropertyAsInt("Ice.ThreadPriority");
-        if(hasPriority)
-        {
-            _timer = new Timer(priority);
-        }
-        else
-        {
-            _timer = new Timer;
-        }
+        _timer = make_shared<ThreadObserverTimer>();
     }
-    catch(const IceUtil::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         Error out(_initData.logger);
         out << "cannot create thread for timer:\n" << ex;
@@ -1478,44 +1515,35 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
 
     try
     {
-        _endpointHostResolver = new EndpointHostResolver(this);
-        bool hasPriority = _initData.properties->getProperty("Ice.ThreadPriority") != "";
-        int priority = _initData.properties->getPropertyAsInt("Ice.ThreadPriority");
-        if(hasPriority)
-        {
-            _endpointHostResolver->start(0, priority);
-        }
-        else
-        {
-            _endpointHostResolver->start();
-        }
+        _endpointHostResolver = make_shared<EndpointHostResolver>(shared_from_this());
+        _endpointHostResolverThread = std::thread([this] { _endpointHostResolver->run(); });
     }
-    catch(const IceUtil::Exception& ex)
+    catch (const Ice::Exception& ex)
     {
         Error out(_initData.logger);
         out << "cannot create thread for endpoint host resolver:\n" << ex;
         throw;
     }
 
-    _clientThreadPool = new ThreadPool(this, "Ice.ThreadPool.Client", 0);
+    _clientThreadPool = ThreadPool::create(shared_from_this(), "Ice.ThreadPool.Client", 0);
 
     //
     // The default router/locator may have been set during the loading of plugins.
     // Therefore we make sure it is not already set before checking the property.
     //
-    if(!_referenceFactory->getDefaultRouter())
+    if (!_referenceFactory->getDefaultRouter())
     {
-        RouterPrxPtr router = ICE_UNCHECKED_CAST(RouterPrx, _proxyFactory->propertyToProxy("Ice.Default.Router"));
-        if(router)
+        auto router = communicator->propertyToProxy<RouterPrx>("Ice.Default.Router");
+        if (router)
         {
             _referenceFactory = _referenceFactory->setDefaultRouter(router);
         }
     }
 
-    if(!_referenceFactory->getDefaultLocator())
+    if (!_referenceFactory->getDefaultLocator())
     {
-        LocatorPrxPtr locator = ICE_UNCHECKED_CAST(LocatorPrx, _proxyFactory->propertyToProxy("Ice.Default.Locator"));
-        if(locator)
+        auto locator = communicator->propertyToProxy<LocatorPrx>("Ice.Default.Locator");
+        if (locator)
         {
             _referenceFactory = _referenceFactory->setDefaultLocator(locator);
         }
@@ -1525,12 +1553,12 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
     // Show process id if requested (but only once).
     //
     bool printProcessId = false;
-    if(!printProcessIdDone && _initData.properties->getPropertyAsInt("Ice.PrintProcessId") > 0)
+    if (!printProcessIdDone && _initData.properties->getIcePropertyAsInt("Ice.PrintProcessId") > 0)
     {
         //
         // Safe double-check locking (no dependent variable!)
         //
-        IceUtilInternal::MutexPtrLock<IceUtil::Mutex> sync(staticMutex);
+        lock_guard lock(staticMutex);
         printProcessId = !printProcessIdDone;
 
         //
@@ -1539,7 +1567,7 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
         printProcessIdDone = true;
     }
 
-    if(printProcessId)
+    if (printProcessId)
     {
 #ifdef _MSC_VER
         consoleOut << GetCurrentProcessId() << endl;
@@ -1557,7 +1585,7 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
     // initialization until after it has interacted directly with the
     // plug-ins.
     //
-    if(_initData.properties->getPropertyAsIntWithDefault("Ice.InitPlugins", 1) > 0)
+    if (_initData.properties->getIcePropertyAsInt("Ice.InitPlugins") > 0)
     {
         pluginManagerImpl->initializePlugins();
     }
@@ -1568,32 +1596,29 @@ IceInternal::Instance::finishSetup(int& argc, const char* argv[], const Ice::Com
     // remote clients to invoke Admin facets as soon as it's registered).
     //
     // Note: getAdmin here can return 0 and do nothing in the event the
-    // application set Ice.Admin.Enabled but did not set Ice.Admin.Enpoints
+    // application set Ice.Admin.Enabled but did not set Ice.Admin.Endpoints
     // and one or more of the properties required to create the Admin object.
     //
-    if(_adminEnabled && _initData.properties->getPropertyAsIntWithDefault("Ice.Admin.DelayCreation", 0) <= 0)
+    if (_adminEnabled && _initData.properties->getIcePropertyAsInt("Ice.Admin.DelayCreation") <= 0)
     {
         getAdmin();
     }
 }
 
 void
-IceInternal::Instance::destroy()
+IceInternal::Instance::destroy() noexcept
 {
     {
-        Lock sync(*this);
+        unique_lock lock(_mutex);
 
         //
         // If destroy is in progress, wait for it to be done. This is
         // necessary in case destroy() is called concurrently by
         // multiple threads.
         //
-        while(_state == StateDestroyInProgress)
-        {
-            wait();
-        }
+        _conditionVariable.wait(lock, [this] { return _state != StateDestroyInProgress; });
 
-        if(_state == StateDestroyed)
+        if (_state == StateDestroyed)
         {
             return;
         }
@@ -1604,48 +1629,60 @@ IceInternal::Instance::destroy()
     // Shutdown and destroy all the incoming and outgoing Ice
     // connections and wait for the connections to be finished.
     //
-    if(_objectAdapterFactory)
+    if (_objectAdapterFactory)
     {
         _objectAdapterFactory->shutdown();
     }
 
-    if(_outgoingConnectionFactory)
+    if (_outgoingConnectionFactory)
     {
         _outgoingConnectionFactory->destroy();
     }
 
-    if(_objectAdapterFactory)
+    if (_objectAdapterFactory)
     {
         _objectAdapterFactory->destroy();
     }
 
-    if(_outgoingConnectionFactory)
+    if (_outgoingConnectionFactory)
     {
         _outgoingConnectionFactory->waitUntilFinished();
     }
 
-    if(_retryQueue)
+    if (_retryQueue)
     {
         _retryQueue->destroy(); // Must be called before destroying thread pools.
     }
 
-    if(_initData.observer)
+    if (_initData.observer)
     {
-        CommunicatorObserverIPtr observer = ICE_DYNAMIC_CAST(CommunicatorObserverI, _initData.observer);
-        if(observer)
+        CommunicatorObserverIPtr observer = dynamic_pointer_cast<CommunicatorObserverI>(_initData.observer);
+        if (observer)
         {
             observer->destroy(); // Break cyclic reference counts. Don't clear _observer, it's immutable.
         }
-        _initData.observer->setObserverUpdater(0); // Break cyclic reference count.
+        _initData.observer->setObserverUpdater(nullptr); // Break cyclic reference count.
     }
 
-    LoggerAdminLoggerPtr logger = ICE_DYNAMIC_CAST(LoggerAdminLogger, _initData.logger);
-    if(logger)
+#if defined(ICE_USE_SCHANNEL)
+    if (_initData.clientAuthenticationOptions && _initData.clientAuthenticationOptions->trustedRootCertificates)
+    {
+        CertCloseStore(_initData.clientAuthenticationOptions->trustedRootCertificates, 0);
+        const_cast<Ice::InitializationData&>(_initData).clientAuthenticationOptions = nullopt;
+    }
+#elif defined(ICE_USE_SECURE_TRANSPORT)
+    if (_initData.clientAuthenticationOptions && _initData.clientAuthenticationOptions->trustedRootCertificates)
+    {
+        CFRelease(_initData.clientAuthenticationOptions->trustedRootCertificates);
+        const_cast<Ice::InitializationData&>(_initData).clientAuthenticationOptions = nullopt;
+    }
+#endif
+
+    LoggerAdminLoggerPtr logger = dynamic_pointer_cast<LoggerAdminLogger>(_initData.logger);
+    if (logger)
     {
-        //
         // This only disables the remote logging; we don't set or reset _initData.logger
-        //
-        logger->destroy();
+        logger->detach();
     }
 
     //
@@ -1653,19 +1690,19 @@ IceInternal::Instance::destroy()
     // all the connections are finished (the connections destruction
     // can require invoking callbacks with the thread pools).
     //
-    if(_serverThreadPool)
+    if (_serverThreadPool)
     {
         _serverThreadPool->destroy();
     }
-    if(_clientThreadPool)
+    if (_clientThreadPool)
     {
         _clientThreadPool->destroy();
     }
-    if(_endpointHostResolver)
+    if (_endpointHostResolver)
     {
         _endpointHostResolver->destroy();
     }
-    if(_timer)
+    if (_timer)
     {
         _timer->destroy();
     }
@@ -1673,55 +1710,39 @@ IceInternal::Instance::destroy()
     //
     // Wait for all the threads to be finished.
     //
-    if(_clientThreadPool)
+    if (_clientThreadPool)
     {
         _clientThreadPool->joinWithAllThreads();
     }
-    if(_serverThreadPool)
+    if (_serverThreadPool)
     {
         _serverThreadPool->joinWithAllThreads();
     }
-    if(_endpointHostResolver)
-    {
-        _endpointHostResolver->getThreadControl().join();
-    }
-
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& p : _objectFactoryMap)
+    if (_endpointHostResolverThread.joinable())
     {
-        p.second->destroy();
+        _endpointHostResolverThread.join();
     }
-#else
-    for_each(_objectFactoryMap.begin(), _objectFactoryMap.end(),
-        Ice::secondVoidMemFun<const string, ObjectFactory>(&ObjectFactory::destroy));
-#endif
-    _objectFactoryMap.clear();
 
-    if(_routerManager)
+    if (_routerManager)
     {
         _routerManager->destroy();
     }
 
-    if(_locatorManager)
+    if (_locatorManager)
     {
         _locatorManager->destroy();
     }
 
-    if(_endpointFactoryManager)
-    {
-        _endpointFactoryManager->destroy();
-    }
-
-    if(_initData.properties->getPropertyAsInt("Ice.Warn.UnusedProperties") > 0)
+    if (_initData.properties->getIcePropertyAsInt("Ice.Warn.UnusedProperties") > 0)
     {
-        set<string> unusedProperties = static_cast<PropertiesI*>(_initData.properties.get())->getUnusedProperties();
-        if(unusedProperties.size() != 0)
+        set<string> unusedProperties = _initData.properties.get()->getUnusedProperties();
+        if (unusedProperties.size() != 0)
         {
             Warning out(_initData.logger);
             out << "The following properties were set but never read:";
-            for(set<string>::const_iterator p = unusedProperties.begin(); p != unusedProperties.end(); ++p)
+            for (const auto& unusedProp : unusedProperties)
             {
-                out << "\n    " << *p;
+                out << "\n    " << unusedProp;
             }
         }
     }
@@ -1729,37 +1750,67 @@ IceInternal::Instance::destroy()
     //
     // Destroy last so that a Logger plugin can receive all log/traces before its destruction.
     //
-    if(_pluginManager)
+    if (_pluginManager)
     {
         _pluginManager->destroy();
     }
 
     {
-        Lock sync(*this);
+        lock_guard lock(_mutex);
 
-        _objectAdapterFactory = 0;
-        _outgoingConnectionFactory = 0;
-        _retryQueue = 0;
+        _objectAdapterFactory = nullptr;
+        _outgoingConnectionFactory = nullptr;
+        _retryQueue = nullptr;
 
-        _serverThreadPool = 0;
-        _clientThreadPool = 0;
-        _endpointHostResolver = 0;
-        _timer = 0;
+        _serverThreadPool = nullptr;
+        _clientThreadPool = nullptr;
+        _endpointHostResolver = nullptr;
+        _timer = nullptr;
 
-        _referenceFactory = 0;
-        _requestHandlerFactory = 0;
-        _proxyFactory = 0;
-        _routerManager = 0;
-        _locatorManager = 0;
-        _endpointFactoryManager = 0;
-        _pluginManager = 0;
-        _dynamicLibraryList = 0;
+        _referenceFactory = nullptr;
+        _routerManager = nullptr;
+        _locatorManager = nullptr;
+        _endpointFactoryManager = nullptr;
+        _pluginManager = nullptr;
 
-        _adminAdapter = 0;
+        _adminAdapter = nullptr;
         _adminFacets.clear();
 
+        _sslEngine = nullptr;
+
         _state = StateDestroyed;
-        notifyAll();
+        _conditionVariable.notify_all();
+    }
+}
+
+void
+IceInternal::Instance::destroyAsync(function<void()> completed) noexcept
+{
+    assert(completed); // the caller (Communicator) makes sure completed is callable.
+
+    bool executeCallback = false;
+    {
+        lock_guard lock(_mutex);
+        if (_state == StateDestroyed)
+        {
+            executeCallback = true; // execute outside the lock
+        }
+        else
+        {
+            // Start a thread that calls destroy() and then executes the callback.
+            // We join these threads in the destructor. It's important to capture this and not shared_from_this() here.
+            _destroyThreads.emplace_back(
+                [this, completed = std::move(completed)]()
+                {
+                    this->destroy();
+                    completed();
+                });
+        }
+    }
+
+    if (executeCallback)
+    {
+        completed();
     }
 }
 
@@ -1773,7 +1824,7 @@ IceInternal::Instance::updateConnectionObservers()
         assert(_objectAdapterFactory);
         _objectAdapterFactory->updateObservers(&ObjectAdapterI::updateConnectionObservers);
     }
-    catch(const Ice::CommunicatorDestroyedException&)
+    catch (const Ice::CommunicatorDestroyedException&)
     {
     }
 }
@@ -1783,44 +1834,44 @@ IceInternal::Instance::updateThreadObservers()
 {
     try
     {
-        if(_clientThreadPool)
+        if (_clientThreadPool)
         {
             _clientThreadPool->updateObservers();
         }
-        if(_serverThreadPool)
+        if (_serverThreadPool)
         {
             _serverThreadPool->updateObservers();
         }
         assert(_objectAdapterFactory);
         _objectAdapterFactory->updateObservers(&ObjectAdapterI::updateThreadObservers);
-        if(_endpointHostResolver)
+        if (_endpointHostResolver)
         {
             _endpointHostResolver->updateObserver();
         }
-        if(_timer)
+        if (_timer)
         {
             _timer->updateObserver(_initData.observer);
         }
     }
-    catch(const Ice::CommunicatorDestroyedException&)
+    catch (const Ice::CommunicatorDestroyedException&)
     {
     }
 }
 
 BufSizeWarnInfo
-IceInternal::Instance::getBufSizeWarn(Short type)
+IceInternal::Instance::getBufSizeWarn(int16_t type)
 {
-    IceUtil::Mutex::Lock lock(_setBufSizeWarnMutex);
+    lock_guard lock(_setBufSizeWarnMutex);
 
     return getBufSizeWarnInternal(type);
 }
 
 BufSizeWarnInfo
-IceInternal::Instance::getBufSizeWarnInternal(Short type)
+IceInternal::Instance::getBufSizeWarnInternal(int16_t type)
 {
     BufSizeWarnInfo info;
-    map<Short, BufSizeWarnInfo>::iterator p = _setBufSizeWarn.find(type);
-    if(p == _setBufSizeWarn.end())
+    auto p = _setBufSizeWarn.find(type);
+    if (p == _setBufSizeWarn.end())
     {
         info.sndWarn = false;
         info.sndSize = -1;
@@ -1835,108 +1886,50 @@ IceInternal::Instance::getBufSizeWarnInternal(Short type)
     return info;
 }
 
+ConnectionOptions
+IceInternal::Instance::readConnectionOptions(const string& propertyPrefix) const
+{
+    const PropertiesPtr& properties = _initData.properties;
+    ConnectionOptions connectionOptions;
+
+    connectionOptions.connectTimeout =
+        chrono::seconds(properties->getIcePropertyAsInt(propertyPrefix + ".ConnectTimeout"));
+
+    connectionOptions.closeTimeout = chrono::seconds(properties->getIcePropertyAsInt(propertyPrefix + ".CloseTimeout"));
+    connectionOptions.idleTimeout = chrono::seconds(properties->getIcePropertyAsInt(propertyPrefix + ".IdleTimeout"));
+    connectionOptions.enableIdleCheck = properties->getIcePropertyAsInt(propertyPrefix + ".EnableIdleCheck") > 0;
+
+    connectionOptions.inactivityTimeout =
+        chrono::seconds(properties->getIcePropertyAsInt(propertyPrefix + ".InactivityTimeout"));
+
+    connectionOptions.maxDispatches = properties->getIcePropertyAsInt(propertyPrefix + ".MaxDispatches");
+
+    return connectionOptions;
+}
+
 void
-IceInternal::Instance::setSndBufSizeWarn(Short type, int size)
+IceInternal::Instance::setSndBufSizeWarn(int16_t type, int size)
 {
-    IceUtil::Mutex::Lock lock(_setBufSizeWarnMutex);
+    lock_guard lock(_setBufSizeWarnMutex);
 
     BufSizeWarnInfo info = getBufSizeWarnInternal(type);
     info.sndWarn = true;
     info.sndSize = size;
-    _setBufSizeWarn[type] =  info;
+    _setBufSizeWarn[type] = info;
 }
 
 void
-IceInternal::Instance::setRcvBufSizeWarn(Short type, int size)
+IceInternal::Instance::setRcvBufSizeWarn(int16_t type, int size)
 {
-    IceUtil::Mutex::Lock lock(_setBufSizeWarnMutex);
+    lock_guard lock(_setBufSizeWarnMutex);
 
     BufSizeWarnInfo info = getBufSizeWarnInternal(type);
     info.rcvWarn = true;
     info.rcvSize = size;
-    _setBufSizeWarn[type] =  info;
-}
-
-void
-IceInternal::Instance::addObjectFactory(const Ice::ObjectFactoryPtr& factory, const string& id)
-{
-    Lock sync(*this);
-
-    //
-    // Create a ValueFactory wrapper around the given ObjectFactory and register the wrapper
-    // with the value factory manager. This may raise AlreadyRegisteredException.
-    //
-#ifdef ICE_CPP11_MAPPING
-    _initData.valueFactoryManager->add([factory](const string& ident)
-                                       {
-                                           return factory->create(ident);
-                                       },
-                                       id);
-#else
-    class ValueFactoryWrapper: public Ice::ValueFactory
-    {
-    public:
-
-        ValueFactoryWrapper(const Ice::ObjectFactoryPtr& factory) :  _objectFactory(factory)
-        {
-        }
-
-        Ice::ValuePtr create(const std::string& id)
-        {
-            return _objectFactory->create(id);
-        }
-
-    private:
-
-        Ice::ObjectFactoryPtr _objectFactory;
-    };
-
-    _initData.valueFactoryManager->add(new ValueFactoryWrapper(factory), id);
-#endif
-
-    //
-    // Also record the object factory in our own map.
-    //
-    _objectFactoryMapHint = _objectFactoryMap.insert(_objectFactoryMapHint,
-                                                     pair<const string, Ice::ObjectFactoryPtr>(id, factory));
-}
-
-Ice::ObjectFactoryPtr
-IceInternal::Instance::findObjectFactory(const string& id) const
-{
-    Lock sync(*this);
-
-    ObjectFactoryMap& objectfactoryMap = const_cast<ObjectFactoryMap&>(_objectFactoryMap);
-
-    ObjectFactoryMap::iterator p = objectfactoryMap.end();
-    if(_objectFactoryMapHint != objectfactoryMap.end())
-    {
-        if(_objectFactoryMapHint->first == id)
-        {
-            p = _objectFactoryMapHint;
-        }
-    }
-
-    if(p == objectfactoryMap.end())
-    {
-        p = objectfactoryMap.find(id);
-    }
-
-    if(p != objectfactoryMap.end())
-    {
-        _objectFactoryMapHint = p;
-        return p->second;
-    }
-    else
-    {
-        return ICE_NULLPTR;
-    }
+    _setBufSizeWarn[type] = info;
 }
 
-IceInternal::ProcessI::ProcessI(const CommunicatorPtr& communicator) :
-    _communicator(communicator)
-{
-}
+IceInternal::ProcessI::ProcessI(CommunicatorPtr communicator) : _communicator(std::move(communicator)) {}
 
 void
 IceInternal::ProcessI::shutdown(const Current&)
@@ -1945,13 +1938,9 @@ IceInternal::ProcessI::shutdown(const Current&)
 }
 
 void
-#ifdef ICE_CPP11_MAPPING
-IceInternal::ProcessI::writeMessage(string message, Int fd, const Current&)
-#else
-IceInternal::ProcessI::writeMessage(const string& message, Int fd, const Current&)
-#endif
+IceInternal::ProcessI::writeMessage(string message, int32_t fd, const Current&)
 {
-    switch(fd)
+    switch (fd)
     {
         case 1:
         {