zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,36 +1,32 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/ConnectionFactory.h>
-#include <Ice/ConnectionI.h>
-#include <Ice/Instance.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/TraceLevels.h>
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/Properties.h>
-#include <Ice/Transceiver.h>
-#include <Ice/Connector.h>
-#include <Ice/Acceptor.h>
-#include <Ice/ThreadPool.h>
-#include <Ice/ObjectAdapterI.h> // For getThreadPool().
-#include <Ice/Reference.h>
-#include <Ice/EndpointI.h>
-#include <Ice/RouterInfo.h>
-#include <Ice/LocalException.h>
-#include <Ice/Functional.h>
-#include <Ice/OutgoingAsync.h>
-#include <Ice/CommunicatorI.h>
-#include <IceUtil/Random.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "ConnectionFactory.h"
+#include "Acceptor.h"
+#include "CommunicatorFlushBatchAsync.h"
+#include "ConnectionI.h"
+#include "Connector.h"
+#include "DefaultsAndOverrides.h"
+#include "EndpointI.h"
+#include "Ice/Communicator.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/LoggerUtil.h"
+#include "Ice/Properties.h"
+#include "Instance.h"
+#include "ObjectAdapterI.h"
+#include "RouterInfo.h"
+#include "ThreadPool.h"
+#include "TraceLevels.h"
+#include "Transceiver.h"
+
+#include <algorithm>
+#include <chrono>
 #include <iterator>
 
 #if TARGET_OS_IPHONE != 0
 namespace IceInternal
 {
-
-bool registerForBackgroundNotification(const IceInternal::IncomingConnectionFactoryPtr&);
-void unregisterForBackgroundNotification(const IceInternal::IncomingConnectionFactoryPtr&);
-
+    bool registerForBackgroundNotification(const IceInternal::IncomingConnectionFactoryPtr&);
+    void unregisterForBackgroundNotification(const IceInternal::IncomingConnectionFactoryPtr&);
 }
 #endif
 
@@ -39,201 +35,88 @@ using namespace Ice;
 using namespace Ice::Instrumentation;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(OutgoingConnectionFactory* p) { return p; }
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(IncomingConnectionFactory* p) { return p; }
-#endif
-
 namespace
 {
-
-#ifdef ICE_CPP11_COMPILER
-template <typename Map> void
-remove(Map& m, const typename Map::key_type& k, const typename Map::mapped_type& v)
-{
-    auto pr = m.equal_range(k);
-    assert(pr.first != pr.second);
-    for(auto q = pr.first; q != pr.second; ++q)
-    {
-        if(q->second.get() == v.get())
-        {
-            m.erase(q);
-            return;
-        }
-    }
-    assert(false); // Nothing was removed which is an error.
-}
-
-template<typename Map, typename Predicate> typename Map::mapped_type
-find(const Map& m, const typename Map::key_type& k, Predicate predicate)
-{
-    auto pr = m.equal_range(k);
-    for(auto q = pr.first; q != pr.second; ++q)
-    {
-        if(predicate(q->second))
-        {
-            return q->second;
-        }
-    }
-    return nullptr;
-}
-
-#else
-template <typename K, typename V> void
-remove(multimap<K, V>& m, K k, V v)
-{
-    pair<typename multimap<K, V>::iterator, typename multimap<K, V>::iterator> pr = m.equal_range(k);
-    assert(pr.first != pr.second);
-    for(typename multimap<K, V>::iterator q = pr.first; q != pr.second; ++q)
-    {
-        if(q->second.get() == v.get())
-        {
-            m.erase(q);
-            return;
-        }
-    }
-    assert(false); // Nothing was removed which is an error.
-}
-
-template <typename K, typename V> ::IceInternal::Handle<V>
-find(const multimap<K,::IceInternal::Handle<V> >& m,
-     K k,
-     const ::IceUtilInternal::ConstMemFun<bool, V, ::IceInternal::Handle<V> >& predicate)
-{
-    pair<typename multimap<K, ::IceInternal::Handle<V> >::const_iterator,
-         typename multimap<K, ::IceInternal::Handle<V> >::const_iterator> pr = m.equal_range(k);
-    for(typename multimap<K, ::IceInternal::Handle<V> >::const_iterator q = pr.first; q != pr.second; ++q)
+    template<typename Map> void remove(Map& m, const typename Map::key_type& k, const typename Map::mapped_type& v)
     {
-        if(predicate(q->second))
+        auto pr = m.equal_range(k);
+        assert(pr.first != pr.second);
+        for (auto q = pr.first; q != pr.second; ++q)
         {
-            return q->second;
+            if (q->second.get() == v.get())
+            {
+                m.erase(q);
+                return;
+            }
         }
+        assert(false); // Nothing was removed which is an error.
     }
-    return IceInternal::Handle<V>();
-}
-#endif
 
-class StartAcceptor : public IceUtil::TimerTask
-#ifdef ICE_CPP11_MAPPING
-                    , public std::enable_shared_from_this<StartAcceptor>
-#endif
-{
-public:
-
-    StartAcceptor(const IncomingConnectionFactoryPtr& factory, const InstancePtr& instance) :
-        _factory(factory), _instance(instance)
+    template<typename Map, typename Predicate>
+    typename Map::mapped_type find(const Map& m, const typename Map::key_type& k, Predicate predicate)
     {
-    }
-
-    void
-    runTimerTask()
-    {
-        try
-        {
-            _factory->startAcceptor();
-        }
-        catch(const Ice::Exception& ex)
+        auto pr = m.equal_range(k);
+        for (auto q = pr.first; q != pr.second; ++q)
         {
-            Error out(_instance->initializationData().logger);
-            out << "acceptor creation failed:\n" << ex << '\n' << _factory->toString();
-            _instance->timer()->schedule(ICE_SHARED_FROM_THIS, IceUtil::Time::seconds(1));
+            if (predicate(q->second))
+            {
+                return q->second;
+            }
         }
+        return nullptr;
     }
-
-private:
-
-    IncomingConnectionFactoryPtr _factory;
-    InstancePtr _instance;
-};
-
-#if TARGET_OS_IPHONE != 0
-class FinishCall : public DispatchWorkItem
-{
-public:
-
-    FinishCall(const IncomingConnectionFactoryPtr& factory) : _factory(factory)
-    {
-    }
-
-    virtual void
-    run()
-    {
-        _factory->finish();
-    }
-
-private:
-
-    const IncomingConnectionFactoryPtr _factory;
-};
-#endif
-
 }
 
 bool
 IceInternal::OutgoingConnectionFactory::ConnectorInfo::operator==(const ConnectorInfo& other) const
 {
-    return connector == other.connector;
+    return targetEqualTo(connector, other.connector);
 }
 
 void
 IceInternal::OutgoingConnectionFactory::destroy()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_destroyed)
+    if (_destroyed)
     {
         return;
     }
 
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& p : _connections)
+    for (const auto& [_, connection] : _connections)
     {
-        p.second->destroy(ConnectionI::CommunicatorDestroyed);
+        connection->destroy(ConnectionI::CommunicatorDestroyed);
     }
-#else
-    for_each(_connections.begin(), _connections.end(),
-             bind2nd(Ice::secondVoidMemFun1<const ConnectorPtr, ConnectionI, ConnectionI::DestructionReason>
-                     (&ConnectionI::destroy), ConnectionI::CommunicatorDestroyed));
-#endif
     _destroyed = true;
-    _communicator = 0;
+    _communicator = nullptr;
 
-    notifyAll();
+    _conditionVariable.notify_all();
 }
 
 void
 IceInternal::OutgoingConnectionFactory::updateConnectionObservers()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& p : _connections)
+    lock_guard lock(_mutex);
+    for (const auto& [_, connection] : _connections)
     {
-        p.second->updateObserver();
+        connection->updateObserver();
     }
-#else
-    for_each(_connections.begin(), _connections.end(),
-             Ice::secondVoidMemFun<const ConnectorPtr, ConnectionI>(&ConnectionI::updateObserver));
-#endif
 }
 
 void
 IceInternal::OutgoingConnectionFactory::waitUntilFinished()
 {
-    multimap<ConnectorPtr, ConnectionIPtr> connections;
+    multimap<ConnectorPtr, ConnectionIPtr, Ice::TargetCompare<ConnectorPtr, std::less>> connections;
 
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+        unique_lock lock(_mutex);
 
         //
         // First we wait until the factory is destroyed. We also wait
         // until there are no pending connections anymore. Only then
         // we can be sure the _connections contains all connections.
         //
-        while(!_destroyed || !_pending.empty() || _pendingConnectCount > 0)
-        {
-            wait();
-        }
+        _conditionVariable.wait(lock, [this] { return _destroyed && _pending.empty() && _pendingConnectCount == 0; });
 
         //
         // We want to wait until all connections are finished outside the
@@ -242,45 +125,26 @@ IceInternal::OutgoingConnectionFactory::waitUntilFinished()
         connections = _connections;
     }
 
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& p : _connections)
+    for (const auto& p : connections)
     {
         p.second->waitUntilFinished();
     }
-#else
-    for_each(connections.begin(), connections.end(),
-             Ice::secondVoidMemFun<const ConnectorPtr, ConnectionI>(&ConnectionI::waitUntilFinished));
-#endif
+
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-        // Ensure all the connections are finished and reapable at this point.
-        vector<Ice::ConnectionIPtr> cons;
-        _monitor->swapReapedConnections(cons);
-        assert(cons.size() == _connections.size());
-        cons.clear();
+        lock_guard lock(_mutex);
         _connections.clear();
         _connectionsByEndpoint.clear();
     }
-
-    //
-    // Must be destroyed outside the synchronization since this might block waiting for
-    // a timer task to complete.
-    //
-    _monitor->destroy();
 }
 
 void
-IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpts,
-                                               bool hasMore,
-                                               Ice::EndpointSelectionType selType,
-                                               const CreateConnectionCallbackPtr& callback)
+IceInternal::OutgoingConnectionFactory::createAsync(
+    vector<EndpointIPtr> endpoints,
+    bool hasMore,
+    function<void(Ice::ConnectionIPtr, bool)> response,
+    function<void(std::exception_ptr)> exception)
 {
-    assert(!endpts.empty());
-
-    //
-    // Apply the overrides.
-    //
-    vector<EndpointIPtr> endpoints = applyOverrides(endpts);
+    assert(!endpoints.empty());
 
     //
     // Try to find a connection to one of the given endpoints.
@@ -289,23 +153,25 @@ IceInternal::OutgoingConnectionFactory::create(const vector<EndpointIPtr>& endpt
     {
         bool compress;
         Ice::ConnectionIPtr connection = findConnection(endpoints, compress);
-        if(connection)
+        if (connection)
         {
-            callback->setConnection(connection, compress);
+            response(std::move(connection), compress);
             return;
         }
     }
-    catch(const Ice::LocalException& ex)
+    catch (...)
     {
-        callback->setException(ex);
+        exception(current_exception());
         return;
     }
 
-#ifdef ICE_CPP11_MAPPING
-    auto cb = make_shared<ConnectCallback>(_instance, this, endpoints, hasMore, callback, selType);
-#else
-    ConnectCallbackPtr cb = new ConnectCallback(_instance, this, endpoints, hasMore, callback, selType);
-#endif
+    auto cb = make_shared<ConnectCallback>(
+        _instance,
+        shared_from_this(),
+        std::move(endpoints),
+        hasMore,
+        std::move(response),
+        std::move(exception));
     cb->getConnectors();
 }
 
@@ -316,9 +182,9 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route
     ObjectAdapterPtr adapter = routerInfo->getAdapter();
     vector<EndpointIPtr> endpoints = routerInfo->getClientEndpoints(); // Must be called outside the synchronization
 
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_destroyed)
+    if (_destroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -329,18 +195,8 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route
     // callbacks from the router can be received over such
     // connections.
     //
-    for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
+    for (auto endpoint : endpoints)
     {
-        EndpointIPtr endpoint = *p;
-
-        //
-        // Modify endpoints with overrides.
-        //
-        if(_instance->defaultsAndOverrides()->overrideTimeout)
-        {
-            endpoint = endpoint->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue);
-        }
-
         //
         // The Connection object does not take the compression flag of
         // endpoints into account, but instead gets the information
@@ -348,16 +204,16 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route
         // other sources. In order to allow connection sharing for
         // endpoints that differ in the value of the compression flag
         // only, we always set the compression flag to false here in
-        // this connection factory.
+        // this connection factory. We also clear the timeout as it is
+        // no longer used for Ice 3.8.
         //
-        endpoint = endpoint->compress(false);
+        endpoint = endpoint->compress(false)->timeout(-1);
 
-        for(multimap<ConnectorPtr, ConnectionIPtr>::const_iterator q = _connections.begin();
-            q != _connections.end(); ++q)
+        for (const auto& [_, connection] : _connections)
         {
-            if(q->second->endpoint() == endpoint)
+            if (connection->endpoint() == endpoint)
             {
-                q->second->setAdapter(adapter);
+                connection->setAdapter(adapter);
             }
         }
     }
@@ -366,60 +222,71 @@ IceInternal::OutgoingConnectionFactory::setRouterInfo(const RouterInfoPtr& route
 void
 IceInternal::OutgoingConnectionFactory::removeAdapter(const ObjectAdapterPtr& adapter)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
-    if(_destroyed)
+    if (_destroyed)
     {
         return;
     }
 
-    for(multimap<ConnectorPtr, ConnectionIPtr>::const_iterator p = _connections.begin(); p != _connections.end(); ++p)
+    for (const auto& [_, connection] : _connections)
     {
-        if(p->second->getAdapter() == adapter)
+        if (connection->getAdapter() == adapter)
         {
-            p->second->setAdapter(0);
+            connection->setAdapter(nullptr);
         }
     }
 }
 
 void
-IceInternal::OutgoingConnectionFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync,
-                                                                Ice::CompressBatch compress)
+IceInternal::OutgoingConnectionFactory::flushAsyncBatchRequests(
+    const CommunicatorFlushBatchAsyncPtr& outAsync,
+    Ice::CompressBatch compress)
 {
     list<ConnectionIPtr> c;
 
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-        for(multimap<ConnectorPtr,  ConnectionIPtr>::const_iterator p = _connections.begin(); p != _connections.end();
-            ++p)
+        lock_guard lock(_mutex);
+        for (const auto& [_, connection] : _connections)
         {
-            if(p->second->isActiveOrHolding())
+            if (connection->isActiveOrHolding())
             {
-                c.push_back(p->second);
+                c.push_back(connection);
             }
         }
     }
 
-    for(list<ConnectionIPtr>::const_iterator p = c.begin(); p != c.end(); ++p)
+    for (const auto& p : c)
     {
         try
         {
-            outAsync->flushConnection(*p, compress);
+            outAsync->flushConnection(p, compress);
         }
-        catch(const LocalException&)
+        catch (const LocalException&)
         {
             // Ignore.
         }
     }
 }
 
-IceInternal::OutgoingConnectionFactory::OutgoingConnectionFactory(const CommunicatorPtr& communicator,
-                                                                  const InstancePtr& instance) :
-    _communicator(communicator),
-    _instance(instance),
-    _monitor(new FactoryACMMonitor(instance, instance->clientACM())),
-    _destroyed(false),
-    _pendingConnectCount(0)
+void
+IceInternal::OutgoingConnectionFactory::removeConnection(const ConnectionIPtr& connection) noexcept
+{
+    lock_guard lock(_mutex);
+    if (!_destroyed)
+    {
+        remove(_connections, connection->connector(), connection);
+        remove(_connectionsByEndpoint, connection->endpoint(), connection);
+        remove(_connectionsByEndpoint, connection->endpoint()->compress(true), connection);
+    }
+}
+
+IceInternal::OutgoingConnectionFactory::OutgoingConnectionFactory(
+    CommunicatorPtr communicator,
+    const InstancePtr& instance)
+    : _communicator(std::move(communicator)),
+      _instance(instance),
+      _connectionOptions(instance->clientConnectionOptions())
 {
 }
 
@@ -432,60 +299,54 @@ IceInternal::OutgoingConnectionFactory::~OutgoingConnectionFactory()
     assert(_pendingConnectCount == 0);
 }
 
-vector<EndpointIPtr>
-IceInternal::OutgoingConnectionFactory::applyOverrides(const vector<EndpointIPtr>& endpts)
+ObjectAdapterPtr
+IceInternal::OutgoingConnectionFactory::getDefaultObjectAdapter() const noexcept
 {
-    DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
-    vector<EndpointIPtr> endpoints = endpts;
-    for(vector<EndpointIPtr>::iterator p = endpoints.begin(); p != endpoints.end(); ++p)
-    {
-        //
-        // Modify endpoints with overrides.
-        //
-        if(defaultsAndOverrides->overrideTimeout)
-        {
-            *p = (*p)->timeout(defaultsAndOverrides->overrideTimeoutValue);
-        }
-    }
-    return endpoints;
+    lock_guard lock(_mutex);
+    return _defaultObjectAdapter;
+}
+
+void
+IceInternal::OutgoingConnectionFactory::setDefaultObjectAdapter(
+    ObjectAdapterPtr adapter) noexcept // NOLINT(performance-unnecessary-value-param)
+{
+    lock_guard lock(_mutex);
+    _defaultObjectAdapter = dynamic_pointer_cast<ObjectAdapterI>(adapter);
 }
 
 ConnectionIPtr
 IceInternal::OutgoingConnectionFactory::findConnection(const vector<EndpointIPtr>& endpoints, bool& compress)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_destroyed)
+    lock_guard lock(_mutex);
+    if (_destroyed)
     {
         throw CommunicatorDestroyedException(__FILE__, __LINE__);
     }
 
     DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
     assert(!endpoints.empty());
-    for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
-    {
-#ifdef ICE_CPP11_COMPILER
-        auto connection = find(_connectionsByEndpoint, *p,
-                               [](const ConnectionIPtr& conn)
-                               {
-                                   return conn->isActiveOrHolding();
-                               });
-#else
-        ConnectionIPtr connection = find(_connectionsByEndpoint, *p, Ice::constMemFun(&ConnectionI::isActiveOrHolding));
-#endif
-        if(connection)
+
+    for (const auto& p : endpoints)
+    {
+        auto connection = find(
+            _connectionsByEndpoint,
+            p->timeout(-1), // clear the timeout
+            [](const ConnectionIPtr& conn) { return conn->isActiveOrHolding(); });
+
+        if (connection)
         {
-            if(defaultsAndOverrides->overrideCompress)
+            if (defaultsAndOverrides->overrideCompress.has_value())
             {
-                compress = defaultsAndOverrides->overrideCompressValue;
+                compress = *defaultsAndOverrides->overrideCompress;
             }
             else
             {
-                compress = (*p)->compress();
+                compress = p->compress();
             }
             return connection;
         }
     }
-    return 0;
+    return nullptr;
 }
 
 ConnectionIPtr
@@ -494,37 +355,30 @@ IceInternal::OutgoingConnectionFactory::findConnection(const vector<ConnectorInf
     // This must be called with the mutex locked.
 
     DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
-    for(vector<ConnectorInfo>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+    for (const auto& p : connectors)
     {
-        if(_pending.find(p->connector) != _pending.end())
+        if (_pending.find(p.connector) != _pending.end())
         {
             continue;
         }
 
-#ifdef ICE_CPP11_COMPILER
-        auto connection = find(_connections, p->connector,
-                               [](const ConnectionIPtr& conn)
-                               {
-                                   return conn->isActiveOrHolding();
-                               });
-#else
-        ConnectionIPtr connection = find(_connections, p->connector, Ice::constMemFun(&ConnectionI::isActiveOrHolding));
-#endif
-        if(connection)
+        auto connection =
+            find(_connections, p.connector, [](const ConnectionIPtr& conn) { return conn->isActiveOrHolding(); });
+        if (connection)
         {
-            if(defaultsAndOverrides->overrideCompress)
+            if (defaultsAndOverrides->overrideCompress.has_value())
             {
-                compress = defaultsAndOverrides->overrideCompressValue;
+                compress = *defaultsAndOverrides->overrideCompress;
             }
             else
             {
-                    compress = p->endpoint->compress();
+                compress = p.endpoint->compress();
             }
             return connection;
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 void
@@ -538,8 +392,8 @@ IceInternal::OutgoingConnectionFactory::incPendingConnectCount()
     // the asynchronous requests waiting on a connection to be established.
     //
 
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_destroyed)
+    lock_guard lock(_mutex);
+    if (_destroyed)
     {
         throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
     }
@@ -549,111 +403,58 @@ IceInternal::OutgoingConnectionFactory::incPendingConnectCount()
 void
 IceInternal::OutgoingConnectionFactory::decPendingConnectCount()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
     --_pendingConnectCount;
     assert(_pendingConnectCount >= 0);
-    if(_destroyed && _pendingConnectCount == 0)
+    if (_destroyed && _pendingConnectCount == 0)
     {
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 }
 
 ConnectionIPtr
-IceInternal::OutgoingConnectionFactory::getConnection(const vector<ConnectorInfo>& connectors,
-                                                      const ConnectCallbackPtr& cb,
-                                                      bool& compress)
+IceInternal::OutgoingConnectionFactory::getConnection(
+    const vector<ConnectorInfo>& connectors,
+    const ConnectCallbackPtr& cb,
+    bool& compress)
 {
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-        if(_destroyed)
+        assert(cb);
+        unique_lock lock(_mutex);
+        if (_destroyed)
         {
             throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
         }
 
-        //
-        // Reap closed connections
-        //
-        vector<Ice::ConnectionIPtr> cons;
-        _monitor->swapReapedConnections(cons);
-        for(vector<Ice::ConnectionIPtr>::const_iterator p = cons.begin(); p != cons.end(); ++p)
+        // Search for an existing connections matching one of the given endpoints.
+        Ice::ConnectionIPtr connection = findConnection(connectors, compress);
+        if (connection)
         {
-            remove(_connections, (*p)->connector(), *p);
-            remove(_connectionsByEndpoint, (*p)->endpoint(), *p);
-            remove(_connectionsByEndpoint, (*p)->endpoint()->compress(true), *p);
+            return connection;
         }
 
         //
-        // Try to get the connection. We may need to wait for other threads to
-        // finish if one of them is currently establishing a connection to one
-        // of our connectors.
+        // Determine whether another thread/request is currently attempting to connect to
+        // one of our endpoints; if so we wait until it's done.
         //
-        while(true)
+        if (addToPending(cb, connectors))
         {
-            if(_destroyed)
-            {
-                throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
-            }
-
-            //
-            // Search for a matching connection. If we find one, we're done.
-            //
-            Ice::ConnectionIPtr connection = findConnection(connectors, compress);
-            if(connection)
-            {
-                return connection;
-            }
-
-            //
-            // Determine whether another thread/request is currently attempting to connect to
-            // one of our endpoints; if so we wait until it's done.
-            //
-            if(addToPending(cb, connectors))
-            {
-                //
-                // If a callback is not specified we wait until another thread notifies us about a
-                // change to the pending list. Otherwise, if a callback is provided we're done:
-                // when the pending list changes the callback will be notified and will try to
-                // get the connection again.
-                //
-                if(!cb)
-                {
-                    wait();
-                }
-                else
-                {
-                    return 0;
-                }
-            }
-            else
-            {
-                //
-                // If no thread is currently establishing a connection to one of our connectors,
-                // we get out of this loop and start the connection establishment to one of the
-                // given connectors.
-                //
-                break;
-            }
+            // A connection to one of our endpoints is pending. The callback will be notified once the connection
+            // is established. Returning null indicates that the connection is still pending.
+            return nullptr;
         }
     }
 
-    //
-    // At this point, we're responsible for establishing the connection to one of
-    // the given connectors. If it's a non-blocking connect, calling nextConnector
-    // will start the connection establishment. Otherwise, we return null to get
-    // the caller to establish the connection.
-    //
-    if(cb)
-    {
-        cb->nextConnector();
-    }
-
-    return 0;
+    // No connection is pending. Call nextConnector to initiate connection establishment. Return null to indicate
+    // that the connection is still pending.
+    cb->nextConnector();
+    return nullptr;
 }
 
 ConnectionIPtr
 IceInternal::OutgoingConnectionFactory::createConnection(const TransceiverPtr& transceiver, const ConnectorInfo& ci)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
     assert(_pending.find(ci.connector) != _pending.end() && transceiver);
 
     //
@@ -664,21 +465,36 @@ IceInternal::OutgoingConnectionFactory::createConnection(const TransceiverPtr& t
     Ice::ConnectionIPtr connection;
     try
     {
-        if(_destroyed)
+        if (_destroyed)
         {
             throw Ice::CommunicatorDestroyedException(__FILE__, __LINE__);
         }
 
-        connection = ConnectionI::create(_communicator, _instance, _monitor, transceiver, ci.connector,
-                                         ci.endpoint->compress(false), ICE_NULLPTR);
+        // The connect, close and idle timeouts are ignored for UDP connections.
+
+        connection = ConnectionI::create(
+            _communicator,
+            _instance,
+            transceiver,
+            ci.connector,
+            ci.endpoint->compress(false)->timeout(-1),
+            _defaultObjectAdapter,
+            [weakSelf = weak_from_this()](const ConnectionIPtr& closedConnection)
+            {
+                if (auto self = weakSelf.lock())
+                {
+                    self->removeConnection(closedConnection);
+                }
+            },
+            _connectionOptions);
     }
-    catch(const Ice::LocalException&)
+    catch (const Ice::LocalException&)
     {
         try
         {
             transceiver->close();
         }
-        catch(const Ice::LocalException&)
+        catch (const Ice::LocalException&)
         {
             // Ignore
         }
@@ -687,153 +503,156 @@ IceInternal::OutgoingConnectionFactory::createConnection(const TransceiverPtr& t
 
     _connections.insert(pair<const ConnectorPtr, ConnectionIPtr>(ci.connector, connection));
     _connectionsByEndpoint.insert(pair<const EndpointIPtr, ConnectionIPtr>(connection->endpoint(), connection));
-    _connectionsByEndpoint.insert(pair<const EndpointIPtr, ConnectionIPtr>(connection->endpoint()->compress(true),
-                                                                           connection));
+    _connectionsByEndpoint.insert(
+        pair<const EndpointIPtr, ConnectionIPtr>(connection->endpoint()->compress(true), connection));
     return connection;
 }
 
 void
-IceInternal::OutgoingConnectionFactory::finishGetConnection(const vector<ConnectorInfo>& connectors,
-                                                            const ConnectorInfo& ci,
-                                                            const ConnectionIPtr& connection,
-                                                            const ConnectCallbackPtr& cb)
+IceInternal::OutgoingConnectionFactory::finishGetConnection(
+    const vector<ConnectorInfo>& connectors,
+    const ConnectorInfo& ci,
+    const ConnectionIPtr& connection,
+    const ConnectCallbackPtr& cb)
 {
-    set<ConnectCallbackPtr> connectionCallbacks;
-    if(cb)
+    ConnectCallbackSet connectionCallbacks;
+    if (cb)
     {
         connectionCallbacks.insert(cb);
     }
 
-    set<ConnectCallbackPtr> callbacks;
+    ConnectCallbackSet callbacks;
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-        for(vector<ConnectorInfo>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+        lock_guard lock(_mutex);
+        for (const auto& connector : connectors)
         {
-            map<ConnectorPtr, set<ConnectCallbackPtr> >::iterator q = _pending.find(p->connector);
-            if(q != _pending.end())
+            auto q = _pending.find(connector.connector);
+            if (q != _pending.end())
             {
-                for(set<ConnectCallbackPtr>::const_iterator r = q->second.begin(); r != q->second.end(); ++r)
+                for (const auto& r : q->second)
                 {
-                    if((*r)->hasConnector(ci))
+                    if (r->hasConnector(ci))
                     {
-                        connectionCallbacks.insert(*r);
+                        connectionCallbacks.insert(r);
                     }
                     else
                     {
-                        callbacks.insert(*r);
+                        callbacks.insert(r);
                     }
                 }
                 _pending.erase(q);
             }
         }
 
-        for(set<ConnectCallbackPtr>::iterator r = connectionCallbacks.begin(); r != connectionCallbacks.end(); ++r)
+        for (const auto& connectionCallback : connectionCallbacks)
         {
-            (*r)->removeFromPending();
-            callbacks.erase(*r);
+            connectionCallback->removeFromPending();
+            callbacks.erase(connectionCallback);
         }
-        for(set<ConnectCallbackPtr>::iterator r = callbacks.begin(); r != callbacks.end(); ++r)
+        for (const auto& callback : callbacks)
         {
-            (*r)->removeFromPending();
+            callback->removeFromPending();
         }
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 
     bool compress;
     DefaultsAndOverridesPtr defaultsAndOverrides = _instance->defaultsAndOverrides();
-    if(defaultsAndOverrides->overrideCompress)
+    if (defaultsAndOverrides->overrideCompress.has_value())
     {
-        compress = defaultsAndOverrides->overrideCompressValue;
+        compress = *defaultsAndOverrides->overrideCompress;
     }
     else
     {
         compress = ci.endpoint->compress();
     }
 
-    for(set<ConnectCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p)
+    for (const auto& callback : callbacks)
     {
-        (*p)->getConnection();
+        callback->getConnection();
     }
-    for(set<ConnectCallbackPtr>::const_iterator p = connectionCallbacks.begin(); p != connectionCallbacks.end(); ++p)
+    for (const auto& connectionCallback : connectionCallbacks)
     {
-        (*p)->setConnection(connection, compress);
+        connectionCallback->setConnection(connection, compress);
     }
 }
 
 void
-IceInternal::OutgoingConnectionFactory::finishGetConnection(const vector<ConnectorInfo>& connectors,
-                                                            const Ice::LocalException& ex,
-                                                            const ConnectCallbackPtr& cb)
+IceInternal::OutgoingConnectionFactory::finishGetConnection(
+    const vector<ConnectorInfo>& connectors,
+    std::exception_ptr ex,
+    const ConnectCallbackPtr& cb)
 {
-    set<ConnectCallbackPtr> failedCallbacks;
-    if(cb)
+    ConnectCallbackSet failedCallbacks;
+    if (cb)
     {
         failedCallbacks.insert(cb);
     }
 
-    set<ConnectCallbackPtr> callbacks;
+    ConnectCallbackSet callbacks;
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-        for(vector<ConnectorInfo>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+        lock_guard lock(_mutex);
+        for (auto p = connectors.begin(); p != connectors.end(); ++p)
         {
-            map<ConnectorPtr, set<ConnectCallbackPtr> >::iterator q = _pending.find(p->connector);
-            if(q != _pending.end())
+            auto q = _pending.find(p->connector);
+            if (q != _pending.end())
             {
-                for(set<ConnectCallbackPtr>::const_iterator r = q->second.begin(); r != q->second.end(); ++r)
+                for (const auto& r : q->second)
                 {
-                    if((*r)->removeConnectors(connectors))
+                    if (r->removeConnectors(connectors))
                     {
-                        failedCallbacks.insert(*r);
+                        failedCallbacks.insert(r);
                     }
                     else
                     {
-                        callbacks.insert(*r);
+                        callbacks.insert(r);
                     }
                 }
                 _pending.erase(q);
             }
         }
 
-        for(set<ConnectCallbackPtr>::iterator r = callbacks.begin(); r != callbacks.end(); ++r)
+        for (const auto& callback : callbacks)
         {
-            assert(failedCallbacks.find(*r) == failedCallbacks.end());
-            (*r)->removeFromPending();
+            assert(failedCallbacks.find(callback) == failedCallbacks.end());
+            callback->removeFromPending();
         }
-        notifyAll();
+        _conditionVariable.notify_all();
     }
 
-    for(set<ConnectCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p)
+    for (const auto& callback : callbacks)
     {
-        (*p)->getConnection();
+        callback->getConnection();
     }
-    for(set<ConnectCallbackPtr>::const_iterator p = failedCallbacks.begin(); p != failedCallbacks.end(); ++p)
+    for (const auto& failedCallback : failedCallbacks)
     {
-        (*p)->setException(ex);
+        failedCallback->setException(ex);
     }
 }
 
 bool
-IceInternal::OutgoingConnectionFactory::addToPending(const ConnectCallbackPtr& cb,
-                                                     const vector<ConnectorInfo>& connectors)
+IceInternal::OutgoingConnectionFactory::addToPending(
+    const ConnectCallbackPtr& cb,
+    const vector<ConnectorInfo>& connectors)
 {
     //
     // Add the callback to each connector pending list.
     //
     bool found = false;
-    for(vector<ConnectorInfo>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+    for (const auto& connector : connectors)
     {
-        map<ConnectorPtr, set<ConnectCallbackPtr> >::iterator q = _pending.find(p->connector);
-        if(q != _pending.end())
+        auto q = _pending.find(connector.connector);
+        if (q != _pending.end())
         {
             found = true;
-            if(cb)
+            if (cb)
             {
                 q->second.insert(cb);
             }
         }
     }
 
-    if(found)
+    if (found)
     {
         return true;
     }
@@ -843,24 +662,25 @@ IceInternal::OutgoingConnectionFactory::addToPending(const ConnectCallbackPtr& c
     // responsible for its establishment. We add empty pending lists,
     // other callbacks to the same connectors will be queued.
     //
-    for(vector<ConnectorInfo>::const_iterator r = connectors.begin(); r != connectors.end(); ++r)
+    for (const auto& connector : connectors)
     {
-        if(_pending.find(r->connector) == _pending.end())
+        if (_pending.find(connector.connector) == _pending.end())
         {
-            _pending.insert(pair<ConnectorPtr, set<ConnectCallbackPtr> >(r->connector, set<ConnectCallbackPtr>()));
+            _pending.insert(make_pair(connector.connector, ConnectCallbackSet()));
         }
     }
     return false;
 }
 
 void
-IceInternal::OutgoingConnectionFactory::removeFromPending(const ConnectCallbackPtr& cb,
-                                                          const vector<ConnectorInfo>& connectors)
+IceInternal::OutgoingConnectionFactory::removeFromPending(
+    const ConnectCallbackPtr& cb,
+    const vector<ConnectorInfo>& connectors)
 {
-    for(vector<ConnectorInfo>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+    for (const auto& connector : connectors)
     {
-        map<ConnectorPtr, set<ConnectCallbackPtr> >::iterator q = _pending.find(p->connector);
-        if(q != _pending.end())
+        auto q = _pending.find(connector.connector);
+        if (q != _pending.end())
         {
             q->second.erase(cb);
         }
@@ -868,21 +688,26 @@ IceInternal::OutgoingConnectionFactory::removeFromPending(const ConnectCallbackP
 }
 
 void
-IceInternal::OutgoingConnectionFactory::handleException(const LocalException& ex, bool hasMore)
+IceInternal::OutgoingConnectionFactory::handleException(exception_ptr ex, bool hasMore)
 {
     TraceLevelsPtr traceLevels = _instance->traceLevels();
-    if(traceLevels->network >= 2)
+    if (traceLevels->network >= 2)
     {
         Trace out(_instance->initializationData().logger, traceLevels->networkCat);
 
         out << "couldn't resolve endpoint host";
-        if(dynamic_cast<const CommunicatorDestroyedException*>(&ex))
+
+        try
         {
-            out << "\n";
+            rethrow_exception(ex);
         }
-        else
+        catch (const CommunicatorDestroyedException& e)
         {
-            if(hasMore)
+            out << "\n" << e;
+        }
+        catch (const std::exception& e)
+        {
+            if (hasMore)
             {
                 out << ", trying next endpoint\n";
             }
@@ -890,27 +715,32 @@ IceInternal::OutgoingConnectionFactory::handleException(const LocalException& ex
             {
                 out << " and no more endpoints to try\n";
             }
+            out << e;
         }
-        out << ex;
     }
 }
 
 void
-IceInternal::OutgoingConnectionFactory::handleConnectionException(const LocalException& ex, bool hasMore)
+IceInternal::OutgoingConnectionFactory::handleConnectionException(exception_ptr ex, bool hasMore)
 {
     TraceLevelsPtr traceLevels = _instance->traceLevels();
-    if(traceLevels->network >= 2)
+    if (traceLevels->network >= 2)
     {
         Trace out(_instance->initializationData().logger, traceLevels->networkCat);
 
         out << "connection to endpoint failed";
-        if(dynamic_cast<const CommunicatorDestroyedException*>(&ex))
+
+        try
         {
-            out << "\n";
+            rethrow_exception(ex);
         }
-        else
+        catch (const CommunicatorDestroyedException& e)
         {
-            if(hasMore)
+            out << "\n" << e;
+        }
+        catch (const std::exception& e)
+        {
+            if (hasMore)
             {
                 out << ", trying next endpoint\n";
             }
@@ -918,23 +748,24 @@ IceInternal::OutgoingConnectionFactory::handleConnectionException(const LocalExc
             {
                 out << " and no more endpoints to try\n";
             }
+            out << e;
         }
-        out << ex;
     }
 }
 
-IceInternal::OutgoingConnectionFactory::ConnectCallback::ConnectCallback(const InstancePtr& instance,
-                                                                         const OutgoingConnectionFactoryPtr& factory,
-                                                                         const vector<EndpointIPtr>& endpoints,
-                                                                         bool hasMore,
-                                                                         const CreateConnectionCallbackPtr& cb,
-                                                                         Ice::EndpointSelectionType selType) :
-    _instance(instance),
-    _factory(factory),
-    _endpoints(endpoints),
-    _hasMore(hasMore),
-    _callback(cb),
-    _selType(selType)
+IceInternal::OutgoingConnectionFactory::ConnectCallback::ConnectCallback(
+    InstancePtr instance,
+    OutgoingConnectionFactoryPtr factory,
+    vector<EndpointIPtr> endpoints,
+    bool hasMore,
+    std::function<void(Ice::ConnectionIPtr, bool)> createConnectionResponse,
+    std::function<void(std::exception_ptr)> createConnectionException)
+    : _instance(std::move(instance)),
+      _factory(std::move(factory)),
+      _endpoints(std::move(endpoints)),
+      _hasMore(hasMore),
+      _createConnectionResponse(std::move(createConnectionResponse)),
+      _createConnectionException(std::move(createConnectionException))
 {
     _endpointsIter = _endpoints.begin();
 }
@@ -945,21 +776,22 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::ConnectCallback(const I
 void
 IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartCompleted(const ConnectionIPtr& connection)
 {
-    if(_observer)
+    if (_observer)
     {
         _observer->detach();
     }
 
     connection->activate();
-    _factory->finishGetConnection(_connectors, *_iter, connection, ICE_SHARED_FROM_THIS);
+    _factory->finishGetConnection(_connectors, *_iter, connection, shared_from_this());
 }
 
 void
-IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailed(const ConnectionIPtr& /*connection*/,
-                                                                               const LocalException& ex)
+IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailed(
+    const ConnectionIPtr& /*connection*/,
+    exception_ptr ex)
 {
     assert(_iter != _connectors.end());
-    if(connectionStartFailedImpl(ex))
+    if (connectionStartFailedImpl(ex))
     {
         nextConnector();
     }
@@ -971,12 +803,12 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailed(c
 void
 IceInternal::OutgoingConnectionFactory::ConnectCallback::connectors(const vector<ConnectorPtr>& connectors)
 {
-    for(vector<ConnectorPtr>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+    for (const auto& connector : connectors)
     {
-        _connectors.push_back(ConnectorInfo(*p, *_endpointsIter));
+        _connectors.emplace_back(connector, *_endpointsIter);
     }
 
-    if(++_endpointsIter != _endpoints.end())
+    if (++_endpointsIter != _endpoints.end())
     {
         nextEndpoint();
     }
@@ -994,14 +826,14 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::connectors(const vector
 }
 
 void
-IceInternal::OutgoingConnectionFactory::ConnectCallback::exception(const Ice::LocalException& ex)
+IceInternal::OutgoingConnectionFactory::ConnectCallback::exception(exception_ptr ex)
 {
     _factory->handleException(ex, _hasMore || _endpointsIter != _endpoints.end() - 1);
-    if(++_endpointsIter != _endpoints.end())
+    if (++_endpointsIter != _endpoints.end())
     {
         nextEndpoint();
     }
-    else if(!_connectors.empty())
+    else if (!_connectors.empty())
     {
         //
         // We now have all the connectors for the given endpoints. We can try to obtain the
@@ -1012,7 +844,7 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::exception(const Ice::Lo
     }
     else
     {
-        _callback->setException(ex);
+        _createConnectionException(ex);
         _factory->decPendingConnectCount(); // Must be called last.
     }
 }
@@ -1029,9 +861,9 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::getConnectors()
         //
         _factory->incPendingConnectCount();
     }
-    catch(const Ice::LocalException& ex)
+    catch (const std::exception&)
     {
-        _callback->setException(ex);
+        _createConnectionException(current_exception());
         return;
     }
 
@@ -1043,13 +875,16 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextEndpoint()
 {
     try
     {
+        auto self = shared_from_this();
         assert(_endpointsIter != _endpoints.end());
-        (*_endpointsIter)->connectors_async(_selType, ICE_SHARED_FROM_THIS);
-
+        (*_endpointsIter)
+            ->connectorsAsync(
+                [self](const vector<ConnectorPtr>& connectors) { self->connectors(connectors); },
+                [self](exception_ptr ex) { self->exception(ex); });
     }
-    catch(const Ice::LocalException& ex)
+    catch (const std::exception&)
     {
-        exception(ex);
+        exception(current_exception());
     }
 }
 
@@ -1063,8 +898,8 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::getConnection()
         // connection.
         //
         bool compress;
-        Ice::ConnectionIPtr connection = _factory->getConnection(_connectors, ICE_SHARED_FROM_THIS, compress);
-        if(!connection)
+        Ice::ConnectionIPtr connection = _factory->getConnection(_connectors, shared_from_this(), compress);
+        if (!connection)
         {
             //
             // A null return value from getConnection indicates that the connection
@@ -1075,12 +910,12 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::getConnection()
             return;
         }
 
-        _callback->setConnection(connection, compress);
+        _createConnectionResponse(connection, compress);
         _factory->decPendingConnectCount(); // Must be called last.
     }
-    catch(const Ice::LocalException& ex)
+    catch (const std::exception&)
     {
-        _callback->setException(ex);
+        _createConnectionException(current_exception());
         _factory->decPendingConnectCount(); // Must be called last.
     }
 }
@@ -1088,15 +923,15 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::getConnection()
 void
 IceInternal::OutgoingConnectionFactory::ConnectCallback::nextConnector()
 {
-    while(true)
+    while (true)
     {
         try
         {
             const CommunicatorObserverPtr& obsv = _factory->_instance->initializationData().observer;
-            if(obsv)
+            if (obsv)
             {
                 _observer = obsv->getConnectionEstablishmentObserver(_iter->endpoint, _iter->connector->toString());
-                if(_observer)
+                if (_observer)
                 {
                     _observer->attach();
                 }
@@ -1104,25 +939,29 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextConnector()
 
             assert(_iter != _connectors.end());
 
-            if(_instance->traceLevels()->network >= 2)
+            if (_instance->traceLevels()->network >= 2)
             {
                 Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                 out << "trying to establish " << _iter->endpoint->protocol() << " connection to "
                     << _iter->connector->toString();
             }
             Ice::ConnectionIPtr connection = _factory->createConnection(_iter->connector->connect(), *_iter);
-            connection->start(ICE_SHARED_FROM_THIS);
+            auto self = shared_from_this();
+            connection->startAsync(
+                [self](const ConnectionIPtr& conn) { self->connectionStartCompleted(conn); },
+                [self](const ConnectionIPtr& conn, exception_ptr ex) { self->connectionStartFailed(conn, ex); });
         }
-        catch(const Ice::LocalException& ex)
+        catch (const Ice::LocalException& ex)
         {
-            if(_instance->traceLevels()->network >= 2)
+            if (_instance->traceLevels()->network >= 2)
             {
                 Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                 out << "failed to establish " << _iter->endpoint->protocol() << " connection to "
-                    << _iter->connector->toString() << "\n" << ex;
+                    << _iter->connector->toString() << "\n"
+                    << ex;
             }
 
-            if(connectionStartFailedImpl(ex))
+            if (connectionStartFailedImpl(current_exception()))
             {
                 continue; // More connectors to try, continue.
             }
@@ -1132,24 +971,25 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::nextConnector()
 }
 
 void
-IceInternal::OutgoingConnectionFactory::ConnectCallback::setConnection(const Ice::ConnectionIPtr& connection,
-                                                                       bool compress)
+IceInternal::OutgoingConnectionFactory::ConnectCallback::setConnection(
+    const Ice::ConnectionIPtr& connection,
+    bool compress)
 {
     //
     // Callback from the factory: the connection to one of the callback
     // connectors has been established.
     //
-    _callback->setConnection(connection, compress);
+    _createConnectionResponse(connection, compress);
     _factory->decPendingConnectCount(); // Must be called last.
 }
 
 void
-IceInternal::OutgoingConnectionFactory::ConnectCallback::setException(const Ice::LocalException& ex)
+IceInternal::OutgoingConnectionFactory::ConnectCallback::setException(exception_ptr ex)
 {
     //
     // Callback from the factory: connection establishment failed.
     //
-    _callback->setException(ex);
+    _createConnectionException(ex);
     _factory->decPendingConnectCount(); // Must be called last.
 }
 
@@ -1167,9 +1007,9 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::removeConnectors(const
     // failed, we remove the connectors and return true if there's
     // no more connectors left to try.
     //
-    for(vector<ConnectorInfo>::const_iterator p = connectors.begin(); p != connectors.end(); ++p)
+    for (const auto& p : connectors)
     {
-        _connectors.erase(remove(_connectors.begin(), _connectors.end(), *p), _connectors.end());
+        _connectors.erase(remove(_connectors.begin(), _connectors.end(), p), _connectors.end());
     }
     return _connectors.empty();
 }
@@ -1177,73 +1017,79 @@ IceInternal::OutgoingConnectionFactory::ConnectCallback::removeConnectors(const
 void
 IceInternal::OutgoingConnectionFactory::ConnectCallback::removeFromPending()
 {
-    _factory->removeFromPending(ICE_SHARED_FROM_THIS, _connectors);
+    _factory->removeFromPending(shared_from_this(), _connectors);
 }
 
 bool
-IceInternal::OutgoingConnectionFactory::ConnectCallback::operator<(const ConnectCallback& rhs) const
+IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailedImpl(std::exception_ptr ex)
 {
-    return this < &rhs;
-}
-
-bool
-IceInternal::OutgoingConnectionFactory::ConnectCallback::connectionStartFailedImpl(const Ice::LocalException& ex)
-{
-    if(_observer)
+    if (_observer)
     {
-        _observer->failed(ex.ice_id());
+        _observer->failed(getExceptionId(ex));
         _observer->detach();
     }
 
     _factory->handleConnectionException(ex, _hasMore || _iter != _connectors.end() - 1);
-    if(dynamic_cast<const Ice::CommunicatorDestroyedException*>(&ex)) // No need to continue.
-    {
-        _factory->finishGetConnection(_connectors, ex, ICE_SHARED_FROM_THIS);
-    }
-    else if(++_iter != _connectors.end()) // Try the next connector.
+
+    bool keepGoing = ++_iter != _connectors.end();
+
+    if (keepGoing)
     {
-        return true;
+        try
+        {
+            rethrow_exception(ex);
+        }
+        catch (const CommunicatorDestroyedException&)
+        {
+            keepGoing = false;
+        }
+        catch (const ConnectTimeoutException&)
+        {
+            // We stop on ConnectTimeoutException to fail reasonably fast when the endpoint has many connectors
+            // (IP addresses).
+            keepGoing = false;
+        }
+        catch (...)
+        {
+        }
     }
-    else
+
+    if (!keepGoing)
     {
-        _factory->finishGetConnection(_connectors, ex, ICE_SHARED_FROM_THIS);
+        _factory->finishGetConnection(_connectors, ex, shared_from_this());
     }
-    return false;
+    return keepGoing;
 }
 
 void
 IceInternal::IncomingConnectionFactory::activate()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
     setState(StateActive);
 }
 
 void
 IceInternal::IncomingConnectionFactory::hold()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
     setState(StateHolding);
 }
 
 void
 IceInternal::IncomingConnectionFactory::destroy()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
     setState(StateClosed);
 }
 
 void
 IceInternal::IncomingConnectionFactory::updateConnectionObservers()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& conn : _connections)
+    lock_guard lock(_mutex);
+    for (const auto& connection : _connections)
     {
-        conn->updateObserver();
+        connection->updateObserver();
     }
-#else
-    for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::updateObserver));
-#endif
 }
 
 void
@@ -1252,16 +1098,13 @@ IceInternal::IncomingConnectionFactory::waitUntilHolding() const
     set<ConnectionIPtr> connections;
 
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+        unique_lock lock(_mutex);
 
         //
         // First we wait until the connection factory itself is in holding
         // state.
         //
-        while(_state < StateHolding)
-        {
-            wait();
-        }
+        _conditionVariable.wait(lock, [this] { return _state >= StateHolding; });
 
         //
         // We want to wait until all connections are in holding state
@@ -1273,14 +1116,10 @@ IceInternal::IncomingConnectionFactory::waitUntilHolding() const
     //
     // Now we wait until each connection is in holding state.
     //
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& conn : connections)
+    for (const auto& conn : connections)
     {
         conn->waitUntilHolding();
     }
-#else
-    for_each(connections.begin(), connections.end(), Ice::constVoidMemFun(&ConnectionI::waitUntilHolding));
-#endif
 }
 
 void
@@ -1288,21 +1127,18 @@ IceInternal::IncomingConnectionFactory::waitUntilFinished()
 {
     set<ConnectionIPtr> connections;
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+        unique_lock lock(_mutex);
 
         //
         // First we wait until the factory is destroyed. If we are using
         // an acceptor, we also wait for it to be closed.
         //
-        while(_state != StateFinished)
-        {
-            wait();
-        }
+        _conditionVariable.wait(lock, [this] { return _state == StateFinished; });
 
         //
         // Clear the OA. See bug 1673 for the details of why this is necessary.
         //
-        _adapter = 0;
+        _adapter = nullptr;
 
         // We want to wait until all connections are finished outside the
         // thread synchronization.
@@ -1310,97 +1146,67 @@ IceInternal::IncomingConnectionFactory::waitUntilFinished()
         connections = _connections;
     }
 
-#ifdef ICE_CPP11_COMPILER
-    for(const auto& conn : connections)
+    for (const auto& conn : connections)
     {
         conn->waitUntilFinished();
     }
-#else
-    for_each(connections.begin(), connections.end(), Ice::voidMemFun(&ConnectionI::waitUntilFinished));
-#endif
 
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-        if(_transceiver)
-        {
-            assert(_connections.size() <= 1); // The connection isn't monitored or reaped.
-        }
-        else
-        {
-            // Ensure all the connections are finished and reapable at this point.
-            vector<Ice::ConnectionIPtr> cons;
-            _monitor->swapReapedConnections(cons);
-            assert(cons.size() == _connections.size());
-            cons.clear();
-        }
+        lock_guard lock(_mutex);
         _connections.clear();
     }
-
-    //
-    // Must be destroyed outside the synchronization since this might block waiting for
-    // a timer task to complete.
-    //
-    _monitor->destroy();
-}
-
-bool
-IceInternal::IncomingConnectionFactory::isLocal(const EndpointIPtr& endpoint) const
-{
-    if(_publishedEndpoint && endpoint->equivalent(_publishedEndpoint))
-    {
-        return true;
-    }
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    return endpoint->equivalent(_endpoint);
 }
 
 EndpointIPtr
 IceInternal::IncomingConnectionFactory::endpoint() const
 {
-    if(_publishedEndpoint)
-    {
-        return _publishedEndpoint;
-    }
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
     return _endpoint;
 }
 
 list<ConnectionIPtr>
 IceInternal::IncomingConnectionFactory::connections() const
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     list<ConnectionIPtr> result;
 
     //
     // Only copy connections which have not been destroyed.
     //
-#ifdef ICE_CPP11_COMPILER
-    remove_copy_if(_connections.begin(), _connections.end(), back_inserter(result),
-                   [](const ConnectionIPtr& conn)
-                   {
-                       return !conn->isActiveOrHolding();
-                   });
-#else
-    remove_copy_if(_connections.begin(), _connections.end(), back_inserter(result),
-                   not1(Ice::constMemFun(&ConnectionI::isActiveOrHolding)));
-#endif
+    remove_copy_if(
+        _connections.begin(),
+        _connections.end(),
+        back_inserter(result),
+        [](const ConnectionIPtr& conn) { return !conn->isActiveOrHolding(); });
     return result;
 }
 
 void
-IceInternal::IncomingConnectionFactory::flushAsyncBatchRequests(const CommunicatorFlushBatchAsyncPtr& outAsync,
-                                                                Ice::CompressBatch compress)
+IceInternal::IncomingConnectionFactory::removeConnection(const ConnectionIPtr& connection) noexcept
+{
+    lock_guard lock(_mutex);
+    if (_state == StateActive || _state == StateHolding)
+    {
+        _connections.erase(connection);
+    }
+    // else it's already being cleaned up.
+}
+
+void
+IceInternal::IncomingConnectionFactory::flushAsyncBatchRequests(
+    const CommunicatorFlushBatchAsyncPtr& outAsync,
+    Ice::CompressBatch compress)
 {
     list<ConnectionIPtr> c = connections(); // connections() is synchronized, so no need to synchronize here.
 
-    for(list<ConnectionIPtr>::const_iterator p = c.begin(); p != c.end(); ++p)
+    for (const auto& p : c)
     {
         try
         {
-            outAsync->flushConnection(*p, compress);
+            outAsync->flushConnection(p, compress);
         }
-        catch(const LocalException&)
+        catch (const LocalException&)
         {
             // Ignore.
         }
@@ -1412,7 +1218,7 @@ bool
 IceInternal::IncomingConnectionFactory::startAsync(SocketOperation)
 {
     assert(_acceptor);
-    if(_state >= StateClosed)
+    if (_state >= StateClosed)
     {
         return false;
     }
@@ -1421,9 +1227,9 @@ IceInternal::IncomingConnectionFactory::startAsync(SocketOperation)
     {
         _acceptor->startAccept();
     }
-    catch(const Ice::LocalException& ex)
+    catch (const Ice::LocalException&)
     {
-        ICE_SET_EXCEPTION_FROM_CLONE(_acceptorException, ex.ice_clone());
+        _acceptorException = current_exception();
         _acceptor->getNativeInfo()->completed(SocketOperationRead);
     }
     return true;
@@ -1435,25 +1241,20 @@ IceInternal::IncomingConnectionFactory::finishAsync(SocketOperation)
     assert(_acceptor);
     try
     {
-        if(_acceptorException)
+        if (_acceptorException)
         {
-            _acceptorException->ice_throw();
+            rethrow_exception(_acceptorException);
         }
         _acceptor->finishAccept();
     }
-    catch(const LocalException& ex)
+    catch (const LocalException& ex)
     {
-        _acceptorException.reset(ICE_NULLPTR);
+        _acceptorException = nullptr;
 
-        Error out(_instance->initializationData().logger);
-        out << "couldn't accept connection:\n" << ex << '\n' << _acceptor->toString();
-        if(_acceptorStarted)
+        if (_warn)
         {
-            _acceptorStarted = false;
-            if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
-            {
-                closeAcceptor();
-            }
+            Warning out(_instance->initializationData().logger);
+            out << "error accepting connection:\n" << ex << '\n' << _acceptor->toString();
         }
     }
     return _state < StateClosed;
@@ -1468,35 +1269,25 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
     ThreadPoolMessage<IncomingConnectionFactory> msg(current, *this);
 
     {
-        IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+        lock_guard lock(_mutex);
 
         ThreadPoolMessage<IncomingConnectionFactory>::IOScope io(msg);
-        if(!io)
+        if (!io)
         {
             return;
         }
 
-        if(_state >= StateClosed)
+        if (_state >= StateClosed)
         {
             return;
         }
-        else if(_state == StateHolding)
+        else if (_state == StateHolding)
         {
-            IceUtil::ThreadControl::yield();
+            this_thread::yield();
             return;
         }
 
-        //
-        // Reap closed connections
-        //
-        vector<Ice::ConnectionIPtr> cons;
-        _monitor->swapReapedConnections(cons);
-        for(vector<Ice::ConnectionIPtr>::const_iterator p = cons.begin(); p != cons.end(); ++p)
-        {
-            _connections.erase(*p);
-        }
-
-        if(!_acceptorStarted)
+        if (!_acceptorStarted)
         {
             return;
         }
@@ -1509,37 +1300,40 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
         {
             transceiver = _acceptor->accept();
 
-            if(_instance->traceLevels()->network >= 2)
-            {
-                Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
-                out << "trying to accept " << _endpoint->protocol() << " connection\n" << transceiver->toString();
-            }
-        }
-        catch(const SocketException& ex)
-        {
-            if(noMoreFds(ex.error))
+            if (_maxConnections > 0 && _connections.size() == static_cast<size_t>(_maxConnections))
             {
-                Error out(_instance->initializationData().logger);
-                out << "can't accept more connections:\n" << ex << '\n' << _acceptor->toString();
+                // Can't accept more connections, so we abort this transport connection.
 
-                assert(_acceptorStarted);
-                _acceptorStarted = false;
-                if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
+                if (_instance->traceLevels()->network >= 2)
                 {
-                    closeAcceptor();
+                    Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
+                    out << "rejecting new " << _endpoint->protocol() << " connection\n"
+                        << transceiver->toString() << "\nbecause the maximum number of connections has been reached";
+                }
+
+                try
+                {
+                    transceiver->close();
+                }
+                catch (...)
+                {
+                    // Ignore.
                 }
+                return;
             }
 
-            // Ignore socket exceptions.
-            return;
+            if (_instance->traceLevels()->network >= 2)
+            {
+                Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
+                out << "trying to accept " << _endpoint->protocol() << " connection\n" << transceiver->toString();
+            }
         }
-        catch(const LocalException& ex)
+        catch (const LocalException& ex)
         {
-            // Warn about other Ice local exceptions.
-            if(_warn)
+            if (_warn)
             {
                 Warning out(_instance->initializationData().logger);
-                out << "connection exception:\n" << ex << '\n' << _acceptor->toString();
+                out << "error accepting connection:\n" << ex << '\n' << _acceptor->toString();
             }
             return;
         }
@@ -1548,24 +1342,37 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
 
         try
         {
-            connection = ConnectionI::create(_adapter->getCommunicator(), _instance, _monitor, transceiver, 0,
-                                             _endpoint, _adapter);
+            connection = ConnectionI::create(
+                _adapter->getCommunicator(),
+                _instance,
+                transceiver,
+                nullptr, // connector
+                _endpoint,
+                _adapter,
+                [weakSelf = weak_from_this()](const ConnectionIPtr& closedConnection)
+                {
+                    if (auto self = weakSelf.lock())
+                    {
+                        static_pointer_cast<IncomingConnectionFactory>(self)->removeConnection(closedConnection);
+                    }
+                },
+                _connectionOptions);
         }
-        catch(const LocalException& ex)
+        catch (const LocalException& ex)
         {
             try
             {
                 transceiver->close();
             }
-            catch(const Ice::LocalException&)
+            catch (const Ice::LocalException&)
             {
                 // Ignore.
             }
 
-            if(_warn)
+            if (_warn)
             {
                 Warning out(_instance->initializationData().logger);
-                out << "connection exception:\n" << ex << '\n' << _acceptor->toString();
+                out << "error accepting connection:\n" << ex << '\n' << _acceptor->toString();
             }
             return;
         }
@@ -1575,42 +1382,35 @@ IceInternal::IncomingConnectionFactory::message(ThreadPoolCurrent& current)
 
     assert(connection);
 
-    connection->start(ICE_SHARED_FROM_THIS);
+    auto self = shared_from_this();
+    connection->startAsync(
+        [self](const ConnectionIPtr& conn) { self->connectionStartCompleted(conn); },
+        [self](const ConnectionIPtr& conn, exception_ptr ex) { self->connectionStartFailed(conn, ex); });
 }
 
 void
 IceInternal::IncomingConnectionFactory::finished(ThreadPoolCurrent&, bool close)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_state < StateClosed)
+    unique_lock lock(_mutex);
+    if (_state < StateClosed)
     {
-        if(close)
+        if (close)
         {
             closeAcceptor();
         }
-
-        //
-        // If the acceptor hasn't been explicitly stopped (which is the case if the acceptor got closed
-        // because of an unexpected error), try to restart the acceptor in 1 second.
-        //
-        if(!_acceptorStopped)
-        {
-            _instance->timer()->schedule(ICE_MAKE_SHARED(StartAcceptor, ICE_SHARED_FROM_THIS, _instance),
-                                         IceUtil::Time::seconds(1));
-        }
         return;
     }
 
     assert(_state >= StateClosed);
     setState(StateFinished);
 
-    if(close)
+    if (close)
     {
         closeAcceptor();
     }
 
 #if TARGET_OS_IPHONE != 0
-    sync.release();
+    lock.unlock();
     finish();
 #endif
 }
@@ -1619,101 +1419,93 @@ IceInternal::IncomingConnectionFactory::finished(ThreadPoolCurrent&, bool close)
 void
 IceInternal::IncomingConnectionFactory::finish()
 {
-    unregisterForBackgroundNotification(ICE_SHARED_FROM_THIS);
+    unregisterForBackgroundNotification(shared_from_this());
 }
 #endif
 
 string
 IceInternal::IncomingConnectionFactory::toString() const
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_transceiver)
+    lock_guard lock(_mutex);
+    if (_transceiver)
     {
         return _transceiver->toString();
     }
-    else if(_acceptor)
+    else if (_acceptor)
     {
         return _acceptor->toString();
     }
     else
     {
-        return string();
+        return {};
     }
 }
 
 NativeInfoPtr
 IceInternal::IncomingConnectionFactory::getNativeInfo()
 {
-    if(_transceiver)
+    if (_transceiver)
     {
         return _transceiver->getNativeInfo();
     }
-    else if(_acceptor)
+    else if (_acceptor)
     {
         return _acceptor->getNativeInfo();
     }
     else
     {
-        return 0;
+        return nullptr;
     }
 }
 
 void
 IceInternal::IncomingConnectionFactory::connectionStartCompleted(const Ice::ConnectionIPtr& connection)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    lock_guard lock(_mutex);
 
     //
-    // Initialy, connections are in the holding state. If the factory is active
+    // Initially, connections are in the holding state. If the factory is active
     // we activate the connection.
     //
-    if(_state == StateActive)
+    if (_state == StateActive)
     {
         connection->activate();
     }
 }
 
 void
-IceInternal::IncomingConnectionFactory::connectionStartFailed(const Ice::ConnectionIPtr& /*connection*/,
-                                                              const Ice::LocalException&)
+IceInternal::IncomingConnectionFactory::connectionStartFailed(const Ice::ConnectionIPtr& /*connection*/, exception_ptr)
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_state >= StateClosed)
-    {
-        return;
-    }
-
-    //
     // Do not warn about connection exceptions here. The connection is not yet validated.
-    //
 }
 
 //
 // COMPILERFIX: The ConnectionFactory setup is broken out into a separate initialize
 // function because when it was part of the constructor C++Builder 2007 apps would
-// crash if an execption was thrown from any calls within the constructor.
+// crash if an exception was thrown from any calls within the constructor.
 //
-IceInternal::IncomingConnectionFactory::IncomingConnectionFactory(const InstancePtr& instance,
-                                                                  const EndpointIPtr& endpoint,
-                                                                  const EndpointIPtr& publishedEndpoint,
-                                                                  const ObjectAdapterIPtr& adapter) :
-    _instance(instance),
-    _monitor(new FactoryACMMonitor(instance, dynamic_cast<ObjectAdapterI*>(adapter.get())->getACM())),
-    _endpoint(endpoint),
-    _publishedEndpoint(publishedEndpoint),
-    _acceptorStarted(false),
-    _acceptorStopped(false),
-    _adapter(adapter),
-    _warn(_instance->initializationData().properties->getPropertyAsInt("Ice.Warn.Connections") > 0),
-    _state(StateHolding)
-{
-}
-
+IceInternal::IncomingConnectionFactory::IncomingConnectionFactory(
+    const InstancePtr& instance,
+    const EndpointIPtr& endpoint,
+    const shared_ptr<ObjectAdapterI>& adapter)
+    : _instance(instance),
+      _connectionOptions(instance->serverConnectionOptions(adapter->getName())),
+      _maxConnections(
+          endpoint->datagram()
+              ? 0
+              : instance->initializationData().properties->getPropertyAsInt(adapter->getName() + ".MaxConnections")),
+      _endpoint(endpoint),
+      _adapter(adapter),
+      _warn(_instance->initializationData().properties->getIcePropertyAsInt("Ice.Warn.Connections") > 0)
+{
+}
+
+#if defined(__APPLE__) && TARGET_OS_IPHONE != 0
 void
 IceInternal::IncomingConnectionFactory::startAcceptor()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_state >= StateClosed || _acceptorStarted)
+    lock_guard lock(_mutex);
+    if (_state >= StateClosed || _acceptorStarted)
     {
         return;
     }
@@ -1725,47 +1517,54 @@ IceInternal::IncomingConnectionFactory::startAcceptor()
 void
 IceInternal::IncomingConnectionFactory::stopAcceptor()
 {
-    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
-    if(_state >= StateClosed || !_acceptorStarted)
+    lock_guard lock(_mutex);
+    if (_state >= StateClosed || !_acceptorStarted)
     {
         return;
     }
 
     _acceptorStopped = true;
     _acceptorStarted = false;
-    if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
+    if (_adapter->getThreadPool()->finish(shared_from_this(), true))
     {
         closeAcceptor();
     }
 }
+#endif
 
 void
 IceInternal::IncomingConnectionFactory::initialize()
 {
-    if(_instance->defaultsAndOverrides()->overrideTimeout)
+    if (_instance->defaultsAndOverrides()->overrideCompress.has_value())
     {
-        _endpoint = _endpoint->timeout(_instance->defaultsAndOverrides()->overrideTimeoutValue);
+        _endpoint = _endpoint->compress(*_instance->defaultsAndOverrides()->overrideCompress);
     }
 
-    if(_instance->defaultsAndOverrides()->overrideCompress)
-    {
-        _endpoint = _endpoint->compress(_instance->defaultsAndOverrides()->overrideCompressValue);
-    }
     try
     {
         const_cast<TransceiverPtr&>(_transceiver) = _endpoint->transceiver();
-        if(_transceiver)
+        if (_transceiver)
         {
-            if(_instance->traceLevels()->network >= 2)
+            // All this is for UDP "connections".
+
+            if (_instance->traceLevels()->network >= 2)
             {
                 Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                 out << "attempting to bind to " << _endpoint->protocol() << " socket\n" << _transceiver->toString();
             }
             const_cast<EndpointIPtr&>(_endpoint) = _transceiver->bind();
-            ConnectionIPtr connection(ConnectionI::create(_adapter->getCommunicator(), _instance, 0, _transceiver, 0,
-                                                          _endpoint, _adapter));
-            connection->start(0);
+            ConnectionIPtr connection(ConnectionI::create(
+                _adapter->getCommunicator(),
+                _instance,
+                _transceiver,
+                nullptr,
+                _endpoint,
+                _adapter,
+                nullptr,
+                _connectionOptions));
+            connection->startAsync(nullptr, nullptr);
             _connections.insert(connection);
+            assert(_maxConnections == 0); // UDP so no max connections
         }
         else
         {
@@ -1774,28 +1573,27 @@ IceInternal::IncomingConnectionFactory::initialize()
             // The notification center will call back on the factory to
             // start the acceptor if necessary.
             //
-            registerForBackgroundNotification(ICE_SHARED_FROM_THIS);
+            registerForBackgroundNotification(shared_from_this());
 #else
             createAcceptor();
 #endif
         }
     }
-    catch(const Ice::Exception&)
+    catch (const Ice::Exception&)
     {
-        if(_transceiver)
+        if (_transceiver)
         {
             try
             {
                 _transceiver->close();
             }
-            catch(const Ice::LocalException&)
+            catch (const Ice::LocalException&)
             {
                 // Ignore
             }
         }
 
         _state = StateFinished;
-        _monitor->destroy();
         _connections.clear();
         throw;
     }
@@ -1810,68 +1608,61 @@ IceInternal::IncomingConnectionFactory::~IncomingConnectionFactory()
 void
 IceInternal::IncomingConnectionFactory::setState(State state)
 {
-    if(_state == state) // Don't switch twice.
+    if (_state == state) // Don't switch twice.
     {
         return;
     }
 
-    switch(state)
+    switch (state)
     {
         case StateActive:
         {
-            if(_state != StateHolding) // Can only switch from holding to active.
+            if (_state != StateHolding) // Can only switch from holding to active.
             {
                 return;
             }
-            if(_acceptor)
+            if (_acceptor)
             {
-                if(_instance->traceLevels()->network >= 1)
+                if (_instance->traceLevels()->network >= 1)
                 {
                     Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                     out << "accepting " << _endpoint->protocol() << " connections at " << _acceptor->toString();
                 }
-                _adapter->getThreadPool()->_register(ICE_SHARED_FROM_THIS, SocketOperationRead);
+                _adapter->getThreadPool()->_register(shared_from_this(), SocketOperationRead);
             }
-#ifdef ICE_CPP11_COMPILER
-            for(const auto& conn : _connections)
+
+            for (const auto& connection : _connections)
             {
-                conn->activate();
+                connection->activate();
             }
-#else
-            for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::activate));
-#endif
             break;
         }
 
         case StateHolding:
         {
-            if(_state != StateActive) // Can only switch from active to holding.
+            if (_state != StateActive) // Can only switch from active to holding.
             {
                 return;
             }
-            if(_acceptor)
+            if (_acceptor)
             {
-                if(_instance->traceLevels()->network >= 1)
+                if (_instance->traceLevels()->network >= 1)
                 {
                     Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
                     out << "holding " << _endpoint->protocol() << " connections at " << _acceptor->toString();
                 }
-                _adapter->getThreadPool()->unregister(ICE_SHARED_FROM_THIS, SocketOperationRead);
+                _adapter->getThreadPool()->unregister(shared_from_this(), SocketOperationRead);
             }
-#ifdef ICE_CPP11_COMPILER
-            for(const auto& conn : _connections)
+            for (const auto& connection : _connections)
             {
-                conn->hold();
+                connection->hold();
             }
-#else
-            for_each(_connections.begin(), _connections.end(), Ice::voidMemFun(&ConnectionI::hold));
-#endif
             break;
         }
 
         case StateClosed:
         {
-            if(_acceptorStarted)
+            if (_acceptorStarted)
             {
                 //
                 // If possible, close the acceptor now to prevent new connections from
@@ -1881,7 +1672,7 @@ IceInternal::IncomingConnectionFactory::setState(State state)
                 // however.
                 //
                 _acceptorStarted = false;
-                if(_adapter->getThreadPool()->finish(ICE_SHARED_FROM_THIS, true))
+                if (_adapter->getThreadPool()->finish(shared_from_this(), true))
                 {
                     closeAcceptor();
                 }
@@ -1889,20 +1680,15 @@ IceInternal::IncomingConnectionFactory::setState(State state)
             else
             {
 #if TARGET_OS_IPHONE != 0
-                _adapter->getThreadPool()->dispatch(new FinishCall(ICE_SHARED_FROM_THIS));
+                _adapter->getThreadPool()->execute([self = shared_from_this()]() { self->finish(); }, nullptr);
 #endif
                 state = StateFinished;
             }
 
-#ifdef ICE_CPP11_COMPILER
-            for(const auto& conn : _connections)
+            for (const auto& connection : _connections)
             {
-                conn->destroy(ConnectionI::ObjectAdapterDeactivated);
+                connection->destroy(ConnectionI::ObjectAdapterDeactivated);
             }
-#else
-            for_each(_connections.begin(), _connections.end(),
-                     bind2nd(Ice::voidMemFun1(&ConnectionI::destroy), ConnectionI::ObjectAdapterDeactivated));
-#endif
             break;
         }
 
@@ -1914,7 +1700,7 @@ IceInternal::IncomingConnectionFactory::setState(State state)
     }
 
     _state = state;
-    notifyAll();
+    _conditionVariable.notify_all();
 }
 
 void
@@ -1923,32 +1709,32 @@ IceInternal::IncomingConnectionFactory::createAcceptor()
     try
     {
         assert(!_acceptorStarted);
-        _acceptor = _endpoint->acceptor(_adapter->getName());
+        _acceptor = _endpoint->acceptor(_adapter->getName(), _adapter->serverAuthenticationOptions());
         assert(_acceptor);
-        if(_instance->traceLevels()->network >= 2)
+        if (_instance->traceLevels()->network >= 2)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
             out << "attempting to bind to " << _endpoint->protocol() << " socket " << _acceptor->toString();
         }
 
         _endpoint = _acceptor->listen();
-        if(_instance->traceLevels()->network >= 1)
+        if (_instance->traceLevels()->network >= 1)
         {
             Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
             out << "listening for " << _endpoint->protocol() << " connections\n" << _acceptor->toDetailedString();
         }
 
-        _adapter->getThreadPool()->initialize(ICE_SHARED_FROM_THIS);
-        if(_state == StateActive)
+        _adapter->getThreadPool()->initialize(shared_from_this());
+        if (_state == StateActive)
         {
-            _adapter->getThreadPool()->_register(ICE_SHARED_FROM_THIS, SocketOperationRead);
+            _adapter->getThreadPool()->_register(shared_from_this(), SocketOperationRead);
         }
 
         _acceptorStarted = true;
     }
-    catch(const Ice::Exception&)
+    catch (const Ice::Exception&)
     {
-        if(_acceptor)
+        if (_acceptor)
         {
             _acceptor->close();
         }
@@ -1961,7 +1747,7 @@ IceInternal::IncomingConnectionFactory::closeAcceptor()
 {
     assert(_acceptor);
 
-    if(_instance->traceLevels()->network >= 1)
+    if (_instance->traceLevels()->network >= 1)
     {
         Trace out(_instance->initializationData().logger, _instance->traceLevels()->networkCat);
         out << "stopping to accept " << _endpoint->protocol() << " connections at " << _acceptor->toString();