zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,87 +1,19 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#include <Ice/IPEndpointI.h>
-#include <Ice/ProtocolInstance.h>
-#include <Ice/Instance.h>
-#include <Ice/LocalException.h>
-#include <Ice/PropertiesI.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/HashUtil.h>
-#include <Ice/NetworkProxy.h>
-#include <IceUtil/MutexPtrLock.h>
+// Copyright (c) ZeroC, Inc.
+
+#include "IPEndpointI.h"
+#include "HashUtil.h"
+#include "Ice/InputStream.h"
+#include "Ice/LocalExceptions.h"
+#include "Instance.h"
+#include "NetworkProxy.h"
+#include "ProtocolInstance.h"
 
 using namespace std;
 using namespace Ice;
 using namespace Ice::Instrumentation;
 using namespace IceInternal;
 
-namespace
-{
-
-IceUtil::Mutex* hashMutex = 0;
-
-class Init
-{
-public:
-
-    Init()
-    {
-        hashMutex = new IceUtil::Mutex;
-    }
-
-    ~Init()
-    {
-        delete hashMutex;
-        hashMutex = 0;
-    }
-};
-
-Init init;
-
-}
-
-#ifndef ICE_CPP11_MAPPING
-IceUtil::Shared* IceInternal::upCast(IPEndpointI* p) { return p; }
-#endif
-IceUtil::Shared* IceInternal::upCast(EndpointHostResolver* p) { return p; }
-
-IceInternal::IPEndpointInfoI::IPEndpointInfoI(const EndpointIPtr& endpoint) : _endpoint(endpoint)
-{
-}
-
-IceInternal::IPEndpointInfoI::~IPEndpointInfoI()
-{
-}
-
-Ice::Short
-IceInternal::IPEndpointInfoI::type() const ICE_NOEXCEPT
-{
-    return _endpoint->type();
-}
-
-bool
-IceInternal::IPEndpointInfoI::datagram() const ICE_NOEXCEPT
-{
-    return _endpoint->datagram();
-}
-
-bool
-IceInternal::IPEndpointInfoI::secure() const ICE_NOEXCEPT
-{
-    return _endpoint->secure();
-}
-
-Ice::EndpointInfoPtr
-IceInternal::IPEndpointI::getInfo() const ICE_NOEXCEPT
-{
-    Ice::IPEndpointInfoPtr info = ICE_MAKE_SHARED(IPEndpointInfoI, ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
-    fillEndpointInfo(info.get());
-    return info;
-}
-
-Ice::Short
+int16_t
 IceInternal::IPEndpointI::type() const
 {
     return _instance->type();
@@ -115,9 +47,9 @@ IceInternal::IPEndpointI::connectionId() const
 EndpointIPtr
 IceInternal::IPEndpointI::connectionId(const string& connectionId) const
 {
-    if(connectionId == _connectionId)
+    if (connectionId == _connectionId)
     {
-        return ICE_SHARED_FROM_CONST_THIS(IPEndpointI);
+        return const_cast<IPEndpointI*>(this)->shared_from_this();
     }
     else
     {
@@ -126,102 +58,73 @@ IceInternal::IPEndpointI::connectionId(const string& connectionId) const
 }
 
 void
-IceInternal::IPEndpointI::connectors_async(Ice::EndpointSelectionType selType, const EndpointI_connectorsPtr& cb) const
+IceInternal::IPEndpointI::connectorsAsync(
+    std::function<void(std::vector<ConnectorPtr>)> response,
+    std::function<void(exception_ptr)> exception) const
 {
-    _instance->resolve(_host, _port, selType, ICE_SHARED_FROM_CONST_THIS(IPEndpointI), cb);
+    _instance->resolve(
+        _host,
+        _port,
+        const_cast<IPEndpointI*>(this)->shared_from_this(),
+        std::move(response),
+        std::move(exception));
 }
 
 vector<EndpointIPtr>
-IceInternal::IPEndpointI::expandIfWildcard() const
+IceInternal::IPEndpointI::expandHost() const
 {
-    vector<EndpointIPtr> endps;
-    vector<string> hosts = getHostsForEndpointExpand(_host, _instance->protocolSupport(), false);
-    if(hosts.empty())
-    {
-        endps.push_back(ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
-    }
-    else
-    {
-        for(vector<string>::const_iterator p = hosts.begin(); p != hosts.end(); ++p)
-        {
-            endps.push_back(createEndpoint(*p, _port, _connectionId));
-        }
-    }
-    return endps;
-}
-
-vector<EndpointIPtr>
-IceInternal::IPEndpointI::expandHost(EndpointIPtr& publish) const
-{
-    //
-    // If this endpoint has an empty host (wildcard address), don't expand, just return
-    // this endpoint.
-    //
-    if(_host.empty())
+    // If this endpoint has an empty host (wildcard address), don't expand, just return this endpoint.
+    if (_host.empty())
     {
         vector<EndpointIPtr> endpoints;
-        endpoints.push_back(ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
+        endpoints.push_back(const_cast<IPEndpointI*>(this)->shared_from_this());
         return endpoints;
     }
 
-    //
-    // If using a fixed port, this endpoint can be used as the published endpoint to
-    // access the returned endpoints. Otherwise, we'll publish each individual expanded
-    // endpoint.
-    //
-    if(_port > 0)
-    {
-        publish = ICE_SHARED_FROM_CONST_THIS(IPEndpointI);
-    }
-
-    vector<Address> addrs = getAddresses(_host,
-                                         _port,
-                                         _instance->protocolSupport(),
-                                         Ice::ICE_ENUM(EndpointSelectionType, Ordered),
-                                         _instance->preferIPv6(),
-                                         true);
+    vector<Address> addrs = getAddresses(_host, _port, _instance->protocolSupport(), _instance->preferIPv6(), true);
 
     vector<EndpointIPtr> endpoints;
-    if(addrs.size() == 1)
-    {
-        endpoints.push_back(ICE_SHARED_FROM_CONST_THIS(IPEndpointI));
-    }
-    else
+    for (const auto& address : addrs)
     {
-        for(vector<Address>::const_iterator p = addrs.begin(); p != addrs.end(); ++p)
-        {
-            string host;
-            int port;
-            addrToAddressAndPort(*p, host, port);
-            endpoints.push_back(createEndpoint(host, port, _connectionId));
-        }
+        string host;
+        int port;
+        addrToAddressAndPort(address, host, port);
+        endpoints.push_back(createEndpoint(host, port, _connectionId));
     }
     return endpoints;
 }
 
+bool
+IceInternal::IPEndpointI::isLoopbackOrMulticast() const
+{
+    return _host.empty() ? false : isLoopbackOrMulticastAddress(_host);
+}
+
 bool
 IceInternal::IPEndpointI::equivalent(const EndpointIPtr& endpoint) const
 {
-    const IPEndpointI* ipEndpointI = dynamic_cast<const IPEndpointI*>(endpoint.get());
-    if(!ipEndpointI)
+    auto ipEndpointI = dynamic_pointer_cast<IPEndpointI>(endpoint);
+    if (!ipEndpointI)
     {
         return false;
     }
-    return ipEndpointI->type() == type() && ipEndpointI->_host == _host && ipEndpointI->_port == _port;
+    return ipEndpointI->type() == type() && ipEndpointI->_normalizedHost == _normalizedHost &&
+           ipEndpointI->_port == _port;
 }
 
-Ice::Int
-IceInternal::IPEndpointI::hash() const
+size_t
+IceInternal::IPEndpointI::hash() const noexcept
 {
-    IceUtilInternal::MutexPtrLock<IceUtil::Mutex> lock(hashMutex);
-    if(!_hashInitialized)
+    size_t h = 5381;
+    hashAdd(h, type());
+    hashAdd(h, _host);
+    hashAdd(h, _port);
+    hashAdd(h, _connectionId);
+    if (isAddressValid(_sourceAddr))
     {
-        _hashValue = 5381;
-        hashAdd(_hashValue, type());
-        hashInit(_hashValue);
-        _hashInitialized = true;
+        hashAdd(h, inetAddrToString(_sourceAddr));
     }
-    return _hashValue;
+    return h;
 }
 
 string
@@ -236,34 +139,34 @@ IceInternal::IPEndpointI::options() const
     //
     ostringstream s;
 
-    if(!_host.empty())
+    if (!_host.empty())
     {
         s << " -h ";
         bool addQuote = _host.find(':') != string::npos;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
         s << _host;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
     }
 
-    s << " -p " << _port;
+    s << " -p " << to_string(_port);
 
-    if(isAddressValid(_sourceAddr))
+    if (isAddressValid(_sourceAddr))
     {
         const string sourceAddr = inetAddrToString(_sourceAddr);
         bool addQuote = sourceAddr.find(':') != string::npos;
         s << " --sourceAddress ";
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
         s << sourceAddr;
-        if(addQuote)
+        if (addQuote)
         {
             s << "\"";
         }
@@ -273,39 +176,35 @@ IceInternal::IPEndpointI::options() const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::IPEndpointI::operator==(const Endpoint& r) const
-#else
-IceInternal::IPEndpointI::operator==(const LocalObject& r) const
-#endif
 {
-    const IPEndpointI* p = dynamic_cast<const IPEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const IPEndpointI*>(&r);
+    if (!p)
     {
         return false;
     }
 
-    if(this == p)
+    if (this == p)
     {
         return true;
     }
 
-    if(_host != p->_host)
+    if (_host != p->_host)
     {
         return false;
     }
 
-    if(_port != p->_port)
+    if (_port != p->_port)
     {
         return false;
     }
 
-    if(_connectionId != p->_connectionId)
+    if (_connectionId != p->_connectionId)
     {
         return false;
     }
 
-    if(compareAddress(_sourceAddr, p->_sourceAddr) != 0)
+    if (compareAddress(_sourceAddr, p->_sourceAddr) != 0)
     {
         return false;
     }
@@ -313,70 +212,66 @@ IceInternal::IPEndpointI::operator==(const LocalObject& r) const
 }
 
 bool
-#ifdef ICE_CPP11_MAPPING
 IceInternal::IPEndpointI::operator<(const Endpoint& r) const
-#else
-IceInternal::IPEndpointI::operator<(const LocalObject& r) const
-#endif
 {
-    const IPEndpointI* p = dynamic_cast<const IPEndpointI*>(&r);
-    if(!p)
+    const auto* p = dynamic_cast<const IPEndpointI*>(&r);
+    if (!p)
     {
-        const EndpointI* e = dynamic_cast<const EndpointI*>(&r);
-        if(!e)
+        const auto* e = dynamic_cast<const EndpointI*>(&r);
+        if (!e)
         {
             return false;
         }
         return type() < e->type();
     }
 
-    if(this == p)
+    if (this == p)
     {
         return false;
     }
 
-    if(type() < p->type())
+    if (type() < p->type())
     {
         return true;
     }
-    else if(p->type() < type())
+    else if (p->type() < type())
     {
         return false;
     }
 
-    if(_host < p->_host)
+    if (_host < p->_host)
     {
         return true;
     }
-    else if(p->_host < _host)
+    else if (p->_host < _host)
     {
         return false;
     }
 
-    if(_port < p->_port)
+    if (_port < p->_port)
     {
         return true;
     }
-    else if(p->_port < _port)
+    else if (p->_port < _port)
     {
         return false;
     }
 
-    if(_connectionId < p->_connectionId)
+    if (_connectionId < p->_connectionId)
     {
         return true;
     }
-    else if(p->_connectionId < _connectionId)
+    else if (p->_connectionId < _connectionId)
     {
         return false;
     }
 
     int rc = compareAddress(_sourceAddr, p->_sourceAddr);
-    if(rc < 0)
+    if (rc < 0)
     {
         return true;
     }
-    else if(rc > 0)
+    else if (rc > 0)
     {
         return false;
     }
@@ -388,65 +283,48 @@ vector<ConnectorPtr>
 IceInternal::IPEndpointI::connectors(const vector<Address>& addresses, const NetworkProxyPtr& proxy) const
 {
     vector<ConnectorPtr> connectors;
-    for(unsigned int i = 0; i < addresses.size(); ++i)
+    connectors.reserve(addresses.size());
+    for (const auto& address : addresses)
     {
-        connectors.push_back(createConnector(addresses[i], proxy));
+        connectors.push_back(createConnector(address, proxy));
     }
     return connectors;
 }
 
-void
-IceInternal::IPEndpointI::hashInit(Ice::Int& h) const
-{
-    hashAdd(h, _host);
-    hashAdd(h, _port);
-    hashAdd(h, _connectionId);
-    if(isAddressValid(_sourceAddr))
-    {
-        hashAdd(h, inetAddrToString(_sourceAddr));
-    }
-}
-
-void
-IceInternal::IPEndpointI::fillEndpointInfo(Ice::IPEndpointInfo* info) const
-{
-    info->host = _host;
-    info->port = _port;
-    info->sourceAddress = inetAddrToString(_sourceAddr);
-}
-
 void
 IceInternal::IPEndpointI::initWithOptions(vector<string>& args, bool oaEndpoint)
 {
     EndpointI::initWithOptions(args);
 
-    if(_host.empty())
+    if (_host.empty())
     {
         const_cast<string&>(_host) = _instance->defaultHost();
+        const_cast<string&>(_normalizedHost) = normalizeIPv6Address(_host);
     }
-    else if(_host == "*")
+    else if (_host == "*")
     {
-        if(oaEndpoint)
+        if (oaEndpoint)
         {
-            const_cast<string&>(_host) = string();
+            const_cast<string&>(_host) = string{};
+            const_cast<string&>(_normalizedHost) = string{};
         }
         else
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "`-h *' not valid for proxy endpoint `" + toString() +
-                                              "'");
+            throw Ice::ParseException(__FILE__, __LINE__, "'-h *' not valid for proxy endpoint '" + toString() + "'");
         }
     }
 
-    if(isAddressValid(_sourceAddr))
+    if (isAddressValid(_sourceAddr))
     {
-        if(oaEndpoint)
+        if (oaEndpoint)
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__,
-                                              "`--sourceAddress' not valid for object adapter endpoint `" + toString() +
-                                              "'");
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "'--sourceAddress' not valid for object adapter endpoint '" + toString() + "'");
         }
     }
-    else if(!oaEndpoint)
+    else if (!oaEndpoint)
     {
         const_cast<Address&>(_sourceAddr) = _instance->defaultSourceAddress();
     }
@@ -455,48 +333,59 @@ IceInternal::IPEndpointI::initWithOptions(vector<string>& args, bool oaEndpoint)
 bool
 IceInternal::IPEndpointI::checkOption(const string& option, const string& argument, const string& endpoint)
 {
-    if(option == "-h")
+    if (option == "-h")
     {
-        if(argument.empty())
+        if (argument.empty())
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "no argument provided for -h option in endpoint " +
-                                              endpoint);
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "no argument provided for -h option in endpoint '" + endpoint + "'");
         }
         const_cast<string&>(_host) = argument;
+        const_cast<string&>(_normalizedHost) = normalizeIPv6Address(_host);
     }
-    else if(option == "-p")
+    else if (option == "-p")
     {
-        if(argument.empty())
+        if (argument.empty())
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "no argument provided for -p option in endpoint " +
-                                              endpoint);
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "no argument provided for -p option in endpoint '" + endpoint + "'");
         }
         istringstream p(argument);
-        if(!(p >> const_cast<Ice::Int&>(_port)) || !p.eof())
+        if (!(p >> const_cast<int32_t&>(_port)) || !p.eof())
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "invalid port value `" + argument + "' in endpoint " +
-                                              endpoint);
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "invalid port value '" + argument + "' in endpoint '" + endpoint + "'");
         }
-        else if(_port < 0 || _port > 65535)
+        else if (_port < 0 || _port > 65535)
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__, "port value `" + argument +
-                                              "' out of range in endpoint " + endpoint);
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "port value '" + argument + "' out of range in endpoint '" + endpoint + "'");
         }
     }
-    else if(option == "--sourceAddress")
+    else if (option == "--sourceAddress")
     {
-        if(argument.empty())
+        if (argument.empty())
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__,
-                                              "no argument provided for --sourceAddress option in endpoint " +
-                                              endpoint);
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "no argument provided for --sourceAddress option in endpoint '" + endpoint + "'");
         }
         const_cast<Address&>(_sourceAddr) = getNumericAddress(argument);
-        if(!isAddressValid(_sourceAddr))
+        if (!isAddressValid(_sourceAddr))
         {
-            throw Ice::EndpointParseException(__FILE__, __LINE__,
-                                              "invalid IP address provided for --sourceAddress option in endpoint " +
-                                              endpoint);
+            throw Ice::ParseException(
+                __FILE__,
+                __LINE__,
+                "invalid IP address provided for --sourceAddress option in endpoint '" + endpoint + "'");
         }
     }
     else
@@ -506,118 +395,116 @@ IceInternal::IPEndpointI::checkOption(const string& option, const string& argume
     return true;
 }
 
-IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance, const string& host, int port,
-                                      const Address& sourceAddr, const string& connectionId) :
-    _instance(instance),
-    _host(host),
-    _port(port),
-    _sourceAddr(sourceAddr),
-    _connectionId(connectionId),
-    _hashInitialized(false)
+IceInternal::IPEndpointI::IPEndpointI(
+    ProtocolInstancePtr instance,
+    string host,
+    int port,
+    const Address& sourceAddr,
+    string connectionId)
+    : _instance(std::move(instance)),
+      _host(std::move(host)),
+      _normalizedHost(normalizeIPv6Address(_host)),
+      _port(port),
+      _sourceAddr(sourceAddr),
+      _connectionId(std::move(connectionId))
 {
 }
 
-IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance) :
-    _instance(instance),
-    _port(0),
-    _hashInitialized(false)
-{
-}
+IceInternal::IPEndpointI::IPEndpointI(ProtocolInstancePtr instance) : _instance(std::move(instance)), _port(0) {}
 
-IceInternal::IPEndpointI::IPEndpointI(const ProtocolInstancePtr& instance, InputStream* s) :
-    _instance(instance),
-    _port(0),
-    _hashInitialized(false)
+IceInternal::IPEndpointI::IPEndpointI(ProtocolInstancePtr instance, InputStream* s)
+    : _instance(std::move(instance)),
+      _port(0)
 {
     s->read(const_cast<string&>(_host), false);
-    s->read(const_cast<Ice::Int&>(_port));
+    const_cast<string&>(_normalizedHost) = normalizeIPv6Address(_host);
+    s->read(const_cast<int32_t&>(_port));
 }
 
-IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& instance) :
-    IceUtil::Thread("Ice.HostResolver"),
-    _instance(instance),
-    _protocol(instance->protocolSupport()),
-    _preferIPv6(instance->preferIPv6()),
-    _destroyed(false)
+IceInternal::EndpointHostResolver::EndpointHostResolver(const InstancePtr& instance)
+    : _instance(instance),
+      _protocol(instance->protocolSupport()),
+      _preferIPv6(instance->preferIPv6())
 {
     updateObserver();
 }
 
 void
-IceInternal::EndpointHostResolver::resolve(const string& host, int port, Ice::EndpointSelectionType selType,
-                                           const IPEndpointIPtr& endpoint, const EndpointI_connectorsPtr& callback)
+IceInternal::EndpointHostResolver::resolve(
+    const string& host,
+    int port,
+    const IPEndpointIPtr& endpoint,
+    function<void(vector<ConnectorPtr>)> response,
+    function<void(exception_ptr)> exception)
 {
     //
     // Try to get the addresses without DNS lookup. If this doesn't work, we queue a resolve
     // entry and the thread will take care of getting the endpoint addresses.
     //
     NetworkProxyPtr networkProxy = _instance->networkProxy();
-    if(!networkProxy)
+    if (!networkProxy)
     {
         try
         {
-            vector<Address> addrs = getAddresses(host, port, _protocol, selType, _preferIPv6, false);
-            if(!addrs.empty())
+            vector<Address> addrs = getAddresses(host, port, _protocol, _preferIPv6, false);
+            if (!addrs.empty())
             {
-                callback->connectors(endpoint->connectors(addrs, 0));
+                response(endpoint->connectors(addrs, nullptr));
                 return;
             }
         }
-        catch(const Ice::LocalException& ex)
+        catch (const Ice::LocalException&)
         {
-            callback->exception(ex);
+            exception(current_exception());
             return;
         }
     }
 
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     assert(!_destroyed);
 
     ResolveEntry entry;
     entry.host = host;
     entry.port = port;
-    entry.selType = selType;
     entry.endpoint = endpoint;
-    entry.callback = callback;
+    entry.response = std::move(response);
+    entry.exception = std::move(exception);
 
-    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
-    if(obsv)
+    const CommunicatorObserverPtr& observer = _instance->initializationData().observer;
+    if (observer)
     {
-        entry.observer = obsv->getEndpointLookupObserver(endpoint);
-        if(entry.observer)
+        entry.observer = observer->getEndpointLookupObserver(endpoint);
+        if (entry.observer)
         {
             entry.observer->attach();
         }
     }
 
     _queue.push_back(entry);
-    notify();
+    _conditionVariable.notify_one();
 }
 
 void
 IceInternal::EndpointHostResolver::destroy()
 {
-    Lock sync(*this);
+    lock_guard lock(_mutex);
     assert(!_destroyed);
     _destroyed = true;
-    notify();
+    _conditionVariable.notify_one();
 }
 
 void
 IceInternal::EndpointHostResolver::run()
 {
-    while(true)
+    while (true)
     {
         ResolveEntry r;
         ThreadObserverPtr threadObserver;
         {
-            Lock sync(*this);
-            while(!_destroyed && _queue.empty())
-            {
-                wait();
-            }
+            unique_lock lock(_mutex);
+            _conditionVariable.wait(lock, [this] { return _destroyed || !_queue.empty(); });
 
-            if(_destroyed)
+            if (_destroyed)
             {
                 break;
             }
@@ -627,69 +514,66 @@ IceInternal::EndpointHostResolver::run()
             threadObserver = _observer.get();
         }
 
-        if(threadObserver)
+        if (threadObserver)
         {
-            threadObserver->stateChanged(ICE_ENUM(ThreadState, ThreadStateIdle), ICE_ENUM(ThreadState, ThreadStateInUseForOther));
+            threadObserver->stateChanged(ThreadState::ThreadStateIdle, ThreadState::ThreadStateInUseForOther);
         }
 
         try
         {
             NetworkProxyPtr networkProxy = _instance->networkProxy();
             ProtocolSupport protocol = _protocol;
-            if(networkProxy)
+            if (networkProxy)
             {
                 networkProxy = networkProxy->resolveHost(_protocol);
-                if(networkProxy)
+                if (networkProxy)
                 {
                     protocol = networkProxy->getProtocolSupport();
                 }
             }
 
-            vector<Address> addresses = getAddresses(r.host, r.port, protocol, r.selType, _preferIPv6, true);
-            if(r.observer)
+            vector<Address> addresses = getAddresses(r.host, r.port, protocol, _preferIPv6, true);
+            if (r.observer)
             {
                 r.observer->detach();
-                r.observer = 0;
+                r.observer = nullptr;
             }
 
-            r.callback->connectors(r.endpoint->connectors(addresses, networkProxy));
+            r.response(r.endpoint->connectors(addresses, networkProxy));
 
-            if(threadObserver)
+            if (threadObserver)
             {
-                threadObserver->stateChanged(ICE_ENUM(ThreadState, ThreadStateInUseForOther),
-                                             ICE_ENUM(ThreadState, ThreadStateIdle));
+                threadObserver->stateChanged(ThreadState::ThreadStateInUseForOther, ThreadState::ThreadStateIdle);
             }
-
         }
-        catch(const Ice::LocalException& ex)
+        catch (const Ice::LocalException& ex)
         {
-            if(threadObserver)
+            if (threadObserver)
             {
-                threadObserver->stateChanged(ICE_ENUM(ThreadState, ThreadStateInUseForOther),
-                                             ICE_ENUM(ThreadState, ThreadStateIdle));
+                threadObserver->stateChanged(ThreadState::ThreadStateInUseForOther, ThreadState::ThreadStateIdle);
             }
-            if(r.observer)
+            if (r.observer)
             {
                 r.observer->failed(ex.ice_id());
                 r.observer->detach();
             }
-            r.callback->exception(ex);
+            r.exception(current_exception());
         }
     }
 
-    for(deque<ResolveEntry>::const_iterator p = _queue.begin(); p != _queue.end(); ++p)
+    for (const auto& p : _queue)
     {
         Ice::CommunicatorDestroyedException ex(__FILE__, __LINE__);
-        if(p->observer)
+        if (p.observer)
         {
-            p->observer->failed(ex.ice_id());
-            p->observer->detach();
+            p.observer->failed(ex.ice_id());
+            p.observer->detach();
         }
-        p->callback->exception(ex);
+        p.exception(make_exception_ptr(ex));
     }
     _queue.clear();
 
-    if(_observer)
+    if (_observer)
     {
         _observer.detach();
     }
@@ -698,13 +582,12 @@ IceInternal::EndpointHostResolver::run()
 void
 IceInternal::EndpointHostResolver::updateObserver()
 {
-    Lock sync(*this);
-    const CommunicatorObserverPtr& obsv = _instance->initializationData().observer;
-    if(obsv)
-    {
-        _observer.attach(obsv->getThreadObserver("Communicator",
-                                                 name(),
-                                                 ICE_ENUM(ThreadState, ThreadStateIdle),
-                                                 _observer.get()));
+    lock_guard lock(_mutex);
+    const CommunicatorObserverPtr& observer = _instance->initializationData().observer;
+    if (observer)
+    {
+        _observer.attach(
+            observer
+                ->getThreadObserver("Communicator", "Ice.HostResolver", ThreadState::ThreadStateIdle, _observer.get()));
     }
 }